Fix baseline patch capture before verifier (part 2)

tasks/task_034/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_034/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_034"
-
-[[verifier.collect]]
-command = "cd /app/task_034 && git config --global --add safe.directory /app/task_034 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0

tasks/task_035/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_035/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_035"
-
-[[verifier.collect]]
-command = "cd /app/task_035 && git config --global --add safe.directory /app/task_035 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0

tasks/task_036/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_036/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_036"
-
-[[verifier.collect]]
-command = "cd /app/task_036 && git config --global --add safe.directory /app/task_036 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0

tasks/task_037/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_037/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_037"
-
-[[verifier.collect]]
-command = "cd /app/task_037 && git config --global --add safe.directory /app/task_037 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0

tasks/task_038/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_038/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_038"
-
-[[verifier.collect]]
-command = "cd /app/task_038 && git config --global --add safe.directory /app/task_038 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0

tasks/task_039/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_039/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_039"
-
-[[verifier.collect]]
-command = "cd /app/task_039 && git config --global --add safe.directory /app/task_039 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0

tasks/task_040/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_040/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_040"
-
-[[verifier.collect]]
-command = "cd /app/task_040 && git config --global --add safe.directory /app/task_040 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0

tasks/task_041/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_041/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_041"
-
-[[verifier.collect]]
-command = "cd /app/task_041 && git config --global --add safe.directory /app/task_041 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0

tasks/task_042/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_042/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_042"
-
-[[verifier.collect]]
-command = "cd /app/task_042 && git config --global --add safe.directory /app/task_042 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0

tasks/task_043/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_043/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_043"
-
-[[verifier.collect]]
-command = "cd /app/task_043 && git config --global --add safe.directory /app/task_043 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0

tasks/task_044/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_044/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_044"
-
-[[verifier.collect]]
-command = "cd /app/task_044 && git config --global --add safe.directory /app/task_044 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0

tasks/task_045/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_045/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_045"
-
-[[verifier.collect]]
-command = "cd /app/task_045 && git config --global --add safe.directory /app/task_045 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0

tasks/task_046/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_046/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_046"
-
-[[verifier.collect]]
-command = "cd /app/task_046 && git config --global --add safe.directory /app/task_046 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0

tasks/task_047/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_047/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_047"
-
-[[verifier.collect]]
-command = "cd /app/task_047 && git config --global --add safe.directory /app/task_047 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0

tasks/task_048/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_048/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_048"
-
-[[verifier.collect]]
-command = "cd /app/task_048 && git config --global --add safe.directory /app/task_048 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0

tasks/task_049/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_049/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_049"
-
-[[verifier.collect]]
-command = "cd /app/task_049 && git config --global --add safe.directory /app/task_049 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0

tasks/task_050/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_050/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_050"
-
-[[verifier.collect]]
-command = "cd /app/task_050 && git config --global --add safe.directory /app/task_050 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0

tasks/task_051/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_051/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_051"
-
-[[verifier.collect]]
-command = "cd /app/task_051 && git config --global --add safe.directory /app/task_051 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0

tasks/task_052/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_052/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_052"
-
-[[verifier.collect]]
-command = "cd /app/task_052 && git config --global --add safe.directory /app/task_052 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0

tasks/task_053/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_053/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_053"
-
-[[verifier.collect]]
-command = "cd /app/task_053 && git config --global --add safe.directory /app/task_053 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0

tasks/task_054/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_054/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_054"
-
-[[verifier.collect]]
-command = "cd /app/task_054 && git config --global --add safe.directory /app/task_054 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0

tasks/task_055/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_055/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_055"
-
-[[verifier.collect]]
-command = "cd /app/task_055 && git config --global --add safe.directory /app/task_055 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0

tasks/task_056/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_056/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_056"
-
-[[verifier.collect]]
-command = "cd /app/task_056 && git config --global --add safe.directory /app/task_056 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0

tasks/task_057/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_057/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_057"
-
-[[verifier.collect]]
-command = "cd /app/task_057 && git config --global --add safe.directory /app/task_057 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0

tasks/task_058/pre_artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+# Pier runs this hook in the task workdir after the agent exits and before a
+# separate verifier starts. Always create the artifact, including for a clean
+# or timed-out agent run, so the verifier receives an explicit empty patch.
+task_dir="${SCI_BENCH_TASK_DIR:-$PWD}"
+artifacts_dir="${ENV_ARTIFACTS_PATH:-/logs/artifacts}"
+patch="$artifacts_dir/model.patch"
+
+mkdir -p "$artifacts_dir"
+: > "$patch"
+
+cd "$task_dir"
+git config --global --add safe.directory "$task_dir"
+roots="$(git rev-list --max-parents=0 --reverse HEAD)"
+set -- $roots
+if [ "$#" -ne 1 ]; then
+    echo "task repository must have exactly one baseline root commit" >&2
+    exit 1
+fi
+baseline="$1"
+git add -A
+git diff --cached --binary "$baseline" > "$patch"

tasks/task_058/task.toml

@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_058"
-
-[[verifier.collect]]
-command = "cd /app/task_058 && git config --global --add safe.directory /app/task_058 && baseline=$(git rev-list --max-parents=0 --reverse HEAD | head -n 1) && git add -A && git diff --cached --binary \"$baseline\" > /logs/artifacts/model.patch"
-timeout_sec = 300.0