Add dataset patchers and remove redundant CrossCodeEval image manifest

Keep image references embedded in task Parquets. Include required SWE-Lego repair assets and Scale SWE exclusion inputs so their patchers remain reproducible. Existing task payloads, archives and cached images are unchanged.

EndlessTerminals_environment-reliable/patch.py

@@ -0,0 +1,1746 @@
+"""Preserve ET build recipes while lowering Docker syntax for Harbor Apptainer.
+
+Task transformations, pilot selection and read-only state probes live here.
+Reviewed finite entrypoint initialization runs through task setup; dependencies stay in images.
+No package unions. Source-bound oracle resource/pip repairs preserve verifier assertions.
+"""
+from __future__ import annotations
+
+import argparse
+import asyncio
+import base64
+import collections
+import copy
+import hashlib
+import io
+import json
+import os
+from pathlib import Path, PurePosixPath
+import posixpath
+import re
+import shlex
+import subprocess
+import sys
+import tarfile
+import tomllib
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+
+REVISION = '26ecf78458e7f756e4d06780d5fbf3dd78e91815'
+SOURCE_SHA256 = '9b4d72b139e235aa64335b6a4b2511b7e710864e0f48b4e6669d2a689ca65490'
+VERSION = 'et-apptainer-build-v6'
+STATIC_VERSION = 'et-static-repairs-v2'
+JSONSCHEMA_SOURCE_SHA256 = '14d0e5189ed8001724d4eaaee202ee56b3c40299d38a13b6d5319b7d532cc8af'
+PIN_REPAIRS = json.loads(r'''{
+  "evidence": [
+    "pilot-validation/submissions/1941f174284d/evidence.tar.gz",
+    "pin-followup-validation/submissions/0ca6f3556148/evidence.tar.gz",
+    "final-pilot-validation/submissions/865a72be0dbc/evidence.tar.gz"
+  ],
+  "requirement": "reward-1 oracle followed by freeze --all; normal stage-4 rerun after generated pins",
+  "tasks": {
+    "task_000000_047019b5": {
+      "script_sha256": "cde44e3f0def2f6d66ee2a14dc87c2711ee46aa2e2642fe3f25c6e907388b1ae",
+      "edits": [
+        {
+          "requirement": "wheel",
+          "start": 316,
+          "end": 321,
+          "original": "wheel",
+          "file": "solution/solve.sh",
+          "replacement": "wheel==0.48.0"
+        }
+      ]
+    },
+    "task_000000_3e17389f": {
+      "script_sha256": "92a66f5cbf881225bf2bde56c499cedbebdcfbee73e42df764c6691f564741a4",
+      "edits": [
+        {
+          "requirement": "pip",
+          "start": 3771,
+          "end": 3774,
+          "original": "pip",
+          "file": "solution/solve.sh",
+          "replacement": "pip==26.2.1"
+        },
+        {
+          "requirement": "setuptools",
+          "start": 3775,
+          "end": 3785,
+          "original": "setuptools",
+          "file": "solution/solve.sh",
+          "replacement": "setuptools==84.0.0"
+        },
+        {
+          "requirement": "wheel",
+          "start": 3786,
+          "end": 3791,
+          "original": "wheel",
+          "file": "solution/solve.sh",
+          "replacement": "wheel==0.48.0"
+        }
+      ]
+    },
+    "task_000000_9aa135c8": {
+      "script_sha256": "2dd3485a8ab55ba0d3609ee1acca470c2d2132ae7db305e461814aae423e73c8",
+      "edits": [
+        {
+          "requirement": "pip",
+          "start": 484,
+          "end": 487,
+          "original": "pip",
+          "file": "solution/solve.sh",
+          "replacement": "pip==26.2.1"
+        },
+        {
+          "requirement": "setuptools",
+          "start": 488,
+          "end": 498,
+          "original": "setuptools",
+          "file": "solution/solve.sh",
+          "replacement": "setuptools==84.0.0"
+        },
+        {
+          "requirement": "requests",
+          "start": 843,
+          "end": 851,
+          "original": "requests",
+          "file": "solution/solve.sh",
+          "replacement": "requests==2.34.2"
+        }
+      ]
+    },
+    "task_000000_f4935f25": {
+      "script_sha256": "8286b9a57a6f152794b826a0bc3cb696a7d0938f0469997cfbe46efee6196156",
+      "edits": [
+        {
+          "requirement": "pulp",
+          "start": 65,
+          "end": 69,
+          "original": "pulp",
+          "file": "solution/solve.sh",
+          "replacement": "pulp==3.3.2"
+        }
+      ]
+    },
+    "task_000000_1bb9cf9f": {
+      "script_sha256": "0ea7ab1b42e698d0add1e0053c257cb20571f19b7d2385d56cbf9e3152c1d226",
+      "edits": [
+        {
+          "requirement": "psutil",
+          "start": 1380,
+          "end": 1386,
+          "original": "psutil",
+          "file": "solution/solve.sh",
+          "replacement": "psutil==7.2.2"
+        }
+      ]
+    },
+    "task_000000_ce45e6d1": {
+      "script_sha256": "da0c7278bdaaa13680cc53b7ce1ca6aba7b36f7539068844bf016cf575737e41",
+      "edits": [
+        {
+          "requirement": "pandas",
+          "start": 142,
+          "end": 148,
+          "original": "pandas",
+          "file": "solution/solve.sh",
+          "replacement": "pandas==2.3.3"
+        },
+        {
+          "requirement": "boto3",
+          "start": 149,
+          "end": 154,
+          "original": "boto3",
+          "file": "solution/solve.sh",
+          "replacement": "boto3==1.43.114"
+        }
+      ]
+    },
+    "task_000000_efb4f0f7": {
+      "script_sha256": "85e83e999fb64cf7fcc6a15168be78aad684415c7a870fc0229ea1c87a08c606",
+      "edits": [
+        {
+          "requirement": "ping3",
+          "start": 191,
+          "end": 196,
+          "original": "ping3",
+          "file": "solution/solve.sh",
+          "replacement": "ping3==5.1.6"
+        },
+        {
+          "requirement": "ping3",
+          "start": 1975,
+          "end": 1980,
+          "original": "ping3",
+          "file": "solution/solve.sh",
+          "replacement": "ping3==5.1.6"
+        },
+        {
+          "requirement": "ping3",
+          "start": 3987,
+          "end": 3992,
+          "original": "ping3",
+          "file": "solution/solve.sh",
+          "replacement": "ping3==5.1.6"
+        },
+        {
+          "requirement": "ping3",
+          "start": 8612,
+          "end": 8617,
+          "original": "ping3",
+          "file": "solution/solve.sh",
+          "replacement": "ping3==5.1.6"
+        },
+        {
+          "requirement": "ping3",
+          "start": 9146,
+          "end": 9151,
+          "original": "ping3",
+          "file": "solution/solve.sh",
+          "replacement": "ping3==5.1.6"
+        }
+      ]
+    },
+    "task_000000_b5807114": {
+      "script_sha256": "14d0e5189ed8001724d4eaaee202ee56b3c40299d38a13b6d5319b7d532cc8af",
+      "edits": [
+        {
+          "requirement": "jsonschema",
+          "start": 852,
+          "end": 862,
+          "original": "jsonschema",
+          "file": "solution/solve.sh",
+          "replacement": "jsonschema==4.26.0"
+        },
+        {
+          "requirement": "jsonschema",
+          "start": 3051,
+          "end": 3061,
+          "original": "jsonschema",
+          "file": "solution/solve.sh",
+          "replacement": "jsonschema==4.26.0"
+        },
+        {
+          "requirement": "jsonschema",
+          "start": 5492,
+          "end": 5502,
+          "original": "jsonschema",
+          "file": "solution/solve.sh",
+          "replacement": "jsonschema==4.26.0"
+        }
+      ]
+    }
+  }
+}''')
+# These are source-bound solution edits. They change resource selection only,
+# preserving the commands which produce and verify the task's requested outputs.
+CPU_REPAIRS = {
+    'task_000000_0b92c5c3': '8985fce1b8097c9bde8c2e44f53b91ac477932586f7178f6307624927fd80928',
+    'task_000000_27030ede': 'dc43dba54353cb7e997c80f815007136cee815bd89870eacf5cb8278b0e9d8fd',
+    'task_000000_b3ae7cf7': '4acc4b9d5212c5b4b03ead5e11f71761a804078ece9ca05b23fede475d0aabe6',
+    'task_000000_bffd5dd1': '0e13aa67639020670aa7cc5bad61b9ab9550bacaec229f61b7fbf989990871d2',
+    'task_000000_bc9c5a3e': 'f1df4fc2b9bb50808d832b113a7cfbe6b99ae33b0b28f9e8aeaea74e00f1993c',
+}
+REVIEWED_EXCLUSIONS = {
+    'task_000000_9719b9f3': {
+        'source_sha256': 'ab1c146763ad2acd0476342110a1c053db29157853f4cb8a5106b2ff4c7b949f',
+        'category': 'reference-solution-integrity',
+        'reason': ('The source oracle installs an empty yaml.py as PyYAML 5.4.1. The recorded oracle '
+                   'trajectory executes this replacement and still receives reward 1. It does not '
+                   'satisfy the instruction to install the actual PyYAML package; version-only grading '
+                   'accepts a placeholder. Retain the original task in the archive for verifier/reference repair.'),
+    },
+    'task_000000_bc9c5a3e': {
+        'source_sha256': '6d68d66fb8a8b71e098ea0648200f211fab0d9c841c758bb3119b3f715f153f9',
+        'category': 'reference-solution-reward-zero',
+        'reason': ('On the tested Helma/Apptainer profile, exactly five ICMP requests to 8.8.8.8 '
+                   'produce no latency sample. Both original and CPU-repaired references score 0: '
+                   'the latency field is empty and the summary JSON is invalid. This is a '
+                   'profile-specific exclusion, not a claim that the task is universally unsolvable.'),
+    },
+}
+BASE_PATH = '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin'
+OPS = set('FROM RUN ENV WORKDIR USER LABEL CMD ENTRYPOINT'.split())
+CACHE_TARGETS = {'/var/cache/apt', '/var/lib/apt', '/root/.cache/pip'}
+WORKDIR_BASE_ROOT = '/home'
+VERIFIER_VERSION = 'et-offline-verifier-v1'
+ORIGINAL_TEST_SH_SHA256 = '52d87e5cb768634d6a7bda203b72ea77c802fdb9e8700d3d7cdcf631080c3298'
+REVIEWED_REPAIRS = json.loads(r'''{
+  "instructions": {
+    "task_000000_3a08bb12": {
+      "description_sha256": "0a129d48079da193c54a51abfc1e27f7e3aa42909712c816cb98306f185d7ed3",
+      "instruction_sha256": "a5bf7db83bbb192cbd1dad89129970caa07bf5b8d899fa04b418ea57088493fd"
+    },
+    "task_000000_84d4748a": {
+      "description_sha256": "861cdd02b2e583ae5efc110327f61556f72e7360fe7254d07e7c13b60d4c08d0",
+      "instruction_sha256": "75e295224630da03eab1acd79e624c1344e1d0809eb8915b6784430dfbc53e45"
+    },
+    "task_000000_c40b78a6": {
+      "description_sha256": "99faf2ba1dbcb1feccd02aba3071bc4a1881adaf5ef424d7021b00ebfa8a7703",
+      "instruction_sha256": "83a83a509eec61b4c7658820983e8d3dc6d4016e9491ca35bac09b286da55662"
+    },
+    "task_000000_e24cd12d": {
+      "description_sha256": "acb37e963b3ee578144105f5f588506d063b129ee3b76c0b0dcffc75ec3c8b8f",
+      "instruction_sha256": "365c16bea2fa4ca234db867960f18b81bec1501b55d59f1c5f7fca2c69351516"
+    },
+    "task_000000_e9aac96e": {
+      "description_sha256": "72ee9078822892887fae1a2c74fb95fbfe633a7cf28dc6bdb0de8ded889cb0b4",
+      "instruction_sha256": "8d39c133ecfd197c4083d60fb61fe0e212556ff638675a953c7488711f6c33aa"
+    }
+  },
+  "revision": "26ecf78458e7f756e4d06780d5fbf3dd78e91815",
+  "timestamps": {
+    "task_000000_44c20928": {
+      "commands": [
+        {
+          "cwd": "/",
+          "env": {
+            "HOME": "/root",
+            "PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
+          },
+          "script": "BASE=/home/user/storage && touch -d \"3 days ago\"  ${BASE}/incoming/project1/keep.txt && touch -d \"2 days ago\"  ${BASE}/incoming/project1/large.bak && touch -d \"15 days ago\" ${BASE}/incoming/project1/old.txt && touch -d \"12 days ago\" ${BASE}/incoming/project2/archive.txt && touch -d \"1 day ago\"   ${BASE}/incoming/project2/temp2.bak",
+          "source_line": 13
+        }
+      ],
+      "source_sha256": "0831fe61449aad85038dba7f925b93b116f1004942521fcd90aea6efe64547fe"
+    },
+    "task_000000_5cc0f6f2": {
+      "commands": [
+        {
+          "cwd": "/",
+          "env": {
+            "HOME": "/root",
+            "PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
+          },
+          "script": "OLD_TIMESTAMP=\"202001010000\" && touch -m -d '1 day ago' /home/user/audit_targets/webserver/newhttpd.conf && touch -m -d '1 day ago' /home/user/audit_targets/app/settings/recent.conf",
+          "source_line": 58
+        }
+      ],
+      "source_sha256": "6018318699692c694629f159c8b82a5c26ccdff6463acdcb4837d9f16218175f"
+    },
+    "task_000000_6723c42c": {
+      "commands": [
+        {
+          "cwd": "/",
+          "env": {
+            "HOME": "/root",
+            "PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
+          },
+          "script": "touch -d \"1 hour ago\" /home/user/app/logs/serviceA.log",
+          "source_line": 19
+        },
+        {
+          "cwd": "/",
+          "env": {
+            "HOME": "/root",
+            "PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
+          },
+          "script": "touch -d \"25 hours ago\" /home/user/app/logs/serviceB.log",
+          "source_line": 23
+        },
+        {
+          "cwd": "/",
+          "env": {
+            "HOME": "/root",
+            "PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
+          },
+          "script": "touch -d \"9 days ago\" /home/user/app/logs/old/serviceC.log",
+          "source_line": 27
+        }
+      ],
+      "source_sha256": "63f73cf6fd9eaf323291477c17d62c747986d2175a218195a9895d4cdd10e4ad"
+    },
+    "task_000000_87d17935": {
+      "commands": [
+        {
+          "cwd": "/",
+          "env": {
+            "HOME": "/root",
+            "PATH": "/home/user/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
+          },
+          "script": "TEN_DAYS_AGO=$(date -d '10 days ago' '+%Y%m%d%H%M.%S') && touch -t \"$TEN_DAYS_AGO\" /home/user/experiments/exp_alpha && touch -t \"$TEN_DAYS_AGO\" /home/user/experiments/exp_alpha/model.bin && touch -t \"$TEN_DAYS_AGO\" /home/user/experiments/exp_beta && touch -t \"$TEN_DAYS_AGO\" /home/user/experiments/exp_beta/model.chk && touch -t \"$TEN_DAYS_AGO\" /home/user/experiments/exp_gamma && touch -t \"$TEN_DAYS_AGO\" /home/user/experiments/exp_gamma/metrics.json",
+          "source_line": 39
+        }
+      ],
+      "source_sha256": "77435bfa229063d1a7054961f1667d2b236c606c4c163b3693a9307d12c75b7d"
+    },
+    "task_000000_9ba2b0a3": {
+      "commands": [
+        {
+          "cwd": "/",
+          "env": {
+            "HOME": "/root",
+            "PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
+          },
+          "script": "touch -d '3 days ago' /home/user/apps/logs/app1.log && touch -d '3 days ago' /home/user/apps/logs/app2.log && touch -d '5 days ago' /home/user/apps/logs/old/old.log",
+          "source_line": 21
+        }
+      ],
+      "source_sha256": "8d52db4d19f8e2df563d6eab03d5d3edbb0fd979262bd2fe0d1e38e8dd12c45d"
+    },
+    "task_000000_aac3d4dd": {
+      "commands": [
+        {
+          "cwd": "/",
+          "env": {
+            "HOME": "/root",
+            "PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
+          },
+          "script": "touch -d \"30 days ago\" /home/user/projects/microservices/serviceA/scripts/deploy.sh && touch -d \"20 days ago\" /home/user/projects/microservices/serviceB/scripts/restart.sh && touch -d \"91 days ago\" /home/user/projects/microservices/serviceC/scripts/cleanup.sh",
+          "source_line": 69
+        }
+      ],
+      "source_sha256": "bd898e6a7c435932b701ff9e7007c1db81ee98294f8fbb887b0a98359054a240"
+    },
+    "task_000000_c0d576aa": {
+      "commands": [
+        {
+          "cwd": "/",
+          "env": {
+            "HOME": "/root",
+            "PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
+          },
+          "script": "touch -d \"10 days ago\" /home/user/repositories/repoA/nested/sample-archive.tar.gz && touch -d \"20 days ago\" /home/user/repositories/repoB/data-1.1.tar.gz",
+          "source_line": 39
+        }
+      ],
+      "source_sha256": "29227f37b8fe593d13830d74382262900e2c008e405897f72e1f5fa139e15d42"
+    },
+    "task_000000_d314a7d5": {
+      "commands": [
+        {
+          "cwd": "/",
+          "env": {
+            "DEBIAN_FRONTEND": "noninteractive",
+            "HOME": "/root",
+            "PATH": "/usr/local/bin:/usr/bin:/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+            "PYTHONIOENCODING": "utf-8"
+          },
+          "script": "touch -d \"2 days ago\"  /home/user/db/queries/daily/report.sql && touch -d \"10 days ago\" /home/user/db/queries/archive/old_report.sql && touch -d \"10 days ago\" /home/user/db/queries/maintenance/cleanup.sql",
+          "source_line": 48
+        }
+      ],
+      "source_sha256": "0957ec33c28b59295ec76e9433f3d658beaf855d23600b6f812fc6157389f59e"
+    },
+    "task_000000_d3ad8877": {
+      "commands": [
+        {
+          "cwd": "/",
+          "env": {
+            "HOME": "/root",
+            "PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
+          },
+          "script": "touch -d '2 days ago' /home/user/configs/nginx/nginx.conf && touch -d '2 days ago' /home/user/configs/nginx/sites-available/default.conf && touch -d '2 days ago' /home/user/configs/app/app.conf && touch -d '2 days ago' /home/user/configs/app/db/database.conf && touch -d '90 days ago' /home/user/configs/obsolete/old.conf",
+          "source_line": 41
+        }
+      ],
+      "source_sha256": "c2ff26b4d8a9625e68dd55b388abd5d1b7a4fd3c7c666985bd254b4f8419833b"
+    },
+    "task_000000_da9fb171": {
+      "commands": [
+        {
+          "cwd": "/",
+          "env": {
+            "HOME": "/root",
+            "PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
+          },
+          "script": "touch -d \"$(date -d '10 days ago')\" /home/user/mobile-build/logs/build-20230901.log && touch -d \"$(date -d '9 days ago')\"  /home/user/mobile-build/logs/test-20230902.log",
+          "source_line": 32
+        }
+      ],
+      "source_sha256": "96d5741a2be65d6207ac7f6f6d40b182e1d851995a458bfc7bf50074a5f3dbdd"
+    },
+    "task_000000_fba47f66": {
+      "commands": [
+        {
+          "cwd": "/",
+          "env": {
+            "HOME": "/root",
+            "PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
+          },
+          "script": "BASE=/home/user/workspace && BUILDS=${BASE}/builds && ARTIFACTS=${BUILDS}/artifacts && ARCHIVE=${BUILDS}/archive && touch -d '10 days ago'         \"${ARTIFACTS}/app-core-1.0.0.jar\"         \"${ARTIFACTS}/app-core-1.1.0.jar\"         \"${ARTIFACTS}/lib-util-2.0.0.jar\"",
+          "source_line": 26
+        },
+        {
+          "cwd": "/",
+          "env": {
+            "HOME": "/root",
+            "PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
+          },
+          "script": "touch -d '1 hour ago' /home/user/workspace/builds/artifacts/fresh-feature-9999.jar /home/user/workspace/builds/artifacts/README.txt",
+          "source_line": 53
+        }
+      ],
+      "source_sha256": "68ddfd6a2462f3437a12099fd93c1f38c529fd1a0240e43c39a7852f587b40f6"
+    }
+  }
+}''')
+# Directory timestamp replay in 87d17935 regressed the archive oracle in the
+# Apptainer pilot. All of its fixtures already exceed the seven-day cutoff.
+# Keep its reviewed source record above, but do not apply the runtime refresh.
+WITHHELD_TIMESTAMP_REPAIRS = {'task_000000_87d17935': 'directory timestamp refresh regressed the oracle pilot'}
+for withheld in WITHHELD_TIMESTAMP_REPAIRS:
+    REVIEWED_REPAIRS['timestamps'].pop(withheld)
+
+VERIFIER_INSTALL = (
+    '/usr/bin/python3 -m pip install --no-cache-dir --target /opt/et-verifier/uv uv==0.9.5 && '
+    'UV_PYTHON_PREFERENCE=only-managed UV_PYTHON_INSTALL_DIR=/opt/et-verifier/python '
+    '/opt/et-verifier/uv/bin/uv venv --no-cache --python 3.12 /opt/et-verifier/venv && '
+    '/opt/et-verifier/uv/bin/uv pip install --no-cache --python '
+    '/opt/et-verifier/venv/bin/python pytest==8.4.1 && '
+    '/bin/rm -rf /opt/et-verifier/uv && /bin/chmod -R a+rX /opt/et-verifier\n')
+OFFLINE_TEST_SH = b'''#!/bin/bash
+# et-offline-verifier-v1: same isolated Python/pytest; no grading-time downloads.
+mkdir -p /logs/verifier || exit $?
+rm -f /logs/verifier/reward.txt /logs/verifier/reward.json || exit $?
+cd /home/user || exit $?
+export PATH="/opt/et-verifier/venv/bin:$PATH"
+/opt/et-verifier/venv/bin/pytest /tests/test_final_state.py -v
+rc=$?
+rm -f /logs/verifier/reward.txt /logs/verifier/reward.json || exit $?
+case "$rc" in
+  0) echo 1 > /logs/verifier/reward.txt ;;
+  1) echo 0 > /logs/verifier/reward.txt ;;
+  *) echo "VERIFIER_ERROR pytest_exit=$rc" >&2; exit "$rc" ;;
+esac
+'''
+PILOT = (
+    'task_000000_0033979a',  # Quoted heredoc, file contents and modes.
+    'task_000000_12ddbd87',  # FROM text inside a heredoc.
+    'task_000000_54d91f57',  # All three BuildKit caches, mixed RUN.
+    'task_000000_31275728',  # Changing WORKDIRs, git initialization.
+    'task_000000_16a4ec74',  # Arithmetic expansion unsupported by the prior AST parser.
+    'task_000000_25cc9764',  # PYTHONUSERBASE and explicit runtime cwd.
+    'task_000000_bed13ee1',  # su, numeric ownership, SQLite initialization.
+    'task_000000_13fbab8c',  # Explicit non-root USER, retained runtime limitation.
+    'task_000000_c6317e51',  # Dummy curl package, preserve package and executable.
+    'task_000000_155368e9',  # Exact pip version control.
+)
+# Reviewed finite entrypoints, bound to complete source Dockerfile bytes.
+# Run their initialization with /bin/true as the payload instead of a long-lived shell.
+STARTUP_REPAIRS = {
+    'task_000000_0119f5d7': '9321c4079e1f8ed8ae6dc7176143d5a37ef2cd3eb1f6cff060b5856e992bdeaa',
+    'task_000000_089a919e': '24898e7507f4290b6d5ddf171f1c80cdd3eb9f12794685a3d00f911c6b3d496a',
+    'task_000000_1925b899': '88674712612d4764d4eb6506911d546104d303b34b4852255f3187144e89dcc6',
+    'task_000000_4c58315f': '4cb548b2e208d87130ff3146744f2cca30f2ff21be6a60d3f35cbe65099391e8',
+    'task_000000_c66c3f8e': '54f837cadacae997f63503989e6d57556a9d84ee9ce4b53b934208e306adc978',
+    'task_000000_da9fb171': '96d5741a2be65d6207ac7f6f6d40b182e1d851995a458bfc7bf50074a5f3dbdd',
+}
+STARTUP_PILOT = tuple(STARTUP_REPAIRS)
+
+# Reviewed directly against the pinned sample Dockerfiles, not their verifiers.
+# These checks complement general observations, which cannot infer arbitrary
+# shell/interpreter effects from static path matches.
+PILOT_STATE = {
+    'task_000000_0119f5d7': {'/home/user': {'mode': '0o755', 'uid': 0, 'gid': 0}},
+    'task_000000_1925b899': {'/home/user': {'mode': '0o755', 'uid': 0, 'gid': 0}},
+    'task_000000_089a919e': {
+        '/home/user': {'mode': '0o755', 'uid': 0, 'gid': 0},
+        **{f'/home/user/cloud_costs/raw_costs_{month}.csv': {
+            'mode': '0o644', 'uid': 0, 'gid': 0,
+            'sha256': hashlib.sha256(b'cloud_costs_placeholder\n').hexdigest(),
+        } for month in ('Jan', 'Feb', 'Mar')},
+        '/home/user/cloud_costs/quarterly_2023_Q1': {'absent': True},
+        '/home/user/cloud_costs/permission_changes.log': {'absent': True},
+    },
+    'task_000000_0033979a': {
+        '/home/user': {'mode': '0o777', 'uid': 0, 'gid': 0},
+        '/home/user/insecure_config': {'mode': '0o755', 'uid': 0, 'gid': 0},
+        '/home/user/insecure_config/sshd_config': {'mode': '0o644', 'uid': 0, 'gid': 0},
+    },
+    'task_000000_bed13ee1': {
+        '/home/user': {'mode': '0o755', 'uid': 1000, 'gid': 1000},
+        '/home/user/pipelines': {'mode': '0o770', 'uid': 1000, 'gid': 1000},
+        '/home/user/pipelines/app_builds.db': {'mode': '0o660', 'uid': 1000, 'gid': 1000},
+        '/tmp/init_builds.sql': {'absent': True},
+    },
+    'task_000000_13fbab8c': {'/home/user': {'mode': '0o755', 'uid': 1000, 'gid': 1000}},
+    'task_000000_16a4ec74': {
+        '/home/user': {'mode': '0o755', 'uid': 0, 'gid': 0},
+        '/home/user/sample_db_data': {'mode': '0o755'},
+        '/home/user/sample_db_data/customers.csv': {
+            'mode': '0o755', 'sha256': hashlib.sha256(('id,name\n' + ''.join(
+                f'{i},Customer_{i}\n' for i in range(1, 50))).encode()).hexdigest()},
+        '/home/user/sample_db_data/orders.csv': {
+            'mode': '0o755', 'sha256': hashlib.sha256(('id,customer_id,total\n' + ''.join(
+                f'{i},{i % 49 + 1},{i * 10}\n' for i in range(1, 100))).encode()).hexdigest()},
+        '/home/user/sample_db_data/products.csv': {
+            'mode': '0o755', 'sha256': hashlib.sha256(('id,name,price\n' + ''.join(
+                f'{i},Product_{i},{i * 5}\n' for i in range(1, 30))).encode()).hexdigest()},
+        '/home/user/backup_benchmark': {'absent': True},
+    },
+    'task_000000_31275728': {
+        '/home/user': {'mode': '0o755', 'uid': 0, 'gid': 0},
+        '/home/user/projects/policy-docs/.git/HEAD': {
+            'sha256': hashlib.sha256(b'ref: refs/heads/master\n').hexdigest()},
+        '/home/user/projects/policy-docs/policy.md': {
+            'sha256': hashlib.sha256(b'# Company Security Policy\n\nThis repository contains security-related policies.\nPlease read carefully and follow all rules.\n\n').hexdigest()},
+    },
+    'task_000000_155368e9': {'/home/user': {'mode': '0o755', 'uid': 0, 'gid': 0}},
+    'task_000000_c6317e51': {
+        '/usr/bin/curl': {'link': '/bin/true', 'uid': 0, 'gid': 0},
+        '/home/user': {'mode': '0o777', 'uid': 0, 'gid': 0},
+        '/tmp/curlpkg': {'absent': True},
+    },
+    # Extra cleanup control, selected with prepare-pilot --task.
+    'task_000000_707e607e': {
+        '/tmp/auth.log.csv': {'absent': True},
+        '/tmp/network.log.csv': {'absent': True},
+        '/tmp/processes.json': {'absent': True},
+        '/home/user/ir_data/logs_bundle.zip': {'mode': '0o666', 'uid': 0, 'gid': 0},
+    },
+}
+
+
+def digest(data):
+    return hashlib.sha256(data).hexdigest()
+
+
+def save(path, value):
+    path.write_text(json.dumps(value, indent=2, sort_keys=True) + '\n')
+
+
+class Unsupported(ValueError):
+    """Preserve and report source programs whose interpretation is unresolved."""
+
+
+def heredocs(header):
+    """Locate shell heredoc operators outside quotes, without parsing bodies."""
+    result, quote, index = [], None, 0
+    while index < len(header):
+        char = header[index]
+        if char == '\\' and quote != "'":
+            index += 2
+            continue
+        if quote:
+            if char == quote:
+                quote = None
+            index += 1
+            continue
+        if char in "'\"":
+            quote = char
+            index += 1
+            continue
+        if char == '#' and (index == 0 or header[index - 1].isspace()):
+            break
+        if header.startswith('<<<', index):
+            raise Unsupported('RUN uses a here-string outside the supported Docker /bin/sh grammar')
+        if header.startswith('<<', index):
+            match = re.match(r'''<<(?P<tabs>-?)\s*(?P<q>['"]?)(?P<name>[A-Za-z_][A-Za-z0-9_.-]*)(?P=q)(?=\s|[;&|<>]|$)''', header[index:])
+            if not match:
+                raise Unsupported('Unrecognized heredoc delimiter')
+            result.append({'delimiter': match['name'], 'strip_tabs': bool(match['tabs']),
+                           'quoted': bool(match['q'])})
+            index += len(match[0])
+            continue
+        index += 1
+    return result
+
+
+def parse_dockerfile(text):
+    """Consume complete instructions before interpreting any directive."""
+    lines, index, result = text.splitlines(keepends=True), 0, []
+    while index < len(lines):
+        start = index
+        line = lines[index].rstrip('\r\n')
+        index += 1
+        if not line.strip() or line.lstrip().startswith('#'):
+            if line.lower().lstrip().startswith('# escape=') and not line.endswith('\\'):
+                raise Unsupported('Non-default Docker escape directive')
+            continue
+        parts = [line]
+        while parts[-1].rstrip().endswith('\\'):
+            parts[-1] = parts[-1].rstrip()[:-1]
+            while index < len(lines):
+                following = lines[index].rstrip('\r\n')
+                index += 1
+                if following.strip() and not following.lstrip().startswith('#'):
+                    break
+            else:
+                raise Unsupported('Dangling Docker continuation')
+            parts.append(following)
+        header = ''.join(parts).strip()
+        match = re.fullmatch(r'([A-Za-z]+)(?:\s+(.*))?', header)
+        if not match or match[1].upper() not in OPS:
+            raise Unsupported(f'Unsupported Docker instruction at line {start + 1}: {header[:100]}')
+        op, value = match[1].upper(), match[2] or ''
+        docs, tail = heredocs(value) if op == 'RUN' else [], []
+        for doc in docs:
+            body = []
+            while index < len(lines):
+                raw = lines[index]
+                index += 1
+                tail.append(raw)
+                check = raw.rstrip('\r\n')
+                if doc['strip_tabs']:
+                    check = check.lstrip('\t')
+                if check == doc['delimiter']:
+                    break
+                body.append(raw)
+            else:
+                raise Unsupported('Unclosed heredoc: ' + doc['delimiter'])
+            doc['body'] = ''.join(body)
+        result.append({'op': op, 'value': value, 'line': start + 1,
+                       'raw': ''.join(lines[start:index]), 'tail': ''.join(tail), 'heredocs': docs})
+    if not result or result[0]['op'] != 'FROM' or sum(i['op'] == 'FROM' for i in result) != 1:
+        raise Unsupported('Expected exactly one initial FROM')
+    if result[0]['value'] != 'ubuntu:22.04':
+        raise Unsupported('Only the pinned ET Ubuntu 22.04 source is supported')
+    return result
+
+
+def docker_words(value, env):
+    """Docker ENV quoting/expansion, with no shell evaluation or command substitution.
+
+    The ET source uses simple $name/${name}; other parameter operators fail closed.
+    All assignments in one ENV instruction expand against the preceding environment.
+    """
+    words, word, quote, index, active = [], '', None, 0, False
+    while index < len(value):
+        char = value[index]
+        if char == '\\' and quote != "'":
+            index += 1
+            if index == len(value):
+                raise Unsupported('Trailing ENV escape')
+            word += value[index]
+            active = True
+        elif char in "'\"" and (quote is None or char == quote):
+            quote = None if quote else char
+            active = True
+        elif char.isspace() and quote is None:
+            if active:
+                words.append(word)
+                word, active = '', False
+        elif char == '$' and quote != "'":
+            match = re.match(r'\$(?:\{([A-Za-z_][A-Za-z0-9_]*)\}|([A-Za-z_][A-Za-z0-9_]*))', value[index:])
+            if match:
+                word += env.get(match[1] or match[2], '')
+                index += len(match[0]) - 1
+            elif value[index:index + 2] == '${':
+                raise Unsupported('Unsupported Docker variable expansion')
+            else:
+                word += char  # Docker ENV does not evaluate $(commands).
+            active = True
+        else:
+            word += char
+            active = True
+        index += 1
+    if quote:
+        raise Unsupported('Unclosed Docker quote')
+    if active:
+        words.append(word)
+    return words
+
+
+def shell_command(script, env, cwd, keys):
+    """Transport complete shell bytes through the line-oriented converter.
+
+    RUN shells remain separate. env -u prevents final Docker ENV settings being
+    injected into earlier RUNs by the existing builder. Never add shell -e to the
+    source program: a source RUN's own final exit status determines success.
+    """
+    encoded = base64.b64encode(script.encode()).decode()
+    assignments = ['-u ' + shlex.quote(key) for key in sorted(keys)]
+    assignments += [shlex.quote(key + '=' + value) for key, value in sorted(env.items())]
+    return (f'cd {shlex.quote(cwd)} && /usr/bin/env ' + ' '.join(assignments)
+            + ' /bin/sh -c "$(/usr/bin/printf %s ' + encoded + ' | /usr/bin/base64 -d)"')
+
+
+def cache_script(command, targets, root):
+    """Emulate the three observed disposable cache mounts within one image build.
+
+    Cache contents persist across mounted RUNs, but underlying image directories
+    are restored after each RUN. In particular, never delete /var/lib/apt wholesale
+    as a substitute for unmounting it. No shared/host cache is used.
+    """
+    lines = ['set -eu']
+    for index, target in enumerate(targets):
+        key = digest(target.encode())[:16]
+        cache, backup = f'{root}/{key}.cache', f'{root}/{key}.original'
+        q, c, b = map(shlex.quote, (target, cache, backup))
+        lines += [f'test ! -L {q}', f'mkdir -p {shlex.quote(root)} {shlex.quote(posixpath.dirname(target))}',
+                  f'if test -e {q}; then test -d {q}; mv {q} {b}; fi',
+                  f'if test -d {c}; then mv {c} {q}; else mkdir -m 0755 {q}; fi']
+    lines += ['set +e', '/bin/sh -c ' + shlex.quote(command), 'et_status=$?', 'set -e']
+    for target in reversed(targets):
+        key = digest(target.encode())[:16]
+        q, c, b = map(shlex.quote, (target, f'{root}/{key}.cache', f'{root}/{key}.original'))
+        lines += [f'if test -d {q}; then mv {q} {c}; fi',
+                  f'if test -d {b}; then mv {b} {q}; else mkdir -p {q}; fi']
+    lines.append('exit "$et_status"')
+    return '\n'.join(lines) + '\n'
+
+
+def split_mounts(value):
+    targets = []
+    while value.startswith('--'):
+        option, separator, value = value.partition(' ')
+        if not separator or not option.startswith('--mount='):
+            raise Unsupported('Unsupported RUN option: ' + option)
+        pairs = [part.split('=', 1) for part in option[8:].split(',')]
+        if any(len(pair) != 2 for pair in pairs):
+            raise Unsupported('Unsupported cache mount option')
+        spec = dict(pairs)
+        target = spec.get('target')
+        if (len(spec) != len(pairs) or spec.get('type') != 'cache' or target not in CACHE_TARGETS
+                or set(spec) - {'type', 'target', 'sharing'}
+                or spec.get('sharing', 'shared') not in ('locked', 'shared') or target in targets):
+            raise Unsupported('Unreviewed mount: ' + option)
+        targets.append(target)
+        value = value.lstrip()
+    return value, targets
+
+
+def compile_dockerfile(text):
+    instructions = parse_dockerfile(text)
+    env, cwd, user = {'PATH': BASE_PATH}, '/', 'root'
+    keys = {'PATH', 'HOME'}
+    for item in instructions:
+        if item['op'] == 'ENV':
+            for token in shlex.split(item['value']):
+                key = token.partition('=')[0]
+                if not re.fullmatch(r'[A-Za-z_][A-Za-z0-9_]*', key) or '=' not in token:
+                    raise Unsupported('Only ENV key=value syntax is supported')
+                keys.add(key)
+    output = ['# ' + VERSION, 'FROM ubuntu:22.04']
+    details = {'version': VERSION, 'runs': [], 'cache_mounts': [], 'source_sha256': digest(text.encode()),
+               'runtime_review': [], 'literal_files': {}, 'probe_paths': ['/home/user']}
+    cache_root = '/var/tmp/.ot-et-cache-' + details['source_sha256'][:20]
+    if cache_root in text:
+        raise Unsupported('Generated cache path collides with source')
+    for item in instructions[1:]:
+        op, value = item['op'], item['value']
+        if op == 'RUN':
+            if user not in ('root', '0'):
+                raise Unsupported('Build-time USER requires a supported identity mapping')
+            command, targets = split_mounts(value)
+            if command.startswith(('[', '<<')):
+                raise Unsupported('Unsupported RUN exec or standalone heredoc form')
+            script = command + ('\n' + item['tail'] if item['tail'] else '')
+            for path in list(details['literal_files']):
+                # A later command may remove or replace a parent directory,
+                # without naming the literal fixture itself (dummy curl does).
+                references = [path, *(str(p) for p in PurePosixPath(path).parents if str(p) != '/')]
+                references += [relative for ref in list(references)
+                               if (relative := posixpath.relpath(ref, cwd)) not in ('.', '..')]
+                if (any(ref in script for ref in references)
+                        and not re.fullmatch(r'\s*(?:(?:chmod|chown|chgrp)\b[^;&|]*\s*(?:&&\s*)?)+', command)):
+                    del details['literal_files'][path]
+            syntax = subprocess.run(['/bin/sh', '-n'], input=script, text=True, capture_output=True)
+            if syntax.returncode:
+                raise Unsupported(f'Original RUN shell syntax at line {item["line"]}: {syntax.stderr.strip()}')
+            run_env = {'HOME': '/root', **env}
+            lowered = shell_command(script, run_env, cwd, keys)
+            if targets:
+                lowered = shell_command(cache_script(lowered, targets, cache_root),
+                                        {'PATH': BASE_PATH, 'HOME': '/root'}, '/', keys)
+                details['cache_mounts'].append({'line': item['line'], 'targets': targets})
+            output.append("RUN /usr/bin/printf 'ET_RUN source-line=%s\\n' " + str(item['line'])
+                     + ' >&2 && ' + lowered)
+            details['runs'].append({'line': item['line'], 'script': script, 'script_sha256': digest(script.encode()),
+                                    'cwd': cwd, 'env': dict(env), 'heredocs': len(item['heredocs'])})
+            # Literal quoted fixtures provide source-derived checks independent of the compiler.
+            match = re.fullmatch(r"cat\s*>\s*([A-Za-z0-9_./-]+)\s*<<(['\"])([A-Za-z0-9_.-]+)\2", command)
+            if match and len(item['heredocs']) == 1:
+                path = posixpath.normpath(posixpath.join(cwd, match[1]))
+                details['literal_files'][path] = digest(item['heredocs'][0]['body'].encode())
+                details['probe_paths'].append(path)
+            details['probe_paths'] += re.findall(r'(?<![A-Za-z0-9_./-])(/(?:home/user|tmp)(?:/[A-Za-z0-9_.-]+)+)', command)
+        elif op == 'ENV':
+            updated = dict(token.split('=', 1) for token in docker_words(value, env))
+            env.update(updated)
+        elif op == 'WORKDIR':
+            words = docker_words(value, env)
+            if len(words) != 1 or not words[0]:
+                raise Unsupported('Unresolved WORKDIR')
+            cwd = posixpath.normpath(posixpath.join(cwd, words[0]))
+            output.append('RUN ' + shell_command('mkdir -p ' + shlex.quote(cwd),
+                                   {'HOME': '/root', **env}, '/', keys))
+        elif op == 'USER':
+            words = docker_words(value, env)
+            if len(words) != 1:
+                raise Unsupported('Unresolved USER')
+            user = words[0]
+            output.append('USER ' + user)
+            details['runtime_review'].append('worker-ignores-USER')
+        elif op in ('CMD', 'ENTRYPOINT'):
+            # Preserve declarations. Exec-based Harbor startup does not implement them.
+            output.append(op + ' ' + value)
+            details['runtime_review'].append('startup-command-needs-review')
+        elif op == 'LABEL':
+            output.append(op + ' ' + value)
+    if details['cache_mounts']:
+        output.append('RUN /bin/rm -rf ' + shlex.quote(cache_root))
+    # Resolve ENV at the Docker instruction where it was declared, not via a
+    # later shell. Quoting is parsed by both Docker and the current shlex bridge.
+    for key, value in sorted(env.items()):
+        if '\n' in value or '\r' in value:
+            raise Unsupported('Multiline runtime ENV')
+        output.append(f'ENV {key}={shlex.quote(value)}')
+    output.append('WORKDIR ' + cwd)
+    undo = undo_precreated_workdir(cwd)
+    if undo:
+        output.insert(2, 'RUN ' + undo)
+        details['workdir_timing'] = {'final_cwd': cwd, 'undo': undo}
+    details['expected'] = {'cwd': cwd, 'user': user, 'env': env}
+    details['runtime_review'].append('worker-overrides-PATH')
+    if any(path.startswith('/tmp/') for path in details['probe_paths']):
+        details['runtime_review'].append('tmp-bind-may-mask-image-state')
+    details['runtime_review'] = sorted(set(details['runtime_review']))
+    details['probe_paths'] = sorted(set(details['probe_paths']))
+    details['status'] = 'build-recipe-patched-runtime-unvalidated'
+    return '\n'.join(output) + '\n', details
+
+
+# Image sharing is a separate transformation over the original instructions.
+# The compatibility compiler remains the fallback and the comparison baseline.
+SHARING_VERSION = 'et-reviewed-recipes-v4'
+SHARING_STATE_DIR = '/var/lib/ot-et-image-sharing-v2'
+SOURCE_CONTEXT = {'container.def', 'task.json', 'test_initial_state.py'}
+
+
+def undo_precreated_workdir(cwd):
+    """Undo the builder's early mkdir only below the reviewed Ubuntu /home root.
+
+    rmdir never deletes files or nonempty directories. Source-position mkdir RUNs
+    recreate the directories before they are used. Other roots are not reviewed.
+    """
+    if not cwd.startswith(WORKDIR_BASE_ROOT.rstrip('/') + '/'):
+        return None
+    paths = [str(p) for p in [PurePosixPath(cwd), *PurePosixPath(cwd).parents]
+             if str(p).startswith(WORKDIR_BASE_ROOT.rstrip('/') + '/')]
+    return '/bin/rmdir -- ' + ' '.join(map(shlex.quote, paths)) + ' 2>/dev/null || true'
+
+
+def simple_command_prefix(value):
+    """Read one flat && operand without interpreting quotes or substitutions.
+
+    Return its original bytes, remaining bytes, and whether shell operators make
+    it unsuitable for literal dependency normalization. The opaque initialization
+    suffix is never reconstructed from these tokens.
+    """
+    quote, index, complex_shell = None, 0, False
+    while index < len(value):
+        char = value[index]
+        if char == '\\' and quote != "'":
+            index += 2
+            continue
+        if quote:
+            if char == quote:
+                quote = None
+            elif quote == '"' and char in '$`':
+                complex_shell = True
+        elif char in "'\"":
+            quote = char
+        elif value.startswith('&&', index):
+            return value[:index].strip(), value[index + 2:].lstrip(), complex_shell
+        elif char in '$`|;<>()[*?~\n#' or char == '&':
+            complex_shell = True
+        index += 1
+    return value.strip(), '', complex_shell or quote is not None
+
+
+def normalize_apt_args(args):
+    """Canonicalize a closed set of independent apt options, not package policy.
+
+    Unknown options, config overrides, combined short flags and interspersed
+    package/options retain their original argv. In particular, quiet level two
+    implies assume-yes during installation and must never be erased there.
+    """
+    yes = {'-y', '--yes', '--assume-yes'}
+    quiet = {'-q', '--quiet'}
+    if args.count('update') == 1 and all(a == 'update' or a in yes | quiet for a in args):
+        return ['update']
+    allowed = yes | {'--no-install-recommends'}
+    flags, packages, action = [], [], False
+    for arg in args:
+        if arg == 'install' and not action and not packages:
+            action = True
+        elif arg in allowed and not packages:
+            flags.append('-y' if arg in yes else arg)
+        elif action and re.fullmatch(r'[a-z0-9][a-z0-9+.:=-]*', arg):
+            packages.append(arg)
+        else:
+            return args
+    if not action or not packages:
+        return args
+    # Keep package order, pins and duplicates; only independent boolean options
+    # move. Do not remove even duplicate flags, to keep the rule narrow.
+    return ['install', *sorted(flags, key=lambda flag: (flag != '-y', flag)), *packages]
+
+
+def dependency_operand(value):
+    """Normalize literal argv and reviewed apt options; preserve shell state."""
+    raw, rest, complex_shell = simple_command_prefix(value)
+    if re.fullmatch(r'rm\s+-(?:rf|fr)\s+/var/lib/apt/lists/\*', raw):
+        return {'command': 'rm -rf /var/lib/apt/lists/*', 'replay': False, 'installs': False, 'rest': rest}
+    if complex_shell:
+        return None
+    try:
+        words = shlex.split(raw)
+    except ValueError:
+        return None
+    if not words:
+        return None
+    assignments = []
+    while words and re.fullmatch(r'[A-Za-z_][A-Za-z0-9_]*=[^\s]*', words[0]):
+        assignments.append(words.pop(0))
+    if not words:
+        return None
+    command, args = words[0], words[1:]
+    replay, installs = False, False
+    if command == 'set':
+        if assignments or not args or any(not re.fullmatch(r'-[eux]+', arg) for arg in args):
+            return None
+        replay = True
+    elif command == 'export':
+        if assignments or not args or any(not re.fullmatch(r'[A-Za-z_][A-Za-z0-9_]*=.*', arg) for arg in args):
+            return None
+        replay = True
+    elif command in ('apt-get', 'apt'):
+        if not args or not any(x in ('update', 'install', 'clean', 'autoclean') for x in args):
+            return None
+        if any(x in ('remove', 'purge', 'upgrade', 'dist-upgrade', 'autoremove') for x in args):
+            return None
+        installs = 'install' in args
+    elif command in ('pip', 'pip3') or (command in ('python', 'python3') and args[:2] == ['-m', 'pip']):
+        pip_args = args[2:] if command in ('python', 'python3') else args
+        if not pip_args or pip_args[0] != 'install':
+            return None
+        # Relative/local requirements can depend on task state, unlike named packages.
+        if any(x in ('-r', '--requirement', '-e', '--editable') or x.startswith(('.', '/', 'file:', 'git+'))
+               or x.startswith(('-r', '--requirement=', '-e', '--editable=')) for x in pip_args[1:]):
+            return None
+        installs = True
+    else:
+        return None
+    original = shlex.join([*assignments, command, *args])
+    if command in ('apt-get', 'apt'):
+        args = normalize_apt_args(args)
+    normalized = shlex.join([*assignments, command, *args])
+    return {'command': normalized, 'replay': replay, 'installs': installs, 'rest': rest,
+            'normalization': {'source': original, 'normalized': normalized} if original != normalized else None}
+
+
+def dependency_records(prefix, context):
+    """Flatten successful literal && chains with their exact effective environment.
+
+    No command contains expansion/substitution. set -e/-u therefore adds no failure
+    cases beyond a failing operand; set -x only affects build diagnostics. Explicit
+    export and inline assignments are captured without leaking into another RUN.
+    """
+    env = dict(context['env'])
+    result = []
+    for command in prefix:
+        words = shlex.split(command)
+        if words[0] == 'set':
+            continue
+        if words[0] == 'export':
+            env.update(dict(word.split('=', 1) for word in words[1:]))
+            continue
+        local = {}
+        while words and re.fullmatch(r'[A-Za-z_][A-Za-z0-9_]*=.*', words[0]):
+            key, value = words.pop(0).split('=', 1)
+            local[key] = value
+        # Preserve the one reviewed glob; quoting it would disable expansion.
+        program = command if words[:2] == ['rm', '-rf'] else shlex.join(words)
+        result.append(dict(context, script=program, env={**env, **local}))
+    return result
+
+
+def inert_startup(item):
+    """Only empty, bare-shell and literal diagnostic startup declarations."""
+    value = item['value']
+    try:
+        argv = json.loads(value) if value.startswith('[') else shlex.split(value)
+    except ValueError:
+        return False
+    if not isinstance(argv, list) or not all(isinstance(v, str) for v in argv):
+        return False
+    if not argv:
+        return True
+    if item['op'] == 'ENTRYPOINT':
+        return False
+    if argv[0] in ('bash', '/bin/bash', 'sh', '/bin/sh') and argv[1:] in ([], ['-l'], ['--login']):
+        return True
+    return (argv[0] in ('echo', '/bin/echo') and
+            not any(any(c in word for c in '$`;&|<>\n') for word in argv[1:]))
+
+
+def initialization_plan(text, details, *, repaired_startup=False):
+    """Separate a literal dependency prefix from complete initialization programs.
+
+    A split inside RUN is restricted to flat && chains of literal installation,
+    set and export operands. The remaining program is byte-preserved, with shell
+    flags/exports replayed. No later installation or cache mount is moved to setup.
+    Unresolved cases keep the compatibility-only task, with an individual reason.
+    """
+    if details['expected']['user'] not in ('root', '0'):
+        raise Unsupported('non-root USER retained in compatibility image')
+    instructions = parse_dockerfile(text)
+    for item in instructions:
+        if item['op'] in ('CMD', 'ENTRYPOINT') and not (repaired_startup or inert_startup(item)):
+            raise Unsupported('startup declaration needs sharing-specific review')
+    keys = sorted(set(details['expected']['env']) | {'HOME', 'PATH'})
+    run_by_line = {r['line']: r for r in details['runs']}
+    env, cwd = {'PATH': BASE_PATH}, '/'
+    build, setup, boundaries, normalizations = [], [], [], []
+    phase, installed = 'build', False
+    for item in instructions[1:]:
+        op, value = item['op'], item['value']
+        if op == 'ENV':
+            env.update(dict(token.split('=', 1) for token in docker_words(value, env)))
+        elif op == 'WORKDIR':
+            cwd = posixpath.normpath(posixpath.join(cwd, docker_words(value, env)[0]))
+            record = {'script': 'mkdir -p ' + shlex.quote(cwd), 'env': {'HOME': '/root', **env},
+                      'cwd': '/', 'targets': []}
+            (build if phase == 'build' else setup).append(record)
+        elif op == 'RUN':
+            command, targets = split_mounts(value)
+            run = run_by_line[item['line']]
+            context = {'env': {'HOME': '/root', **run['env']}, 'cwd': run['cwd'], 'targets': targets}
+            remaining, prefix, replay = command, [], []
+            if phase == 'build':
+                while remaining and (part := dependency_operand(remaining)) is not None:
+                    prefix.append(part['command'])
+                    if part.get('normalization'):
+                        normalizations.append(dict(part['normalization'], line=item['line']))
+                    if part['replay']:
+                        replay.append(part['command'])
+                    installed |= part['installs']
+                    remaining = part['rest']
+                if not remaining:
+                    if item['tail']:
+                        raise Unsupported('dependency heredoc requires review')
+                    build.extend(dependency_records(prefix, context))
+                    continue
+            if not installed:
+                raise Unsupported('initialization precedes a reviewed dependency prefix')
+            if targets:
+                raise Unsupported('cache-mounted mixed initialization retained in image')
+            if prefix:
+                build.extend(dependency_records(prefix, context))
+                boundaries.append({'line': item['line'], 'dependency_operands': len(prefix), 'replay': replay})
+            else:
+                remaining = command
+            script = (' && '.join(replay) + ' && ' if replay else '') + remaining
+            if item['tail']:
+                script += '\n' + item['tail']
+            # Fail closed on later installers, identity operations, mount-sensitive
+            # state and dynamically executed shell/interpreter initialization.
+            review = re.sub(r'(?<![\w/])apt(?:-get)?\s+(?:clean|autoclean)\b', '', script)
+            if re.search(r'(?<![/\w-])(?:apt(?:-get)?|pip[23]?|dpkg|npm|yarn|conda|curl|wget|make|cmake|ninja|gcc|cargo|rustup|gem|bundle|composer|uv|uvx|useradd|adduser|groupadd|addgroup|chown|chgrp|sudo|su)\b', review):
+                raise Unsupported('initializer contains installation, identity or download operations')
+            mounted_path = r'(?<![\w/])/(?:tmp|root|proc|sys|dev)(?:/|\b)'
+            referenced_env = [value for key, value in context['env'].items()
+                              if re.search(r'\$(?:' + re.escape(key) + r'\b|\{' + re.escape(key) + r'\})', script)]
+            if any(re.search(mounted_path, value) for value in [script, run['cwd'], *referenced_env]):
+                raise Unsupported('initializer references a runtime-mounted system path')
+            if re.search(r'\b(?:python[23]?|perl|ruby|node|eval|bash|sh)\s+(?:-[^\n ]*c\b|<<|/)', remaining):
+                raise Unsupported('interpreter initialization needs individual review')
+            if (details['expected']['env'].get('HOME') == '/home/user'
+                    and re.search(r'\bchmod\s+(?:-[^\s]*R[^\s]*\s+|--recursive\s+)[^;&\n]*\s/home/user(?:\s|$|;|&)', script)):
+                raise Unsupported('recursive home permissions would touch runtime-created package caches')
+            phase = 'setup'
+            setup.append(dict(context, script=script))
+    if not setup:
+        raise Unsupported('no task initialization to separate')
+    seed_home = any('/home/user' in c['script'] for c in setup) or cwd.startswith('/home/user')
+    profile = {'version': SHARING_VERSION, 'base': 'ubuntu:22.04', 'build': build,
+               'initialization_defaults': {'state_dir': SHARING_STATE_DIR, 'home': '/home/user' if seed_home else None},
+               'runtime': details['expected'], 'environment_keys': keys}
+    identity = digest(json.dumps(profile, sort_keys=True, separators=(',', ':')).encode())
+    root = '/var/tmp/.ot-et-cache-' + identity[:20]
+    lines = ['# ' + SHARING_VERSION, 'FROM ubuntu:22.04']
+    if undo := undo_precreated_workdir(details['expected']['cwd']):
+        lines.append('RUN ' + undo)
+    for command in build:
+        lowered = shell_command(command['script'], command['env'], command['cwd'], keys)
+        if command['targets']:
+            lowered = shell_command(cache_script(lowered, command['targets'], root),
+                                    {'PATH': BASE_PATH, 'HOME': '/root'}, '/', keys)
+        lines.append('RUN ' + lowered)
+    if any(command['targets'] for command in build):
+        lines.append('RUN /bin/rm -rf ' + shlex.quote(root))
+    # Capture the builder's defaults rather than inheriting the runtime shell's
+    # different umask. Seed the common home and preserve its mode across the
+    # worker's empty-WORKDIR bind, before source initialization applies its modes.
+    state = shlex.quote(SHARING_STATE_DIR)
+    lines.append(f'RUN /bin/mkdir -p {state} && umask > {state}/umask')
+    if seed_home:
+        lines.append(f'RUN /bin/mkdir -p /home/user && /usr/bin/stat -c %a /home/user > {state}/home-mode')
+    # Startup requires this cwd before setup files can be uploaded/executed.
+    lines.append('RUN /bin/mkdir -p ' + shlex.quote(details['expected']['cwd']))
+    for key, value in sorted(details['expected']['env'].items()):
+        lines.append(f'ENV {key}={shlex.quote(value)}')
+    lines.append('WORKDIR ' + details['expected']['cwd'])
+    commands = ([f'/bin/chmod "$(/bin/cat {state}/home-mode)" /home/user'] if seed_home else [])
+    commands += [f'umask "$(/bin/cat {state}/umask)" && ' +
+                 shell_command(c['script'], c['env'], c['cwd'], keys) for c in setup]
+    return {'identity': identity, 'dockerfile': '\n'.join(lines) + '\n', 'commands': commands,
+            'profile': profile, 'initialization': setup, 'split_boundaries': boundaries,
+            'dependency_normalizations': normalizations}
+
+
+def relocate_source_context(members):
+    """Keep source truth and unused recipes outside build and agent-upload paths."""
+    result, moved = [], []
+    names = {info.name for info, _ in members}
+    for original, data in members:
+        info = copy.copy(original)
+        if info.name.startswith('environment/') and info.name != 'environment/Dockerfile':
+            relative = info.name.removeprefix('environment/')
+            if info.isdir() or relative not in SOURCE_CONTEXT:
+                raise Unsupported('unreviewed extra build-context member: ' + info.name)
+            info.name = 'source_metadata/environment/' + relative
+            if info.name in names:
+                raise Unsupported('source metadata destination already exists')
+            moved.append({'source': original.name, 'destination': info.name, 'sha256': digest(data)})
+        result.append((info, data))
+    return result, moved
+
+
+def read_task(binary):
+    members, seen = [], set()
+    with tarfile.open(fileobj=io.BytesIO(binary), mode='r:*') as archive:
+        for info in archive:
+            path = PurePosixPath(info.name)
+            if path.is_absolute() or '..' in path.parts or info.name in seen:
+                raise ValueError('Unsafe or duplicate task archive entry')
+            seen.add(info.name)
+            members.append((info, archive.extractfile(info).read() if info.isfile() else None))
+    return members
+
+
+def write_task(members):
+    buffer = io.BytesIO()
+    with tarfile.open(fileobj=buffer, mode='w', format=tarfile.PAX_FORMAT) as archive:
+        for original, data in sorted(members, key=lambda item: item[0].name):
+            info = copy.copy(original)
+            info.mtime, info.uid, info.gid, info.uname, info.gname = 0, 0, 0, '', ''
+            info.pax_headers = {}
+            if data is not None:
+                info.size = len(data)
+            archive.addfile(info, io.BytesIO(data) if data is not None else None)
+    return buffer.getvalue()
+
+
+def setup_script(commands, source_sha256):
+    """Run reviewed initialization once per instance, never reset an oracle trial."""
+    return ('#!/bin/bash\nset -eu\n'
+            'setup_dir=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)\n'
+            'marker="$setup_dir/.ot-et-' + source_sha256 + '.done"\n'
+            '[ ! -f "$marker" ] || exit 0\n' + '\n'.join('/bin/sh -c ' + shlex.quote(command) for command in commands)
+            + '\n: > "$marker"\n')
+
+
+def with_setup(members, commands, source_sha256):
+    names = {info.name for info, _ in members}
+    if any(name == 'setup_files' or name.startswith('setup_files/') for name in names):
+        raise Unsupported('Existing task setup requires individual review')
+    solution = next(((i, info, data) for i, (info, data) in enumerate(members)
+                     if info.name == 'solution/solve.sh'), None)
+    if solution is None or not solution[2]:
+        raise Unsupported('Task setup requires an existing solution script')
+    index, info, original = solution
+    call = b'bash /setup_files/setup.sh || exit $?\n'
+    if original.startswith(b'#!'):
+        first, separator, rest = original.partition(b'\n')
+        if not separator:
+            raise Unsupported('Solution shebang has no body')
+        updated = first + separator + call + rest
+    else:
+        updated = call + original
+    members[index] = (info, updated)
+    script = setup_script(commands, source_sha256).encode()
+    info = tarfile.TarInfo('setup_files/setup.sh')
+    info.mode = 0o755
+    members.append((info, script))
+    return members
+
+
+def patch_task(task_id, binary, *, task_setup=True, share_images=False, offline_verifier=False,
+               reviewed_repairs=True):
+    members = read_task(binary)
+    source = next(data for info, data in members if info.name == 'environment/Dockerfile')
+    try:
+        repair = STARTUP_REPAIRS.get(task_id) if task_setup else None
+        if repair and digest(source) != repair:
+            raise Unsupported('Reviewed startup source digest differs')
+        converted, details = compile_dockerfile(source.decode())
+        commands = []
+        if share_images:
+            try:
+                plan = initialization_plan(source.decode(), details, repaired_startup=bool(repair))
+                relocated, moves = relocate_source_context(members)
+                if any(info.name.startswith('setup_files/') for info, _ in members):
+                    raise Unsupported('existing setup requires composition review')
+            except Unsupported as exc:
+                details['sharing'] = {'status': 'retained', 'reason': str(exc)}
+            else:
+                members = relocated
+                converted = plan.pop('dockerfile')
+                commands.extend(plan.pop('commands'))
+                details['sharing'] = dict(plan, status='separated', relocated=moves)
+        timestamp = REVIEWED_REPAIRS['timestamps'].get(task_id) if reviewed_repairs and task_setup else None
+        if timestamp:
+            if digest(source) != timestamp['source_sha256']:
+                raise Unsupported('Reviewed timestamp source digest differs')
+            # Shared initialization already replays these original RUN programs.
+            in_setup = details.get('sharing', {}).get('status') == 'separated'
+            if not in_setup:
+                keys = sorted(set(details['expected']['env']) | {'HOME', 'PATH'})
+                commands.extend(shell_command(c['script'], c['env'], c['cwd'], keys)
+                                for c in timestamp['commands'])
+            details['timestamp_refresh'] = {'kind': 'source-initialization' if in_setup else 'reviewed-touch',
+                                            'commands': timestamp['commands']}
+        if repair:
+            if details['expected']['user'] not in ('root', '0'):
+                raise Unsupported('Task setup cannot implement a non-root runtime identity')
+            entrypoints = [i['value'] for i in parse_dockerfile(source.decode()) if i['op'] == 'ENTRYPOINT']
+            try:
+                argv = json.loads(entrypoints[-1])
+            except (IndexError, ValueError) as exc:
+                raise Unsupported('Reviewed startup requires an exec-form ENTRYPOINT') from exc
+            if not isinstance(argv, list) or not argv or not all(isinstance(v, str) for v in argv):
+                raise Unsupported('Reviewed startup requires nonempty string arguments')
+            command = shlex.join([*argv, '/bin/true'])
+            commands.append(command)
+            details['startup_command'] = command
+        if commands:
+            members = with_setup(members, commands, details['source_sha256'])
+            details['task_setup'] = {'kind': 'initialization-and-startup' if details.get('sharing', {}).get('status') == 'separated'
+                                    else 'reviewed-entrypoint', 'commands': len(commands),
+                                    'completion_marker': '.ot-et-' + details['source_sha256'] + '.done'}
+        instruction = REVIEWED_REPAIRS['instructions'].get(task_id) if reviewed_repairs else None
+        if instruction:
+            original = next(data for info, data in members if info.name == 'instruction.md')
+            metadata = next(data for info, data in members
+                            if info.name in ('environment/task.json', 'source_metadata/environment/task.json'))
+            restored = json.loads(metadata)['description'].encode()
+            if digest(original) != instruction['instruction_sha256'] or digest(restored) != instruction['description_sha256']:
+                raise Unsupported('Reviewed instruction source digest differs')
+            members = [(info, restored if info.name == 'instruction.md' else data) for info, data in members]
+            details['instruction_restoration'] = dict(instruction, original_chars=len(original.decode()),
+                                                      restored_chars=len(restored.decode()))
+        if offline_verifier:
+            wrapper = next(data for info, data in members if info.name == 'tests/test.sh')
+            if digest(wrapper) != ORIGINAL_TEST_SH_SHA256:
+                raise Unsupported('Reviewed verifier wrapper digest differs')
+            install = shell_command(VERIFIER_INSTALL, {'HOME': '/root', 'PATH': BASE_PATH}, '/',
+                                    sorted(set(details['expected']['env']) | {'HOME', 'PATH'}))
+            user = details['expected']['user']
+            converted += ('USER root\n' if user not in ('root', '0') else '') + 'RUN ' + install + '\n'
+            if user not in ('root', '0'):
+                converted += 'USER ' + user + '\n'
+            members = [(info, OFFLINE_TEST_SH if info.name == 'tests/test.sh' else data) for info, data in members]
+            details['offline_verifier'] = {'version': VERIFIER_VERSION, 'source_sha256': ORIGINAL_TEST_SH_SHA256,
+                                           'python': '3.12', 'pytest': '8.4.1', 'uv': '0.9.5'}
+    except Unsupported as exc:
+        return binary, {'task_id': task_id, 'status': 'held-unchanged', 'reason': str(exc)}
+    details['reviewed_state'] = PILOT_STATE.get(task_id, {})
+    details['probe_paths'] = sorted(set(details['probe_paths']) | set(details['reviewed_state']))
+    # Flag possible identity/ownership operations for review, without changing
+    # runtime behavior or treating a static match as a host-capability failure.
+    identity_ops = re.compile(r'\b(?:useradd|adduser|groupadd|addgroup|chown|chgrp|su|sudo)\b|\binstall\s+[^;&\n]*\s-[og]\b')
+    if (details['expected']['user'] not in ('root', '0')
+            or any(identity_ops.search(run['script']) for run in details['runs'])):
+        details['runtime_review'].append('identity-and-ownership-needs-review')
+    for index, (info, data) in enumerate(members):
+        if info.name == 'environment/Dockerfile':
+            members[index] = (info, converted.encode())
+    return write_task(members), dict(details, task_id=task_id)
+
+
+def rows(source):
+    import pyarrow.parquet as pq
+    # Dictionary decoding of task_binary is expensive with multiple Arrow threads.
+    for batch in pq.ParquetFile(source).iter_batches(batch_size=16, use_threads=False):
+        yield from batch.to_pylist()
+
+
+def context_digest(binary):
+    """The worker's full build-context hash, excluding task setup and provenance."""
+    result = hashlib.sha256()
+    for info, data in sorted(read_task(binary), key=lambda pair: pair[0].name):
+        if info.isfile() and info.name.startswith('environment/'):
+            relative = info.name.removeprefix('environment/').encode()
+            result.update(len(relative).to_bytes(4, 'big'))
+            result.update(relative)
+            result.update(len(data).to_bytes(4, 'big'))
+            result.update(data)
+    return result.hexdigest()
+
+
+def static_repairs(task_id, original, binary):
+    """Reuse suffix normalization and apply the reviewed CPU edits, with evidence."""
+    from validation.checks.instruction_suffix import suffix
+    members = read_task(binary)
+    files = {info.name: data for info, data in members}
+    edits = {}
+    instruction = suffix(files['instruction.md'], files['task.toml'])
+    if instruction != files['instruction.md']:
+        edits['instruction.md'] = instruction
+    if task_id in PIN_REPAIRS['tasks']:
+        recipe = PIN_REPAIRS['tasks'][task_id]
+        source = {info.name: data for info, data in read_task(original)}['solution/solve.sh']
+        if digest(source) != recipe['script_sha256']:
+            raise ValueError(f'{task_id}: reviewed pip source changed')
+        first, separator, body = source.partition(b'\n')
+        setup_call = b'bash /setup_files/setup.sh || exit $?\n'
+        if files['solution/solve.sh'] not in (source, first + separator + setup_call + body):
+            raise ValueError(f'{task_id}: unexpected changes before pip repairs')
+        script = files['solution/solve.sh'].decode()
+        delta = len(script) - len(source.decode())
+        for edit in sorted(recipe['edits'], key=lambda e: e['start'], reverse=True):
+            start, end = edit['start'] + delta, edit['end'] + delta
+            if script[start:end] != edit['original']:
+                raise ValueError(f'{task_id}: stale package-pin evidence')
+            script = script[:start] + edit['replacement'] + script[end:]
+        edits['solution/solve.sh'] = script.encode()
+    if task_id == 'task_000000_b5807114' and files['tests/test.sh'] == OFFLINE_TEST_SH:
+        source = {info.name: data for info, data in read_task(original)}['solution/solve.sh']
+        if digest(source) != JSONSCHEMA_SOURCE_SHA256:
+            raise ValueError('Reviewed JSON-schema solution changed')
+        # pytest is already invoked by absolute path. Its subprocess must find
+        # the task Python (with jsonschema), not the isolated grading Python.
+        edits['tests/test.sh'] = OFFLINE_TEST_SH.replace(b'export PATH="/opt/et-verifier/venv/bin:$PATH"\n', b'')
+    if task_id in CPU_REPAIRS:
+        source = {info.name: data for info, data in read_task(original)}['solution/solve.sh']
+        if digest(source) != CPU_REPAIRS[task_id]:
+            raise ValueError(f'{task_id}: reviewed CPU source changed')
+        script = files['solution/solve.sh'].decode()
+        if task_id == 'task_000000_bc9c5a3e':
+            # This task measures the host; the audit must log the command used.
+            script = script.replace('cpu_cmd="nproc"', 'cpu_cmd="nproc --all"')
+            script = script.replace('cpu=$(nproc)', 'cpu=$(nproc --all)')
+        else:
+            cpus = tomllib.loads(files['task.toml'].decode())['environment']['cpus']
+            if isinstance(cpus, bool) or not isinstance(cpus, int) or cpus <= 0:
+                raise ValueError(f'{task_id}: expected positive integer CPU budget')
+            script, count = re.subn(
+                r'\$\((?:command -v nproc >/dev/null && nproc \|\| echo 4|nproc 2>/dev/null \|\| echo 4|nproc)\)',
+                str(cpus), script)
+            if count != (3 if task_id == 'task_000000_27030ede' else 1):
+                raise ValueError(f'{task_id}: reviewed CPU replacement count changed')
+        edits['solution/solve.sh'] = script.encode()
+    result = [(info, edits.get(info.name, data)) for info, data in members]
+    evidence = {'version': STATIC_VERSION, 'edits': [
+        {'file': name, 'before_sha256': digest(files[name]), 'after_sha256': digest(data)}
+        for name, data in sorted(edits.items())]}
+    return write_task(result), evidence
+
+
+def patch_main(args):
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+    pa.set_cpu_count(2)
+    pa.set_io_thread_count(2)
+    if digest(args.source.read_bytes()) != SOURCE_SHA256:
+        raise ValueError('Source checksum differs from the unmodified pinned ET Parquet')
+    if args.output.resolve().is_relative_to(Path(__file__).resolve().parent):
+        raise ValueError('Generated artifacts must live outside data/endless_terminals')
+    args.output.mkdir(parents=True, exist_ok=False)
+    records, labels, reasons, dropped = [], {}, {}, {}
+    target = args.output / 'tasks.parquet'
+    temporary = target.with_suffix('.parquet.tmp')
+    schema = pq.ParquetFile(args.source).schema_arrow
+    # Plan first, so singleton recipes keep the byte-identical compatibility task.
+    planned, sizes = [], collections.Counter()
+    for row in rows(args.source):
+        if args.filter_reviewed and row['path'] in REVIEWED_EXCLUSIONS:
+            exclusion = REVIEWED_EXCLUSIONS[row['path']]
+            if digest(row['task_binary']) != exclusion['source_sha256']:
+                raise ValueError(f"{row['path']}: reviewed exclusion source changed")
+            dropped[row['path']] = {k: exclusion[k] for k in ('category', 'reason')}
+            continue
+        new, details = patch_task(row['path'], row['task_binary'], task_setup=not args.no_task_setup,
+                                  share_images=not args.no_share_images, offline_verifier=not args.no_offline_verifier,
+                                  reviewed_repairs=not args.no_reviewed_repairs)
+        sharing = details.get('sharing', {})
+        if sharing.get('status') == 'separated':
+            sizes[sharing['identity']] += 1
+        planned.append((row, new, details))
+        if len(planned) % 100 == 0:
+            print(f'Planned {len(planned)}/2492', flush=True)
+    image_groups = {}
+    with pq.ParquetWriter(temporary, schema, compression='zstd', use_dictionary=False) as writer:
+        for row, new, details in planned:
+            sharing = details.get('sharing', {})
+            if sharing.get('status') == 'separated' and sizes[sharing['identity']] == 1:
+                identity = sharing['identity']
+                new, details = patch_task(row['path'], row['task_binary'], task_setup=not args.no_task_setup,
+                                          offline_verifier=not args.no_offline_verifier,
+                                          reviewed_repairs=not args.no_reviewed_repairs)
+                details['sharing'] = {'status': 'retained', 'reason': 'no matching dependency recipe',
+                                      'candidate_identity': identity}
+                sharing = details['sharing']
+            if not args.no_static_repairs:
+                new, details['static_repairs'] = static_repairs(row['path'], row['task_binary'], new)
+            key = context_digest(new)
+            details['environment_sha256'] = key
+            if sharing.get('status') == 'separated':
+                group = image_groups.setdefault(key, {'identity': sharing['identity'], 'tasks': [],
+                                                      'profile': sharing['profile']})
+                group['tasks'].append(row['path'])
+            if new != row['task_binary']:
+                labels[row['path']] = ['apptainer-build-compatibility']
+                reasons[row['path']] = ('Preserve ordered build environment/cwd; lower heredocs and emulate '
+                    'reviewed disposable cache mounts. Shared runtime behavior is unchanged.')
+                if details.get('startup_command'):
+                    labels[row['path']] = ['apptainer-build-and-startup-compatibility']
+                    reasons[row['path']] += (' Invoke the reviewed finite source ENTRYPOINT after container mounts, '
+                        'with /bin/true as payload, through guarded task setup.')
+                if sharing.get('status') == 'separated':
+                    labels[row['path']] = ['shared-dependency-image-and-task-setup']
+                    reasons[row['path']] += (' Share a dependency execution recipe and runtime declarations after '
+                        'normalizing reviewed redundant apt update flags and equivalent install option spelling/order. '
+                        'Keep installation in the image; replay task initialization with its original shell context '
+                        'before any repaired entrypoint. Preserve unused context metadata outside the image and '
+                        'agent-visible setup. Add one guarded setup call before the unchanged solution body.')
+                if details.get('workdir_timing'):
+                    reasons[row['path']] += ' Undo early empty WORKDIR creation before source RUN steps.'
+                if details.get('timestamp_refresh'):
+                    labels[row['path']].append('fresh-instance-timestamps')
+                    reasons[row['path']] += ' Refresh reviewed relative timestamps once per fresh instance, preserving source touch commands.'
+                if details.get('instruction_restoration'):
+                    labels[row['path']].append('restored-truncated-instruction')
+                    reasons[row['path']] += ' Restore the complete original description from task metadata after source-hash review.'
+                if details.get('offline_verifier'):
+                    labels[row['path']].append('offline-verifier')
+                    reasons[row['path']] += (' Install isolated Python 3.12/pytest 8.4.1 grading tools in the image; '
+                        'preserve test assertions and task dependencies. Grading uses no bootstrap downloads; '
+                        'pytest assertion failure scores zero, infrastructure/collection errors receive no reward.')
+                if details.get('static_repairs'):
+                    labels[row['path']].append('instruction-suffix')
+                    reasons[row['path']] += ' Append the canonical timeout/anti-cheating sentence using the declared agent timeout.'
+                    if row['path'] in CPU_REPAIRS:
+                        labels[row['path']].append('cpu-resource-portability')
+                        reasons[row['path']] += (' Bound solution workers by the declared CPU budget, or explicitly measure '
+                                                'host CPUs with nproc --all and record that exact command.')
+                    if row['path'] in PIN_REPAIRS['tasks']:
+                        labels[row['path']].append('dependency-pinning')
+                        reasons[row['path']] += ' Pin reviewed literal installs to versions captured after a reward-1 oracle, then rerun normal validation.'
+                    if any(e['file'] == 'tests/test.sh' for e in details['static_repairs']['edits']):
+                        labels[row['path']].append('verifier-subprocess-path')
+                        reasons[row['path']] += ' Preserve the task PATH for verifier subprocesses while invoking isolated pytest by absolute path; assertions are unchanged.'
+            writer.write_table(pa.Table.from_pylist([dict(row, task_binary=new)], schema=schema))
+            records.append(details)
+    temporary.replace(target)
+    from data.utils.patch_reporting import write_patch_report
+    write_patch_report(args.source, target, source={'dataset': 'obiwan96/endless-terminals',
+        'url': 'https://huggingface.co/datasets/obiwan96/endless-terminals', 'revision': REVISION},
+        dropped=dropped, change_labels=labels, change_reasons=reasons, patcher=__file__)
+    (args.output / 'build-manifest.jsonl').write_text(''.join(json.dumps(r, sort_keys=True) + '\n' for r in records))
+    save(args.output / 'image-groups.json', image_groups)
+    summary = {'version': VERSION, 'sharing_version': None if args.no_share_images else SHARING_VERSION,
+               'static_repairs_version': None if args.no_static_repairs else STATIC_VERSION,
+               'source_sha256': SOURCE_SHA256, 'source_revision': REVISION, 'tasks': len(records),
+               'reviewed_exclusions': dropped, 'source_tasks': len(records) + len(dropped),
+               'statuses': dict(collections.Counter(r['status'] for r in records)),
+               'runtime_validated': 0, 'task_setup': sum(bool(r.get('task_setup')) for r in records),
+               'shared_tasks': sum(len(group['tasks']) for group in image_groups.values()),
+               'shared_images': len(image_groups), 'unique_build_contexts': len({r['environment_sha256'] for r in records}),
+               'normalized_shared_tasks': sum(bool(r.get('sharing', {}).get('dependency_normalizations')) for r in records),
+               'offline_verifiers': sum(bool(r.get('offline_verifier')) for r in records),
+               'timestamp_refreshes': sum(bool(r.get('timestamp_refresh')) for r in records),
+               'restored_instructions': sum(bool(r.get('instruction_restoration')) for r in records),
+               'workdir_timing_repairs': sum(bool(r.get('workdir_timing')) for r in records),
+               'sharing_retained_reasons': dict(collections.Counter(r['sharing']['reason'] for r in records
+                                                                   if r.get('sharing', {}).get('status') == 'retained')),
+               'oracle_and_nop': 'not-run-by-patcher',
+               'patcher_sha256': digest(Path(__file__).read_bytes()), 'output_sha256': digest(target.read_bytes())}
+    save(args.output / 'summary.json', summary)
+    print(json.dumps(summary, indent=2))
+
+
+def pilot_main(args):
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+    args.output.mkdir(parents=True, exist_ok=False)
+    selected = set(args.task or PILOT)
+    kept = [row for row in rows(args.source) if row['path'] in selected]
+    if {row['path'] for row in kept} != selected:
+        raise ValueError('Pilot IDs missing from source')
+    pq.write_table(pa.Table.from_pylist(kept), args.output / 'tasks.parquet', compression='zstd', use_dictionary=False)
+    save(args.output / 'selection.json', {'source_sha256': digest(args.source.read_bytes()),
+         'tasks': sorted(selected), 'purpose': 'build and initial-state pilot; no oracle/no-op'})
+    print(args.output / 'tasks.parquet')
+
+
+def probe_command(details):
+    """Observe the actual worker shell; never repair its environment in the probe."""
+    config = {'paths': details['probe_paths'], 'env': sorted(set(details['expected']['env']) | {'HOME', 'PATH'}),
+              'user': details['expected']['user']}
+    script = '''import hashlib,json,os,pwd,stat,subprocess
+c=json.loads(CONFIG)
+result={"id":subprocess.check_output(["/usr/bin/id"],text=True).strip(),"uid":os.getuid(),"gid":os.getgid(),"cwd":os.getcwd(),"env":{k:os.environ.get(k) for k in c["env"]},"paths":{}}
+try: result["expected_uid"]=int(c["user"]) if c["user"].isdigit() else pwd.getpwnam(c["user"]).pw_uid
+except KeyError: result["expected_uid"]=None
+for path in c["paths"]:
+ try:
+  s=os.lstat(path); item={"mode":oct(stat.S_IMODE(s.st_mode)),"uid":s.st_uid,"gid":s.st_gid,"size":s.st_size,"link":os.readlink(path) if stat.S_ISLNK(s.st_mode) else None}
+  if stat.S_ISREG(s.st_mode) and s.st_size <= 16*1024*1024:
+   with open(path,"rb") as f: item["sha256"]=hashlib.file_digest(f,"sha256").hexdigest()
+  result["paths"][path]=item
+ except OSError as e: result["paths"][path]={"error":str(e),"errno":e.errno}
+print("ET_STATE_JSON="+json.dumps(result,sort_keys=True))
+'''.replace('CONFIG', repr(json.dumps(config)))
+    # Jammy Python 3.10 lacks hashlib.file_digest.
+    script = script.replace('hashlib.file_digest(f,"sha256").hexdigest()', 'hashlib.sha256(f.read()).hexdigest()')
+    paths = ' '.join(shlex.quote(p) for p in details['probe_paths'])
+    return ('/usr/bin/id; pwd; printf "PATH=%s\\n" "$PATH"; '
+            '/bin/ls -la /home/user; /bin/ls -ld -- ' + paths + '; '
+            '/usr/bin/python3 -c ' + shlex.quote(script))
+
+
+def state_failures(details, actual):
+    """Compare recorded observations with source expectations, without executing code."""
+    failures = []
+    if actual['uid'] != actual['expected_uid']:
+        failures.append('user-mismatch')
+    if actual['cwd'] != details['expected']['cwd']:
+        failures.append('cwd-mismatch')
+    for key, expected in details['expected']['env'].items():
+        if actual['env'].get(key) != expected:
+            failures.append('env-mismatch:' + key)
+    for path, expected in details['literal_files'].items():
+        if actual['paths'].get(path, {}).get('sha256') != expected:
+            failures.append('literal-fixture-mismatch:' + path)
+    for path, checks in details.get('reviewed_state', {}).items():
+        observed = actual['paths'].get(path, {})
+        for key, expected in checks.items():
+            found = observed.get('errno') == 2 if key == 'absent' else observed.get(key)
+            if found != expected:
+                failures.append(f'path-{key}-mismatch:{path}')
+    return failures
+
+
+async def terminal_probe(env, command):
+    """Observe a real Harbor interactive terminal, without its install fallback."""
+    from uuid import uuid4
+    from harbor.agents.terminus_2.tmux_session import TmuxSession
+    name = 'et-state-' + uuid4().hex[:12]
+    output = '/run/ot-harbor-tmux/' + name
+    session = TmuxSession(session_name=name, environment=env)
+    start = session._tmux_start_session
+    launched = await env.exec(start, timeout_sec=30)
+    if launched.return_code:
+        return {'status': 'error', 'start_command': start, 'stderr': launched.stderr}
+    script = (command + ' > ' + shlex.quote(output) + ' 2>&1; '
+              '/usr/bin/touch ' + shlex.quote(output + '.done'))
+    # Capture output to a private infrastructure path to avoid terminal wrapping
+    # corrupting JSON. Checked task files are only read, and artifacts are removed.
+    encoded = base64.b64encode(script.encode()).decode()
+    line = '/bin/bash --noprofile -c "$(/usr/bin/printf %s ' + encoded + ' | /usr/bin/base64 -d)"'
+    try:
+        sent = await env.exec('/usr/bin/tmux send-keys -t ' + name + ' -l -- ' + shlex.quote(line)
+                             + ' && /usr/bin/tmux send-keys -t ' + name + ' Enter', timeout_sec=30)
+        if sent.return_code:
+            return {'status': 'error', 'start_command': start, 'stderr': sent.stderr}
+        for _ in range(60):
+            value = await env.exec('test -f ' + shlex.quote(output + '.done')
+                                   + ' && /bin/cat ' + shlex.quote(output), timeout_sec=10)
+            if value.return_code == 0:
+                return {'status': 'observed', 'start_command': start, 'command': command,
+                        'stdout': value.stdout, 'stderr': value.stderr}
+            await asyncio.sleep(0.2)
+        return {'status': 'error', 'start_command': start, 'stderr': 'Terminal state probe timed out'}
+    finally:
+        await env.exec('/usr/bin/tmux kill-session -t ' + name + '; /bin/rm -f '
+                       + shlex.quote(output) + ' ' + shlex.quote(output + '.done'), timeout_sec=30)
+
+
+async def probe_main(args):
+    """Add ET observations to the existing stage-3 lifecycle in this process only."""
+    from validation.stages import harbor as runtime
+    from validation.stages.runner import parser
+    from validation.checks import environment as inspection
+    from validation.data.materialize import materialize
+    args.output.mkdir(parents=True, exist_ok=False)
+    tasks = materialize(args.source, args.output / 'tasks')
+    records = {r['task_id']: r for r in map(json.loads, args.manifest.read_text().splitlines())}
+    settings = parser().parse_args([str(args.source), '--no-fix-instruction-paths', '--no-fix-pip-pins',
+                                   '--no-fix-instruction-suffix', '--submit', 'never'])
+    settings.dry_run = False
+    settings.environment_kwargs = {'bridge_url': args.bridge_url, 'sif_cache': str(args.images)}
+    original = inspection.inspect_environment
+    results = []
+
+    async def inspect(env, task, context, label):
+        ordinary = await original(env, task, context, label)
+        details = records[task.paths.task_dir.name]
+        if 'expected' not in details:
+            return dict(ordinary, et_state={'status': 'not_checked', 'reason': details.get('reason')})
+        command = probe_command(details)
+        value = await env.exec(command, timeout_sec=60)
+        evidence = {'command': command, 'stdout': value.stdout, 'stderr': value.stderr,
+                    'return_code': value.return_code, 'expected': details['expected']}
+        matches = [line.partition('=')[2] for line in (value.stdout or '').splitlines() if line.startswith('ET_STATE_JSON=')]
+        failures = []
+        if value.return_code or len(matches) != 1:
+            failures.append('state-probe-failed')
+        else:
+            actual = json.loads(matches[0])
+            evidence['actual'] = actual
+            failures = state_failures(details, actual)
+        terminal = await terminal_probe(env, command)
+        lines = [line.partition('=')[2] for line in terminal.get('stdout', '').splitlines()
+                 if line.startswith('ET_STATE_JSON=')]
+        if terminal['status'] != 'observed' or len(lines) != 1:
+            failures.append('terminal-state-probe-failed')
+        else:
+            terminal['actual'] = json.loads(lines[0])
+            terminal['failures'] = state_failures(details, terminal['actual'])
+            terminal['status'] = 'failed' if terminal['failures'] else 'passed'
+            failures += ['terminal:' + f for f in terminal['failures']]
+        evidence['terminal'] = terminal
+        evidence.update(status='failed' if failures else 'passed', failures=failures,
+                        limitations='Ownership and nonliteral file state require source-specific review; startup commands are not certified.')
+        return dict(ordinary, et_state=evidence, status='failed' if failures else ordinary['status'])
+
+    inspection.inspect_environment = inspect
+    try:
+        for task in tasks:
+            result = await runtime.build_task(task, args.output / task.name, settings)
+            results.append({'task_id': task.name, **result})
+            save(args.output / 'state-probes.json', results)
+            print(task.name, result['status'], flush=True)
+    finally:
+        inspection.inspect_environment = original
+    return 0 if results and all(r['status'] == 'passed' for r in results) else 1
+
+
+def main():
+    if len(sys.argv) > 1 and sys.argv[1] in ('prepare-pilot', 'probe'):
+        command = sys.argv.pop(1)
+    else:
+        command = 'patch'
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--source', required=True, type=Path)
+    parser.add_argument('--output', required=True, type=Path)
+    if command == 'patch':
+        parser.add_argument('--no-share-images', action='store_true', help='Reproduce the completed compatibility-only patch')
+        parser.add_argument('--no-task-setup', action='store_true', help='Build-only control for repair comparisons')
+        parser.add_argument('--no-offline-verifier', action='store_true', help='Keep the original online grading wrapper')
+        parser.add_argument('--no-reviewed-repairs', action='store_true', help='Keep original instructions and build-relative timestamps')
+        parser.add_argument('--no-static-repairs', action='store_true', help='Reproduce historical output without suffix and reviewed CPU repairs')
+        parser.add_argument('--filter-reviewed', action='store_true', help='Archive the two source-bound exclusions reviewed under the recorded Helma/Apptainer profile')
+    if command == 'prepare-pilot':
+        parser.add_argument('--task', action='append')
+    if command == 'probe':
+        parser.add_argument('--manifest', required=True, type=Path)
+        parser.add_argument('--bridge-url', required=True)
+        parser.add_argument('--images', required=True, type=Path)
+    args = parser.parse_args()
+    if command == 'patch':
+        patch_main(args)
+    elif command == 'prepare-pilot':
+        pilot_main(args)
+    else:
+        raise SystemExit(asyncio.run(probe_main(args)))
+
+
+if __name__ == '__main__':
+    main()

crosscodeeval_environment-reliable/patch.py

@@ -0,0 +1,1438 @@
+#!/usr/bin/env python3
+"""Patch TaskTrove CrossCodeEval tasks: retrieval context, benchmark verifier, oracle.
+
+For each task in the input parquet:
+1. Match it to the pinned upstream record (amazon-science/cceval 40c68d2b) by
+   prompt and groundtruth. Unmatched or ambiguous rows keep their files and only
+   get steps 4-5.
+2. Keep the task only if every identifier of its graded reference is knowable.
+   A name is knowable when it occurs in what the agent sees (instruction,
+   context excerpts or their file names) as a whole word or by all its
+   camelCase/snake_case parts, or is a literal, a python standard-library name,
+   a name in KNOWN_NAMES, or a name used in API position by tasks from
+   COMMON_REPOS other repositories. Context comes from the first retrieval
+   (BM25, UniXcoder, OpenAI; before-cursor only) that makes every name
+   knowable; tasks with no such retrieval, or with no identifier at all, are
+   dropped.
+3. Write that retrieval's excerpts to setup_files/context/, minus empty ones,
+   ones from the target file and ones containing the reference.
+4. Replace tests/test.sh with the benchmark scorer (VERIFIER, written as
+   tests/cceval_verifier.py; python tasks also get tests/prompt.txt) and remove
+   the legacy grading bullet from instruction.md.
+5. Add an oracle (solution/solve.sh) that writes the reference.
+
+The report (<output>.report.json) lists kept, dropped and unmatched task IDs,
+the retrieval used per task and the unknowable names per tried retrieval.
+Beside the output it writes review/dropped.jsonl (every dropped task with the
+reason and the names that were not inferable) and review/sample.md (40 of them
+with their code, to read): the filter and its audit are one script, so they
+cannot disagree.
+The standard-library list comes from the running interpreter (python_version
+in the report).
+"""
+from __future__ import annotations
+
+# Support both direct execution and python -m data.<source>.patch.
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+
+
+import argparse
+import hashlib
+import io
+import json
+import os
+import re
+import sys
+import tarfile
+import types
+from pathlib import Path, PurePosixPath
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+PATCH_EXPLANATION = (
+    "Issue: TaskTrove omitted the benchmark's cross-file context. Its C#, Python and "
+    "TypeScript verifiers gave 0.25 reward for short code-like answers and could give "
+    "full reward for prefix or leading-identifier matches without a correct completion. "
+    "Java used a whole-answer diff that rejected different indentation. Fix: Replace this scoring "
+    "with normalized exact match of the first statement, add a reference solution, "
+    "and pin verifier dependencies. For uniquely matched upstream tasks, restore retrieved "
+    "cross-file excerpts after removing target-file and answer-containing excerpts. "
+    "Exclude tasks when the supplied code and known library names do not give the agent "
+    "enough information to infer names required by the expected answer. Also exclude "
+    "tasks whose scored answer contains no variable, function or other code names."
+)
+MISSING_NAMES_LABEL = 'Required code names cannot be inferred'
+MISSING_NAMES_EXPLANATION = (
+    "The expected answer uses names, such as methods or variables, that the agent "
+    "cannot infer from the prompt, the available excerpts from other files, or the "
+    "filter's list of known library names. None of the available sets of excerpts "
+    "provides enough information. The agent would have to guess these names to match "
+    "the expected answer."
+)
+NO_NAMES_LABEL = 'Expected completion contains no code names'
+NO_NAMES_EXPLANATION = (
+    "The part of the expected answer that is scored contains no variable, function, "
+    "class or other code names (identifiers). These tasks were excluded by the "
+    "patcher's rule requiring at least one such name in the scored completion."
+)
+CHANGE_FILE_LABELS = {name: 'context-and-verifier-repaired' for name in
+                      ('instruction.md', 'tests/', 'solution/', 'environment/', 'setup_files/context/')}
+
+
+def change_explanation(context_restored):
+    return PATCH_EXPLANATION + ("" if context_restored else
+        " Cross-file excerpts were not added for this task.")
+
+CONTEXT_NOTE = ("\n\nAdditional read-only cross-file context is available under:\n"
+                "  /setup_files/context/\n\n"
+                "These files are retrieved excerpts from related repository files.\n"
+                "They may be incomplete and may begin or end in the middle of a file.\n"
+                "Inspect them when deciding the missing continuation.\n")
+
+# Written into every task as tests/cceval_verifier.py (python3 standard library only).
+VERIFIER = r'''#!/usr/bin/env python3
+"""Score one CrossCodeEval task with the benchmark's own metric code.
+
+Port of amazon-science/cceval 40c68d2b (scripts/eval_metric.py,
+scripts/eval_utils.py, scripts/keywords). Plumbing differences: keyword files
+inlined, nltk's word tokenizer is re.findall(r"\\w+"), fuzz.ratio is its
+difflib path, and python statement boundaries use ast.parse instead of
+tree-sitter.
+
+Reward = exact match of the first statement: truncate, remove comments, strip
+each line, drop empty lines, compare the line lists. Edit similarity and
+identifier EM/precision/recall/F1 are reported next to it.
+
+Deviations from the benchmark, each applied to prediction and reference alike:
+- the reference is truncated too (the benchmark truncates only the prediction,
+  so a reference with a second statement could never match);
+- csharp/java/typescript: ';', '{', '}' and '//' inside string or template
+  literals do not end a statement or start a comment; '#' is a comment only in
+  python;
+- a bracket with only whitespace before it does not end the statement (the
+  benchmark's `if end_idx` skipped index 0);
+- typescript: a '{ ... }' group closed on the same line belongs to the statement;
+- a final line that is only '{' is ignored.
+"""
+from __future__ import annotations
+
+import argparse
+import ast
+import difflib
+import json
+import keyword
+import re
+import sys
+from pathlib import Path
+
+CCEVAL_COMMIT = "40c68d2b7ca2a8eae95d901ac80e6a540a84a53d"
+
+# --- scripts/keywords/*.txt (keywordlist.py: python uses keyword.kwlist) ---
+KEYWORDS = {
+    "java": """abstract assert boolean break byte case catch char class continue
+default do double else enum extends final finally float for if implements
+import instanceof int interface long native new package private protected
+public return short static strictfp super switch synchronized this throw
+throws transient try void volatile while var const goto""",
+    "csharp": """abstract as base bool break byte case catch char checked class
+const continue decimal default delegate do double else enum event explicit
+extern finally fixed float for foreach goto if implicit in int interface
+internal is lock long namespace new null object operator out override params
+private protected public readonly ref return sbyte sealed short sizeof
+stackalloc static string struct switch this throw try typeof uint ulong
+unchecked unsafe ushort using virtual void volatile while""",
+    "typescript": """break case catch class const continue debugger default delete
+do else export extends finally for function if import in instanceof new
+return super switch this throw try typeof var void while with yield enum
+implements interface let package private protected public static""",
+}
+
+
+def get_language_keywords(language):
+    language = language.lower()
+    if language == "python":
+        return frozenset(k for k in keyword.kwlist if k != "True" and k != "False")
+    return frozenset(KEYWORDS[language].split())
+
+
+# --- scripts/eval_utils.py ---
+IDENTIFIER_REGEX = re.compile("[_a-zA-Z][_a-zA-Z0-9]*")
+REGEX_TEXT = ("(?<=[a-z0-9])(?=[A-Z])|"
+              "(?<=[A-Z0-9])(?=[A-Z][a-z])|"
+              "(?<=[0-9])(?=[a-zA-Z])|"
+              "(?<=[A-Za-z])(?=[0-9])|"
+              "(?<=[@$.'\"])(?=[a-zA-Z0-9])|"
+              "(?<=[a-zA-Z0-9])(?=[@$.'\"])|"
+              "_|\\s+")
+string_pattern = r'"([^"\\]*(\\.[^"\\]*)*)"|\'([^\'\\]*(\\.[^\'\\]*)*)\''
+
+SPLIT_REGEX = re.compile(REGEX_TEXT)
+
+
+def code_tokenize(text):
+    """nltk RegexpTokenizer(r'\\w+').tokenize"""
+    return re.findall(r"\w+", text)
+
+
+def fuzz_ratio(s1, s2):
+    """fuzzywuzzy.fuzz.ratio without python-Levenshtein (the benchmark's install)."""
+    if s1 is None or s2 is None:
+        return 0
+    if s1 == s2:
+        return 100
+    return int(round(100 * difflib.SequenceMatcher(None, s1, s2).ratio()))
+
+
+def cal_edit_sim(references, hypotheses):
+    total = len(references)
+    edit_sim = 0.0
+    for pred, gt in zip(hypotheses, references):
+        pred = pred.strip()
+        gt = gt.strip()
+        edit_sim += fuzz_ratio(pred, gt)
+    return edit_sim / total
+
+
+def split_identifier_into_parts(identifier):
+    """
+    Split a single identifier into parts on snake_case and camelCase
+    """
+    identifier_parts = list(s for s in SPLIT_REGEX.split(identifier) if len(s) > 0)
+
+    if len(identifier_parts) == 0:
+        return [identifier]
+    if "_" in identifier:  # We consider "_" as part of identifier and add it back in between each semantic part
+        # if snake_case, we only split identifiers based on "_", ignore the mixed camelCase or other special symbols
+        # this helps us avoid splitting identifiers like "get_2d_array" into ["get", "2", "d", "array"]
+        # also avoid many other corner cases
+        identifier_parts = identifier.split("_")
+        tmp = [identifier_parts[0]]
+        for i in identifier_parts[1:]:
+            tmp.append("_")
+            tmp.append(i)
+        identifier_parts = tmp
+
+    return identifier_parts
+
+
+def is_identifier(token, lang=None):
+    return True if IDENTIFIER_REGEX.match(token) \
+                   and (lang is None or token not in get_language_keywords(lang)) \
+        else False
+
+
+def extract_identifiers(source_code, lang):
+    # the main idea is to remove String from a source code
+    # then, tokenize the code to get all words and match with identifier regular expression
+    # check if it is a language specific keyword, it not, then it is an identifier
+    source_code_without_strings = re.sub(string_pattern, '', source_code)
+    _ids = [t for t in code_tokenize(source_code_without_strings) if is_identifier(t, lang)]
+    return _ids
+
+
+def code_chars(s):
+    """(index, char) outside string and template literals; ${...} parts are code."""
+    i, n, state = 0, len(s), []
+    while i < n:
+        c = s[i]
+        top = state[-1] if state else None
+        if top in ('"', "'", '`'):
+            if c == '\\':
+                i += 2
+                continue
+            if c == top:
+                state.pop()
+            elif top == '`' and s.startswith('${', i):
+                state.append('${')
+                i += 2
+                continue
+            i += 1
+            continue
+        if c in ('"', "'", '`'):
+            state.append(c)
+        elif top == '${' and c == '}':
+            state.pop()
+        else:
+            yield i, c
+        i += 1
+
+
+def get_bracket_lang_statement(completion, inline_groups=False):
+    chars = list(code_chars(completion))
+    end_idx = None
+    k = 0
+    while k < len(chars):
+        i, c = chars[k]
+        if c in [";", "}", "{"]:
+            # A leading bracket (`} as Thread;`, `});`) is not a statement by itself.
+            if not completion[:i].strip():
+                k += 1
+                continue
+            if c == "{" and inline_groups:
+                # A group closed on the same line (object literal, destructuring)
+                # belongs to the statement; only a `{` left open starts a block.
+                depth, j, closed = 0, k, None
+                while j < len(chars):
+                    if chars[j][1] == "{":
+                        depth += 1
+                    elif chars[j][1] == "}":
+                        depth -= 1
+                        if depth == 0:
+                            closed = j
+                            break
+                    j += 1
+                if closed is not None and "\n" not in completion[i:chars[closed][0]]:
+                    k = closed + 1
+                    continue
+            end_idx = i
+            break
+        k += 1
+    return completion[:end_idx + 1] if end_idx is not None else completion
+
+
+def remove_comments(code, lang=None):
+    """'#' comments for python, '//' comments outside strings otherwise."""
+    if lang == "python":
+        return re.sub(r'#.*', '', code)
+    out, last = [], 0
+    for i, c in code_chars(code):
+        if c == '/' and code.startswith('//', i):
+            j = code.find('\n', i)
+            j = len(code) if j < 0 else j
+            out.append(code[last:i])
+            last = j
+    out.append(code[last:])
+    return ''.join(out)
+
+
+def is_parse_valid(parser, code):
+    """Benchmark: tree-sitter parse tree without ERROR nodes. Here: ast.parse."""
+    try:
+        ast.parse(code)
+        return True
+    except (SyntaxError, ValueError, RecursionError, MemoryError):
+        return False
+
+
+def get_python_one_statement(prompt, completion, parser):
+    for i in range(len(completion)):
+        code = prompt + completion[:i + 1]
+        if not is_parse_valid(parser, code):
+            continue
+        if completion[i + 1] == "\n":
+            return completion[:i + 1].rstrip()
+
+    return completion
+
+
+def postprocess_code_lines(prompt, completion, parser, lang):
+    try:
+        if lang in ["java", "csharp", "typescript"]:
+            return get_bracket_lang_statement(completion, inline_groups=(lang == "typescript"))
+        elif lang == "python":
+            return get_python_one_statement(prompt, completion, parser)
+    except Exception as e:
+        return completion
+
+
+# --- scripts/eval_metric.py ---
+def compute_id_match(pred_ids, target_ids):
+    pred_ids = list(set(pred_ids))
+    target_ids = list(set(target_ids))
+    tp = 0
+    fp = 0
+    fn = 0
+    for pid in pred_ids:
+        if pid in target_ids:
+            tp += 1
+        else:
+            fp += 1
+    for tid in target_ids:
+        if tid not in pred_ids:
+            fn += 1
+    return tp, fp, fn
+
+
+def normalized_lines(code):
+    return [l.strip() for l in code.split("\n") if l.strip()]
+
+
+def score(prompt, pred, groundtruth, lang):
+    """process_examples plus the per-sample block of compute_metric_stmt."""
+    prediction = remove_comments(postprocess_code_lines(prompt, pred, None, lang), lang)
+    target = remove_comments(postprocess_code_lines(prompt, groundtruth, None, lang), lang)
+    target_truncated = normalized_lines(target) != normalized_lines(remove_comments(groundtruth, lang))
+
+    pred_lines = normalized_lines(prediction)
+    gt_lines = normalized_lines(target)
+    # A trailing lone "{" (C# method headers) carries no information.
+    if len(pred_lines) > 1 and pred_lines[-1] == "{":
+        pred_lines = pred_lines[:-1]
+    if len(gt_lines) > 1 and gt_lines[-1] == "{":
+        gt_lines = gt_lines[:-1]
+    em_label = int(pred_lines == gt_lines)
+
+    pred_ids = extract_identifiers(prediction, lang)
+    target_ids = extract_identifiers(target, lang)
+
+    identifier_em = int(pred_ids == target_ids)
+    es = cal_edit_sim([target], [prediction])
+    id_tp, id_fp, id_fn = compute_id_match(pred_ids, target_ids)
+    return {
+        "em": em_label,
+        "es": es,
+        "id_em": identifier_em,
+        "id_precision": id_tp / (id_tp + id_fp) if (id_tp + id_fp) != 0 else 0,
+        "id_recall": id_tp / (id_tp + id_fn) if (id_tp + id_fn) != 0 else 0,
+        "id_f1": 2 * id_tp / (2 * id_tp + id_fp + id_fn) if (2 * id_tp + id_fp + id_fn) != 0 else 0,
+    }, {"pred": prediction, "target": target, "pred_ids": pred_ids, "target_ids": target_ids,
+        "pred_lines": pred_lines, "gt_lines": gt_lines, "target_truncated": target_truncated}
+
+
+# --- plumbing ---
+def read_text(path):
+    return Path(path).read_bytes().decode("utf-8", "replace")
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--language", required=True, choices=["csharp", "java", "python", "typescript"])
+    ap.add_argument("--prediction", required=True, help="the agent's answer file")
+    ap.add_argument("--reference", required=True, help="the task's groundtruth file")
+    ap.add_argument("--prompt", default=None, help="code before the cursor (python truncation)")
+    ap.add_argument("--out", required=True, help="verifier output directory")
+    a = ap.parse_args(argv)
+    out = Path(a.out)
+    out.mkdir(parents=True, exist_ok=True)
+    groundtruth = read_text(a.reference)
+    missing = not Path(a.prediction).is_file()
+    pred = "" if missing else read_text(a.prediction)
+    prompt = read_text(a.prompt) if a.prompt and Path(a.prompt).is_file() else ""
+    metrics, detail = score(prompt, pred, groundtruth, a.language)
+    rewards = {"reward": metrics["em"], "es": metrics["es"], "id_em": metrics["id_em"],
+               "id_precision": metrics["id_precision"], "id_recall": metrics["id_recall"], "id_f1": metrics["id_f1"]}
+    (out / "reward.json").write_text(json.dumps(rewards) + "\n")
+    (out / "reward.txt").write_text(f"{metrics['em']}\n")
+    detail.update(language=a.language, cceval_commit=CCEVAL_COMMIT, prediction_missing=missing,
+                  prompt_chars=len(prompt))
+    (out / "metrics.json").write_text(json.dumps(detail, indent=2) + "\n")
+    lines = [f"{'PASS' if metrics['em'] else 'FAIL'}[cceval-em] es={metrics['es']} id_f1={metrics['id_f1']:.3f}"]
+    if missing:
+        lines.append(f"no prediction file: {a.prediction}")
+    if detail["target_truncated"]:
+        lines.append("reference truncated to its first statement (the benchmark would not truncate it)")
+    if not metrics["em"]:
+        lines += list(difflib.unified_diff(detail["gt_lines"], detail["pred_lines"], "reference", "prediction", lineterm=""))
+    (out / "test_output.txt").write_text("\n".join(lines) + "\n")
+    print("\n".join(lines))
+    return 0 if metrics["em"] else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+'''
+
+
+# The pinned upstream: which TaskTrove files this patch reads, at which revision,
+# and the name each repaired set is published under. --all fetches and patches
+# every one of them, so "run the patcher on the pinned upstream" is one command.
+UPSTREAM_REPO = 'open-thoughts/TaskTrove'
+UPSTREAM_REVISION = '96567362fa3c41208e0954317c53767023b420eb'
+SOURCES = {
+    'csharp': ('deprecated/laion__exp_rpt_crosscodeeval-csharp-v4', 'laion__exp_rpt_crosscodeeval-csharp-v5'),
+    'java': ('laion__exp_rpt_crosscodeeval-java-v3', 'laion__exp_rpt_crosscodeeval-java-v4'),
+    'python': ('deprecated/laion__exp_rpt_crosscodeeval-python-v2', 'laion__exp_rpt_crosscodeeval-python-v3'),
+    'typescript': ('deprecated/laion__exp_rpt_crosscodeeval-typescript-v2', 'laion__exp_rpt_crosscodeeval-typescript-v3'),
+}
+
+RETRIEVERS = ('rg1_bm25', 'rg1_unixcoder_cosine_sim', 'rg1_openai_cosine_sim')
+COMMON_REPOS = 3
+LITERALS = frozenset('true false null undefined None True False this self super NaN Infinity void'.split())
+VERBS = frozenset("""get set is has to from load build create make add remove update find read
+write parse init new on handle compute check fetch put with use apply run do try can should
+validate convert render register resolve format open close start stop enable disable reset
+clear delete save send receive emit ensure as into for by of at""".split())
+# Known without context: keywords missing from the benchmark's keyword lists,
+# language globals, standard and dominant framework APIs (from a review of
+# names that alone blocked dropped tasks).
+KNOWN_NAMES = {
+    'csharp': frozenset("""where var async await dynamic partial yield nameof
+        System Console Convert Math String Guid DateTime TimeSpan Enumerable Dictionary List HashSet
+        Exception ArgumentNullException ArgumentException InvalidOperationException NotImplementedException
+        Environment Path File Directory Regex Encoding CancellationToken Task IEnumerable Func Action
+        StringComparer StringComparison StringBuilder Nullable Tuple KeyValuePair
+        Rigidbody Collider Collision AudioClip AudioSource Material Transform GameObject Vector2 Vector3
+        Quaternion MonoBehaviour Debug Instantiate Destroy Time Mathf Input Camera Color Animator Physics
+        Renderer SpriteRenderer Texture2D Sprite Coroutine WaitForSeconds Resources Random
+        HarmonyPatch HarmonyPrefix HarmonyPostfix HarmonyBefore HarmonyAfter HarmonyPriority
+        __instance __result __state""".split()),
+    'java': frozenset("""record sealed permits yield
+        System Integer Long Double Float Boolean Character Byte Short String Math Collections Arrays Objects
+        Optional List Map Set HashMap ArrayList LinkedList HashSet TreeMap Collectors Stream Thread Runnable
+        Exception RuntimeException IllegalArgumentException IllegalStateException NullPointerException
+        StringBuilder Files Paths Path UUID Duration Instant LocalDate LocalDateTime TimeUnit Logger Random
+        singleton singletonList emptyList emptyMap unmodifiableList containsValue relativize drawOval
+        currentTimeMillis nanoTime printStackTrace parseInt valueOf toString equals hashCode format
+        requireNonNull assertEquals assertTrue assertFalse assertNotNull assertNull
+        getAndIncrement getDeclaredConstructor""".split()),
+    'python': frozenset("""assertEqual assertEquals assertTrue assertFalse assertIn assertIsNone assertRaises
+        asarray zeros ones reshape flat ndarray iloc loc DataFrame Series
+        requires_grad_ no_grad tensor cuda device vmap jit grad""".split()),
+    'typescript': frozenset("""unknown keyof never readonly infer satisfies declare override namespace as is asserts
+        type of get set
+        JSON Math Object Array Promise Number String Boolean Date Map Set WeakMap Symbol Error TypeError RegExp
+        console window document navigator globalThis process Buffer setTimeout setInterval clearTimeout
+        fetch Response Request Headers URL URLSearchParams Iterable Iterator IterableIterator
+        Partial Record Pick Omit Required Readonly ReturnType Parameters Awaited NonNullable
+        Uint8Array ArrayBuffer TextEncoder TextDecoder byteLength GPUBufferUsage GPUDevice GPUBuffer mappedAtCreation
+        closest querySelector querySelectorAll addEventListener getBoundingClientRect
+        lstatSync statSync readFileSync writeFileSync existsSync readdirSync mkdirSync
+        join resolve dirname basename tap""".split()),
+}
+# API position: after '.', 'new ' or '::', or before '(' or '<' (not prose in comments/strings).
+API_USE = re.compile(r'(?:(?<=\.)|(?<=\bnew )|(?<=::))[A-Za-z_][A-Za-z0-9_]*|[A-Za-z_][A-Za-z0-9_]*(?=\s*[(<])')
+
+
+def gold_path(language):
+    return 'tests/expected.txt' if language == 'java' else 'tests/solution.txt'
+
+
+def load_verifier():
+    module = types.ModuleType('cceval_verifier')
+    exec(compile(VERIFIER, 'cceval_verifier.py', 'exec'), module.__dict__)
+    return module
+
+
+_verifier = None
+
+
+def verifier_module():
+    global _verifier
+    if _verifier is None:
+        _verifier = load_verifier()
+    return _verifier
+
+
+def key(lang, prompt_text, gold):
+    return hashlib.sha256(json.dumps([lang, prompt_text, gold], ensure_ascii=False).encode()).hexdigest()
+
+
+def norm(s):
+    return re.sub(r"\s+", " ", s).strip()
+
+
+def unpack(blob):
+    with tarfile.open(fileobj=io.BytesIO(blob), mode="r:*") as t:
+        return {m.name.removeprefix("./"): t.extractfile(m).read() for m in t if m.isfile()}
+
+
+def pack(files):
+    b = io.BytesIO()
+    with tarfile.open(fileobj=b, mode="w:gz") as t:
+        for name, data in files.items():
+            info = tarfile.TarInfo(name)
+            info.size = len(data)
+            info.mode = 0o755 if name.endswith('.sh') else 0o644
+            t.addfile(info, io.BytesIO(data))
+    return b.getvalue()
+
+
+def prompt(files):
+    """The code to complete. Source comments can contain Markdown fences, so the
+    fence before "## Your Task" ends the block, not the first one."""
+    s = files.get('instruction.md', b'').decode('utf8', 'replace')
+    m = re.search(r"## Context \(Code to Complete\)\s*\n```[^\n]*\n(.*?)\n```[ \t]*(?=\n+## Your Task(?:\n|$)|\s*\Z)", s, re.S)
+    return m.group(1) if m else None
+
+
+def correct_grading_instruction(instruction):
+    """Drop the legacy grading bullet and its partial-credit promises."""
+    before, separator, task = instruction.rpartition("\n## Your Task")
+    if not separator:
+        return instruction
+    task = re.sub(r"\s+It\s+also accepts[^\n]*(?:\n(?![ \t]*\n)[^\n]*)*", "", task)
+    task = re.sub(r"\n- The verifier byte-compares your fragment to a reference[^\n]*(?:\n(?![ \t]*\n)[^\n]*)*", "", task)
+    return before + separator + task
+
+
+def add_oracle(files, language, original=None):
+    """solution/solve.sh copies the reference (upstream groundtruth when matched)."""
+    reference = files[gold_path(language)]
+    source = 'packaged_gold'
+    if original is not None:
+        reference = original['groundtruth'].encode('utf-8')
+        if reference != files[gold_path(language)]:
+            raise ValueError('Upstream groundtruth differs from the verifier reference')
+        source = 'upstream'
+    if not reference.strip():
+        raise ValueError(f'Empty oracle reference: {gold_path(language)}')
+    files['solution/solution_snippet.txt'] = reference
+    files['solution/solve.sh'] = b'#!/bin/bash\nset -euo pipefail\nmkdir -p /app\ncp /solution/solution_snippet.txt /app/solution.txt\n'
+    return source
+
+
+# Versions installed when the images were built and oracle/no-answer were validated
+# (python:3.10-slim, Python 3.10.21, 2026-09-29). Packages they pull in are not pinned.
+PIP_PINS = {'pytest': '9.1.1', 'pytest-timeout': '2.4.0'}
+
+
+def pin_pip_installs(files):
+    """Pin the packages named in the Dockerfile's pip installs; an unknown one is an error."""
+    name = 'environment/Dockerfile'
+    if name not in files:
+        return False
+    def pin(line):
+        words = line.group(0).split()
+        for i, word in enumerate(words[3:], 3):
+            if word.startswith('-') or '==' in word:
+                continue
+            if word not in PIP_PINS:
+                raise ValueError(f'No pinned version for pip package {word!r}; add it to PIP_PINS')
+            words[i] = f'{word}=={PIP_PINS[word]}'
+        return ' '.join(words)
+    before = files[name].decode('utf-8')
+    after = re.sub(r'^RUN pip install [^\n]*$', pin, before, flags=re.M)
+    files[name] = after.encode('utf-8')
+    return after != before
+
+
+def benchmark_verifier(files, language, prompt_text=None):
+    """Install the scorer and return the new tests/test.sh."""
+    files['tests/cceval_verifier.py'] = VERIFIER.encode('utf-8')
+    if language == 'python' and prompt_text is not None:
+        files['tests/prompt.txt'] = prompt_text.encode('utf-8')
+    return (f'#!/bin/bash\nmkdir -p /logs/verifier\n'
+            f'exec python3 /tests/cceval_verifier.py --language {language} --prediction /app/solution.txt'
+            f' --reference /{gold_path(language)} --prompt /tests/prompt.txt --out /logs/verifier\n').encode()
+
+
+def context_file_name(name):
+    """Repository paths become one file name: '/' -> '__'. Other characters stay as
+    they are; the static checks work on a renamed copy when a name needs it."""
+    return name.replace('/', '__')
+
+
+def whole_word(ident, text):
+    return re.search(r'(?<![A-Za-z0-9_])' + re.escape(ident) + r'(?![A-Za-z0-9_])', text) is not None
+
+
+def parts_of(ident):
+    parts = [p for p in verifier_module().split_identifier_into_parts(ident) if p and p != '_']
+    if len(parts) > 1 and parts[0].lower() in VERBS:
+        parts = parts[1:]
+    return [p.lower() for p in parts if len(p) >= 2 and not p.isdigit()]
+
+
+_stdlib_names = None
+
+
+def python_stdlib_names():
+    """Attribute names of builtins and of every importable stdlib module and its classes."""
+    global _stdlib_names
+    if _stdlib_names is None:
+        import builtins, importlib, inspect, warnings
+        names = set(dir(builtins))
+        skip = {'antigravity', 'this', 'idlelib', 'turtledemo', 'tkinter.tix', '__main__'}
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore')
+            for mod in sorted(sys.stdlib_module_names - skip):
+                try:
+                    m = importlib.import_module(mod)
+                except Exception:
+                    continue
+                names.update(dir(m))
+                for _, cls in inspect.getmembers(m, inspect.isclass):
+                    names.update(dir(cls))
+        _stdlib_names = frozenset(n for n in names if not n.startswith('_'))
+    return _stdlib_names
+
+
+def classify(ident, text, is_common=lambda ident: False, stdlib=frozenset(), known=frozenset()):
+    """'word' | 'parts' | 'trivial' | 'literal' | 'stdlib' | 'known' | 'common' | 'missing'"""
+    if whole_word(ident, text):
+        return 'word'
+    parts = parts_of(ident)
+    if not parts:
+        return 'trivial'
+    if all(p in text.lower() for p in parts):
+        return 'parts'
+    if ident in LITERALS:
+        return 'literal'
+    if ident in stdlib:
+        return 'stdlib'
+    if ident in known:
+        return 'known'
+    return 'common' if is_common(ident) else 'missing'
+
+
+def reference_identifiers(gold, lang, prompt_text=''):
+    """Identifiers of the graded reference, computed exactly as the verifier does."""
+    v = verifier_module()
+    target = v.remove_comments(v.postprocess_code_lines(prompt_text, gold, None, lang), lang)
+    return sorted(set(v.extract_identifiers(target, lang)))
+
+
+def reference_verdicts(gold, lang, text, is_common=lambda ident: False, stdlib=frozenset(), prompt_text=''):
+    known = KNOWN_NAMES.get(lang, frozenset())
+    return {i: classify(i, text, is_common, stdlib, known) for i in reference_identifiers(gold, lang, prompt_text)}
+
+
+def recoverable(verdicts):
+    return 'missing' not in verdicts.values()
+
+
+def context_chunks(record, gold):
+    """Retrieved excerpts minus empty ones, target-file ones and ones containing the reference."""
+    target = PurePosixPath(record.get('metadata', {}).get('file', '')).as_posix()
+    counts = dict.fromkeys(('context_chunks', 'kept_chunks', 'dropped_empty', 'dropped_target', 'dropped_gold'), 0)
+    kept = []
+    for c in (record.get('crossfile_context') or {}).get('list', []):
+        text = c.get('retrieved_chunk', '')
+        name = PurePosixPath(c.get('filename', '')).as_posix()
+        counts['context_chunks'] += 1
+        if not text.strip():
+            counts['dropped_empty'] += 1
+        elif name == target:
+            counts['dropped_target'] += 1
+        elif gold.strip() and (gold.strip() in text or norm(gold) in norm(text)):
+            counts['dropped_gold'] += 1
+        else:
+            kept.append((name, text))
+            counts['kept_chunks'] += 1
+    return kept, counts
+
+
+def load_original(archive, retrievers=RETRIEVERS):
+    """{retriever: {key: [records]}} from the pinned upstream archive."""
+    idx = {r: {} for r in retrievers}
+    with tarfile.open(archive, 'r:*') as t:
+        for m in t:
+            name = PurePosixPath(m.name).name
+            retriever = name[len('line_completion_'):-len('.jsonl')]
+            if not (m.isfile() and name.startswith('line_completion_') and name.endswith('.jsonl') and retriever in idx):
+                continue
+            lang = PurePosixPath(m.name).parts[0]
+            for line in t.extractfile(m):
+                r = json.loads(line)
+                idx[retriever].setdefault(key(lang, r['prompt'], r['groundtruth']), []).append(r)
+    return idx
+
+
+def choose_context(files, lang, prompt_text, gold, k, matches, originals, is_common, stdlib):
+    """First retrieval whose excerpts make every reference name knowable, plus the
+    unknowable names per tried retrieval (None: no unique record there)."""
+    instruction = files['instruction.md'].decode('utf8', 'replace')
+    missing = {}
+    for retriever in RETRIEVERS:
+        candidates = matches if retriever == 'rg1_bm25' else originals[retriever].get(k, [])
+        if len(candidates) != 1:
+            missing[retriever] = None
+            continue
+        kept, counts = context_chunks(candidates[0], gold)
+        visible = instruction + '\n' + '\n'.join(n for n, _ in kept) + '\n' + '\n'.join(t for _, t in kept)
+        verdicts = reference_verdicts(gold, lang, visible, is_common, stdlib, prompt_text)
+        if recoverable(verdicts):
+            return (retriever, kept, counts, verdicts), missing
+        missing[retriever] = [i for i, v in verdicts.items() if v == 'missing']
+    return None, missing
+
+
+def graded_reference(gold, lang, prompt_text=''):
+    """The part of the reference the verifier actually compares."""
+    return verifier_module().postprocess_code_lines(prompt_text, gold, None, lang)
+
+
+def write_review(out, records, sample=40, seed=20260916):
+    """Why each dropped task was dropped, plus a sample of them to read.
+
+    Only the dropped ones are written out: the kept tasks are the output parquet,
+    and their verdicts are counted in the report.
+    """
+    out.mkdir(parents=True, exist_ok=True)
+    dropped = [r for r in records if not r['kept']]
+    with open(out / 'dropped.jsonl', 'w') as f:
+        for r in dropped:
+            f.write(json.dumps(r) + '\n')
+    import random
+    picked = random.Random(seed).sample(dropped, min(sample, len(dropped)))
+    md = ['# Dropped tasks, sampled for review', '',
+          f'{len(dropped)} of {len(records)} tasks were dropped; {len(picked)} shown.', '']
+    for r in picked:
+        md += [f"## {r['task']} ({r['language']}) - {r['reason']}", '',
+               '```', r['graded_reference'].strip(), '```', '',
+               f"unknowable names: {', '.join(r['missing_names']) or '(none)'}", '']
+    (out / 'sample.md').write_text('\n'.join(md))
+    return len(dropped)
+
+
+def fetch_upstream(dest):
+    """The pinned upstream parquets, downloaded once into <dest>/<source name>/."""
+    from huggingface_hub import hf_hub_download
+    out = {}
+    for lang, (src, published) in SOURCES.items():
+        path = Path(hf_hub_download(UPSTREAM_REPO, f'{src}/tasks.parquet', repo_type='dataset',
+                                    revision=UPSTREAM_REVISION, local_dir=dest))
+        out[lang] = (path, published)
+        print(f'{src}/tasks.parquet -> {path}', file=sys.stderr)
+    return out
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument('--input', help='one upstream parquet')
+    ap.add_argument('--output', help='where the repaired parquet goes')
+    ap.add_argument('--all', action='store_true',
+                    help=f'fetch and patch every source of {UPSTREAM_REPO} at {UPSTREAM_REVISION[:8]}')
+    ap.add_argument('--upstream', type=Path, default=Path(os.environ.get('OT_WORKSPACE', '.')) / 'upstream',
+                    help='where --all downloads the pinned parquets')
+    ap.add_argument('--outdir', type=Path, default=Path(os.environ.get('OT_WORKSPACE', '.')) / 'patched',
+                    help='where --all writes the repaired parquets')
+    ap.add_argument('--archive', help='the upstream cceval archive; not needed with --pin-only')
+    ap.add_argument('--pin-only', action='store_true',
+                    help='only pin the pip installs of an already patched parquet (--input, --output)')
+    a = ap.parse_args()
+    if a.pin_only:
+        if not (a.input and a.output):
+            raise SystemExit('--pin-only needs --input and --output')
+        print(json.dumps(pin_parquet(Path(a.input), Path(a.output))))
+        return
+    if not a.archive:
+        raise SystemExit('--archive is required')
+    if a.all:
+        originals = load_original(a.archive)
+        for lang, (src, published) in fetch_upstream(a.upstream).items():
+            out = a.outdir / published / 'tasks.parquet'
+            print(f'\n=== {lang}: {src} -> {out}', file=sys.stderr)
+            patch_parquet(src, out, originals)
+        return
+    if not (a.input and a.output):
+        raise SystemExit('pass --all, or both --input and --output')
+    patch_parquet(Path(a.input), Path(a.output), load_original(a.archive))
+
+
+def pin_parquet(input_path, output_path):
+    """Pin the pip installs of every task; all other files keep their bytes."""
+    parent_manifest = input_path.with_suffix('.manifest.json')
+    provenance = json.loads(parent_manifest.read_text()) if parent_manifest.exists() else None
+    if provenance:
+        original = provenance.get('original_parquet')
+        if not original:
+            raise ValueError('pin-only reporting needs a manifest with original_parquet; rerun the full patcher')
+        with Path(original['path']).open('rb') as stream:
+            if hashlib.file_digest(stream, 'sha256').hexdigest() != original['sha256']:
+                raise ValueError('original Parquet changed since the full patch run')
+        for artifact in (output_path.with_suffix('.archive.parquet'), output_path.with_suffix('.manifest.json')):
+            if artifact.exists():
+                raise ValueError(f'Use a new output location; reporting artifact exists: {artifact}')
+    table = pq.read_table(input_path)
+    rows = {n: [] for n in table.column_names}
+    pinned = 0
+    for row in table.to_pylist():
+        files = unpack(row['task_binary'])
+        if pin_pip_installs(files):
+            pinned += 1
+            row['task_binary'] = pack(files)
+        for n in rows:
+            rows[n].append(row[n])
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    pq.write_table(pa.table(rows, schema=table.schema), output_path)
+    if provenance:
+        sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+        from data.utils.patch_reporting import write_patch_report
+        write_patch_report(original['path'], output_path, patcher=__file__, source=provenance['source'],
+            dropped={task['task_id']: {'category': task['labels'][0], 'reason': task['reason']}
+                     for task in provenance['tasks'] if task['action'] == 'dropped'},
+            file_labels=CHANGE_FILE_LABELS,
+            change_reasons={task['task_id']: task.get('reason') or change_explanation(
+                any(name.startswith('setup_files/context/') for name in task['changed_files']))
+                for task in provenance['tasks'] if task['action'] == 'changed'},
+            patches=[*provenance.get('patches', []), {'operation': 'pin-only', 'pins': PIP_PINS}])
+    return {'input': str(input_path), 'input_sha256': hashlib.sha256(input_path.read_bytes()).hexdigest(),
+            'output': str(output_path), 'output_sha256': hashlib.sha256(output_path.read_bytes()).hexdigest(),
+            'tasks': table.num_rows, 'pinned': pinned, 'pins': PIP_PINS}
+
+
+def patch_parquet(input_path, output_path, originals):
+    for artifact in (output_path.with_suffix('.archive.parquet'), output_path.with_suffix('.manifest.json')):
+        if artifact.exists():
+            raise ValueError(f'Use a new output location; reporting artifact exists: {artifact}')
+    table = pq.read_table(input_path)
+    stats = dict.fromkeys(('rows', 'unique', 'unmatched', 'ambiguous', 'kept', 'dropped', 'dropped_no_identifiers',
+                           'oracle_upstream', 'oracle_packaged_gold', 'context_chunks', 'kept_chunks',
+                           'dropped_empty', 'dropped_target', 'dropped_gold', 'pinned_pip_installs'), 0)
+    stats.update(unmatched_task_ids=[], ambiguous_task_ids=[], dropped_task_ids=[], dropped_no_identifiers_task_ids=[],
+                 context_source={r: 0 for r in RETRIEVERS}, context_source_task_ids={r: [] for r in RETRIEVERS},
+                 missing_by_retriever={}, identifier_verdicts={}, common_repos=COMMON_REPOS,
+                 python_version=sys.version.split()[0])
+
+    # Pass 1: match rows; per repository, the names used in API position in its BM25 view.
+    prepared, repos_with = [], {}
+    for row in table.to_pylist():
+        files = unpack(row['task_binary'])
+        lang = re.search(r'crosscodeeval-(\w+)-', row['path']).group(1)
+        p = prompt(files)
+        gold = files.get('tests/solution.txt', files.get('tests/expected.txt', b'')).decode('utf8', 'replace')
+        k = key(lang, p, gold) if p is not None else None
+        matches = originals['rg1_bm25'].get(k, []) if k else []
+        match = matches[0] if len(matches) == 1 else None
+        repo = match['metadata'].get('repository', row['path']) if match else row['path']
+        text = files['instruction.md'].decode('utf8', 'replace')
+        if match:
+            text += '\n' + '\n'.join(t for _, t in context_chunks(match, gold)[0])
+        for name in set(API_USE.findall(text)):
+            repos_with.setdefault(name, set()).add(repo)
+        prepared.append((row, files, lang, p, gold, k, matches, match, repo))
+    stdlib = python_stdlib_names() if any(x[2] == 'python' for x in prepared) else frozenset()
+
+    review_dir = output_path.parent / 'review'
+    rows = {n: [] for n in table.column_names}
+    review = []
+
+    def record(row, lang, gold, p, kept, reason, retriever=None, verdicts=None, missing=None):
+        review.append({'task': row['path'], 'language': lang, 'kept': kept, 'reason': reason,
+                       'retriever': retriever, 'verdicts': verdicts or {},
+                       'missing_names': sorted({n for names in (missing or {}).values()
+                                                for n in (names or [])}),
+                       'graded_reference': graded_reference(gold, lang, p or '')})
+
+    for row, files, lang, p, gold, k, matches, match, repo in prepared:
+        stats['rows'] += 1
+        if not reference_identifiers(gold, lang, p or ''):
+            stats['dropped_no_identifiers'] += 1
+            stats['dropped_no_identifiers_task_ids'].append(row['path'])
+            record(row, lang, gold, p, False, NO_NAMES_EXPLANATION)
+            continue
+        if match is None:
+            stats['unmatched' if not matches else 'ambiguous'] += 1
+            stats['unmatched_task_ids' if not matches else 'ambiguous_task_ids'].append(row['path'])
+        else:
+            stats['unique'] += 1
+            is_common = lambda ident, repo=repo: len(repos_with.get(ident, set()) - {repo}) >= COMMON_REPOS
+            chosen, missing = choose_context(files, lang, p or '', gold, k, matches, originals, is_common, stdlib)
+            if missing:
+                stats['missing_by_retriever'][row['path']] = missing
+            if chosen is None:
+                stats['dropped'] += 1
+                stats['dropped_task_ids'].append(row['path'])
+                names = sorted({name for values in missing.values() for name in (values or [])})
+                record(row, lang, gold, p, False,
+                       MISSING_NAMES_EXPLANATION + ' Names missing from one or more sets of excerpts: '
+                       + ', '.join(names), missing=missing)
+                continue
+            retriever, kept, counts, verdicts = chosen
+            record(row, lang, gold, p, True, 'kept', retriever, verdicts, missing)
+            stats['context_source'][retriever] += 1
+            stats['context_source_task_ids'][retriever].append(row['path'])
+            for n, c in counts.items():
+                stats[n] += c
+            for v in verdicts.values():
+                stats['identifier_verdicts'][v] = stats['identifier_verdicts'].get(v, 0) + 1
+            for i, (name, text) in enumerate(kept):
+                files[f'setup_files/context/{i:03d}_{context_file_name(name) or f"context_{i}.txt"}'] = text.encode()
+            instruction = files['instruction.md'].decode('utf8', 'replace')
+            if kept and '/setup_files/context/' not in instruction:
+                files['instruction.md'] = (instruction.rstrip() + CONTEXT_NOTE).encode()
+        if match is None:
+            record(row, lang, gold, p, True, 'kept without context (no unique upstream match)')
+        stats['kept'] += 1
+        if 'tests/test.sh' in files:
+            files['tests/test.sh'] = benchmark_verifier(files, lang, p)
+        files['instruction.md'] = correct_grading_instruction(files['instruction.md'].decode('utf-8')).encode('utf-8')
+        stats[f'oracle_{add_oracle(files, lang, match)}'] += 1
+        stats['pinned_pip_installs'] += pin_pip_installs(files)
+        row['task_binary'] = pack(files)
+        for n in rows:
+            rows[n].append(row[n])
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    pq.write_table(pa.table(rows, schema=table.schema), output_path)
+    sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+    from data.utils.patch_reporting import write_patch_report
+    write_patch_report(input_path, output_path, patcher=__file__,
+        file_labels=CHANGE_FILE_LABELS,
+        change_reasons={entry['task']: change_explanation(entry['retriever'] is not None)
+                        for entry in review if entry['kept']},
+        source={'dataset': UPSTREAM_REPO, 'revision': UPSTREAM_REVISION,
+                'url': f'https://huggingface.co/datasets/{UPSTREAM_REPO}/tree/{UPSTREAM_REVISION}'},
+        dropped={entry['task']: {
+            'category': (NO_NAMES_LABEL if entry['task'] in stats['dropped_no_identifiers_task_ids']
+                         else MISSING_NAMES_LABEL),
+            'reason': entry['reason']} for entry in review if not entry['kept']},
+        patches=[{'patcher': 'data/crosscodeeval/patch.py',
+                  'sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest()}])
+    report = json.dumps(stats, indent=2)
+    output_path.with_suffix('.report.json').write_text(report + '\n')
+    print(report)
+    n = write_review(review_dir, review)
+    # stdout stays the report as JSON, so it can be piped; notes go to stderr.
+    print(f'review: {n} dropped tasks in {review_dir}/dropped.jsonl, sample in {review_dir}/sample.md',
+          file=sys.stderr)
+
+
+# Prepare
+"""Download the published repair at its immutable revision, then apply pip pins."""
+import argparse
+import json
+import os
+from pathlib import Path
+import sys
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+from huggingface_hub import hf_hub_download
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+REVISION = '12df4483fe99c79ccbb4c923d76ab5a2b042e64a'
+prepare_SOURCES = {'csharp-v5': 1353, 'java-v4': 1895, 'python-v3': 432, 'typescript-v3': 3030}
+
+
+def prepare_main(root):
+    root = root.resolve()
+    os.environ.setdefault('HF_HOME', str(root / 'cache/huggingface'))
+    records, sample = [], []
+    for family, count in prepare_SOURCES.items():
+        source = f'laion__exp_rpt_crosscodeeval-{family}/tasks.parquet'
+        original = hf_hub_download('open-thoughts/TaskTrove', source,
+                                   repo_type='dataset', revision=REVISION,
+                                   local_dir=root / 'published', cache_dir=root / 'cache/huggingface/hub')
+        output = root / 'parquets-pinned' / f'{family}.parquet'
+        record = pin_parquet(Path(original), output)
+        if record['tasks'] != count:
+            raise ValueError(f'Unexpected coverage: {record}')
+        records.append(record)
+        table = pq.read_table(output)
+        sample.append(table.slice(0, 3 if family.startswith(('csharp', 'java')) else 2))
+        print(json.dumps(record), flush=True)
+    provenance = {'dataset': 'open-thoughts/TaskTrove', 'revision': REVISION, 'files': records}
+    (root / 'parquets-pinned/source.json').write_text(json.dumps(provenance, indent=2) + '\n')
+    (root / 'sample').mkdir(exist_ok=True)
+    pq.write_table(pa.concat_tables(sample), root / 'sample/tasks.parquet')
+
+
+def prepare_cli():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('root', type=Path)
+    prepare_main(parser.parse_args().root)
+
+
+# Warmup
+"""Warm distinct CrossCodeEval environments and benchmark cached container I/O.
+
+Uses the real Harbor bridge and stages 3 -> 5 -> 4, without publishing or
+changing production caches. Inputs are already patched/materialized tasks;
+cross-file excerpts are supplied in setup_files, not downloaded Git checkouts.
+Explicit paths also allow use outside ZIH. Run only inside a CPU allocation.
+"""
+
+import argparse
+import asyncio
+from contextlib import contextmanager
+import hashlib
+import json
+import os
+from pathlib import Path
+import shutil
+import signal
+import subprocess
+import sys
+import time
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT))
+
+
+def save(path, value):
+    tmp = path.with_suffix('.tmp')
+    tmp.write_text(json.dumps(value, indent=2) + '\n')
+    tmp.replace(path)
+
+
+def fingerprint(directory):
+    """Same file-name/content digest as the patched bridge (not just Dockerfile)."""
+    digest = hashlib.sha256()
+    for path in sorted(directory.rglob('*')):
+        if path.is_file():
+            name, content = str(path.relative_to(directory)).encode(), path.read_bytes()
+            digest.update(len(name).to_bytes(4, 'big')); digest.update(name)
+            digest.update(len(content).to_bytes(4, 'big')); digest.update(content)
+    return digest.hexdigest()[:12]
+
+
+def inventory(tasks):
+    groups, languages = {}, {}
+    for task in sorted(tasks.iterdir()):
+        if not (task / 'task.toml').is_file():
+            continue
+        if not task.name.startswith('crosscodeeval-'):
+            raise ValueError(f'Expected patched CrossCodeEval tasks: {task}')
+        if not (task / 'environment/Dockerfile').is_file():
+            raise ValueError(f'Missing Dockerfile: {task}')
+        key = fingerprint(task / 'environment')
+        groups.setdefault(key, []).append(task)
+        languages.setdefault(task.name.rsplit('-', 1)[0], task)
+    if not groups:
+        raise ValueError('No materialized CrossCodeEval tasks found')
+    representatives = sorted(set(languages.values()) | {v[0] for v in groups.values()})
+    return groups, representatives
+
+
+def cache_files(cache, keys):
+    """Resolve symlinks; copy SIF and the adjacent deferred build companions."""
+    result = {}
+    for key in keys:
+        matches = sorted(cache.glob(f'*-{key}.sif'))
+        if not matches:
+            continue
+        source = matches[0].resolve(strict=True)
+        result[f'build_warmup-{key}.sif'] = source
+        for suffix in ('.deferred.json', '.overlay.img'):
+            companion = source.with_suffix(suffix)
+            if companion.exists():
+                result[f'build_warmup-{key}{suffix}'] = companion
+    return result
+
+
+def copy_cache(files, destination):
+    destination.mkdir(parents=True, exist_ok=True)
+    for name, source in files.items():
+        # Preserve sparse overlays; dereference shared-cache symlinks.
+        subprocess.run(['cp', '--sparse=always', '--reflink=auto', '--',
+                        str(source), str(destination / name)], check=True)
+
+
+@contextmanager
+def bridge(cache, scratch, out):
+    from hpc.validation_worker import free_port, wait_ready
+    import harbor
+    scratch.mkdir(parents=True)
+    out.mkdir(parents=True, exist_ok=True)
+    previous = os.environ.copy()
+    processes, logs = [], []
+    for key in ('APPTAINER_BIND', 'APPTAINER_BINDPATH', 'SINGULARITY_BIND', 'SINGULARITY_BINDPATH'):
+        os.environ.pop(key, None)
+    os.environ.update(TMPDIR=str(scratch), APPTAINER_TMPDIR=str(scratch / 'build'),
+        APPTAINER_NO_MOUNT='hostfs,bind-paths,cwd', APPTAINER_BINDPATH='/etc/resolv.conf:/etc/resolv.conf:ro',
+        BRIDGE_USE_FAKEROOT='1', BRIDGE_INSTANCE_REUSE='0', BRIDGE_START_CONCURRENCY='1',
+        BRIDGE_START_INTERVAL='0.25', OT_NET_ISOLATION='0', HARBOR_SIF_CACHE=str(cache),
+        OT_NETWORK_STATUS_PATH=str(out / 'network.json'))
+    (scratch / 'build').mkdir()
+    port = free_port(40000 + os.getpid() % 10000)
+    url = f'http://127.0.0.1:{port}'
+    os.environ['APPTAINER_BRIDGE_URL'] = url
+    launcher = ROOT / 'validation/stages/service_entrypoint.py'
+    server = Path(harbor.__file__).parent / 'environments/apptainer/server.py'
+    try:
+        commands = [
+            ('server', [str(server), '--host', '127.0.0.1', '--port', str(port)]),
+            ('worker', [str(ROOT / 'harbor_patches/bridge_worker.py'), '--bridge-url', url,
+                        '--sif-cache', str(cache), '--staging-base', str(scratch / 'instances'), '--num-workers', '2'])]
+        for name, command in commands:
+            log = (out / f'{name}.log').open('w'); logs.append(log)
+            processes.append(subprocess.Popen([sys.executable, '-u', str(launcher), *command],
+                             stdout=log, stderr=subprocess.STDOUT, start_new_session=True))
+            wait_ready(url + '/status', processes, timeout=600, workers=name == 'worker')
+        yield url
+    finally:
+        for process in reversed(processes):
+            if process.poll() is None:
+                os.killpg(process.pid, signal.SIGTERM)
+        for process in processes:
+            try:
+                process.wait(timeout=20)
+            except subprocess.TimeoutExpired:
+                os.killpg(process.pid, signal.SIGKILL); process.wait()
+        for log in logs:
+            log.close()
+        os.environ.clear(); os.environ.update(previous)
+
+
+async def measure(task, out, cache, url, journal, label, build_only=False):
+    from validation.stages import harbor as runtime
+    from validation.stages.runner import parser
+    from validation.stages.container_reuse import ReuseScope
+    from harbor.trial.trial import Trial
+    args = parser().parse_args([str(task), '--backend', 'apptainer', '--submit', 'never',
+                               '--trial-cpus', '1', '--trial-memory-mb', '2048'])
+    args.environment_kwargs = dict(bridge_url=url, sif_cache=str(cache))
+    # Instrument the actual harness copy, not a stand-in filesystem benchmark.
+    upload = Trial._upload_setup_files
+    upload_times = []
+    async def timed_upload(self):
+        started = time.monotonic()
+        try:
+            return await upload(self)
+        finally:
+            upload_times.append(time.monotonic() - started)
+    Trial._upload_setup_files = timed_upload
+    try:
+        async with ReuseScope() as scope:
+            for stage in ([3] if build_only else [3, 5, 4]):
+                stage_out = out / f'stage-{stage}'
+                stage_out.mkdir(parents=True)
+                if stage != 3:
+                    await scope.clear_logs()
+                upload_times.clear()
+                started = time.monotonic()
+                if stage == 3:
+                    result = await runtime.build_task(task, stage_out, args)
+                else:
+                    config = runtime.job_config(task, stage_out / 'jobs', args,
+                                                'nop' if stage == 5 else 'oracle')
+                    job_dir = await runtime.execute_job(config)
+                    result = runtime.assess_trials(runtime.trial_results(job_dir), 1, 0 if stage == 5 else 1)
+                record = dict(layout=label, task=task.name, stage=stage,
+                              seconds=time.monotonic() - started, setup_upload_seconds=list(upload_times),
+                              result=result, starts=scope.starts, reuses=scope.reuses)
+                journal.write(json.dumps(record) + '\n'); journal.flush(); os.fsync(journal.fileno())
+                print(json.dumps(record), flush=True)
+                if result['status'] not in ('passed', 'completed'):
+                    raise RuntimeError(f'{label} {task.name} stage {stage} failed; see durable outcomes.jsonl')
+            cleanup_started = time.monotonic()
+        journal.write(json.dumps(dict(layout=label, task=task.name, phase='container_cleanup',
+                                      seconds=time.monotonic() - cleanup_started)) + '\n')
+        journal.flush(); os.fsync(journal.fileno())
+    finally:
+        Trial._upload_setup_files = upload
+
+
+def warmup_main():
+    ap = argparse.ArgumentParser(description='Warm distinct CrossCodeEval environments and benchmark cached container I/O.\n\nUses the real Harbor bridge and stages 3 -> 5 -> 4, without publishing or\nchanging production caches. Inputs are already patched/materialized tasks;\ncross-file excerpts are supplied in setup_files, not downloaded Git checkouts.\nExplicit paths also allow use outside ZIH. Run only inside a CPU allocation.')
+    ap.add_argument('--tasks', type=Path, required=True)
+    ap.add_argument('--cache', type=Path, required=True, help='existing source image cache (read only)')
+    ap.add_argument('--out', type=Path, required=True, help='new durable run directory')
+    ap.add_argument('--local-root', type=Path, required=True, help='private scratch selected by cluster mapping')
+    ap.add_argument('--max-local-gib', type=float, default=8)
+    ap.add_argument('--repeats', type=int, default=2)
+    ap.add_argument('--warmup-only', action='store_true')
+    args = ap.parse_args()
+    if not os.environ.get('SLURM_JOB_ID'):
+        ap.error('Run in a Slurm CPU allocation')
+    if args.repeats < 1 or args.max_local_gib <= 0:
+        ap.error('repeats and max-local-gib must be positive')
+    args.out = args.out.resolve(); args.local_root = args.local_root.resolve()
+    if args.out.is_relative_to(Path.home()) or args.local_root.is_relative_to(Path.home()):
+        ap.error('Data and scratch must be outside home')
+    args.out.mkdir(parents=True, exist_ok=False)
+    groups, representatives = inventory(args.tasks)
+    save(args.out / 'inventory.json', dict(groups={k: [p.name for p in v] for k, v in groups.items()},
+         representatives=[p.name for p in representatives], source=str(args.tasks.resolve()),
+         cluster=os.environ.get('SLURM_CLUSTER_NAME'), partition=os.environ.get('SLURM_JOB_PARTITION'),
+         local_root=str(args.local_root), note='Cached-image starts, not cold builds; OS page cache is not flushed.'))
+    cache = args.out / 'images'
+    started = time.monotonic()
+    copy_cache(cache_files(args.cache, groups), cache)
+    save(args.out / 'cache-seed.json', dict(seconds=time.monotonic() - started))
+    with (args.out / 'outcomes.jsonl').open('x') as journal:
+        with bridge(cache, args.out / 'warmup-scratch', args.out / 'warmup-services') as url:
+            for key, tasks in groups.items():
+                asyncio.run(measure(tasks[0], args.out / 'warmup' / key, cache, url, journal, 'warmup', True))
+        if args.warmup_only:
+            return
+        files = cache_files(cache, groups)
+        if len([n for n in files if n.endswith('.sif')]) != len(groups):
+            raise RuntimeError('Warmup did not cache every distinct environment')
+        task_bytes = sum(p.stat().st_size for task in representatives for p in task.rglob('*') if p.is_file())
+        # Conservative apparent size (including sparse overlays) plus writable
+        # instance/build headroom. Only one task is live in this initial pilot.
+        needed = sum(p.stat().st_size for p in files.values()) + task_bytes + 4 * 2**30
+        args.local_root.mkdir(parents=True, exist_ok=True)
+        mount = subprocess.check_output(['findmnt', '-T', str(args.local_root), '-no', 'FSTYPE'], text=True).strip()
+        if mount == 'tmpfs':
+            memory_mb = int(os.environ.get('SLURM_MEM_PER_NODE', '0'))
+            if not memory_mb:
+                memory_mb = int(os.environ.get('SLURM_MEM_PER_CPU', '0')) * int(os.environ.get('SLURM_CPUS_PER_TASK', '1'))
+            if args.max_local_gib * 1024 > memory_mb / 4:
+                raise RuntimeError('RAM scratch budget must fit within one quarter of allocated job memory')
+        if needed > args.max_local_gib * 2**30 or needed > shutil.disk_usage(args.local_root).free:
+            raise RuntimeError(f'Local pilot needs at least {needed} bytes; exceeds budget/free space')
+        local = args.local_root / f'cce-warmup-{os.getpid()}'
+        local.mkdir()
+        try:
+            started = time.monotonic()
+            copy_cache(files, local / 'images')
+            image_seconds = time.monotonic() - started
+            started = time.monotonic()
+            for task in representatives:
+                shutil.copytree(task, local / 'tasks' / task.name)
+            save(args.out / 'staging.json', dict(image_seconds=image_seconds,
+                 task_seconds=time.monotonic() - started, estimated_peak_bytes=needed, filesystem=mount))
+            layouts = [('horse', cache, args.out / 'scratch', False),
+                       ('local-images', local / 'images', args.out / 'scratch', False),
+                       ('local-work', cache, local / 'scratch', True),
+                       ('local-both', local / 'images', local / 'scratch', True)]
+            for repeat in range(args.repeats):
+                # Reverse order on alternate repetitions to expose warm-cache/order effects.
+                for name, images, scratch, local_tasks in (layouts if repeat % 2 == 0 else layouts[::-1]):
+                    label = f'{repeat}-{name}'
+                    output = args.out / label
+                    with bridge(images, scratch / label, output / 'services') as url:
+                        for task in representatives:
+                            source = local / 'tasks' / task.name if local_tasks else task
+                            asyncio.run(measure(source, output / task.name, images, url, journal, label))
+            save(args.out / 'complete.json', dict(status='passed', repeats=args.repeats,
+                 tasks=len(representatives), layouts=len(layouts)))
+        finally:
+            shutil.rmtree(local)
+
+
+def warmup_cli():
+    warmup_main()
+
+
+# Rewards
+#!/usr/bin/env python3
+"""How to grade a CrossCodeEval answer locally, and which wrong answers are worth
+trying. tests/test_dataset_reward_plugins.py imports this module as
+`data.<dataset>.patch`; register new reward contracts in that test.
+"""
+import contextlib
+import importlib.util
+import io
+import json
+import re
+import tempfile
+from pathlib import Path
+
+# Where a trial's answer has to be for the task's tests/test.sh to grade it.
+ANSWER_PATH = '/app/solution.txt'
+
+
+def language(task: Path) -> str:
+    return re.search(r'-(\w+)-\d+$', task.name).group(1)
+
+
+def reference(task: Path) -> str:
+    """The graded reference solution, as shipped in the task."""
+    lang = language(task)
+    return (task / 'tests' / ('expected.txt' if lang == 'java' else 'solution.txt')).read_text()
+
+
+def grade(task: Path, answer: str) -> float:
+    """Reward for `answer`, using this task's own verifier, in this process."""
+    lang = language(task)
+    spec = importlib.util.spec_from_file_location('v', task / 'tests/cceval_verifier.py')
+    v = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(v)
+    gold_file = task / 'tests' / ('expected.txt' if lang == 'java' else 'solution.txt')
+    prompt = task / 'tests/prompt.txt'
+    with tempfile.TemporaryDirectory() as d:
+        pred = Path(d) / 'solution.txt'
+        pred.write_text(answer)
+        args = ['--language', lang, '--prediction', str(pred), '--reference', str(gold_file),
+                '--out', d + '/out']
+        if prompt.exists():
+            args += ['--prompt', str(prompt)]
+        with contextlib.redirect_stdout(io.StringIO()):
+            v.main(args)
+        return json.loads((Path(d) / 'out/reward.json').read_text())['reward']
+
+
+def extra_variants(task: Path, gold: str) -> dict[str, tuple[str, float]]:
+    """{label: (answer, expected reward)} beyond the generic reference/empty pair.
+
+    Each of these caught a real verifier defect:
+      re-indented reference   whitespace must not matter (Java's old diff failed this)
+      lone } ; {              what the retired TaskTrove verifier paid partial credit for
+      return null;            the most common trivial first statement
+      one identifier renamed  catches a verifier rewarding a prefix or first-token match
+    """
+    spec = importlib.util.spec_from_file_location('v', task / 'tests/cceval_verifier.py')
+    v = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(v)
+    ids = v.extract_identifiers(gold, language(task))
+    near = gold.replace(ids[0], ids[0] + 'Wrong', 1) if ids else gold + ' wrong'
+    reindented = '\n'.join('    ' + l.strip() for l in gold.splitlines()) + '\n'
+    return {'reference re-indented': (reindented, 1),
+            'garbage call': ('__PILOT_WRONG_ANSWER__();', 0),
+            'lone }': ('}', 0), 'lone ;': (';', 0), 'lone {': ('{', 0),
+            'return null;': ('return null;', 0),
+            'one identifier renamed': (near, 0)}
+
+
+def rewards_cli():
+    import argparse
+    parser = argparse.ArgumentParser(description="Grade one task with its own verifier")
+    parser.add_argument("task", type=Path)
+    task = parser.parse_args().task
+    gold = reference(task)
+    for label, (answer, want) in {"reference": (gold, 1), "empty answer": ("", 0), **extra_variants(task, gold)}.items():
+        print(label, grade(task, answer), "expected", want)
+
+
+
+def prepare_release(root):
+    """Repackage the existing release, preserving every retained task byte."""
+    from collections import Counter
+    root = Path(root)
+    output = root / 'prepared'
+    output.mkdir(exist_ok=False)
+    images = json.loads((root / 'input/pr-5/images/crosscodeeval.json').read_text())
+    tables, archives, audit = [], [], []
+    original_images, retained_images = set(), set()
+    totals = Counter()
+    for lang, (source, patched) in SOURCES.items():
+        published = patched.removeprefix('laion__exp_rpt_')
+        original = {r['path']: r for r in pq.read_table(root / 'input/original' / source / 'tasks.parquet').to_pylist()}
+        table = pq.read_table(root / 'input/pr-5' / published / 'tasks.parquet')
+        historical = pq.read_table(root / 'input/pr-14' / published / 'tasks.parquet')
+        assert table.replace_schema_metadata(None).equals(historical.replace_schema_metadata(None))
+        regenerated = root / 'reconstructed' / patched
+        manifest = json.loads((regenerated / 'tasks.manifest.json').read_text())
+        kept = set(table['path'].to_pylist())
+        assert kept == {r['task_id'] for r in manifest['tasks'] if r['action'] != 'dropped'}
+        archive = pq.read_table(regenerated / 'tasks.archive.parquet')
+        assert set(archive['path'].to_pylist()) == set(original) - kept
+        for row in archive.to_pylist():
+            assert row['task_binary'] == original[row['path']]['task_binary']
+        counts = Counter()
+        for row in original.values():
+            original_images.add(unpack(row['task_binary'])['environment/Dockerfile'])
+        for row in table.to_pylist():
+            files = unpack(row['task_binary'])
+            before = unpack(original[row['path']]['task_binary'])
+            retained_images.add(files['environment/Dockerfile'])
+            assert row['stages_passed'] == '1,3,4,5'
+            assert images['tasks'][row['path']]['content_sha256'] == row['content_sha256']
+            counts['changed'] += files != before
+            counts['dependency_pins'] += files['environment/Dockerfile'] != before['environment/Dockerfile']
+            counts['context'] += any(k.startswith('setup_files/context/') for k in files)
+            counts['oracle'] += files.get('solution/solve.sh') != before.get('solution/solve.sh')
+            counts['verifier'] += files.get('tests/test.sh') != before.get('tests/test.sh')
+            counts['instructions'] += files['instruction.md'] != before['instruction.md']
+        reasons = Counter(r['labels'][0] for r in manifest['tasks'] if r['action'] == 'dropped')
+        totals.update(counts)
+        audit.append(dict(language=lang, original=len(original), kept=len(kept), archived=archive.num_rows,
+                          changes=dict(counts), exclusions=dict(reasons)))
+        tables.append(table.replace_schema_metadata(None))
+        archives.append(archive.replace_schema_metadata(None))
+    tasks = pa.concat_tables(tables)
+    archive = pa.concat_tables(archives)
+    assert tasks.num_rows == 6710 and archive.num_rows == 1053
+    assert totals['changed'] == 6710
+    summary = dict(original=7763, kept=6710, archived=1053, unchanged=0, changes=dict(totals),
+                   original_image_definitions=len(original_images), retained_image_definitions=len(retained_images),
+                   cached_images=len(images['bundles']), languages=audit,
+                   task_payloads_unchanged_from_pr14=True, all_existing_instruction_changes_preserved=True,
+                   source_revision=UPSTREAM_REVISION,
+                   release_revision=json.loads((root / 'input/files-14.json').read_text())['revision'],
+                   image_release_revision=json.loads((root / 'input/files-5.json').read_text())['revision'])
+    metadata = {b'ot.images.v1': json.dumps(images).encode(), b'ot.release.v1': json.dumps(summary).encode()}
+    pq.write_table(tasks.replace_schema_metadata(metadata), output / 'tasks.parquet')
+    pq.write_table(archive.replace_schema_metadata({b'ot.release.v1': json.dumps(summary).encode()}), output / 'archive.parquet')
+    (output / 'summary.json').write_text(json.dumps(summary, indent=2) + '\n')
+    print(json.dumps(summary, indent=2))
+
+
+def prepare_release_cli():
+    parser = argparse.ArgumentParser(description='Preserve and reorganize the reviewed CrossCodeEval release')
+    parser.add_argument('root', type=Path)
+    prepare_release(parser.parse_args().root)
+
+
+if __name__ == '__main__':
+    from data.utils.cli import dispatch
+    dispatch({'prepare-release': prepare_release_cli, 'prepare': prepare_cli, 'warmup': warmup_cli, 'rewards': rewards_cli})
+    main()

scaleswe_environment-reliable/patch.py

@@ -0,0 +1,1489 @@
+"""Apply reviewed instruction and verifier repairs to pinned Scale-SWE tasks."""
+from __future__ import annotations
+
+# Support both direct execution and python -m data.<source>.patch.
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+
+
+import argparse
+import copy
+import hashlib
+import io
+import inspect
+import json
+from pathlib import Path, PurePosixPath
+import re
+import tarfile
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+from data.utils.patch_reporting import write_patch_report
+from data.utils.resolve_absolute_paths import apply_reviewed_replacements, collect_reports
+from validation.contract import files_digest
+
+REVISION = '8935f8e55244fd56080cdb8dcd0819a57e8a003c'
+HERE = Path(__file__).resolve().parent
+
+APPIUM_IMPORT_TASKS = frozenset({
+    'appium_python-client_pr446',
+    'appium_python-client_pr521',
+    'appium_python-client_pr594',
+})
+
+VERIFIER_IMPORT_TASKS = {
+    **{task: ('python-client', 'Expose Appium repository test helpers when grading through /tests/score.py.')
+       for task in APPIUM_IMPORT_TASKS},
+    'dbcli_pgcli_pr942': ('pgcli', 'Expose the repository root so restored tests.utils imports resolve after the reference removes tests/__init__.py.'),
+    'sbdchd_flake8-pie_pr93': ('flake8-pie', 'Import flake8_pie from the task checkout instead of the installed package, which lacks the selected feature modules.'),
+    **{f'sbdchd_flake8-pie_pr{pr}': ('flake8-pie', 'Import flake8_pie from the task checkout: the image installs a non-editable copy of a later commit in site-packages, so the unchanged checkout also scored 1 under no-op.')
+       for pr in (40, 42, 44, 54)},
+    'joseph-roitman_pytest-snapshot_pr30': ('pytest-snapshot', 'Load the pytest_snapshot plugin from the task checkout: the image installs a non-editable copy of a later commit in site-packages, so the unchanged checkout also scored 1 under no-op.'),
+    # No-op reward 1 in the 2026-10-08 full run: the selected tests imported the package installed in
+    # site-packages instead of the task checkout, so the unchanged checkout passed. Confirmed by the
+    # 2026-10-10 rerun (job 963978): with the repository root first on PYTHONPATH every reference scores 1
+    # and every no-op scores 0.
+    'ethereum_eth-utils_pr78': ('eth-utils', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    'ethereum_eth-utils_pr84': ('eth-utils', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    'hussein-awala_spark-on-k8s_pr1': ('spark-on-k8s', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    'hussein-awala_spark-on-k8s_pr11': ('spark-on-k8s', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    'hussein-awala_spark-on-k8s_pr12': ('spark-on-k8s', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    'hussein-awala_spark-on-k8s_pr13': ('spark-on-k8s', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    'joseph-roitman_pytest-snapshot_pr10': ('pytest-snapshot', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    'joseph-roitman_pytest-snapshot_pr13': ('pytest-snapshot', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    'joseph-roitman_pytest-snapshot_pr32': ('pytest-snapshot', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    'joseph-roitman_pytest-snapshot_pr34': ('pytest-snapshot', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    'joseph-roitman_pytest-snapshot_pr36': ('pytest-snapshot', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    'lasp_cdflib_pr38': ('cdflib', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    'lasp_cdflib_pr49': ('cdflib', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    'onnx_tensorflow-onnx_pr832': ('tensorflow-onnx', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    'onnx_tensorflow-onnx_pr839': ('tensorflow-onnx', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    'onnx_tensorflow-onnx_pr850': ('tensorflow-onnx', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    'onnx_tensorflow-onnx_pr867': ('tensorflow-onnx', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    'onnx_tensorflow-onnx_pr882': ('tensorflow-onnx', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    'onnx_tensorflow-onnx_pr949': ('tensorflow-onnx', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    'onnx_tensorflow-onnx_pr968': ('tensorflow-onnx', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    'onnx_tensorflow-onnx_pr974': ('tensorflow-onnx', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    'pytest-dev_pytest-bdd_pr335': ('pytest-bdd', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    'pytest-dev_pytest-bdd_pr398': ('pytest-bdd', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    'pytransitions_transitions_pr73': ('transitions', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    's4v4g3_otel-extensions-python_pr4': ('otel-extensions-python', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+    'stephrdev_pytest-isort_pr40': ('pytest-isort', 'Import the package under test from the task checkout instead of the installed site-packages copy, which made the unchanged checkout score 1 under no-op.'),
+}
+
+# Tasks archived after the 2026-10-10 recheck (reference, no-op and environment evidence per task); see archived_tasks.json.
+RECHECK_ARCHIVE = json.loads((HERE / 'archived_tasks.json').read_text()) if (HERE / 'archived_tasks.json').is_file() else {}
+
+ARCHIVED_TASKS = {
+    **{f'matan1008_pykdebugparser_pr{pr}': {
+        'category': 'image-missing-test-dependency',
+        'reason': 'The task image lacks the construct package that the test modules import, so neither the reference nor the no-op run can collect a single test, even with the repository on the import path. Installing it at verification time would make the verifier depend on PyPI; archived until the image is fixed.'}
+       for pr in (5, 6)},
+    'biocommons_hgvs_pr699': {
+        'category': 'verifier-external-dependency',
+        'reason': 'The reference verifier requires a connection to the external UTA database at uta.biocommons.org:5432. The service timed out during validation, so test results depend on an unavailable external database. Archived at user request because this verifier dependency is not reliable.'},
+    'biocommons_hgvs_pr775': {
+        'category': 'verifier-external-dependency',
+        'reason': 'The reference verifier requires a connection to the external UTA database at uta.biocommons.org:5432. The service timed out during validation, so test results depend on an unavailable external database. Archived at user request because this verifier dependency is not reliable.'},
+    'kurtbrose_pyjks_pr19': {
+        'category': 'reference-solution-reward-zero',
+        'reason': 'Reference scores 0 because verifier baseline restoration deletes the new tests/expected/custom_entry_passwords.py helper while leaving its import in tests/expected/__init__.py. Pytest fails during collection before executing tests. This is a verifier preparation defect, not evidence of a broken reference implementation. Archived without repair at user request.'},
+    'turner-townsend_flask-pydantic-spec_pr78': {
+        'category': 'verifier-execution-error',
+        'reason': 'Verifier test patch omits tests/common.py defining DemoModelV1, causing no-op collection failure. Reference executes 38 passing tests but scores zero because expected unparameterized selectors do not match parameterized results. Archived without repair at user request.'},
+    'meerk40t_svgelements_pr24': {
+        'category': 'verifier-execution-error',
+        'reason': 'Verifier test patch deletes test/test_distance.py and moves tests to test/test_length.py, but selected test IDs still reference the deleted file. Reference and no-op both execute zero tests. Archived without repair at user request.'},
+}
+ARCHIVED_TASKS = {**RECHECK_ARCHIVE, **ARCHIVED_TASKS}
+
+# Reference failures from the 2026-10-08 full run whose gold patch adds or modifies test-support files that the
+# verifier reset discards (2026-10-10 static scan of gold.patch against f2p.patch). The restoration repair applies
+# only to these tasks and to TEST_FIXTURE_REPAIRS; previously validated tasks keep their verifiers unchanged.
+FIXTURE_RESTORATION_TASKS = frozenset({
+    'appium_python-client_pr531',
+    'ariebovenberg_slotscheck_pr93',
+    'audreyr_cookiecutter_pr1419',
+    'audreyr_cookiecutter_pr1468',
+    'audreyr_cookiecutter_pr1874',
+    'audreyr_cookiecutter_pr1981',
+    'audreyr_cookiecutter_pr1995',
+    'audreyr_cookiecutter_pr839',
+    'bottlepy_bottle_pr787',
+    'burnash_gspread_pr1010',
+    'burnash_gspread_pr1012',
+    'burnash_gspread_pr1013',
+    'burnash_gspread_pr1021',
+    'burnash_gspread_pr1030',
+    'burnash_gspread_pr1063',
+    'burnash_gspread_pr1095',
+    'burnash_gspread_pr1138',
+    'burnash_gspread_pr1207',
+    'burnash_gspread_pr1215',
+    'burnash_gspread_pr1225',
+    'burnash_gspread_pr1233',
+    'burnash_gspread_pr1299',
+    'burnash_gspread_pr1305',
+    'burnash_gspread_pr1308',
+    'burnash_gspread_pr1364',
+    'burnash_gspread_pr1392',
+    'burnash_gspread_pr1402',
+    'burnash_gspread_pr1404',
+    'burnash_gspread_pr1417',
+    'burnash_gspread_pr1498',
+    'burnash_gspread_pr945',
+    'businho_pytest-ruff_pr25',
+    'clemense_yourdfpy_pr4',
+    'clld_clldutils_pr93',
+    'cloudtools_troposphere_pr2069',
+    'cookiecutter_cookiecutter_pr1200',
+    'cookiecutter_cookiecutter_pr1468',
+    'cookiecutter_cookiecutter_pr1493',
+    'cookiecutter_cookiecutter_pr1981',
+    'cookiecutter_cookiecutter_pr1995',
+    'dantebben_nox-uv_pr4',
+    'dapr_python-sdk_pr89',
+    'drgarcia1986_simple-settings_pr11',
+    'drgarcia1986_simple-settings_pr8',
+    'eerkunt_terraform-compliance_pr352',
+    'eerkunt_terraform-compliance_pr448',
+    'eerkunt_terraform-compliance_pr563',
+    'executablebooks_myst-nb_pr604',
+    'executablebooks_sphinx-design_pr13',
+    'fonttools_fonttools_pr1970',
+    'fonttools_fonttools_pr2080',
+    'fonttools_fonttools_pr3912',
+    'fortran-lang_fortls_pr49',
+    'globus_globus-sdk-python_pr1179',
+    'globus_globus-sdk-python_pr903',
+    'google_flatbuffers_pr5631',
+    'googleapis_proto-plus-python_pr112',
+    'googleapis_proto-plus-python_pr118',
+    'googlefonts_ufo2ft_pr866',
+    'googlefonts_ufo2ft_pr870',
+    'gorakhargosh_watchdog_pr968',
+    'hadialqattan_pycln_pr120',
+    'hakancelikdev_unimport_pr289',
+    'hhatto_autopep8_pr288',
+    'iterative_gto_pr148',
+    'iterative_gto_pr309',
+    'jackdewinter_pymarkdown_pr1413',
+    'jackdewinter_pymarkdown_pr1414',
+    'jackdewinter_pymarkdown_pr279',
+    'jackdewinter_pymarkdown_pr280',
+    'jackdewinter_pymarkdown_pr455',
+    'jackdewinter_pymarkdown_pr559',
+    'jackdewinter_pymarkdown_pr636',
+    'jackdewinter_pymarkdown_pr80',
+    'jsh9_pydoclint_pr155',
+    'jsh9_pydoclint_pr188',
+    'jsh9_pydoclint_pr192',
+    'jsh9_pydoclint_pr199',
+    'jsh9_pydoclint_pr205',
+    'jsh9_pydoclint_pr206',
+    'jsh9_pydoclint_pr207',
+    'jsh9_pydoclint_pr225',
+    'jsh9_pydoclint_pr227',
+    'jsh9_pydoclint_pr230',
+    'jsh9_pydoclint_pr259',
+    'jsh9_pydoclint_pr260',
+    'jsh9_pydoclint_pr271',
+    'jsh9_pydoclint_pr277',
+    'jxtech_wechatpy_pr328',
+    'jxtech_wechatpy_pr333',
+    'jxtech_wechatpy_pr66',
+    'jxtech_wechatpy_pr69',
+    'jxtech_wechatpy_pr74',
+    'jxtech_wechatpy_pr94',
+    'keboola_python-component_pr63',
+    'localstack_plux_pr28',
+    'ludeeus_awesomeversion_pr290',
+    'mesonbuild_meson-python_pr177',
+    'mesonbuild_meson-python_pr467',
+    'mesonbuild_meson-python_pr569',
+    'mesonbuild_meson-python_pr96',
+    'mitmproxy_mitmproxy_pr4860',
+    'neovim_python-client_pr534',
+    'olofk_fusesoc_pr711',
+    'p1c2u_jsonschema-spec_pr6',
+    'pdm-project_pdm-backend_pr105',
+    'pepkit_peppy_pr489',
+    'pepkit_peppy_pr495',
+    'praw-dev_praw_pr563',
+    'praw-dev_praw_pr575',
+    'praw-dev_praw_pr602',
+    'praw-dev_praw_pr612',
+    'praw-dev_prawcore_pr112',
+    'praw-dev_prawcore_pr116',
+    'praw-dev_prawcore_pr119',
+    'praw-dev_prawcore_pr13',
+    'praw-dev_prawcore_pr15',
+    'praw-dev_prawcore_pr206',
+    'praw-dev_prawcore_pr25',
+    'praw-dev_prawcore_pr26',
+    'praw-dev_prawcore_pr32',
+    'praw-dev_prawcore_pr4',
+    'praw-dev_prawcore_pr42',
+    'praw-dev_prawcore_pr57',
+    'praw-dev_prawcore_pr59',
+    'praw-dev_prawcore_pr61',
+    'praw-dev_prawcore_pr62',
+    'praw-dev_prawcore_pr66',
+    'pydantic_bump-pydantic_pr90',
+    'pyinfra-dev_pyinfra_pr192',
+    'pyinfra-dev_pyinfra_pr194',
+    'pyinfra-dev_pyinfra_pr196',
+    'pypa_pyproject-metadata_pr206',
+    'pypa_pyproject-metadata_pr232',
+    'pypa_twine_pr83',
+    'python-distro_distro_pr106',
+    'python-distro_distro_pr247',
+    'python-distro_distro_pr30',
+    'python-poetry_poetry-core_pr101',
+    'python-poetry_poetry-core_pr108',
+    'python-poetry_poetry-core_pr221',
+    'python-poetry_poetry-core_pr228',
+    'python-poetry_poetry-core_pr368',
+    'python-poetry_poetry-core_pr462',
+    'python-poetry_poetry-core_pr469',
+    'python-poetry_poetry-core_pr57',
+    'python-poetry_poetry-core_pr578',
+    'python-poetry_poetry-core_pr620',
+    'python-poetry_poetry-core_pr629',
+    'python-poetry_poetry-core_pr634',
+    'python-poetry_poetry-core_pr661',
+    'python-poetry_poetry-core_pr666',
+    'python-poetry_poetry-core_pr675',
+    'python-poetry_poetry-core_pr710',
+    'python-poetry_poetry-core_pr734',
+    'python-poetry_poetry-core_pr81',
+    'python-poetry_poetry-core_pr830',
+    'python-poetry_poetry-core_pr874',
+    'python-trio_flake8-async_pr100',
+    'python-trio_flake8-async_pr22',
+    'python-trio_flake8-async_pr34',
+    'python-trio_flake8-async_pr98',
+    'radish-bdd_radish_pr447',
+    'ros-infrastructure_rosdep_pr789',
+    'sigmavirus24_github3.py_pr1199',
+    'sphinx-contrib_confluencebuilder_pr1044',
+    'sphinx-contrib_confluencebuilder_pr769',
+    'sphinx-doc_sphinx-argparse_pr49',
+    'spulec_freezegun_pr119',
+    'tconbeer_sqlfmt_pr16',
+    'tconbeer_sqlfmt_pr221',
+    'tconbeer_sqlfmt_pr25',
+    'tefra_xsdata_pr653',
+    'tlambert03_mkdocs-api-autonav_pr12',
+    'ultrabug_mkdocs-static-i18n_pr183',
+})
+
+# Fixture paths confirmed from failure logs in the 2026-10-09 audit; the repair below must still restore each of them.
+TEST_FIXTURE_REPAIRS = {
+    'andialbrecht_sqlparse_pr317': ('tests/files/encoding_utf8.sql',),
+    'audreyr_cookiecutter_pr1692': ('tests/test-generate-context/nested_dict.json',),
+    'audreyr_cookiecutter_pr2010': ('tests/test-generate-context/nested_dict_additional.json',),
+    'awslabs_serverless-application-model_pr1756': ('tests/translator/input/http_api_lambda_auth.yaml',),
+    'awslabs_serverless-application-model_pr2242': ('tests/translator/input/function_with_event_filtering.yaml',),
+    'awslabs_serverless-application-model_pr2261': ('tests/translator/input/http_api_multiple_authorizers.yaml',),
+    'beetbox_beets_pr3641': ('test/rsrc/lyrics/geniuscom/Wutangclancreamlyrics.txt',),
+    'beetbox_beets_pr5352': ('test/rsrc/lyrics/geniuscom/2pacalleyezonmelyrics.txt',),
+    'best-doctor_flake8-class-attributes-order_pr13': ('tests/test_files/special_method.py',),
+    'best-doctor_flake8-functions_pr5': ('tests/test_files/file_pure_function.py',),
+    'bufbuild_protovalidate-python_pr308': ('tests/testdata/string_ext_supplemental.textproto',),
+    'buriy_python-readability_pr190': ('tests/samples/summary-keep-all-images.sample.html',),
+    'butler54_mdformat-frontmatter_pr5': ('tests/simple-md-test.md',),
+    'c4deszes_ldfparser_pr106': ('tests/ldf/ldf_with_sporadic_frames.ldf',),
+    'c4deszes_ldfparser_pr116': ('tests/ldf/j2602_1.ldf',),
+    'c4deszes_ldfparser_pr80': ('tests/ldf/lin_schedules.ldf',),
+    'canonical_operator_pr800': ('test/charms/test_smoke/charmcraft.yaml',),
+    'censys_censys-python_pr312': ('tests/cli/test.xml',),
+    'cookiecutter_cookiecutter_pr1692': ('tests/test-generate-context/nested_dict.json',),
+    'cookiecutter_cookiecutter_pr2010': ('tests/test-generate-context/nested_dict_additional.json',),
+    'cthoyt_pystow_pr17': ('tests/resources/test_1.tsv',),
+    'demisto_demisto-sdk_pr102': ('tests/test_files/indicator-field-exact-scheme.json',),
+    'django-crispy-forms_crispy-bootstrap5_pr151': ('tests/results/modal.html',),
+    'django-crispy-forms_crispy-bootstrap5_pr44': ('tests/results/field_with_buttons.html',),
+    'django-crispy-forms_crispy-bootstrap5_pr81': ('tests/results/alert.html',),
+    'drgarcia1986_simple-settings_pr19': ('tests/samples/simple_yaml_file.yaml',),
+    'fastavro_fastavro_pr482': ('tests/load_schema_test_3/A.avsc',),
+    'fastavro_fastavro_pr491': ('tests/load_schema_test_7/A.avsc',),
+    'fastavro_fastavro_pr492': ('tests/load_schema_test_8/A.avsc',),
+    'fastavro_fastavro_pr497': ('tests/load_schema_test_12/com/namespace/E.avsc',),
+    'fonttools_fonttools_pr1460': ('Tests/feaLib/data/bug1459.fea',),
+    'fonttools_fonttools_pr1669': ('Tests/cffLib/data/TestCFF2Widths.ttx',),
+    'fonttools_fonttools_pr1752': ('Tests/varLib/data/SingleMaster.designspace',),
+    'fonttools_fonttools_pr1827': ('Tests/varLib/data/VarLibLocationTest.designspace',),
+    'fonttools_fonttools_pr1876': ('Tests/feaLib/data/GSUB_error.fea',),
+    'fonttools_fonttools_pr1878': ('Tests/feaLib/data/aalt_chain_contextual_subst.fea',),
+    'fonttools_fonttools_pr1905': ('Tests/feaLib/data/MultipleLookupsPerGlyph2.fea',),
+    'fonttools_fonttools_pr1944': ('Tests/subset/data/TestContextSubstFormat3.ttx',),
+    'fonttools_fonttools_pr1957': ('Tests/varLib/data/FeatureVarsWholeRange.designspace',),
+    'fonttools_fonttools_pr1973': ('Tests/feaLib/data/include/test.ufo/features.fea',),
+    'fonttools_fonttools_pr2112': ('Tests/subset/data/layout_scripts.ttx',),
+    'fonttools_fonttools_pr2161': ('Tests/ttLib/data/woff2_overlap_offcurve_in.ttx',),
+    'fonttools_fonttools_pr2170': ('Tests/feaLib/data/delete_glyph.fea',),
+    'fonttools_fonttools_pr2277': ('Tests/feaLib/data/bug2276.fea',),
+    'fonttools_fonttools_pr2313': ('Tests/subset/data/GPOS_SinglePos_no_value_issue_2312.ttx',),
+    'fonttools_fonttools_pr2432': ('Tests/feaLib/data/variable_scalar_anchor.fea',),
+    'fonttools_fonttools_pr2447': ('Tests/merge/data/CFFFont1.ttx',),
+    'fonttools_fonttools_pr2462': ('Tests/subset/data/BungeeColor-Regular.ttx',),
+    'fonttools_fonttools_pr2555': ('Tests/varLib/instancer/data/SinglePos.ttx',),
+    'fonttools_fonttools_pr2660': ('Tests/varLib/data/TestVariableCOLR.designspace',),
+    'fonttools_fonttools_pr2673': ('Tests/varLib/instancer/data/STATInstancerTest.ttx',),
+    'fonttools_fonttools_pr2684': ('Tests/designspaceLib/data/DS5BreakTest.designspace',),
+    'fonttools_fonttools_pr2776': ('Tests/feaLib/data/variable_bug2772.fea',),
+    'fonttools_fonttools_pr2789': ('Tests/ttLib/data/TestTTF_normalizeLocation.ttx',),
+    'fonttools_fonttools_pr3024': ('Tests/varLib/data/master_no_overwrite_stat/Test-CondensedThin.ttx',),
+    'fonttools_fonttools_pr3027': ('Tests/ttLib/tables/data/COLRv1-clip-boxes-glyf.ttx',),
+    'fonttools_fonttools_pr3034': ('Tests/varLib/data/test_results/InterpolateLayoutGPOS_7_diff.ttx',),
+    'fonttools_fonttools_pr3075': ('Tests/varLib/data/SparseMasters_ufo.designspace',),
+    'fonttools_fonttools_pr3092': ('Tests/ttLib/tables/data/_g_l_y_f_instructions.ttx',),
+    'fonttools_fonttools_pr3115': ('Tests/ttx/data/roundtrip_DSIG_split_at_XML_parse_buffer_size.ttx',),
+    'fonttools_fonttools_pr3305': ('Tests/subset/data/NotoSansCJKjp-Regular.subset.ttx',),
+    'fonttools_fonttools_pr3330': ('Tests/feaLib/data/variable_mark_anchor.fea',),
+    'fonttools_fonttools_pr3506': ('Tests/varLib/instancer/data/CFF2Instancer-VF-1.ttx',),
+    'fonttools_fonttools_pr3520': ('Tests/feaLib/data/duplicate_lookup_reference.fea',),
+    'fonttools_fonttools_pr3559': ('Tests/feaLib/data/contextual_inline_multi_sub_format_2.fea',),
+    'fonttools_fonttools_pr3672': ('Tests/subset/data/cmap14_font1.ttx',),
+    'fonttools_fonttools_pr3726': ('Tests/feaLib/data/contextual_inline_format_4.fea',),
+    'fonttools_fonttools_pr3783': ('Tests/feaLib/data/spec9a2.fea',),
+    'fonttools_fonttools_pr3800': ('Tests/feaLib/data/CursivePosSubtable.fea',),
+    'fonttools_fonttools_pr3803': ('Tests/feaLib/data/single_pos_NULL.fea',),
+    'fonttools_fonttools_pr3804': ('Tests/feaLib/data/class_pair_pos_duplicates.fea',),
+    'fonttools_fonttools_pr3811': ('Tests/feaLib/data/spec8a_2.fea',),
+    'fonttools_fonttools_pr3838': ('Tests/varLib/data/test_results/FeatureVars_latn_dflt_var.ttx',),
+    'fonttools_fonttools_pr3849': ('Tests/feaLib/data/bug3846_1.fea',),
+    'fonttools_fonttools_pr3853': ('Tests/subset/data/PreserveSillyNamesTest.ttx',),
+    'fonttools_fonttools_pr3874': ('Tests/feaLib/data/combo_mult_and_lig_sub.fea',),
+    'fonttools_fonttools_pr3895': ('Tests/feaLib/data/identical_feature_lookups.fea',),
+    'frictionlessdata_frictionless-py_pr1052': ('tests/fixtures/output-markdown/package.md',),
+    'goodmami_wn_pr264': ('tests/data/mini-lmf-1.4.xml',),
+    'google_flatbuffers_pr6217': ('tests/optional_scalars/ScalarStuff.cs',),
+    'googlefonts_ufo2ft_pr289': ('tests/data/TestFont-NoOptimize-CFF.ttx',),
+    'googlefonts_ufo2ft_pr318': ('tests/data/IncompatibleMasters/NewFont-Regular.ufo/metainfo.plist',),
+    'googlefonts_ufo2ft_pr335': ('tests/data/Instructions.ufo/metainfo.plist',),
+    'googlefonts_ufo2ft_pr359': ('tests/data/ColorTest.ufo/metainfo.plist',),
+    'googlefonts_ufo2ft_pr816': ('tests/data/TestVarFont.designspace',),
+    'googlefonts_ufo2ft_pr817': ('tests/data/OTestFont.designspace',),
+    'googlefonts_ufo2ft_pr869': ('tests/data/ContextualAnchorsTest-Regular.ufo/metainfo.plist',),
+    'googlefonts_ufo2ft_pr909': ('tests/data/Bug908.ufo/metainfo.plist',),
+    'googlefonts_ufo2ft_pr942': ('tests/data/BagelFatOne-Regular.designspace',),
+    'goose3_goose3_pr157': ('tests/data/publishdate/test_publish_date_unix_milliseconds.json',),
+    'goose3_goose3_pr180': ('tests/data/title/test_title_sitename_list.json',),
+    'goose3_goose3_pr25': ('tests/data/images/test_base64_image.json',),
+    'goose3_goose3_pr54': ('tests/data/metas/test_meta_encoding.json',),
+    'goose3_goose3_pr60': ('tests/data/title/test_title_splitter.json',),
+    'goose3_goose3_pr64': ('tests/data/opengraph/test_opengraph_type.json',),
+    'goose3_goose3_pr66': ('tests/data/content/test_retry_top_node.json',),
+    'goose3_goose3_pr90': ('tests/data/opengraph/test_opengraph_types_mult.json',),
+    'gruebel_pycep_pr151': ('tests/test_function/examples/array/flatten/result.json',),
+    'gruebel_pycep_pr181': ('tests/examples/basic/06-type/result.json',),
+    'gruebel_pycep_pr320': ('tests/examples/complex/10-extension/result.json',),
+    'gruebel_pycep_pr321': ('tests/examples/complex/11-typed-var/result.json',),
+    'gruebel_pycep_pr322': ('tests/examples/complex/12-nullable-type/result.json',),
+    'gruebel_pycep_pr323': ('tests/examples/complex/13-import/result.json',),
+    'gruebel_pycep_pr326': ('tests/examples/complex/14-type-decorator/result.json',),
+    'gruebel_pycep_pr43': ('tests/test_function/examples/date/date_time_to_epoch/result.json',),
+    'gruebel_pycep_pr52': ('tests/test_function/examples/file/load_json_content/result.json',),
+    'home-assistant-libs_python-supervisor-client_pr152': ('tests/fixtures/host_disk_usage.json',),
+    'iterative_gto_pr269': ('tests/resources/sample_remote_repo_expected_registry.json',),
+    'jackdewinter_pymarkdown_pr1050': ('test/resources/rules/md010/issue-1015.md',),
+    'jacksmith15_json-ref-dict_pr13': ('tests/schemas/slash-key.yaml',),
+    'jacksmith15_json-ref-dict_pr4': ('tests/schemas/bad-circular.yaml',),
+    'jacksmith15_json-ref-dict_pr9': ('tests/schemas/with-tabs.json',),
+    'jazzband_icalevents_pr133': ('test/test_data/google_2024.ics',),
+    'jazzband_icalevents_pr140': ('test/test_data/regression_offset_native.ics',),
+    'jazzband_icalevents_pr79': ('test/test_data/google_tz.ics',),
+    'jazzband_icalevents_pr80': ('test/test_data/cest.ics',),
+    'jazzband_icalevents_pr88': ('test/test_data/rrule_until_only_date.ics',),
+    'jazzband_icalevents_pr91': ('test/test_data/empty.ics',),
+    'jazzband_icalevents_pr92': ('test/test_data/status_and_url.ics',),
+    'jazzband_icalevents_pr95': ('test/test_data/multi_attendee_response.ics',),
+    'jazzband_icalevents_pr97': ('test/test_data/multi_exdate_same_line_ms.ics',),
+    'jazzband_tablib_pr534': ('tests/files/issue_524.yaml',),
+    'joshtemple_lkml_pr10': ('tests/resources/duplicate_top_level_keys.view.lkml',),
+    'jsh9_pydoclint_pr123': ('tests/data/edge_cases/09_double_quotes_in_Literal/google.py',),
+    'jsh9_pydoclint_pr129': ('tests/data/edge_cases/10_absent_return_anno/numpy.py',),
+    'jsh9_pydoclint_pr130': ('tests/data/google/class_attributes/cases.py',),
+    'jsh9_pydoclint_pr153': ('tests/data/edge_cases/12_property_methods_as_class_attr/google.py',),
+    'jsh9_pydoclint_pr86': ('tests/data/edge_cases/06_no_type_hints_in_doc/numpy.py',),
+    'jsh9_pydoclint_pr89': ('tests/data/edge_cases/07_underscore_args/google.py',),
+    'jxtech_wechatpy_pr381': ('tests/fixtures/changeopenid.json',),
+    'jxtech_wechatpy_pr412': ('tests/fixtures/sns_jscode2session.json',),
+    'jxtech_wechatpy_pr456': ('tests/fixtures/enterprise/user_list.json',),
+    'lovesegfault_beautysh_pr36': ('tests/indent_test1_raw.sh',),
+    'marshallward_f90nml_pr120': ('tests/long_string.nml',),
+    'marshallward_f90nml_pr180': ('tests/null_target_end_comma.nml',),
+    'mattijn_topojson_pr141': ('tests/files_topojson/gm.topo.json',),
+    'maxb2_typer-config_pr15': ('tests/config.env',),
+    'maxb2_typer-config_pr17': ('tests/config.ini',),
+    'meeb_whoisit_pr7': ('tests/data_rdap_response_domain3.json',),
+    'meeb_whoisit_pr8': ('tests/data_rdap_response_ip_v4_2.json',),
+    'mesonbuild_meson-python_pr219': ('tests/packages/unknown-user-args-top-level/pyproject.toml',),
+    'mesonbuild_meson-python_pr377': ('tests/packages/purelib-platlib-split/pyproject.toml',),
+    'mesonbuild_meson-python_pr455': ('tests/packages/missing-meson-version/pyproject.toml',),
+    'mesonbuild_meson-python_pr71': ('tests/packages/unsupported-python-version/pyproject.toml',),
+    'mhe_pynrrd_pr40': ('tests/test1d_ascii.nrrd',),
+    'mirumee_ariadne-codegen_pr106': ('tests/main/graphql_schemas/example/pyproject.toml',),
+    'mirumee_ariadne-codegen_pr264': ('tests/main/graphql_schemas/example/pyproject-schema-graphql.toml',),
+    'ncclient_ncclient_pr299': ('test/unit/ssh_config',),
+    'ncclient_ncclient_pr628': ('test/unit/transport/certs/id_ed25519_test.pub',),
+    'nicklambourne_slackblocks_pr32': ('test/samples/blocks/section_block_empty_text_field_value.json',),
+    'nicklambourne_slackblocks_pr49': ('test/samples/messages/message_with_optional_arguments.json',),
+    'olofk_fusesoc_pr645': ('tests/capi2_cores/parser/inheritance.core',),
+    'pappasam_toml-sort_pr91': ('tests/examples/gradle-version-catalog.toml',),
+    'pdm-project_pdm-backend_pr14': ('tests/fixtures/projects/demo-package-include-old/pyproject.toml',),
+    'pdm-project_pdm-backend_pr20': ('tests/fixtures/projects/demo-package-with-deep-path/pyproject.toml',),
+    'pdm-project_pdm-backend_pr21': ('tests/fixtures/projects/demo-cextension/pyproject.toml',),
+    'pdm-project_pdm-backend_pr49': ('tests/fixtures/projects/demo-no-name-nor-version/pyproject.toml',),
+    'pdm-project_pdm-backend_pr5': ('tests/fixtures/projects/demo-legacy/pyproject.toml',),
+    'pdm-project_pdm-backend_pr65': ('tests/fixtures/projects/demo-purelib-with-build/pyproject.toml',),
+    'pdm-project_pdm-backend_pr8': ('tests/fixtures/projects/demo-explicit-package-dir/pyproject.toml',),
+    'python-poetry_poetry-core_pr118': ('tests/fixtures/with_readme_files/README-1.rst',),
+    'python-poetry_poetry-core_pr248': ('tests/fixtures/with_readme_files/README-1.rst',),
+    'radish-bdd_radish_pr457': ('tests/output/unix/filter-when-using-tags-with-args.txt',),
+    'salesforce_cloudsplaining_pr90': ('test/files/shared/test_exclusions_for_service_roles_expected.json',),
+    'sayanarijit_expandvars_pr18': ('tests/data/foo.txt',),
+    'snowflakedb_snowflake-cli_pr505': ('tests/test_data/projects/snowpark_procedures/snowflake.yml',),
+    'spdx_tools-python_pr236': ('tests/data/formats/SPDXSBOMExample.tag',),
+    'stac-utils_stac-pydantic_pr108': ('tests/example_stac/example-item_geometry-null.json',),
+    'stac-utils_stac-pydantic_pr81': ('tests/example_stac/example-collection-list.json',),
+    'tconbeer_sqlfmt_pr126': ('tests/data/unformatted/110_other_identifiers.sql',),
+    'tconbeer_sqlfmt_pr127': ('tests/data/unformatted/111_chained_boolean_between.sql',),
+    'tconbeer_sqlfmt_pr143': ('tests/data/unformatted/201_basic_snapshot.sql',),
+    'tconbeer_sqlfmt_pr146': ('tests/data/preformatted/301_multiline_jinjafmt.sql',),
+    'tconbeer_sqlfmt_pr21': ('tests/data/unit_tests/test_parser/test_multiline_wrapping.sql',),
+    'tconbeer_sqlfmt_pr210': ('tests/data/unformatted/116_chained_booleans.sql',),
+    'tconbeer_sqlfmt_pr216': ('tests/data/unformatted/213_gitlab_fct_sales_funnel_target.sql',),
+    'tconbeer_sqlfmt_pr228': ('tests/data/unformatted/118_within_group.sql',),
+    'tconbeer_sqlfmt_pr233': ('tests/data/unformatted/119_psycopg_placeholders.sql',),
+    'tconbeer_sqlfmt_pr238': ('tests/data/unformatted/120_array_literals.sql',),
+    'tconbeer_sqlfmt_pr47': ('tests/data/unit_tests/test_splitter/test_comment_split_impact_on_open_brackets.sql',),
+    'tilezen_mapbox-vector-tile_pr70': ('tests/error_nested_multipolygon.wkt',),
+    'twitterdev_twitter-python-ads-sdk_pr212': ('tests/fixtures/promoted_tweets_attach.json',),
+    'valohai_valohai-yaml_pr118': ('tests/warning_examples/override-with-extra-fields-warning.yaml',),
+    'valohai_valohai-yaml_pr94': ('tests/error_examples/invalid-indentation-with-valid-YAML.yaml',),
+    'wbond_asn1crypto_pr79': ('tests/fixtures/ocsp-with-pkup.pem',),
+    'xmunoz_sodapy_pr17': ('tests/test_data/successblobres.txt',),
+    'xmunoz_sodapy_pr23': ('tests/test_data/update_song_metadata.txt',),
+    'yu-iskw_dbt-artifacts-parser_pr19': ('tests/resources/v7/jaffle_shop/manifest.json',),
+    'zapier_email-reply-parser_pr14': ('test/emails/email_headers_no_delimiter.txt',),
+    'zapier_email-reply-parser_pr31': ('test/emails/email_2_3.txt',),
+    'zheller_flake8-quotes_pr52': ('test/data/multiline_string.py',),
+    'zheller_flake8-quotes_pr78': ('test/data/doubles_escaped.py',),
+}
+
+NETWORK_TIMEOUT_GROUPS = {
+    'swagger-api_swagger-codegen': ((2765, 2796, 2801, 2831, 2863, 2878, 2899, 2929, 2987, 3015, 3031, 3034, 3075, 3090, 3126, 3130), 'public Petstore API'),
+    'elastic_elastic-transport-python': ((26, 55, 127), 'httpbin.org test service'),
+    'developmentseed_rio-stac': ((65, 71), 'remote STAC schemas'),
+    'richardkiss_pycoin': ((392, 400), 'public blockchain transaction services'),
+}
+for _repo, (_prs, _dependency) in NETWORK_TIMEOUT_GROUPS.items():
+    for _pr in _prs:
+        ARCHIVED_TASKS[f'{_repo}_pr{_pr}'] = {
+            'category': 'verifier-network-dependency',
+            'reason': f'Original reference and no-op verifiers hit the 1800-second limit. Diagnostics on a representative task from this repository confirmed blocking access to {_dependency}. Archived at user request as part of this network-dependent timeout group; this task was not individually diagnosed unless included in the diagnostic sample.'}
+
+EXACT_ID_SCORING_TASKS = frozenset({
+    'comtravo_ctparse_pr129',
+    'falconry_falcon_pr2366',
+    'falconry_falcon_pr2503',
+    'falconry_falcon_pr2572',
+    'falconry_falcon_pr2581',
+})
+
+
+class ExactPytestResults:
+    """Record actual pytest identities without rewriting parameter text."""
+    def __init__(self, expected):
+        self.expected = set(expected)
+        self.collected = set()
+        self.coverage = {}
+        self.phases = {}
+        self.failed = False
+
+    def pytest_collection_finish(self, session):
+        self.collected = {item.nodeid for item in session.items}
+        for selector in self.expected:
+            self.coverage[selector] = ({selector} if selector in self.collected else {
+                node for node in self.collected
+                if node.startswith(selector + '[') or node.startswith(selector + '::')})
+
+    def pytest_collectreport(self, report):
+        if report.failed:
+            self.failed = True
+
+    def pytest_runtest_logreport(self, report):
+        if not report.passed:
+            self.failed = True
+        self.phases.setdefault(report.nodeid, set()).add(report.when)
+
+    def all_passed(self, exitcode):
+        return (exitcode == 0 and not self.failed and bool(self.expected)
+                and set(self.coverage) == self.expected
+                and all(self.coverage.values())
+                and set().union(*self.coverage.values()) == self.collected
+                and all(self.phases.get(node, set()) >= {'setup', 'call', 'teardown'}
+                        for node in self.collected))
+
+
+def exact_pytest_score_main():
+    import json
+    import sys
+    import pytest
+    with open(sys.argv[1]) as stream:
+        expected = json.load(stream)
+    if not expected:
+        print('<score>0.0</score>', flush=True)
+        return
+    results = ExactPytestResults(expected)
+    exitcode = pytest.main(['-vv', '-o', 'addopts=', '--rootdir=.', *expected], plugins=[results])
+    print('<score>1.0</score>' if results.all_passed(exitcode) else '<score>0.0</score>', flush=True)
+
+
+def repair_exact_test_scoring(contents, task_id):
+    if task_id not in EXACT_ID_SCORING_TASKS:
+        return []
+    replacement = ('"""Score exact pytest identities; require complete successful execution."""\n\n'
+                   + inspect.getsource(ExactPytestResults) + '\n'
+                   + inspect.getsource(exact_pytest_score_main)
+                   + '\nif __name__ == "__main__":\n    exact_pytest_score_main()\n')
+    text = contents['tests/score.py'].decode()
+    if text == replacement:
+        return []
+    if 'def all_passed(xml_content: str, expected: list[str])' not in text:
+        raise ValueError('ScaleSWE scorer changed since exact-ID review')
+    contents['tests/score.py'] = replacement.encode()
+    return [{'file': 'tests/score.py', 'phase': 'verifier-exact-test-ids',
+             'reason': 'Replace lossy JUnit name reconstruction with exact pytest collection and execution identities. Preserve parameter text, require every selected test and all setup/call/teardown phases to pass, and reject skipped tests, collection failures and unsuccessful pytest exit.'}]
+
+
+JSONARGPARSE_DEBUG_TASKS = frozenset(
+    f'omni-us_jsonargparse_pr{pr}' for pr in
+    (162, 164, 176, 177, 186, 190, 194, 197, 198, 210, 211, 214, 216,
+     218, 222, 223, 233, 239, 242, 253, 266, 267, 268, 270, 272, 273))
+
+JSONARGPARSE_DEBUG_FIXTURE = '''
+
+# ScaleSWE verifier: completion tests must not take ownership of pytest's fd 9.
+import pytest as _scaleswe_pytest
+
+@_scaleswe_pytest.fixture(autouse=True)
+def _scaleswe_argcomplete_debug_stream(monkeypatch):
+    import io
+    import sys
+    import argcomplete.io as completion_io
+    from argcomplete.finders import CompletionFinder
+    class DebugStream(io.StringIO):
+        target = None
+        def write(self, text):
+            self.target.write(text)
+            return super().write(text)
+        def flush(self):
+            self.target.flush()
+            return super().flush()
+    with DebugStream() as debug_stream:
+        def init_debug_stream(self):
+            debug_stream.target = sys.stderr
+        with monkeypatch.context() as patch:
+            patch.setattr(completion_io, 'debug_stream', debug_stream)
+            patch.setattr(CompletionFinder, '_init_debug_stream', init_debug_stream)
+            yield
+'''
+
+
+def repair_argcomplete_test_fixture(fixture):
+    from pathlib import Path
+    path = Path('jsonargparse_tests/test_argcomplete.py')
+    text = path.read_text()
+    if 'class ArgcompleteTests(' not in text:
+        raise ValueError('Jsonargparse completion tests changed since review')
+    if 'def _scaleswe_argcomplete_debug_stream(' not in text:
+        path.write_text(text + fixture)
+
+
+def repair_argcomplete_debug_stream(contents, task_id):
+    if task_id not in JSONARGPARSE_DEBUG_TASKS:
+        return []
+    name = 'tests/score.py'
+    text = contents[name].decode()
+    if 'def repair_argcomplete_test_fixture(' in text:
+        return []
+    entry = 'if __name__ == "__main__":\n    main()'
+    if text.count(entry) != 1:
+        raise ValueError('Jsonargparse scorer entrypoint changed since review')
+    replacement = inspect.getsource(repair_argcomplete_test_fixture) + '\n' + entry.replace(
+        '    main()', '    repair_argcomplete_test_fixture(' + repr(JSONARGPARSE_DEBUG_FIXTURE) + ')\n    main()')
+    contents[name] = text.replace(entry, replacement).encode()
+    return [{'file': name, 'phase': 'verifier-debug-stream-isolation',
+             'reason': 'Jsonargparse completion tests invoke argcomplete in the pytest process. Argcomplete wraps fixed descriptor 9 as its debug stream; replacing that owning wrapper closes pytest faulthandler\'s descriptor and crashes after passing tests. Give completion tests an isolated in-memory debug stream that forwards warnings to the stderr selected at autocomplete entry without owning its descriptor, and restore original state after each test. Preserve assertions, selectors, dependency versions, scoring and pytest cleanup.'}]
+
+
+def repair_werkzeug_request_test():
+    from pathlib import Path
+    path = Path('tests/test_test.py')
+    text = path.read_text()
+    old = ('    req = builder.get_request()\n'
+           '    strict_eq(req.form["foo"], u"bar")\n'
+           '    strict_eq(req.files["blafasel"].read(), b"foo")\n')
+    new = ('    req = builder.get_request()\n'
+           '    try:\n'
+           '        strict_eq(req.form["foo"], u"bar")\n'
+           '        strict_eq(req.files["blafasel"].read(), b"foo")\n'
+           '    finally:\n'
+           '        req.close()  # ScaleSWE: release the uploaded temporary file.\n')
+    if text.count(new) == 1:
+        return
+    if text.count(old) != 1:
+        raise ValueError('Werkzeug multipart request test changed since review')
+    path.write_text(text.replace(old, new, 1))
+
+
+def repair_werkzeug_request_cleanup(contents, task_id):
+    if task_id != 'pallets_werkzeug_pr1694':
+        return []
+    name = 'tests/score.py'
+    text = contents[name].decode()
+    if 'def repair_werkzeug_request_test(' in text:
+        return []
+    entry = 'if __name__ == "__main__":\n    main()'
+    if text.count(entry) != 1:
+        raise ValueError('Werkzeug scorer entrypoint changed since review')
+    replacement = inspect.getsource(repair_werkzeug_request_test) + '\n' + entry.replace(
+        '    main()', '    repair_werkzeug_request_test()\n    main()')
+    contents[name] = text.replace(entry, replacement).encode()
+    return [{'file': name, 'phase': 'verifier-request-cleanup',
+             'reason': 'Werkzeug test_environ_builder_content_type leaves its multipart request open, leaking an uploaded SpooledTemporaryFile. Pytest promotes the resulting unraisable ResourceWarning to an error during shutdown after all 211 reference tests pass. Close that request in a finally block after its existing assertions. Preserve assertions, selectors, scoring, dependency versions and warning checks.'}]
+
+
+PYOUT_CLEANUP_TASKS = frozenset(f'pyout_pyout_pr{pr}' for pr in (108, 109, 111))
+
+PYOUT_CLEANUP_FIXTURE = '''
+
+# ScaleSWE verifier: release delayed test work after assertions, then join pools.
+@pytest.fixture(autouse=True)
+def _scaleswe_cleanup_delayed_workers(monkeypatch):
+    import pyout.interface as interface
+    delays, pools = [], []
+    original_init = Delayed.__init__
+    original_pool = interface.Pool
+
+    def tracked_init(self, *args, **kwargs):
+        original_init(self, *args, **kwargs)
+        delays.append(self)
+
+    class TrackedPool(original_pool):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            pools.append(self)
+
+    monkeypatch.setattr(Delayed, '__init__', tracked_init)
+    monkeypatch.setattr(interface, 'Pool', TrackedPool)
+    try:
+        yield
+    finally:
+        for delay in delays:
+            delay.now = True
+        for pool in pools:
+            pool.shutdown(wait=True)
+'''
+
+
+def repair_pyout_test_cleanup(fixture):
+    from pathlib import Path
+    path = Path('pyout/tests/test_tabular.py')
+    text = path.read_text()
+    if 'class Delayed(' not in text or 'def test_tabular_write_callable_kb_interrupt_in_exit(' not in text:
+        raise ValueError('Pyout delayed-work tests changed since review')
+    if 'def _scaleswe_cleanup_delayed_workers(' not in text:
+        path.write_text(text + fixture)
+
+
+def repair_flask_worker_fixtures():
+    """Size test-owned pools from the container CPU affinity, then join them."""
+    import os
+    from pathlib import Path
+    try:
+        workers = max(1, len(os.sched_getaffinity(0)))
+    except (AttributeError, OSError):
+        workers = 1
+    path = Path('tests/conftest.py')
+    text = path.read_text()
+    if '# ScaleSWE affinity-aware fixture pools' in text:
+        return
+    if text.count('    return app') != 2:
+        raise ValueError('Flask-executor app fixtures changed since review')
+    replacement = """    # ScaleSWE affinity-aware fixture pools
+    app.config['EXECUTOR_MAX_WORKERS'] = {workers}
+    try:
+        yield app
+    finally:
+        for value in app.extensions.values():
+            if isinstance(value, Executor):
+                value.shutdown(wait=True)""".format(workers=workers)
+    path.write_text(text.replace('    return app', replacement))
+    print('ScaleSWE fixture worker count from CPU affinity:', workers, flush=True)
+
+
+def run_joblib_with_available_cpus(main):
+    """Give the old multiprocessing API the verifier's allowed CPU count."""
+    import multiprocessing
+    import os
+    original = multiprocessing.cpu_count
+
+    def available_cpus():
+        try:
+            return max(1, len(os.sched_getaffinity(0)))
+        except (AttributeError, OSError):
+            return 1
+
+    multiprocessing.cpu_count = available_cpus
+    try:
+        print('ScaleSWE available verifier CPUs:', available_cpus(), flush=True)
+        return main()
+    finally:
+        multiprocessing.cpu_count = original
+
+
+RECHUNKER_CPU_TASKS = frozenset(f'pangeo-data_rechunker_pr{pr}' for pr in (22, 27, 30, 48))
+
+
+def run_dask_with_available_cpus(main):
+    import os
+    import dask
+    try:
+        cpus = max(1, len(os.sched_getaffinity(0)))
+    except (AttributeError, OSError):
+        cpus = 1
+    print('ScaleSWE available verifier CPUs:', cpus, flush=True)
+    with dask.config.set(num_workers=cpus):
+        return main()
+
+
+def repair_timeout_verifiers(contents, task_id):
+    edits = []
+    if task_id in ('joblib_joblib_pr449', 'joblib_joblib_pr541'):
+        name = 'tests/score.py'
+        text = contents[name].decode()
+        entry = 'if __name__ == "__main__":\n    main()'
+        if 'def run_joblib_with_available_cpus(' not in text:
+            if text.count(entry) != 1:
+                raise ValueError('Joblib score entrypoint changed since review')
+            replacement = inspect.getsource(run_joblib_with_available_cpus) + '\n' + entry.replace(
+                '    main()', '    run_joblib_with_available_cpus(main)')
+            contents[name] = text.replace(entry, replacement).encode()
+            edits.append({'file': name, 'phase': 'verifier-cpu-affinity' if task_id == 'joblib_joblib_pr541' else 'verifier-worker-cleanup',
+                          'reason': 'Host CPU discovery can size pools for 384 CPUs despite only four allocated CPUs, causing out-of-memory termination. Use process CPU affinity for multiprocessing.cpu_count during verification, falling back to one CPU; preserve Joblib negative n_jobs semantics, explicit worker counts, tests, scoring and the 4096 MB memory limit'})
+    if task_id in RECHUNKER_CPU_TASKS:
+        name = 'tests/score.py'
+        text = contents[name].decode()
+        entry = 'if __name__ == "__main__":\n    main()'
+        if 'def run_dask_with_available_cpus(' not in text:
+            if text.count(entry) != 1:
+                raise ValueError('Rechunker score entrypoint changed since review')
+            replacement = inspect.getsource(run_dask_with_available_cpus) + '\n' + entry.replace(
+                '    main()', '    run_dask_with_available_cpus(main)')
+            contents[name] = text.replace(entry, replacement).encode()
+            edits.append({'file': name, 'phase': 'verifier-cpu-affinity',
+                          'reason': 'Dask defaults to 384 host CPUs despite only four allocated CPUs, causing out-of-memory termination. Set verifier Dask num_workers from process CPU affinity, falling back to one CPU, and restore configuration afterward. Preserve tests, assertions, selectors, scoring and the 4096 MB memory limit.'})
+    if task_id == 'dchevell_flask-executor_pr12':
+        name = 'tests/score.py'
+        text = contents[name].decode()
+        entry = 'if __name__ == "__main__":\n    main()'
+        if 'def repair_flask_worker_fixtures(' not in text:
+            if text.count(entry) != 1:
+                raise ValueError('Flask-executor score entrypoint changed since review')
+            replacement = inspect.getsource(repair_flask_worker_fixtures) + '\n' + entry.replace(
+                '    main()', '    repair_flask_worker_fixtures()\n    main()')
+            contents[name] = text.replace(entry, replacement).encode()
+            edits.append({'file': name, 'phase': 'verifier-worker-cleanup',
+                          'reason': 'Set test fixture default workers from container CPU affinity (one worker if unavailable) and join fixture executors after each test; preserve explicit worker-count tests, assertions, scoring and the 4096 MB task memory limit'})
+    if task_id in PYOUT_CLEANUP_TASKS:
+        name = 'tests/score.py'
+        text = contents[name].decode()
+        entry = 'if __name__ == "__main__":\n    main()'
+        if 'def repair_pyout_test_cleanup(' not in text:
+            if text.count(entry) != 1:
+                raise ValueError('Pyout score entrypoint changed since review')
+            replacement = inspect.getsource(repair_pyout_test_cleanup) + '\n' + entry.replace(
+                '    main()', '    repair_pyout_test_cleanup(' + repr(PYOUT_CLEANUP_FIXTURE) + ')\n    main()')
+            contents[name] = text.replace(entry, replacement).encode()
+            edits.append({'file': name, 'phase': 'verifier-worker-cleanup',
+                          'reason': 'Release delayed test helper work after assertions and join test-created pools; preserve selected tests and assertions'})
+    if task_id == 'rom1504_embedding-reader_pr9':
+        name = 'tests/f2p.patch'
+        if 'diff --git a/tests/fixtures.py b/tests/fixtures.py' not in contents[name].decode():
+            chunks = contents['solution/gold.patch'].decode().split('diff --git ')
+            chunk = next(c for c in chunks if c.startswith('a/tests/fixtures.py b/tests/fixtures.py\n'))
+            contents[name] += ('\ndiff --git ' + chunk).encode()
+            script = contents['tests/test.sh'].decode()
+            anchor = 'if [ -s /tests/f2p.patch ]; then'
+            if script.count(anchor) != 1:
+                raise ValueError('Embedding-reader test preparation changed since review')
+            contents['tests/test.sh'] = script.replace(anchor, 'git checkout "$base" -- tests/fixtures.py || exit $?\n' + anchor).encode()
+            score = contents['tests/score.py'].decode()
+            anchor = 'pytest.main(["-vv",'
+            if score.count(anchor) != 1:
+                raise ValueError('Embedding-reader grader changed since review')
+            contents['tests/score.py'] = score.replace(anchor, 'pytest.main(["-vv", "--forked", "--timeout=60", "--timeout-method=thread",').encode()
+            edits.append({'file': 'tests', 'phase': 'verifier-worker-cleanup',
+                          'reason': 'Include and consistently restore the missing id2 fixture update; isolate each selected test with pytest-forked and a 60-second test timeout so broken reader worker shutdown cannot wedge the verifier; preserve assertions and reward rules'})
+    return edits
+
+DEFERRED_IMPORTS = {
+    'keboola_python-component_pr39': {'tests/test_base.py': {'keboola.component.base': ['sync_action']}},
+    'bluetooth-devices_cached-ipaddress_pr26': {'tests/test_ipaddress.py': {'cached_ipaddress': ['*'], 'cached_ipaddress.ipaddress': ['*']}},
+    'semuconsulting_pynmeagps_pr84': {'tests/test_static.py': {'pynmeagps.nmeahelpers': ['leapsecond']}},
+    'semuconsulting_pynmeagps_pr78': {
+        'tests/test_static.py': {'pynmeagps.nmeatypes_decodes': ['*']},
+        'tests/test_stream.py': {'pynmeagps': ['FMI_STATUS']}},
+    'ouhammmourachid_mermaid-py_pr105': {
+        'mermaid/tests/test_flowchart.py': {'mermaid': ['Direction'], 'mermaid.style': ['Style']},
+        'mermaid/tests/test_statediagram.py': {'mermaid': ['Direction'], 'mermaid.style': ['Style']},
+        'mermaid/tests/test_style.py': {'mermaid.style': ['Style']}},
+}
+
+
+def defer_test_imports(plan):
+    """Move reviewed module imports into their consuming functions, preserving test bodies."""
+    import ast
+    from pathlib import Path
+
+    for filename, modules in plan.items():
+        path = Path(filename)
+        source = path.read_text()
+        tree = ast.parse(source)
+        lines = source.splitlines(keepends=True)
+        moved = {}
+        edits = []
+        for node in tree.body:
+            if not isinstance(node, ast.ImportFrom) or node.level or node.module not in modules:
+                continue
+            selected = modules[node.module]
+            remaining = []
+            for alias in node.names:
+                if '*' in selected or alias.name in selected:
+                    if alias.name == '*':
+                        raise ValueError('Cannot defer a wildcard import: ' + filename)
+                    name = alias.asname or alias.name
+                    moved[name] = 'from ' + node.module + ' import ' + alias.name + (' as ' + alias.asname if alias.asname else '')
+                else:
+                    remaining.append(alias)
+            if len(remaining) != len(node.names):
+                replacement = ast.unparse(ast.ImportFrom(module=node.module, names=remaining, level=0)) + '\n' if remaining else ''
+                edits.append((node.lineno - 1, node.end_lineno, replacement))
+        if not moved:
+            raise ValueError('Reviewed imports missing from ' + filename)
+
+        def visit_scope(nodes):
+            for node in nodes:
+                if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    headers = [*node.decorator_list, node.args, *([node.returns] if node.returns else [])]
+                    if any(isinstance(n, ast.Name) and n.id in moved for h in headers for n in ast.walk(h)):
+                        raise ValueError('Deferred import used in function signature: ' + filename)
+                    used = {n.id for stmt in node.body for n in ast.walk(stmt)
+                            if isinstance(n, ast.Name) and isinstance(n.ctx, ast.Load)} & moved.keys()
+                    if used:
+                        first = node.body[0]
+                        if isinstance(first, ast.Expr) and isinstance(first.value, ast.Constant) and isinstance(first.value.value, str):
+                            first = node.body[1]
+                        indent = ' ' * first.col_offset
+                        edits.append((first.lineno - 1, first.lineno - 1,
+                                      ''.join(indent + moved[name] + '\n' for name in sorted(used))))
+                elif isinstance(node, ast.ClassDef):
+                    if any(isinstance(n, ast.Name) and n.id in moved for h in [*node.bases, *node.keywords, *node.decorator_list] for n in ast.walk(h)):
+                        raise ValueError('Deferred import used in class definition: ' + filename)
+                    visit_scope(node.body)
+                elif not isinstance(node, (ast.Import, ast.ImportFrom)):
+                    if any(isinstance(n, ast.Name) and isinstance(n.ctx, ast.Load) and n.id in moved for n in ast.walk(node)):
+                        raise ValueError('Deferred import used outside a function: ' + filename)
+        visit_scope(tree.body)
+        for start, end, replacement in sorted(edits, reverse=True):
+            lines[start:end] = [replacement]
+        updated = ''.join(lines)
+        ast.parse(updated)
+        path.write_text(updated)
+
+
+def repair_collection_imports(contents, task_id):
+    if task_id not in DEFERRED_IMPORTS:
+        return []
+    filename = 'tests/score.py'
+    text = contents[filename].decode()
+    marker = '# ScaleSWE reviewed call-time test imports v1\n'
+    if marker in text:
+        return []
+    entry = 'if __name__ == "__main__":\n    main()'
+    if text.count(entry) != 1:
+        raise ValueError('ScaleSWE score entrypoint changed since review')
+    replacement = marker + inspect.getsource(defer_test_imports) + '\n' + entry.replace('    main()', '    defer_test_imports(' + repr(DEFERRED_IMPORTS[task_id]) + ')\n    main()')
+    contents[filename] = text.replace(entry, replacement).encode()
+    return [{'file': filename, 'phase': 'verifier-call-time-imports',
+             'reason': 'Defer reviewed feature imports to consuming test functions; preserve selected tests, assertions and reward rules',
+             'imports': DEFERRED_IMPORTS[task_id]}]
+
+
+def repair_verifier_imports(contents, task_id):
+    if task_id not in VERIFIER_IMPORT_TASKS:
+        return []
+    name = 'tests/test.sh'
+    text = contents[name].decode()
+    command = 'python /tests/score.py /tests/test_ids.json | tee /logs/verifier/score.txt'
+    prefix = 'export PYTHONPATH="$PWD${PYTHONPATH:+:$PYTHONPATH}"\n'
+    if prefix + command in text:
+        return []
+    repo, reason = VERIFIER_IMPORT_TASKS[task_id]
+    if text.count(command) != 1 or f'cd /workspace/{repo} || exit 1' not in text:
+        raise ValueError('Verifier changed since import-path review')
+    contents[name] = text.replace(command, prefix + command, 1).encode()
+    return [{'file': name, 'old': command, 'new': prefix + command,
+             'phase': 'verifier-import-path',
+             'reason': reason + ' Prepend the repository root to PYTHONPATH; preserve assertions, selectors and reward rules.'}]
+
+
+SKIPPED_REQUIRED_TESTS = {
+    # dimod's test_nocpp_error checks the fallback used when the C++ extension is absent and skips
+    # itself when the extension is present. Scale's images build the extension, so the test can never
+    # pass there, yet Scale lists it among the required tests; the scorer treats a skip as not passed.
+    **{f'dwavesystems_dimod_pr{pr}': ('tests/test_fixedvariablecomposite.py::TestRoofDualityComposite::test_nocpp_error',)
+       for pr in (432, 445, 462, 471, 512)},
+}
+SKIPPED_REQUIRED_TEST_REASON = ('Remove a required test that the task image can never run: it checks the fallback used when the dimod C++ '
+                                'extension is absent and skips itself because the image builds the extension. The scorer counts a skip as '
+                                'not passed, so the reference solution scored 0 although every other required test passed. The remaining '
+                                'required tests still cover the change; tests, assertions and the scorer are unchanged.')
+
+
+def repair_skipped_required_tests(contents, task_id):
+    """Drop required test IDs that are skipped by design in the task image."""
+    remove = SKIPPED_REQUIRED_TESTS.get(task_id)
+    if not remove or 'tests/test_ids.json' not in contents:
+        return []
+    ids = json.loads(contents['tests/test_ids.json'].decode())
+    missing = [t for t in remove if t not in ids]
+    if missing:
+        raise ValueError(f'Required test list changed since review for {task_id}: {missing}')
+    kept = [t for t in ids if t not in remove]
+    if not kept:
+        raise ValueError(f'No required tests would remain for {task_id}')
+    contents['tests/test_ids.json'] = json.dumps(kept).encode()
+    return [{'file': 'tests/test_ids.json', 'phase': 'verifier-required-test-skipped', 'removed': list(remove),
+             'reason': SKIPPED_REQUIRED_TEST_REASON}]
+
+
+RESET_TEST_DIRS = ('test', 'tests', 'Test', 'Tests')
+FIXTURE_RESTORATION_REASON = (
+    'Scoring resets the test directories to the base commit and then applies tests/f2p.patch, the tests that verify '
+    'the fix. The pull request also added or changed test-support files under those directories (fixtures, recorded '
+    'cassettes, sample inputs) that f2p.patch leaves out, so the reset removes them and the selected tests fail even '
+    'with the reference solution. Append the pull request\'s own diff for exactly these files to f2p.patch so the '
+    'verifier restores the complete post-PR test tree. Source files, other tests and the reset itself are unchanged.')
+TEST_MODULE_RE = re.compile(r'(^|/)(test_[^/]*\.py|[^/]*_test\.py|conftest\.py)$')
+
+
+def _diff_chunks(patch):
+    """Map each same-path file diff in a git patch to its chunk text."""
+    chunks = {}
+    for chunk in patch.split('diff --git ')[1:]:
+        header = chunk.splitlines()[0] if chunk.splitlines() else ''
+        match = re.fullmatch(r'a/(.+) b/(.+)', header)
+        if match and match.group(1) == match.group(2):
+            chunks[match.group(1)] = 'diff --git ' + chunk
+    return chunks
+
+
+def _repair_hunk_headers(patch):
+    """Make every hunk header state the line counts the hunk actually carries.
+
+    Some Scale-SWE patches lost their final context line, so the last hunk
+    header claims one line more than follows it. git apply rejects such a
+    patch and patch(1) only tolerates the shortfall at end of file; once more
+    diff chunks follow, patch(1) stops at the junction with "malformed patch".
+    Headers whose counts already match are kept byte-identical; correcting the
+    others changes no patch content.
+    """
+    lines = patch.split('\n')
+    out, i = [], 0
+    while i < len(lines):
+        match = re.match(r'@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$', lines[i])
+        if not match:
+            out.append(lines[i]); i += 1
+            continue
+        j = i + 1
+        while j < len(lines) and not lines[j].startswith('@@') and not lines[j].startswith('diff --git '):
+            j += 1
+        body = lines[i + 1:j]
+        old = sum(1 for l in body if l[:1] in (' ', '-'))
+        new = sum(1 for l in body if l[:1] in (' ', '+'))
+        declared = (int(match.group(2) or 1), int(match.group(4) or 1))
+        header = lines[i] if declared == (old, new) else f'@@ -{match.group(1)},{old} +{match.group(3)},{new} @@{match.group(5)}'
+        out.append(header); out.extend(body); i = j
+    return '\n'.join(out)
+
+
+def _in_verifier_reset_scope(path):
+    """Paths ScaleSWE's test.sh checks out from the base commit or removes before applying f2p.patch."""
+    return PurePosixPath(path).parts[0] in RESET_TEST_DIRS or bool(TEST_MODULE_RE.search(path))
+
+
+def repair_added_test_fixtures(contents, task_id):
+    """Give the verifier the complete post-PR test tree.
+
+    Scoring rebuilds the test tree in two steps: reset the test directories to
+    the base commit (so agent edits to tests are discarded), then apply
+    tests/f2p.patch, the tests that verify the fix. The pull request also added
+    or changed test-support files under those directories (fixtures, recorded
+    cassettes, sample inputs), but f2p.patch leaves them out. The reset removes
+    them, so the selected tests fail even with the reference solution, and no
+    agent can make them pass because anything it creates there is reset too.
+
+    This repair appends the pull request's own diff for exactly those files to
+    f2p.patch: files under the top-level test directories that f2p.patch does
+    not already contain, excluding source files and new test modules that the
+    selected test IDs do not use. Hunk headers whose counts no longer match
+    their lines (a truncated final context line in the dataset) are corrected so
+    the combined patch applies as one. The reset and every other gold change are
+    untouched. It applies only to tasks whose reference failed for this reason.
+    """
+    if task_id not in FIXTURE_RESTORATION_TASKS and task_id not in TEST_FIXTURE_REPAIRS:
+        return []
+    gold = contents.get('solution/gold.patch', b'').decode(errors='replace')
+    if not gold or 'tests/f2p.patch' not in contents:
+        return []
+    f2p = contents['tests/f2p.patch'].decode(errors='replace')
+    gold_chunks, f2p_chunks = _diff_chunks(gold), _diff_chunks(f2p)
+    try:
+        selected_files = {entry.split('::')[0] for entry in json.loads(contents.get('tests/test_ids.json', b'[]').decode())}
+    except ValueError:
+        selected_files = set()
+    restored, additions = [], []
+    for path, chunk in gold_chunks.items():
+        if path in f2p_chunks or 'deleted file mode ' in chunk or not _in_verifier_reset_scope(path):
+            continue
+        if PurePosixPath(path).parts[0] not in RESET_TEST_DIRS:
+            continue  # test-named files outside the test trees stay with the gold/f2p split
+        if TEST_MODULE_RE.search(path) and not ('new file mode ' in chunk and path in selected_files):
+            continue
+        additions.append(chunk)
+        restored.append(path)
+    required = set(TEST_FIXTURE_REPAIRS.get(task_id, ()))
+    if required - set(restored) - set(f2p_chunks):
+        raise ValueError(f'Reviewed test fixtures not restored for {task_id}: {sorted(required - set(restored) - set(f2p_chunks))}')
+    if not additions:
+        return []
+    f2p = _repair_hunk_headers(f2p)
+    additions = [_repair_hunk_headers(chunk) for chunk in additions]
+    separator = '' if f2p.endswith('\n') or not f2p else '\n'
+    contents['tests/f2p.patch'] = (f2p + separator + '\n'.join(additions)).encode()
+    return [{'file': 'tests/f2p.patch', 'phase': 'verifier-test-fixture-restoration',
+             'paths': restored,
+             'reason': FIXTURE_RESTORATION_REASON}]
+
+
+# Explicitly reviewed instruction corrections; keep the task's other hints intact.
+INSTRUCTION_CORRECTIONS = {
+    'appium_python-client_pr517': (
+        'b1f4a2dc528408bb6651e198b76963c04069b6558453c3da42233ed54848bea2',
+        [('Attempt to run iOS functional tests in parallel using the `-n` flag.',
+          'Attempt to run iOS functional tests in parallel using the existing test file:'),
+         ('pytest -n 2 test/functional/ios/find_by_ios_class_chain_tests.py',
+          'pytest -n 2 /workspace/python-client/test/functional/ios/search_context/find_by_ios_class_chain_tests.py')]),
+    'beetbox_mediafile_pr86': (
+        '25ddb4ef83ecc81c538044f8bf4ebfeb367be92adb7a8e2eb5ea283927184e24',
+        [('**`mediafile/utils.py`**: For general utility functions and helpers.',
+          '**`/workspace/mediafile/mediafile/utils/`**: For general utility functions and helpers.')]),
+}
+
+
+def patch_blob(blob, diagnostic=None, decisions=(), oracle_passed=False, task_id=None, automatic_paths=False):
+    with tarfile.open(fileobj=io.BytesIO(blob)) as archive:
+        members = archive.getmembers()
+        contents = {}
+        for member in members:
+            name = PurePosixPath(member.name)
+            if name.is_absolute() or '..' in name.parts or not (member.isfile() or member.isdir()):
+                raise ValueError('Unsafe task archive member')
+            if member.isfile():
+                if str(name) in contents:
+                    raise ValueError('Duplicate archive member')
+                contents[str(name)] = archive.extractfile(member).read()
+        if (decisions or automatic_paths) and files_digest(contents.items()) != (diagnostic or {}).get('agent_baseline', {}).get('task_sha256'):
+            raise ValueError('Task changed since path resolution')
+        original = contents['instruction.md'].decode()
+        changed, edits = (apply_reviewed_replacements(original, diagnostic, decisions, oracle_passed=oracle_passed)
+                          if decisions else (original, []))
+        if automatic_paths:
+            from validation.checks.instruction_paths import automatic
+            changed, edits = automatic(original, diagnostic, oracle_passed)
+            # Task-specific corrections take precedence over generic spans.
+            protected = []
+            for old, _ in INSTRUCTION_CORRECTIONS.get(task_id, ('', []))[1]:
+                start = original.find(old)
+                if start >= 0:
+                    protected.append((start, start + len(old)))
+            edits = [e for e in edits if not any(e['start'] < end and start < e['end'] for start, end in protected)]
+            changed = original
+            for edit in reversed(edits):
+                changed = changed[:edit['start']] + edit['new'] + changed[edit['end']:]
+        if task_id in INSTRUCTION_CORRECTIONS:
+            digest, replacements = INSTRUCTION_CORRECTIONS[task_id]
+            if hashlib.sha256(original.encode()).hexdigest() != digest:
+                raise ValueError('Instruction changed since task-specific correction review')
+            for old, new in replacements:
+                if changed.count(old) != 1:
+                    raise ValueError('Reviewed instruction correction is missing or conflicts with another edit')
+                changed = changed.replace(old, new, 1)
+                edits.append({'old': old, 'new': new, 'phase': 'explicit-instruction-review',
+                              'reason': 'User-approved minimal path correction; preserve remaining task wording'})
+        edits.extend(repair_verifier_imports(contents, task_id))
+        edits.extend(repair_collection_imports(contents, task_id))
+        edits.extend(repair_timeout_verifiers(contents, task_id))
+        edits.extend(repair_exact_test_scoring(contents, task_id))
+        edits.extend(repair_argcomplete_debug_stream(contents, task_id))
+        edits.extend(repair_werkzeug_request_cleanup(contents, task_id))
+        edits.extend(repair_added_test_fixtures(contents, task_id))
+        edits.extend(repair_skipped_required_tests(contents, task_id))
+        if not edits:
+            return blob, []
+        contents['instruction.md'] = changed.encode()
+        output = io.BytesIO()
+        with tarfile.open(fileobj=output, mode='w') as target:
+            for member in members:
+                member = copy.copy(member)
+                if member.isfile():
+                    data = contents[str(PurePosixPath(member.name))]
+                    member.size = len(data)
+                    target.addfile(member, io.BytesIO(data))
+                else:
+                    target.addfile(member)
+        return output.getvalue(), edits
+
+
+QUALITY_LABELS = {'instruction-path-clarified', 'anti-cheat-instruction'}
+
+
+def environment_repair_stage(task):
+    labels = set(task['labels']) - QUALITY_LABELS
+    if not labels:
+        return None
+    if labels == {'verifier-call-time-imports'} or task['task_id'] == 'rom1504_embedding-reader_pr9':
+        return 5
+    if labels == {'verifier-import-path'} and 'no-op' in task.get('reason', ''):
+        return 5
+    reference = {'verifier-import-path', 'verifier-test-fixture-restoration',
+                 'verifier-exact-test-ids', 'verifier-debug-stream-isolation',
+                 'verifier-request-cleanup', 'verifier-cpu-affinity',
+                 'verifier-worker-cleanup', 'verifier-required-test-skipped'}
+    if labels <= reference:
+        return 4
+    raise ValueError('Unclassified repair: ' + task['task_id'])
+
+
+def archive_files(blob):
+    """Read regular task files without extracting to disk."""
+    files = {}
+    with tarfile.open(fileobj=io.BytesIO(blob)) as archive:
+        for member in archive:
+            name = str(PurePosixPath(member.name))
+            if PurePosixPath(name).is_absolute() or '..' in PurePosixPath(name).parts:
+                raise ValueError('Unsafe task archive member')
+            if member.isdir():
+                continue
+            if not member.isfile() or name in files:
+                raise ValueError('Unsupported or duplicate task archive member')
+            files[name] = (archive.extractfile(member).read(), member.mode)
+    return files
+
+
+def restore_source_instruction(blob, instruction):
+    """Restore only the upstream instruction, preserving all runtime files and modes."""
+    from data.utils.full_source.harbor_parquet import pack_task
+    files = archive_files(blob)
+    files['instruction.md'] = (instruction, files['instruction.md'][1])
+    return pack_task(files)
+
+
+def environment_archive_stage(row):
+    """Cause-based attribution; the historical archive itself retains stage 0."""
+    labels = {label.removeprefix('patch-drop:') for label in row['archive_labels']}
+    noop = {'verifier-no-op-passes', 'task-changes-only-test-files',
+            'verifier-timeout-without-fix', 'verifier-timing-dependent'}
+    reference = {'reference-solution-reward-zero', 'verifier-collection-error',
+                 'verifier-network-dependency', 'verifier-external-dependency',
+                 'verifier-stale-cassette', 'verifier-execution-checker-pythonpath',
+                 'verifier-privileged-port', 'image-dependency-mismatch',
+                 'image-missing-test-dependency', 'verifier-execution-error'}
+    if labels and labels <= noop:
+        return 5
+    if labels and labels <= reference:
+        return 4
+    raise ValueError('Unclassified archive reason: ' + row['path'])
+
+
+def prepare_environment(upstream, tasks, archive, run_record, output, publication_revision):
+    """Prepare the instruction-original variant from pinned source and historical tasks."""
+    from collections import Counter
+    from data.utils.full_source.convert_prime import scale_files
+    from data.utils.full_source.harbor_parquet import pack_task
+
+    if not re.fullmatch('[0-9a-f]{40}', publication_revision):
+        raise ValueError('Use an immutable publication revision')
+    if output.exists():
+        raise ValueError('Use a new output directory')
+    record = json.loads(run_record.read_text())
+    provenance = record['patch_provenance']['scaleswe']
+    if provenance['source']['revision'] != REVISION:
+        raise ValueError('Unexpected upstream revision')
+    manifest = {x['task_id']: x for x in provenance['tasks']}
+    automation = record['automation_changes']['scaleswe']['tasks']
+    if any(set(x['labels']) != {'anti-cheat-instruction'} for x in automation):
+        raise ValueError('Unreviewed automatic runtime changes')
+    automated_ids = {x['task_id'] for x in automation}
+    published = pq.ParquetFile(tasks)
+    # Recover the frozen common converter support from a task with no patcher edits.
+    support = None
+    for batch in published.iter_batches(batch_size=32):
+        for row in batch.to_pylist():
+            if manifest[row['path']]['action'] == 'unchanged':
+                files = archive_files(row['task_binary'])
+                test = files['tests/test.sh'][0].decode()
+                start = test.index('\n', test.index('\nbase=') + 1) + 1
+                end = test.index('if [ -s /tests/f2p.patch ]; then', start)
+                support = {'score': files['tests/score.py'][0], 'restore': test[start:end]}
+                break
+        if support:
+            break
+    if support is None:
+        raise ValueError('No unchanged converter baseline')
+    source = {}
+    for shard in sorted(upstream.glob('*.parquet')):
+        for batch in pq.ParquetFile(shard).iter_batches(batch_size=32):
+            for raw in batch.to_pylist():
+                task = raw['instance_id']
+                if task in source or task not in manifest:
+                    raise ValueError('Duplicate or unexpected source task: ' + task)
+                original = pack_task(scale_files(raw, support))
+                if hashlib.sha256(original).hexdigest() != manifest[task]['source_binary_sha256']:
+                    raise ValueError('Pinned source does not reproduce conversion: ' + task)
+                files = archive_files(original)
+                source[task] = {'instruction': files['instruction.md'][0],
+                                'image': raw['image_url'],
+                                'files': {k: (hashlib.sha256(v).hexdigest(), mode)
+                                          for k, (v, mode) in files.items()}}
+    if set(source) != set(manifest):
+        raise ValueError('Incomplete source task accounting')
+    print(f'Verified all {len(source)} original converted payload hashes', flush=True)
+    archived = pq.read_table(archive)
+    archive_rows = archived.to_pylist()
+    excluded_ids = set()
+    exclusions = []
+    for row in archive_rows:
+        task = row['path']
+        if task in excluded_ids or manifest[task]['action'] != 'dropped':
+            raise ValueError('Invalid archive task: ' + task)
+        excluded_ids.add(task)
+        if hashlib.sha256(row['task_binary']).hexdigest() != manifest[task]['source_binary_sha256']:
+            raise ValueError('Archive no longer preserves original payload: ' + task)
+        exclusions.append({'task_id': task, 'attributed_stage': environment_archive_stage(row),
+                           'historical_archive_stage': row['archive_stage'],
+                           'labels': row['archive_labels'], 'reason': row['archive_reason']})
+    kept_ids = set(source) - excluded_ids
+    changed_ids = {task for task in kept_ids if set(manifest[task]['labels']) - QUALITY_LABELS}
+    run_url = ('https://huggingface.co/datasets/FWeindel/validated-tasks/blob/'
+               + publication_revision + '/runs/' + record['run'] + '.json')
+    summary = {
+        'source': provenance['source'], 'source_tasks': len(source), 'kept': len(kept_ids),
+        'changed_kept': len(changed_ids), 'unchanged_kept': len(kept_ids - changed_ids),
+        'archived': len(excluded_ids),
+        'changed_by_attributed_stage': dict(Counter(environment_repair_stage(manifest[x]) for x in changed_ids)),
+        'archived_by_attributed_stage': dict(Counter(x['attributed_stage'] for x in exclusions)),
+        'original_images': len({x['image'] for x in source.values()}),
+        'retained_images': len({source[x]['image'] for x in kept_ids}),
+        'image_consolidation': False, 'image_registry': 'https://hub.docker.com/r/aweaiteam/scaleswe/tags',
+        'quality_path_edits_excluded': provenance['instructions_changed'],
+        'quality_suffix_edits_excluded': len(automated_ids),
+        'historical_run': run_url, 'publication_revision': publication_revision,
+        'fresh_validation': False,
+        'evidence_transfer': 'Historical stages 3/4/5 only. Original instructions restored; every other file and its mode preserved from the audited publication. No new runtime or teacher run.',
+    }
+    schema = published.schema_arrow.with_metadata({b'ot.environment_reliable.v1': json.dumps(summary).encode()})
+    output.mkdir(parents=True)
+    retained_audit, seen = [], set()
+    with pq.ParquetWriter(output/'tasks.parquet', schema, compression='zstd') as writer:
+        for batch in published.iter_batches(batch_size=32):
+            rows = batch.to_pylist()
+            for row in rows:
+                task = row['path']
+                if task in seen or task not in kept_ids or task not in automated_ids:
+                    raise ValueError('Invalid retained task: ' + task)
+                seen.add(task)
+                if row['stages_passed'] != '1,3,4,5':
+                    raise ValueError('Incomplete historical evidence: ' + task)
+                before = archive_files(row['task_binary'])
+                if files_digest((k, v) for k, (v, _) in before.items()) != row['content_sha256']:
+                    raise ValueError('Published content hash mismatch: ' + task)
+                pre_static, count = re.subn(
+                    rb'\n\nYou have [0-9]+ seconds to complete this task\. Do not cheat by using online solutions or hints specific to this task\.\n$',
+                    b'\n', before['instruction.md'][0])
+                if count != 1 or hashlib.sha256(restore_source_instruction(row['task_binary'], pre_static)).hexdigest() != manifest[task]['output_binary_sha256']:
+                    raise ValueError('Historical payload differs from recorded patcher output: ' + task)
+                payload = restore_source_instruction(row['task_binary'], source[task]['instruction'])
+                after = archive_files(payload)
+                if {k: v for k, v in before.items() if k != 'instruction.md'} != {
+                        k: v for k, v in after.items() if k != 'instruction.md'}:
+                    raise ValueError('Runtime content changed: ' + task)
+                actual = {k: (hashlib.sha256(v).hexdigest(), mode) for k, (v, mode) in after.items()}
+                changed_files = sorted(k for k in actual.keys() | source[task]['files'].keys()
+                                       if actual.get(k) != source[task]['files'].get(k))
+                expected = sorted(k for k in manifest[task]['changed_files'] if k != 'instruction.md')
+                if changed_files != expected or bool(changed_files) != (task in changed_ids):
+                    raise ValueError('Unaccounted runtime repair: ' + task)
+                if not changed_files and hashlib.sha256(payload).hexdigest() != manifest[task]['source_binary_sha256']:
+                    raise ValueError('Unchanged task differs from original archive: ' + task)
+                row.update(task_binary=payload, content_sha256=files_digest((k, v) for k, (v, _) in after.items()),
+                           stages_passed='3,4,5', run=run_url, patch_changed=bool(changed_files),
+                           patch_labels=sorted(set(manifest[task]['labels']) - QUALITY_LABELS))
+                retained_audit.append({'task_id': task, 'changed_files': changed_files,
+                    'labels': row['patch_labels'], 'reason': manifest[task].get('reason', ''),
+                    'attributed_stage': environment_repair_stage(manifest[task]),
+                    'source_binary_sha256': manifest[task]['source_binary_sha256'],
+                    'output_binary_sha256': hashlib.sha256(payload).hexdigest(),
+                    'content_sha256': row['content_sha256'], 'image': source[task]['image']})
+            writer.write_table(pa.Table.from_pylist(rows, schema=schema))
+    if seen != kept_ids:
+        raise ValueError('Missing retained tasks')
+    for row in archive_rows:
+        row['run'] = run_url
+    pq.write_table(pa.Table.from_pylist(archive_rows, schema=archived.schema).replace_schema_metadata(schema.metadata),
+                   output/'archive.parquet', compression='zstd')
+    (output/'summary.json').write_text(json.dumps(summary, indent=2)+'\n')
+    (output/'audit.json').write_text(json.dumps({'summary': summary, 'retained': retained_audit,
+        'exclusions': exclusions}, indent=2)+'\n')
+    (output/'images.json').write_text(json.dumps({task: source[task]['image'] for task in sorted(kept_ids)}, indent=2)+'\n')
+    return summary
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--source', type=Path)
+    parser.add_argument('--validated-tasks', type=Path)
+    parser.add_argument('--validated-archive', type=Path)
+    parser.add_argument('--upstream-shards', type=Path)
+    parser.add_argument('--run-record', type=Path)
+    parser.add_argument('--publication-revision')
+    parser.add_argument('--output', type=Path, required=True, help='new output directory')
+    parser.add_argument('--resolution-report', type=Path, action='append', default=[])
+    parser.add_argument('--automatic-paths', action='store_true', help='use shared automatic normalization, without a review file')
+    parser.add_argument('--review', type=Path, help='review JSON: tasks maps IDs to decisions and unresolved reasons')
+    args = parser.parse_args()
+    if args.validated_tasks:
+        if args.source or args.review or args.automatic_paths or args.resolution_report:
+            parser.error('Environment preparation cannot be combined with instruction patching')
+        if not all((args.validated_archive, args.upstream_shards, args.run_record, args.publication_revision)):
+            parser.error('Environment preparation requires archive, upstream shards, run record and publication revision')
+        print(json.dumps(prepare_environment(args.upstream_shards, args.validated_tasks,
+            args.validated_archive, args.run_record, args.output, args.publication_revision), indent=2))
+        return
+    if not args.source or any((args.validated_archive, args.upstream_shards, args.run_record, args.publication_revision)):
+        parser.error('Supply --source, or the complete environment preparation inputs')
+    if args.output.exists():
+        raise ValueError('Use a new output directory')
+    review = json.loads(args.review.read_text())['tasks'] if args.review else {}
+    evidence = collect_reports(args.resolution_report)
+    source = pq.read_table(args.source)
+    rows = source.to_pylist()
+    names = {row['path'] for row in rows}
+    if set(review) - names:
+        raise ValueError('Review contains tasks outside the source')
+    labels, reasons, unresolved, changes = {}, {}, {}, {}
+    dropped = {name: ARCHIVED_TASKS[name] for name in names & ARCHIVED_TASKS.keys()}
+    rows = [row for row in rows if row['path'] not in dropped]
+    for row in rows:
+        name = row['path']
+        decision = review.get(name, {})
+        automatic_paths = args.automatic_paths and name in evidence and bool(evidence[name]['selected'].get('diagnostic', {}).get('agent_baseline', {}).get('task_sha256'))
+        selected = evidence[name]['selected'] if automatic_paths or decision.get('replacements') else {}
+        row['task_binary'], edits = patch_blob(
+            row['task_binary'], selected.get('diagnostic'), decision.get('replacements', []),
+            oracle_passed=selected.get('status') == 'passed' and bool(selected.get('rewards')) and all(r == 1 for r in selected['rewards']),
+            task_id=name, automatic_paths=automatic_paths)
+        if not edits:
+            continue
+        changes[name] = edits
+        labels[name] = []
+        descriptions = []
+        if any(e.get('phase') not in ('verifier-import-path', 'verifier-call-time-imports', 'verifier-worker-cleanup', 'verifier-exact-test-ids', 'verifier-debug-stream-isolation', 'verifier-request-cleanup', 'verifier-cpu-affinity', 'verifier-test-fixture-restoration', 'verifier-required-test-skipped') for e in edits):
+            labels[name].append('instruction-path-clarified')
+            descriptions.append('User-approved minimal instruction correction' if name in INSTRUCTION_CORRECTIONS
+                                else 'Absolute paths supported by task-setup/reference-solution observations')
+        if any(e.get('phase') == 'verifier-import-path' for e in edits):
+            labels[name].append('verifier-import-path')
+            descriptions.extend(e['reason'] for e in edits if e.get('phase') == 'verifier-import-path')
+        fixture_repairs = [e for e in edits if e.get('phase') == 'verifier-test-fixture-restoration']
+        if fixture_repairs:
+            labels[name].append('verifier-test-fixture-restoration')
+            descriptions.extend(e['reason'] for e in fixture_repairs)
+        if any(e.get('phase') == 'verifier-call-time-imports' for e in edits):
+            labels[name].append('verifier-call-time-imports')
+            descriptions.append('Move reviewed feature imports into consuming test functions so missing functionality fails during test execution; preserve selected tests, assertions and reward rules')
+        cleanup = [e['reason'] for e in edits if e.get('phase') == 'verifier-worker-cleanup']
+        if cleanup:
+            labels[name].append('verifier-worker-cleanup')
+            descriptions.extend(cleanup)
+        exact_ids = [e['reason'] for e in edits if e.get('phase') == 'verifier-exact-test-ids']
+        if exact_ids:
+            labels[name].append('verifier-exact-test-ids')
+            descriptions.extend(exact_ids)
+        debug_stream = [e['reason'] for e in edits if e.get('phase') == 'verifier-debug-stream-isolation']
+        if debug_stream:
+            labels[name].append('verifier-debug-stream-isolation')
+            descriptions.extend(debug_stream)
+        request_cleanup = [e['reason'] for e in edits if e.get('phase') == 'verifier-request-cleanup']
+        if request_cleanup:
+            labels[name].append('verifier-request-cleanup')
+            descriptions.extend(request_cleanup)
+        cpu_affinity = [e['reason'] for e in edits if e.get('phase') == 'verifier-cpu-affinity']
+        if cpu_affinity:
+            labels[name].append('verifier-cpu-affinity')
+            descriptions.extend(cpu_affinity)
+        skipped = [e['reason'] for e in edits if e.get('phase') == 'verifier-required-test-skipped']
+        if skipped:
+            labels[name].append('verifier-required-test-skipped')
+            descriptions.extend(skipped)
+        reasons[name] = '; '.join(descriptions)
+        if decision.get('unresolved'):
+            unresolved[name] = decision['unresolved']
+    args.output.mkdir(parents=True)
+    output = args.output / 'tasks.parquet'
+    from validation.checks.path_cache import KEY, blob_fingerprint, completed
+    cache = {row['path']: blob_fingerprint(row['task_binary']) for row in rows
+             if row['path'] in evidence and completed(evidence[row['path']]['selected']['diagnostic'])}
+    metadata = dict(source.schema.metadata or {})
+    metadata[KEY] = json.dumps(cache).encode()
+    pq.write_table(pa.Table.from_pylist(rows, schema=source.schema).replace_schema_metadata(metadata), output)
+    (args.output / 'path-edits.json').write_text(json.dumps(changes, indent=2)+'\n')
+    (args.output / 'unresolved-paths.json').write_text(json.dumps(unresolved, indent=2)+'\n')
+    write_patch_report(args.source, output, patcher=__file__, source={
+        'dataset': 'PrimeIntellect/Scale-SWE-Verified', 'revision': REVISION,
+        'url': f'https://huggingface.co/datasets/PrimeIntellect/Scale-SWE-Verified/tree/{REVISION}'},
+        dropped=dropped, change_labels=labels, change_reasons=reasons,
+        patches=[{'version': 'absolute-paths-v1', 'resolver_reports': [str(p.resolve()) for p in args.resolution_report],
+                  'automatic_paths': args.automatic_paths, 'review': str(args.review.resolve()) if args.review else None},
+                 {'version': 'verifier-import-path-v2',
+                  'tasks': sorted(name for name in changes if name in VERIFIER_IMPORT_TASKS)},
+                 {'version': 'reviewed-collection-repairs-v1', 'tasks': sorted(set(changes) & DEFERRED_IMPORTS.keys()),
+                  'archived_tasks': sorted(dropped)},
+                 {'version': 'gold-added-test-fixtures-v1',
+                  'tasks': sorted(name for name, task_edits in changes.items()
+                                  if any(e.get('phase') == 'verifier-test-fixture-restoration'
+                                         for e in task_edits))},
+                 {'version': 'skipped-required-tests-v1', 'tasks': sorted(name for name in changes if name in SKIPPED_REQUIRED_TESTS)}])
+    print(json.dumps({'tasks': len(rows), 'changed': len(changes), 'output': str(output)}))
+
+
+if __name__ == '__main__':
+    main()

swelego-real-data-verified_environment-reliable/assets/Leap_Second.dat

@@ -0,0 +1,41 @@
+#  Value of TAI-UTC in second valid beetween the initial value until
+#  the epoch given on the next line. The last line reads that NO
+#  leap second was introduced since the corresponding date 
+#  Updated through IERS Bulletin 72 issued in July 2026
+#  
+#
+#  File expires on 28 June 2027
+#
+#
+#    MJD        Date        TAI-UTC (s)
+#           day month year
+#    ---    --------------   ------   
+#
+    41317.0    1  1 1972       10
+    41499.0    1  7 1972       11
+    41683.0    1  1 1973       12
+    42048.0    1  1 1974       13
+    42413.0    1  1 1975       14
+    42778.0    1  1 1976       15
+    43144.0    1  1 1977       16
+    43509.0    1  1 1978       17
+    43874.0    1  1 1979       18
+    44239.0    1  1 1980       19
+    44786.0    1  7 1981       20
+    45151.0    1  7 1982       21
+    45516.0    1  7 1983       22
+    46247.0    1  7 1985       23
+    47161.0    1  1 1988       24
+    47892.0    1  1 1990       25
+    48257.0    1  1 1991       26
+    48804.0    1  7 1992       27
+    49169.0    1  7 1993       28
+    49534.0    1  7 1994       29
+    50083.0    1  1 1996       30
+    50630.0    1  7 1997       31
+    51179.0    1  1 1999       32
+    53736.0    1  1 2006       33
+    54832.0    1  1 2009       34
+    56109.0    1  7 2012       35
+    57204.0    1  7 2015       36
+    57754.0    1  1 2017       37

swelego-real-data-verified_environment-reliable/assets/environment-repairs.json

@@ -0,0 +1,296 @@
+{
+ "source_revision": "8b0d2bed6f04ef571ca04abebf737ea23cbceaf3",
+ "tasks": {
+  "borgbackup__borg-5263": {
+   "base_commit": "5ebde5cebc3ef572552b368228eaad4d29f0ee39",
+   "label": "restored-git-version-history",
+   "reason": "Restore the pinned base commit ancestry and its verified historical release tag, without checking out later code. Our depth-one checkout lost the history needed for the source version and, for Sunpy, triggered a shallow-repository warning treated as an error."
+  },
+  "dask__fastparquet-940": {
+   "base_commit": "0f7a98eac60771685f853f8a955787b7c82a5d18",
+   "label": "restored-git-version-history",
+   "reason": "Restore the pinned base commit ancestry and its verified historical release tag, without checking out later code. Our depth-one checkout lost the history needed for the source version and, for Sunpy, triggered a shallow-repository warning treated as an error."
+  },
+  "gitpython-developers__GitPython-1812": {
+   "base_commit": "307f1987596a99fb7b7192d8a5308a0df736ca7b",
+   "label": "restored-git-test-history",
+   "reason": "Restore the pinned base commit ancestry and attach HEAD to a local task branch at that same commit. GitPython tests inspect parents, historical commits and symbolic HEAD; our shallow detached checkout omitted those inputs. Preserve source, test assertions and reference patch.",
+   "full_history": true,
+   "branch": "swelego-task"
+  },
+  "gitpython-developers__GitPython-1547": {
+   "base_commit": "cc92d5126b2fc80f7cc6866fc8f99b3ffb0189ae",
+   "label": "restored-git-test-history",
+   "reason": "Restore the pinned base commit ancestry and attach HEAD to a local task branch at that same commit. GitPython tests inspect parents, historical commits and symbolic HEAD; our shallow detached checkout omitted those inputs. Preserve source, test assertions and reference patch.",
+   "full_history": true,
+   "branch": "swelego-task"
+  },
+  "gitpython-developers__GitPython-1832": {
+   "base_commit": "afa575454f85b34800460881cc9c3cd7fe78c8e3",
+   "label": "restored-git-test-history",
+   "reason": "Restore the pinned base commit ancestry and attach HEAD to a local task branch at that same commit. GitPython tests inspect parents, historical commits and symbolic HEAD; our shallow detached checkout omitted those inputs. Preserve source, test assertions and reference patch. Restore the verified historical 0.1.6 tag explicitly queried by test_diff_interface.",
+   "full_history": true,
+   "branch": "swelego-task"
+  },
+  "sunpy__sunpy-7522": {
+   "base_commit": "27f7e032c1a7f9a911dca618f8b2011ad82d7a78",
+   "label": "restored-git-version-history",
+   "reason": "Restore the pinned base commit ancestry and its verified historical release tag, without checking out later code. Our depth-one checkout lost the history needed for the source version and, for Sunpy, triggered a shallow-repository warning treated as an error. After restoring history, collection exposed an expired leap-second table. Restore the IERS Bulletin72 table, valid through 2027-06-28, from a checksum-pinned local artifact; preserve astropy and other dependency versions and avoid a verification-time download.",
+   "additional_labels": [
+    "refreshed-leap-second-data"
+   ],
+   "leap_second_table": {
+    "source": "https://hpiers.obspm.fr/iers/bul/bulc/Leap_Second.dat",
+    "bulletin": 72,
+    "expires": "2027-06-28",
+    "sha256": "6cb6f5d4b819f2e568e25db4b0b26d89dedf031fdffb18bc94d40f4e94e268d7"
+   }
+  },
+  "vyperlang__vyper-3384": {
+   "base_commit": "5ae0a0784426697529c71e4724ccf43ad9c36f07",
+   "label": "restored-generated-version-metadata",
+   "reason": "Restore the setuptools-scm build plugin declared by the pinned source so installation generates its version module. The runtime freeze omitted this build tool; our installation without build isolation did not regenerate the file. This repairs environment reconstruction, not the task code or reference patch."
+  },
+  "vyperlang__vyper-4253": {
+   "base_commit": "6bcdb00e1c9faaf940395b44756d4970919fd58c",
+   "label": "restored-generated-version-metadata",
+   "reason": "Restore the setuptools-scm build plugin declared by the pinned source so installation generates its version module. The runtime freeze omitted this build tool; our installation without build isolation did not regenerate the file. This repairs environment reconstruction, not the task code or reference patch."
+  },
+  "pimutils__khal-1305": {
+   "base_commit": "25c5c2671908a72f82f4d2add02068374ffb3242",
+   "label": "restored-generated-version-metadata",
+   "reason": "Restore the setuptools-scm build plugin declared by the pinned source so installation generates its version module. The runtime freeze omitted this build tool; our installation without build isolation did not regenerate the file. This repairs environment reconstruction, not the task code or reference patch."
+  },
+  "statsmodels__statsmodels-8339": {
+   "base_commit": "35b803767bd7803ca5f9fc35d4546aa8cb7be844",
+   "label": "restored-generated-version-metadata",
+   "reason": "Restore the setuptools-scm build plugin declared by the pinned source so installation generates its version module. The runtime freeze omitted this build tool; our installation without build isolation did not regenerate the file. This repairs environment reconstruction, not the task code or reference patch."
+  },
+  "statsmodels__statsmodels-8831": {
+   "base_commit": "3e739c26729e2c844394f5918846e2897ad0f871",
+   "label": "restored-generated-version-metadata",
+   "reason": "Restore the setuptools-scm build plugin declared by the pinned source so installation generates its version module. The runtime freeze omitted this build tool; our installation without build isolation did not regenerate the file. This repairs environment reconstruction, not the task code or reference patch."
+  },
+  "pytest-dev__pytest-xdist-667": {
+   "base_commit": "7f2426b11d2c7890e5637fdaa3aa1c75b4f31758",
+   "label": "restored-generated-version-metadata",
+   "reason": "Restore the setuptools-scm build plugin declared by the pinned source so installation generates its version module. The runtime freeze omitted this build tool; our installation without build isolation did not regenerate the file. This repairs environment reconstruction, not the task code or reference patch."
+  },
+  "zarr-developers__zarr-python-659": {
+   "base_commit": "da4f790ace08ae9ee2ff25289a7d3f40c6ecb61a",
+   "label": "restored-generated-version-metadata",
+   "reason": "Restore the setuptools-scm build plugin declared by the pinned source so installation generates its version module. The runtime freeze omitted this build tool; our installation without build isolation did not regenerate the file. This repairs environment reconstruction, not the task code or reference patch."
+  },
+  "sympy__sympy-10635": {
+   "base_commit": "72058725d8bd819aa68450ddfb619b681d9e1dd2",
+   "label": "verifier-legacy-pytest-helper",
+   "reason": "Restore the missing raises export in the legacy SymPy pytest helper using pytest.raises during verification. The source defines raises only outside pytest mode, so selected tests fail collection under the recorded pytest runner. Preserve assertions, test selection, dependency versions and reference patch.",
+   "pytest_plugin": "swelego_sympy_pytest"
+  },
+  "sympy__sympy-10753": {
+   "base_commit": "b23618db3be6f3af9f288002064a14b5aa4ea932",
+   "label": "verifier-legacy-pytest-helper",
+   "reason": "Restore the missing raises export in the legacy SymPy pytest helper using pytest.raises during verification. The source defines raises only outside pytest mode, so selected tests fail collection under the recorded pytest runner. Preserve assertions, test selection, dependency versions and reference patch.",
+   "pytest_plugin": "swelego_sympy_pytest"
+  },
+  "sympy__sympy-10762": {
+   "base_commit": "325341a268a9e7aa07511245b964a3d727167150",
+   "label": "verifier-legacy-pytest-helper",
+   "reason": "Restore the missing raises export in the legacy SymPy pytest helper using pytest.raises during verification. The source defines raises only outside pytest mode, so selected tests fail collection under the recorded pytest runner. Preserve assertions, test selection, dependency versions and reference patch.",
+   "pytest_plugin": "swelego_sympy_pytest"
+  },
+  "sympy__sympy-10808": {
+   "base_commit": "0da63c857cc29ff62c4a4b25158d43c3cf3776e6",
+   "label": "verifier-legacy-pytest-helper",
+   "reason": "Restore the missing raises export in the legacy SymPy pytest helper using pytest.raises during verification. The source defines raises only outside pytest mode, so selected tests fail collection under the recorded pytest runner. Preserve assertions, test selection, dependency versions and reference patch.",
+   "pytest_plugin": "swelego_sympy_pytest"
+  },
+  "sympy__sympy-10827": {
+   "base_commit": "c6c5dfb9ba567c340a420af67ca0b46eace7a45a",
+   "label": "verifier-legacy-pytest-helper",
+   "reason": "Restore the missing raises export in the legacy SymPy pytest helper using pytest.raises during verification. The source defines raises only outside pytest mode, so selected tests fail collection under the recorded pytest runner. Preserve assertions, test selection, dependency versions and reference patch.",
+   "pytest_plugin": "swelego_sympy_pytest"
+  },
+  "sympy__sympy-11149": {
+   "base_commit": "db73ed37b955474ad9f1b3d2c5c762e32ce2cbfe",
+   "label": "verifier-legacy-pytest-helper",
+   "reason": "Restore the missing raises export in the legacy SymPy pytest helper using pytest.raises during verification. The source defines raises only outside pytest mode, so selected tests fail collection under the recorded pytest runner. Preserve assertions, test selection, dependency versions and reference patch.",
+   "pytest_plugin": "swelego_sympy_pytest"
+  },
+  "pymor__pymor-1296": {
+   "base_commit": "6114612e5574117570df66cb2404ce1f822dc145",
+   "label": "aligned-build-runtime-numpy",
+   "reason": "Replace runtime numpy==2.0.2 with numpy==1.23.5 for this legacy PyMOr checkout, matching the NumPy headers used by its isolated numpy.distutils build. The original frozen NumPy 2 runtime cannot load the resulting NumPy 1 ABI extension. Preserve other runtime pins and the reference patch.",
+   "runtime_replacements": {
+    "numpy==2.0.2": "numpy==1.23.5"
+   }
+  },
+  "deepset-ai__haystack-9242": {
+   "base_commit": "cdc53cae78d080d67ecaa184ff16a83dba13a010",
+   "label": "restored-verifier-dependencies",
+   "reason": "Install pytest-asyncio==0.26.0, declared by the pinned Haystack development dependencies but absent from the recorded runtime freeze. This enables the existing strict asyncio marker and async fixtures without changing tests or reference code.",
+   "test_dependencies": [
+    "pytest-asyncio==0.26.0"
+   ]
+  },
+  "pymor__pymor-1068": {
+   "base_commit": "d7b624f892daa4194b4504e753d198461626aaa0",
+   "label": "aligned-build-runtime-numpy",
+   "reason": "Replace runtime numpy==2.0.2 with numpy==1.23.5 for this legacy PyMOr checkout, matching the NumPy headers used by its isolated numpy.distutils build. The original frozen NumPy 2 runtime cannot load the resulting NumPy 1 ABI extension. Preserve other runtime pins and the reference patch.",
+   "runtime_replacements": {
+    "numpy==2.0.2": "numpy==1.23.5"
+   }
+  },
+  "blue-yonder__tsfresh-578": {
+   "base_commit": "c3d35c42c799d1f36a1aca1d90ec0ab6450ce264",
+   "label": "bounded-verifier-parallelism",
+   "reason": "Use two pytest workers and one numerical-library thread per worker for this verifier. Upstream automatic worker selection sees the 384-CPU host instead of the task allocation, causing excessive process startup and resource contention. Preserve selected tests, assertions, dependencies and reference patch.",
+   "pytest_workers": 2
+  },
+  "pybamm-team__PyBaMM-3968": {
+   "base_commit": "09ee982ba84055ec2c56f73b4cc63742c2ca0721",
+   "label": "bounded-verifier-parallelism",
+   "reason": "Use two pytest workers and one numerical-library thread per worker for this verifier. Upstream automatic worker selection sees the 384-CPU host instead of the task allocation, causing excessive process startup and resource contention. Preserve selected tests, assertions, dependencies and reference patch. Install the declared citation extra pybtex and its missing latexcodec dependency so the unfixed package imports during collection. The original regression test then deliberately removes optional dependencies and still exercises the missing-dependency bug during test execution.",
+   "pytest_workers": 2,
+   "test_dependencies": [
+    "pybtex==0.24.0",
+    "latexcodec==3.0.0"
+   ],
+   "additional_labels": [
+    "restored-verifier-dependencies"
+   ]
+  },
+  "pybamm-team__PyBaMM-4179": {
+   "base_commit": "088ca3827c831e1b93c4667b6f4353f64fb32cbf",
+   "label": "bounded-verifier-parallelism",
+   "reason": "Use two pytest workers and one numerical-library thread per worker for this verifier. Upstream automatic worker selection sees the 384-CPU host instead of the task allocation, causing excessive process startup and resource contention. Preserve selected tests, assertions, dependencies and reference patch.",
+   "pytest_workers": 2
+  },
+  "pybamm-team__PyBaMM-4221": {
+   "base_commit": "b50dfa595dd93a2943aa2a5a8aa14ac9468aea8e",
+   "label": "bounded-verifier-parallelism",
+   "reason": "Use two pytest workers and one numerical-library thread per worker for this verifier. Upstream automatic worker selection sees the 384-CPU host instead of the task allocation, causing excessive process startup and resource contention. Preserve selected tests, assertions, dependencies and reference patch.",
+   "pytest_workers": 2
+  },
+  "pybamm-team__PyBaMM-4267": {
+   "base_commit": "668e563b01749bcbb55a017e39b0cf94d8256619",
+   "label": "bounded-verifier-parallelism",
+   "reason": "Use two pytest workers and one numerical-library thread per worker for this verifier. Upstream automatic worker selection sees the 384-CPU host instead of the task allocation, causing excessive process startup and resource contention. Preserve selected tests, assertions, dependencies and reference patch.",
+   "pytest_workers": 2
+  },
+  "common-workflow-language__cwltool-1964": {
+   "base_commit": "8ff1fd05a12a124d104a67b7fd8ac3382c3e5212",
+   "label": "bounded-verifier-parallelism",
+   "reason": "Use two pytest workers and one numerical-library thread per worker for this verifier. Upstream automatic worker selection sees the 384-CPU host instead of the task allocation, causing excessive process startup and resource contention. Preserve selected tests, assertions, dependencies and reference patch.",
+   "pytest_workers": 2
+  },
+  "pybamm-team__PyBaMM-4192": {
+   "base_commit": "deca7e2bc404d94a8c944507fb2adee71546b5b0",
+   "label": "bounded-verifier-parallelism",
+   "reason": "Use two pytest workers and one numerical-library thread per worker for this verifier. Upstream automatic worker selection sees the 384-CPU host instead of the task allocation, causing excessive process startup and resource contention. Preserve selected tests, assertions, dependencies and reference patch.",
+   "pytest_workers": 2
+  },
+  "pybamm-team__PyBaMM-4072": {
+   "base_commit": "5f35628f21d44a4152419b7d8215a40f201709bc",
+   "label": "bounded-verifier-parallelism",
+   "reason": "Use two pytest workers and one numerical-library thread per worker for this verifier. Upstream automatic worker selection sees the 384-CPU host instead of the task allocation, causing excessive process startup and resource contention. Preserve selected tests, assertions, dependencies and reference patch.",
+   "pytest_workers": 2
+  },
+  "tobymao__sqlglot-3166": {
+   "base_commit": "cdbe39e7ec36b30e211942b1f62ae86946c7b520",
+   "label": "bounded-verifier-process-pool",
+   "reason": "Bound the optimizer test module ProcessPoolExecutor to two spawned workers. Its default creates a host-sized pool for each fixture group, despite the smaller task allocation; spawning also avoids forking after DuckDB initializes threads. Preserve submitted fixture jobs, result assertions, selected tests, dependencies and reference patch.",
+   "pytest_plugin": "swelego_sqlglot_workers"
+  },
+  "tobymao__sqlglot-4004": {
+   "base_commit": "fcaae87d50653600048917945652cdf463bcc3cf",
+   "label": "bounded-verifier-process-pool",
+   "reason": "Bound the optimizer test module ProcessPoolExecutor to two spawned workers. Its default creates a host-sized pool for each fixture group, despite the smaller task allocation; spawning also avoids forking after DuckDB initializes threads. Preserve submitted fixture jobs, result assertions, selected tests, dependencies and reference patch.",
+   "pytest_plugin": "swelego_sqlglot_workers"
+  },
+  "python-lsp__python-lsp-server-309": {
+   "base_commit": "cd9941c485516a1993c9c3beb7d407696b06c9cd",
+   "label": "bounded-verifier-process-pool",
+   "reason": "Bound the pinned Rope 1.13.0 autoimport cache ProcessPoolExecutor to two spawned workers. Its default sizes to the host rather than the task allocation; the diagnostic run exhausted task memory while initializing the cache. Preserve indexed packages, cache generation work, test assertions and reference patch.",
+   "pytest_plugin": "swelego_rope_workers"
+  },
+  "holoviz__holoviews-6346": {
+   "base_commit": "c1e22a3e2d38046da285ae3c67f076e60c19226a",
+   "label": "repair-directory-package-metadata",
+   "reason": "Remove only the malformed directory at tomli's dist-info METADATA path before installing the frozen requirements. Pip failed because that path was a directory rather than its required metadata file; the pinned tomli package is then installed normally. After that repair the verifier still failed: the package computes its version with setuptools_scm, which treats our depth-one checkout as a shallow repository and fails conftest import before any test runs (jobs 959924 and 960175). Fetch the pinned commit's full ancestry without checking out later code, as for setuptools_scm-854. Preserve runtime dependency pins, tests and reference patch.",
+   "remove_directory_metadata": "tomli-2.0.1.dist-info/METADATA",
+   "full_history": true,
+   "additional_labels": [
+    "restore-git-version-history"
+   ]
+  },
+  "astropy__astropy-16241": {
+   "base_commit": "33265f16ebb00d3c6c5812911df0d9b4e1bbb8e0",
+   "label": "refreshed-leap-second-data",
+   "reason": "The regression verifier runs after the bundled leap-second table has expired and Astropy raises an IERSStaleWarning while building coordinate frames. Install the checksum-pinned IERS Bulletin 72 table, valid through 2027-06-28, into astropy_iers_data during setup. Preserve runtime dependency pins, tests and reference patch.",
+   "leap_second_table": {
+    "source": "https://hpiers.obspm.fr/iers/bul/bulc/Leap_Second.dat",
+    "bulletin": 72,
+    "expires": "2027-06-28",
+    "sha256": "6cb6f5d4b819f2e568e25db4b0b26d89dedf031fdffb18bc94d40f4e94e268d7"
+   }
+  },
+  "astropy__pyvo-357": {
+   "base_commit": "861298fbff5395d61af8192b9b739cff911cb025",
+   "label": "refreshed-leap-second-data",
+   "reason": "The async TAP regression verifier triggers Astropy's expired bundled leap-second table and raises an IERSStaleWarning. Install the checksum-pinned IERS Bulletin 72 table, valid through 2027-06-28, into astropy_iers_data during setup. Preserve runtime dependency pins, tests and reference patch.",
+   "leap_second_table": {
+    "source": "https://hpiers.obspm.fr/iers/bul/bulc/Leap_Second.dat",
+    "bulletin": 72,
+    "expires": "2027-06-28",
+    "sha256": "6cb6f5d4b819f2e568e25db4b0b26d89dedf031fdffb18bc94d40f4e94e268d7"
+   }
+  },
+  "pypa__setuptools_scm-854": {
+   "base_commit": "8856af656b576f8b8c3612303007bbaa92ec8d50",
+   "label": "restore-git-version-history",
+   "reason": "The reference verifier's version test fails because the shallow task checkout emits a warning where complete history is required. Fetch the pinned commit's full ancestry without checking out later code. Preserve dependency versions, tests and reference patch.",
+   "full_history": true
+  },
+  "moogar0880__PyTrakt-54": {
+   "base_commit": "f574c1c1dfc6f65f21296184659aadc2879f2be6",
+   "label": "verifier-fixed-date",
+   "reason": "The verifier includes an unrelated `now()` format check that fails only in October: the pinned code pads month 10 as `010` because it compares the month with `> 10`. Fix the verifier-local clock to November 2026 so this test checks formatting without depending on the run date; preserve the task source, assertions and reference patch.",
+   "pytest_plugin": "swelego_pytrakt_clock"
+  },
+  "tomerfiliba-org__rpyc-479": {
+   "base_commit": "94dbe362d1e12fb0c48bb795aecc1180d6a1a690",
+   "label": "verifier-allowed-cpu-affinity",
+   "reason": "The affinity regression test pinned to CPU 0, outside the CPU set allocated to its task. In the verifier copy, pin to the lowest CPU already allowed by the task instead. This still tests single-CPU affinity and threaded RPyC behavior without depending on a node-specific CPU number; preserve test selection, assertions and reference patch.",
+   "verifier_script": "swelego_rpyc_affinity.py"
+  },
+  "zarr-developers__zarr-python-2784": {
+   "base_commit": "c66f32b93f1dfe4b4e6deebb22a5ea45d40c5aa5",
+   "label": "restored-git-version-history",
+   "reason": "Restore the pinned base commit ancestry and the preceding release tag v3.0.2 (commit cab29d21, 2025-01-31, thirteen commits before the base), without checking out later code. The package version comes from hatch-vcs; in our depth-one checkout it fell below 3.0.0, so the pinned numcodecs 0.15.1 refused its zarr integration and the required test test_roundtrip_numcodecs failed with ImportError while the other 713 selected tests passed (job 964135). Preserve dependency versions, tests and reference patch."
+  },
+  "tox-dev__tox-2643": {
+   "base_commit": "267d3275ad929b12e951dc8a6d2b73aa3e61b168",
+   "label": "restored-git-version-history",
+   "reason": "Restore the pinned base commit ancestry and the preceding release tag 4.0.2 (commit 5c0863ce, two commits before the base), without checking out later code. tox computes its version with setuptools_scm; in our depth-one checkout it became 0.1.dev1, so every child tox run in the four failing integration tests decided the host tox did not satisfy tox>=4.0, tried to provision it from the tests' deliberately unreachable index and exited 1 (job 964137). Preserve dependency versions, tests and reference patch."
+  },
+  "sigmavirus24__github3.py-1167": {
+   "base_commit": "99398b4de421dde31992f3e9127f1e1f594124e0",
+   "label": "bounded-verifier-parallelism",
+   "pytest_workers": 2,
+   "reason": "Use two pytest workers for this verifier. The repository configuration enables pytest-xdist with automatic worker selection, which sees the 384-CPU host instead of the task allocation: the verifier was killed at 4 GiB and at 12 GiB (jobs 960179, 964134) while every test alone peaks at 45 MiB, and under a thread limit the same run died in xdist node startup with \"can't start new thread\" (job 964365). Preserve selected tests, assertions, dependencies and reference patch."
+  },
+  "pybamm-team__PyBaMM-4644": {
+   "base_commit": "3bf74038405bd9f489395eb3c3ae2cbd4911a1c5",
+   "label": "bounded-verifier-parallelism",
+   "pytest_workers": 2,
+   "reason": "Use two pytest workers and one numerical-library thread per worker for this verifier. The repository configuration enables pytest-xdist with automatic worker selection, which sees the 384-CPU host: the verifier was killed at 4 GiB and at 12 GiB (jobs 960179, 964134, 964365) while every selected test alone peaks at 207 MiB (job 964137). Preserve selected tests, assertions, dependencies and reference patch."
+  },
+  "RightBrain-Networks__auto-semver-51": {
+   "base_commit": "eaebfcc3297fd1adb355069691cbf5e95eb31731",
+   "label": "checkout-default-branch",
+   "branch": "master",
+   "reason": "Attach HEAD to a local master branch at the pinned base commit, as the upstream image does. The required test_run_no_merge resolves the current branch name and expects the repository default branch master; on our detached checkout it fails (jobs 959554 and v66-0), while all 17 required tests pass with the gold and test patches on a master branch and only the same test fails detached (local reproduction 2026-10-10). The duplicate-tag messages in the verifier output are emitted by the test suite itself and are not the failure. Preserve source, test assertions and reference patch."
+  }
+ }
+}

swelego-real-data-verified_environment-reliable/assets/f5_test_imports.py

@@ -0,0 +1,44 @@
+"""Defer the reviewed new-feature import until the consuming test runs."""
+import ast
+from pathlib import Path
+
+
+def repair(root):
+    statement = 'from f5.bigip.tm.asm.tasks import Import_Policy'
+    for kind in ('functional', 'unit'):
+        path = Path(root) / f'f5/bigip/tm/asm/test/{kind}/test_tasks.py'
+        source = path.read_text()
+        lines = source.splitlines(keepends=True)
+        tree = ast.parse(source)
+        imports = [n for n in tree.body if isinstance(n, ast.ImportFrom)
+                   and ast.get_source_segment(source, n) == statement]
+        if len(imports) != 1:
+            raise ValueError(f'Expected one reviewed Import_Policy import in {path}')
+        edits = [(imports[0].lineno - 1, imports[0].end_lineno, '')]
+        covered = set()
+        for node in ast.walk(tree):
+            if not isinstance(node, ast.FunctionDef):
+                continue
+            uses = [n for stmt in node.body for n in ast.walk(stmt)
+                    if isinstance(n, ast.Name) and n.id == 'Import_Policy']
+            if not uses:
+                continue
+            first = node.body[0]
+            if isinstance(first, ast.Expr) and isinstance(first.value, ast.Constant) and isinstance(first.value.value, str):
+                first = node.body[1]
+            edits.append((first.lineno - 1, first.lineno - 1,
+                          ' ' * first.col_offset + statement + '\n'))
+            covered.update(id(n) for n in uses)
+        all_uses = {id(n) for n in ast.walk(tree)
+                    if isinstance(n, ast.Name) and n.id == 'Import_Policy'}
+        if not covered or covered != all_uses:
+            raise ValueError(f'Unreviewed Import_Policy use in {path}')
+        for start, end, replacement in sorted(edits, reverse=True):
+            lines[start:end] = [replacement]
+        result = ''.join(lines)
+        ast.parse(result)
+        path.write_text(result)
+
+
+if __name__ == '__main__':
+    repair('/testbed')

swelego-real-data-verified_environment-reliable/assets/sdss_verifier_clock.py

@@ -0,0 +1,22 @@
+"""Keep SDSS #69's release-date regression test before DR19 becomes public."""
+import datetime
+import sys
+from types import SimpleNamespace
+
+
+class VerifierDatetime(datetime.datetime):
+    @classmethod
+    def now(cls, tz=None):
+        return cls(2025, 4, 1, tzinfo=tz)
+
+
+def pytest_collection_modifyitems(session, config, items):
+    # Tests import this module during collection. Replace only its datetime
+    # reference, leaving the process clock and other dependencies untouched.
+    module = sys.modules.get('sdss_access.path.path')
+    if module is None:
+        raise RuntimeError('SDSS verifier did not import sdss_access.path.path')
+    clock = SimpleNamespace(**{name: getattr(datetime, name)
+                              for name in dir(datetime) if not name.startswith('__')})
+    clock.datetime = VerifierDatetime
+    module.datetime = clock

swelego-real-data-verified_environment-reliable/assets/setup.sh

@@ -0,0 +1,67 @@
+#!/bin/bash
+set -euo pipefail
+marker=/setup_files/.swelego-@IDENTITY@
+if [ -f "$marker" ]; then exit 0; fi
+@PREPARED@
+export PATH=/opt/conda/envs/testbed/bin:/opt/conda/bin:$PATH
+set +u
+source /opt/conda/bin/activate testbed
+set -u
+export PIP_DISABLE_PIP_VERSION_CHECK=1
+export PIP_DEFAULT_TIMEOUT=60
+export PIP_PROGRESS_BAR=off
+export PIP_ROOT_USER_ACTION=ignore
+export GIT_TERMINAL_PROMPT=0
+@EXPORTS@
+started=$SECONDS
+phase=checkout
+timings=/setup_files/setup-phases.tsv
+: > "$timings"
+last=$SECONDS
+finish_phase() {
+    printf '%s\t%s\n' "$phase" "$((SECONDS-last))" >> "$timings"
+    last=$SECONDS
+    phase=$1
+}
+finish() {
+    status=$?
+    trap - EXIT
+    finish_phase done
+    /opt/conda/bin/python - "$started" "$SECONDS" "$status" <<'PY'
+import json, pathlib, sys
+phases = {}
+for line in pathlib.Path('/setup_files/setup-phases.tsv').read_text().splitlines():
+    name, seconds = line.split('\t')
+    phases[name] = int(seconds)
+result = {'seconds': int(sys.argv[2])-int(sys.argv[1]), 'exit_code': int(sys.argv[3]), 'phases': phases}
+pathlib.Path('/setup_files/setup-timing.json').write_text(json.dumps(result, indent=2)+'\n')
+print('SWELEGO_SETUP_TIMING=' + json.dumps(result), flush=True)
+PY
+    exit "$status"
+}
+trap finish EXIT
+mkdir -p /testbed
+cd /testbed
+git init
+git remote remove origin 2>/dev/null || true
+git remote add origin @REPO@
+git fetch --depth @DEPTH@ origin @COMMIT@
+git checkout --detach --force @COMMIT@
+test "$(git rev-parse HEAD)" = @COMMIT@
+@VERSION_TAG@
+git remote remove origin
+finish_phase conda
+@CONDA@
+finish_phase preinstall
+@PREINSTALL@
+finish_phase dependencies
+python -m pip install --no-deps@PIP_CACHE@ -r /setup_files/requirements.txt
+finish_phase install
+# Frozen dependencies are already restored. The local checkout must not resolve
+# newer versions through extras or an isolated build environment.
+export PIP_NO_DEPS=1
+# pip maps this negative-option environment variable to build_isolation itself.
+export PIP_NO_BUILD_ISOLATION=0
+@INSTALL@
+test "$(git rev-parse HEAD)" = @COMMIT@
+touch "$marker"

swelego-real-data-verified_environment-reliable/assets/swelego_pytrakt_clock.py

@@ -0,0 +1,19 @@
+"""Keep PyTrakt's unrelated current-date formatting test deterministic."""
+import datetime
+import sys
+
+
+class VerifierDatetime(datetime.datetime):
+    @classmethod
+    def now(cls, tz=None):
+        # PyTrakt 0.16.0 pads months using `month > 10`; October therefore
+        # becomes "010". November avoids that unrelated boundary while keeping
+        # the task's existing two-digit date-format assertion meaningful.
+        return cls(2026, 11, 5, tzinfo=tz)
+
+
+def pytest_collection_modifyitems(session, config, items):
+    module = sys.modules.get('trakt.utils')
+    if module is None:
+        raise RuntimeError('PyTrakt did not import trakt.utils')
+    module.datetime = VerifierDatetime

swelego-real-data-verified_environment-reliable/assets/swelego_rope_workers.py

@@ -0,0 +1,14 @@
+"""Bound Rope's autoimport cache workers without changing indexed inputs."""
+from concurrent.futures import ProcessPoolExecutor
+from functools import partial
+import multiprocessing
+
+
+def pytest_configure(config):
+    from rope.contrib.autoimport import sqlite
+
+    if sqlite.ProcessPoolExecutor is not ProcessPoolExecutor:
+        raise RuntimeError('Unexpected Rope autoimport process pool')
+    sqlite.ProcessPoolExecutor = partial(
+        ProcessPoolExecutor, max_workers=2,
+        mp_context=multiprocessing.get_context('spawn'))

swelego-real-data-verified_environment-reliable/assets/swelego_rpyc_affinity.py

@@ -0,0 +1,29 @@
+"""Make RPyC's verifier affinity test honor the task's allocated CPU set."""
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+
+OLD = 'self._os.sched_setaffinity(0, {0, })'
+NEW = 'self._os.sched_setaffinity(0, {min(self._os.sched_getaffinity(0)), })'
+
+
+def rewrite(source: str) -> str:
+    if source.count(OLD) == 1 and source.count(NEW) == 0:
+        return source.replace(OLD, NEW)
+    if source.count(OLD) == 0 and source.count(NEW) == 1:
+        return source
+    raise ValueError('Expected exactly one hard-coded CPU 0 affinity call')
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('test_file', type=Path)
+    args = parser.parse_args()
+    source = args.test_file.read_text()
+    args.test_file.write_text(rewrite(source))
+
+
+if __name__ == '__main__':
+    main()

swelego-real-data-verified_environment-reliable/assets/swelego_sqlglot_workers.py

@@ -0,0 +1,19 @@
+"""Bound only the optimizer test module's fixture worker pool."""
+from concurrent.futures import ProcessPoolExecutor
+from functools import partial
+import multiprocessing
+
+
+def pytest_collection_modifyitems(session, config, items):
+    modules = {item.module for item in items}
+    matched = False
+    for module in modules:
+        if module.__name__ == 'tests.test_optimizer':
+            if module.ProcessPoolExecutor is not ProcessPoolExecutor:
+                raise RuntimeError('Unexpected optimizer fixture process pool')
+            module.ProcessPoolExecutor = partial(
+                ProcessPoolExecutor, max_workers=2,
+                mp_context=multiprocessing.get_context('spawn'))
+            matched = True
+    if not matched:
+        raise RuntimeError('Optimizer verifier tests were not collected')

swelego-real-data-verified_environment-reliable/assets/swelego_sympy_pytest.py

@@ -0,0 +1,9 @@
+"""Restore the exception assertion export omitted by legacy SymPy pytest mode."""
+
+
+def pytest_configure(config):
+    import pytest
+    from sympy.utilities import pytest as helper
+
+    if not hasattr(helper, 'raises'):
+        helper.raises = pytest.raises

swelego-real-data-verified_environment-reliable/assets/wheel-cache.json

@@ -0,0 +1,1473 @@
+{
+  "source_revision": "8b0d2bed6f04ef571ca04abebf737ea23cbceaf3",
+  "measured_tasks": [
+    "pgmpy__pgmpy-1470",
+    "tinosulzer__PyBaMM-66",
+    "tobymao__sqlglot-1944",
+    "roaldnefs__salt-lint-35",
+    "vertexproject__synapse-294",
+    "stfc__PSyclone-834",
+    "astropy__astropy-16127",
+    "rsagroup__rsatoolbox-375",
+    "UXARRAY__uxarray-877",
+    "python-graphblas__python-graphblas-303",
+    "kylebgorman__wikipron-392",
+    "albumentations-team__albumentations-1193",
+    "DHI__mikeio-227",
+    "GjjvdBurg__paper2remarkable-43",
+    "LibertyAces__BitSwanPump-53",
+    "PMEAL__OpenPNM-2550",
+    "Unidata__MetPy-3056",
+    "TeamGraphix__graphix-225",
+    "andersbogsnes__ml_tooling-683",
+    "audeering__auglib-36",
+    "dask__dask-ml-743",
+    "dask__distributed-3021",
+    "eigenfoo__littlemcmc-62",
+    "einsteinpy__einsteinpy-301",
+    "jupyter__nbgrader-947",
+    "lincc-frameworks__nested-pandas-139",
+    "iterative__dvc-6284",
+    "m3dev__gokart-147",
+    "matplotlib__matplotlib-18184",
+    "modin-project__modin-1842",
+    "mne-tools__mne-python-2495",
+    "plotly__dash-796",
+    "pybamm-team__PyBaMM-2141",
+    "pyro-ppl__numpyro-1792",
+    "qutech__qupulse-616",
+    "pytorch__ignite-506"
+  ],
+  "profiles": {
+    "3.10.16": [
+      "Bottleneck==1.4.2",
+      "Cython==3.0.12",
+      "PyYAML==6.0.2",
+      "Pygments==2.19.1",
+      "aiobotocore==2.21.1",
+      "aiohappyeyeballs==2.6.1",
+      "aiohttp==3.11.14",
+      "aioitertools==0.12.0",
+      "aiosignal==1.3.2",
+      "asdf-astropy==0.7.1",
+      "asdf==4.1.0",
+      "asdf_coordinates_schemas==0.3.0",
+      "asdf_standard==1.1.1",
+      "asdf_transform_schemas==0.5.0",
+      "astropy-iers-data==0.2025.3.31.0.36.18",
+      "asttokens==3.0.0",
+      "async-timeout==5.0.1",
+      "attrs==25.3.0",
+      "beautifulsoup4==4.13.3",
+      "bleach==6.2.0",
+      "botocore==1.37.1",
+      "certifi==2025.1.31",
+      "cfgv==3.4.0",
+      "click==8.1.8",
+      "cloudpickle==3.1.1",
+      "contourpy==1.3.1",
+      "coverage==7.8.0",
+      "cycler==0.12.1",
+      "dask==2025.3.0",
+      "decorator==5.2.1",
+      "distlib==0.3.9",
+      "exceptiongroup==1.2.2",
+      "executing==2.2.0",
+      "extension-helpers==1.2.0",
+      "filelock==3.18.0",
+      "fonttools==4.56.0",
+      "frozenlist==1.5.0",
+      "fsspec==2025.3.1",
+      "h5py==3.13.0",
+      "html5lib==1.1",
+      "hypothesis==6.130.5",
+      "identify==2.6.9",
+      "idna==3.10",
+      "importlib_metadata==8.6.1",
+      "iniconfig==2.1.0",
+      "ipython==8.34.0",
+      "jedi==0.19.2",
+      "jmespath==1.0.1",
+      "jplephem==2.22",
+      "kiwisolver==1.4.8",
+      "locket==1.0.0",
+      "matplotlib-inline==0.1.7",
+      "matplotlib==3.10.1",
+      "mpmath==1.3.0",
+      "multidict==6.2.0",
+      "nodeenv==1.9.1",
+      "numpy==2.2.4",
+      "packaging==24.2",
+      "pandas==2.2.3",
+      "parso==0.8.4",
+      "partd==1.4.2",
+      "pexpect==4.9.0",
+      "pillow==11.1.0",
+      "platformdirs==4.3.7",
+      "pluggy==1.5.0",
+      "pre_commit==4.2.0",
+      "prompt_toolkit==3.0.50",
+      "propcache==0.3.1",
+      "ptyprocess==0.7.0",
+      "pure_eval==0.2.3",
+      "pyarrow==19.0.1",
+      "pyerfa==2.0.1.5",
+      "pyparsing==3.2.3",
+      "pytest-arraydiff==0.6.1",
+      "pytest-astropy-header==0.2.2",
+      "pytest-astropy==0.11.0",
+      "pytest-cov==6.0.0",
+      "pytest-doctestplus==1.4.0",
+      "pytest-filter-subpackage==0.2.0",
+      "pytest-mock==3.14.0",
+      "pytest-remotedata==0.4.1",
+      "pytest==8.3.5",
+      "python-dateutil==2.9.0.post0",
+      "pytz==2025.2",
+      "s3fs==2025.3.1",
+      "scipy==1.15.2",
+      "semantic-version==2.10.0",
+      "setuptools-scm==8.2.0",
+      "six==1.17.0",
+      "sortedcontainers==2.4.0",
+      "soupsieve==2.6",
+      "stack-data==0.6.3",
+      "tomli==2.2.1",
+      "toolz==1.0.0",
+      "traitlets==5.14.3",
+      "typing_extensions==4.13.0",
+      "tzdata==2025.2",
+      "urllib3==2.3.0",
+      "virtualenv==20.29.3",
+      "wcwidth==0.2.13",
+      "webencodings==0.5.1",
+      "wrapt==1.17.2",
+      "yarl==1.18.3",
+      "zipp==3.21.0"
+    ],
+    "3.6.13": [
+      "APScheduler==3.10.4",
+      "Babel==2.11.0",
+      "Flask==1.1.4",
+      "GitPython==3.1.18",
+      "HeapDict==1.0.1",
+      "Jinja2==2.10.3",
+      "Jinja2==3.0.3",
+      "Mako==1.1.6",
+      "MarkupSafe==2.0.1",
+      "Pillow==8.4.0",
+      "PyJWT==2.4.0",
+      "PyVISA==1.11.3",
+      "PyYAML==6.0.1",
+      "Pygments==2.14.0",
+      "SQLAlchemy==1.4.54",
+      "Send2Trash==1.8.3",
+      "Sphinx==4.3.2",
+      "Sphinx==5.3.0",
+      "Werkzeug==1.0.1",
+      "aiohttp==3.8.6",
+      "aiosignal==1.2.0",
+      "alabaster==0.7.13",
+      "alembic==1.7.7",
+      "anyio==3.6.2",
+      "anytree==2.8.0",
+      "argon2-cffi-bindings==21.2.0",
+      "argon2-cffi==21.3.0",
+      "astroid==1.4.9",
+      "astropy==4.1",
+      "async-generator==1.10",
+      "async-timeout==4.0.2",
+      "asynctest==0.13.0",
+      "attrs==22.2.0",
+      "backcall==0.2.0",
+      "backports.zoneinfo==0.2.1",
+      "black==22.8.0",
+      "bleach==4.1.0",
+      "bokeh==2.3.3",
+      "boto3==1.23.10",
+      "botocore==1.26.10",
+      "cached-property==1.5.2",
+      "cachetools==4.2.4",
+      "cffi==1.15.1",
+      "charset-normalizer==2.0.12",
+      "click==7.1.2",
+      "click==8.0.4",
+      "cloudpickle==2.2.1",
+      "codecov==2.1.13",
+      "comm==0.1.4",
+      "configparser==5.2.0",
+      "contextvars==2.4",
+      "cov-core==1.15.0",
+      "coverage==6.2",
+      "cryptography==40.0.2",
+      "cycler==0.11.0",
+      "daft==0.1.2",
+      "dask==2021.3.0",
+      "databricks-cli==0.17.8",
+      "dataclasses==0.8",
+      "decorator==4.4.2",
+      "decorator==5.1.1",
+      "defusedxml==0.7.1",
+      "distlib==0.3.9",
+      "distro==1.9.0",
+      "docker==5.0.3",
+      "docutils==0.17.1",
+      "docutils==0.18.1",
+      "entrypoints==0.4",
+      "execnet==1.9.0",
+      "filelock==3.4.1",
+      "flake8==5.0.4",
+      "fparser==0.0.11",
+      "frozenlist==1.2.0",
+      "gitdb==4.0.9",
+      "google-api-core==2.8.2",
+      "google-api-python-client==2.52.0",
+      "google-auth-httplib2==0.2.0",
+      "google-auth==2.22.0",
+      "googleapis-common-protos==1.56.3",
+      "graphviz==0.19.1",
+      "greenlet==2.0.2",
+      "gunicorn==21.2.0",
+      "gym-notices==0.0.8",
+      "gym==0.26.2",
+      "hestia==0.6.0",
+      "httplib2==0.22.0",
+      "idna-ssl==1.1.0",
+      "idna==3.10",
+      "imagesize==1.4.1",
+      "immutables==0.19",
+      "importlib-metadata==4.2.0",
+      "importlib-metadata==4.8.3",
+      "importlib-resources==5.4.0",
+      "iniconfig==1.1.1",
+      "ipykernel==5.5.6",
+      "ipython-genutils==0.2.0",
+      "ipython==7.16.3",
+      "ipywidgets==7.8.5",
+      "isort==5.10.1",
+      "itsdangerous==1.1.0",
+      "jedi==0.17.2",
+      "jmespath==0.10.0",
+      "joblib==1.1.1",
+      "json5==0.9.16",
+      "jsonpatch==1.32",
+      "jsonpointer==2.3",
+      "jsonschema==3.2.0",
+      "jupyter-client==7.1.2",
+      "jupyter-console==6.4.3",
+      "jupyter-core==4.9.2",
+      "jupyter-server-proxy==3.2.4",
+      "jupyter-server==1.13.1",
+      "jupyter-sphinx==0.4.0",
+      "jupyter==1.1.1",
+      "jupyterlab-pygments==0.1.2",
+      "jupyterlab-server==2.10.3",
+      "jupyterlab==3.2.9",
+      "jupyterlab_widgets==1.1.11",
+      "kiwisolver==1.3.1",
+      "latexcodec==2.0.1",
+      "lazy-object-proxy==1.7.1",
+      "llvmlite==0.36.0",
+      "lmdb==1.6.2",
+      "lockfile==0.12.2",
+      "looseversion==1.3.0",
+      "luigi==3.6.0",
+      "marshmallow==3.0.0rc5",
+      "matplotlib==3.3.4",
+      "mccabe==0.7.0",
+      "mistune==0.8.4",
+      "mlflow==1.23.1",
+      "mock==5.2.0",
+      "mpmath==1.3.0",
+      "msgpack-python==0.5.6",
+      "msgpack==1.0.5",
+      "multidict==5.2.0",
+      "mypy-extensions==1.0.0",
+      "nbclassic==0.3.5",
+      "nbclient==0.5.9",
+      "nbconvert==6.0.7",
+      "nbformat==5.1.3",
+      "nbsphinx==0.8.8",
+      "nbval==0.10.0",
+      "nest-asyncio==1.6.0",
+      "networkx==2.5.1",
+      "nose-cov==1.6",
+      "nose==1.3.7",
+      "notebook==6.4.10",
+      "numba==0.53.1",
+      "numpy==1.19.5",
+      "oauthlib==3.2.2",
+      "packaging==21.3",
+      "pandas==1.1.5",
+      "pandocfilters==1.5.1",
+      "parso==0.7.1",
+      "pathspec==0.9.0",
+      "patsy==1.0.1",
+      "pep257==0.7.0",
+      "pep8==1.7.1",
+      "pexpect==4.9.0",
+      "pickleshare==0.7.5",
+      "platformdirs==2.4.0",
+      "plotly==3.10.0",
+      "pluggy==1.0.0",
+      "polyaxon-client==0.6.1",
+      "polyaxon-schemas==0.6.1",
+      "polystores==0.2.5",
+      "prometheus-client==0.17.1",
+      "prometheus_flask_exporter==0.23.2",
+      "prompt-toolkit==3.0.36",
+      "protobuf==3.19.6",
+      "protobuf==4.21.0",
+      "psutil==7.0.0",
+      "ptyprocess==0.7.0",
+      "py==1.11.0",
+      "pyOpenSSL==23.2.0",
+      "pyarrow==6.0.1",
+      "pyasn1-modules==0.3.0",
+      "pyasn1==0.5.1",
+      "pybtex-docutils==1.0.2",
+      "pybtex==0.24.0",
+      "pycodestyle==2.10.0",
+      "pycodestyle==2.9.1",
+      "pycparser==2.21",
+      "pycryptodomex==3.21.0",
+      "pyenchant==3.2.2",
+      "pyflakes==2.5.0",
+      "pyflakes==3.0.1",
+      "pylint==1.6.5",
+      "pyparsing==3.1.4",
+      "pyrsistent==0.18.0",
+      "pytest-asyncio==0.16.0",
+      "pytest-cache==1.0",
+      "pytest-cov==2.5.1",
+      "pytest-cov==4.0.0",
+      "pytest-flakes==4.0.5",
+      "pytest-mock==3.6.1",
+      "pytest-pep257==0.0.5",
+      "pytest-pep8==1.0.6",
+      "pytest-pylint==0.14.1",
+      "pytest-xdist==3.0.2",
+      "pytest==7.0.1",
+      "python-daemon==2.3.2",
+      "python-dateutil==2.9.0.post0",
+      "pytz-deprecation-shim==0.1.0.post0",
+      "pytz==2025.2",
+      "pyzmq==25.0.2",
+      "pyzmq==25.1.2",
+      "querystring-parser==1.2.4",
+      "redis==4.3.6",
+      "requests-toolbelt==1.0.0",
+      "requests==2.27.1",
+      "retrying==1.3.4",
+      "rhea==0.5.5",
+      "rsa==4.9",
+      "s3transfer==0.5.2",
+      "salt==3006.6",
+      "scikit-learn==0.24.2",
+      "scipy==1.5.4",
+      "simpervisor==0.4",
+      "six==1.17.0",
+      "slackclient==2.9.4",
+      "smmap==5.0.0",
+      "sniffio==1.2.0",
+      "snowballstemmer==2.2.0",
+      "sortedcontainers==2.4.0",
+      "sphinx-rtd-theme==2.0.0",
+      "sphinxcontrib-applehelp==1.0.2",
+      "sphinxcontrib-bibtex==2.5.0",
+      "sphinxcontrib-devhelp==1.0.2",
+      "sphinxcontrib-htmlhelp==2.0.0",
+      "sphinxcontrib-jquery==4.1",
+      "sphinxcontrib-jsmath==1.0.1",
+      "sphinxcontrib-qthelp==1.0.3",
+      "sphinxcontrib-serializinghtml==1.1.5",
+      "sphinxcontrib-spelling==7.7.0",
+      "sqlparse==0.4.4",
+      "statsmodels==0.12.2",
+      "sympy==1.9",
+      "tabor-control==0.1.1",
+      "tabulate==0.8.10",
+      "tblib==1.7.0",
+      "tek-awg==0.2.1",
+      "tenacity==8.2.2",
+      "tensorboardX==2.6.2.2",
+      "termcolor==1.1.0",
+      "terminado==0.12.1",
+      "testpath==0.6.0",
+      "threadpoolctl==3.1.0",
+      "toml==0.10.2",
+      "tomli==1.2.3",
+      "toolz==0.12.0",
+      "torch==1.10.2",
+      "tornado==6.1",
+      "tox==3.28.0",
+      "tqdm==4.64.1",
+      "traitlets==4.3.3",
+      "typed-ast==1.5.5",
+      "typing_extensions==4.1.1",
+      "tzdata==2025.2",
+      "tzlocal==4.2",
+      "uritemplate==4.1.1",
+      "urllib3==1.26.20",
+      "virtualenv==20.17.1",
+      "visdom==0.2.4",
+      "wcwidth==0.2.13",
+      "webencodings==0.5.1",
+      "websocket-client==1.3.1",
+      "widgetsnbextension==3.6.10",
+      "wrapt==1.16.0",
+      "xdoctest==1.1.6",
+      "xxhash==3.2.0",
+      "yarl==1.7.2",
+      "zhinst==22.2.29711",
+      "zict==2.1.0",
+      "zipp==3.6.0"
+    ],
+    "3.8.12": [
+      "PyQt5==5.15.4",
+      "PyYAML==6.0.2",
+      "awkward==2.6.10",
+      "awkward_cpp==40",
+      "cffi==1.17.1",
+      "donfig==0.8.1.post1",
+      "exceptiongroup==1.2.2",
+      "fsspec==2025.3.1",
+      "importlib_metadata==8.5.0",
+      "iniconfig==2.1.0",
+      "llvmlite==0.41.1",
+      "numba==0.58.1",
+      "pluggy==1.5.0",
+      "pycparser==2.22",
+      "pytest==8.3.5",
+      "suitesparse-graphblas==7.3.3.0",
+      "tomli==2.2.1",
+      "typing_extensions==4.13.0"
+    ],
+    "3.8.20": [
+      "GitPython==3.1.44",
+      "Jinja2==3.1.6",
+      "MarkupSafe==2.1.5",
+      "PyDrive2==1.21.3",
+      "PyJWT==2.9.0",
+      "PyNaCl==1.5.0",
+      "PyWavelets==1.4.1",
+      "PyYAML==5.4.1",
+      "PyYAML==6.0.2",
+      "Pygments==2.9.0",
+      "WsgiDAV==3.1.0",
+      "adal==1.2.7",
+      "adlfs==0.7.1",
+      "aiobotocore==1.3.0",
+      "aiohappyeyeballs==2.4.4",
+      "aiohttp==3.10.11",
+      "aioitertools==0.12.0",
+      "aiosignal==1.3.1",
+      "aliyun-python-sdk-core-v3==2.13.33",
+      "aliyun-python-sdk-core==2.16.0",
+      "aliyun-python-sdk-kms==2.16.5",
+      "anyio==4.5.2",
+      "appdirs==1.4.4",
+      "argcomplete==3.6.1",
+      "astroid==2.5.6",
+      "async-timeout==5.0.1",
+      "atpublic==5.0",
+      "attrs==21.4.0",
+      "attrs==25.3.0",
+      "autocommand==2.2.2",
+      "azure-core==1.32.0",
+      "azure-datalake-store==0.0.53",
+      "azure-identity==1.21.0",
+      "azure-storage-blob==12.6.0",
+      "backports.tarfile==1.2.0",
+      "bcrypt==4.3.0",
+      "beautifulsoup4==4.9.3",
+      "boto3==1.17.49",
+      "boto==2.49.0",
+      "botocore==1.20.49",
+      "cachetools==4.2.4",
+      "certifi==2025.1.31",
+      "cffi==1.17.1",
+      "charset-normalizer==3.4.1",
+      "chemicals==1.3.3",
+      "click==8.1.8",
+      "collective.checkdocs==0.2",
+      "colorama==0.4.6",
+      "configobj==5.0.9",
+      "contourpy==1.1.1",
+      "coverage==7.6.1",
+      "crc32c==2.2.post0",
+      "crcmod==1.7",
+      "cryptography==43.0.3",
+      "cycler==0.12.1",
+      "decorator==5.2.1",
+      "defusedxml==0.7.1",
+      "dictdiffer==0.9.0",
+      "diskcache==5.6.3",
+      "distro==1.9.0",
+      "docker-compose==1.29.2",
+      "docker==7.1.0",
+      "dockerpty==0.4.1",
+      "docopt==0.6.2",
+      "docrep==0.3.2",
+      "docutils==0.20.1",
+      "dpath==2.2.0",
+      "dulwich==0.22.4",
+      "exceptiongroup==1.2.2",
+      "execnet==2.1.1",
+      "filelock==3.0.12",
+      "flaky==3.7.0",
+      "flatdict==4.0.1",
+      "flatten-dict==0.4.2",
+      "flufl.lock==3.2",
+      "fluids==1.1.0",
+      "fonttools==4.56.0",
+      "freetype-py==2.5.1",
+      "frozenlist==1.5.0",
+      "fsspec==2021.6.1",
+      "funcy==2.0",
+      "future==1.0.0",
+      "gcsfs==2021.6.1",
+      "gitdb==4.0.12",
+      "google-api-core==2.10.2",
+      "google-api-python-client==2.166.0",
+      "google-auth-httplib2==0.2.0",
+      "google-auth-oauthlib==0.5.3",
+      "google-auth==1.35.0",
+      "google-cloud-core==1.7.3",
+      "google-cloud-storage==1.40.0",
+      "google-compute-engine==2.8.13",
+      "google-crc32c==1.5.0",
+      "google-resumable-media==1.3.3",
+      "googleapis-common-protos==1.69.2",
+      "grandalf==0.6",
+      "h11==0.14.0",
+      "h5py==3.11.0",
+      "hdfs==2.5.8",
+      "hsluv==5.0.4",
+      "httpcore==1.0.7",
+      "httplib2==0.22.0",
+      "httpx==0.28.1",
+      "idna==3.10",
+      "imageio==2.35.1",
+      "importlib_metadata==8.5.0",
+      "importlib_resources==6.4.5",
+      "iniconfig==2.1.0",
+      "intel-cmplr-lib-ur==2025.1.0",
+      "intel-openmp==2025.1.0",
+      "invoke==2.2.0",
+      "isodate==0.7.2",
+      "isort==5.13.2",
+      "jaraco.classes==3.4.0",
+      "jaraco.collections==5.1.0",
+      "jaraco.context==6.0.1",
+      "jaraco.functools==4.1.0",
+      "jaraco.structures==2.2.0",
+      "jaraco.text==4.0.0",
+      "jaraco.ui==2.4.0",
+      "jaraco.windows==5.5.0",
+      "jmespath==0.10.0",
+      "joblib==1.4.2",
+      "json-tricks==3.17.3",
+      "json5==0.10.0",
+      "jsonpath-ng==1.7.0",
+      "jsonschema-specifications==2023.12.1",
+      "jsonschema==3.2.0",
+      "jsonschema==4.23.0",
+      "kiwisolver==1.4.7",
+      "knack==0.12.0",
+      "lazy-object-proxy==1.10.0",
+      "lazy_loader==0.4",
+      "llvmlite==0.41.1",
+      "markdown-it-py==2.2.0",
+      "matplotlib==3.7.5",
+      "mccabe==0.6.1",
+      "mdurl==0.1.2",
+      "mkl==2025.1.0",
+      "mock-ssh-server==0.9.0",
+      "mock==4.0.3",
+      "more-itertools==10.5.0",
+      "mpmath==1.3.0",
+      "msal-extensions==1.3.0",
+      "msal==1.32.0",
+      "msrest==0.7.1",
+      "msrestazure==0.6.4.post1",
+      "multidict==6.1.0",
+      "mypy==0.910",
+      "mypy_extensions==0.4.4",
+      "named==1.4.2",
+      "nanotime==0.5.2",
+      "networkx==2.8.8",
+      "networkx==3.1",
+      "numba==0.58.1",
+      "numpy==1.24.4",
+      "oauth2client==4.1.3",
+      "oauthlib==3.2.2",
+      "opencv-python-headless==4.11.0.86",
+      "oss2==2.6.1",
+      "packaging==24.2",
+      "pandas==2.0.3",
+      "paramiko==3.5.1",
+      "path==17.0.0",
+      "pathspec==0.12.1",
+      "pillow==10.4.0",
+      "pkgutil_resolve_name==1.3.10",
+      "pluggy==0.13.1",
+      "pluggy==1.5.0",
+      "ply==3.11",
+      "propcache==0.2.0",
+      "protobuf==4.25.6",
+      "psutil==7.0.0",
+      "py==1.11.0",
+      "pyOpenSSL==24.2.1",
+      "pyarrow==17.0.0",
+      "pyasn1==0.6.1",
+      "pyasn1_modules==0.4.2",
+      "pycparser==2.22",
+      "pycryptodome==3.22.0",
+      "pydocstyle==6.1.1",
+      "pydot==1.4.2",
+      "pygit2==1.13.3",
+      "pygtrie==2.5.0",
+      "pylint-plugin-utils==0.6",
+      "pylint-pytest==1.0.3",
+      "pylint==2.8.3",
+      "pypardiso==0.4.6",
+      "pyparsing==2.4.7",
+      "pyparsing==3.1.4",
+      "pyrsistent==0.20.0",
+      "pytest-cov==2.12.1",
+      "pytest-docker==0.10.3",
+      "pytest-forked==1.6.0",
+      "pytest-lazy-fixture==0.6.3",
+      "pytest-mock==3.6.1",
+      "pytest-timeout==1.4.2",
+      "pytest-xdist==2.3.0",
+      "pytest==6.2.4",
+      "pytest==8.3.5",
+      "python-benedict==0.34.1",
+      "python-dateutil==2.9.0.post0",
+      "python-dotenv==0.21.1",
+      "python-fsutil==0.15.0",
+      "python-slugify==8.0.4",
+      "pytz==2025.2",
+      "qudida==0.0.4",
+      "rangehttpserver==1.2.0",
+      "referencing==0.35.1",
+      "requests-oauthlib==2.0.0",
+      "requests==2.32.3",
+      "rich==13.2.0",
+      "rpds-py==0.20.1",
+      "rsa==4.9",
+      "ruamel.yaml.clib==0.2.8",
+      "ruamel.yaml==0.18.10",
+      "s3fs==2021.6.1",
+      "s3transfer==0.3.7",
+      "scikit-image==0.18.3",
+      "scikit-image==0.21.0",
+      "scikit-learn==1.3.2",
+      "scipy==1.10.1",
+      "shellingham==1.5.4",
+      "shortuuid==1.0.13",
+      "shtab==1.7.1",
+      "six==1.17.0",
+      "smmap==5.0.2",
+      "sniffio==1.3.1",
+      "snowballstemmer==2.2.0",
+      "soupsieve==2.6",
+      "sympy==1.13.3",
+      "tabulate==0.9.0",
+      "tbb==2022.1.0",
+      "tcmlib==1.3.0",
+      "terminaltables==3.1.10",
+      "text-unidecode==1.3",
+      "texttable==1.7.0",
+      "thermo==0.4.2",
+      "threadpoolctl==3.5.0",
+      "tifffile==2023.7.10",
+      "toml==0.10.2",
+      "tomli==2.2.1",
+      "tqdm==4.67.1",
+      "traits==7.0.2",
+      "transforms3d==0.4.2",
+      "typer==0.15.2",
+      "types-paramiko==3.5.0.20240928",
+      "types-requests==2.31.0.6",
+      "types-tabulate==0.9.0.20241207",
+      "types-toml==0.10.8.20240310",
+      "types-urllib3==1.26.25.14",
+      "typing_extensions==4.13.0",
+      "tzdata==2025.2",
+      "umf==0.10.0",
+      "uritemplate==4.1.1",
+      "urllib3==1.26.6",
+      "vispy==0.14.2",
+      "voluptuous==0.14.2",
+      "webdav4==0.10.0",
+      "websocket-client==0.59.0",
+      "wget==3.2",
+      "wrapt==1.12.1",
+      "xmltodict==0.12.0",
+      "yarl==1.15.2",
+      "zc.lockfile==3.0.post1",
+      "zipp==3.20.2"
+    ],
+    "3.9.21": [
+      "Brotli==1.1.0",
+      "Cartopy==0.23.0",
+      "Cython==3.0.12",
+      "Deprecated==1.2.18",
+      "Flask-Compress==1.17",
+      "Flask==3.1.0",
+      "Jinja2==3.1.6",
+      "Markdown==3.7",
+      "MarkupSafe==3.0.2",
+      "Pint==0.24.4",
+      "PyJWT==2.10.1",
+      "PyPDF2==3.0.1",
+      "PySocks==1.7.1",
+      "PyYAML==6.0.2",
+      "Pygments==2.19.1",
+      "Pympler==1.1",
+      "Send2Trash==1.8.3",
+      "Sphinx==7.3.7",
+      "Sphinx==7.4.7",
+      "Unidecode==1.3.8",
+      "Werkzeug==3.1.3",
+      "absl-py==2.2.1",
+      "alabaster==0.7.16",
+      "annotated-types==0.7.0",
+      "antimeridian==0.3.8",
+      "anyio==4.9.0",
+      "anytree==2.12.1",
+      "appdirs==1.4.4",
+      "argcomplete==3.6.1",
+      "argon2-cffi-bindings==21.2.0",
+      "argon2-cffi==23.1.0",
+      "arrow==1.3.0",
+      "arviz==0.17.1",
+      "asttokens==3.0.0",
+      "asv==0.6.3",
+      "asv_runner==0.2.1",
+      "async-lru==2.0.5",
+      "attrs==25.3.0",
+      "audb==1.11.3",
+      "audbackend==2.2.2",
+      "audeer==2.2.1",
+      "audformat==1.3.1",
+      "audinterface==1.2.3",
+      "audiofile==1.5.1",
+      "audmath==1.4.1",
+      "audobject==0.7.11",
+      "audresample==1.3.3",
+      "autoflake==2.3.1",
+      "autograd==1.7.0",
+      "autoray==0.7.1",
+      "babel==2.17.0",
+      "beautifulsoup4==4.13.3",
+      "bibtexparser==2.0.0b8",
+      "black==20.8b1",
+      "black==25.1.0",
+      "bleach==6.2.0",
+      "blinker==1.9.0",
+      "bokeh==3.4.3",
+      "bs4==0.0.2",
+      "build==1.2.2.post1",
+      "casadi==3.7.0",
+      "certifi==2025.1.31",
+      "cffi==1.17.1",
+      "cfgv==3.4.0",
+      "cftime==1.6.4.post1",
+      "chardet==3.0.4",
+      "chardet==5.2.0",
+      "charset-normalizer==3.4.1",
+      "chex==0.1.89",
+      "click==8.1.8",
+      "clldutils==3.24.2",
+      "cloudpickle==3.1.1",
+      "colorama==0.4.6",
+      "colorcet==3.1.0",
+      "colorlog==6.9.0",
+      "colorspacious==1.1.2",
+      "comm==0.2.2",
+      "contourpy==1.2.1",
+      "contourpy==1.3.0",
+      "cotengra==0.7.1",
+      "coverage==7.8.0",
+      "cryptography==44.0.2",
+      "cssselect2==0.8.0",
+      "cssselect==1.3.0",
+      "csvw==3.5.1",
+      "cycler==0.12.1",
+      "cytoolz==1.0.1",
+      "dash_core_components==1.0.0",
+      "dash_html_components==1.0.0",
+      "dash_renderer==1.0.0",
+      "dash_table==4.0.0",
+      "dask-expr==1.1.10",
+      "dask==2024.8.0",
+      "datashader==0.17.0",
+      "debugpy==1.8.13",
+      "decorator==5.2.1",
+      "defusedxml==0.7.1",
+      "dill==0.3.9",
+      "distlib==0.3.9",
+      "dm-haiku==0.0.13",
+      "dm-tree==0.1.8",
+      "docutils==0.21.2",
+      "dohq-artifactory==1.0.0",
+      "duckdb==1.2.1",
+      "etils==1.5.2",
+      "eval_type_backport==0.2.2",
+      "exceptiongroup==1.2.2",
+      "execnet==2.1.1",
+      "executing==2.2.0",
+      "fake-useragent==2.1.0",
+      "fastjsonschema==2.21.1",
+      "filelock==3.18.0",
+      "flake8-docstrings==1.7.0",
+      "flake8==3.8.4",
+      "flake8==7.2.0",
+      "flax==0.8.5",
+      "flexcache==0.3",
+      "flexparser==0.4",
+      "fonttools==4.56.0",
+      "fqdn==1.5.1",
+      "fsspec==2025.3.1",
+      "funsor==0.4.5",
+      "galois==0.4.4",
+      "gast==0.6.0",
+      "geoviews==1.12.0",
+      "graphviz==0.20.3",
+      "green==4.0.2",
+      "guzzle_sphinx_theme==0.7.11",
+      "h11==0.14.0",
+      "h5netcdf==1.6.1",
+      "h5py==3.13.0",
+      "holoviews==1.20.2",
+      "html2text==2024.2.26",
+      "httpcore==1.0.7",
+      "httpx==0.28.1",
+      "humanize==4.12.2",
+      "identify==2.6.9",
+      "idna==2.10",
+      "idna==3.10",
+      "imageio==2.37.0",
+      "imagesize==1.4.1",
+      "importlib-metadata==4.13.0",
+      "importlib_metadata==8.6.1",
+      "importlib_resources==6.5.2",
+      "iniconfig==2.1.0",
+      "ipykernel==6.29.5",
+      "ipython-genutils==0.2.0",
+      "ipython==8.18.1",
+      "ipywidgets==7.8.5",
+      "ipywidgets==8.1.5",
+      "iso3166==2.1.1",
+      "iso639-lang==2.6.0",
+      "iso639==0.1.4",
+      "isodate==0.7.2",
+      "isoduration==20.11.0",
+      "isort==6.0.1",
+      "itsdangerous==2.2.0",
+      "jax==0.4.30",
+      "jaxlib==0.4.30",
+      "jaxns==2.4.8",
+      "jaxopt==0.8.3",
+      "jedi==0.19.2",
+      "jmp==0.0.4",
+      "joblib==1.4.2",
+      "json5==0.10.0",
+      "jsonpointer==3.0.0",
+      "jsonschema-specifications==2024.10.1",
+      "jsonschema==4.23.0",
+      "julia==0.6.2",
+      "jupyter-console==6.6.3",
+      "jupyter-events==0.12.0",
+      "jupyter-lsp==2.2.5",
+      "jupyter==1.1.1",
+      "jupyter_client==8.6.3",
+      "jupyter_core==5.7.2",
+      "jupyter_server==2.15.0",
+      "jupyter_server_terminals==0.5.3",
+      "jupyterlab==4.3.6",
+      "jupyterlab_pygments==0.3.0",
+      "jupyterlab_server==2.27.3",
+      "jupyterlab_widgets==1.1.11",
+      "jupyterlab_widgets==3.0.13",
+      "kiwisolver==1.4.7",
+      "language-tags==1.2.0",
+      "lark==1.1.9",
+      "latexcodec==3.0.0",
+      "lazy_loader==0.4",
+      "linkify-it-py==2.0.3",
+      "llvmlite==0.43.0",
+      "locket==1.0.0",
+      "lxml==5.3.1",
+      "makefun==1.15.6",
+      "markdown-it-py==3.0.0",
+      "matplotlib-inline==0.1.7",
+      "matplotlib==3.8.4",
+      "matplotlib==3.9.4",
+      "mccabe==0.6.1",
+      "mccabe==0.7.0",
+      "mdit-py-plugins==0.4.2",
+      "mdurl==0.1.2",
+      "mikecore==0.2.2",
+      "minio==7.2.15",
+      "mistune==3.1.3",
+      "ml_dtypes==0.5.1",
+      "mne==1.8.0",
+      "mpmath==1.3.0",
+      "msgpack==1.1.0",
+      "multipledispatch==1.0.0",
+      "mypy-extensions==1.0.0",
+      "mypy==0.790",
+      "mypy==1.15.0",
+      "mypy_extensions==0.4.4",
+      "narwhals==1.32.0",
+      "nbclient==0.10.2",
+      "nbconvert==7.16.6",
+      "nbformat==5.10.4",
+      "nbsphinx==0.9.7",
+      "nest-asyncio==1.6.0",
+      "netCDF4==1.7.2",
+      "networkx==3.2.1",
+      "nodeenv==1.9.1",
+      "notebook==7.3.3",
+      "notebook_shim==0.2.4",
+      "nox==2024.10.9",
+      "numba==0.60.0",
+      "numpy==1.22.0",
+      "numpy==1.26.4",
+      "numpy==2.0.2",
+      "numpydoc==1.8.0",
+      "opt_einsum==3.4.0",
+      "optax==0.2.4",
+      "orbax-checkpoint==0.6.4",
+      "outcome==1.3.0.post0",
+      "overrides==7.7.0",
+      "oyaml==1.0",
+      "packaging==24.2",
+      "pandas==2.0.3",
+      "pandas==2.2.3",
+      "pandocfilters==1.5.1",
+      "panel==1.4.5",
+      "param==2.2.0",
+      "parameterized==0.9.0",
+      "parse==1.20.2",
+      "parso==0.8.4",
+      "partd==1.4.2",
+      "pathlib==1.0.1",
+      "pathspec==0.12.1",
+      "pbr==6.1.1",
+      "pdfminer.six==20250327",
+      "pdfplumber==0.11.6",
+      "pdoc==15.0.1",
+      "percy==2.0.2",
+      "pexpect==4.9.0",
+      "pikepdf==9.5.2",
+      "pillow==11.1.0",
+      "platformdirs==4.3.7",
+      "plotly==6.0.1",
+      "pluggy==0.13.1",
+      "pluggy==1.5.0",
+      "pooch==1.8.2",
+      "pre_commit==4.2.0",
+      "prometheus_client==0.21.1",
+      "prompt_toolkit==3.0.50",
+      "protobuf==6.30.2",
+      "psutil==7.0.0",
+      "ptyprocess==0.7.0",
+      "pure_eval==0.2.3",
+      "py4j==0.10.9.7",
+      "py==1.11.0",
+      "pyarrow==19.0.1",
+      "pybtex==0.24.0",
+      "pycodestyle==2.13.0",
+      "pycodestyle==2.6.0",
+      "pycparser==2.22",
+      "pycryptodome==3.22.0",
+      "pyct==0.5.0",
+      "pydantic==2.11.1",
+      "pydantic_core==2.33.0",
+      "pydocstyle==3.0.0",
+      "pydyf==0.11.0",
+      "pyee==11.1.1",
+      "pyflakes==2.2.0",
+      "pyflakes==3.3.1",
+      "pylab-sdk==1.7.2",
+      "pylatexenc==2.10",
+      "pyparsing==3.2.3",
+      "pypdfium2==4.30.1",
+      "pyperclip==1.9.0",
+      "pyphen==0.17.2",
+      "pyppeteer==2.0.0",
+      "pyproj==3.6.1",
+      "pyproject_hooks==1.2.0",
+      "pyquery==2.0.1",
+      "pyright==1.1.398",
+      "pyro-api==0.1.2",
+      "pyshp==2.3.1",
+      "pyspark==3.5.5",
+      "pytest-asyncio==0.26.0",
+      "pytest-cov==6.0.0",
+      "pytest-doctestplus==1.4.0",
+      "pytest-mock==3.14.0",
+      "pytest-mpl==0.17.0",
+      "pytest-rerunfailures==15.0",
+      "pytest-sugar==1.0.0",
+      "pytest-timeout==2.3.1",
+      "pytest-xdist==3.6.1",
+      "pytest==6.1.1",
+      "pytest==8.3.5",
+      "python-dateutil==2.9.0.post0",
+      "python-json-logger==3.3.0",
+      "pytz==2025.2",
+      "pyviz_comms==3.0.4",
+      "pyzmq==26.3.0",
+      "pyzx==0.8.0",
+      "qiskit-aer==0.17.0",
+      "qiskit==1.4.2",
+      "quimb==1.10.0",
+      "rdflib==7.1.4",
+      "readability-lxml==0.8.1",
+      "readthedocs-sphinx-search==0.3.2",
+      "referencing==0.36.2",
+      "regex==2024.11.6",
+      "requests-html==0.10.0",
+      "requests==2.24.0",
+      "requests==2.32.3",
+      "retrying==1.3.4",
+      "rfc3339-validator==0.1.4",
+      "rfc3986-validator==0.1.1",
+      "rfc3986==1.5.0",
+      "rich==14.0.0",
+      "rpds-py==0.24.0",
+      "rstcheck-core==1.2.1",
+      "rstcheck==6.2.4",
+      "ruff==0.11.2",
+      "rustworkx==0.16.0",
+      "scikit-fem==10.0.2",
+      "scikit-image==0.24.0",
+      "scikit-learn==1.6.1",
+      "scipy==1.11.4",
+      "scipy==1.13.1",
+      "seaborn==0.13.2",
+      "segments==2.2.0",
+      "selenium==4.30.0",
+      "setuptools-scm==8.2.0",
+      "shapely==2.0.7",
+      "shellingham==1.5.4",
+      "six==1.17.0",
+      "sniffio==1.3.1",
+      "snowballstemmer==2.2.0",
+      "sortedcontainers==2.4.0",
+      "soundfile==0.13.1",
+      "soupsieve==2.6",
+      "spatialpandas==0.4.10",
+      "sphinx-copybutton==0.5.2",
+      "sphinx-gallery==0.19.0",
+      "sphinx-rtd-theme==3.0.2",
+      "sphinxcontrib-applehelp==2.0.0",
+      "sphinxcontrib-devhelp==2.0.0",
+      "sphinxcontrib-htmlhelp==2.1.0",
+      "sphinxcontrib-jquery==4.1",
+      "sphinxcontrib-jsmath==1.0.1",
+      "sphinxcontrib-qthelp==2.0.0",
+      "sphinxcontrib-serializinghtml==2.0.0",
+      "sphinxcontrib-svg2pdfconverter==1.3.0",
+      "stack-data==0.6.3",
+      "stevedore==5.4.1",
+      "symengine==0.13.0",
+      "sympy==1.13.3",
+      "tabulate==0.9.0",
+      "tensorflow-probability==0.25.0",
+      "tensorstore==0.1.69",
+      "termcolor==2.5.0",
+      "terminado==0.18.1",
+      "threadpoolctl==3.6.0",
+      "tifffile==2024.8.30",
+      "tinycss2==1.4.0",
+      "tinyhtml5==2.0.0",
+      "titlecase==2.4.1",
+      "toml==0.10.2",
+      "tomli==2.2.1",
+      "toolz==1.0.0",
+      "tornado==6.4.2",
+      "tqdm==4.67.1",
+      "traitlets==5.14.3",
+      "trio-websocket==0.12.2",
+      "trio==0.29.0",
+      "typed-ast==1.4.3",
+      "typer==0.15.2",
+      "types-networkx==3.4.2.20250319",
+      "types-psutil==7.0.0.20250218",
+      "types-python-dateutil==2.9.0.20241206",
+      "typing-inspection==0.4.0",
+      "typing_extensions==4.13.0",
+      "tzdata==2025.2",
+      "uc-micro-py==1.0.3",
+      "unicodedataplus==13.0.0.post2",
+      "uri-template==1.3.0",
+      "uritemplate==4.1.1",
+      "urllib3==1.25.11",
+      "urllib3==2.3.0",
+      "virtualenv==20.29.3",
+      "virtualenv==20.30.0",
+      "w3lib==2.3.1",
+      "waitress==3.0.2",
+      "wcwidth==0.2.13",
+      "weasyprint==65.0",
+      "webcolors==24.11.1",
+      "webencodings==0.5.1",
+      "websocket-client==1.8.0",
+      "websockets==10.4",
+      "widgetsnbextension==3.6.10",
+      "widgetsnbextension==4.0.13",
+      "wordcloud==1.9.4",
+      "wrapt==1.17.2",
+      "wsproto==1.2.0",
+      "xarray-einstats==0.7.0",
+      "xarray==2024.7.0",
+      "xyzservices==2025.1.0",
+      "zipp==3.21.0",
+      "zopfli==0.2.3.post1",
+      "zstandard==0.23.0"
+    ],
+    "3.7.16": [
+      "Babel==2.14.0",
+      "HeapDict==1.0.1",
+      "Jinja2==3.1.6",
+      "MarkupSafe==2.1.5",
+      "Pillow==7.2.0",
+      "Pillow==9.5.0",
+      "PyJWT==1.7.1",
+      "PyMySQL==0.9.2",
+      "PyYAML==5.3.1",
+      "PyYAML==6.0.1",
+      "Pygments==2.17.2",
+      "SQLAlchemy==1.3.19",
+      "SQLAlchemy==2.0.40",
+      "SecretStorage==3.3.3",
+      "Send2Trash==1.8.3",
+      "Sphinx==5.3.0",
+      "aiobotocore==2.4.2",
+      "aiofiles==22.1.0",
+      "aiohttp==3.8.6",
+      "aioitertools==0.11.0",
+      "aiokafka==0.8.0",
+      "aiomysql==0.0.22",
+      "aioodbc==0.3.3",
+      "aiopg==0.16.0",
+      "aioresponses==0.6.0",
+      "aiosignal==1.3.1",
+      "aiosmtplib==1.1.7",
+      "aiosqlite==0.19.0",
+      "alabaster==0.7.13",
+      "anyio==3.7.1",
+      "appdirs==1.4.4",
+      "apptools==5.2.1",
+      "argon2-cffi-bindings==21.2.0",
+      "argon2-cffi==23.1.0",
+      "arrow==1.2.3",
+      "asab==19.11",
+      "astroid==2.15.8",
+      "async-timeout==4.0.3",
+      "asyncssh==2.0.1",
+      "asynctest==0.13.0",
+      "attrs==20.2.0",
+      "attrs==24.2.0",
+      "backcall==0.2.0",
+      "beautifulsoup4==4.13.3",
+      "black==23.3.0",
+      "bleach==6.0.0",
+      "bokeh==2.4.3",
+      "botocore==1.27.59",
+      "cached-property==1.5.2",
+      "cachetools==5.5.2",
+      "certifi==2020.6.20",
+      "cffi==1.15.1",
+      "cfgv==3.1.0",
+      "chardet==3.0.4",
+      "charset-normalizer==3.4.1",
+      "click==8.1.8",
+      "cloudpickle==2.2.1",
+      "colorama==0.4.6",
+      "comm==0.1.4",
+      "configobj==5.0.9",
+      "coverage==4.5.4",
+      "coverage==5.2.1",
+      "coverage==7.2.7",
+      "cryptography==44.0.2",
+      "cycler==0.10.0",
+      "cycler==0.11.0",
+      "dask-glm==0.3.2",
+      "dask-xgboost==0.2.0",
+      "dask==2.19.0",
+      "dask==2022.2.0",
+      "debugpy==1.7.0",
+      "decorator==5.1.1",
+      "defusedxml==0.7.1",
+      "dill==0.3.7",
+      "distlib==0.3.9",
+      "distributed==2.19.0",
+      "distributed==2022.2.0",
+      "docutils==0.19",
+      "dohq-artifactory==0.7.382",
+      "entrypoints==0.4",
+      "envisage==7.0.3",
+      "et-xmlfile==1.1.0",
+      "exceptiongroup==1.2.2",
+      "execnet==2.0.2",
+      "fastavro==0.24.2",
+      "fastjsonschema==2.21.1",
+      "feather-format==0.4.1",
+      "filelock==3.12.2",
+      "flake8==5.0.4",
+      "fonttools==4.38.0",
+      "fqdn==1.5.1",
+      "frozenlist==1.3.3",
+      "fsspec==2023.1.0",
+      "google-api-core==1.34.1",
+      "google-api-core==2.24.2",
+      "google-api-python-client==1.12.11",
+      "google-auth-httplib2==0.2.0",
+      "google-auth-oauthlib==1.2.1",
+      "google-auth==2.38.0",
+      "google-cloud-bigquery-storage==1.1.2",
+      "google-cloud-bigquery==1.27.2",
+      "google-cloud-core==1.5.0",
+      "google-crc32c==1.5.0",
+      "google-resumable-media==1.3.3",
+      "google==3.0.0",
+      "googleapis-common-protos==1.69.2",
+      "greenlet==3.1.1",
+      "grpcio-status==1.48.2",
+      "grpcio==1.62.3",
+      "h5py==3.8.0",
+      "httplib2==0.22.0",
+      "identify==1.4.25",
+      "idna==2.10",
+      "idna==3.10",
+      "imagesize==1.4.1",
+      "importlib-metadata==4.13.0",
+      "importlib-metadata==4.2.0",
+      "importlib-metadata==6.7.0",
+      "importlib-resources==5.12.0",
+      "iniconfig==1.0.0",
+      "iniconfig==2.0.0",
+      "ipykernel==6.16.2",
+      "ipython-genutils==0.2.0",
+      "ipython==7.34.0",
+      "ipywidgets==8.1.5",
+      "isoduration==20.11.0",
+      "isort==5.11.5",
+      "jaraco.classes==3.2.3",
+      "jedi==0.19.2",
+      "jeepney==0.9.0",
+      "jmespath==1.0.1",
+      "joblib==0.17.0",
+      "joblib==1.3.2",
+      "json5==0.9.16",
+      "jsonpointer==3.0.0",
+      "jsonschema==4.17.3",
+      "jupyter-console==6.6.3",
+      "jupyter-events==0.6.3",
+      "jupyter-server==1.24.0",
+      "jupyter-ydoc==0.2.5",
+      "jupyter==1.1.1",
+      "jupyter_client==7.4.9",
+      "jupyter_core==4.12.0",
+      "jupyter_server_fileid==0.9.3",
+      "jupyter_server_ydoc==0.8.0",
+      "jupyterlab-pygments==0.2.2",
+      "jupyterlab==3.6.8",
+      "jupyterlab_server==2.24.0",
+      "jupyterlab_widgets==3.0.13",
+      "kafka-python==2.1.4",
+      "keyring==24.1.1",
+      "kiwisolver==1.2.0",
+      "kiwisolver==1.4.5",
+      "lazy-object-proxy==1.9.0",
+      "llvmlite==0.39.1",
+      "locket==1.0.0",
+      "lxml==5.3.1",
+      "markdown-it-py==2.2.0",
+      "matplotlib-inline==0.1.6",
+      "matplotlib==3.2.2",
+      "matplotlib==3.3.2",
+      "matplotlib==3.5.3",
+      "mayavi==4.8.1",
+      "mccabe==0.7.0",
+      "mdurl==0.1.2",
+      "mistune==3.0.2",
+      "mongoquery==1.4.2",
+      "more-itertools==9.1.0",
+      "motor==2.5.1",
+      "msgpack==0.6.2",
+      "msgpack==1.0.5",
+      "multidict==6.0.5",
+      "multipledispatch==1.0.0",
+      "mypy-extensions==1.0.0",
+      "mypy==1.4.1",
+      "mysql-replication==0.25",
+      "nbclassic==1.2.0",
+      "nbclient==0.7.4",
+      "nbconvert==7.6.0",
+      "nbformat==5.8.0",
+      "nest-asyncio==1.6.0",
+      "nibabel==4.0.2",
+      "nodeenv==1.4.0",
+      "nose-timer==1.0.1",
+      "nose==1.3.7",
+      "notebook==6.5.7",
+      "notebook_shim==0.2.4",
+      "numba==0.56.4",
+      "numexpr==2.8.6",
+      "numpy==1.19.2",
+      "numpy==1.21.6",
+      "numpydoc==1.5.0",
+      "oauthlib==3.2.2",
+      "openpyxl==3.1.3",
+      "packaging==24.0",
+      "pandas-gbq==0.15.0",
+      "pandas==0.25.3",
+      "pandas==1.0.5",
+      "pandas==1.1.3",
+      "pandas==1.3.5",
+      "pandocfilters==1.5.1",
+      "parso==0.8.4",
+      "partd==1.4.1",
+      "pathlib==1.0.1",
+      "pathspec==0.11.2",
+      "pexpect==4.9.0",
+      "pickleshare==0.7.5",
+      "pika==1.3.2",
+      "pkginfo==1.10.0",
+      "pkgutil_resolve_name==1.3.10",
+      "platformdirs==4.0.0",
+      "pluggy==0.13.1",
+      "pluggy==1.2.0",
+      "pre-commit==2.7.1",
+      "prometheus-client==0.17.1",
+      "prompt_toolkit==3.0.48",
+      "proto-plus==1.26.1",
+      "protobuf==3.20.3",
+      "protobuf==4.24.4",
+      "psutil==5.6.6",
+      "psutil==7.0.0",
+      "psycopg2-binary==2.9.9",
+      "ptyprocess==0.7.0",
+      "py-spy==0.4.0",
+      "py==1.11.0",
+      "py==1.9.0",
+      "pyaml==20.4.0",
+      "pyarrow==0.16.0",
+      "pyasn1-modules==0.3.0",
+      "pyasn1==0.5.1",
+      "pycodestyle==2.9.1",
+      "pycparser==2.21",
+      "pydata-google-auth==1.8.2",
+      "pydocstyle==6.3.0",
+      "pyface==8.0.0",
+      "pyflakes==2.5.0",
+      "pylint==2.17.7",
+      "pymongo==3.13.0",
+      "pyodbc==4.0.39",
+      "pyparsing==2.4.7",
+      "pyparsing==3.1.4",
+      "pyrsistent==0.19.3",
+      "pysurfer==0.11.2",
+      "pytest-cov==2.10.1",
+      "pytest-cov==4.1.0",
+      "pytest-custom-exit-code==0.3.0",
+      "pytest-html==3.2.0",
+      "pytest-metadata==3.0.0",
+      "pytest-mock==3.11.1",
+      "pytest-testmon==1.2.3",
+      "pytest-xdist==3.5.0",
+      "pytest==6.1.1",
+      "pytest==7.4.4",
+      "python-dateutil==2.8.1",
+      "python-dateutil==2.9.0.post0",
+      "python-json-logger==3.0.1",
+      "pytz==2019.3",
+      "pytz==2020.1",
+      "pytz==2025.2",
+      "pyzmq==26.2.1",
+      "ray==0.8.6",
+      "readme-renderer==37.3",
+      "redis==3.4.1",
+      "requests-oauthlib==2.0.0",
+      "requests-toolbelt==1.0.0",
+      "requests==2.24.0",
+      "requests==2.31.0",
+      "rfc3339-validator==0.1.4",
+      "rfc3986-validator==0.1.1",
+      "rfc3986==2.0.0",
+      "rich==13.8.1",
+      "rsa==4.9",
+      "s3fs==2023.1.0",
+      "scikit-learn==0.23.1",
+      "scikit-learn==1.0.2",
+      "scikit-optimize==0.8.1",
+      "scipy==1.5.2",
+      "scipy==1.7.3",
+      "six==1.15.0",
+      "six==1.17.0",
+      "sniffio==1.3.1",
+      "snowballstemmer==2.2.0",
+      "sortedcontainers==2.4.0",
+      "soupsieve==2.4.1",
+      "sparse==0.13.0",
+      "sphinx-rtd-theme==2.0.0",
+      "sphinxcontrib-applehelp==1.0.2",
+      "sphinxcontrib-devhelp==1.0.2",
+      "sphinxcontrib-htmlhelp==2.0.0",
+      "sphinxcontrib-jquery==4.1",
+      "sphinxcontrib-jsmath==1.0.1",
+      "sphinxcontrib-qthelp==1.0.3",
+      "sphinxcontrib-serializinghtml==1.1.5",
+      "tables==3.7.0",
+      "tblib==2.0.0",
+      "terminado==0.17.1",
+      "threadpoolctl==2.1.0",
+      "threadpoolctl==3.1.0",
+      "tinycss2==1.2.1",
+      "toml==0.10.1",
+      "tomli==2.0.1",
+      "tomlkit==0.12.5",
+      "toolz==0.12.1",
+      "tornado==6.2",
+      "tox==3.28.0",
+      "tqdm==4.67.1",
+      "traitlets==5.9.0",
+      "traits==6.4.3",
+      "traitsui==8.0.0",
+      "twine==4.0.2",
+      "typed-ast==1.5.5",
+      "typing_extensions==4.7.1",
+      "uri-template==1.3.0",
+      "uritemplate==3.0.1",
+      "urllib3==1.25.10",
+      "urllib3==1.26.20",
+      "urllib3==2.0.7",
+      "virtualenv==20.26.6",
+      "vtk==9.3.1",
+      "wcwidth==0.2.13",
+      "webcolors==1.13",
+      "webencodings==0.5.1",
+      "websocket-client==1.6.1",
+      "widgetsnbextension==4.0.13",
+      "wrapt==1.16.0",
+      "xarray==0.19.0",
+      "xgboost==0.90",
+      "xlrd==2.0.1",
+      "y-py==0.6.2",
+      "yarl==1.9.4",
+      "ypy-websocket==0.8.4",
+      "zict==2.2.0",
+      "zipp==3.15.0"
+    ]
+  }
+}