Skip to content

The first exam for code agents in the physical world: frozen robot tasks from many benchmark suites, each answered with a program and verified in a separate sandbox. Runs on Harbor.

HumanCLAW: current Time limit text and standard-files 0.4.1 (#529)

Kangrui Wangce9d0dd5918d
diff --git a/tasks/humanclaw/humanclaw-nav-chair-i125-privileged/DIGEST b/tasks/humanclaw/humanclaw-nav-chair-i125-privileged/DIGEST
index aa7f30a4e4..04d9fe1b5a 100644
--- a/tasks/humanclaw/humanclaw-nav-chair-i125-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-nav-chair-i125-privileged/DIGEST
@@ -1 +1 @@
-sha256:72d85b52ffac12f1535d7d513882880a1255200f9adb7b1bab77f1523e2e2f5c
+sha256:0b09f3a5be7616d09f616d2e59fcfc7c90950f1e2bd723bab27d353315b829e1
diff --git a/tasks/humanclaw/humanclaw-nav-chair-i125-privileged/instruction.md b/tasks/humanclaw/humanclaw-nav-chair-i125-privileged/instruction.md
index d79fa4d01d..363b00cff5 100644
--- a/tasks/humanclaw/humanclaw-nav-chair-i125-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-nav-chair-i125-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-nav-chair-i125-standard/DIGEST b/tasks/humanclaw/humanclaw-nav-chair-i125-standard/DIGEST
index 7a490006f1..652e6e3620 100644
--- a/tasks/humanclaw/humanclaw-nav-chair-i125-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-nav-chair-i125-standard/DIGEST
@@ -1 +1 @@
-sha256:33d8dba526c49acefea5cbeb7101be2e8c646eebeb245b6cf1d9477ddc30f3e8
+sha256:328334e27b498b9685bf72103404b0aa367fe1c0f62772a8fdd0284c460ebf2a
diff --git a/tasks/humanclaw/humanclaw-nav-chair-i125-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-nav-chair-i125-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-nav-chair-i125-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-chair-i125-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-nav-chair-i125-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-nav-chair-i125-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-nav-chair-i125-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-chair-i125-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-nav-chair-i125-standard/instruction.md b/tasks/humanclaw/humanclaw-nav-chair-i125-standard/instruction.md
index e19568da84..6d9e93c4b9 100644
--- a/tasks/humanclaw/humanclaw-nav-chair-i125-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-nav-chair-i125-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-nav-chair-i125-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-nav-chair-i125-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-nav-chair-i125-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-chair-i125-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i110-privileged/DIGEST b/tasks/humanclaw/humanclaw-nav-tv-i110-privileged/DIGEST
index 4e092c9e9f..08902fa1a6 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i110-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-nav-tv-i110-privileged/DIGEST
@@ -1 +1 @@
-sha256:38ea78c4ca04a6a5fd914f8bd4b18eb5eb6428bf68b8dc947faae2520f1306d4
+sha256:42864a0581c398cea9e6a01114931965d3aa9794dea8ee62f450860adb08fac7
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i110-privileged/instruction.md b/tasks/humanclaw/humanclaw-nav-tv-i110-privileged/instruction.md
index 21b68ae415..996e365090 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i110-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-nav-tv-i110-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i110-standard/DIGEST b/tasks/humanclaw/humanclaw-nav-tv-i110-standard/DIGEST
index 247c90f486..50ad08c987 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i110-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-nav-tv-i110-standard/DIGEST
@@ -1 +1 @@
-sha256:681e853826ba814f9ccf19f6b2ffa5159be822427415d39ce0447c2d4c0c2931
+sha256:bf1a32646ce9b3ca48ef58d97291cb6e5ee9ac04c9c4d70985544aa035155478
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i110-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i110-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i110-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i110-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i110-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i110-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i110-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i110-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i110-standard/instruction.md b/tasks/humanclaw/humanclaw-nav-tv-i110-standard/instruction.md
index 4b40ca85f1..9075cc8922 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i110-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-nav-tv-i110-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i110-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i110-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i110-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i110-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i111-privileged/DIGEST b/tasks/humanclaw/humanclaw-nav-tv-i111-privileged/DIGEST
index ce007edfee..83b8746b68 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i111-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-nav-tv-i111-privileged/DIGEST
@@ -1 +1 @@
-sha256:0a15c8a0463c877e096fd1e51aae73cd46172188a1954235a8049554feccedfb
+sha256:d0f73cdbac1a57cf0a62e410fa5b26388d469d0201a19ae159ceef36daf96ff9
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i111-privileged/instruction.md b/tasks/humanclaw/humanclaw-nav-tv-i111-privileged/instruction.md
index 14889caba9..3a35bfb696 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i111-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-nav-tv-i111-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i111-standard/DIGEST b/tasks/humanclaw/humanclaw-nav-tv-i111-standard/DIGEST
index ad4e4349aa..87b7617214 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i111-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-nav-tv-i111-standard/DIGEST
@@ -1 +1 @@
-sha256:2be2d5f7221645948527b3348ff486406592245959fe9cd18f8511f699619bff
+sha256:ff10bb892f1b71a6f5dc35f2647c3496eb61cf41aaf9cb4f80136941c76ca6da
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i111-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i111-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i111-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i111-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i111-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i111-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i111-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i111-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i111-standard/instruction.md b/tasks/humanclaw/humanclaw-nav-tv-i111-standard/instruction.md
index bfa6a29a86..644a4970dc 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i111-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-nav-tv-i111-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i111-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i111-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i111-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i111-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i112-privileged/DIGEST b/tasks/humanclaw/humanclaw-nav-tv-i112-privileged/DIGEST
index cdeafec78b..237815e42b 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i112-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-nav-tv-i112-privileged/DIGEST
@@ -1 +1 @@
-sha256:15cc00ab8c423cefcb7c4667e0f131a11be2a9399ade188c591485c55a773c43
+sha256:e0958b73d6dc9ad7b80946d52136fff07fd24edb1ceb3ce2fbd6204126bfae90
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i112-privileged/instruction.md b/tasks/humanclaw/humanclaw-nav-tv-i112-privileged/instruction.md
index 9268380b81..8e26ccaca9 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i112-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-nav-tv-i112-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i112-standard/DIGEST b/tasks/humanclaw/humanclaw-nav-tv-i112-standard/DIGEST
index a7c5b2f69b..125be7917f 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i112-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-nav-tv-i112-standard/DIGEST
@@ -1 +1 @@
-sha256:9cdb89e313bd84b82f463efd1d8cd05d9521a366d92d11082bbbd3625209df1e
+sha256:8c3e0effdfdaa7769f906b6feaedcc819d64212ae3ddddaf904251b36ee718f1
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i112-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i112-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i112-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i112-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i112-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i112-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i112-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i112-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i112-standard/instruction.md b/tasks/humanclaw/humanclaw-nav-tv-i112-standard/instruction.md
index 991772bd97..42ba5d0323 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i112-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-nav-tv-i112-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i112-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i112-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i112-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i112-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i113-privileged/DIGEST b/tasks/humanclaw/humanclaw-nav-tv-i113-privileged/DIGEST
index b06953cd97..7de9e86f39 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i113-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-nav-tv-i113-privileged/DIGEST
@@ -1 +1 @@
-sha256:6e3c0bfba5d0a45ccb0c50e593da7576b1ef463a4640df1d4b316904d4ad6959
+sha256:31ce2f0f02edfc9974ea0d75fb110b6bbed013616f1d3bc8fe845c418b01b1d3
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i113-privileged/instruction.md b/tasks/humanclaw/humanclaw-nav-tv-i113-privileged/instruction.md
index 27c9733216..e96d627619 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i113-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-nav-tv-i113-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i113-standard/DIGEST b/tasks/humanclaw/humanclaw-nav-tv-i113-standard/DIGEST
index fbe4a0f5cb..a1a2e680aa 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i113-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-nav-tv-i113-standard/DIGEST
@@ -1 +1 @@
-sha256:b2fa29173e220887a9740446591453668097c4df362d9df9aa60f0de4246d18c
+sha256:cfd2506f65a604cf2310e556a7a4b16e48a60582b71fe7636adc90ae15e1d232
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i113-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i113-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i113-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i113-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i113-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i113-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i113-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i113-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i113-standard/instruction.md b/tasks/humanclaw/humanclaw-nav-tv-i113-standard/instruction.md
index 94ea9fa7ab..d8695a56f2 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i113-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-nav-tv-i113-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i113-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i113-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i113-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i113-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i114-privileged/DIGEST b/tasks/humanclaw/humanclaw-nav-tv-i114-privileged/DIGEST
index 14cc2190fa..be969f9cea 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i114-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-nav-tv-i114-privileged/DIGEST
@@ -1 +1 @@
-sha256:d423b15074b04d7375dd61274e6a6750ae03a66d15a5c49097df0eb056ed47e0
+sha256:946003f8644799c8f3d65d3570944e9e4c8fac547d2c0bde9b710663b51fdf60
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i114-privileged/instruction.md b/tasks/humanclaw/humanclaw-nav-tv-i114-privileged/instruction.md
index d4e4fec0e6..bdf9ddb303 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i114-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-nav-tv-i114-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i114-standard/DIGEST b/tasks/humanclaw/humanclaw-nav-tv-i114-standard/DIGEST
index ea1e09f5a9..c31333a035 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i114-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-nav-tv-i114-standard/DIGEST
@@ -1 +1 @@
-sha256:02fe0e82349a50c9a6f72fa259110d05aa4230b79e859117abeefb52087895d8
+sha256:ae7a6acd9b79e741c1ed5f796272fab0861fad4251977b2b7cdfbe80ee8d4be2
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i114-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i114-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i114-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i114-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i114-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i114-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i114-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i114-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i114-standard/instruction.md b/tasks/humanclaw/humanclaw-nav-tv-i114-standard/instruction.md
index 1154fea164..5909061e63 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i114-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-nav-tv-i114-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i114-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i114-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i114-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i114-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i115-privileged/DIGEST b/tasks/humanclaw/humanclaw-nav-tv-i115-privileged/DIGEST
index 12473bffcc..a3c58745d9 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i115-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-nav-tv-i115-privileged/DIGEST
@@ -1 +1 @@
-sha256:3a1a2199565755029b5d011d8056f58998094982c65e6b3105792c8a9656b175
+sha256:fb25b925fc37a0338dcf1631a2d98accd44c549eda824dd390e304cd6e5c2c51
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i115-privileged/instruction.md b/tasks/humanclaw/humanclaw-nav-tv-i115-privileged/instruction.md
index d6f6d555c4..2fc98905cc 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i115-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-nav-tv-i115-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i115-standard/DIGEST b/tasks/humanclaw/humanclaw-nav-tv-i115-standard/DIGEST
index 491a83be6f..6e7dd5a5e4 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i115-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-nav-tv-i115-standard/DIGEST
@@ -1 +1 @@
-sha256:00bda5361afb189582dc49a30fc837a7bdc09bba4494092b829ef1fe24d4ba19
+sha256:79eae7cc7a427f15016515130e457d18e1b311940070266dfc13adaaaa620003
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i115-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i115-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i115-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i115-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i115-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i115-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i115-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i115-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i115-standard/instruction.md b/tasks/humanclaw/humanclaw-nav-tv-i115-standard/instruction.md
index 3143e68472..4a3f226b16 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i115-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-nav-tv-i115-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i115-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i115-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i115-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i115-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i136-privileged/DIGEST b/tasks/humanclaw/humanclaw-nav-tv-i136-privileged/DIGEST
index 352eee2d22..63caa49f7f 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i136-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-nav-tv-i136-privileged/DIGEST
@@ -1 +1 @@
-sha256:fc3df4018ef1604dd5a6c10968f20347a06f1dd1a6b1391f49530e58b3da6c66
+sha256:d2d715e503e680c741059bf2bef1438d623dc67e7c1dfaf89ac3f65ce7699325
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i136-privileged/instruction.md b/tasks/humanclaw/humanclaw-nav-tv-i136-privileged/instruction.md
index 14c0e480b8..032c20d1fe 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i136-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-nav-tv-i136-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i136-standard/DIGEST b/tasks/humanclaw/humanclaw-nav-tv-i136-standard/DIGEST
index d2ecd878f2..9efac50c5f 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i136-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-nav-tv-i136-standard/DIGEST
@@ -1 +1 @@
-sha256:395982c356ee5832cd0d4eb5246e8a0f1a095f47106ddcf2bec01e8ec65c2294
+sha256:1ab5b497033381b7c8f9f1b46479e20b9c100943cb6e2f1e4775acb80394e3b5
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i136-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i136-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i136-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i136-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i136-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i136-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i136-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i136-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i136-standard/instruction.md b/tasks/humanclaw/humanclaw-nav-tv-i136-standard/instruction.md
index b2a3e4ec80..81afd37a57 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i136-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-nav-tv-i136-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i136-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i136-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i136-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i136-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i139-privileged/DIGEST b/tasks/humanclaw/humanclaw-nav-tv-i139-privileged/DIGEST
index 205add1c8d..03e6b6f704 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i139-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-nav-tv-i139-privileged/DIGEST
@@ -1 +1 @@
-sha256:1ea40048edd156a0313c4709f19e62fdae48907488c1f4747ec76fc83965fbb3
+sha256:0ae7595626e17b2420a4f659a7f87aecef6afce26fee10b18f47df3cffadc39f
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i139-privileged/instruction.md b/tasks/humanclaw/humanclaw-nav-tv-i139-privileged/instruction.md
index 6924aa5e25..fc2df135f2 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i139-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-nav-tv-i139-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i139-standard/DIGEST b/tasks/humanclaw/humanclaw-nav-tv-i139-standard/DIGEST
index 36cbacb879..de9c7a1b80 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i139-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-nav-tv-i139-standard/DIGEST
@@ -1 +1 @@
-sha256:81341f57c70005a375929e4b8118c4ee2f1a8bf8f535175dbfa67075afcfb13b
+sha256:461fcc44139db7a3b53ad5733afc27b6e64b3fefdec5c4d676f140ff6e16a277
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i139-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i139-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i139-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i139-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i139-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i139-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i139-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i139-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i139-standard/instruction.md b/tasks/humanclaw/humanclaw-nav-tv-i139-standard/instruction.md
index a598f1e9bf..9df938a91a 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i139-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-nav-tv-i139-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i139-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i139-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i139-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i139-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i16-privileged/DIGEST b/tasks/humanclaw/humanclaw-nav-tv-i16-privileged/DIGEST
index 2b94d5cd9f..b92bf8ceb9 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i16-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-nav-tv-i16-privileged/DIGEST
@@ -1 +1 @@
-sha256:5276aedf3af45a85e1782808197782976468c1a8e1f7dc5ff979a9e5ff56a4ef
+sha256:44ac891e649af5d8766e284bee77b8c5e3a46540baa5581a1bc728287ac671b9
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i16-privileged/instruction.md b/tasks/humanclaw/humanclaw-nav-tv-i16-privileged/instruction.md
index 127e5c5aba..c12751f183 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i16-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-nav-tv-i16-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i16-standard/DIGEST b/tasks/humanclaw/humanclaw-nav-tv-i16-standard/DIGEST
index 8450d0d0da..80e8f79dc8 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i16-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-nav-tv-i16-standard/DIGEST
@@ -1 +1 @@
-sha256:98a0a580f622039de941b9fed9f09fe067636975de7dc9c22fbfb181c92b6cd8
+sha256:d3b04ef7163266ed8998ad34d19fa69df33c2b82448e36f6956493f82d3d75fa
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i16-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i16-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i16-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i16-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i16-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i16-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i16-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i16-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i16-standard/instruction.md b/tasks/humanclaw/humanclaw-nav-tv-i16-standard/instruction.md
index 5d91f91d6b..91204b7a38 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i16-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-nav-tv-i16-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i16-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i16-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i16-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i16-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i166-privileged/DIGEST b/tasks/humanclaw/humanclaw-nav-tv-i166-privileged/DIGEST
index 00bb93d152..50fbecba02 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i166-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-nav-tv-i166-privileged/DIGEST
@@ -1 +1 @@
-sha256:8e7e9dcf48656a66d6218f207cd9ea1fd6ba0990701a9a08ccd3d87708e2d6be
+sha256:7dd2afe1d22f9a54bb5c4b32c8dbb2cb109f164634c4cd360974a736458d3edb
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i166-privileged/instruction.md b/tasks/humanclaw/humanclaw-nav-tv-i166-privileged/instruction.md
index 7af7eca606..ce893db661 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i166-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-nav-tv-i166-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i166-standard/DIGEST b/tasks/humanclaw/humanclaw-nav-tv-i166-standard/DIGEST
index d9dbedec5a..67089edb4c 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i166-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-nav-tv-i166-standard/DIGEST
@@ -1 +1 @@
-sha256:23ca2bcf42dcfe3c928a15bf0e885bb7dddaa176559321f924d0455913c137f3
+sha256:6beda1a4ffdf87057cc2b4862e2d5c011d14fab1cfb244d7e25a6f3866c8bf9e
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i166-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i166-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i166-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i166-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i166-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i166-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i166-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i166-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i166-standard/instruction.md b/tasks/humanclaw/humanclaw-nav-tv-i166-standard/instruction.md
index 0f5306b57e..e906c38dc2 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i166-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-nav-tv-i166-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i166-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i166-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i166-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i166-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i17-privileged/DIGEST b/tasks/humanclaw/humanclaw-nav-tv-i17-privileged/DIGEST
index fb5343589f..f769c18d88 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i17-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-nav-tv-i17-privileged/DIGEST
@@ -1 +1 @@
-sha256:75fc140c738518b1c02367ede3ed91ad3cf8b81232037c6088c060fc274eed26
+sha256:4b2b4c79cf90fcd8fd577a403e158fe49c396db4de4da62d6270bbd370c4f53c
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i17-privileged/instruction.md b/tasks/humanclaw/humanclaw-nav-tv-i17-privileged/instruction.md
index 82907317f5..9ab7b741f2 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i17-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-nav-tv-i17-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i17-standard/DIGEST b/tasks/humanclaw/humanclaw-nav-tv-i17-standard/DIGEST
index cd498100c3..7881ad78b3 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i17-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-nav-tv-i17-standard/DIGEST
@@ -1 +1 @@
-sha256:4aa5c54019bc05874d2361be129a8ce3446e5688c961336bb1bd1b83ad217603
+sha256:95745809f9fb0e3f550ec69ad9537b45803c966de0e48a09500060798bea7ccf
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i17-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i17-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i17-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i17-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i17-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i17-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i17-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i17-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i17-standard/instruction.md b/tasks/humanclaw/humanclaw-nav-tv-i17-standard/instruction.md
index 72bd64584f..712f59c09f 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i17-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-nav-tv-i17-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-nav-tv-i17-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-nav-tv-i17-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-nav-tv-i17-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-nav-tv-i17-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i04-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i04-privileged/DIGEST
index 4d94b1a8d6..10290b7a93 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i04-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i04-privileged/DIGEST
@@ -1 +1 @@
-sha256:fc21567eb0ec21b214e10dac1d027dd5f1afedebaaee2ccbfbebacc6166fabea
+sha256:94b40960a2fdf98afe837a647dd8b850f28169528aa543317a1abf6a79be0148
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i04-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i04-privileged/instruction.md
index e1da41a814..d8ce5dc40f 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i04-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i04-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i04-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i04-standard/DIGEST
index 4dbac60540..3667501257 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i04-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i04-standard/DIGEST
@@ -1 +1 @@
-sha256:8bb759fb942ab7ca4cd3cd71cfd1e115a3c9985280ffdc41b922e04c8e98de74
+sha256:5bae5de75d143f5712522a363303614f62e56769264186e50681021613bc104d
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i04-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i04-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i04-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i04-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i04-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i04-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i04-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i04-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i04-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i04-standard/instruction.md
index 2298733784..db9ff2f3be 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i04-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i04-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i04-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i04-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i04-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i04-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i06-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i06-privileged/DIGEST
index 766a5f8409..4212b52828 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i06-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i06-privileged/DIGEST
@@ -1 +1 @@
-sha256:0a1cfc87d800b580aa0f5135731fd6ea9fcf7c2c6f065dcb9222e01d3940d18f
+sha256:06a96b1ce531148c41840ef408060e873b1d997aa24747f3da855ee2eaa60e8b
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i06-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i06-privileged/instruction.md
index cd88cfa2c1..3d7ec877aa 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i06-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i06-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i06-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i06-standard/DIGEST
index 9ca38b5483..9159ad2545 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i06-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i06-standard/DIGEST
@@ -1 +1 @@
-sha256:612f40704fd419f49e59552a792f7579340839a2f21fe009b96e98802fdf875b
+sha256:a2dab80d9b29a550ece8c327fd861339337a315d8c950d5e042393655e10f3b1
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i06-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i06-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i06-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i06-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i06-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i06-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i06-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i06-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i06-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i06-standard/instruction.md
index cf012c7754..83ea1a09d2 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i06-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i06-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i06-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i06-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i06-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i06-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i08-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i08-privileged/DIGEST
index 06b4a02580..4837d5f8e3 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i08-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i08-privileged/DIGEST
@@ -1 +1 @@
-sha256:633df8e6c373240d712b6f8d4898a8552928848f95e925d35f03c79c21ccc8da
+sha256:6cba095ec86298ea06c78648eec4e75b2f30c3dfb7f9a07ba25021a53073a5c4
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i08-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i08-privileged/instruction.md
index 2c442ace18..09a38c63b9 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i08-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i08-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i08-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i08-standard/DIGEST
index 8bdafc9a10..e5ff55ff2b 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i08-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i08-standard/DIGEST
@@ -1 +1 @@
-sha256:4164e486ec4258887bd0712fb73c0c6a511bfad3628f7d2936d0c9e1525efa47
+sha256:27e5bf55585571dc08e13da2ac3adde68513b3ee5a178f67ded06555e8f93a3d
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i08-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i08-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i08-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i08-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i08-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i08-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i08-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i08-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i08-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i08-standard/instruction.md
index 75259b77fc..682cc3ed29 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i08-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i08-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i08-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i08-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i08-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i08-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i112-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i112-privileged/DIGEST
index a4453b8513..bf68c7c146 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i112-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i112-privileged/DIGEST
@@ -1 +1 @@
-sha256:63fc161d7cae6cc972a13c93b2a45b3d879411ec935e0001de4c194e4c2d7609
+sha256:4339fa69654aefb0f333aee3db23e0db3526ddadfb9928ca79b0721428eab38e
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i112-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i112-privileged/instruction.md
index cbe1cc19b2..3a240c0843 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i112-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i112-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i112-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i112-standard/DIGEST
index f7f96b6166..a85d9e4e59 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i112-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i112-standard/DIGEST
@@ -1 +1 @@
-sha256:54a0277a8db8cebe432c3918c39e8f19a0516efe34cfe8b2105357967a041ab3
+sha256:b31e4b835bc8d312dd7508c0b670dfbe9bf8d29bc86bb79c1406ac110710a415
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i112-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i112-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i112-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i112-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i112-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i112-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i112-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i112-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i112-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i112-standard/instruction.md
index 2c6fd2f5f5..d03274a1bc 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i112-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i112-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i112-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i112-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i112-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i112-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i113-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i113-privileged/DIGEST
index 52bdceaf0f..578bace097 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i113-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i113-privileged/DIGEST
@@ -1 +1 @@
-sha256:47d9c479f3a0fff6cc605a0e3a36e2bffb4006975ac59a7a5ca11633591aa971
+sha256:56054a41a29b9639bfe54784fcd225d41476de58fbbfbbe70191cd59deb54cb4
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i113-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i113-privileged/instruction.md
index ede52d5644..bce5d2137b 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i113-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i113-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i113-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i113-standard/DIGEST
index d9c200e5a0..abf63bcba1 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i113-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i113-standard/DIGEST
@@ -1 +1 @@
-sha256:a3f4cbdab41695192d4dc19d3e0d0f7c325a47c856d04677b5b7fba0b3707050
+sha256:1cb637b5b0985ed5e19e536df1d5ecbd80d95b267d220284162bcac0fe85d402
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i113-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i113-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i113-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i113-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i113-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i113-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i113-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i113-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i113-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i113-standard/instruction.md
index dbc31cfe9a..34c8b5f75f 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i113-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i113-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i113-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i113-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i113-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i113-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i114-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i114-privileged/DIGEST
index 07bb3906be..2d6141968d 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i114-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i114-privileged/DIGEST
@@ -1 +1 @@
-sha256:1bfbf5e2e79fe00948a3fd2c3112f783ba24a0d4ce5cee2f64536d60ffd61bea
+sha256:19f71ba2b8184fd025e104bbf5d001627aa8493a92a05d9b90de5545eea13d7f
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i114-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i114-privileged/instruction.md
index c095b8e46e..bb05b87d6d 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i114-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i114-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i114-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i114-standard/DIGEST
index 5049577d66..9f8eabd097 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i114-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i114-standard/DIGEST
@@ -1 +1 @@
-sha256:dbb9532d84944432f96971fae223982ef53c2253885ef90eebf521ff27dcd839
+sha256:11f35d2e5ab15d4f81c0f181c9af56691b50fff43c0f105918aed7144756d6ba
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i114-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i114-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i114-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i114-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i114-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i114-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i114-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i114-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i114-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i114-standard/instruction.md
index b5f03d73b4..0e368a42e5 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i114-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i114-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i114-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i114-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i114-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i114-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i115-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i115-privileged/DIGEST
index ae6223b0d3..a9e4aced3a 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i115-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i115-privileged/DIGEST
@@ -1 +1 @@
-sha256:9da654735e4f27aec25d96097abc1f133339e193fe16ad22974af38591651c92
+sha256:9f1ca01108871fb5c278410f1592a8c2f50bc5789ccda4b1054825f2cceb0ab3
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i115-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i115-privileged/instruction.md
index 9a68d11bb6..6d8cd1c99d 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i115-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i115-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i115-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i115-standard/DIGEST
index a6f8e7e6e0..5dd9383e65 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i115-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i115-standard/DIGEST
@@ -1 +1 @@
-sha256:5d04f756871e6e527411c03244ec1341df147455a96e5e6265d5fbc6f7e7e5ab
+sha256:666238f921edc189f553ff7a18976e73411681c23a754d85552de7632d415a26
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i115-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i115-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i115-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i115-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i115-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i115-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i115-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i115-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i115-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i115-standard/instruction.md
index 9b7dcedbb8..1c44c9e02c 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i115-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i115-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i115-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i115-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i115-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i115-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i116-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i116-privileged/DIGEST
index 0aa6fcef9d..4d9758b998 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i116-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i116-privileged/DIGEST
@@ -1 +1 @@
-sha256:82d3593a1771641c31bfe4c3be367f69845caf44f6181be6619a7df8c7c27470
+sha256:03fe61658483d717496053ea7ac5403665ee10076f0c6ff99c72796e0d0433ae
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i116-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i116-privileged/instruction.md
index fb24741777..63baa937a6 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i116-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i116-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i116-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i116-standard/DIGEST
index ecefe005e9..dfae6251e9 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i116-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i116-standard/DIGEST
@@ -1 +1 @@
-sha256:8e8484aa9a11436c2feeaa888c3f792b7a122ae6568e6fbf4a2364ba7f5dfd0e
+sha256:a1901ae29f44adffda67672763040c934474de5835da2c367f2e7ccc7467e902
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i116-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i116-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i116-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i116-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i116-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i116-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i116-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i116-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i116-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i116-standard/instruction.md
index 8e1e83d192..c79d253651 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i116-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i116-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i116-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i116-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i116-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i116-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i16-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i16-privileged/DIGEST
index 6d7bcceef1..ac8cf5d4c5 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i16-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i16-privileged/DIGEST
@@ -1 +1 @@
-sha256:b92bf6d07205f0cfd2e8a6040c7908a7b2758c5d058c33c68b08ba0c38d3c611
+sha256:f859de0bbf40b4cbe8c5a29cabbf792ae3f7353df7ce0d5a0d5dcf4e07e10054
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i16-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i16-privileged/instruction.md
index 06ef83ac74..71365df7fc 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i16-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i16-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i16-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i16-standard/DIGEST
index 7f05e302e5..1bf835c1e2 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i16-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i16-standard/DIGEST
@@ -1 +1 @@
-sha256:3d3599926cf920f2c051cd63f6d0d50919f5d3c836aa952a86c449fe9f17e1e5
+sha256:6e6679a432369f8d22d4bdab6bb7a3a7cf7d13e0b97f9cd738ddb92c38bd72ba
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i16-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i16-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i16-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i16-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i16-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i16-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i16-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i16-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i16-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i16-standard/instruction.md
index 7a1ff8ded1..776183b714 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i16-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i16-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i16-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i16-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i16-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i16-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i161-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i161-privileged/DIGEST
index e2bf2e0422..0dc96e4d6b 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i161-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i161-privileged/DIGEST
@@ -1 +1 @@
-sha256:eaf99b5ad8e2953e338dad8a5041638168526b26394d207471a8c970664b34ac
+sha256:3db2431b6901d2aa76a9288e348096c7c3bc43fc959034be8675807de2c00f23
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i161-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i161-privileged/instruction.md
index 5b51ad4316..ffddd009e3 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i161-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i161-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i161-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i161-standard/DIGEST
index 59964621ac..9dbd6b7704 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i161-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i161-standard/DIGEST
@@ -1 +1 @@
-sha256:0039095d2b746813438de68aeb79e5eadf8338edd61b112a868848b4524f2a8c
+sha256:d1725e45028785b693494d75ab8c83923b9db15716e7115c00670e1533d535f8
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i161-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i161-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i161-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i161-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i161-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i161-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i161-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i161-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i161-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i161-standard/instruction.md
index 7668475b2b..566f13c68c 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i161-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i161-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i161-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i161-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i161-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i161-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i17-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i17-privileged/DIGEST
index 8baf3e6523..4fc2be8edd 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i17-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i17-privileged/DIGEST
@@ -1 +1 @@
-sha256:8027e44728c2328c184dfbe7e7fc2a377dce8cc1498d639ba081f3adacfd4a36
+sha256:77eaa06a84e63c814ed667ba752f7ad14c3641d1c6b7c5f35dc15ce4579f5152
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i17-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i17-privileged/instruction.md
index e26f2d8314..9adb3e870c 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i17-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i17-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i17-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i17-standard/DIGEST
index 663229480d..5c74ee12e4 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i17-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i17-standard/DIGEST
@@ -1 +1 @@
-sha256:ad92c089078760da13c8e08c072dde313bcc63fd88ca22a6e96b3522bf9d8c59
+sha256:32413df9914a8394bd8cb0148b008755f7776fde1c703b15549e5157c9e1b7fe
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i17-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i17-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i17-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i17-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i17-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i17-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i17-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i17-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i17-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i17-standard/instruction.md
index 0c72d20e4e..2c1001e3bc 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i17-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i17-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i17-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i17-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i17-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i17-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i204-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i204-privileged/DIGEST
index 7e6b78028a..db8edbef9e 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i204-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i204-privileged/DIGEST
@@ -1 +1 @@
-sha256:e38174f962c720e82a9b78ce084950d912abe0bef8b048a5cffe093f99601cb3
+sha256:36c0183f9ffee4c941ccce9af74d17a19debb277362e37249c56691dd26d5ab7
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i204-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i204-privileged/instruction.md
index 3a207fc62c..f39b5d3f73 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i204-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i204-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i204-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i204-standard/DIGEST
index 54cf8145bf..8e1c749d52 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i204-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i204-standard/DIGEST
@@ -1 +1 @@
-sha256:a27c7a71fd9422b62ccd7c910a49143b01ed2702a621ca3ee7f9fb0a978cbd10
+sha256:7bac111585d4120d829140429a4edeb52071d07cd07dd92f14c1b0fb6ff62a10
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i204-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i204-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i204-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i204-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i204-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i204-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i204-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i204-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i204-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i204-standard/instruction.md
index 8b0cf0e410..d0b6036430 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i204-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i204-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i204-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i204-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i204-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i204-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i24-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i24-privileged/DIGEST
index 6a8a5b85ac..c6f80a574a 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i24-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i24-privileged/DIGEST
@@ -1 +1 @@
-sha256:e0393eb080569fbeadd9aed34bcd088814f92e6e3c8f25561bdcaf6640dfc8c1
+sha256:6c8f85d3242366d89c1d0b90d3edd1251ae85875241d0f9e72b4e1da0d51ceb4
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i24-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i24-privileged/instruction.md
index c573036dd7..f35a44faec 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i24-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i24-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i24-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i24-standard/DIGEST
index 012f4858ab..4dadacde12 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i24-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i24-standard/DIGEST
@@ -1 +1 @@
-sha256:50451f31722d7ec4b8470e9d970405dd3506a8f33a5e3fc7c8a93b9f2849aa3b
+sha256:e2948c399f1de737eed112323bad8d4d5df150d7e537d9cfcfe4a4ba99163149
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i24-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i24-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i24-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i24-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i24-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i24-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i24-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i24-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i24-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i24-standard/instruction.md
index b8b988c631..f8c7a90956 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i24-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i24-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i24-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i24-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i24-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i24-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i36-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i36-privileged/DIGEST
index acb41da9de..b54d013b68 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i36-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i36-privileged/DIGEST
@@ -1 +1 @@
-sha256:7f34ae8734a2379cafb184ed3f5e7fdc0a9e93dbffab8d5660169301a1b4e358
+sha256:883f36fcd555063cf2ed8099af5728b146636556bb8177b18d951a4d4df0430f
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i36-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i36-privileged/instruction.md
index 1525673293..703e240977 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i36-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i36-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i36-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i36-standard/DIGEST
index 5c6142c05a..0418b4f730 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i36-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i36-standard/DIGEST
@@ -1 +1 @@
-sha256:f926fd8c17665965972f901e8498fd117d9a5871684884f4bd3150462674ad97
+sha256:e38a089c3d326807b7074ee4e92204b8d78504d3faa4d5f8cdf9758d4b3448fb
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i36-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i36-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i36-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i36-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i36-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i36-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i36-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i36-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i36-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i36-standard/instruction.md
index fc7c3fbfc4..9a99c18dc8 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i36-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i36-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i36-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i36-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i36-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i36-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i42-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i42-privileged/DIGEST
index b59fe2e77d..9ee9884607 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i42-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i42-privileged/DIGEST
@@ -1 +1 @@
-sha256:e99b8561141bacf8a87919d1b98c38575371d63a1e42c6a5b4366672634a0916
+sha256:a87e2bc322c3bdcc56d9eaf5d62b568385a81d1e799b7e4dbaf6f11cf12529f7
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i42-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i42-privileged/instruction.md
index e09c7779e9..801b16806b 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i42-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i42-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i42-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i42-standard/DIGEST
index 019d1fe5dc..ef62b3a0f1 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i42-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i42-standard/DIGEST
@@ -1 +1 @@
-sha256:9b618e75dab26dba49dd081dca18b7e09ca674b6eaa032081b8b54332f609bd6
+sha256:c0be3b719e263b4649f022c4ef333bc31a57a2095b55a7e0aee7153c5d12acf6
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i42-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i42-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i42-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i42-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i42-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i42-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i42-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i42-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i42-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i42-standard/instruction.md
index 09a671062f..19b869e25b 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i42-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i42-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i42-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i42-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i42-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i42-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i43-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i43-privileged/DIGEST
index c64c2a7e78..537171c166 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i43-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i43-privileged/DIGEST
@@ -1 +1 @@
-sha256:06e7b2a997207fa5f780df1f9e0ffef6f1a5a37ed16789ad79f25ecfdbdad78c
+sha256:92c2abe810ad433ef939b8f554cac812c1cb89fa4deb4abd4c407e521187055a
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i43-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i43-privileged/instruction.md
index 9d96e2988e..f9c921f9b7 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i43-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i43-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i43-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i43-standard/DIGEST
index 0856cace40..ab4e58fb95 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i43-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i43-standard/DIGEST
@@ -1 +1 @@
-sha256:5f84f508ca25371b501022f31fd4e7127d8796deb24593e115e56868d2b21b42
+sha256:53da742f4ab3a56160c9cc98ed34e89c799c0a453c4e0539c7d917be64efcee4
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i43-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i43-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i43-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i43-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i43-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i43-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i43-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i43-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i43-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i43-standard/instruction.md
index 1fb2425025..58ec3b9eb4 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i43-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i43-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i43-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i43-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i43-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i43-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i44-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i44-privileged/DIGEST
index 48d5776a56..32406de11c 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i44-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i44-privileged/DIGEST
@@ -1 +1 @@
-sha256:4417c27546ae4483f5ee5c7a94f0bde1c397e377e907eb52ff31561ad7e8620a
+sha256:69e64d6a37d8c837c06c8a00de5db7c4a8a06c29f9e45dbb5a5b2e521821cf1f
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i44-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i44-privileged/instruction.md
index 7137a9b082..57df465c07 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i44-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i44-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i44-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i44-standard/DIGEST
index 5a1a4120a1..66f7217d37 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i44-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i44-standard/DIGEST
@@ -1 +1 @@
-sha256:7d0c54966c37f447e075ead5678b56313f5066981a0d31d65f43f2b7a9455258
+sha256:b4aea93d4a0681b8155fe07c361e8f27ac8ab0c4069057a6e16b627545e0f15e
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i44-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i44-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i44-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i44-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i44-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i44-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i44-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i44-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i44-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i44-standard/instruction.md
index 4dc9222beb..8c90e679f8 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i44-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i44-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i44-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i44-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i44-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i44-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i45-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i45-privileged/DIGEST
index 3bafa68c4b..8c97c29c89 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i45-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i45-privileged/DIGEST
@@ -1 +1 @@
-sha256:89e58d55193c7bc8f4db58860b5fb8b2593b5e1e848c67dff7bcd621ac9e772b
+sha256:79f68fa9ae2a622190c097ce4ba7702e64f3338911fe2edb91b3637bab8bd569
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i45-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i45-privileged/instruction.md
index c3a9e561bf..d22592049e 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i45-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i45-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i45-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i45-standard/DIGEST
index b0cc79a8c0..efc9745a29 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i45-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i45-standard/DIGEST
@@ -1 +1 @@
-sha256:c24b70d95d3f8dd756905f8a69a3b2519cc0f70fbcc2c7b645f61213e95584dd
+sha256:1d11bfce884a8d878169eaeb2c83c7d383c0b24be4b98eb40d51684ab852ba8b
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i45-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i45-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i45-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i45-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i45-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i45-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i45-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i45-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i45-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i45-standard/instruction.md
index 6c83cdfee3..0d4bc29adf 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i45-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i45-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i45-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i45-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i45-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i45-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i62-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i62-privileged/DIGEST
index bb2022bef5..7cf4ab160a 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i62-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i62-privileged/DIGEST
@@ -1 +1 @@
-sha256:7e43545145a764d9a4937dabb4ef685b8c2f74c647831e6fbfd8df7b8552d4a3
+sha256:ee094af3f2b75dd81e051bf7c4db890c21bdbf7acfb09b3a26aa7fcc47402d6d
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i62-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i62-privileged/instruction.md
index 2e73336767..5dd7585025 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i62-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i62-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i62-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i62-standard/DIGEST
index d0aa50aae3..a0024be249 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i62-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i62-standard/DIGEST
@@ -1 +1 @@
-sha256:a5fa1c49b834329742cf1b8d5a1fc302a6bd2cbefe5f1a126c8acd5d6670c789
+sha256:e3bfaab51911ee8bc529bf6b0d08c9b10a5661befd5116ea3729acd75fcd7061
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i62-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i62-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i62-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i62-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i62-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i62-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i62-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i62-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i62-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i62-standard/instruction.md
index 2b0bfe9810..9b3b897f57 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i62-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i62-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i62-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i62-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i62-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i62-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i63-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i63-privileged/DIGEST
index d484577a7c..e745466aab 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i63-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i63-privileged/DIGEST
@@ -1 +1 @@
-sha256:fec225e8cbf524a69c1633f216a0ca80fd5bf54601d63b3e7a9136cbce9ab28c
+sha256:370af3edf57d410931a89022b01476d2723f1cd739afa60494c135098ff5048b
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i63-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i63-privileged/instruction.md
index 7bb3145f19..69e8695b50 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i63-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i63-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i63-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i63-standard/DIGEST
index 6c9d9934d0..cc090533c9 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i63-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i63-standard/DIGEST
@@ -1 +1 @@
-sha256:e419660278042923bcc6e607425e84249f8a660673ad75ef61fd1d9eb054f067
+sha256:d4d4e5d0c4bcf502928b676002a2411c5773573946d9ce258e0f450d8b5dcb1b
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i63-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i63-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i63-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i63-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i63-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i63-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i63-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i63-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i63-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i63-standard/instruction.md
index 19e5d81ce7..fee736425e 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i63-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i63-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i63-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i63-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i63-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i63-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i72-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i72-privileged/DIGEST
index ba78dc7874..a479d8486a 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i72-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i72-privileged/DIGEST
@@ -1 +1 @@
-sha256:7d0d3a676a022511064f7d440d149850903b7be0c77c74a045bab3bb517b04de
+sha256:d2190436d09ba7d09d997e388149d1d1c82ba247eb7d2d71735914774673fbde
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i72-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i72-privileged/instruction.md
index be660fc5c7..67ea6abfdc 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i72-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i72-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i72-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i72-standard/DIGEST
index 8b4ea21394..f2ce35588b 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i72-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i72-standard/DIGEST
@@ -1 +1 @@
-sha256:199151b6d07ce09f6515784328c71150b339491e0362b6ae1eac81d2e1b3e3e6
+sha256:99afc4f807523b7dfc7b1ca9c01714d73d9504db034c7beee489345cf1a7a22f
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i72-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i72-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i72-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i72-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i72-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i72-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i72-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i72-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i72-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i72-standard/instruction.md
index 20702cff8e..5ef86b09b7 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i72-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i72-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i72-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i72-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i72-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i72-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i97-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i97-privileged/DIGEST
index e146961114..ffea2d1b71 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i97-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i97-privileged/DIGEST
@@ -1 +1 @@
-sha256:ae014622e203320e28661e44d1c4f40db25047296d5989cdd542391e1eed41b4
+sha256:0253f7720bc62ca5890614ffb6d6e66975d6d4dc6b895f9f9469eac2d285354d
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i97-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i97-privileged/instruction.md
index 3a1a3bc1da..e359374844 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i97-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i97-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i97-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-bed-i97-standard/DIGEST
index 859b647eb5..b9727d3469 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i97-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-bed-i97-standard/DIGEST
@@ -1 +1 @@
-sha256:6ac42c5bd947f447befd3bee13364017f1ff2b13397fc1491078c8210c450edd
+sha256:eea2e97d0b8ca59c2c12c16f6eb9f9368752830a9c75441b347b63f3ad5ae8eb
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i97-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i97-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i97-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i97-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i97-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i97-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i97-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i97-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i97-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-bed-i97-standard/instruction.md
index 662de8cd21..5f3ee69c71 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i97-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-bed-i97-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-bed-i97-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-bed-i97-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-bed-i97-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-bed-i97-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i124-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-couch-i124-privileged/DIGEST
index 2403c9325a..136623741b 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i124-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-couch-i124-privileged/DIGEST
@@ -1 +1 @@
-sha256:d7b1be52d8ba5b43525b40f0a0417dd236b67c6d4bb552a964392db0ac83792e
+sha256:5b69025cdbe66cea12d3a595d5d27fcef164640330b44324d194831c750e2757
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i124-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-couch-i124-privileged/instruction.md
index 5b0289dd35..87c9bcbc97 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i124-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-couch-i124-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i124-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-couch-i124-standard/DIGEST
index 75421024a1..f1635a885f 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i124-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-couch-i124-standard/DIGEST
@@ -1 +1 @@
-sha256:c31ab30357dacce243421aae0e69f12cfaec55bb87c030d369202d6c7d73f65a
+sha256:db21f8c1da2972f74692b38d566bcffb9d8d81505d16d77e07286cca0f069b0d
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i124-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i124-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i124-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i124-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i124-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i124-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i124-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i124-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i124-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-couch-i124-standard/instruction.md
index 38942a0ed9..b6c6039a26 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i124-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-couch-i124-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i124-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i124-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i124-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i124-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i14-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-couch-i14-privileged/DIGEST
index f5ad05e5ee..841d1652e5 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i14-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-couch-i14-privileged/DIGEST
@@ -1 +1 @@
-sha256:cabf3e2463c9e983213b5783e60a86cd2cdd74b986461af9fb3a76689517186c
+sha256:797c8b7538ec317f056a4dc19bf921af576fbad84c685c903ebd02ec3f38b5ef
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i14-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-couch-i14-privileged/instruction.md
index 3c9413467c..6138fb2945 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i14-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-couch-i14-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i14-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-couch-i14-standard/DIGEST
index e758cd4812..e6b29ed616 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i14-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-couch-i14-standard/DIGEST
@@ -1 +1 @@
-sha256:a7530a7e6e2b9295e2e716beaf32bce9dab61629b4ec0bf02639949cf8980a14
+sha256:7e95fc0b31d13e0144e90e4a7dfb658df507087d08fac71798c5cfc3d41f5091
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i14-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i14-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i14-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i14-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i14-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i14-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i14-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i14-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i14-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-couch-i14-standard/instruction.md
index e442654c69..6ed0deb4e1 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i14-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-couch-i14-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i14-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i14-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i14-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i14-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i154-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-couch-i154-privileged/DIGEST
index 6605536ec3..2b5c7432c2 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i154-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-couch-i154-privileged/DIGEST
@@ -1 +1 @@
-sha256:92f4bf724bb4d4cca92d67a5e8ab7fb06eba913d6ad85fa4fe297fd0c997db95
+sha256:36a6299614cfa83e81b20f38fad2b3d3ba5b984203e6812566c33280059a47ca
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i154-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-couch-i154-privileged/instruction.md
index 6886d77105..a688918d59 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i154-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-couch-i154-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i154-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-couch-i154-standard/DIGEST
index 8e844d2d5c..62aec16e87 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i154-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-couch-i154-standard/DIGEST
@@ -1 +1 @@
-sha256:6ad081d9581c4a8a620ed12619a112af49825ff37539be45ce8265ff110bbe4d
+sha256:6cfed9e2e735e20896a4afa0018182f31713694c2c3733d469bc18b869388d8d
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i154-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i154-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i154-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i154-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i154-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i154-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i154-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i154-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i154-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-couch-i154-standard/instruction.md
index bc39958cca..2cdfb48acc 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i154-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-couch-i154-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i154-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i154-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i154-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i154-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i158-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-couch-i158-privileged/DIGEST
index cea631005b..0a4800d515 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i158-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-couch-i158-privileged/DIGEST
@@ -1 +1 @@
-sha256:ba5533e4cea13b39e8c4edd4e48d6720563af172e726ded2faf332dea41d9533
+sha256:f2f156513c17f60fecefbc89b7d4f1a9c09dccd807a76e09a83fda4b9a768057
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i158-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-couch-i158-privileged/instruction.md
index fb434fff8c..1e40dcf728 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i158-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-couch-i158-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i158-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-couch-i158-standard/DIGEST
index 1d8a8aef8c..0b56e2b138 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i158-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-couch-i158-standard/DIGEST
@@ -1 +1 @@
-sha256:a5439d562a3a1c91b5fef770f7311dd7b0dfa2050455dcf66647c905af6b412d
+sha256:4d5f90e6f54fafc1204aa895113fe353d518bd4c3ad10a74455656f2f75d752c
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i158-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i158-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i158-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i158-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i158-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i158-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i158-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i158-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i158-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-couch-i158-standard/instruction.md
index 03459cada5..e564c07509 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i158-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-couch-i158-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i158-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i158-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i158-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i158-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i164-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-couch-i164-privileged/DIGEST
index a3224e8c39..5a98663d83 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i164-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-couch-i164-privileged/DIGEST
@@ -1 +1 @@
-sha256:155bf62500dac17c4988c9db2b9d9dc76a07c27b8b5a6c36642a4ef83e75defe
+sha256:bb55c8c1b94c628202b113eca7016de6477a8566829eee12c6cbb4a83fe8c27e
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i164-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-couch-i164-privileged/instruction.md
index cf7c05714b..95b39227ac 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i164-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-couch-i164-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i164-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-couch-i164-standard/DIGEST
index e79f041436..1d89513754 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i164-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-couch-i164-standard/DIGEST
@@ -1 +1 @@
-sha256:7ed60ace5e42c8301d17da3e14f57a2f3d0bf8a9c877903ed98408fead03c44f
+sha256:3b99f2c3f1e3bed3ed503406650723d142f322d21dafd47ed6bce1cd810952ec
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i164-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i164-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i164-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i164-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i164-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i164-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i164-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i164-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i164-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-couch-i164-standard/instruction.md
index 3e19d77bef..5cbd30b059 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i164-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-couch-i164-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i164-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i164-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i164-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i164-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i179-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-couch-i179-privileged/DIGEST
index 534bfe9baf..9a9d3612c7 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i179-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-couch-i179-privileged/DIGEST
@@ -1 +1 @@
-sha256:e921300e171121689186344ac64f0e4e231ed74ec01281eb57282588688efaf7
+sha256:3a7d7235307d60d07023b37c560aca1cd66ae3a1b203d58e71d8c10f11db8bca
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i179-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-couch-i179-privileged/instruction.md
index 0aa15cf8aa..86169f2c53 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i179-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-couch-i179-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i179-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-couch-i179-standard/DIGEST
index 0cace245df..6585002918 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i179-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-couch-i179-standard/DIGEST
@@ -1 +1 @@
-sha256:d2dc0703922608c609d0ea9fd2ed6b042b954a9e969342cb580559d79badb1fb
+sha256:6337ba330a5c6b6b2fe516c183a9f69bde4ac807307730662c071d4a008db9e6
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i179-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i179-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i179-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i179-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i179-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i179-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i179-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i179-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i179-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-couch-i179-standard/instruction.md
index 279a6bd405..53b2449de9 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i179-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-couch-i179-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i179-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i179-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i179-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i179-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i186-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-couch-i186-privileged/DIGEST
index 467ebb72d9..09036d7537 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i186-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-couch-i186-privileged/DIGEST
@@ -1 +1 @@
-sha256:17237518b4173dfc8fcf18567b7ce7c9250a2b1e8493cc6a6eb1de3143dc9303
+sha256:7752dfddf339631a98b0fca072192263afc8c456d94eba94ab44f2f954ef45b5
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i186-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-couch-i186-privileged/instruction.md
index fcda3b43df..4827e6d8d8 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i186-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-couch-i186-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i186-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-couch-i186-standard/DIGEST
index e296be16f2..8a443cbf5d 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i186-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-couch-i186-standard/DIGEST
@@ -1 +1 @@
-sha256:76747e0d3ddbab52f57b2f14b2100011dc5d1c0b525fa4b9c7ac5a05a975cec8
+sha256:7296e090f25c01cc1f92f81a9d88fee45efda4b5d84a933eb8e5f394a5b723a5
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i186-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i186-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i186-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i186-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i186-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i186-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i186-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i186-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i186-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-couch-i186-standard/instruction.md
index 9b0ae7c971..982e4200b6 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i186-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-couch-i186-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i186-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i186-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i186-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i186-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i199-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-couch-i199-privileged/DIGEST
index 221b6d2401..244cb695ce 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i199-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-couch-i199-privileged/DIGEST
@@ -1 +1 @@
-sha256:867e92e7a54d740896bc8cf15def8fe7307125c424b44da481d3b2a80434cbf4
+sha256:f16588bc1877199141fc60bfbb011c021363591da7c16e67b79c9552421aeea2
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i199-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-couch-i199-privileged/instruction.md
index 276d9ffd25..65e7a08581 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i199-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-couch-i199-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i199-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-couch-i199-standard/DIGEST
index 974c1c42db..be9523e43b 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i199-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-couch-i199-standard/DIGEST
@@ -1 +1 @@
-sha256:d7bf15c10380f85558affb9c39f35c997de2d6e0d2ada218acb2ad37ff542076
+sha256:0e825e3198cbbf91bf3c9a071713d784a176fec82e28f7530029826e30832d6d
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i199-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i199-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i199-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i199-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i199-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i199-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i199-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i199-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i199-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-couch-i199-standard/instruction.md
index 653ff34135..d494735653 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i199-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-couch-i199-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i199-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i199-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i199-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i199-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i213-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-couch-i213-privileged/DIGEST
index 9edda1641f..a680b1dec2 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i213-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-couch-i213-privileged/DIGEST
@@ -1 +1 @@
-sha256:a6865a8f8cf1292e0444c69f1a98682e1e0c62e59973a15c429457ed626c9eb2
+sha256:f5ae5e35e4d7c5456503ad80cf9ac51c4442b3b5a01f76e7c0fc75bfe5280c2c
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i213-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-couch-i213-privileged/instruction.md
index e952365891..a89454cf0f 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i213-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-couch-i213-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i213-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-couch-i213-standard/DIGEST
index 8c9f5c5f4d..a25921259c 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i213-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-couch-i213-standard/DIGEST
@@ -1 +1 @@
-sha256:d4c69fff7158cd0b0af1f837c0c1d9814a1fc3586b099a4d77eb38e17c24f307
+sha256:272a4a22ce22a6c990166989c89fe9b7917b12f2778e2ef5961663b7ed4bd3f6
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i213-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i213-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i213-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i213-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i213-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i213-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i213-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i213-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i213-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-couch-i213-standard/instruction.md
index 6941d39143..3b63a17845 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i213-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-couch-i213-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i213-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i213-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i213-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i213-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i22-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-couch-i22-privileged/DIGEST
index 41e128faf4..3225505894 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i22-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-couch-i22-privileged/DIGEST
@@ -1 +1 @@
-sha256:aba2ae0a14b3c2b2c1eb8044752924109b8d539dfdc5886efff088b55c1d9b1a
+sha256:4dda67d20a34984e1aadcc2ca2bc1d99e2e4ddee4f6ae9d2d16ea1d9a4953e84
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i22-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-couch-i22-privileged/instruction.md
index 33fd5f6fff..3b3ab3b601 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i22-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-couch-i22-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i22-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-couch-i22-standard/DIGEST
index 3fd73d4189..02b3a9a5fb 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i22-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-couch-i22-standard/DIGEST
@@ -1 +1 @@
-sha256:cde45785d66d0bd77a8cd810d9c165e68aaa0fb404b96c7799e62f4c8f37ecc8
+sha256:19a3eb3d2464c4f347667218f25492dd53cdd52f83fc24a1b27c806b7a53117f
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i22-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i22-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i22-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i22-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i22-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i22-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i22-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i22-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i22-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-couch-i22-standard/instruction.md
index 6597d3ed92..e46a2c76bf 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i22-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-couch-i22-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i22-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i22-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i22-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i22-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i92-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-couch-i92-privileged/DIGEST
index a76df2e6c2..57aed077df 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i92-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-couch-i92-privileged/DIGEST
@@ -1 +1 @@
-sha256:ba4316cca5256cb3719690b09666c42f5c457b2ff886b3835fc8ea875b7f926a
+sha256:b0b6b79e7d2c8904573c4caf405b1942538b805fade1772ecd15a38789f58949
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i92-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-couch-i92-privileged/instruction.md
index 1352f2e8f6..07ccaade31 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i92-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-couch-i92-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i92-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-couch-i92-standard/DIGEST
index 62f962558f..9d39af15d2 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i92-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-couch-i92-standard/DIGEST
@@ -1 +1 @@
-sha256:fdd4d507c59260f310d152b8936c92a1ec0614c690e0ba955a221171883fe9d0
+sha256:f85a46a2d6ba7a1b23b2630b5360351bb641db0720ca7f9a4204e5da6073166f
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i92-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i92-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i92-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i92-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i92-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i92-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i92-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i92-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i92-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-couch-i92-standard/instruction.md
index 045e50567e..7ebac8fba8 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i92-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-couch-i92-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i92-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i92-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i92-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i92-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i98-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-couch-i98-privileged/DIGEST
index 7bc1d37c88..b277007ad5 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i98-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-couch-i98-privileged/DIGEST
@@ -1 +1 @@
-sha256:9bf217cca7a14dcd06c0a160e9da7f767662ce56f58c045fab80bda78806c858
+sha256:e4bcbbef20f7d900dec7da42f50fed9555d687eec28849ffc599c52542e93ac2
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i98-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-couch-i98-privileged/instruction.md
index efc8f7e64d..a92047568c 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i98-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-couch-i98-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i98-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-couch-i98-standard/DIGEST
index 19e7d15b30..3db9aa6a99 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i98-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-couch-i98-standard/DIGEST
@@ -1 +1 @@
-sha256:fb8a710165c8b82f176b89b972bac56abf2d1317127939c9060cb9018a8d5ca8
+sha256:6ed2c197fd28a94f979033591428e4b2f96b805064fc34b4dda9a4694a647105
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i98-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i98-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i98-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i98-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i98-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i98-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i98-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i98-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i98-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-couch-i98-standard/instruction.md
index 30588bc48e..dbe977f762 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i98-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-couch-i98-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-couch-i98-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-couch-i98-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-couch-i98-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-couch-i98-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i04-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-toilet-i04-privileged/DIGEST
index 7af57582c3..9695a0aabb 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i04-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i04-privileged/DIGEST
@@ -1 +1 @@
-sha256:c69a91e420ff54b91a0a24a0913a03582219b02c0f3c6de9cc2bfc0c83673090
+sha256:94dcee792d4a9dcfcf870d4acd285f834164635cf6326721c9623df445efd3ef
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i04-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-toilet-i04-privileged/instruction.md
index 4d7c5d402b..ebe3ac5961 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i04-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i04-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i04-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-toilet-i04-standard/DIGEST
index f3bb2d8721..205d45213d 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i04-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i04-standard/DIGEST
@@ -1 +1 @@
-sha256:dba8ff3cffb5a342366107f193a4ced235b3e3678ac8cde0df029daf340311cd
+sha256:bc7f5c4da3de04fe4eb5131ecca5fdb61fed147dc82673f047efcc856cef3164
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i04-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i04-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i04-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i04-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i04-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i04-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i04-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i04-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i04-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-toilet-i04-standard/instruction.md
index 04c2453760..f64469d404 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i04-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i04-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i04-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i04-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i04-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i04-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i112-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-toilet-i112-privileged/DIGEST
index 9a7d07ddad..f06347ccae 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i112-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i112-privileged/DIGEST
@@ -1 +1 @@
-sha256:c72d41db808463b22849c79e550dc26193ef3f9205f60cd8ede2bb93129e0139
+sha256:85e8c36b7ef1eb476df685df8cf9c0700cfda4456318a0a72cb5dbff899765d2
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i112-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-toilet-i112-privileged/instruction.md
index e69cf9ff2a..63890e50ed 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i112-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i112-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i112-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-toilet-i112-standard/DIGEST
index 58a919d2f1..a2910e1eba 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i112-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i112-standard/DIGEST
@@ -1 +1 @@
-sha256:17ad256c4b21401a3690da87dee8b192309056cb27cdffb9ad434e86de1175b0
+sha256:98fb881ec266593373c0d1ee75e5b98537d706e5877c789bd402b0053341830a
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i112-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i112-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i112-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i112-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i112-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i112-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i112-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i112-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i112-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-toilet-i112-standard/instruction.md
index 9c80350bd6..1af6cb7ab6 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i112-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i112-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i112-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i112-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i112-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i112-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i113-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-toilet-i113-privileged/DIGEST
index a8e7951204..d70e807bc7 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i113-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i113-privileged/DIGEST
@@ -1 +1 @@
-sha256:d633a4d61a9557165531b99361aff03d7f200b5432a085aa783341603f4f4b79
+sha256:69b71943d8270ce297c2e59fac664c679d7c5b66eef63c36a3003f218e2466c1
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i113-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-toilet-i113-privileged/instruction.md
index a0e222d222..2c58008e04 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i113-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i113-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i113-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-toilet-i113-standard/DIGEST
index b3c725fd2c..776ea2118b 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i113-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i113-standard/DIGEST
@@ -1 +1 @@
-sha256:d2841a4a4a2405ecee25102460fecc3e0b9a7b5c8efcb783c919d2521a964da3
+sha256:1fecbacc8b9c5838f40d93d23f9f6ef1c3f3464a76e80e4841f05948609a1974
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i113-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i113-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i113-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i113-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i113-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i113-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i113-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i113-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i113-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-toilet-i113-standard/instruction.md
index 723580a702..f98945efff 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i113-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i113-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i113-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i113-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i113-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i113-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i132-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-toilet-i132-privileged/DIGEST
index 6d565bf087..e317a09687 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i132-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i132-privileged/DIGEST
@@ -1 +1 @@
-sha256:75c21f3ce174537f3043d0cb2e87a0a6e9dd8958d8de4b96268466fddd609ff1
+sha256:eb50f95c3a582df12400519d0b9ebe96ba9d82b4dac5bcf268166a1b49197d66
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i132-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-toilet-i132-privileged/instruction.md
index df99c7236b..8db7d20baf 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i132-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i132-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i132-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-toilet-i132-standard/DIGEST
index b53d0adcd6..7a987c4f93 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i132-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i132-standard/DIGEST
@@ -1 +1 @@
-sha256:61197cea6f0c7b15620c318c526ce72fc0d9bea879908e5c8bf4a2ffc179c988
+sha256:6f59ded74883c9355afe64b9419ce47a7d50c0ea37fad3b0adc5ccad0a966813
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i132-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i132-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i132-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i132-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i132-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i132-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i132-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i132-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i132-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-toilet-i132-standard/instruction.md
index ad8876c218..ba7deb8397 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i132-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i132-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i132-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i132-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i132-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i132-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i14-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-toilet-i14-privileged/DIGEST
index cc27b02573..2255e156f5 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i14-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i14-privileged/DIGEST
@@ -1 +1 @@
-sha256:d75eefe7710399ca5e4ba1300d309d44e890d5e9b33cad0bd5c97aea2022815e
+sha256:9731a82054336d07f2cad632f682581f42314253afbfdd0fed2e4056e8393ea9
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i14-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-toilet-i14-privileged/instruction.md
index 6da4eab525..a18e102f4c 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i14-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i14-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i14-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-toilet-i14-standard/DIGEST
index a814aafcd8..73658f6146 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i14-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i14-standard/DIGEST
@@ -1 +1 @@
-sha256:f8b97dd78b69215873b3d4f860a7b95f46465a5263cb977ace3ecc40629b3013
+sha256:1ef4153d325350d2088604dfe68aa73ed46cb4c478af1f6f80652f397fdf0792
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i14-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i14-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i14-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i14-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i14-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i14-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i14-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i14-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i14-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-toilet-i14-standard/instruction.md
index 9b81cf461e..352a40c960 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i14-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i14-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i14-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i14-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i14-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i14-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i15-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-toilet-i15-privileged/DIGEST
index 970d9c17f5..4946f97323 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i15-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i15-privileged/DIGEST
@@ -1 +1 @@
-sha256:0b8d354243cdae82e906f07da3b04363c63d151ade1f3cf2c52f66695399176f
+sha256:ad0f11a2494f1dbe7bf01d9fd30ebd96e410c8b5fe149fb270a71f7a51c39ed6
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i15-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-toilet-i15-privileged/instruction.md
index 54de8cba92..7528515eeb 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i15-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i15-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i15-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-toilet-i15-standard/DIGEST
index 7a60dda07c..61eb64feca 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i15-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i15-standard/DIGEST
@@ -1 +1 @@
-sha256:b225270b7d2e64e6e364aa7dfa0363e53810f82bb33d498c42f2bd9d05c6fffe
+sha256:54bd42e13d3872e5c22e56e855868cae7a7bef505ee17397d8644a272a2633ba
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i15-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i15-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i15-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i15-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i15-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i15-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i15-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i15-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i15-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-toilet-i15-standard/instruction.md
index ba00b69778..e8dfaf8e82 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i15-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i15-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i15-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i15-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i15-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i15-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i66-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-toilet-i66-privileged/DIGEST
index af2fda52d7..7017643c73 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i66-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i66-privileged/DIGEST
@@ -1 +1 @@
-sha256:0194a7809ca422968ebcc715d7c043a7adfbdf19bcc9325fa2dae96b2f629ad7
+sha256:67fe76713349861babd7ae74195bb5734835ba544d4d672714639d7cb4fd0398
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i66-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-toilet-i66-privileged/instruction.md
index c6f4bed4e3..3fe2e8add3 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i66-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i66-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i66-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-toilet-i66-standard/DIGEST
index 67c86ba07e..04a57f62e6 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i66-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i66-standard/DIGEST
@@ -1 +1 @@
-sha256:4854390e7dd09aa49d46deff64ddd2e295625b1bbe2ab666c1bcb3f7c28ebf54
+sha256:2fd078737476f2d20aa06adaddc77cfd130b4cd2d3445d91b27759b9efa4379b
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i66-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i66-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i66-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i66-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i66-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i66-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i66-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i66-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i66-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-toilet-i66-standard/instruction.md
index 335f64453e..b772305cec 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i66-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i66-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i66-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i66-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i66-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i66-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i91-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-toilet-i91-privileged/DIGEST
index 16d8bbb025..9c7033ec20 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i91-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i91-privileged/DIGEST
@@ -1 +1 @@
-sha256:65e87aa18b3ffb6a6a29b645ce674cb27c537b9f16c6c90a539d290d340dae28
+sha256:d4d1f7099e7c8ff0d80e0cd793d63ce3b3b19ad0b8e060e98481446a3e141c96
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i91-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-toilet-i91-privileged/instruction.md
index 4a52c49592..29cde3babc 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i91-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i91-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i91-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-toilet-i91-standard/DIGEST
index a714cd74f7..1fb87758ec 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i91-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i91-standard/DIGEST
@@ -1 +1 @@
-sha256:32f248faa23bbd63f2d7d27e211f4dea1361bb5e28ab9e47279112700a55a9c7
+sha256:dde0210e10725de738c113839c157e6eae2fa1448efafa2a04cf880dfcc7b650
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i91-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i91-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i91-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i91-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i91-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i91-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i91-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i91-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i91-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-toilet-i91-standard/instruction.md
index dc4302048e..e1edc99e81 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i91-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i91-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i91-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i91-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i91-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i91-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i95-privileged/DIGEST b/tasks/humanclaw/humanclaw-sit-toilet-i95-privileged/DIGEST
index 59b3a4ddd2..44817cfd79 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i95-privileged/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i95-privileged/DIGEST
@@ -1 +1 @@
-sha256:85f70e41d857333a788ed02e4d16deb41f0011f48a6dbf8cbd5a0e8d20a15296
+sha256:b106499c14c961b2f01ee001f95926a441c1eb307704222f803b8058a17f2bed
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i95-privileged/instruction.md b/tasks/humanclaw/humanclaw-sit-toilet-i95-privileged/instruction.md
index e9ea691304..3bcb5b68f8 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i95-privileged/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i95-privileged/instruction.md
@@ -66,4 +66,4 @@ Your container: **6 CPUs**, **8 GiB of memory**, **1024 processes and threads**,
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time a simulator takes to start counts. When it is up you are stopped without warning and only what is in `/app/output/` at that moment is graded, so save a deliverable as soon as you have one and overwrite it whenever you have a better one. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i95-standard/DIGEST b/tasks/humanclaw/humanclaw-sit-toilet-i95-standard/DIGEST
index d37a0c3868..a2f30b5c4e 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i95-standard/DIGEST
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i95-standard/DIGEST
@@ -1 +1 @@
-sha256:2b20ccfa1dc44d58d9b8646f21cfff2b8dbd135597c426fed80bf3f24ea808bb
+sha256:03b1d11bbfebea1f2d695fcfc3d307a209478e4403e5201c5273f1917041ba9f
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i95-standard/environment/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i95-standard/environment/Dockerfile
index c01c67bf98..7211cfb917 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i95-standard/environment/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i95-standard/environment/Dockerfile
@@ -2,7 +2,7 @@
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY client-requirements.txt /tmp/
RUN pip install --no-cache-dir -r /tmp/client-requirements.txt
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /v2_1/rcb_client.py /opt/tools/
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /v2_1/rcb_client.py /opt/tools/
ENV PYTHONPATH=/opt/tools
RUN mkdir -p /app/output
WORKDIR /app
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i95-standard/environment/sim/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i95-standard/environment/sim/Dockerfile
index 7587530db5..412e5d9591 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i95-standard/environment/sim/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i95-standard/environment/sim/Dockerfile
@@ -174,6 +174,6 @@ WORKDIR /app
# the shared RCB1 codec. .dockerignore keeps the build's own two files out of /srv.
FROM humanclaw-base
COPY . /srv/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /rcb1.py /srv/rcb1.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /rcb1.py /srv/rcb1.py
COPY --from=ghcr.io/mll-lab-nu/efe:humanclaw-files-0.1.0@sha256:8e01e30979d38d60b34e7ce6994b536528fbba4a6018ca4f7cb00b876f21bcfe /hc_core.py /rcb_service.py /server.py /srv/
WORKDIR /srv
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i95-standard/instruction.md b/tasks/humanclaw/humanclaw-sit-toilet-i95-standard/instruction.md
index c4fc6be040..9068f66e2d 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i95-standard/instruction.md
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i95-standard/instruction.md
@@ -63,4 +63,4 @@ Your container: **4 CPUs**, **3 GiB of memory**, **1024 processes and threads**
## Time limit
You have 3600 seconds to complete this task. Do not cheat by using online solutions or hints specific to this task.
-This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it (for example Codex's `yield_time_ms`) even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
+This is wall-clock time from the start of your session; the time you wait for the simulator service counts. When it is up you are stopped without warning and the episode is graded as it stands at that moment. The service's `time_left_s` counts the same limit from your first request to the service, so it never runs out before your time does: your real time left is `time_left_s` minus the time you spent before that request. Plan by it. Your session started when you received this task. `/run/rcb-limits/usage.json`, rewritten every few seconds, gives the time left on this limit (`time_left_s`) and its end (`deadline_utc`), counted from a little before your session started, so it never gives you more time than you have: read it (or run `date`) before you decide that time is short, never guess. Waiting counts too: a tool call that sends input to a process that keeps running (an interactive interpreter, a simulator loop, a server) can wait for the whole wait or yield time you give it even when the answer is printed at once, so give such calls a short wait and poll again if the output is not complete, or run one-shot scripts that exit when they are done. Installing packages is not cheating (`## External material` above).
diff --git a/tasks/humanclaw/humanclaw-sit-toilet-i95-standard/tests/Dockerfile b/tasks/humanclaw/humanclaw-sit-toilet-i95-standard/tests/Dockerfile
index a56c910254..83af169468 100644
--- a/tasks/humanclaw/humanclaw-sit-toilet-i95-standard/tests/Dockerfile
+++ b/tasks/humanclaw/humanclaw-sit-toilet-i95-standard/tests/Dockerfile
@@ -1,7 +1,7 @@
# Separate verifier sandbox: grades the sim service's own artifacts; needs nothing but Python.
FROM docker.io/library/python:3.12.14-slim@sha256:f77ac9e44ae96ef2c90b8053ea08c31f8be030f824196b0ae4db6d462c84e51f
COPY test.sh /tests/
-COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.0@sha256:90253c4cb419668f84c6728dc6d6e23ea55ef8d7f7e7835a5eb65015729f91b0 /v2_1/grade.py /tests/grade.py
+COPY --from=ghcr.io/mll-lab-nu/efe:standard-files-0.4.1@sha256:7f1a830075fd6dd25e7a20a340316c041df583a29062796f59a4fa63b6f76946 /v2_1/grade.py /tests/grade.py
RUN chmod +x /tests/test.sh
# resources (PROTOCOL §6) # rcb-monitor
COPY --from=ghcr.io/mll-lab-nu/efe:monitor-0.5.0@sha256:ecc5f24f1516ca11711d7c2d3ac07c89f79cd9220812c1244498ec71e352402a /opt/rcb_monitor/rcb_limits.py /tests/rcb_limits.py