diff --git a/tasks/task_062/pre_artifacts.sh b/tasks/task_062/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_062/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"
diff --git a/tasks/task_062/task.toml b/tasks/task_062/task.toml
index 3045bb6399e55850c06425ee3f82235439613b75..311f637c572d8c22cbcfb77f602ce2611a4a952a 100644
--- a/tasks/task_062/task.toml
+++ b/tasks/task_062/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_062"
-
-[[verifier.collect]]
-command = "cd /app/task_062 && git config --global --add safe.directory /app/task_062 && 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
diff --git a/tasks/task_063/pre_artifacts.sh b/tasks/task_063/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_063/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"
diff --git a/tasks/task_063/task.toml b/tasks/task_063/task.toml
index c5f692cdd65ea0505691b0cfeaebf09dd6b33d22..0172e618c996b297f48397bf5b1c511dedae5e6f 100644
--- a/tasks/task_063/task.toml
+++ b/tasks/task_063/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_063"
-
-[[verifier.collect]]
-command = "cd /app/task_063 && git config --global --add safe.directory /app/task_063 && 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
diff --git a/tasks/task_064/pre_artifacts.sh b/tasks/task_064/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_064/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"
diff --git a/tasks/task_064/task.toml b/tasks/task_064/task.toml
index 65146d91fcc06c8123d3c1035f738b6f4ca93ea4..67515846f0ed8d68a6c2a90b098d5edb8582ba7d 100644
--- a/tasks/task_064/task.toml
+++ b/tasks/task_064/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_064"
-
-[[verifier.collect]]
-command = "cd /app/task_064 && git config --global --add safe.directory /app/task_064 && 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
diff --git a/tasks/task_065/pre_artifacts.sh b/tasks/task_065/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_065/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"
diff --git a/tasks/task_065/task.toml b/tasks/task_065/task.toml
index 95ae833f92ea272255a7d70a922335ea8f8b42c0..87331ac090381fc1ab68a4b45c006854384653b7 100644
--- a/tasks/task_065/task.toml
+++ b/tasks/task_065/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_065"
-
-[[verifier.collect]]
-command = "cd /app/task_065 && git config --global --add safe.directory /app/task_065 && 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
diff --git a/tasks/task_066/pre_artifacts.sh b/tasks/task_066/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_066/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"
diff --git a/tasks/task_066/task.toml b/tasks/task_066/task.toml
index 90a1293a763ee1aaf952c3b264241d6892dbf221..f9de43927453b434727e5ce5e6ae6f3e476f78a5 100644
--- a/tasks/task_066/task.toml
+++ b/tasks/task_066/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_066"
-
-[[verifier.collect]]
-command = "cd /app/task_066 && git config --global --add safe.directory /app/task_066 && 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
diff --git a/tasks/task_067/pre_artifacts.sh b/tasks/task_067/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_067/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"
diff --git a/tasks/task_067/task.toml b/tasks/task_067/task.toml
index ccfc0f2461a70ab80ec7e9ce5449df7f3182f217..c12ece7da30bec53378cb4e8cb9c140bb7827a69 100644
--- a/tasks/task_067/task.toml
+++ b/tasks/task_067/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_067"
-
-[[verifier.collect]]
-command = "cd /app/task_067 && git config --global --add safe.directory /app/task_067 && 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
diff --git a/tasks/task_068/pre_artifacts.sh b/tasks/task_068/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_068/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"
diff --git a/tasks/task_068/task.toml b/tasks/task_068/task.toml
index 5d014489c9f5663089aeb080e319cbc5fbe4eba7..e7104c61970bec6fba6157b5a3634ffc1ffcb821 100644
--- a/tasks/task_068/task.toml
+++ b/tasks/task_068/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_068"
-
-[[verifier.collect]]
-command = "cd /app/task_068 && git config --global --add safe.directory /app/task_068 && 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
diff --git a/tasks/task_069/pre_artifacts.sh b/tasks/task_069/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_069/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"
diff --git a/tasks/task_069/task.toml b/tasks/task_069/task.toml
index 620b11ee381bb3e9345f31dea5372a9dc844c819..3fb363d0c21c097dc4707c2f190e3467817ee010 100644
--- a/tasks/task_069/task.toml
+++ b/tasks/task_069/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_069"
-
-[[verifier.collect]]
-command = "cd /app/task_069 && git config --global --add safe.directory /app/task_069 && 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
diff --git a/tasks/task_070/pre_artifacts.sh b/tasks/task_070/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_070/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"
diff --git a/tasks/task_070/task.toml b/tasks/task_070/task.toml
index 3e00a99b039e7479c6a3afaee9155e017eff6f21..e790abcd96567ecc2080afb0cd8c8a5e5b3b97ab 100644
--- a/tasks/task_070/task.toml
+++ b/tasks/task_070/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_070"
-
-[[verifier.collect]]
-command = "cd /app/task_070 && git config --global --add safe.directory /app/task_070 && 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
diff --git a/tasks/task_071/pre_artifacts.sh b/tasks/task_071/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_071/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"
diff --git a/tasks/task_071/task.toml b/tasks/task_071/task.toml
index 1601b8dd45a5dcc65ef6fb0a3d7d3c67ba6aae82..62091f147243d10eab35b02afba506711e6c99c6 100644
--- a/tasks/task_071/task.toml
+++ b/tasks/task_071/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_071"
-
-[[verifier.collect]]
-command = "cd /app/task_071 && git config --global --add safe.directory /app/task_071 && 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
diff --git a/tasks/task_072/pre_artifacts.sh b/tasks/task_072/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_072/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"
diff --git a/tasks/task_072/task.toml b/tasks/task_072/task.toml
index c6be63b49c4e61b34a13dc2865e6ce5d18b0bbf5..7ea31e87a8084184f4ea61c88474157b7e507038 100644
--- a/tasks/task_072/task.toml
+++ b/tasks/task_072/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_072"
-
-[[verifier.collect]]
-command = "cd /app/task_072 && git config --global --add safe.directory /app/task_072 && 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
diff --git a/tasks/task_073/pre_artifacts.sh b/tasks/task_073/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_073/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"
diff --git a/tasks/task_073/task.toml b/tasks/task_073/task.toml
index 1f96cb6de848f18dab3690f7dc95e2e74b7a7377..dec721a1996d7f37cd65e3ad5837f99f8910a97e 100644
--- a/tasks/task_073/task.toml
+++ b/tasks/task_073/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_073"
-
-[[verifier.collect]]
-command = "cd /app/task_073 && git config --global --add safe.directory /app/task_073 && 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
diff --git a/tasks/task_074/pre_artifacts.sh b/tasks/task_074/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_074/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"
diff --git a/tasks/task_074/task.toml b/tasks/task_074/task.toml
index 3cfe19422ba19602886c95953335b8a042272c40..e98afb2d4fa79954650e6bdd3ff9de5a5e4b14d9 100644
--- a/tasks/task_074/task.toml
+++ b/tasks/task_074/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_074"
-
-[[verifier.collect]]
-command = "cd /app/task_074 && git config --global --add safe.directory /app/task_074 && 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
diff --git a/tasks/task_075/pre_artifacts.sh b/tasks/task_075/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_075/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"
diff --git a/tasks/task_075/task.toml b/tasks/task_075/task.toml
index 443de0f521dfdcaf8d6c372c632f90c5eb95b50b..f63e1cc7aea3ab1a6d58a1ac49d202c9eee8a8a9 100644
--- a/tasks/task_075/task.toml
+++ b/tasks/task_075/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_075"
-
-[[verifier.collect]]
-command = "cd /app/task_075 && git config --global --add safe.directory /app/task_075 && 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
diff --git a/tasks/task_076/pre_artifacts.sh b/tasks/task_076/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_076/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"
diff --git a/tasks/task_076/task.toml b/tasks/task_076/task.toml
index b2c18fe8548d47596a5456a3c44d1fdae3305e0a..21734ee2ca9d9e7ded8c03e75197736658b3e544 100644
--- a/tasks/task_076/task.toml
+++ b/tasks/task_076/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_076"
-
-[[verifier.collect]]
-command = "cd /app/task_076 && git config --global --add safe.directory /app/task_076 && 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
diff --git a/tasks/task_077/pre_artifacts.sh b/tasks/task_077/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_077/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"
diff --git a/tasks/task_077/task.toml b/tasks/task_077/task.toml
index 30ebd5ef802fc719f337069c83a791ef61c846b0..d40fb98d8647095f4c5dacea43017ecc314196d9 100644
--- a/tasks/task_077/task.toml
+++ b/tasks/task_077/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_077"
-
-[[verifier.collect]]
-command = "cd /app/task_077 && git config --global --add safe.directory /app/task_077 && 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
diff --git a/tasks/task_078/pre_artifacts.sh b/tasks/task_078/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_078/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"
diff --git a/tasks/task_078/task.toml b/tasks/task_078/task.toml
index a2b819a7c2bcb4bb4ea919fbd251d33be2e0bacd..c2ba5566ebf846ebb190a32fa260c1da40accabe 100644
--- a/tasks/task_078/task.toml
+++ b/tasks/task_078/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_078"
-
-[[verifier.collect]]
-command = "cd /app/task_078 && git config --global --add safe.directory /app/task_078 && 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
diff --git a/tasks/task_079/pre_artifacts.sh b/tasks/task_079/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_079/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"
diff --git a/tasks/task_079/task.toml b/tasks/task_079/task.toml
index aeabfec9182ff995cf5adbb574542bab25816d28..c76266893b7802891a74d764f76ef0d91754be40 100644
--- a/tasks/task_079/task.toml
+++ b/tasks/task_079/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_079"
-
-[[verifier.collect]]
-command = "cd /app/task_079 && git config --global --add safe.directory /app/task_079 && 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
diff --git a/tasks/task_080/pre_artifacts.sh b/tasks/task_080/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_080/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"
diff --git a/tasks/task_080/task.toml b/tasks/task_080/task.toml
index f3ccf501792a831b70e972095e140a9f92bb6108..220fe99fcb25ed88398e7f6fdc357d9116cd2e6e 100644
--- a/tasks/task_080/task.toml
+++ b/tasks/task_080/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_080"
-
-[[verifier.collect]]
-command = "cd /app/task_080 && git config --global --add safe.directory /app/task_080 && 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
diff --git a/tasks/task_081/pre_artifacts.sh b/tasks/task_081/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_081/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"
diff --git a/tasks/task_081/task.toml b/tasks/task_081/task.toml
index c7015c51cd33005cfff047b3b87222cfe81f0019..2401f04e9a0f07d76d210079333221df20662617 100644
--- a/tasks/task_081/task.toml
+++ b/tasks/task_081/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_081"
-
-[[verifier.collect]]
-command = "cd /app/task_081 && git config --global --add safe.directory /app/task_081 && 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
diff --git a/tasks/task_082/pre_artifacts.sh b/tasks/task_082/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_082/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"
diff --git a/tasks/task_082/task.toml b/tasks/task_082/task.toml
index a9fe5d4cc6172f77b5ebeb40918a879ddf177fb0..624e656a83b170e62f017c7e7a7777b30ad2610d 100644
--- a/tasks/task_082/task.toml
+++ b/tasks/task_082/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_082"
-
-[[verifier.collect]]
-command = "cd /app/task_082 && git config --global --add safe.directory /app/task_082 && 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
diff --git a/tasks/task_083/pre_artifacts.sh b/tasks/task_083/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_083/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"
diff --git a/tasks/task_083/task.toml b/tasks/task_083/task.toml
index e9b4b9dc6127ccac192f96c751fa6b4209361a41..dbc0d3080adda7b833433651fbb4b653178ee961 100644
--- a/tasks/task_083/task.toml
+++ b/tasks/task_083/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_083"
-
-[[verifier.collect]]
-command = "cd /app/task_083 && git config --global --add safe.directory /app/task_083 && 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
diff --git a/tasks/task_084/pre_artifacts.sh b/tasks/task_084/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_084/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"
diff --git a/tasks/task_084/task.toml b/tasks/task_084/task.toml
index 032a8f5f4804f100fd5868fcdce3bacc0b05ce99..d2ee97a9ef4ae8c69a2e772cbfd9720c81ed097d 100644
--- a/tasks/task_084/task.toml
+++ b/tasks/task_084/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_084"
-
-[[verifier.collect]]
-command = "cd /app/task_084 && git config --global --add safe.directory /app/task_084 && 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
diff --git a/tasks/task_085/pre_artifacts.sh b/tasks/task_085/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_085/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"
diff --git a/tasks/task_085/task.toml b/tasks/task_085/task.toml
index 2890c8d5f6fb4bcc1886961320c9b780f421355b..e49ce1324d3c0bf4f49121b90971d0a9747bd94e 100644
--- a/tasks/task_085/task.toml
+++ b/tasks/task_085/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_085"
-
-[[verifier.collect]]
-command = "cd /app/task_085 && git config --global --add safe.directory /app/task_085 && 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
diff --git a/tasks/task_086/pre_artifacts.sh b/tasks/task_086/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_086/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"
diff --git a/tasks/task_086/task.toml b/tasks/task_086/task.toml
index 7df7419802bb6e2ef678cf36e8b1b5e777dfee33..43db963fc0cd4fbd1db323606b11bc7a57f61d32 100644
--- a/tasks/task_086/task.toml
+++ b/tasks/task_086/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_086"
-
-[[verifier.collect]]
-command = "cd /app/task_086 && git config --global --add safe.directory /app/task_086 && 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
diff --git a/tasks/task_087/pre_artifacts.sh b/tasks/task_087/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_087/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"
diff --git a/tasks/task_087/task.toml b/tasks/task_087/task.toml
index d301ebc2807b3699a38f05a9f97fe2f319051620..18a1283be3aa79f96edf7016123dc6a538e2e897 100644
--- a/tasks/task_087/task.toml
+++ b/tasks/task_087/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_087"
-
-[[verifier.collect]]
-command = "cd /app/task_087 && git config --global --add safe.directory /app/task_087 && 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
diff --git a/tasks/task_088/pre_artifacts.sh b/tasks/task_088/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_088/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"
diff --git a/tasks/task_088/task.toml b/tasks/task_088/task.toml
index ba90d29431f98dd2ed1050eb1e2b85a1b6378260..91b294e13402c8762f6cce20366894b43b31e70e 100644
--- a/tasks/task_088/task.toml
+++ b/tasks/task_088/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_088"
-
-[[verifier.collect]]
-command = "cd /app/task_088 && git config --global --add safe.directory /app/task_088 && 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
diff --git a/tasks/task_089/pre_artifacts.sh b/tasks/task_089/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_089/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"
diff --git a/tasks/task_089/task.toml b/tasks/task_089/task.toml
index bdf0169ebd3ed225c1ea7213856224ec3c2e4528..30598f1dba3fddbb6d4c564e5f3307af6bfb26f8 100644
--- a/tasks/task_089/task.toml
+++ b/tasks/task_089/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_089"
-
-[[verifier.collect]]
-command = "cd /app/task_089 && git config --global --add safe.directory /app/task_089 && 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
diff --git a/tasks/task_090/pre_artifacts.sh b/tasks/task_090/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_090/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"
diff --git a/tasks/task_090/task.toml b/tasks/task_090/task.toml
index bd4b1af5fc8825c7239caa844d9019dda048577a..31ecb7f8d5f41691e81ceccae836bad6b02a2fea 100644
--- a/tasks/task_090/task.toml
+++ b/tasks/task_090/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_090"
-
-[[verifier.collect]]
-command = "cd /app/task_090 && git config --global --add safe.directory /app/task_090 && 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
diff --git a/tasks/task_091/pre_artifacts.sh b/tasks/task_091/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_091/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"
diff --git a/tasks/task_091/task.toml b/tasks/task_091/task.toml
index 4d0465ebe84412b3f92c10ac545b089d67ad308f..7245d0360c79eb7c834740ba03d52ccc66e97549 100644
--- a/tasks/task_091/task.toml
+++ b/tasks/task_091/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_091"
-
-[[verifier.collect]]
-command = "cd /app/task_091 && git config --global --add safe.directory /app/task_091 && 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
diff --git a/tasks/task_092/pre_artifacts.sh b/tasks/task_092/pre_artifacts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ff37f1edbdb81d7de9600c78f981f09d33583aa
--- /dev/null
+++ b/tasks/task_092/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"
diff --git a/tasks/task_092/task.toml b/tasks/task_092/task.toml
index 498f5bf764c8f3c9baaeefda64e1c12493c94bad..dc000c55301a45904ef366c5770596c25d6509fc 100644
--- a/tasks/task_092/task.toml
+++ b/tasks/task_092/task.toml
@@ -38,7 +38,3 @@ cpus = 2
 memory_mb = 8192
 storage_mb = 20480
 workdir = "/app/task_092"
-
-[[verifier.collect]]
-command = "cd /app/task_092 && git config --global --add safe.directory /app/task_092 && 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