Fix baseline patch capture before verifier (part 3)

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"

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

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"

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

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"

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

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"

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

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"

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

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"

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

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"

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

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"

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

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"

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

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"

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

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"

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

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"

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

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"

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

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"

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

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"

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

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"

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

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"

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

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"

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

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"

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

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"

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

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"

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

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"

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

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"

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

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"

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

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"

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