MiMo-V2.6-RL Terminal as Harbor tasks (part 2)

tasks/candidate-1247-security-reverse-engineering/tests/test_outputs.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+import ast
+import hashlib
+import json
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+
+APP = Path("/app")
+PROJECT = APP / "vendor/dissect-cstruct"
+FIXTURES = Path("/tests/fixtures")
+REPORT = APP / "repair_report.json"
+CONTEXT_PATTERN = re.compile(r"^([ >])(\d+): (.*)$")
+
+
+def load_cases() -> dict[str, object]:
+    return json.loads((FIXTURES / "regression_cases.json").read_text())
+
+
+def expected_context(definition: str, line: int, radius: int = 2) -> dict[int, str]:
+    lines = definition.splitlines()
+    start = max(1, line - radius)
+    end = min(len(lines), line + radius)
+    return {number: lines[number - 1] for number in range(start, end + 1)}
+
+
+def parse_diagnostic(message: str) -> tuple[int, dict[int, str], set[int]]:
+    header = re.match(r"line (\d+):", message)
+    assert header, f"missing line-number header: {message!r}"
+    rows: dict[int, str] = {}
+    marked: set[int] = set()
+    for raw_line in message.splitlines()[1:]:
+        match = CONTEXT_PATTERN.fullmatch(raw_line)
+        assert match, f"malformed context row: {raw_line!r}"
+        marker, number, source = match.groups()
+        line_number = int(number)
+        assert line_number not in rows, f"duplicate context line {line_number}"
+        rows[line_number] = source
+        if marker == ">":
+            marked.add(line_number)
+    return int(header.group(1)), rows, marked
+
+
+def run_load(definition: str) -> Exception:
+    from dissect.cstruct import cstruct
+
+    with pytest.raises(Exception) as captured:
+        cstruct().load(definition)
+    return captured.value
+
+
+def test_gate_workspace_integrity_and_report() -> None:
+    integrity = json.loads((FIXTURES / "source_integrity.json").read_text())
+    assert PROJECT.is_dir()
+    for relative_path, expected_hash in integrity.items():
+        path = APP / relative_path
+        assert path.is_file(), f"required frozen asset missing: {relative_path}"
+        assert hashlib.sha256(path.read_bytes()).hexdigest() == expected_hash
+
+    for relative_path in ("dissect/cstruct/lexer.py", "dissect/cstruct/parser.py"):
+        source = (PROJECT / relative_path).read_text()
+        ast.parse(source)
+        assert len(source) > 1000
+
+    report = json.loads(REPORT.read_text())
+    assert report["schema_version"] == "tbench.cstruct_repair_report.v1"
+    assert {item["name"] for item in report["diagnostics"]} == {"unknown_directive", "missing_terminator"}
+    assert report["decode_probe"] == {
+        "count": 2,
+        "flags": 129,
+        "magic": 50010,
+        "offsets": [16, 44],
+        "size": 12,
+    }
+
+
+def test_gate_focused_upstream_suite() -> None:
+    environment = os.environ.copy()
+    environment["PYTHONPATH"] = str(PROJECT)
+    completed = subprocess.run(
+        [
+            sys.executable,
+            "-c",
+            (
+                "import sys, types, pytest; "
+                "package = types.ModuleType('tests'); "
+                f"package.__path__ = [{str(PROJECT / 'tests')!r}]; "
+                "sys.modules['tests'] = package; "
+                "raise SystemExit(pytest.main(sys.argv[1:]))"
+            ),
+            "-q",
+            str(PROJECT / "tests/test_lexer.py"),
+            str(PROJECT / "tests/test_parser.py"),
+        ],
+        cwd=PROJECT,
+        env=environment,
+        capture_output=True,
+        text=True,
+        timeout=45,
+    )
+    assert completed.returncode == 0, completed.stdout + completed.stderr
+    assert "passed" in completed.stdout
+
+
+def test_core_lexer_context_is_dynamic_and_numbered() -> None:
+    case = load_cases()["lexer"]
+    error = run_load(case["definition"])
+    assert type(error).__name__ == case["error_type"]
+    assert case["message_fragment"] in str(error)
+    line, rows, marked = parse_diagnostic(str(error))
+    assert line == case["line"]
+    assert rows == expected_context(case["definition"], line)
+    assert marked == {line}
+
+
+def test_core_parser_context_uses_failing_token() -> None:
+    case = load_cases()["parser"]
+    error = run_load(case["definition"])
+    assert type(error).__name__ == case["error_type"]
+    assert case["message_fragment"] in str(error)
+    line, rows, marked = parse_diagnostic(str(error))
+    assert line == case["line"]
+    assert rows == expected_context(case["definition"], line)
+    assert marked == {line}
+
+
+def test_core_valid_big_endian_binary_decode_is_preserved() -> None:
+    from dissect.cstruct import cstruct
+
+    case = load_cases()["binary"]
+    parser = cstruct(endian=case["endian"]).load(case["definition"])
+    value = parser.EvidenceHeader(bytes.fromhex(case["hex"]))
+    actual = {
+        "signature": value.signature,
+        "flags": value.flags,
+        "count": value.count,
+        "record_offsets": list(value.record_offsets),
+        "size": len(parser.EvidenceHeader),
+    }
+    assert actual == case["expected"]
+    assert value.dumps().hex() == case["hex"]
+
+
+def test_edge_line_continuations_use_normalized_source() -> None:
+    case = load_cases()["continued_parser"]
+    error = run_load(case["definition"])
+    assert type(error).__name__ == case["error_type"]
+    line, rows, marked = parse_diagnostic(str(error))
+    assert line == case["line"]
+    assert rows == expected_context(case["normalized_definition"], line)
+    assert marked == {line}
+    assert all("\\" not in source for source in rows.values())
+
+
+def test_edge_preload_parser_error_is_safe_and_line_only() -> None:
+    from dissect.cstruct import cstruct
+    from dissect.cstruct.lexer import Token, TokenType
+    from dissect.cstruct.parser import CStyleParser
+
+    parser = CStyleParser(cstruct())
+    error = parser._error("pre-load failure", token=Token(TokenType.IDENTIFIER, "bad", 17))
+    assert type(error).__name__ == "ParserError"
+    assert str(error) == "line 17: pre-load failure"

tasks/candidate-1257-software-systems/environment/Dockerfile

@@ -0,0 +1,3 @@
+# The task's image, pinned by digest (the same as [environment].docker_image).
+# Setup runs at start from [environment.healthcheck]; environment/setup/ is its readable copy.
+FROM docker.io/xiaomimimo/mimo-v2.6-rl-oss@sha256:5dde74728d7d458d80c166752b6e0afa5e870a4d5a4c5e79976c75c5e8b92ed5

tasks/candidate-1257-software-systems/environment/setup/setup.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+# Runs once, as root, before the agent starts: Harbor's [environment.healthcheck] unpacks this folder into
+# /var/lib/mimo and runs it. Generated by mimo_harbor; see its README for how each step maps to Xiaomi's harness.
+M=/var/lib/mimo
+[ -f "$M/ready" ] && exit 0
+chmod 700 "$M"
+fail() { echo "setup: $*" >&2; exit 1; }
+# the answer-leak blocklist (mimoagent), applied to /etc/hosts by the agent right after it installs
+write_blocklist() { cp "$M/files/blocklist" "$M/blocklist"; }
+
+# Terminal-Bench rows (in the General domain): the Harbor convention itself. Scrub test leftovers from the image and
+# remember what was in the workspace, so harness residue can be told apart from the agent's work at grading time.
+rm -rf /tests
+find /logs/verifier -mindepth 1 -delete 2>/dev/null || true
+ls -A /app 2>/dev/null > "$M/before" || true
+
+touch "$M/ready"
+echo "setup done"

tasks/candidate-1257-software-systems/instruction.md

@@ -0,0 +1,33 @@
+You are an agent, your current working directory is /app.
+
+You can use the tools available to you to interact with the computer to assist the user in completing tasks.
+
+# Repair compressed wheel-tag parsing
+
+You are given a frozen Python packaging library under `/app/vendor/packaging`.
+The public tag parser currently accepts malformed interpreter components in a
+compressed tag. For example, a dotted numeric component can be expanded into
+several bogus interpreter tags. The wheel filename utility then exposes the
+same defect through its public API.
+
+Repair the existing production source in both `src/packaging/tags.py` and
+`src/packaging/utils.py`.
+
+Requirements:
+
+1. Every interpreter member of a compressed tag must be a Python identifier.
+   Reject invalid members before creating any `Tag` objects. Digits are valid
+   when the complete value is an identifier: preserve values such as `py3`,
+   `graalpy311`, and `_custom`.
+2. Keep existing empty-component, three-component, ordering, and tag-limit
+   checks intact.
+3. `parse_wheel_filename()` must translate tag validation failures to its own
+   `InvalidWheelFilename` exception while retaining normal project-name,
+   version, build, and valid-tag normalization behavior.
+4. Run the offline integration audit at `/app/run_audit.py`. It reads
+   `/app/inputs/tag_cases.json` and writes the required artifact
+   `/app/output.json` using the schema in `/app/contract.json`.
+
+Do not add dependencies or access the network. The deliverable is the modified
+source tree plus the generated JSON artifact.
+

tasks/candidate-1257-software-systems/task.toml

@@ -0,0 +1,39 @@
+schema_version = "1.4"
+
+[task]
+name = "mimo-v2.6-rl/candidate-1257-software-systems"
+description = "MiMo-V2.6-RL terminal task candidate-1257-software-systems"
+keywords = ["mimo-v2.6-rl", "terminal"]
+
+[metadata]
+adapter = "mimo_harbor 1.0.0"
+domain = "terminal"
+original_allow_internet = false
+reference_harness = "XiaomiMiMo/verl a2ad9f6 + XiaomiMiMo/mimoagent 467f0a1"
+reference_step_limit = 500
+source_dataset = "XiaomiMiMo/MiMo-V2.6-RL-oss"
+source_id = "candidate-1257-software-systems"
+source_revision = "639865fd3374018d6cb29b9fb82dd531406fcf5f"
+
+[agent]
+timeout_sec = 900.0
+
+[verifier]
+timeout_sec = 240.0
+user = "root"
+
+[environment]
+docker_image = "docker.io/xiaomimimo/mimo-v2.6-rl-oss@sha256:5dde74728d7d458d80c166752b6e0afa5e870a4d5a4c5e79976c75c5e8b92ed5"
+workdir = "/app"
+cpus = 1
+memory_mb = 2048
+storage_mb = 10240
+network_mode = "public"
+build_timeout_sec = 1800.0
+
+[environment.healthcheck]
+# one-time setup before the agent (environment/setup/setup.sh)
+command = "bash -c 'test -f /var/lib/mimo/ready || { mkdir -p /var/lib/mimo && echo H4sIAAAAAAAC/+2T30/UQBDH77l/xddCEAx3PVAhgUiCkegLL+iDCSFk206vm9vuNrvbq0T83532gJP4qr44n5e2+2PmO9+ZBopdOwv15C8yZ47n8/E5//158Pbo8PH9Yf34zeujCeaTf0AXovKccvJ/svUiy7XNchXqZAtXnQ1wtqB9qADvXNxHTpXzhFgT1IJsxGBYDCf4pHzu/MuAa7Ir7Z1teHdWkzKxLmoqljfobKuKZeDLOqBypiQPbaPjVNlK+czoPGt046BsCT8k13GGj2TJq0gl8jsM27f1mOoUgYhPBFxdnH+4vOCIHrXrQaqoWRa1aFTL2Ry+auUazdr4pqUQZsnlu2cZk2tMK6Tbl5knVd6luMHODuibjpgnRd24Ejyyw4E0qZQ2u3v4DipqhzQMv8wJtl+lONs5PF1fOjjFD65qdMmGnvzUkFoiN65YGh0idoeso4F7bG7bGs31sdKMYpHVLnBVXO3GZa8XdYSq4mBZZNfYdmNC0nsd6fYp7qiraMdKKm0oZE9b6bi4+RwUssQv5BttlZm+J8u2edcH7Go7pl47b1C6Rmm7dzIurvuMwtkVC9PODi0gU83wufBdjkhcnqEquhV5brN3zXhPN1zJ0FlO6qmhJudS+lpF9DxcDxl755eBh4QnLrjHbvHxoMuOUCjL88c2mZI947HbRB9d4gYPAcAxF16V2i4QdUOzxDeY+grZoC0klebxyoxbhIwl6kqzkCmbUFIbaxxgWpKhSDg8y0paZbYzBvf3iL6jxARMz5Fxx55tn63NHf+N9OlwEl3Hnm7GKvllZNhVS2kyEQRBEARBEARBEARBEARBEARBEARBEARBEIQ/xk8LxjaZACgAAA== | base64 -d | tar -xzf - -C /var/lib/mimo && bash /var/lib/mimo/setup.sh; }'"
+timeout_sec = 1200.0
+retries = 0
+interval_sec = 5.0

tasks/candidate-1257-software-systems/tests/anti_hack_guard.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""TBench in-pod anti-hack guard.
+
+Runs at the very start of ``tests/test.sh``, inside the verifier container,
+after the agent's ``/app`` has been copied in.  The RL harness materialises
+``tests/`` into the MAIN container only after the agent exits, so the agent
+cannot see or tamper with this file — which makes it the right place to reject
+workspace pollution the agent planted during the episode.
+
+Detection (any hit -> write reward=0 and exit non-zero):
+
+1. **Planted interpreter hooks.**  ``conftest.py`` / ``sitecustomize.py`` /
+   ``usercustomize.py`` / ``*.pth`` / ``pytest.ini`` / ``.coveragerc`` /
+   ``tox.ini`` anywhere under ``/app`` whose path is NOT listed in the pristine
+   manifest.  Upstream vendor trees that legitimately ship a ``conftest.py``
+   are listed in the manifest and are therefore not false positives.
+2. **Protected-file mutation.**  Any manifest entry whose sha256 changed while
+   its path is outside the declared mutable set.
+3. **Protected-file deletion.**  Any non-mutable, non-artifact manifest entry
+   that vanished.
+
+The manifest is generated from the pristine ``environment/`` tree and shipped
+as ``tests/fixtures/pristine_env_manifest.json``.  A missing manifest degrades to
+name-only detection so the guard never blocks an uninstrumented task.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sys
+from pathlib import Path
+
+SCHEMA = "tbench.pristine_env_manifest.v1"
+
+APP = Path(os.environ.get("TBENCH_APP_ROOT", "/app"))
+FIXTURES = Path(os.environ.get("TBENCH_FIXTURES", "/tests/fixtures"))
+MANIFEST = FIXTURES / "pristine_env_manifest.json"
+REWARD = Path(os.environ.get("TBENCH_REWARD_FILE", "/logs/verifier/reward.txt"))
+
+DANGEROUS_NAMES = {
+    "conftest.py",
+    "sitecustomize.py",
+    "usercustomize.py",
+    "pytest.ini",
+    ".coveragerc",
+    "tox.ini",
+    "pyproject.toml",  # only dangerous when planted; upstream copies are in the manifest
+}
+
+
+def sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def is_dangerous(rel: str) -> bool:
+    name = rel.rsplit("/", 1)[-1]
+    return name in DANGEROUS_NAMES or name.endswith(".pth")
+
+
+def load_manifest() -> dict | None:
+    if not MANIFEST.is_file():
+        return None
+    try:
+        doc = json.loads(MANIFEST.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    if not isinstance(doc, dict) or not isinstance(doc.get("files"), dict):
+        return None
+    return doc
+
+
+def reject(reason: str, reward: Path | None = None) -> int:
+    target = REWARD if reward is None else reward
+    try:
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text("0\n", encoding="utf-8")
+    except OSError as exc:  # pragma: no cover - reward file is the contract
+        print(f"anti_hack_guard: cannot write reward file: {exc}", file=sys.stderr)
+        return 2
+    print(f"anti_hack_guard: REJECT {reason}", file=sys.stderr)
+    return 1
+
+
+def scan(manifest: dict | None, app: Path | None = None) -> str | None:
+    app_root = APP if app is None else app
+    files: dict[str, str] = (manifest or {}).get("files") or {}
+    mutable_set = {
+        entry.lstrip("/")
+        for entry in (manifest or {}).get("mutable") or []
+        if isinstance(entry, str)
+    }
+    artifacts = {
+        str(entry).removeprefix("/app/").lstrip("/")
+        for entry in (manifest or {}).get("artifacts") or []
+        if isinstance(entry, str)
+    }
+
+    if not app_root.is_dir():
+        return None
+
+    for path in sorted(app_root.rglob("*")):
+        if not path.is_file() or path.is_symlink():
+            continue
+        rel = path.relative_to(app_root).as_posix()
+        if is_dangerous(rel) and rel not in files:
+            return f"planted_interpreter_hook:{rel}"
+
+    if manifest is None:
+        return None
+
+    # Deletion detection is only sound when the built image is known to equal
+    # the source tree (plain ``COPY . /app``).  A multi-stage or dockerignored
+    # build legitimately omits files, and rejecting those would zero out the
+    # oracle for a perfectly good task.
+    detect_deletion = bool(manifest.get("detect_deletion", True))
+    for rel, expected in files.items():
+        if rel in mutable_set or rel in artifacts:
+            continue
+        path = app_root / rel
+        if not path.exists():
+            if detect_deletion:
+                return f"protected_file_deleted:{rel}"
+            continue
+        if not path.is_file():
+            continue
+        if sha256(path) != expected:
+            return f"protected_file_mutated:{rel}"
+    return None
+
+
+def main(app: Path | None = None, reward: Path | None = None) -> int:
+    manifest = load_manifest()
+    reason = scan(manifest, app=app)
+    if reason:
+        return reject(reason, reward=reward)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

tasks/candidate-1257-software-systems/tests/fixtures/cases.json

@@ -0,0 +1,14 @@
+{
+  "direct": [
+    {"tag": "py2.py3-none-any", "status": "ok", "tags": ["py2-none-any", "py3-none-any"]},
+    {"tag": "_custom.graalpy311-none-any", "status": "ok", "tags": ["_custom-none-any", "graalpy311-none-any"]},
+    {"tag": "2.7.6-cp27-manylinux_2_17_x86_64", "status": "error", "error_type": "InvalidTag"},
+    {"tag": "py3..py2-none-any", "status": "error", "error_type": "InvalidTag"}
+  ],
+  "wheels": [
+    {"filename": "demo_pkg-1.4-py3.py2-none-any.whl", "status": "ok", "name": "demo-pkg", "version": "1.4", "build": [], "tags": ["py2-none-any", "py3-none-any"]},
+    {"filename": "demo_pkg-2.0-1abc-cp311-abi3-manylinux_2_17_x86_64.whl", "status": "ok", "name": "demo-pkg", "version": "2.0", "build": [1, "abc"], "tags": ["cp311-abi3-manylinux_2_17_x86_64"]},
+    {"filename": "demo_pkg-1.4-2.7.6-none-any.whl", "status": "error", "error_type": "InvalidWheelFilename"},
+    {"filename": "demo_pkg-1.4-py3..py2-none-any.whl", "status": "error", "error_type": "InvalidWheelFilename"}
+  ]
+}

tasks/candidate-1257-software-systems/tests/fixtures/pristine_env_manifest.json

@@ -0,0 +1,43 @@
+{
+  "artifacts": [
+    "output.json"
+  ],
+  "detect_deletion": true,
+  "files": {
+    "Dockerfile": "fdc4026cc5e1301ffb6bdfd12f61c9d1591909ddf05501b43ef6ade47d01641f",
+    "contract.json": "8e2c57170bb87ecabeb87f35cc88b68d62df53c66767441acd1bfff6dc3ff1bd",
+    "inputs/tag_cases.json": "407e6bec7a3114350887395b6c399cfa1bbd2a49782c0f0b218af291ca829fe1",
+    "run_audit.py": "7ca92adf058d01e96c1ada6e42ed328db23294813cd981f0c315cd854d11f377",
+    "vendor/packaging/LICENSE": "cad1ef5bd340d73e074ba614d26f7deaca5c7940c3d8c34852e65c4909686c48",
+    "vendor/packaging/README.rst": "62ffae0495b4ed9b8357c03f661b923861565fc8f3bdd42de23a4e5217514e3a",
+    "vendor/packaging/pyproject.toml": "b0a54ca7272d1dce914f64e6dddf6026e5664aff3622971994956b320c00f59e",
+    "vendor/packaging/src/packaging/__init__.py": "bf01887ad0f4a9fa9e3b9cd4601dc40a7b2970b5c808cde59e64c4aa1e797c91",
+    "vendor/packaging/src/packaging/_elffile.py": "1f025f54c573f1a85740c4fbd908cc1d1fb0c177c14377ebf5f09d6cd5368780",
+    "vendor/packaging/src/packaging/_manylinux.py": "5b6e84324c42538ab4cdb148e2430fdba36f04427b0efda55bea083a35fa6136",
+    "vendor/packaging/src/packaging/_musllinux.py": "0328fb827b1170c77df4c107d49be8df8d37262103490a61e8acad8a2f9cadff",
+    "vendor/packaging/src/packaging/_parser.py": "88a348115209327497e453b635e5db099fd592f9335d710c7313b29cdb30c50c",
+    "vendor/packaging/src/packaging/_ranges.py": "b7b595f2e692aeb3697c545b85c24cbbcb4552f2adc6d9059aa82d0877e816b7",
+    "vendor/packaging/src/packaging/_structures.py": "eb48d16c5efca7ccf930a9cd77a700a6b80e69d0891d5d03966526441a8565cb",
+    "vendor/packaging/src/packaging/_tokenizer.py": "cc25e57c0d564c89e15073471d6e1c264299ca946fb17c0e1e4af54ef7713ee6",
+    "vendor/packaging/src/packaging/dependency_groups.py": "5309cc564ca3022dfb594816e9d593bb09cdf34208c1fb8c5ec9afb6c670278c",
+    "vendor/packaging/src/packaging/direct_url.py": "843baa95d04cbb49288de9d9fd77ee946e862cb603123e7e46a69e171fa7d06b",
+    "vendor/packaging/src/packaging/errors.py": "ea17c461701ff2ffc817ae7e94569d24e30889e04fdb120ab721178c6d67188b",
+    "vendor/packaging/src/packaging/licenses/__init__.py": "590d12eee73ddbec53b4e9ee5bfc64d9cb3aacb4940e8ebcba260757ce56740b",
+    "vendor/packaging/src/packaging/licenses/_spdx.py": "596ec35e2ca0ebcba9fd8343ff0a51625af548786257815f24b41f7e08613314",
+    "vendor/packaging/src/packaging/markers.py": "9056d5d4882a3ba14a7624ba64c3a33aadb00c563dce4d15343dc229fbef5f8a",
+    "vendor/packaging/src/packaging/metadata.py": "de04e563692ed785d4779c711639b9c464f92fb5865d80c9a540602f8f12ba14",
+    "vendor/packaging/src/packaging/py.typed": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/packaging/src/packaging/pylock.py": "1bc9a1fc8835202b3b5722fcde0b142f71064b31d9c67647ea879d9b21c855c5",
+    "vendor/packaging/src/packaging/ranges.py": "b4781ce913e5dff9e07906f20585c54c3028e1f7ff56341828e79d522ddbfab6",
+    "vendor/packaging/src/packaging/requirements.py": "c3e8fd347d4c92e4083445fd95441fcb02d2def922c96d1b2147728c394168aa",
+    "vendor/packaging/src/packaging/specifiers.py": "f9e37cfb1ceba333a1302c2af605ec6f2fb67801f341af70d347f9271ab8e9cb",
+    "vendor/packaging/src/packaging/tags.py": "cb6d67388b647f87e4e83b89a005949e682c6b804f4b7f2bb0a2853e6d15b590",
+    "vendor/packaging/src/packaging/utils.py": "0074d32bf98c4bc4a400507c499615ac8c29b09a456d538422d82fd39640c8aa",
+    "vendor/packaging/src/packaging/version.py": "af4b2bfdbdaaf743eb5ef831e7981963857ef39ab96fdbeee4d402539f715059"
+  },
+  "mutable": [
+    "vendor/packaging/src/packaging/tags.py",
+    "vendor/packaging/src/packaging/utils.py"
+  ],
+  "schema_version": "tbench.pristine_env_manifest.v1"
+}

tasks/candidate-1257-software-systems/tests/task_test.sh

@@ -0,0 +1,26 @@
+#!/bin/sh
+set +e
+mkdir -p /logs/verifier
+# tbench-anti-hack-guard:v1
+export PYTHONNOUSERSITE=1
+export PYTHONDONTWRITEBYTECODE=1
+# Fail open when the verifier image has no python3 (node-only tests images are
+# excluded from the RL set but still verifiable natively): a missing
+# interpreter must not swallow the grader's own reward write.
+if command -v python3 >/dev/null 2>&1 && [ -f /tests/anti_hack_guard.py ]; then
+  if ! python3 /tests/anti_hack_guard.py; then
+    # Guard already wrote reward=0; the reward file is the grading contract.
+    exit 0
+  fi
+fi
+
+
+python3 -m pytest --ctrf /logs/verifier/ctrf.json -q /tests/test_outputs.py
+status=$?
+if [ "$status" -eq 0 ]; then
+  echo 1 > /logs/verifier/reward.txt
+else
+  echo 0 > /logs/verifier/reward.txt
+fi
+exit 0
+

tasks/candidate-1257-software-systems/tests/test.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+# Terminal-Bench grading: the task's own test script (task_test.sh here) writes /logs/verifier/reward.txt.
+# "-1" there is its crash sentinel: a testbed failure, so no reward is written (not scored).
+CWD=/app
+mkdir -p /logs/verifier
+# the task's anti-hack guard rejects files planted in the workspace: drop what agent harnesses leave there
+for d in .opencode .claude .codex .gemini .goose .aider.tags.cache.v4; do
+  grep -qx "$d" /var/lib/mimo/before 2>/dev/null || rm -rf "$CWD/$d"
+done
+cd "$CWD" && bash /tests/task_test.sh
+R=$(cat /logs/verifier/reward.txt 2>/dev/null | tr -d '[:space:]')
+if [ -z "$R" ] || [ "$R" = "-1" ]; then
+  rm -f /logs/verifier/reward.txt
+  echo "the tests crashed before grading (reward '${R}'): not scored" >&2
+  exit 1
+fi

tasks/candidate-1257-software-systems/tests/test_outputs.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+APP = Path('/app')
+SRC = APP / 'vendor/packaging/src'
+sys.path.insert(0, str(SRC))
+from packaging.tags import InvalidTag, parse_tag  # noqa: E402
+from packaging.utils import InvalidWheelFilename, parse_wheel_filename  # noqa: E402
+
+FIXTURE = json.loads((Path(__file__).parent / 'fixtures/cases.json').read_text())
+
+
+def load_report():
+    path = APP / 'output.json'
+    assert path.is_file(), 'required artifact is missing'
+    report = json.loads(path.read_text())
+    assert report['schema_version'] == 'packaging-tag-audit.v1'
+    assert set(report) == {'schema_version', 'direct_cases', 'wheel_cases', 'summary'}
+    return report
+
+
+def test_gate_artifact_and_source_tree():
+    report = load_report()
+    assert len(report['direct_cases']) == len(FIXTURE['direct'])
+    assert len(report['wheel_cases']) == len(FIXTURE['wheels'])
+    for rel in ('tags.py', 'utils.py', 'version.py', 'specifiers.py', 'requirements.py'):
+        assert (SRC / 'packaging' / rel).is_file()
+    assert (APP / 'run_audit.py').is_file()
+
+
+def test_gate_source_compiles():
+    result = subprocess.run(
+        [sys.executable, '-m', 'compileall', '-q', str(SRC / 'packaging')],
+        env={**os.environ, 'PYTHONPATH': str(SRC)},
+        capture_output=True,
+        text=True,
+    )
+    assert result.returncode == 0, result.stderr
+
+
+def test_core_direct_independent_recompute():
+    report = load_report()
+    by_input = {item['input']: item for item in report['direct_cases']}
+    for case in FIXTURE['direct']:
+        observed = by_input[case['tag']]
+        try:
+            actual = sorted(map(str, parse_tag(case['tag'])))
+        except Exception as exc:
+            assert case['status'] == 'error'
+            assert type(exc).__name__ == case['error_type']
+            assert observed['status'] == 'error'
+            assert observed['error_type'] == case['error_type']
+        else:
+            assert case['status'] == 'ok'
+            assert actual == case['tags']
+            assert observed['status'] == 'ok'
+            assert observed['tags'] == actual
+
+
+def test_core_wheel_independent_recompute():
+    report = load_report()
+    by_input = {item['input']: item for item in report['wheel_cases']}
+    for case in FIXTURE['wheels']:
+        observed = by_input[case['filename']]
+        try:
+            name, version, build, tags = parse_wheel_filename(
+                case['filename']
+            )
+        except Exception as exc:
+            assert case['status'] == 'error'
+            assert type(exc).__name__ == case['error_type']
+            assert observed['status'] == 'error'
+            assert observed['error_type'] == case['error_type']
+        else:
+            assert case['status'] == 'ok'
+            assert str(name) == case['name']
+            assert str(version) == case['version']
+            assert list(build) == case['build']
+            assert sorted(map(str, tags)) == case['tags']
+            assert observed['status'] == 'ok'
+            assert observed['name'] == str(name)
+            assert observed['version'] == str(version)
+            assert observed['build'] == list(build)
+            assert observed['tags'] == case['tags']
+
+
+def test_edge_public_error_contract_and_summary():
+    report = load_report()
+    with pytest.raises(InvalidTag, match='invalid interpreter'):
+        parse_tag('2.7.6-cp27-any')
+    with pytest.raises(ValueError, match='not in sorted order'):
+        parse_tag('py3.py2-none-any', validate_order=True)
+    with pytest.raises(InvalidWheelFilename, match='invalid tag component'):
+        parse_wheel_filename('demo_pkg-1.4-2.7.6-none-any.whl')
+    assert report['summary'] == {
+        'direct_ok': 2,
+        'direct_errors': 2,
+        'wheel_ok': 2,
+        'wheel_errors': 2,
+    }

tasks/candidate-1271-media-games/environment/Dockerfile

@@ -0,0 +1,3 @@
+# The task's image, pinned by digest (the same as [environment].docker_image).
+# Setup runs at start from [environment.healthcheck]; environment/setup/ is its readable copy.
+FROM docker.io/xiaomimimo/mimo-v2.6-rl-oss@sha256:37034a49d0e3b9840cf385f178466f3db6777e2a656c2765c6f711b5c7894f96

tasks/candidate-1271-media-games/environment/setup/setup.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+# Runs once, as root, before the agent starts: Harbor's [environment.healthcheck] unpacks this folder into
+# /var/lib/mimo and runs it. Generated by mimo_harbor; see its README for how each step maps to Xiaomi's harness.
+M=/var/lib/mimo
+[ -f "$M/ready" ] && exit 0
+chmod 700 "$M"
+fail() { echo "setup: $*" >&2; exit 1; }
+# the answer-leak blocklist (mimoagent), applied to /etc/hosts by the agent right after it installs
+write_blocklist() { cp "$M/files/blocklist" "$M/blocklist"; }
+
+# Terminal-Bench rows (in the General domain): the Harbor convention itself. Scrub test leftovers from the image and
+# remember what was in the workspace, so harness residue can be told apart from the agent's work at grading time.
+rm -rf /tests
+find /logs/verifier -mindepth 1 -delete 2>/dev/null || true
+ls -A /app 2>/dev/null > "$M/before" || true
+
+touch "$M/ready"
+echo "setup done"

tasks/candidate-1271-media-games/instruction.md

@@ -0,0 +1,59 @@
+You are an agent, your current working directory is /app.
+
+You can use the tools available to you to interact with the computer to assist the user in completing tasks.
+
+# Repair Arcade's camera and batch rendering integration
+
+A dependency upgrade changed how window cameras and batch drawing interact.
+The frozen Arcade tree in `/app/vendor/project` still uses the old integration:
+camera activation writes matrices to obsolete window attributes, the default
+projector does not implement the batch-camera scope protocol, and both graphics
+backends bypass Arcade's buffer abstraction when binding the window matrix
+block.
+
+Repair the existing source tree. Modify these six production modules:
+
+- `arcade/camera/camera_2d.py`
+- `arcade/camera/default.py`
+- `arcade/camera/orthographic.py`
+- `arcade/camera/perspective.py`
+- `arcade/gl/backends/opengl/context.py`
+- `arcade/gl/backends/webgl/context.py`
+
+The repaired behavior must satisfy all of the following:
+
+1. `Camera2D.use()`, `OrthographicProjector.use()`, and
+   `PerspectiveProjector.use()` make themselves current, preserve their
+   viewport/scissor behavior, and write generated projection and view matrices
+   to `window.ctx.projection_matrix` and `window.ctx.view_matrix`. They must not
+   create or rely on legacy `window.projection` or `window.view` attributes.
+2. `DefaultProjector` exposes live `projection` and `view` properties backed by
+   its Arcade context. It implements batch camera `begin()` and `end()` hooks as
+   no-ops and `get_group_scissor()` returns `None`, so a batch does not inherit
+   an Arcade scissor rectangle as an extra pyglet group.
+3. Camera activation scopes continue to restore the previous camera, matrices,
+   viewport, scissor, and framebuffer state even when drawing raises an
+   exception.
+4. Both `OpenGLArcadeContext.bind_window_block()` and
+   `WebGLArcadeContext.bind_window_block()` bind the Arcade-owned buffer through
+   `buffer.bind_to_uniform_block(binding=0, offset=0, size=128)`. Do not call a
+   raw backend binding API or use the underlying buffer id.
+5. Keep the public API and the rest of the source tree intact. Do not replace
+   the six modules, modify `/app/tools/check_camera_integration.py`, or change
+   the camera data/projection helpers or Arcade buffer abstraction.
+
+After repairing the modules, run:
+
+```bash
+python3 /app/tools/check_camera_integration.py
+```
+
+This must exit successfully and create `/app/repair_report.json`. The output
+contract is `/app/output_contract.json`; its `output_schema_version` is
+`arcade.camera-repair-report.v1`. The report must show `status: "pass"`, no
+errors, all six compiled modules, context-routed state for all three camera
+families, a complete default-projector protocol result, and identical recorded
+uniform-buffer calls for both backends.
+
+The final submission is the repaired source tree plus
+`/app/repair_report.json`. Runtime work must remain offline and CPU-only.

tasks/candidate-1271-media-games/task.toml

@@ -0,0 +1,39 @@
+schema_version = "1.4"
+
+[task]
+name = "mimo-v2.6-rl/candidate-1271-media-games"
+description = "MiMo-V2.6-RL terminal task candidate-1271-media-games"
+keywords = ["mimo-v2.6-rl", "terminal"]
+
+[metadata]
+adapter = "mimo_harbor 1.0.0"
+domain = "terminal"
+original_allow_internet = false
+reference_harness = "XiaomiMiMo/verl a2ad9f6 + XiaomiMiMo/mimoagent 467f0a1"
+reference_step_limit = 500
+source_dataset = "XiaomiMiMo/MiMo-V2.6-RL-oss"
+source_id = "candidate-1271-media-games"
+source_revision = "639865fd3374018d6cb29b9fb82dd531406fcf5f"
+
+[agent]
+timeout_sec = 900.0
+
+[verifier]
+timeout_sec = 240.0
+user = "root"
+
+[environment]
+docker_image = "docker.io/xiaomimimo/mimo-v2.6-rl-oss@sha256:37034a49d0e3b9840cf385f178466f3db6777e2a656c2765c6f711b5c7894f96"
+workdir = "/app"
+cpus = 1
+memory_mb = 2048
+storage_mb = 10240
+network_mode = "public"
+build_timeout_sec = 1800.0
+
+[environment.healthcheck]
+# one-time setup before the agent (environment/setup/setup.sh)
+command = "bash -c 'test -f /var/lib/mimo/ready || { mkdir -p /var/lib/mimo && echo H4sIAAAAAAAC/+2T30/UQBDH77l/xddCEAx3PVAhgUiCkegLL+iDCSFk206vm9vuNrvbq0T83532gJP4qr44n5e2+2PmO9+ZBopdOwv15C8yZ47n8/E5//158Pbo8PH9Yf34zeujCeaTf0AXovKccvJ/svUiy7XNchXqZAtXnQ1wtqB9qADvXNxHTpXzhFgT1IJsxGBYDCf4pHzu/MuAa7Ir7Z1teHdWkzKxLmoqljfobKuKZeDLOqBypiQPbaPjVNlK+czoPGt046BsCT8k13GGj2TJq0gl8jsM27f1mOoUgYhPBFxdnH+4vOCIHrXrQaqoWRa1aFTL2Ry+auUazdr4pqUQZsnlu2cZk2tMK6Tbl5knVd6luMHODuibjpgnRd24Ejyyw4E0qZQ2u3v4DipqhzQMv8wJtl+lONs5PF1fOjjFD65qdMmGnvzUkFoiN65YGh0idoeso4F7bG7bGs31sdKMYpHVLnBVXO3GZa8XdYSq4mBZZNfYdmNC0nsd6fYp7qiraMdKKm0oZE9b6bi4+RwUssQv5BttlZm+J8u2edcH7Go7pl47b1C6Rmm7dzIurvuMwtkVC9PODi0gU83wufBdjkhcnqEquhV5brN3zXhPN1zJ0FlO6qmhJudS+lpF9DxcDxl755eBh4QnLrjHbvHxoMuOUCjL88c2mZI947HbRB9d4gYPAcAxF16V2i4QdUOzxDeY+grZoC0klebxyoxbhIwl6kqzkCmbUFIbaxxgWpKhSDg8y0paZbYzBvf3iL6jxARMz5Fxx55tn63NHf+N9OlwEl3Hnm7GKvllZNhVS2kyEQRBEARBEARBEARBEARBEARBEARBEARBEIQ/xk8LxjaZACgAAA== | base64 -d | tar -xzf - -C /var/lib/mimo && bash /var/lib/mimo/setup.sh; }'"
+timeout_sec = 1200.0
+retries = 0
+interval_sec = 5.0

tasks/candidate-1271-media-games/tests/anti_hack_guard.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""TBench in-pod anti-hack guard.
+
+Runs at the very start of ``tests/test.sh``, inside the verifier container,
+after the agent's ``/app`` has been copied in.  The RL harness materialises
+``tests/`` into the MAIN container only after the agent exits, so the agent
+cannot see or tamper with this file — which makes it the right place to reject
+workspace pollution the agent planted during the episode.
+
+Detection (any hit -> write reward=0 and exit non-zero):
+
+1. **Planted interpreter hooks.**  ``conftest.py`` / ``sitecustomize.py`` /
+   ``usercustomize.py`` / ``*.pth`` / ``pytest.ini`` / ``.coveragerc`` /
+   ``tox.ini`` anywhere under ``/app`` whose path is NOT listed in the pristine
+   manifest.  Upstream vendor trees that legitimately ship a ``conftest.py``
+   are listed in the manifest and are therefore not false positives.
+2. **Protected-file mutation.**  Any manifest entry whose sha256 changed while
+   its path is outside the declared mutable set.
+3. **Protected-file deletion.**  Any non-mutable, non-artifact manifest entry
+   that vanished.
+
+The manifest is generated from the pristine ``environment/`` tree and shipped
+as ``tests/fixtures/pristine_env_manifest.json``.  A missing manifest degrades to
+name-only detection so the guard never blocks an uninstrumented task.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sys
+from pathlib import Path
+
+SCHEMA = "tbench.pristine_env_manifest.v1"
+
+APP = Path(os.environ.get("TBENCH_APP_ROOT", "/app"))
+FIXTURES = Path(os.environ.get("TBENCH_FIXTURES", "/tests/fixtures"))
+MANIFEST = FIXTURES / "pristine_env_manifest.json"
+REWARD = Path(os.environ.get("TBENCH_REWARD_FILE", "/logs/verifier/reward.txt"))
+
+DANGEROUS_NAMES = {
+    "conftest.py",
+    "sitecustomize.py",
+    "usercustomize.py",
+    "pytest.ini",
+    ".coveragerc",
+    "tox.ini",
+    "pyproject.toml",  # only dangerous when planted; upstream copies are in the manifest
+}
+
+
+def sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def is_dangerous(rel: str) -> bool:
+    name = rel.rsplit("/", 1)[-1]
+    return name in DANGEROUS_NAMES or name.endswith(".pth")
+
+
+def load_manifest() -> dict | None:
+    if not MANIFEST.is_file():
+        return None
+    try:
+        doc = json.loads(MANIFEST.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    if not isinstance(doc, dict) or not isinstance(doc.get("files"), dict):
+        return None
+    return doc
+
+
+def reject(reason: str, reward: Path | None = None) -> int:
+    target = REWARD if reward is None else reward
+    try:
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text("0\n", encoding="utf-8")
+    except OSError as exc:  # pragma: no cover - reward file is the contract
+        print(f"anti_hack_guard: cannot write reward file: {exc}", file=sys.stderr)
+        return 2
+    print(f"anti_hack_guard: REJECT {reason}", file=sys.stderr)
+    return 1
+
+
+def scan(manifest: dict | None, app: Path | None = None) -> str | None:
+    app_root = APP if app is None else app
+    files: dict[str, str] = (manifest or {}).get("files") or {}
+    mutable_set = {
+        entry.lstrip("/")
+        for entry in (manifest or {}).get("mutable") or []
+        if isinstance(entry, str)
+    }
+    artifacts = {
+        str(entry).removeprefix("/app/").lstrip("/")
+        for entry in (manifest or {}).get("artifacts") or []
+        if isinstance(entry, str)
+    }
+
+    if not app_root.is_dir():
+        return None
+
+    for path in sorted(app_root.rglob("*")):
+        if not path.is_file() or path.is_symlink():
+            continue
+        rel = path.relative_to(app_root).as_posix()
+        if is_dangerous(rel) and rel not in files:
+            return f"planted_interpreter_hook:{rel}"
+
+    if manifest is None:
+        return None
+
+    # Deletion detection is only sound when the built image is known to equal
+    # the source tree (plain ``COPY . /app``).  A multi-stage or dockerignored
+    # build legitimately omits files, and rejecting those would zero out the
+    # oracle for a perfectly good task.
+    detect_deletion = bool(manifest.get("detect_deletion", True))
+    for rel, expected in files.items():
+        if rel in mutable_set or rel in artifacts:
+            continue
+        path = app_root / rel
+        if not path.exists():
+            if detect_deletion:
+                return f"protected_file_deleted:{rel}"
+            continue
+        if not path.is_file():
+            continue
+        if sha256(path) != expected:
+            return f"protected_file_mutated:{rel}"
+    return None
+
+
+def main(app: Path | None = None, reward: Path | None = None) -> int:
+    manifest = load_manifest()
+    reason = scan(manifest, app=app)
+    if reason:
+        return reject(reason, reward=reward)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

tasks/candidate-1271-media-games/tests/fixtures/expected.json

@@ -0,0 +1,28 @@
+{
+  "schema_version": "arcade.camera-repair-report.v1",
+  "compiled_modules": [
+    "arcade/camera/camera_2d.py",
+    "arcade/camera/orthographic.py",
+    "arcade/camera/perspective.py",
+    "arcade/camera/default.py",
+    "arcade/gl/backends/opengl/context.py",
+    "arcade/gl/backends/webgl/context.py"
+  ],
+  "report_camera_viewport": [11, 13, 640, 360],
+  "report_camera_scissor": [17, 19, 320, 180],
+  "base_sha256": {
+    "arcade/camera/camera_2d.py": "75878ad5777108667453d1385671294d250b0d004b614555394f1b93ffb06cf7",
+    "arcade/camera/default.py": "2a7e2f3537a64b5764228766f616e51263a83331eaeab2afd6f6d3bbc6bd03e8",
+    "arcade/camera/orthographic.py": "cd9b8895c22fabc09da6291b9039889d9a1fdc06ad8907b06555dc690d50a622",
+    "arcade/camera/perspective.py": "ecb5113d0b9c77e2de2fc2ed77459d5b84e4058f64197315f4db13e8e93e49ea",
+    "arcade/gl/backends/opengl/context.py": "2470825bcf5d91711980c9748baa462153ac2f79fe7357e2e8d2b6b172bc71b4",
+    "arcade/gl/backends/webgl/context.py": "dd18073f2278b5cafad9e15be2bf72d3a696236c91b49fb1d1303c9b142c6b2d"
+  },
+  "immutable_sha256": {
+    "output_contract.json": "882592eea5f1783af8c05d5f3980b61927fecccadcbe4156f3c64393b05d5e1a",
+    "tools/check_camera_integration.py": "e0c2730568cdf27ca5e0cacfdd4ddad2ae25d9079e05290288cbde84eaf24682",
+    "vendor/project/arcade/camera/data_types.py": "5448abb1f64fa300003002d4e7ba741f399e06170f97ea69a82758fef711553e",
+    "vendor/project/arcade/camera/projection_functions.py": "210b50e41c343a352cfa47dc92ceee5b5e36dc9e9d0a7e70680e8790fc10a067",
+    "vendor/project/arcade/gl/buffer.py": "9d1849f827cc8a5bc4da919615a336906544bbcb4a86f2a77b5979264a354a25"
+  }
+}

tasks/candidate-1271-media-games/tests/fixtures/pristine_env_manifest.json

@@ -0,0 +1,255 @@
+{
+  "artifacts": [
+    "repair_report.json"
+  ],
+  "detect_deletion": true,
+  "files": {
+    "Dockerfile": "fdc4026cc5e1301ffb6bdfd12f61c9d1591909ddf05501b43ef6ade47d01641f",
+    "output_contract.json": "882592eea5f1783af8c05d5f3980b61927fecccadcbe4156f3c64393b05d5e1a",
+    "tools/check_camera_integration.py": "e0c2730568cdf27ca5e0cacfdd4ddad2ae25d9079e05290288cbde84eaf24682",
+    "vendor/project/README.md": "8691237bab1d39b6a6588b517d7ec347ae84d4e2c1c15f324cfea4d6f8c32381",
+    "vendor/project/arcade/__init__.py": "83eb914c7830e3e13439ffb25f97b1d491aa3ec56def292f8f13e27de9112ace",
+    "vendor/project/arcade/__main__.py": "bc83487cfc66a56b2e035b05dcaf3946d1a32c660f92464005b31abab3f88edf",
+    "vendor/project/arcade/anim/__init__.py": "f0b51c257706e4aa7b7055f186ffec4ab41cfecdcba59aab8dc1e3f09810964d",
+    "vendor/project/arcade/anim/easing.py": "5b0c14aaccfba1b5111f6177230763a65a92bc52897cbd37c431859153e7d13b",
+    "vendor/project/arcade/application.py": "b0efac623bfc9531298fbe270f4dc6860be308a743797d94d9926ecc6931bb39",
+    "vendor/project/arcade/cache/__init__.py": "5ea65253f700e27bfb87f132513ed531110cf284354b44fa7d2d5ed405e1274e",
+    "vendor/project/arcade/cache/hit_box.py": "09a95ef0d6c100c0531d8dba758580265056643176e03274f8560a3f25f34880",
+    "vendor/project/arcade/cache/image_data.py": "fa090def75a2575cb21ab172ef528064f5e2cd32bc89e23f186e19802a46f843",
+    "vendor/project/arcade/cache/texture.py": "4113b10e24b113e650a2631f48d67e776b609c828c6acd69edf3f1ef8747e2dd",
+    "vendor/project/arcade/camera/__init__.py": "dd00fe3272d286366d7c167a7d13e234e99a6af8df7fd22d4c8fbd16ede1cdfc",
+    "vendor/project/arcade/camera/camera_2d.py": "75878ad5777108667453d1385671294d250b0d004b614555394f1b93ffb06cf7",
+    "vendor/project/arcade/camera/data_types.py": "5448abb1f64fa300003002d4e7ba741f399e06170f97ea69a82758fef711553e",
+    "vendor/project/arcade/camera/default.py": "2a7e2f3537a64b5764228766f616e51263a83331eaeab2afd6f6d3bbc6bd03e8",
+    "vendor/project/arcade/camera/grips/__init__.py": "fa4648f1ad335d722d33fbf3bef28bfbcd5ec90ccfc60e0e55b72017335d1154",
+    "vendor/project/arcade/camera/grips/constrain.py": "c86f2c33cd699ef1cf0a9ccad8ea266a2936d733d8cd141ec037d0bdc0a9df5e",
+    "vendor/project/arcade/camera/grips/position.py": "25bf549e01a31888056393d1398effb36c0522bbcfc415ae36bee042fc1c8cb3",
+    "vendor/project/arcade/camera/grips/rotate.py": "29bf877f3e1ccbb919cc81a5c574131413f3341923b6b76e97c866543461a5a8",
+    "vendor/project/arcade/camera/grips/screen_shake_2d.py": "7347e197344ff52279a9c0c9aec6f0abaf7e58088b09f80f70b881de65266a60",
+    "vendor/project/arcade/camera/grips/strafe.py": "6df9a9a6c3659cb0e15b5afa8e13bc7620208e2b160b315aaf927d9a1bc16655",
+    "vendor/project/arcade/camera/orthographic.py": "cd9b8895c22fabc09da6291b9039889d9a1fdc06ad8907b06555dc690d50a622",
+    "vendor/project/arcade/camera/perspective.py": "ecb5113d0b9c77e2de2fc2ed77459d5b84e4058f64197315f4db13e8e93e49ea",
+    "vendor/project/arcade/camera/projection_functions.py": "210b50e41c343a352cfa47dc92ceee5b5e36dc9e9d0a7e70680e8790fc10a067",
+    "vendor/project/arcade/camera/static.py": "b0247d4d6efc7b5714472dcf2380969f25dffa8f5f7896e9f340a5809073e024",
+    "vendor/project/arcade/camera/viewport.py": "81f0610689479b1dcc63a4277395f5826b33b33e0e7d956ea39b67b4fea922aa",
+    "vendor/project/arcade/clock.py": "03491bd7b2f6bfdad81bcea814d74ec53fe83f1444b01bcec5983a9f1a8fffea",
+    "vendor/project/arcade/color/__init__.py": "be137ee7d5597fd76a97b5a2f0037c044ff4954ac9ed9eec1463b066d6de24fa",
+    "vendor/project/arcade/context.py": "2a419296a04cba56b310ffa87134e047f7f54bbb870ef8f15d4d27889856eb20",
+    "vendor/project/arcade/controller.py": "cd99c18fdfa46e446342f61e9720a237609593c3b40efc57ec34f3d0246c3f67",
+    "vendor/project/arcade/csscolor/__init__.py": "9477008ecac9f1c31fbb2b73ef11b98470f085ba99e12470f42b41cb67507644",
+    "vendor/project/arcade/draw/__init__.py": "90833d89d69228826133003dfe87138526facbc32db99c533b1aa24adaa82a25",
+    "vendor/project/arcade/draw/arc.py": "157f02fd989b8d98b4ae44a5d1228bbe8f8001f6491f6a64c27bf836ef34c90a",
+    "vendor/project/arcade/draw/circle.py": "daed7c18473bca66680e4586f0ecf58a41040296d57280af0947bbf1ae15c36c",
+    "vendor/project/arcade/draw/helpers.py": "c57f6d44ee8b43bd1ad64357fb05311ad774da3251d23a4cb53fd0ee7520b233",
+    "vendor/project/arcade/draw/line.py": "2e717481bd4782bd6ab75935fff9cdad3aa36826de45f53369b028e796d500aa",
+    "vendor/project/arcade/draw/parabola.py": "ba83837992345577c54574d4f515442b9ccc6104f231078c2d498f878d5ace3d",
+    "vendor/project/arcade/draw/point.py": "d1ea8796f61323b70bc91dfecfac9c617b623bdabdbdac384f458e10d46feb44",
+    "vendor/project/arcade/draw/polygon.py": "703b9c787247da44eeebeabb91ea23aa6008f38d7fd93099a89b77e0da622d5e",
+    "vendor/project/arcade/draw/rect.py": "99e14c44e21f3354622c01a9eacfca7293c5fc2398000110cbe9fef4bdb8736e",
+    "vendor/project/arcade/draw/triangle.py": "edd316fbf7ac951c995dfa23867ae32e5fbc4fcbd2d79e3ce1b4071138aafc3a",
+    "vendor/project/arcade/earclip.py": "6d943204f38c59a42a1d3a9858baf806541916ced6550fa198f6b190abdeadb8",
+    "vendor/project/arcade/exceptions.py": "b06703564372247c106604764a8d7706b67f8f6c692ba911d9653f8f5d789150",
+    "vendor/project/arcade/experimental/__init__.py": "c1799dacb0d56c1799d4e4313089b4550d898b73428a9632a0c534b290071a35",
+    "vendor/project/arcade/experimental/atlas_render_into.py": "250e5c31f8614c62d20bc49aa0c1a4777de60a93162fe55677340df9f2307920",
+    "vendor/project/arcade/experimental/atlas_replace_image.py": "a8b7afffb7355a3958385281023b57ad23c94253b15a4e1b78cfcfe3491c0de1",
+    "vendor/project/arcade/experimental/bloom_filter.py": "497370eb73401688e1119f7e6682cef2782a3d8b97a2f18da597dacfd05995d5",
+    "vendor/project/arcade/experimental/controller_window.py": "89599dfc4927dbd3c0bedb6a35273ff6f410f0b8949f6c0a57398d9a06ab881b",
+    "vendor/project/arcade/experimental/crt_filter.py": "1b541f508e5801b88f70f4e4c5cf9bb3dfd497e887be3888b2628a008307bb8c",
+    "vendor/project/arcade/experimental/gaussian_kernel.py": "05437f4071424a0f88e91859ebd5f89861b3c197069c5681ef9a17a052eed9af",
+    "vendor/project/arcade/experimental/geo_culling_check.py": "2ee17df10e6cac35132352d8b4dee05c95c3d3b88308d8124efd167215b098a8",
+    "vendor/project/arcade/experimental/input_manager_example.py": "510f32044c256255da3dcdd22597ffb7d9da10bb5196dd67dae0ef4ba6b669a3",
+    "vendor/project/arcade/experimental/perspective_parallax.py": "ac12efcaa6ebbe9cc973221c6360e20e06b005bee8a43a041d81b2b8ee23ceea",
+    "vendor/project/arcade/experimental/postprocessing.py": "eb1e9c96974614e4d707975f961fa23e589a0f4a86aae9a1e06f3b5286bc7a9c",
+    "vendor/project/arcade/experimental/profiling.py": "7ad21e352f6f04b91987feb395df5a6573991c81aaa3f04bafcde52715f91eeb",
+    "vendor/project/arcade/experimental/pygame_interaction.py": "53c9dcae863366239545fafedbfd371f943fedf7ea264cb405f9d21824ef2378",
+    "vendor/project/arcade/experimental/query_demo.py": "57b6e6d0b211fcf5decdcb86f98bd9a3ff15cde562f7dbaa70e5edc763695faa",
+    "vendor/project/arcade/experimental/render_offscreen_animated.py": "f4113a22f4d727ae702bb12b033d540976ea7478c5a76e97b05f49e80ba327b6",
+    "vendor/project/arcade/experimental/shadertoy.py": "019a26e66463dd67c7949cbf017758faa489e9d35d08665d32adfc8aba66bdf6",
+    "vendor/project/arcade/experimental/shadertoy_demo.py": "aaf71d62a17b838d8760e7207445eb43030ca42be05c516238f45a5c0c77bbcd",
+    "vendor/project/arcade/experimental/shadertoy_demo_simple.py": "a369097951366c7c02e11a6f60624f11f2c647837044eb77547e8c904a2c1536",
+    "vendor/project/arcade/experimental/shadertoy_textures.py": "debf9561c26f6290fa6eb65a2942d31d1a37d1f29ea8d67c8bafe8ef66a44afb",
+    "vendor/project/arcade/experimental/shadertoy_video_cv2.py": "170f5fe91b7355f0558df10c55fa66dc64e871b461cbbd63d400ed323d662e7c",
+    "vendor/project/arcade/experimental/shapes_buffered_2_glow.py": "a9d283e7b3dfa5200ad339b45bb043a86a35a8ef604e30563256f07c1923ab04",
+    "vendor/project/arcade/experimental/shapes_perf.py": "014cce45c9fd1813f66075dc91e839f20a135065da7034dd3c2fd7bc7e1f0a38",
+    "vendor/project/arcade/experimental/star_nest.glsl": "dddc0d8afdb2cd775f8442a273d3491e6981715539c463df823d10e05a042d6c",
+    "vendor/project/arcade/experimental/texture_transforms.py": "dc216dc7b83db3104a5aa145bd846266b5ff08dce5d2bd073e3adee4e80e9ff4",
+    "vendor/project/arcade/future/__init__.py": "3c7e6210d632b179fe365d126e13bb1b7a9c6c78a8754ee00d6c66633aef69fe",
+    "vendor/project/arcade/future/background/__init__.py": "82d33ff016f2d5aea30a135647ba22ed3600e60d6b9c2cadf52ca94364f5995f",
+    "vendor/project/arcade/future/background/background.py": "aadf84e473f40193efc304824fae7b9dc161e485041c70f23720e996e22f342a",
+    "vendor/project/arcade/future/background/background_texture.py": "dab2ddfc3b90b71dacb8ee56dfe1e0391c3a70e3cf71c5c79cf4186adcae4014",
+    "vendor/project/arcade/future/background/groups.py": "3ab6be0ddbe2c5dd3a8063e2583a2264fdfafa88c14b3f6ed1bea6c2f4c4859c",
+    "vendor/project/arcade/future/light/__init__.py": "ca37126fb23b4bced8789635c338c456a9b1cf9bf864c1c16c92cff230218a7b",
+    "vendor/project/arcade/future/light/light_demo.py": "1df521270432aa8b2f5f7d3dd2c85fed5c465e342e9abb1b5b2b9bbc50ea0fbb",
+    "vendor/project/arcade/future/light/light_demo_perf.py": "5fd83cbc4c54647b51b417c8c36c76e92d8c79e7b9eca8bcb2e639841b07bd03",
+    "vendor/project/arcade/future/light/lights.py": "7b1c58dac662464c4718749c5cf3111ffe9f53a4f402635938cf6ff9f253260f",
+    "vendor/project/arcade/future/splash.py": "5bb82bbac03ee9afb6331b241074984f1f025e8e89474b0dfed33ba16b0e9560",
+    "vendor/project/arcade/future/sub_clock.py": "93ced605b8a841ad1745a329c211364c3d9245e33529a4247485e7fc352849a8",
+    "vendor/project/arcade/future/texture_render_target.py": "b6481daf8a9046f8b8a791dd5d4473574bac1bce5d22ab1226ea41b3c8c5800a",
+    "vendor/project/arcade/future/video/__init__.py": "df546af31fbc9244ca73f11821fd1be833588344bbbca616893f532aa10f2fed",
+    "vendor/project/arcade/future/video/video_cv2.py": "ab2ad4a0a83082c5258b2101dd454abf7655b0d03968cd1a864a4068ea31b7ee",
+    "vendor/project/arcade/future/video/video_player.py": "68e7861f40c238551d770770b7d617fc269e01052abb9eed35076dc68f948309",
+    "vendor/project/arcade/future/video/video_record_cv2.py": "19d5a4f06244b1db57ff7ff2b13665d96bf6bdf558c3fac218212311715faea4",
+    "vendor/project/arcade/geometry.py": "01a76d814d64bef44443331e42325416b54bac4459ccfb5502efdadd421562fd",
+    "vendor/project/arcade/gl/__init__.py": "af8c93b542cc6e5514985289acb631aadbab5f6b2c39726c17dc27186dcc6f7e",
+    "vendor/project/arcade/gl/backends/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/project/arcade/gl/backends/opengl/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/project/arcade/gl/backends/opengl/buffer.py": "c62bfb087f58a430093b9250913f047dcd2e86a080b1ab40ba1b3007036e3827",
+    "vendor/project/arcade/gl/backends/opengl/compute_shader.py": "458b373a788c648bbc72915a51f1960dcfe9cbedbd53081c3b1ea776c5e8e1e6",
+    "vendor/project/arcade/gl/backends/opengl/context.py": "2470825bcf5d91711980c9748baa462153ac2f79fe7357e2e8d2b6b172bc71b4",
+    "vendor/project/arcade/gl/backends/opengl/framebuffer.py": "e872cc66344f3773b4754e2baa493270735e398921a6ce9073458542f30a1f68",
+    "vendor/project/arcade/gl/backends/opengl/glsl.py": "251c57127c18c6000d7ab7cdf22dfae64fafcf95c977f11ea6f4947dab16bb0c",
+    "vendor/project/arcade/gl/backends/opengl/program.py": "77aadf012f5642f6c7ce2a321fedfeacf3533ded0b74de255dacfeedef08a9bd",
+    "vendor/project/arcade/gl/backends/opengl/provider.py": "3d0ec3b7e9d2c3b369e3c270e8d5a4878b1bc4f0da5dd155b3456def2d130f7c",
+    "vendor/project/arcade/gl/backends/opengl/query.py": "3d08b82bc9a0c71223aee314b9689adac16a609e9bd439447bfc2300275758d5",
+    "vendor/project/arcade/gl/backends/opengl/sampler.py": "ce988f1eba0a43e4b11bdec06ae8f4cfdc9a4dc5a2cf482ac6baa6ba0fd37864",
+    "vendor/project/arcade/gl/backends/opengl/texture.py": "126f2fd6ef228e62e0783827920839b96f81bdedae4093dd1daad6cb658bf7e0",
+    "vendor/project/arcade/gl/backends/opengl/texture_array.py": "ac0df0c4ae448a2b9270481ef1ad561590a2afd1d377bf2b74b176dbfcffa979",
+    "vendor/project/arcade/gl/backends/opengl/uniform.py": "5a7ed82f91e48250b6095be15b8ddd2c6a32c0cb94778887e22eb0b32d7040d6",
+    "vendor/project/arcade/gl/backends/opengl/utils.py": "a0f7fd81ff544b61bd0dbe3cde71a33d021118c4aee98bbd9cb4c9e97462e1cc",
+    "vendor/project/arcade/gl/backends/opengl/vertex_array.py": "398f64386a4596e2855e7daea56a352597543e802b937c4698bb8c10707bf106",
+    "vendor/project/arcade/gl/backends/webgl/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/project/arcade/gl/backends/webgl/buffer.py": "a0ee6d72a851f897c3d1c764a08b12db399bed0b170a3a317fe027165acd2922",
+    "vendor/project/arcade/gl/backends/webgl/context.py": "dd18073f2278b5cafad9e15be2bf72d3a696236c91b49fb1d1303c9b142c6b2d",
+    "vendor/project/arcade/gl/backends/webgl/framebuffer.py": "819e66224117a5059107c58a5cfa3da0b6d62cad156ac6c2fe18421bf275c8a8",
+    "vendor/project/arcade/gl/backends/webgl/glsl.py": "61c33478d2162e240a1b27dcdca7b51fbaad18f281ab2b77fcfe8609400b135d",
+    "vendor/project/arcade/gl/backends/webgl/program.py": "a26f5fa009d20299c240d6de0e4d5e5336003990fd2a0ba7d1e7f82e417d8278",
+    "vendor/project/arcade/gl/backends/webgl/provider.py": "7e1922add90eaa20d8b864821750309f93b18ac594fac436cf8ff2a609795648",
+    "vendor/project/arcade/gl/backends/webgl/query.py": "01de30c1d4fba4cd13546e2dfabf5d26e8313c347ee162e39db81d3978fed762",
+    "vendor/project/arcade/gl/backends/webgl/sampler.py": "72942455fa2322848cd431bfb2858c549409a672a9a3d0968ec16f8f5202aad3",
+    "vendor/project/arcade/gl/backends/webgl/texture.py": "29fa3fad3906c8ca592e2f18fee4f75d54e8548a1215f989bedea858c28e326a",
+    "vendor/project/arcade/gl/backends/webgl/texture_array.py": "a00a836d742c2999b88259bcd866619980d0d925fa2de506721146dbd2be7ed5",
+    "vendor/project/arcade/gl/backends/webgl/uniform.py": "b023631fa61d265ccb472e9ac631128bcdeef62362c6a18ded5bd76aacbbf771",
+    "vendor/project/arcade/gl/backends/webgl/utils.py": "9220cc7b4c72180dcc66cf019afb907c00a1514d39e31f7cb88b80e2b79ce8a3",
+    "vendor/project/arcade/gl/backends/webgl/vertex_array.py": "b32ff07acb169c623ac834a14746f8854ca654b05f9ca09fc70e794b3a1e24c4",
+    "vendor/project/arcade/gl/buffer.py": "9d1849f827cc8a5bc4da919615a336906544bbcb4a86f2a77b5979264a354a25",
+    "vendor/project/arcade/gl/compute_shader.py": "154b1b047122aac6e3f0753d6ed5e626fdce8346e8ad9fe57ef47defd470c6e3",
+    "vendor/project/arcade/gl/context.py": "5f11dc19d67f38ba1652dce015c7f6f9938051ab8aa373549f312d470a26f741",
+    "vendor/project/arcade/gl/enums.py": "32e4a12903e282b26f74888003c5d24ab514deaa1c25580ecabb11aaefca8243",
+    "vendor/project/arcade/gl/exceptions.py": "0bb0b6e4056ddf77c1e23bd3fd04c80d8e1fc1e31d4dd66d64cb8efd2215e120",
+    "vendor/project/arcade/gl/framebuffer.py": "ceb7842cadd38d45d024d7e334af1bae9c2fbea03ac02588f1a1de69a624cd76",
+    "vendor/project/arcade/gl/geometry.py": "4bdeec67228c4bd9e06e80a375cb75375219dc94b264328d2b95798e016a45b7",
+    "vendor/project/arcade/gl/program.py": "d98652087ec2bec32c1971dc3fb17f9befdedab57e816f5f4ec2ee7ec5af4ed2",
+    "vendor/project/arcade/gl/provider.py": "121ab346d83c856c19173609881b10abf6f5e261cbcdcfbf54970e5a953b9db2",
+    "vendor/project/arcade/gl/query.py": "c907c844471eccd7d0fd52fc47548f51f93095e3fbbdbb845e3645bf7c222f48",
+    "vendor/project/arcade/gl/sampler.py": "1e93d349a425f8ada7794b9e714ceae19ca6ee7111d31fea2ef2f65c431e4732",
+    "vendor/project/arcade/gl/texture.py": "dc29f1f4f3adbe8c666305591820f0faa82a43a164e1a81c145fa8e9544f4c3d",
+    "vendor/project/arcade/gl/texture_array.py": "7b5e82179e329e8f48ae96e264c4029ebe12ca0a1adc1558a9de699ff07219d8",
+    "vendor/project/arcade/gl/types.py": "9da5c0ea5960ef46ba302807bb922ddde46ffff16ea1378562e19234400e0d6a",
+    "vendor/project/arcade/gl/vertex_array.py": "a91553bc11b733f34619f7802718ccf6d109ae0357f0c9be6f53c462fa45b1db",
+    "vendor/project/arcade/gui/__init__.py": "d078ca7c564ae2cf2fe72c7cf4987c5b23e02a4922bda9b76822373b29ff21c0",
+    "vendor/project/arcade/gui/constructs.py": "deb107d83e7f3d4d4bfdcb68acb3cbbeafef263f3ad994408a5883a29da19bed",
+    "vendor/project/arcade/gui/events.py": "4edf5e63d5b041b175fa11886c95da8aff8cd9b59bd8de6e0cd462d183ed74d1",
+    "vendor/project/arcade/gui/experimental/__init__.py": "4ac92d3a1dffb801677f0f1d04d08d0d3e1f49156538b10a4971d88901b34069",
+    "vendor/project/arcade/gui/experimental/animate.py": "f607c3d14c867eee1cdc4026e75aa1c4cc7b55c0fca2f29442a0d43aa6e27233",
+    "vendor/project/arcade/gui/experimental/focus.py": "286e8c9e5ea9b102cd2ee852b1a38c19f81864451529e48926d2346f2297875f",
+    "vendor/project/arcade/gui/experimental/group.py": "19b74f961fb5feafdf89217cca63d894702eed91e27d92afe5d1255dde740c68",
+    "vendor/project/arcade/gui/experimental/password_input.py": "0527a2ed05781af8301a204066f181e86cc4bc2ce148ab8171d1f75a4f875b57",
+    "vendor/project/arcade/gui/experimental/restricted_input.py": "26b284c7d26e53d8c1527267933c9d41575d236f562171af2d5ba6cff6dccebe",
+    "vendor/project/arcade/gui/experimental/scroll_area.py": "7c32f2a41c3c1e82747e4f72b8d1af82647a1ccf7928009fdbab863d5ad25725",
+    "vendor/project/arcade/gui/experimental/transition.py": "b4ea5534759b6006eeab9d3115dda3d27e0ad4b67bf1a1034a232492a7eda5ff",
+    "vendor/project/arcade/gui/experimental/typed_text_input.py": "fa0729f4d03c3552bafe010a475e4c04f3269898bd355dde83e387e0ef9f5bed",
+    "vendor/project/arcade/gui/mixins.py": "eaaa8c33dfbf452001b2115828e9b3dc32b0b5b8230887617d5cfe1ba8783caa",
+    "vendor/project/arcade/gui/nine_patch.py": "447158336768b46d40f1e3e4dd7d64aae929e5f18259af7dd6e234c333b4222c",
+    "vendor/project/arcade/gui/property.py": "6a158f1825772eaf050c2ab7e03dbe59d2df0ed1e8c0821444ca6a7ebbb871ec",
+    "vendor/project/arcade/gui/style.py": "0938d087745d19e7c941ef4e47867d79b19ed22441067859a390b6c3be856e1e",
+    "vendor/project/arcade/gui/surface.py": "e9f16864412ffa25103ba23a1e3679d95369523fa8965db9f5783f9dddad5c13",
+    "vendor/project/arcade/gui/ui_manager.py": "428842164988b7352bc95ab0910dfdafa6c6d8ac519efe3ce9aa359258ff7164",
+    "vendor/project/arcade/gui/view.py": "e0e5024ac2dc6f67b455a9450472f59fdc4519db48b36982f4c3c557f6bc8eb9",
+    "vendor/project/arcade/gui/widgets/__init__.py": "5f195cd718ccf16d454677c23cd344fb55f93b468c0af11f0142a36b390e5417",
+    "vendor/project/arcade/gui/widgets/buttons.py": "7349a4d5b4175b7c121e036b3c453ac1b4e248b812e4e3a31b666ebe5ae64cb2",
+    "vendor/project/arcade/gui/widgets/dropdown.py": "663b1d13633691cc839a7d93806fa434b696749f998e6ad29a08f15c400d5375",
+    "vendor/project/arcade/gui/widgets/image.py": "4ea450d50c387f5b120a15c90fb134c14b8f91b6dcf70c70bf37a535059c914f",
+    "vendor/project/arcade/gui/widgets/layout.py": "24effd242de3dbc7e328207c9043ec12c50e3187f481a013028f7a5d461df9dd",
+    "vendor/project/arcade/gui/widgets/slider.py": "b8a5a2511e9b8f2f36a78ae97a87ae95ba7b23f445cbc37d4088d2d0bb23d1ca",
+    "vendor/project/arcade/gui/widgets/text.py": "4ac2bc5d8895ca0b9b1caa644bafe4a6b58eda4a9afbc4f9f2359c01f1ca1b46",
+    "vendor/project/arcade/gui/widgets/toggle.py": "1dbf1c06686e33775cfa7c7e139443ba3fddfa657c20b2f96875815e780b2e64",
+    "vendor/project/arcade/hexagon.py": "ce34ac7600ec9a50c206fb9f69411cad2608a9a665b568b3b096e9abf7ccbf9c",
+    "vendor/project/arcade/hitbox/__init__.py": "1a8d6830b9a48ace63471e2ebf9760fd6d1e6cf34aaa3b09b1dd0a9e05d3fd95",
+    "vendor/project/arcade/hitbox/base.py": "8df96c1714f931ec4cc45471b1d8b5d2435a55782d0aa8831811f40d42eb48c6",
+    "vendor/project/arcade/hitbox/bounding_box.py": "51603c72227964b47fa45e90aa4befe82564f731bcc66ae52e8e223b2ddf7be8",
+    "vendor/project/arcade/hitbox/pymunk.py": "aaa6d234c7676fe1e416994012d6b15d48e8739d677681b816cddc3bffa67f81",
+    "vendor/project/arcade/hitbox/simple.py": "cbd648a8e28604a0a92ae28bc4695533386af9bef466124a8a0715b97b8050e4",
+    "vendor/project/arcade/input/README.md": "5cd5424b88d4aa93512965ae904c514acf9d6e9b69ac2fcf4f2b946cd37f9a08",
+    "vendor/project/arcade/input/__init__.py": "f92d3f380d13576bd1934de6ecba898395cfc888e80c8bb689791df6b9a6a17e",
+    "vendor/project/arcade/input/input_mapping.py": "f277d7c045bf90fd700158f7563b4358547be2b3f0b40b144f25fd7ae9ce0343",
+    "vendor/project/arcade/input/inputs.py": "815c9b9eb1ad2a14de5db086288d84ea029d300350bba0e931334460fb145c5f",
+    "vendor/project/arcade/input/manager.py": "ee696d7f65d0a3b1a9732bca5deac2cef3c28e74832bd4d5c8eebddef88acf72",
+    "vendor/project/arcade/input/raw_dicts.py": "12e798f3e01aa907ad4dbc3e050b8a5c9286f56121666f9b3373d721a44e3f69",
+    "vendor/project/arcade/isometric.py": "bef065d6bcdd4778762975e46c1a212230e33dc88bd2dcf0225bcda4c3579104",
+    "vendor/project/arcade/joysticks.py": "af44f983a29928ab3a3ff42a555388ec55a558fad6122712123e5c6a878678d0",
+    "vendor/project/arcade/key/__init__.py": "370d21c3906e63f7a87a807979bc243e98c125f066af5f09701579c44ac43b87",
+    "vendor/project/arcade/math.py": "a48cabcc41ebe08eff23fd3e1b1e4c125fb0b87bba00e3c757adb494c98f9aa7",
+    "vendor/project/arcade/particles/__init__.py": "9c36fc2dbd30c5f824e9ca2567542bde0616ef45363a31865c0afeb5581c0dac",
+    "vendor/project/arcade/particles/emitter.py": "b547c984db4431dc5cc240d061c620e76a9c136555ecca01a731f248eaf3fae1",
+    "vendor/project/arcade/particles/emitter_simple.py": "be3259ee1217624d438f6762e9b11c288938bae5bb66201edfa7587e1f2d4b88",
+    "vendor/project/arcade/particles/particle.py": "14a25a4f0d8a0b40141e4a85ef6633bcbd89cb1336a4cc04e7a468f9d45ff7c6",
+    "vendor/project/arcade/paths.py": "80d74c2dce3002f548909785da67a6159475b467ccda860efe3fb28230e440b4",
+    "vendor/project/arcade/perf_graph.py": "4e727f1e61410141c905643a0ce7b7d17fa090178eeae04c18b5cca56934217c",
+    "vendor/project/arcade/perf_info.py": "05f954736c75e8ee90873cd7a2314e58a5d61793a9642b52f42861662f6c40b5",
+    "vendor/project/arcade/physics_engines.py": "d68fdc819bfed448e1b92d3455cc802c2935112f4ec03ff62b6d94db1de79891",
+    "vendor/project/arcade/pymunk_physics_engine.py": "e351e762ea61d0a53f7dadb01ee07ee0995586fc61aa77af36df910f9bb5053c",
+    "vendor/project/arcade/scene.py": "d04d270742a68795de416aef329eaded839ad2b6de29789b8d501a6a2aff7cce",
+    "vendor/project/arcade/screenshot.py": "a6d04af9f0d3791fa6a8c0bfc90762684a8cb1304ab76b02c1f48c04da000293",
+    "vendor/project/arcade/sections.py": "ceb00f7499b7b850ca97dc93a7310dfe14b558d1ae7083b60f6275e12d5f01dc",
+    "vendor/project/arcade/shape_list.py": "13fae49e036357a4829caaa021887b72792d15d229b3d2bdd305c52906c72ab3",
+    "vendor/project/arcade/sound.py": "68cdb8131dae3a5d10b82bfd2609c355a285a3cdb9fd987500875baedb658783",
+    "vendor/project/arcade/sprite/__init__.py": "8f470d422d00e5801ce733c9c443e16f510b3d5e34f77f53f674c79ea97ed050",
+    "vendor/project/arcade/sprite/animated.py": "dc75b118178f35f7c16e94e86d71e63a058f2556ab12e25ae52f316167f24243",
+    "vendor/project/arcade/sprite/base.py": "6146cf410dba3f2fd98b93f39849e3128ce0394eff9b3aae4352d9080203b88c",
+    "vendor/project/arcade/sprite/colored.py": "1b014512d0f1fba8fe3e23d6b5765f322811fa4acf1a844377211b54ed328770",
+    "vendor/project/arcade/sprite/enums.py": "cd7f1aa47af129dc38cac9355a0d94e93d0263e79db81557789070080058e2c1",
+    "vendor/project/arcade/sprite/mixins.py": "fe5105135734ad00c20a31ed995ff9440a6c09f9f91fabd30d88d56586ddc3f8",
+    "vendor/project/arcade/sprite/sprite.py": "b5fd0afee9000886fb435f8aa4388d220f6dd484c5c939de735c004f83cfdd05",
+    "vendor/project/arcade/sprite_list/__init__.py": "fcbbf5d0b1f0e24c9deb278bdfb3c228ca15c93e7617bf06925c2e1d1062e1d7",
+    "vendor/project/arcade/sprite_list/collision.py": "8142d9fad46a408f8fa341a5d5274570374e705d9db4bba107b09f1716e25f2a",
+    "vendor/project/arcade/sprite_list/spatial_hash.py": "e0b36a15c5cd8c22dc4d81bcd736c391ca3031f749851d359019880aaa2f67b0",
+    "vendor/project/arcade/sprite_list/sprite_list.py": "c29849ef67f186c84f3b5a8b2c14f47622838018d02fc793a1ab37a76e013d26",
+    "vendor/project/arcade/start_finish_data.py": "6f72e2b4a83c05b8f753410d20cea40d7720360b083ef89fd45b8826d792a208",
+    "vendor/project/arcade/text.py": "c99f5d2b556cd78ce2aeb75a873da3098b7e6ab5cf17959d4ece112948e75666",
+    "vendor/project/arcade/texture/__init__.py": "9dd55a11c6209716443acd2ee3300ff730dc275932d758343a1de0349067d69e",
+    "vendor/project/arcade/texture/generate.py": "19f2ce73d9b33ce6abb9f2e0f0c75448c2ab8d031c19a509c0b4632ff13e40e3",
+    "vendor/project/arcade/texture/loading.py": "0fab90dad90cb57ab21b9073def9b42701f72e7d01c081ea45dd0d17c1d397f1",
+    "vendor/project/arcade/texture/manager.py": "7bcb57c64595a48a01fc6509cca7711461661fca77029a44b23d41dd8dd0f6b6",
+    "vendor/project/arcade/texture/spritesheet.py": "8e16fce9c86acd415bb0f6111bd257dee6131b35a51a3d3f5e142e9976b814e7",
+    "vendor/project/arcade/texture/texture.py": "7ec9f3daee965d7f77c3392bb125db1362a93ab5b37b86b1e0ca64fd992f6829",
+    "vendor/project/arcade/texture/tools.py": "08774782f05acdc8fab97ea7d8f295bae11206386ce268753a277b0554a0e431",
+    "vendor/project/arcade/texture/transforms.py": "e5fda86a85453cd02920abcf882f306719f4f82737daa865eb8a1ce8bcf6f396",
+    "vendor/project/arcade/texture_atlas/__init__.py": "5d46bbabdd596a3b62557675734b39b69765b7a914c64f2d070ce26c7f7dff29",
+    "vendor/project/arcade/texture_atlas/atlas_array.py": "235da5a5cce2a1fef98ec477c1e37b4be17d6f3bed36410388fdcee9234958dc",
+    "vendor/project/arcade/texture_atlas/atlas_bindless.py": "c5e4e0322e2e8d1952b5bf4988bcbefc3fd8a3c656230d4dea46a1d42eda5665",
+    "vendor/project/arcade/texture_atlas/atlas_default.py": "6dbe51dab94b49f7187e07e2519c8995ab79b2880da5ee77651d348603da5939",
+    "vendor/project/arcade/texture_atlas/base.py": "4e82b326c6faf6c830117e176ebf4f55169dc09a8c027bd013c9c5cb91973932",
+    "vendor/project/arcade/texture_atlas/ref_counters.py": "31d3007b9458b9ef283e1b5d87dfea5dd622ac36aca3647765b4a27218a9297b",
+    "vendor/project/arcade/texture_atlas/region.py": "03aba1589cc5a62c85da4517142b9c964f2b907bc840ee616477558a56162376",
+    "vendor/project/arcade/texture_atlas/uv_data.py": "60b61f7ef21d9406d7dd3e6ef179dd7baef490427212f06fa4dbd1107ea213b8",
+    "vendor/project/arcade/tilemap/__init__.py": "f1b38b6c6f2f53766cb543ac2855b71fa3317920efb1fe17919196a2ff62973a",
+    "vendor/project/arcade/tilemap/tilemap.py": "574869fdaa607bca21926179ed89e10aa38f8dcda149ee30b5c04cc85b146579",
+    "vendor/project/arcade/types/__init__.py": "e9f4326dc5171cdbbbbad9d27831ca78eb21d783473e2faa607e3de37b766844",
+    "vendor/project/arcade/types/box.py": "fd2bea1459417a2b13e2eb903004a6a2f459ec6f2376066b9a3cb94484de3244",
+    "vendor/project/arcade/types/color.py": "972950b98a3c3b55422c8a84ab2e4b7da0728130661bbf1d7bd4c0dc57630bc6",
+    "vendor/project/arcade/types/numbers.py": "1dfa2278f0f8963a4c85f587902e38053793e2ab16f238ddde4e93927c3248f2",
+    "vendor/project/arcade/types/rect.py": "f23a895c46c759d4d9355c4a1851bba862360ce4bb272dbbefa27e7a3f515617",
+    "vendor/project/arcade/types/vector_like.py": "1c495b4f9475b2894897a43f4222e73b1753edc975c417360bfbea52bb48072d",
+    "vendor/project/arcade/uicolor.py": "456868fc6de37a05552f6dd94db846736862b9043f956265feb1b44ded09b5df",
+    "vendor/project/arcade/utils.py": "cc9537d96c7f6752d1af3de0e6dc2887d8d4f935ac6ac4902ad6a1c3895f003d",
+    "vendor/project/arcade/version.py": "59f6d50292f5c1cf1d9ca0b46a3c11243937eaeac349357109539c540c843cb4",
+    "vendor/project/arcade/window_commands.py": "ee076ccd605f1f93422d4cdfdf9a3357b29e10f08599abb873c8acacfec65abb",
+    "vendor/project/license.rst": "9713d1f2b74f9c4af4f674dabe76053970cbd0065e8377bbcae10c4b27c70e4a",
+    "vendor/project/pyproject.toml": "b207089c1c905a10dd3b5287f1af358e592507bd54570e1fb73577800fc3b3ef",
+    "vendor/project/tests/unit/camera/test_camera2d.py": "80c0422a53c0bc4cdc6b02f43a27585a65174aa8866866104a1ae29bf50fb26f",
+    "vendor/project/tests/unit/camera/test_camera_controller_methods.py": "9797c79c9d977b4b4794da94df4cf07adbb5ccb87d05478396b8c6e44d8514de",
+    "vendor/project/tests/unit/camera/test_camera_shake.py": "00ca24936a59faf05e0e33815d4c47ee6bf988103f0a99768974317ba970aa35",
+    "vendor/project/tests/unit/camera/test_orthographic_projector.py": "d43dc466d0dbef0d7f82fdf6eb58e35c14d0a279aa39edc9bc9415b9b7e6a18f",
+    "vendor/project/tests/unit/camera/test_perspective_projector.py": "54a770be0a3b4a16ae0d955e26af697c1e57abb743fa006bf72ad3e6787ee0ae",
+    "vendor/project/tests/unit/camera/test_viewport_projector.py": "3720053104d45ddac6d0fa51cc1970d15c976b4fe9795cb9c48da283027ae4da"
+  },
+  "mutable": [
+    "vendor/project/arcade/camera/camera_2d.py",
+    "vendor/project/arcade/camera/default.py",
+    "vendor/project/arcade/camera/orthographic.py",
+    "vendor/project/arcade/camera/perspective.py",
+    "vendor/project/arcade/gl/backends/opengl/context.py",
+    "vendor/project/arcade/gl/backends/webgl/context.py"
+  ],
+  "schema_version": "tbench.pristine_env_manifest.v1"
+}

tasks/candidate-1271-media-games/tests/task_test.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+set -u
+# tbench-anti-hack-guard:v1
+export PYTHONNOUSERSITE=1
+export PYTHONDONTWRITEBYTECODE=1
+# Fail open when the verifier image has no python3 (node-only tests images are
+# excluded from the RL set but still verifiable natively): a missing
+# interpreter must not swallow the grader's own reward write.
+if command -v python3 >/dev/null 2>&1 && [ -f /tests/anti_hack_guard.py ]; then
+  if ! python3 /tests/anti_hack_guard.py; then
+    # Guard already wrote reward=0; the reward file is the grading contract.
+    exit 0
+  fi
+fi
+
+
+
+mkdir -p /logs/verifier
+set +e
+python3 -m pytest --ctrf /logs/verifier/ctrf.json -q /tests/test_outputs.py
+status=$?
+set -e
+
+if [ ! -s /logs/verifier/ctrf.json ]; then
+    echo "pytest did not produce CTRF output" >&2
+    exit 2
+fi
+
+if [ "$status" -eq 0 ]; then
+    echo 1 > /logs/verifier/reward.txt
+else
+    echo 0 > /logs/verifier/reward.txt
+fi
+
+exit 0

tasks/candidate-1271-media-games/tests/test.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+# Terminal-Bench grading: the task's own test script (task_test.sh here) writes /logs/verifier/reward.txt.
+# "-1" there is its crash sentinel: a testbed failure, so no reward is written (not scored).
+CWD=/app
+mkdir -p /logs/verifier
+# the task's anti-hack guard rejects files planted in the workspace: drop what agent harnesses leave there
+for d in .opencode .claude .codex .gemini .goose .aider.tags.cache.v4; do
+  grep -qx "$d" /var/lib/mimo/before 2>/dev/null || rm -rf "$CWD/$d"
+done
+cd "$CWD" && bash /tests/task_test.sh
+R=$(cat /logs/verifier/reward.txt 2>/dev/null | tr -d '[:space:]')
+if [ -z "$R" ] || [ "$R" = "-1" ]; then
+  rm -f /logs/verifier/reward.txt
+  echo "the tests crashed before grading (reward '${R}'): not scored" >&2
+  exit 1
+fi

tasks/candidate-1271-media-games/tests/test_outputs.py

@@ -0,0 +1,244 @@
+from __future__ import annotations
+
+import ast
+import copy
+import hashlib
+import json
+import os
+from contextlib import contextmanager
+from pathlib import Path
+from types import SimpleNamespace
+
+
+APP = Path(os.environ.get("APP_ROOT", "/app"))
+PROJECT = APP / "vendor" / "project"
+TESTS = Path(os.environ.get("TESTS_ROOT", "/tests"))
+EXPECTED = json.loads((TESTS / "fixtures" / "expected.json").read_text())
+
+CAMERAS = {
+    "camera_2d": ("arcade/camera/camera_2d.py", "Camera2D", "orthographic"),
+    "orthographic": ("arcade/camera/orthographic.py", "OrthographicProjector", "orthographic"),
+    "perspective": ("arcade/camera/perspective.py", "PerspectiveProjector", "perspective"),
+}
+
+
+class Rect:
+    def __init__(self, *values):
+        self.lbwh_int = tuple(values)
+
+
+class BufferRecorder:
+    def __init__(self):
+        self.calls = []
+
+    def bind_to_uniform_block(self, **kwargs):
+        self.calls.append(kwargs)
+
+
+class ForbiddenRawBackend:
+    def __getattr__(self, name):
+        raise AssertionError(f"raw backend API was used: {name}")
+
+
+def extracted_method(relative, class_name, method_name, globals_=None):
+    path = PROJECT / relative
+    tree = ast.parse(path.read_text(), filename=str(path))
+    class_node = next(
+        node for node in tree.body if isinstance(node, ast.ClassDef) and node.name == class_name
+    )
+    original = next(
+        node
+        for node in class_node.body
+        if isinstance(node, ast.FunctionDef) and node.name == method_name
+    )
+    node = copy.deepcopy(original)
+    node.decorator_list = []
+    node.returns = None
+    for arg in (*node.args.posonlyargs, *node.args.args, *node.args.kwonlyargs):
+        arg.annotation = None
+    namespace = dict(globals_ or {})
+    module = ast.fix_missing_locations(ast.Module(body=[node], type_ignores=[]))
+    exec(compile(module, str(path), "exec"), namespace)
+    return namespace[method_name]
+
+
+def run_camera_case(name):
+    relative, class_name, projection_kind = CAMERAS[name]
+    use = extracted_method(
+        relative,
+        class_name,
+        "use",
+        {
+            "generate_orthographic_matrix": lambda data, zoom: f"projection:{projection_kind}",
+            "generate_perspective_matrix": lambda data, zoom: f"projection:{projection_kind}",
+            "generate_view_matrix": lambda data: f"view:{name}",
+        },
+    )
+    ctx = SimpleNamespace(
+        viewport=(0, 0, 0, 0),
+        scissor=None,
+        projection_matrix="old-projection",
+        view_matrix="old-view",
+    )
+    window = SimpleNamespace(ctx=ctx, current_camera="old-camera")
+    camera = SimpleNamespace(
+        _window=window,
+        render_target=None,
+        projection_data=object(),
+        view_data=object(),
+        zoom=1.0,
+        _projection=object(),
+        _view=SimpleNamespace(zoom=1.0),
+        _viewport=Rect(2, 4, 800, 450),
+        viewport=Rect(2, 4, 800, 450),
+        scissor=Rect(10, 20, 400, 225),
+    )
+    use(camera)
+    return window, camera
+
+
+def recompute_report_surfaces():
+    camera_state = {}
+    for name in CAMERAS:
+        window, camera = run_camera_case(name)
+        camera_state[name] = {
+            "projection": window.ctx.projection_matrix,
+            "view": window.ctx.view_matrix,
+            "viewport": list(window.ctx.viewport),
+            "scissor": list(window.ctx.scissor),
+            "current_camera_updated": window.current_camera is camera,
+            "legacy_window_matrix_writes": hasattr(window, "projection")
+            or hasattr(window, "view"),
+        }
+
+    backend_bindings = {}
+    for backend, class_name in (
+        ("opengl", "OpenGLArcadeContext"),
+        ("webgl", "WebGLArcadeContext"),
+    ):
+        bind = extracted_method(
+            f"arcade/gl/backends/{backend}/context.py", class_name, "bind_window_block"
+        )
+        recorder = BufferRecorder()
+        context = SimpleNamespace(
+            _window_block=SimpleNamespace(buffer=recorder), _gl=ForbiddenRawBackend()
+        )
+        bind(context)
+        backend_bindings[backend] = {"calls": recorder.calls}
+    return camera_state, backend_bindings
+
+
+def test_gate_artifact_schema_and_source_tree():
+    report = json.loads((APP / "repair_report.json").read_text())
+    contract = json.loads((APP / "output_contract.json").read_text())
+    assert set(report) == {
+        "schema_version",
+        "status",
+        "compiled_modules",
+        "camera_state",
+        "default_projector",
+        "backend_bindings",
+        "errors",
+    }
+    assert report["schema_version"] == "arcade.camera-repair-report.v1"
+    assert EXPECTED["schema_version"] == "arcade.camera-repair-report.v1"
+    assert contract["output_schema_version"] == report["schema_version"]
+    assert contract["artifact"] == "/app/repair_report.json"
+    assert report["status"] == "pass" and report["errors"] == []
+    assert report["compiled_modules"] == EXPECTED["compiled_modules"]
+    for relative, base_hash in EXPECTED["base_sha256"].items():
+        path = PROJECT / relative
+        assert path.is_file() and path.stat().st_size > 100
+        assert hashlib.sha256(path.read_bytes()).hexdigest() != base_hash
+        compile(path.read_text(), relative, "exec")
+    for relative, expected_hash in EXPECTED["immutable_sha256"].items():
+        path = APP / relative
+        assert path.is_file()
+        assert hashlib.sha256(path.read_bytes()).hexdigest() == expected_hash
+
+
+def test_core_camera_context_routing():
+    for name, (_, _, projection_kind) in CAMERAS.items():
+        window, camera = run_camera_case(name)
+        assert window.current_camera is camera
+        assert window.ctx.projection_matrix == f"projection:{projection_kind}"
+        assert window.ctx.view_matrix == f"view:{name}"
+        assert window.ctx.viewport == (2, 4, 800, 450)
+        assert window.ctx.scissor == (10, 20, 400, 225)
+        assert not hasattr(window, "projection") and not hasattr(window, "view")
+
+
+def test_core_default_batch_protocol():
+    ctx = SimpleNamespace(
+        projection_matrix="projection-A", view_matrix="view-A", scissor=(1, 2, 3, 4)
+    )
+    projector = SimpleNamespace(_ctx=ctx)
+    projection = extracted_method("arcade/camera/default.py", "DefaultProjector", "projection")
+    view = extracted_method("arcade/camera/default.py", "DefaultProjector", "view")
+    begin = extracted_method("arcade/camera/default.py", "DefaultProjector", "begin")
+    end = extracted_method("arcade/camera/default.py", "DefaultProjector", "end")
+    group_scissor = extracted_method(
+        "arcade/camera/default.py", "DefaultProjector", "get_group_scissor"
+    )
+    assert projection(projector) == "projection-A"
+    assert view(projector) == "view-A"
+    ctx.projection_matrix, ctx.view_matrix = "projection-B", "view-B"
+    assert projection(projector) == "projection-B" and view(projector) == "view-B"
+    assert begin(projector) is None and end(projector) is None
+    assert group_scissor(projector) is None
+
+
+def test_core_backend_buffer_abstraction():
+    _, bindings = recompute_report_surfaces()
+    expected_call = {"binding": 0, "offset": 0, "size": 128}
+    assert bindings["opengl"]["calls"] == [expected_call]
+    assert bindings["webgl"]["calls"] == [expected_call]
+    assert bindings["opengl"] == bindings["webgl"]
+
+
+def test_edge_activation_restores_state_and_report_is_recomputed():
+    ctx = SimpleNamespace(
+        current_camera="previous-camera",
+        view_matrix="previous-view",
+        projection_matrix="previous-projection",
+        scissor=(1, 3, 5, 7),
+        viewport=(2, 4, 640, 360),
+    )
+    previous = dict(vars(ctx))
+
+    def use_active():
+        ctx.current_camera = projector
+        ctx.view_matrix = "active-view"
+        ctx.projection_matrix = "active-projection"
+        ctx.scissor = None
+        ctx.viewport = (0, 0, 100, 100)
+
+    projector = SimpleNamespace(_ctx=ctx, use=use_active)
+    activate_generator = extracted_method(
+        "arcade/camera/default.py", "DefaultProjector", "activate"
+    )
+    try:
+        with contextmanager(activate_generator)(projector):
+            assert ctx.current_camera is projector
+            raise RuntimeError("simulated draw failure")
+    except RuntimeError:
+        pass
+    assert vars(ctx) == previous
+
+    report = json.loads((APP / "repair_report.json").read_text())
+    camera_state, backend_bindings = recompute_report_surfaces()
+    for name, values in camera_state.items():
+        assert report["camera_state"][name]["projection"] == values["projection"]
+        assert report["camera_state"][name]["view"] == values["view"]
+        assert report["camera_state"][name]["viewport"] == EXPECTED["report_camera_viewport"]
+        assert report["camera_state"][name]["scissor"] == EXPECTED["report_camera_scissor"]
+        assert report["camera_state"][name]["current_camera_updated"] is True
+        assert report["camera_state"][name]["legacy_window_matrix_writes"] is False
+    assert report["default_projector"] == {
+        "projection": "default-projection",
+        "view": "default-view",
+        "begin_return": None,
+        "end_return": None,
+        "group_scissor": None,
+    }
+    assert report["backend_bindings"] == backend_bindings

tasks/candidate-1305-software-data-engineering/environment/Dockerfile

@@ -0,0 +1,3 @@
+# The task's image, pinned by digest (the same as [environment].docker_image).
+# Setup runs at start from [environment.healthcheck]; environment/setup/ is its readable copy.
+FROM docker.io/xiaomimimo/mimo-v2.6-rl-oss@sha256:6af5f2e49a663c7fce492eb4d3e5d1d08fd3f004bb4e7608586504a072d4de9c

tasks/candidate-1305-software-data-engineering/environment/setup/setup.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+# Runs once, as root, before the agent starts: Harbor's [environment.healthcheck] unpacks this folder into
+# /var/lib/mimo and runs it. Generated by mimo_harbor; see its README for how each step maps to Xiaomi's harness.
+M=/var/lib/mimo
+[ -f "$M/ready" ] && exit 0
+chmod 700 "$M"
+fail() { echo "setup: $*" >&2; exit 1; }
+# the answer-leak blocklist (mimoagent), applied to /etc/hosts by the agent right after it installs
+write_blocklist() { cp "$M/files/blocklist" "$M/blocklist"; }
+
+# Terminal-Bench rows (in the General domain): the Harbor convention itself. Scrub test leftovers from the image and
+# remember what was in the workspace, so harness residue can be told apart from the agent's work at grading time.
+rm -rf /tests
+find /logs/verifier -mindepth 1 -delete 2>/dev/null || true
+ls -A /app 2>/dev/null > "$M/before" || true
+
+touch "$M/ready"
+echo "setup done"

tasks/candidate-1305-software-data-engineering/instruction.md

@@ -0,0 +1,48 @@
+You are an agent, your current working directory is /app.
+
+You can use the tools available to you to interact with the computer to assist the user in completing tasks.
+
+You are repairing the vendored petl ETL library in `/app/vendor/project`.
+
+The frozen source has a cross-module fluent-API regression: some `Table` view
+classes store constructor options in instance attributes named `cache`,
+`complement`, `index`, or `skip`. Those names are inherited operations on table
+containers, so composed pipelines can fail with `TypeError` when a fluent
+operation is called. Correct the existing source modules; do not replace the
+library with a new evaluator or a one-off script.
+
+Requirements:
+
+1. Preserve the public fluent operations and their function-form equivalents.
+   A view created with `cache`, `complement`, `index`, or `skip` options must
+   still apply those options during lazy iteration and materialisation.
+2. Cover every affected view family in the vendored tree, including hash joins,
+   sorting, row/field selection, regex search, basic field operations,
+   materialisation, and the optional Avro and bcolz readers. Keep optional
+   backends import-safe; do not install or download their dependencies.
+3. Preserve exact headers, row values, duplicate-key join rows, ordering, and
+   the meaning of false/true option values. Do not eagerly consume a source
+   merely to make a method callable.
+4. Exercise a composed pipeline from `fixtures/pipeline.json` and write
+   `/app/repair_report.json` with this exact schema:
+
+```json
+{
+  "schema_version": "petl-repair-report.v1",
+  "output_schema_version": "petl-repair-report.v1",
+  "source_tree": "vendor/project",
+  "modules_repaired": ["petl/..."],
+  "joined_rows": [[...]],
+  "complement_rows": [[...]],
+  "sorted_rows": [[...]],
+  "regex_rows": [[...]],
+  "index_position": 0,
+  "method_checks": {"cache": true, "complement": true, "index": true, "skip": true}
+}
+```
+
+`modules_repaired` must name the existing source modules you actually changed.
+The rows must come from running petl, not from hardcoded expected output. The
+report must be valid JSON and written at the absolute path above. You may use
+standard-library tooling and the vendored package only; leave the fixture
+unchanged.

tasks/candidate-1305-software-data-engineering/task.toml

@@ -0,0 +1,39 @@
+schema_version = "1.4"
+
+[task]
+name = "mimo-v2.6-rl/candidate-1305-software-data-engineering"
+description = "MiMo-V2.6-RL terminal task candidate-1305-software-data-engineering"
+keywords = ["mimo-v2.6-rl", "terminal"]
+
+[metadata]
+adapter = "mimo_harbor 1.0.0"
+domain = "terminal"
+original_allow_internet = false
+reference_harness = "XiaomiMiMo/verl a2ad9f6 + XiaomiMiMo/mimoagent 467f0a1"
+reference_step_limit = 500
+source_dataset = "XiaomiMiMo/MiMo-V2.6-RL-oss"
+source_id = "candidate-1305-software-data-engineering"
+source_revision = "639865fd3374018d6cb29b9fb82dd531406fcf5f"
+
+[agent]
+timeout_sec = 900.0
+
+[verifier]
+timeout_sec = 240.0
+user = "root"
+
+[environment]
+docker_image = "docker.io/xiaomimimo/mimo-v2.6-rl-oss@sha256:6af5f2e49a663c7fce492eb4d3e5d1d08fd3f004bb4e7608586504a072d4de9c"
+workdir = "/app"
+cpus = 1
+memory_mb = 2048
+storage_mb = 10240
+network_mode = "public"
+build_timeout_sec = 1800.0
+
+[environment.healthcheck]
+# one-time setup before the agent (environment/setup/setup.sh)
+command = "bash -c 'test -f /var/lib/mimo/ready || { mkdir -p /var/lib/mimo && echo H4sIAAAAAAAC/+2T30/UQBDH77l/xddCEAx3PVAhgUiCkegLL+iDCSFk206vm9vuNrvbq0T83532gJP4qr44n5e2+2PmO9+ZBopdOwv15C8yZ47n8/E5//158Pbo8PH9Yf34zeujCeaTf0AXovKccvJ/svUiy7XNchXqZAtXnQ1wtqB9qADvXNxHTpXzhFgT1IJsxGBYDCf4pHzu/MuAa7Ir7Z1teHdWkzKxLmoqljfobKuKZeDLOqBypiQPbaPjVNlK+czoPGt046BsCT8k13GGj2TJq0gl8jsM27f1mOoUgYhPBFxdnH+4vOCIHrXrQaqoWRa1aFTL2Ry+auUazdr4pqUQZsnlu2cZk2tMK6Tbl5knVd6luMHODuibjpgnRd24Ejyyw4E0qZQ2u3v4DipqhzQMv8wJtl+lONs5PF1fOjjFD65qdMmGnvzUkFoiN65YGh0idoeso4F7bG7bGs31sdKMYpHVLnBVXO3GZa8XdYSq4mBZZNfYdmNC0nsd6fYp7qiraMdKKm0oZE9b6bi4+RwUssQv5BttlZm+J8u2edcH7Go7pl47b1C6Rmm7dzIurvuMwtkVC9PODi0gU83wufBdjkhcnqEquhV5brN3zXhPN1zJ0FlO6qmhJudS+lpF9DxcDxl755eBh4QnLrjHbvHxoMuOUCjL88c2mZI947HbRB9d4gYPAcAxF16V2i4QdUOzxDeY+grZoC0klebxyoxbhIwl6kqzkCmbUFIbaxxgWpKhSDg8y0paZbYzBvf3iL6jxARMz5Fxx55tn63NHf+N9OlwEl3Hnm7GKvllZNhVS2kyEQRBEARBEARBEARBEARBEARBEARBEARBEIQ/xk8LxjaZACgAAA== | base64 -d | tar -xzf - -C /var/lib/mimo && bash /var/lib/mimo/setup.sh; }'"
+timeout_sec = 1200.0
+retries = 0
+interval_sec = 5.0

tasks/candidate-1305-software-data-engineering/tests/anti_hack_guard.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""TBench in-pod anti-hack guard.
+
+Runs at the very start of ``tests/test.sh``, inside the verifier container,
+after the agent's ``/app`` has been copied in.  The RL harness materialises
+``tests/`` into the MAIN container only after the agent exits, so the agent
+cannot see or tamper with this file — which makes it the right place to reject
+workspace pollution the agent planted during the episode.
+
+Detection (any hit -> write reward=0 and exit non-zero):
+
+1. **Planted interpreter hooks.**  ``conftest.py`` / ``sitecustomize.py`` /
+   ``usercustomize.py`` / ``*.pth`` / ``pytest.ini`` / ``.coveragerc`` /
+   ``tox.ini`` anywhere under ``/app`` whose path is NOT listed in the pristine
+   manifest.  Upstream vendor trees that legitimately ship a ``conftest.py``
+   are listed in the manifest and are therefore not false positives.
+2. **Protected-file mutation.**  Any manifest entry whose sha256 changed while
+   its path is outside the declared mutable set.
+3. **Protected-file deletion.**  Any non-mutable, non-artifact manifest entry
+   that vanished.
+
+The manifest is generated from the pristine ``environment/`` tree and shipped
+as ``tests/fixtures/pristine_env_manifest.json``.  A missing manifest degrades to
+name-only detection so the guard never blocks an uninstrumented task.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sys
+from pathlib import Path
+
+SCHEMA = "tbench.pristine_env_manifest.v1"
+
+APP = Path(os.environ.get("TBENCH_APP_ROOT", "/app"))
+FIXTURES = Path(os.environ.get("TBENCH_FIXTURES", "/tests/fixtures"))
+MANIFEST = FIXTURES / "pristine_env_manifest.json"
+REWARD = Path(os.environ.get("TBENCH_REWARD_FILE", "/logs/verifier/reward.txt"))
+
+DANGEROUS_NAMES = {
+    "conftest.py",
+    "sitecustomize.py",
+    "usercustomize.py",
+    "pytest.ini",
+    ".coveragerc",
+    "tox.ini",
+    "pyproject.toml",  # only dangerous when planted; upstream copies are in the manifest
+}
+
+
+def sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def is_dangerous(rel: str) -> bool:
+    name = rel.rsplit("/", 1)[-1]
+    return name in DANGEROUS_NAMES or name.endswith(".pth")
+
+
+def load_manifest() -> dict | None:
+    if not MANIFEST.is_file():
+        return None
+    try:
+        doc = json.loads(MANIFEST.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    if not isinstance(doc, dict) or not isinstance(doc.get("files"), dict):
+        return None
+    return doc
+
+
+def reject(reason: str, reward: Path | None = None) -> int:
+    target = REWARD if reward is None else reward
+    try:
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text("0\n", encoding="utf-8")
+    except OSError as exc:  # pragma: no cover - reward file is the contract
+        print(f"anti_hack_guard: cannot write reward file: {exc}", file=sys.stderr)
+        return 2
+    print(f"anti_hack_guard: REJECT {reason}", file=sys.stderr)
+    return 1
+
+
+def scan(manifest: dict | None, app: Path | None = None) -> str | None:
+    app_root = APP if app is None else app
+    files: dict[str, str] = (manifest or {}).get("files") or {}
+    mutable_set = {
+        entry.lstrip("/")
+        for entry in (manifest or {}).get("mutable") or []
+        if isinstance(entry, str)
+    }
+    artifacts = {
+        str(entry).removeprefix("/app/").lstrip("/")
+        for entry in (manifest or {}).get("artifacts") or []
+        if isinstance(entry, str)
+    }
+
+    if not app_root.is_dir():
+        return None
+
+    for path in sorted(app_root.rglob("*")):
+        if not path.is_file() or path.is_symlink():
+            continue
+        rel = path.relative_to(app_root).as_posix()
+        if is_dangerous(rel) and rel not in files:
+            return f"planted_interpreter_hook:{rel}"
+
+    if manifest is None:
+        return None
+
+    # Deletion detection is only sound when the built image is known to equal
+    # the source tree (plain ``COPY . /app``).  A multi-stage or dockerignored
+    # build legitimately omits files, and rejecting those would zero out the
+    # oracle for a perfectly good task.
+    detect_deletion = bool(manifest.get("detect_deletion", True))
+    for rel, expected in files.items():
+        if rel in mutable_set or rel in artifacts:
+            continue
+        path = app_root / rel
+        if not path.exists():
+            if detect_deletion:
+                return f"protected_file_deleted:{rel}"
+            continue
+        if not path.is_file():
+            continue
+        if sha256(path) != expected:
+            return f"protected_file_mutated:{rel}"
+    return None
+
+
+def main(app: Path | None = None, reward: Path | None = None) -> int:
+    manifest = load_manifest()
+    reason = scan(manifest, app=app)
+    if reason:
+        return reject(reason, reward=reward)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

tasks/candidate-1305-software-data-engineering/tests/fixtures/base_hashes.json

@@ -0,0 +1,10 @@
+{
+  "petl/io/avro.py": "22bf288b24756edaba41b4e65f86225658d50565fe822f48bb5a549d16ac2cfb",
+  "petl/io/bcolz.py": "3fd08b5074048cb95c0e2664df316a6ad4441073412e7d4e55d9d31738775ff6",
+  "petl/transform/basics.py": "c6568f5957cd99951cde713dae31b69a2c5a369320d8af6ab18d5240836f9ff3",
+  "petl/transform/hashjoins.py": "d3d67b18f8bc142bfb47f7508305ecf2ba81b2bd2494f669a05913df567f7fda",
+  "petl/transform/regex.py": "2bc5d1ca46f4c46caee7f64754cda58186eec1c531b0ce1cc0771d600fccf86c",
+  "petl/transform/selects.py": "f7d6e9ec1c6f2a155368bd5d6062866b127489d4f4a03e3de0838b3c095830be",
+  "petl/transform/sorts.py": "45c9058d5eeefcb589ca14f0a70cd8d351e55aec11b418f24367a20010f2d833",
+  "petl/util/materialise.py": "45849d9929fb08f3d15a4e00bf4bc1d1d1e12f054a7f2461f3da88a099902762"
+}

tasks/candidate-1305-software-data-engineering/tests/fixtures/pipeline.json

@@ -0,0 +1,7 @@
+{
+  "left": [["id", "team", "score", "text"], [1, "A", 8, "alpha"], [2, "B", 3, "beta"], [3, "A", 7, "gamma"], [4, "C", 5, "delta"], [5, "B", 9, "epsilon"]],
+  "right": [["id", "label"], [1, "one"], [1, "uno"], [3, "three"], [5, "five"], [6, "six"]],
+  "exclude_ids": [3],
+  "regex": "^u",
+  "skip_regex_rows": 1
+}

tasks/candidate-1305-software-data-engineering/tests/fixtures/pristine_env_manifest.json

@@ -0,0 +1,154 @@
+{
+  "artifacts": [
+    "repair_report.json"
+  ],
+  "detect_deletion": true,
+  "files": {
+    "Dockerfile": "fdc4026cc5e1301ffb6bdfd12f61c9d1591909ddf05501b43ef6ade47d01641f",
+    "fixtures/pipeline.json": "11f886f5ecda75645bf1973cfecc6c7974d3f8679ca4bbb6b38958ec8dc005a1",
+    "vendor/project/LICENSE.txt": "229ce990bc98e631baf741926f7f237f303f8bc2166742ab5f0f406eb76f0162",
+    "vendor/project/petl/__init__.py": "e86a2a7e6848609ea4fd3d3fb00c8d8c59a968a920a9cdf5e25f95f07dc632ba",
+    "vendor/project/petl/comparison.py": "91b4b449fbcffe242f07af593b9d2bd0850852580dbcfadd978fbff219b2a6e3",
+    "vendor/project/petl/compat.py": "22b8e7c74f150f60f30db5c5144f23ea846360e9823d31723cd7462bfdc5c353",
+    "vendor/project/petl/config.py": "5f08e3ccf5c1016f9579ec1db02f8091b92bc21c77cf30919afa198e1cbe5f46",
+    "vendor/project/petl/errors.py": "ea62cba5b647a7f3670afb5f097502bfd65a27c7f0d6990e30f259c73666b411",
+    "vendor/project/petl/io/__init__.py": "461beee51c7437852097f6bd659e0635f2427f00c106a5b1044a4b84aa3ae1c0",
+    "vendor/project/petl/io/avro.py": "22bf288b24756edaba41b4e65f86225658d50565fe822f48bb5a549d16ac2cfb",
+    "vendor/project/petl/io/base.py": "105ab4feced4951d974c39e69ca3b12088e2c7dc515ddcc92bba6e521f68a0ae",
+    "vendor/project/petl/io/bcolz.py": "3fd08b5074048cb95c0e2664df316a6ad4441073412e7d4e55d9d31738775ff6",
+    "vendor/project/petl/io/csv.py": "41a236d11aa17a6c88232576ff150cb21b50f8a616345978c371302b42fc8e6f",
+    "vendor/project/petl/io/csv_py2.py": "3cdb941a590dad86b14bd4087a5298577ea06705e53481d9aba31c57c4569af6",
+    "vendor/project/petl/io/csv_py3.py": "779e341e54f3db81c7ef9294bec54fe2e9555f1b9a8ba5ed8d80a6ceace00375",
+    "vendor/project/petl/io/db.py": "5039984a738b1cb0ff8332dd982e45c7322a6017c3f402d4ebac4d534ef1c312",
+    "vendor/project/petl/io/db_create.py": "d489c19eaac062b7010900d2c1696ebf355fe1927c4d3c392c3785aaf502f460",
+    "vendor/project/petl/io/db_utils.py": "e2e5115e50fe0257f1be3a84eb8adbf9874d398274b20d0724b5a36122d1bf51",
+    "vendor/project/petl/io/gsheet.py": "83ecb1494ad6cb5e62851b924ba9394c28c86b329f5857edc50653df18a2ed42",
+    "vendor/project/petl/io/html.py": "5c60d5930e9bc6c8793c9f1e4d5c1f2f363d3f06b0664759af76ebd6794fc5af",
+    "vendor/project/petl/io/json.py": "a5b433902bcc972d71d72201d970f39310908a9cd3d9d2fdd5cb0d0e76b12ca6",
+    "vendor/project/petl/io/numpy.py": "b16a588f06290d8daa4ecc46696b1df6641fd6d07be49673d9b124b92a0cb48f",
+    "vendor/project/petl/io/pandas.py": "645876d06e259b40582812ae255b414e3da959df880ae84d119da850e54c5315",
+    "vendor/project/petl/io/pickle.py": "00e8ce8b678dee734c86ebfd848b585fca3100a8462da6090634feebc6a66164",
+    "vendor/project/petl/io/pytables.py": "8465eb869f94ecfa50078697616c426147025324077eb0beb0fd17431daf2012",
+    "vendor/project/petl/io/remotes.py": "72e2a64b6b5aff419dfefaf5c5b983174c7859d83773681d07a91f509f60695b",
+    "vendor/project/petl/io/sources.py": "ef40a98159428fee4220255524e7ed656c893de2dacf17285b08b892852f6788",
+    "vendor/project/petl/io/text.py": "db98827c906972735880445f9995d9860ccab77cef40b5d3cc6a5dfe92f9a8dc",
+    "vendor/project/petl/io/whoosh.py": "bf86ae43412e07ed6a6d539894ba4cb675fb0c24bfd8086c8cf952dc3e959a58",
+    "vendor/project/petl/io/xls.py": "fa73c2150a3e4fa0850fd4536267a5974738be1ca0e1a15d06c5531099d1f95b",
+    "vendor/project/petl/io/xlsx.py": "8bad13e82154ec670b8d71c3d93e33b641d3fa569d2f567bbe400177e5d91690",
+    "vendor/project/petl/io/xlutils_view.py": "ff5cfda4263414e6421c23407d829799b24fc419652ccb38275e40bcef1483b9",
+    "vendor/project/petl/io/xml.py": "99e371906f4c8110cd3eb06f00f7fc9f9b550310b326534841ce0bacf5bf62d3",
+    "vendor/project/petl/test/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/project/petl/test/conftest.py": "1f0fec5821f7a9076bc6ae525c5bb7db9dd2141b30a2e2995b94e06f110556e0",
+    "vendor/project/petl/test/failonerror.py": "fc878a521661cfd10c64a34b26e683ba6e9afc5fdd90b4a779895b98f4e39bdf",
+    "vendor/project/petl/test/helpers.py": "493ae8ca36f0d9edf6ba0631ff242e2231b3998f8f672c873d91daf7b5f94091",
+    "vendor/project/petl/test/io/__init__.py": "b409d7b2819b6d184e08ba2f6d0dbe32130f4716255b5230ffc4db36ab529688",
+    "vendor/project/petl/test/io/test_avro.py": "9d612ca566956444eff2100ae2206399e0c878118a987d9ef788fcf0168bdd1f",
+    "vendor/project/petl/test/io/test_avro_schemas.py": "ac563e3464dd4b2d032487957bd225b431b250ba2799571dd1ea0d79bd458df0",
+    "vendor/project/petl/test/io/test_bcolz.py": "622d11718541b9794d29bee517d7bb59d1838fde3ab704230dced3b7c93f7a27",
+    "vendor/project/petl/test/io/test_csv.py": "efa75dc02f4e09ac01b6a0ab96bb07db957adc67ecf3dca18950aeaba33793b6",
+    "vendor/project/petl/test/io/test_csv_unicode.py": "2ab286b9e0a233640e1e788d89e0f6712627b2ea05bd795b7aa195bc72806e9a",
+    "vendor/project/petl/test/io/test_db.py": "38c3716afad806ea41d2dcf13ab556cb47260c0b4850b9714a0f978efadbf732",
+    "vendor/project/petl/test/io/test_db_create.py": "ac03466b4d2faf82631d36815b61876273ad8a392d16b45e68af2e5b07120cd4",
+    "vendor/project/petl/test/io/test_db_inference.py": "bc3f2b5bf277db2680b5736e88b20dbecc17a01ff72c1c619a41f1a373b131e3",
+    "vendor/project/petl/test/io/test_db_server.py": "fe06a9bada1804d4f0a46480b8e379091b0acfcc9e8b614337a5c3a37d91ddff",
+    "vendor/project/petl/test/io/test_gsheet.py": "83268aa5dbadb996196f054e9332e73309a39361b8914bd260fe85f50cd1f73b",
+    "vendor/project/petl/test/io/test_html.py": "c8884066d53ea81f46a0889371a408cdb5f5c284ea06fc5a6a24ad0972691ee9",
+    "vendor/project/petl/test/io/test_html_unicode.py": "f1b5fad185da409042af417ac5be1724054a2bb34d170d3b2de56c06fce4d829",
+    "vendor/project/petl/test/io/test_json.py": "c2987bd970fe0b534aee4853e1579c224fd8fe983d8cbddbf805caea250d7859",
+    "vendor/project/petl/test/io/test_json_unicode.py": "cfd436a73f527317d4afd2969f1b072b79e7d06521086c55e6ebfe2947d5adcf",
+    "vendor/project/petl/test/io/test_jsonl.py": "c8f19d00edebf5577e103aca4dbaf2387da5635e9c8ac21b17491117f0a2a049",
+    "vendor/project/petl/test/io/test_numpy.py": "39cab1514585420b4be1110b8b5ea5fa7ad6c72484b2ae60016c4be4a0d8bdb5",
+    "vendor/project/petl/test/io/test_pandas.py": "8bfd9fc3e52af29492b2afc6a2112d61fc1fe0209fb76b41ed9659946940623c",
+    "vendor/project/petl/test/io/test_pickle.py": "86e2a01bd5d72403033f67246a671e81bd0971e4f93d681f2d6927290ee2078c",
+    "vendor/project/petl/test/io/test_pytables.py": "70b411ba711037d32de7a28fc74de0fdf09713c09240aebee3f18c9e34c2f36f",
+    "vendor/project/petl/test/io/test_remotes.py": "8ae399844d49d1e6de90f942514a14a0edede8847e4cdf6c3569cb32b878ee83",
+    "vendor/project/petl/test/io/test_sources.py": "a61891b1508e7f673bfcdc682f51f7d49bce974634ab43950cab0b47c547f675",
+    "vendor/project/petl/test/io/test_sqlite3.py": "788708e999a3f8ec42483a4f0402f1170df41e5f21b32737d47d74fe9506e43d",
+    "vendor/project/petl/test/io/test_tees.py": "0d7968009eb684d4a67f2e57e87eacfeacef1ab39c33e36d8fc944ad2bd37ea9",
+    "vendor/project/petl/test/io/test_text.py": "3ae6361710d97cecb293c502539be295b3b240b575024cfcb6721175f59341f9",
+    "vendor/project/petl/test/io/test_text_unicode.py": "9a541cf3b31245eb33936d5a87a663db3476f6156b407a7e4a5376c3afeb1947",
+    "vendor/project/petl/test/io/test_whoosh.py": "5594f579363533e01165b7d612d237de4f6c4b09c982f09f8c71a2b4442b956a",
+    "vendor/project/petl/test/io/test_xls.py": "094cce80a43d9914133a1b5dd55eafed66c1fb8c1fdb1eafaccfc9749700e8b2",
+    "vendor/project/petl/test/io/test_xlsx.py": "ecc87d1fac9fc3a687ea786de31d056cdf30d9e820cfb7b1e84c3a79b76979c2",
+    "vendor/project/petl/test/io/test_xml.py": "ee4646b075baa1f92a60dc9d09a289cf13988cede7627c748269fd735133d70f",
+    "vendor/project/petl/test/resources/test.xls": "ce2b34cfb7764bca30c315c06c80427d10a30fd962161c84ec10b79a02dd7dd1",
+    "vendor/project/petl/test/resources/test.xlsx": "608dfeff0c7013ee3493960b107ee616d7a3b5766a3142af4cfaac1e9d071976",
+    "vendor/project/petl/test/resources/test.xml": "59e7ea8fa325794aa281d2e6a4577158d5c1e664d79d3813d63cfab3c43365b5",
+    "vendor/project/petl/test/test_comparison.py": "2c3c7e9f5e0852255f2b2e3687d2cd162004a1022efba01e45ec7e9055817ac4",
+    "vendor/project/petl/test/test_fluent.py": "f56159d1eb27e567035fea73b47c256f704c66f951dc851c4a4e04719afb38f6",
+    "vendor/project/petl/test/test_helpers.py": "778503e2f58a43803f604061144d7538c2543dfc3b6e620d162e68f1c2379b63",
+    "vendor/project/petl/test/test_interactive.py": "bd545630a10173242a6fe3cd2c8f54eecfd1c941fddb22c3c6f968038dbb167f",
+    "vendor/project/petl/test/test_method_shadow.py": "1848c67eb7739449b38b39bb117bf71776c3884493f195d342f789042e441f11",
+    "vendor/project/petl/test/transform/__init__.py": "b409d7b2819b6d184e08ba2f6d0dbe32130f4716255b5230ffc4db36ab529688",
+    "vendor/project/petl/test/transform/test_basics.py": "5c8c5e2251ec4251e7ab44e3f17d93659bc1b7e923bd953fbdf759261c9dde5e",
+    "vendor/project/petl/test/transform/test_conversions.py": "ce57294a13bb54e40d617c52ef355d7bacff2b96c34325500d68a9188f69f2a2",
+    "vendor/project/petl/test/transform/test_dedup.py": "927f6a0d5fc14a730e3a62ba3e8c91d6b0292387b28f92b5c960355f9ed9aba4",
+    "vendor/project/petl/test/transform/test_fills.py": "e4c52a45febdd972b238ce42422987cd286d68287bc97981c1e5e0317526f3e7",
+    "vendor/project/petl/test/transform/test_headers.py": "ea6146061b44f7c83311922ef9de962e18de097a7624fb30c22e1d0894433b5e",
+    "vendor/project/petl/test/transform/test_intervals.py": "60ef858c8b82b0d084f99d8155084152ab250a5c060e9a4a9281c3ccc7c2f27d",
+    "vendor/project/petl/test/transform/test_joins.py": "3e2ff1547900c3ff2c35368bab3375c5129e3a4cbcd83c9791e423e084844dea",
+    "vendor/project/petl/test/transform/test_maps.py": "da1527dba1b7b3315602d3ea811efae19f1bae66e3c1c3d4cd01cd9a7c87a020",
+    "vendor/project/petl/test/transform/test_reductions.py": "8226dfb26ebd41f39209b80f487a386b1bc84c53fd45e26450b3517534157c83",
+    "vendor/project/petl/test/transform/test_regex.py": "741e3de173252ec97858441b2f0ea5f18dcf6869617ab676da75ddbe73213107",
+    "vendor/project/petl/test/transform/test_reshape.py": "940fe2d0a43b279196f060019340429000668e158541da314839b3404ad7b0f1",
+    "vendor/project/petl/test/transform/test_selects.py": "960af707d2ff128c7a0a921112dfb7c0797cbe0d475162654db1e6f7abef0623",
+    "vendor/project/petl/test/transform/test_setops.py": "d26ee9642081a65324f704a310b098c618521ea68cd1cc45af8932fd5ac55064",
+    "vendor/project/petl/test/transform/test_sorts.py": "2b9216f029dcb1215da9ecf4c41e8e8af9e614fa30154ee9d0406c8fd675cc1f",
+    "vendor/project/petl/test/transform/test_unpacks.py": "7c9369360825f771bcb48a289d76d0249c15952578dd009f503f1f94c69668d9",
+    "vendor/project/petl/test/transform/test_validation.py": "4dbff0a0b5902b44cb5304131ff722cf4bc8be48d8dfa6012c1c4c34f773aae5",
+    "vendor/project/petl/test/util/__init__.py": "4137243893d1da9b9fb877034fbcf41a43dee67e38def7f22b5115cee2a71913",
+    "vendor/project/petl/test/util/test_base.py": "a531b4da8176e07780034b52cbef0bd9e154f828ace2d53b71d7b9de34bcaed6",
+    "vendor/project/petl/test/util/test_counting.py": "e41b08dc9034981afcdb37f40b313c5f02b7a82ce2849b90cf8ab7f34ab1c2f5",
+    "vendor/project/petl/test/util/test_lookups.py": "c4cfea17b9c6d5fa248f7f06e9810bf835a878b2b2a8bacc0b9c567a39f326fd",
+    "vendor/project/petl/test/util/test_materialise.py": "3c8de6010748cbf2a9d4f0de447293a490eb3659c82ca40ffb33dca72d8cf589",
+    "vendor/project/petl/test/util/test_misc.py": "0795853a84bbdbef13295722231795c05323fa17575bca34ef9781adf968a0b6",
+    "vendor/project/petl/test/util/test_parsers.py": "67a0f5322c6d679661814bc8e8137d464b9401062123755c98039aa3df8ede29",
+    "vendor/project/petl/test/util/test_random.py": "00f856e4b7c14c33945fcfb8be669b5a9294e29a0a26875e9a687fb824fb0d6e",
+    "vendor/project/petl/test/util/test_statistics.py": "a07527bbacc7f4eb02b17de11e9f1e0e0b19ff4b27ad87c0a9b21b007fc30b6b",
+    "vendor/project/petl/test/util/test_timing.py": "eaacfc65433f77271ee56abca072305d9d9717e833e20fb5549cb8002043b1b1",
+    "vendor/project/petl/test/util/test_vis.py": "1f5d1ba402000c16968bd033ae0311b3658e580aa2a790f13224199690c767ee",
+    "vendor/project/petl/transform/__init__.py": "0283aed158196edead2f30fa2151a983294ca92d2993a31fa728ab141f6e85ac",
+    "vendor/project/petl/transform/basics.py": "c6568f5957cd99951cde713dae31b69a2c5a369320d8af6ab18d5240836f9ff3",
+    "vendor/project/petl/transform/conversions.py": "8b89190c12de678b1cd86205d99aec90bcaa5c45005da116e19e6ccfed626ded",
+    "vendor/project/petl/transform/dedup.py": "32585f1cc73864baa0b4443b1172949a1da12da9a2a03747d79cc450bc68a10c",
+    "vendor/project/petl/transform/fills.py": "85c53c4aab37805fb39f0834e2bf96cde8362888a837e135b402d9b63f0aacfc",
+    "vendor/project/petl/transform/hashjoins.py": "d3d67b18f8bc142bfb47f7508305ecf2ba81b2bd2494f669a05913df567f7fda",
+    "vendor/project/petl/transform/headers.py": "4d468d16028b08edce4627b0c43b9ce6997a8e1872c0586828e0bb37c55ebc95",
+    "vendor/project/petl/transform/intervals.py": "8da053e0262f4596e07889fc237f182b1e45dbc74c0c5b3cc8f58cfbbfc30f28",
+    "vendor/project/petl/transform/joins.py": "065bda794d575d48eb1b7fd14ef1bdfedc6467b575a2364c1d55a52784237dd0",
+    "vendor/project/petl/transform/maps.py": "18014a9ddbfb78d3bb0acb3b32a10b3d493146b11e37821ef30596ca63ea25a8",
+    "vendor/project/petl/transform/reductions.py": "563b78faa011491d83a2b295faa1fdd5aaf108e4acfd80f8cd2d2192e8f6c699",
+    "vendor/project/petl/transform/regex.py": "2bc5d1ca46f4c46caee7f64754cda58186eec1c531b0ce1cc0771d600fccf86c",
+    "vendor/project/petl/transform/reshape.py": "01138dcc88b478262fbd97a00bd7c08415dd582a28d2bb08a79d3d6748de80b6",
+    "vendor/project/petl/transform/selects.py": "f7d6e9ec1c6f2a155368bd5d6062866b127489d4f4a03e3de0838b3c095830be",
+    "vendor/project/petl/transform/setops.py": "71e8c5a4ae225ea28f364bb09b6590fabd88c7d86e2d7e7c5debe35ef7c67bed",
+    "vendor/project/petl/transform/sorts.py": "45c9058d5eeefcb589ca14f0a70cd8d351e55aec11b418f24367a20010f2d833",
+    "vendor/project/petl/transform/unpacks.py": "198ab9519bde9b783d520e77640818e2c7207f8a19cef8ebd87951497c23be75",
+    "vendor/project/petl/transform/validation.py": "5d6940a374d5e58a9bf9f7943712d3e1d9de686000491dca5502fd8b3da45566",
+    "vendor/project/petl/util/__init__.py": "2ec41e5e7761192f701cca40fd3aae321f13b13b32dbcf7e9523a4f774896cf7",
+    "vendor/project/petl/util/base.py": "a444b8a07943b52f6cac155d9d280d79fdf611f0c33b10e7f9ffa232b7ab37a2",
+    "vendor/project/petl/util/counting.py": "5426f3ac00e26eda7709b9b781bdd9b2e667a2b3c827d66d6c5fddd70a00dc6a",
+    "vendor/project/petl/util/lookups.py": "56217a6ee9e1ea676ece69a6971cfbdae16a530491bb9f2d92f97134c5d273a9",
+    "vendor/project/petl/util/materialise.py": "45849d9929fb08f3d15a4e00bf4bc1d1d1e12f054a7f2461f3da88a099902762",
+    "vendor/project/petl/util/misc.py": "4c5807fcee5016b0e6ee2f22ce5051109d51746b501b3ba1a34120f7c4d5db96",
+    "vendor/project/petl/util/parsers.py": "87d259ea226a97404063c46cf8977028517e57f9a7505c61f331bfcdf66fbd17",
+    "vendor/project/petl/util/random.py": "227e351f57e333e549e21b1a97fce48f04eb9726ac4fd2b65e34065bf43420ec",
+    "vendor/project/petl/util/statistics.py": "2bf45bed9647ac8174f2cb80b8eb01145aee5e041941c00a88fac3964f19016e",
+    "vendor/project/petl/util/timing.py": "46f19f128510d6d00f3101af3a2d5c5c63439106d330d2ae634c6466c32a4ae3",
+    "vendor/project/petl/util/vis.py": "4ec1b23fbd5164aa18d3449db64836d3d388a12f88c5ce0d716d35d1301e4b0c",
+    "vendor/project/petl/version.py": "cf2aae3d11d9fd2a98f3aaeb73a997e212298d592e3add876c02b8b37b8fa7bd",
+    "vendor/project/pyproject.toml": "8e780909621cc0ca57276f828accd6cc54b7e107c0a4d1eff5b7046efc5cf2b6",
+    "vendor/project/setup.py": "5ca32459812e2ee50aa4d9f860a74dd2d248fe9667dec19dac246be4a2c876d7"
+  },
+  "mutable": [
+    "vendor/project/petl/io/avro.py",
+    "vendor/project/petl/io/bcolz.py",
+    "vendor/project/petl/transform/basics.py",
+    "vendor/project/petl/transform/hashjoins.py",
+    "vendor/project/petl/transform/regex.py",
+    "vendor/project/petl/transform/selects.py",
+    "vendor/project/petl/transform/sorts.py",
+    "vendor/project/petl/util/materialise.py"
+  ],
+  "schema_version": "tbench.pristine_env_manifest.v1"
+}

tasks/candidate-1305-software-data-engineering/tests/task_test.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -u
+mkdir -p /logs/verifier
+set +e
+# tbench-anti-hack-guard:v1
+export PYTHONNOUSERSITE=1
+export PYTHONDONTWRITEBYTECODE=1
+# Fail open when the verifier image has no python3 (node-only tests images are
+# excluded from the RL set but still verifiable natively): a missing
+# interpreter must not swallow the grader's own reward write.
+if command -v python3 >/dev/null 2>&1 && [ -f /tests/anti_hack_guard.py ]; then
+  if ! python3 /tests/anti_hack_guard.py; then
+    # Guard already wrote reward=0; the reward file is the grading contract.
+    exit 0
+  fi
+fi
+
+
+python3 -m pytest --ctrf /logs/verifier/ctrf.json -q /tests/test_outputs.py
+rc=$?
+set -e
+if [ "$rc" -eq 0 ]; then
+  printf '1\n' > /logs/verifier/reward.txt
+else
+  printf '0\n' > /logs/verifier/reward.txt
+fi
+exit "$rc"

tasks/candidate-1305-software-data-engineering/tests/test.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+# Terminal-Bench grading: the task's own test script (task_test.sh here) writes /logs/verifier/reward.txt.
+# "-1" there is its crash sentinel: a testbed failure, so no reward is written (not scored).
+CWD=/app
+mkdir -p /logs/verifier
+# the task's anti-hack guard rejects files planted in the workspace: drop what agent harnesses leave there
+for d in .opencode .claude .codex .gemini .goose .aider.tags.cache.v4; do
+  grep -qx "$d" /var/lib/mimo/before 2>/dev/null || rm -rf "$CWD/$d"
+done
+cd "$CWD" && bash /tests/task_test.sh
+R=$(cat /logs/verifier/reward.txt 2>/dev/null | tr -d '[:space:]')
+if [ -z "$R" ] || [ "$R" = "-1" ]; then
+  rm -f /logs/verifier/reward.txt
+  echo "the tests crashed before grading (reward '${R}'): not scored" >&2
+  exit 1
+fi

tasks/candidate-1305-software-data-engineering/tests/test_outputs.py

@@ -0,0 +1,167 @@
+import ast
+import hashlib
+import json
+import os
+import subprocess
+import sys
+from functools import lru_cache
+from pathlib import Path
+
+
+APP = Path('/app')
+PACKAGE = APP / 'vendor' / 'project'
+FIXTURE = json.loads((Path('/tests/fixtures/pipeline.json')).read_text())
+MODULES = {
+    'petl/io/avro.py', 'petl/io/bcolz.py', 'petl/transform/basics.py',
+    'petl/transform/hashjoins.py', 'petl/transform/regex.py',
+    'petl/transform/selects.py', 'petl/transform/sorts.py',
+    'petl/util/materialise.py',
+}
+
+
+def _expected_join():
+    left, right = FIXTURE['left'], FIXTURE['right']
+    lh, rh = left[0], right[0]
+    li, ri = lh.index('id'), rh.index('id')
+    out_h = [f'L_{x}' for x in lh] + [f'R_{x}' for i, x in enumerate(rh) if i != ri]
+    rows = [out_h]
+    lookup = {}
+    for row in right[1:]:
+        lookup.setdefault(row[ri], []).append(row)
+    for row in left[1:]:
+        for match in lookup.get(row[li], []):
+            rows.append([f for f in row] + [v for i, v in enumerate(match) if i != ri])
+    return rows
+
+
+def _expected_stages():
+    joined = _expected_join()
+    selected = [joined[0]] + [r for r in joined[1:] if r[2] >= 5]
+    excluded = [r for r in selected[1:] if r[0] != 3]
+    ordered = [selected[0]] + sorted(selected[1:], key=lambda r: r[0], reverse=True)
+    regex_data = [r for r in ordered[1:] if not r[-1].startswith(FIXTURE['regex'].lstrip('^'))]
+    return joined, [selected[0]] + excluded, ordered, regex_data
+
+
+@lru_cache(maxsize=1)
+def _petl_stages():
+    script = r'''
+import json
+import petl as etl
+from pathlib import Path
+f = json.loads(Path('/tests/fixtures/pipeline.json').read_text())
+left, right = f['left'], f['right']
+j = etl.hashjoin(left, right, key='id', cache=True, lprefix='L_', rprefix='R_')
+joined = list(j.cache(n=64))
+s = etl.select(j, 'L_score', lambda value: value >= 5)
+exclude = [joined[0], [3, 'A', 7, 'gamma', 'three']]
+complement = list(s.complement(exclude, cache=False))
+sv = etl.sort(s, key='L_id', reverse=True, cache=False)
+ordered = list(sv.cache(n=64))
+rv = etl.search(sv, 'R_label', f['regex'], complement=True)
+regex_rows = list(rv.skip(f['skip_regex_rows']))
+added = etl.addfield(sv, 'marker', lambda row: 'ok', index=0)
+print(json.dumps({'joined': joined, 'complement': complement, 'ordered': ordered,
+                  'regex': regex_rows, 'index': added.index(('marker', 'L_id', 'L_team', 'L_score', 'L_text', 'R_label'))}))
+'''
+    env = dict(os.environ, PYTHONPATH='/app/vendor/project')
+    proc = subprocess.run([sys.executable, '-c', script], env=env,
+                          capture_output=True, text=True, timeout=45)
+    assert proc.returncode == 0, proc.stderr
+    return json.loads(proc.stdout)
+
+
+def test_gate_report_schema_and_required_modules():
+    report_path = APP / 'repair_report.json'
+    assert report_path.is_file()
+    report = json.loads(report_path.read_text())
+    assert report['schema_version'] == 'petl-repair-report.v1'
+    assert report['output_schema_version'] == 'petl-repair-report.v1'
+    assert report['source_tree'] == 'vendor/project'
+    assert set(report['modules_repaired']) == MODULES
+    assert report['method_checks'] == {'cache': True, 'complement': True, 'index': True, 'skip': True}
+    for rel in MODULES:
+        assert (PACKAGE / rel).is_file()
+
+
+def test_gate_all_mutable_modules_changed_from_pristine():
+    baseline = json.loads((Path('/tests/fixtures/base_hashes.json')).read_text())
+    for rel, expected in baseline.items():
+        digest = hashlib.sha256((PACKAGE / rel).read_bytes()).hexdigest()
+        assert digest != expected, rel
+
+
+def test_core_fluent_pipeline_and_duplicate_join_rows():
+    got = _petl_stages()
+    expected_joined, expected_complement, expected_ordered, expected_regex = _expected_stages()
+    assert got['joined'] == expected_joined
+    assert got['joined'][0] == ['L_id', 'L_team', 'L_score', 'L_text', 'R_label']
+    assert sum(1 for row in got['joined'] if row and row[0] == 1) == 2
+    assert got['complement'] == expected_complement
+    assert got['ordered'] == expected_ordered
+
+
+def test_core_independent_regex_skip_and_index_recompute():
+    got = _petl_stages()
+    _, _, ordered, expected_regex = _expected_stages()
+    assert got['regex'] == expected_regex
+    assert got['regex'] == [ordered[1], ordered[2], ordered[3]]
+    assert got['index'] == 0
+    assert all(len(row) == 5 for row in got['ordered'])
+
+
+def test_core_constructor_options_remain_semantically_active():
+    script = r'''
+import petl as etl
+rows = [['id', 'value'], [1, 'a'], [2, 'b']]
+h = etl.hashjoin(rows, [['id', 'label'], [1, 'x']], key='id', cache=False)
+s = etl.sort(rows, key='id', cache=False)
+assert h._cache is False
+assert s._cache is False
+sel = etl.select(rows, 'id', lambda value: value == 1, complement=True)
+assert list(sel) == [('id', 'value'), (2, 'b')]
+'''
+    env = dict(os.environ, PYTHONPATH='/app/vendor/project')
+    proc = subprocess.run([sys.executable, '-c', script], env=env,
+                          capture_output=True, text=True, timeout=45)
+    assert proc.returncode == 0, proc.stderr
+
+
+def test_core_ast_collision_scan_covers_source_tree():
+    blocked = {'cache', 'complement', 'index', 'skip'}
+    collisions = []
+    for rel in MODULES:
+        path = PACKAGE / rel
+        tree = ast.parse(path.read_text(), filename=str(path))
+        for node in ast.walk(tree):
+            target = getattr(node, 'targets', [])
+            if isinstance(node, ast.AnnAssign):
+                target = [node.target]
+            for item in target:
+                if (isinstance(item, ast.Attribute) and isinstance(item.value, ast.Name)
+                        and item.value.id == 'self' and item.attr in blocked):
+                    collisions.append(f'{path}:{node.lineno}: self.{item.attr}')
+    assert not collisions, '\n'.join(collisions)
+
+
+def test_edge_optional_readers_keep_skip_semantics_without_imports():
+    script = r'''
+from petl.io.avro import AvroView
+from petl.io.bcolz import BcolzView
+class Fake:
+    names = ('id', 'value')
+    def iter(self, outcols=None, skip=0, limit=None):
+        rows = [(1, 'a'), (2, 'b'), (3, 'c')][skip:]
+        yield from rows[:limit]
+    def where(self, expression, outcols=None, skip=0, limit=None):
+        yield from self.iter(outcols, skip, limit)
+b = BcolzView(Fake(), skip=1)
+assert callable(b.skip)
+assert list(b) == [('id', 'value'), (2, 'b'), (3, 'c')]
+a = AvroView(None, limit=None, skips=2)
+assert callable(a.skip) and a._skip == 2
+'''
+    env = dict(os.environ, PYTHONPATH='/app/vendor/project')
+    proc = subprocess.run([sys.executable, '-c', script], env=env,
+                          capture_output=True, text=True, timeout=45)
+    assert proc.returncode == 0, proc.stderr

tasks/candidate-1399-security-reverse-engineering/environment/Dockerfile

@@ -0,0 +1,3 @@
+# The task's image, pinned by digest (the same as [environment].docker_image).
+# Setup runs at start from [environment.healthcheck]; environment/setup/ is its readable copy.
+FROM docker.io/xiaomimimo/mimo-v2.6-rl-oss@sha256:04f742598087c75a634ddf50808e42bb441f18d7a9af3072834626435e40e315

tasks/candidate-1399-security-reverse-engineering/environment/setup/setup.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+# Runs once, as root, before the agent starts: Harbor's [environment.healthcheck] unpacks this folder into
+# /var/lib/mimo and runs it. Generated by mimo_harbor; see its README for how each step maps to Xiaomi's harness.
+M=/var/lib/mimo
+[ -f "$M/ready" ] && exit 0
+chmod 700 "$M"
+fail() { echo "setup: $*" >&2; exit 1; }
+# the answer-leak blocklist (mimoagent), applied to /etc/hosts by the agent right after it installs
+write_blocklist() { cp "$M/files/blocklist" "$M/blocklist"; }
+
+# Terminal-Bench rows (in the General domain): the Harbor convention itself. Scrub test leftovers from the image and
+# remember what was in the workspace, so harness residue can be told apart from the agent's work at grading time.
+rm -rf /tests
+find /logs/verifier -mindepth 1 -delete 2>/dev/null || true
+ls -A /app 2>/dev/null > "$M/before" || true
+
+touch "$M/ready"
+echo "setup done"

tasks/candidate-1399-security-reverse-engineering/instruction.md

@@ -0,0 +1,21 @@
+You are an agent, your current working directory is /app.
+
+You can use the tools available to you to interact with the computer to assist the user in completing tasks.
+
+# Repair cross-backend address semantics
+
+You are working in a frozen reverse-engineering feature extractor. Repair the existing source tree, not by replacing it with a new evaluator or modifying the regression runner.
+
+The three backend file extractors receive virtual addresses from their analysis APIs. File-scope ASCII and UTF-16 strings must retain those values as `AbsoluteVirtualAddress`; they must not be relabeled as file offsets merely because downstream code also supports file offsets.
+
+Embedded PE detection is different: when a backend can prove a byte-to-file mapping, emit `FileOffsetAddress`. Ghidra can report an unmapped address with `-1`; in that case emit the embedded feature at the original `AbsoluteVirtualAddress` instead of dropping it. Preserve the existing Binary Ninja and IDA mapped-offset behavior and keep feature values unchanged.
+
+Work in `vendor/capa/features/extractors/{ghidra,ida,binja}/file.py`. Then run:
+
+```sh
+python3 tools/run_regression.py
+```
+
+The command executes the existing extractor functions against deterministic backend doubles whose virtual addresses deliberately differ from file offsets. It must produce `/app/output.json` with `output_schema_version` equal to `capa-address-regression.v1`, two string observations per backend, all four mapped/unmapped embedded-PE cases, and a compatibility section. Preserve the detected feature values and exact backend-provided coordinates.
+
+Do not install packages, use the network, edit `tools/run_regression.py`, or add a replacement extractor. The verifier protects the rest of the frozen project and independently executes the repaired functions with its own fixtures.

tasks/candidate-1399-security-reverse-engineering/task.toml

@@ -0,0 +1,39 @@
+schema_version = "1.4"
+
+[task]
+name = "mimo-v2.6-rl/candidate-1399-security-reverse-engineering"
+description = "MiMo-V2.6-RL terminal task candidate-1399-security-reverse-engineering"
+keywords = ["mimo-v2.6-rl", "terminal"]
+
+[metadata]
+adapter = "mimo_harbor 1.0.0"
+domain = "terminal"
+original_allow_internet = false
+reference_harness = "XiaomiMiMo/verl a2ad9f6 + XiaomiMiMo/mimoagent 467f0a1"
+reference_step_limit = 500
+source_dataset = "XiaomiMiMo/MiMo-V2.6-RL-oss"
+source_id = "candidate-1399-security-reverse-engineering"
+source_revision = "639865fd3374018d6cb29b9fb82dd531406fcf5f"
+
+[agent]
+timeout_sec = 900.0
+
+[verifier]
+timeout_sec = 240.0
+user = "root"
+
+[environment]
+docker_image = "docker.io/xiaomimimo/mimo-v2.6-rl-oss@sha256:04f742598087c75a634ddf50808e42bb441f18d7a9af3072834626435e40e315"
+workdir = "/app"
+cpus = 1
+memory_mb = 2048
+storage_mb = 10240
+network_mode = "public"
+build_timeout_sec = 1800.0
+
+[environment.healthcheck]
+# one-time setup before the agent (environment/setup/setup.sh)
+command = "bash -c 'test -f /var/lib/mimo/ready || { mkdir -p /var/lib/mimo && echo H4sIAAAAAAAC/+2T30/UQBDH77l/xddCEAx3PVAhgUiCkegLL+iDCSFk206vm9vuNrvbq0T83532gJP4qr44n5e2+2PmO9+ZBopdOwv15C8yZ47n8/E5//158Pbo8PH9Yf34zeujCeaTf0AXovKccvJ/svUiy7XNchXqZAtXnQ1wtqB9qADvXNxHTpXzhFgT1IJsxGBYDCf4pHzu/MuAa7Ir7Z1teHdWkzKxLmoqljfobKuKZeDLOqBypiQPbaPjVNlK+czoPGt046BsCT8k13GGj2TJq0gl8jsM27f1mOoUgYhPBFxdnH+4vOCIHrXrQaqoWRa1aFTL2Ry+auUazdr4pqUQZsnlu2cZk2tMK6Tbl5knVd6luMHODuibjpgnRd24Ejyyw4E0qZQ2u3v4DipqhzQMv8wJtl+lONs5PF1fOjjFD65qdMmGnvzUkFoiN65YGh0idoeso4F7bG7bGs31sdKMYpHVLnBVXO3GZa8XdYSq4mBZZNfYdmNC0nsd6fYp7qiraMdKKm0oZE9b6bi4+RwUssQv5BttlZm+J8u2edcH7Go7pl47b1C6Rmm7dzIurvuMwtkVC9PODi0gU83wufBdjkhcnqEquhV5brN3zXhPN1zJ0FlO6qmhJudS+lpF9DxcDxl755eBh4QnLrjHbvHxoMuOUCjL88c2mZI947HbRB9d4gYPAcAxF16V2i4QdUOzxDeY+grZoC0klebxyoxbhIwl6kqzkCmbUFIbaxxgWpKhSDg8y0paZbYzBvf3iL6jxARMz5Fxx55tn63NHf+N9OlwEl3Hnm7GKvllZNhVS2kyEQRBEARBEARBEARBEARBEARBEARBEARBEIQ/xk8LxjaZACgAAA== | base64 -d | tar -xzf - -C /var/lib/mimo && bash /var/lib/mimo/setup.sh; }'"
+timeout_sec = 1200.0
+retries = 0
+interval_sec = 5.0

tasks/candidate-1399-security-reverse-engineering/tests/anti_hack_guard.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""TBench in-pod anti-hack guard.
+
+Runs at the very start of ``tests/test.sh``, inside the verifier container,
+after the agent's ``/app`` has been copied in.  The RL harness materialises
+``tests/`` into the MAIN container only after the agent exits, so the agent
+cannot see or tamper with this file — which makes it the right place to reject
+workspace pollution the agent planted during the episode.
+
+Detection (any hit -> write reward=0 and exit non-zero):
+
+1. **Planted interpreter hooks.**  ``conftest.py`` / ``sitecustomize.py`` /
+   ``usercustomize.py`` / ``*.pth`` / ``pytest.ini`` / ``.coveragerc`` /
+   ``tox.ini`` anywhere under ``/app`` whose path is NOT listed in the pristine
+   manifest.  Upstream vendor trees that legitimately ship a ``conftest.py``
+   are listed in the manifest and are therefore not false positives.
+2. **Protected-file mutation.**  Any manifest entry whose sha256 changed while
+   its path is outside the declared mutable set.
+3. **Protected-file deletion.**  Any non-mutable, non-artifact manifest entry
+   that vanished.
+
+The manifest is generated from the pristine ``environment/`` tree and shipped
+as ``tests/fixtures/pristine_env_manifest.json``.  A missing manifest degrades to
+name-only detection so the guard never blocks an uninstrumented task.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sys
+from pathlib import Path
+
+SCHEMA = "tbench.pristine_env_manifest.v1"
+
+APP = Path(os.environ.get("TBENCH_APP_ROOT", "/app"))
+FIXTURES = Path(os.environ.get("TBENCH_FIXTURES", "/tests/fixtures"))
+MANIFEST = FIXTURES / "pristine_env_manifest.json"
+REWARD = Path(os.environ.get("TBENCH_REWARD_FILE", "/logs/verifier/reward.txt"))
+
+DANGEROUS_NAMES = {
+    "conftest.py",
+    "sitecustomize.py",
+    "usercustomize.py",
+    "pytest.ini",
+    ".coveragerc",
+    "tox.ini",
+    "pyproject.toml",  # only dangerous when planted; upstream copies are in the manifest
+}
+
+
+def sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def is_dangerous(rel: str) -> bool:
+    name = rel.rsplit("/", 1)[-1]
+    return name in DANGEROUS_NAMES or name.endswith(".pth")
+
+
+def load_manifest() -> dict | None:
+    if not MANIFEST.is_file():
+        return None
+    try:
+        doc = json.loads(MANIFEST.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    if not isinstance(doc, dict) or not isinstance(doc.get("files"), dict):
+        return None
+    return doc
+
+
+def reject(reason: str, reward: Path | None = None) -> int:
+    target = REWARD if reward is None else reward
+    try:
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text("0\n", encoding="utf-8")
+    except OSError as exc:  # pragma: no cover - reward file is the contract
+        print(f"anti_hack_guard: cannot write reward file: {exc}", file=sys.stderr)
+        return 2
+    print(f"anti_hack_guard: REJECT {reason}", file=sys.stderr)
+    return 1
+
+
+def scan(manifest: dict | None, app: Path | None = None) -> str | None:
+    app_root = APP if app is None else app
+    files: dict[str, str] = (manifest or {}).get("files") or {}
+    mutable_set = {
+        entry.lstrip("/")
+        for entry in (manifest or {}).get("mutable") or []
+        if isinstance(entry, str)
+    }
+    artifacts = {
+        str(entry).removeprefix("/app/").lstrip("/")
+        for entry in (manifest or {}).get("artifacts") or []
+        if isinstance(entry, str)
+    }
+
+    if not app_root.is_dir():
+        return None
+
+    for path in sorted(app_root.rglob("*")):
+        if not path.is_file() or path.is_symlink():
+            continue
+        rel = path.relative_to(app_root).as_posix()
+        if is_dangerous(rel) and rel not in files:
+            return f"planted_interpreter_hook:{rel}"
+
+    if manifest is None:
+        return None
+
+    # Deletion detection is only sound when the built image is known to equal
+    # the source tree (plain ``COPY . /app``).  A multi-stage or dockerignored
+    # build legitimately omits files, and rejecting those would zero out the
+    # oracle for a perfectly good task.
+    detect_deletion = bool(manifest.get("detect_deletion", True))
+    for rel, expected in files.items():
+        if rel in mutable_set or rel in artifacts:
+            continue
+        path = app_root / rel
+        if not path.exists():
+            if detect_deletion:
+                return f"protected_file_deleted:{rel}"
+            continue
+        if not path.is_file():
+            continue
+        if sha256(path) != expected:
+            return f"protected_file_mutated:{rel}"
+    return None
+
+
+def main(app: Path | None = None, reward: Path | None = None) -> int:
+    manifest = load_manifest()
+    reason = scan(manifest, app=app)
+    if reason:
+        return reject(reason, reward=reward)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

tasks/candidate-1399-security-reverse-engineering/tests/fixtures/expected_schema.json

@@ -0,0 +1 @@
+{"output_schema_version":"capa-address-regression.v1","required_backends":["ghidra","ida","binja"],"required_embedded_cases":["ghidra_mapped","ghidra_unmapped","ida_mapped","binja_mapped"]}

tasks/candidate-1399-security-reverse-engineering/tests/fixtures/pristine_env_manifest.json

@@ -0,0 +1,125 @@
+{
+  "artifacts": [
+    "output.json"
+  ],
+  "detect_deletion": true,
+  "files": {
+    "Dockerfile": "fdc4026cc5e1301ffb6bdfd12f61c9d1591909ddf05501b43ef6ade47d01641f",
+    "tools/run_regression.py": "b757966156436ff3d300f3378ae5192da35253b8c3e0c022a7f0d4df71a17b16",
+    "vendor/LICENSE.txt": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30",
+    "vendor/capa/exceptions.py": "12adbe09bbc555fecb3dc5ee70643511fcc7ec5427d34e48635fb574493c8c72",
+    "vendor/capa/features/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/capa/features/address.py": "5b4945bfa4e35dc45cbe6d50b4bccbf46c0e09f570f9e57156fcb309dfb8033e",
+    "vendor/capa/features/basicblock.py": "efb5819ded8782e10a7b4c6fe24908dd9291f02edf9fe97a44e6d7bff229c352",
+    "vendor/capa/features/com/__init__.py": "12bdcd6a78dde3f652643e030ad776645c5d474bd12cf3a165744b9c6d47849f",
+    "vendor/capa/features/com/classes.py": "745f7f79e56b19dd2cf1dd487c6d45db2378081c16d2fca49a200686970c7f90",
+    "vendor/capa/features/com/interfaces.py": "774d6d3009169183fd4ee8b4be08184a32e729d14f4e7c90eb5b029af4a4d47b",
+    "vendor/capa/features/common.py": "b49ed429e273d091df6bc99455144eed885ca4a54150f3c6e53a4a3451dea17d",
+    "vendor/capa/features/extractors/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/capa/features/extractors/base_extractor.py": "c630308916f3ee7394ff1287a17360af9647de3af9b0bc14a9c9b9395e00310d",
+    "vendor/capa/features/extractors/binexport2/__init__.py": "46f9d90292b3bab1869212cfec46ada08012b7a5ab24fd65fccbfa88651a4f8a",
+    "vendor/capa/features/extractors/binexport2/arch/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/capa/features/extractors/binexport2/arch/arm/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/capa/features/extractors/binexport2/arch/arm/helpers.py": "785de2d90894ba28368d53c1c5cd38099858419b6b9ab5a976f49a04357e8d74",
+    "vendor/capa/features/extractors/binexport2/arch/arm/insn.py": "69908022eabbd5ebd95d66361c32e5691e5352eb8dadfd22b6d2100722c0aa9f",
+    "vendor/capa/features/extractors/binexport2/arch/intel/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/capa/features/extractors/binexport2/arch/intel/helpers.py": "03d9963f8f0e91816a51b6d2b3830e62d1d92bb01d9275384e0998e5298478bd",
+    "vendor/capa/features/extractors/binexport2/arch/intel/insn.py": "389bd3e526b2c282c0cc4f7c73904d5f611cd190cead029bf788f6cb97385645",
+    "vendor/capa/features/extractors/binexport2/basicblock.py": "aa27d712f7c6af5167a012464b2ab2fa619e20ca84f2ee654a90a4ac299c0944",
+    "vendor/capa/features/extractors/binexport2/binexport2_pb2.py": "9ade22c7cbafa07c7513cc3129d09fa3b12c73c6a6f8001267aab07db00eea86",
+    "vendor/capa/features/extractors/binexport2/binexport2_pb2.pyi": "d05c80ad5397be2dae91466bd5b6f15bef119bf6e23f1e4b76058e3707f06b06",
+    "vendor/capa/features/extractors/binexport2/extractor.py": "046c9f4792df8a8e50138e6cdefb087b3c6811fa196be1de911b0b3eec343ec2",
+    "vendor/capa/features/extractors/binexport2/file.py": "1598d35449a5ad4d6e036016d2c963072d3b8ce04785fad57836d3af6a6e71c3",
+    "vendor/capa/features/extractors/binexport2/function.py": "3cb828119b5303b004782a053c9bf37a4d09c45871c293767e7f2b1b455d02ad",
+    "vendor/capa/features/extractors/binexport2/helpers.py": "f4ef7546f41df482c15b75509e2b8557d9eeb8a6736c47a9331d4088b69046f4",
+    "vendor/capa/features/extractors/binexport2/insn.py": "a8ed39292e4b984186582e32ebd0f0a4d3b41beb4a1d1e4564f53ac4cee8c08f",
+    "vendor/capa/features/extractors/binja/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/capa/features/extractors/binja/basicblock.py": "463564d0c239661ecade35e40bfbd0920cf23ff6c1d2912a0f0ab1bcc870ed20",
+    "vendor/capa/features/extractors/binja/extractor.py": "f97bc7e306e038c40ddbe3a5cadafc2760ae0657f01487dca88425e2f7435834",
+    "vendor/capa/features/extractors/binja/file.py": "4dc292ae9a7ac3be748fe5c83626886eb80c2005730a9b98f39430e1b2ce10ce",
+    "vendor/capa/features/extractors/binja/find_binja_api.py": "d10bc8408ac9ab2f23c2fbd96957452c98cd90d35d81528d0b2fceb104494317",
+    "vendor/capa/features/extractors/binja/function.py": "824423ecbe46cad334ce3f793491651ee518f54664927b33647d40148655c8c2",
+    "vendor/capa/features/extractors/binja/global_.py": "5e6257e3a421851b23a6d4f660fbe2ff8708135e1e967a2050c8d7b2d23c32a1",
+    "vendor/capa/features/extractors/binja/helpers.py": "cebb5363b9998052ae4b2b4601e530ab25479a7b258932c128e38b675b7f944d",
+    "vendor/capa/features/extractors/binja/insn.py": "4d4b94227bc00fd97f985511479a4c14920cba2653dac784097da3aed276c01b",
+    "vendor/capa/features/extractors/cape/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/capa/features/extractors/cape/call.py": "10c6e38c6daf58a81cf67fa70d879ca781f9ca6e486ec6dcda2c65bc8e495928",
+    "vendor/capa/features/extractors/cape/extractor.py": "0368403ce98cbb3e0499fab06ea6e9e9745fd9c0f7a8e363e833c3a47abcc173",
+    "vendor/capa/features/extractors/cape/file.py": "3cbdf40c7e16fcf3174737f6dfb7a5a303523b5ddd7ee150d8322979cfb25752",
+    "vendor/capa/features/extractors/cape/global_.py": "36df9126e7e3cd5881c88c564185e87ee7162efa8fd2ddd60d6259464de07164",
+    "vendor/capa/features/extractors/cape/models.py": "fd7ec3b7dcd892b0dca80ca75592d49e30a7b172164f7b982d6bd0ee0e314755",
+    "vendor/capa/features/extractors/cape/process.py": "f57416634702332d64159bac35e8f6ba5e7f07e2240c4e13f927e38c83302a37",
+    "vendor/capa/features/extractors/cape/thread.py": "d6b1d27ec060c393e63f4c8b503d9bdbdbac84e249d4a6509fff3545b94b7192",
+    "vendor/capa/features/extractors/common.py": "d5df60e1b02006605505270cd2f7bebc2a715fa845a8e7607e33e5badad67cb1",
+    "vendor/capa/features/extractors/dnfile/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/capa/features/extractors/dnfile/extractor.py": "1a85560f9343a5dce72e3b3b336f8aaad2981698f8b76d0e363617415bf98231",
+    "vendor/capa/features/extractors/dnfile/file.py": "251e54168fd7f90d7a9e513010d3ffc703a2b25d3420f72cf3bec917bd806d86",
+    "vendor/capa/features/extractors/dnfile/function.py": "0c943f9aca13e17d1e64800892b973585e1d2f796f276ded6baacb180cc8389b",
+    "vendor/capa/features/extractors/dnfile/helpers.py": "553765220f6bf3ac933c49100b9c6d1468e81eeb66b646b912d68e86001e571e",
+    "vendor/capa/features/extractors/dnfile/insn.py": "9d8dada3ac8da1d1d02e5d74dd6ddd4334318b987732c0df884a6cde0fdac404",
+    "vendor/capa/features/extractors/dnfile/types.py": "11ceea648a028258c63e1481291a9fa1e4dbddbd43f64c15841c9e7e46120e52",
+    "vendor/capa/features/extractors/dotnetfile.py": "d4530a0b64a0d6854cd89c79cdad63b1f076d041ad76cd0c82205588d70473b8",
+    "vendor/capa/features/extractors/drakvuf/call.py": "2d99a6d58ade1e597ff5668cf455586f4c296e1562f046d9b5b351aed2fa7f6b",
+    "vendor/capa/features/extractors/drakvuf/extractor.py": "c80ffe65f5ca5e927b8474b89a4778622339cdd55dcdfc53a971d749ba23ca55",
+    "vendor/capa/features/extractors/drakvuf/file.py": "2af51cf016b98c2b5214d4229bd64e99f7b8ea482541bcf2db56fe5e4140d2b9",
+    "vendor/capa/features/extractors/drakvuf/global_.py": "7c58e43f7f23856d9b3c5654fe7ea4935a75d4fb30de7c8e9f6ee0424317eb01",
+    "vendor/capa/features/extractors/drakvuf/helpers.py": "41362b1bef90d6977e071f2acbe196508a5b65e556434b79c59f6c1f213f8fd4",
+    "vendor/capa/features/extractors/drakvuf/models.py": "98aac89ddba3d01d2e632a70a819c6a0e34e27ca542aefb68da41fce9a81c7df",
+    "vendor/capa/features/extractors/drakvuf/process.py": "35548a615dd04d1e766de197493f41cbe9b670b2489b135fcc86e3b32e1c670e",
+    "vendor/capa/features/extractors/drakvuf/thread.py": "a55c37699a8dd09aa25c0d30d383d717466513f81d18a16e508b6e9b71286c76",
+    "vendor/capa/features/extractors/elf.py": "d593283dca2256af030dc146d7fc93de843f3ba016aac38bc479fefbc6d36226",
+    "vendor/capa/features/extractors/elffile.py": "b756b7670fd97f8f5d73c143c7e4fc6dfa0c4175a762214405adb024862e551b",
+    "vendor/capa/features/extractors/ghidra/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/capa/features/extractors/ghidra/basicblock.py": "57b99ee9c498b7355d12d9cfaef7059adb6c34bcf54c6f5de7b8fdd230693308",
+    "vendor/capa/features/extractors/ghidra/context.py": "e9e467378eb61c4efe5fed2a3e24fa1c322d2d1375370edce264947aaf6e8cf2",
+    "vendor/capa/features/extractors/ghidra/extractor.py": "1d4bb94a32d5de97d4b4ad7802b77cc34a5cd8cb4de4e184b3adb7af6af619de",
+    "vendor/capa/features/extractors/ghidra/file.py": "b6b6bf2c7197b7bb6a73db2fb0cf2a52f07433723fa6a4b30d6470f7fa4f1830",
+    "vendor/capa/features/extractors/ghidra/function.py": "67569b32d544f0a3822644a929b26532c79eac532c1e459da3518330ab95941b",
+    "vendor/capa/features/extractors/ghidra/global_.py": "7d93fabb6e8ce35d0b6b28322ef2b3108c5ad84cf35fc79c0e3d738f6161a03d",
+    "vendor/capa/features/extractors/ghidra/helpers.py": "fc71d08f451dd422f4e6fdcf707662e8fa7648eead34b0ed1c4eedc3f59c9884",
+    "vendor/capa/features/extractors/ghidra/insn.py": "9501a87c13130b1bb138a9813cae8bc87647750ee25141f05d5727cef4fad350",
+    "vendor/capa/features/extractors/helpers.py": "3a74da5cfcff2c7014a4c84e9e7237af2815e8f31617b332b838fb824ac4e085",
+    "vendor/capa/features/extractors/ida/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/capa/features/extractors/ida/basicblock.py": "ff89e4d1701979e8bb1a7430e561c01818f31ff4ad90100bb2be3f4f3e4a570a",
+    "vendor/capa/features/extractors/ida/extractor.py": "b83b30d9eaf262c14910ee208843471116772c2ca43ff033eb3046d6c40eb1c9",
+    "vendor/capa/features/extractors/ida/file.py": "c36d84e6564a6a888895883d5bad5541f65ee25b61b78000d2c3e9421d31a51e",
+    "vendor/capa/features/extractors/ida/function.py": "af70904ea796c6709ca181111452f91a3053886036c8c850002d2e9765a98cc8",
+    "vendor/capa/features/extractors/ida/global_.py": "06058b45d58d9a22528fad58d2c28af0050a65ad0cd328e512372566e1c1c2b6",
+    "vendor/capa/features/extractors/ida/helpers.py": "568124859eebc615d030aea7be03e32dc620e884c6fa1d57575393f857e69cd8",
+    "vendor/capa/features/extractors/ida/idalib.py": "a598abe2e4d290b3241098250eecaf2861bd7ea75fe10f39d3425625c38a9dfe",
+    "vendor/capa/features/extractors/ida/insn.py": "695d374c3b8e1a71b01d81b59d8dff5b3cb4ddcdcf6bbd1184cd608da10f3341",
+    "vendor/capa/features/extractors/loops.py": "ae544b0cad6da5c472b3abbbc58cf84fcfd8ba29d5a8d2f8798a5893507768e2",
+    "vendor/capa/features/extractors/null.py": "224dd08bc53c6fab7980c991a8c9a2889ba0f4fd087f0294d91bce34b904eae0",
+    "vendor/capa/features/extractors/pefile.py": "c97b5fa2f00124f5937a00f0f78b8f795a373a30dbee8558c5b7b91150a699e7",
+    "vendor/capa/features/extractors/strings.py": "6a4ebb77291b8e598a7c8cc19f282a1bdd593f6294c19279b3139e7d023799c2",
+    "vendor/capa/features/extractors/viv/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/capa/features/extractors/viv/basicblock.py": "9d7499d704f31eddee84a348b998b9c33e14d406cb18a4a8d884eaddcf16a1b2",
+    "vendor/capa/features/extractors/viv/extractor.py": "c47545a78b8638bd84fe8b4eec087249608823430f300050fba6595a1edd815b",
+    "vendor/capa/features/extractors/viv/file.py": "9901b1b2af24c03b4b7d947826865e9bcf4c8a5cc63f2e75c461e545ee5b967d",
+    "vendor/capa/features/extractors/viv/function.py": "501b80f14db804d9b6aaa23e38c09b31ab2c0a687dc0a56f1b1f035c6484f999",
+    "vendor/capa/features/extractors/viv/global_.py": "fb1875014869edfa1eef9a83c6021286a8b9179a549d5cdb5fad50bc33e6bccd",
+    "vendor/capa/features/extractors/viv/helpers.py": "c9b2fd92d6ae07c22c7f4146263861d93846b84195d767b623150851c56ed685",
+    "vendor/capa/features/extractors/viv/indirect_calls.py": "2787227b13ff3dbb6218b8e6528d36dcaf5445e51196f86172b18589cf1b3444",
+    "vendor/capa/features/extractors/viv/insn.py": "184d34ec258bf725415ed45e83a1d0f0e6d9a2d9c4df3d74680f71f07f6a7f27",
+    "vendor/capa/features/extractors/vmray/__init__.py": "35405864af7837a9e7d67d4670e90110d3db6f46000d559535ceb1d4ef78830b",
+    "vendor/capa/features/extractors/vmray/call.py": "56fc1c3ae4dccb32b8424028fd2af8f4834f977de9354bb925e5b777349b7ec7",
+    "vendor/capa/features/extractors/vmray/extractor.py": "b0c23cff85145f18723bab21a3debddc86783c319215a4a7803764ce5c966e7b",
+    "vendor/capa/features/extractors/vmray/file.py": "8b78b2ced74065e2d6409ebec3ba41744394591546d72d1b4c0b7f98ea97d2ff",
+    "vendor/capa/features/extractors/vmray/global_.py": "9660a07ab9c4448efd399b93c14c3173e241f48c65b3393f535a53d603c2d849",
+    "vendor/capa/features/extractors/vmray/models.py": "8a1f3b607e49048cd07f485f39b324e7ba918f1d70170741afc74208fc23ea00",
+    "vendor/capa/features/file.py": "0ebebea72576eabed7ac8ef969f474ac1cd115f9e5f801ebeba0531f4008ffd3",
+    "vendor/capa/features/freeze/__init__.py": "023a5ddb63e67b4a5c12001550a1cfdbba5c1f763007d7233e9e9c77943d5afb",
+    "vendor/capa/features/freeze/__main__.py": "9fc9901f416ad5b2e9d238e46fb5cfc94b12fe12cade230e8ca43cc4f1be1651",
+    "vendor/capa/features/freeze/features.py": "cbe79a81c0146a2961bb763a9b157f2daebbdb64aebc53861d2c8ae8e8952ad6",
+    "vendor/capa/features/insn.py": "c6c08dd8ca05c6ad9d4b6a050fd191f4412c3aa7ea2e6216634aca1f16175009",
+    "vendor/capa/helpers.py": "62854d9337422e03111a086a541488f4a1e89de2c132f83746454aec2118d710",
+    "vendor/capa/version.py": "379de2c4f16a18df933b0f467fc9f470c94753700f62010e9c4f1d59309a4db1",
+    "vendor/pyproject.toml": "53797e2fec66ace49ff88aa7dd0d14a0d43e7af37bf08f076ae966a93b4635a3"
+  },
+  "mutable": [
+    "vendor/capa/features/extractors/binja/file.py",
+    "vendor/capa/features/extractors/ghidra/file.py",
+    "vendor/capa/features/extractors/ida/file.py"
+  ],
+  "schema_version": "tbench.pristine_env_manifest.v1"
+}

tasks/candidate-1399-security-reverse-engineering/tests/fixtures/protected_hashes.json

@@ -0,0 +1,110 @@
+{
+ "Dockerfile": "fdc4026cc5e1301ffb6bdfd12f61c9d1591909ddf05501b43ef6ade47d01641f",
+ "tools/run_regression.py": "b757966156436ff3d300f3378ae5192da35253b8c3e0c022a7f0d4df71a17b16",
+ "vendor/LICENSE.txt": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30",
+ "vendor/capa/exceptions.py": "12adbe09bbc555fecb3dc5ee70643511fcc7ec5427d34e48635fb574493c8c72",
+ "vendor/capa/features/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+ "vendor/capa/features/address.py": "5b4945bfa4e35dc45cbe6d50b4bccbf46c0e09f570f9e57156fcb309dfb8033e",
+ "vendor/capa/features/basicblock.py": "efb5819ded8782e10a7b4c6fe24908dd9291f02edf9fe97a44e6d7bff229c352",
+ "vendor/capa/features/com/__init__.py": "12bdcd6a78dde3f652643e030ad776645c5d474bd12cf3a165744b9c6d47849f",
+ "vendor/capa/features/com/classes.py": "745f7f79e56b19dd2cf1dd487c6d45db2378081c16d2fca49a200686970c7f90",
+ "vendor/capa/features/com/interfaces.py": "774d6d3009169183fd4ee8b4be08184a32e729d14f4e7c90eb5b029af4a4d47b",
+ "vendor/capa/features/common.py": "b49ed429e273d091df6bc99455144eed885ca4a54150f3c6e53a4a3451dea17d",
+ "vendor/capa/features/extractors/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+ "vendor/capa/features/extractors/base_extractor.py": "c630308916f3ee7394ff1287a17360af9647de3af9b0bc14a9c9b9395e00310d",
+ "vendor/capa/features/extractors/binexport2/__init__.py": "46f9d90292b3bab1869212cfec46ada08012b7a5ab24fd65fccbfa88651a4f8a",
+ "vendor/capa/features/extractors/binexport2/arch/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+ "vendor/capa/features/extractors/binexport2/arch/arm/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+ "vendor/capa/features/extractors/binexport2/arch/arm/helpers.py": "785de2d90894ba28368d53c1c5cd38099858419b6b9ab5a976f49a04357e8d74",
+ "vendor/capa/features/extractors/binexport2/arch/arm/insn.py": "69908022eabbd5ebd95d66361c32e5691e5352eb8dadfd22b6d2100722c0aa9f",
+ "vendor/capa/features/extractors/binexport2/arch/intel/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+ "vendor/capa/features/extractors/binexport2/arch/intel/helpers.py": "03d9963f8f0e91816a51b6d2b3830e62d1d92bb01d9275384e0998e5298478bd",
+ "vendor/capa/features/extractors/binexport2/arch/intel/insn.py": "389bd3e526b2c282c0cc4f7c73904d5f611cd190cead029bf788f6cb97385645",
+ "vendor/capa/features/extractors/binexport2/basicblock.py": "aa27d712f7c6af5167a012464b2ab2fa619e20ca84f2ee654a90a4ac299c0944",
+ "vendor/capa/features/extractors/binexport2/binexport2_pb2.py": "9ade22c7cbafa07c7513cc3129d09fa3b12c73c6a6f8001267aab07db00eea86",
+ "vendor/capa/features/extractors/binexport2/binexport2_pb2.pyi": "d05c80ad5397be2dae91466bd5b6f15bef119bf6e23f1e4b76058e3707f06b06",
+ "vendor/capa/features/extractors/binexport2/extractor.py": "046c9f4792df8a8e50138e6cdefb087b3c6811fa196be1de911b0b3eec343ec2",
+ "vendor/capa/features/extractors/binexport2/file.py": "1598d35449a5ad4d6e036016d2c963072d3b8ce04785fad57836d3af6a6e71c3",
+ "vendor/capa/features/extractors/binexport2/function.py": "3cb828119b5303b004782a053c9bf37a4d09c45871c293767e7f2b1b455d02ad",
+ "vendor/capa/features/extractors/binexport2/helpers.py": "f4ef7546f41df482c15b75509e2b8557d9eeb8a6736c47a9331d4088b69046f4",
+ "vendor/capa/features/extractors/binexport2/insn.py": "a8ed39292e4b984186582e32ebd0f0a4d3b41beb4a1d1e4564f53ac4cee8c08f",
+ "vendor/capa/features/extractors/binja/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+ "vendor/capa/features/extractors/binja/basicblock.py": "463564d0c239661ecade35e40bfbd0920cf23ff6c1d2912a0f0ab1bcc870ed20",
+ "vendor/capa/features/extractors/binja/extractor.py": "f97bc7e306e038c40ddbe3a5cadafc2760ae0657f01487dca88425e2f7435834",
+ "vendor/capa/features/extractors/binja/find_binja_api.py": "d10bc8408ac9ab2f23c2fbd96957452c98cd90d35d81528d0b2fceb104494317",
+ "vendor/capa/features/extractors/binja/function.py": "824423ecbe46cad334ce3f793491651ee518f54664927b33647d40148655c8c2",
+ "vendor/capa/features/extractors/binja/global_.py": "5e6257e3a421851b23a6d4f660fbe2ff8708135e1e967a2050c8d7b2d23c32a1",
+ "vendor/capa/features/extractors/binja/helpers.py": "cebb5363b9998052ae4b2b4601e530ab25479a7b258932c128e38b675b7f944d",
+ "vendor/capa/features/extractors/binja/insn.py": "4d4b94227bc00fd97f985511479a4c14920cba2653dac784097da3aed276c01b",
+ "vendor/capa/features/extractors/cape/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+ "vendor/capa/features/extractors/cape/call.py": "10c6e38c6daf58a81cf67fa70d879ca781f9ca6e486ec6dcda2c65bc8e495928",
+ "vendor/capa/features/extractors/cape/extractor.py": "0368403ce98cbb3e0499fab06ea6e9e9745fd9c0f7a8e363e833c3a47abcc173",
+ "vendor/capa/features/extractors/cape/file.py": "3cbdf40c7e16fcf3174737f6dfb7a5a303523b5ddd7ee150d8322979cfb25752",
+ "vendor/capa/features/extractors/cape/global_.py": "36df9126e7e3cd5881c88c564185e87ee7162efa8fd2ddd60d6259464de07164",
+ "vendor/capa/features/extractors/cape/models.py": "fd7ec3b7dcd892b0dca80ca75592d49e30a7b172164f7b982d6bd0ee0e314755",
+ "vendor/capa/features/extractors/cape/process.py": "f57416634702332d64159bac35e8f6ba5e7f07e2240c4e13f927e38c83302a37",
+ "vendor/capa/features/extractors/cape/thread.py": "d6b1d27ec060c393e63f4c8b503d9bdbdbac84e249d4a6509fff3545b94b7192",
+ "vendor/capa/features/extractors/common.py": "d5df60e1b02006605505270cd2f7bebc2a715fa845a8e7607e33e5badad67cb1",
+ "vendor/capa/features/extractors/dnfile/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+ "vendor/capa/features/extractors/dnfile/extractor.py": "1a85560f9343a5dce72e3b3b336f8aaad2981698f8b76d0e363617415bf98231",
+ "vendor/capa/features/extractors/dnfile/file.py": "251e54168fd7f90d7a9e513010d3ffc703a2b25d3420f72cf3bec917bd806d86",
+ "vendor/capa/features/extractors/dnfile/function.py": "0c943f9aca13e17d1e64800892b973585e1d2f796f276ded6baacb180cc8389b",
+ "vendor/capa/features/extractors/dnfile/helpers.py": "553765220f6bf3ac933c49100b9c6d1468e81eeb66b646b912d68e86001e571e",
+ "vendor/capa/features/extractors/dnfile/insn.py": "9d8dada3ac8da1d1d02e5d74dd6ddd4334318b987732c0df884a6cde0fdac404",
+ "vendor/capa/features/extractors/dnfile/types.py": "11ceea648a028258c63e1481291a9fa1e4dbddbd43f64c15841c9e7e46120e52",
+ "vendor/capa/features/extractors/dotnetfile.py": "d4530a0b64a0d6854cd89c79cdad63b1f076d041ad76cd0c82205588d70473b8",
+ "vendor/capa/features/extractors/drakvuf/call.py": "2d99a6d58ade1e597ff5668cf455586f4c296e1562f046d9b5b351aed2fa7f6b",
+ "vendor/capa/features/extractors/drakvuf/extractor.py": "c80ffe65f5ca5e927b8474b89a4778622339cdd55dcdfc53a971d749ba23ca55",
+ "vendor/capa/features/extractors/drakvuf/file.py": "2af51cf016b98c2b5214d4229bd64e99f7b8ea482541bcf2db56fe5e4140d2b9",
+ "vendor/capa/features/extractors/drakvuf/global_.py": "7c58e43f7f23856d9b3c5654fe7ea4935a75d4fb30de7c8e9f6ee0424317eb01",
+ "vendor/capa/features/extractors/drakvuf/helpers.py": "41362b1bef90d6977e071f2acbe196508a5b65e556434b79c59f6c1f213f8fd4",
+ "vendor/capa/features/extractors/drakvuf/models.py": "98aac89ddba3d01d2e632a70a819c6a0e34e27ca542aefb68da41fce9a81c7df",
+ "vendor/capa/features/extractors/drakvuf/process.py": "35548a615dd04d1e766de197493f41cbe9b670b2489b135fcc86e3b32e1c670e",
+ "vendor/capa/features/extractors/drakvuf/thread.py": "a55c37699a8dd09aa25c0d30d383d717466513f81d18a16e508b6e9b71286c76",
+ "vendor/capa/features/extractors/elf.py": "d593283dca2256af030dc146d7fc93de843f3ba016aac38bc479fefbc6d36226",
+ "vendor/capa/features/extractors/elffile.py": "b756b7670fd97f8f5d73c143c7e4fc6dfa0c4175a762214405adb024862e551b",
+ "vendor/capa/features/extractors/ghidra/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+ "vendor/capa/features/extractors/ghidra/basicblock.py": "57b99ee9c498b7355d12d9cfaef7059adb6c34bcf54c6f5de7b8fdd230693308",
+ "vendor/capa/features/extractors/ghidra/context.py": "e9e467378eb61c4efe5fed2a3e24fa1c322d2d1375370edce264947aaf6e8cf2",
+ "vendor/capa/features/extractors/ghidra/extractor.py": "1d4bb94a32d5de97d4b4ad7802b77cc34a5cd8cb4de4e184b3adb7af6af619de",
+ "vendor/capa/features/extractors/ghidra/function.py": "67569b32d544f0a3822644a929b26532c79eac532c1e459da3518330ab95941b",
+ "vendor/capa/features/extractors/ghidra/global_.py": "7d93fabb6e8ce35d0b6b28322ef2b3108c5ad84cf35fc79c0e3d738f6161a03d",
+ "vendor/capa/features/extractors/ghidra/helpers.py": "fc71d08f451dd422f4e6fdcf707662e8fa7648eead34b0ed1c4eedc3f59c9884",
+ "vendor/capa/features/extractors/ghidra/insn.py": "9501a87c13130b1bb138a9813cae8bc87647750ee25141f05d5727cef4fad350",
+ "vendor/capa/features/extractors/helpers.py": "3a74da5cfcff2c7014a4c84e9e7237af2815e8f31617b332b838fb824ac4e085",
+ "vendor/capa/features/extractors/ida/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+ "vendor/capa/features/extractors/ida/basicblock.py": "ff89e4d1701979e8bb1a7430e561c01818f31ff4ad90100bb2be3f4f3e4a570a",
+ "vendor/capa/features/extractors/ida/extractor.py": "b83b30d9eaf262c14910ee208843471116772c2ca43ff033eb3046d6c40eb1c9",
+ "vendor/capa/features/extractors/ida/function.py": "af70904ea796c6709ca181111452f91a3053886036c8c850002d2e9765a98cc8",
+ "vendor/capa/features/extractors/ida/global_.py": "06058b45d58d9a22528fad58d2c28af0050a65ad0cd328e512372566e1c1c2b6",
+ "vendor/capa/features/extractors/ida/helpers.py": "568124859eebc615d030aea7be03e32dc620e884c6fa1d57575393f857e69cd8",
+ "vendor/capa/features/extractors/ida/idalib.py": "a598abe2e4d290b3241098250eecaf2861bd7ea75fe10f39d3425625c38a9dfe",
+ "vendor/capa/features/extractors/ida/insn.py": "695d374c3b8e1a71b01d81b59d8dff5b3cb4ddcdcf6bbd1184cd608da10f3341",
+ "vendor/capa/features/extractors/loops.py": "ae544b0cad6da5c472b3abbbc58cf84fcfd8ba29d5a8d2f8798a5893507768e2",
+ "vendor/capa/features/extractors/null.py": "224dd08bc53c6fab7980c991a8c9a2889ba0f4fd087f0294d91bce34b904eae0",
+ "vendor/capa/features/extractors/pefile.py": "c97b5fa2f00124f5937a00f0f78b8f795a373a30dbee8558c5b7b91150a699e7",
+ "vendor/capa/features/extractors/strings.py": "6a4ebb77291b8e598a7c8cc19f282a1bdd593f6294c19279b3139e7d023799c2",
+ "vendor/capa/features/extractors/viv/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+ "vendor/capa/features/extractors/viv/basicblock.py": "9d7499d704f31eddee84a348b998b9c33e14d406cb18a4a8d884eaddcf16a1b2",
+ "vendor/capa/features/extractors/viv/extractor.py": "c47545a78b8638bd84fe8b4eec087249608823430f300050fba6595a1edd815b",
+ "vendor/capa/features/extractors/viv/file.py": "9901b1b2af24c03b4b7d947826865e9bcf4c8a5cc63f2e75c461e545ee5b967d",
+ "vendor/capa/features/extractors/viv/function.py": "501b80f14db804d9b6aaa23e38c09b31ab2c0a687dc0a56f1b1f035c6484f999",
+ "vendor/capa/features/extractors/viv/global_.py": "fb1875014869edfa1eef9a83c6021286a8b9179a549d5cdb5fad50bc33e6bccd",
+ "vendor/capa/features/extractors/viv/helpers.py": "c9b2fd92d6ae07c22c7f4146263861d93846b84195d767b623150851c56ed685",
+ "vendor/capa/features/extractors/viv/indirect_calls.py": "2787227b13ff3dbb6218b8e6528d36dcaf5445e51196f86172b18589cf1b3444",
+ "vendor/capa/features/extractors/viv/insn.py": "184d34ec258bf725415ed45e83a1d0f0e6d9a2d9c4df3d74680f71f07f6a7f27",
+ "vendor/capa/features/extractors/vmray/__init__.py": "35405864af7837a9e7d67d4670e90110d3db6f46000d559535ceb1d4ef78830b",
+ "vendor/capa/features/extractors/vmray/call.py": "56fc1c3ae4dccb32b8424028fd2af8f4834f977de9354bb925e5b777349b7ec7",
+ "vendor/capa/features/extractors/vmray/extractor.py": "b0c23cff85145f18723bab21a3debddc86783c319215a4a7803764ce5c966e7b",
+ "vendor/capa/features/extractors/vmray/file.py": "8b78b2ced74065e2d6409ebec3ba41744394591546d72d1b4c0b7f98ea97d2ff",
+ "vendor/capa/features/extractors/vmray/global_.py": "9660a07ab9c4448efd399b93c14c3173e241f48c65b3393f535a53d603c2d849",
+ "vendor/capa/features/extractors/vmray/models.py": "8a1f3b607e49048cd07f485f39b324e7ba918f1d70170741afc74208fc23ea00",
+ "vendor/capa/features/file.py": "0ebebea72576eabed7ac8ef969f474ac1cd115f9e5f801ebeba0531f4008ffd3",
+ "vendor/capa/features/freeze/__init__.py": "023a5ddb63e67b4a5c12001550a1cfdbba5c1f763007d7233e9e9c77943d5afb",
+ "vendor/capa/features/freeze/__main__.py": "9fc9901f416ad5b2e9d238e46fb5cfc94b12fe12cade230e8ca43cc4f1be1651",
+ "vendor/capa/features/freeze/features.py": "cbe79a81c0146a2961bb763a9b157f2daebbdb64aebc53861d2c8ae8e8952ad6",
+ "vendor/capa/features/insn.py": "c6c08dd8ca05c6ad9d4b6a050fd191f4412c3aa7ea2e6216634aca1f16175009",
+ "vendor/capa/helpers.py": "62854d9337422e03111a086a541488f4a1e89de2c132f83746454aec2118d710",
+ "vendor/capa/version.py": "379de2c4f16a18df933b0f467fc9f470c94753700f62010e9c4f1d59309a4db1",
+ "vendor/pyproject.toml": "53797e2fec66ace49ff88aa7dd0d14a0d43e7af37bf08f076ae966a93b4635a3"
+}

tasks/candidate-1399-security-reverse-engineering/tests/task_test.sh

@@ -0,0 +1,23 @@
+#!/bin/sh
+set -eu
+mkdir -p /logs/verifier
+set +e
+# tbench-anti-hack-guard:v1
+export PYTHONNOUSERSITE=1
+export PYTHONDONTWRITEBYTECODE=1
+# Fail open when the verifier image has no python3 (node-only tests images are
+# excluded from the RL set but still verifiable natively): a missing
+# interpreter must not swallow the grader's own reward write.
+if command -v python3 >/dev/null 2>&1 && [ -f /tests/anti_hack_guard.py ]; then
+  if ! python3 /tests/anti_hack_guard.py; then
+    # Guard already wrote reward=0; the reward file is the grading contract.
+    exit 0
+  fi
+fi
+
+
+python3 -m pytest --ctrf /logs/verifier/ctrf.json -q /tests/test_outputs.py
+status=$?
+set -e
+if [ "$status" -eq 0 ]; then echo 1 > /logs/verifier/reward.txt; else echo 0 > /logs/verifier/reward.txt; fi
+exit 0

tasks/candidate-1399-security-reverse-engineering/tests/test.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+# Terminal-Bench grading: the task's own test script (task_test.sh here) writes /logs/verifier/reward.txt.
+# "-1" there is its crash sentinel: a testbed failure, so no reward is written (not scored).
+CWD=/app
+mkdir -p /logs/verifier
+# the task's anti-hack guard rejects files planted in the workspace: drop what agent harnesses leave there
+for d in .opencode .claude .codex .gemini .goose .aider.tags.cache.v4; do
+  grep -qx "$d" /var/lib/mimo/before 2>/dev/null || rm -rf "$CWD/$d"
+done
+cd "$CWD" && bash /tests/task_test.sh
+R=$(cat /logs/verifier/reward.txt 2>/dev/null | tr -d '[:space:]')
+if [ -z "$R" ] || [ "$R" = "-1" ]; then
+  rm -f /logs/verifier/reward.txt
+  echo "the tests crashed before grading (reward '${R}'): not scored" >&2
+  exit 1
+fi

tasks/candidate-1399-security-reverse-engineering/tests/test_outputs.py

@@ -0,0 +1,299 @@
+from __future__ import annotations
+
+import ast
+import hashlib
+import json
+from pathlib import Path
+from types import SimpleNamespace
+
+
+ROOT = Path("/app")
+EXTRACTORS = ROOT / "vendor/capa/features/extractors"
+OUT = ROOT / "output.json"
+
+
+class Feature:
+    def __init__(self, value: str):
+        self.value = value
+
+
+class String(Feature):
+    pass
+
+
+class Characteristic(Feature):
+    pass
+
+
+class Address(int):
+    pass
+
+
+class AbsoluteVirtualAddress(Address):
+    pass
+
+
+class FileOffsetAddress(Address):
+    pass
+
+
+class GhidraAddress:
+    def __init__(self, value: int):
+        self.value = value
+
+    def add(self, offset: int):
+        return GhidraAddress(self.value + offset)
+
+    def getOffset(self):
+        return self.value
+
+
+class GhidraBlock:
+    def __init__(self, start: int, data: bytes, name: str):
+        self.start = GhidraAddress(start)
+        self.data = data
+        self.name = name
+
+    def getStart(self):
+        return self.start
+
+    def getName(self):
+        return self.name
+
+    def isLoaded(self):
+        return True
+
+    def isInitialized(self):
+        return True
+
+
+class GhidraProgram:
+    def __init__(self, blocks):
+        self.blocks = blocks
+
+    def getMemory(self):
+        return SimpleNamespace(getBlocks=lambda: self.blocks)
+
+
+class IdaSegment:
+    def __init__(self, start: int):
+        self.start_ea = start
+
+
+class BinjaSegment:
+    def __init__(self):
+        self.start = 0x810000
+        self.data_offset = 0x1800
+        self.data_length = 0x400
+        self.length = 0x400
+
+
+class BinjaView:
+    view_type = "Raw"
+    start = 0
+
+    def __init__(self, segment):
+        self.segment = segment
+        self.strings = [
+            SimpleNamespace(start=0x810031, value="alpha-ascii"),
+            SimpleNamespace(start=0x8100A0, value="beta-wide"),
+        ]
+
+    def get_segment_at(self, address):
+        return self.segment if self.segment.start <= address < self.segment.start + self.segment.length else None
+
+    def read(self, _start, length):
+        return bytes(length)
+
+
+def load_function(relative_path: str, name: str, globals_: dict):
+    path = ROOT / relative_path
+    tree = ast.parse(path.read_text(), filename=str(path))
+    function = next(node for node in tree.body if isinstance(node, ast.FunctionDef) and node.name == name)
+    module = ast.Module(
+        body=[ast.ImportFrom(module="__future__", names=[ast.alias(name="annotations")], level=0), function],
+        type_ignores=[],
+    )
+    namespace = dict(globals_)
+    exec(compile(ast.fix_missing_locations(module), str(path), "exec"), namespace)
+    return namespace[name]
+
+
+def encode(items):
+    return [(feature.value, type(address).__name__, int(address)) for feature, address in items]
+
+
+def recompute_strings():
+    ghidra_block = GhidraBlock(0x401000, b"fixture", "strings")
+    ghidra_helpers = SimpleNamespace(
+        get_current_program=lambda: GhidraProgram([ghidra_block]),
+        get_block_bytes=lambda block: block.data,
+        get_file_offset=lambda address: {0x401023: 0x223, 0x4010B0: 0x2B0}.get(address.getOffset(), -1),
+    )
+    ghidra_capa = SimpleNamespace(
+        features=SimpleNamespace(
+            extractors=SimpleNamespace(
+                strings=SimpleNamespace(
+                    extract_ascii_strings=lambda _data: [SimpleNamespace(offset=0x23, s="alpha-ascii")],
+                    extract_unicode_strings=lambda _data: [SimpleNamespace(offset=0xB0, s="beta-wide")],
+                ),
+                ghidra=SimpleNamespace(helpers=ghidra_helpers),
+            )
+        )
+    )
+    ghidra = load_function(
+        "vendor/capa/features/extractors/ghidra/file.py",
+        "extract_file_strings",
+        {"capa": ghidra_capa, "String": String, "AbsoluteVirtualAddress": AbsoluteVirtualAddress, "FileOffsetAddress": FileOffsetAddress},
+    )
+
+    ida_segment = IdaSegment(0x710000)
+    ida_capa = SimpleNamespace(
+        features=SimpleNamespace(
+            extractors=SimpleNamespace(
+                strings=SimpleNamespace(
+                    extract_ascii_strings=lambda _data: [SimpleNamespace(offset=0x19, s="alpha-ascii")],
+                    extract_unicode_strings=lambda _data: [SimpleNamespace(offset=0x88, s="beta-wide")],
+                ),
+                ida=SimpleNamespace(
+                    helpers=SimpleNamespace(get_segments=lambda **_kwargs: [ida_segment], get_segment_buffer=lambda _seg: b"fixture")
+                ),
+            )
+        )
+    )
+    ida_loader = SimpleNamespace(get_fileregion_offset=lambda address: {0x710019: 0x319, 0x710088: 0x388}.get(address, -1))
+    ida = load_function(
+        "vendor/capa/features/extractors/ida/file.py",
+        "extract_file_strings",
+        {"capa": ida_capa, "ida_loader": ida_loader, "String": String, "AbsoluteVirtualAddress": AbsoluteVirtualAddress, "FileOffsetAddress": FileOffsetAddress},
+    )
+
+    binja_segment = BinjaSegment()
+    binja_view = BinjaView(binja_segment)
+    binja = load_function(
+        "vendor/capa/features/extractors/binja/file.py",
+        "extract_file_strings",
+        {"String": String, "AbsoluteVirtualAddress": AbsoluteVirtualAddress, "FileOffsetAddress": FileOffsetAddress},
+    )
+    return {
+        "ghidra": encode(ghidra()),
+        "ida": encode(ida()),
+        "binja": encode(binja(binja_view)),
+    }
+
+
+def recompute_embedded():
+    ghidra_blocks = [GhidraBlock(0x510000, b"mapped", "mapped"), GhidraBlock(0x620000, b"unmapped", "unmapped")]
+    ghidra_helpers = SimpleNamespace(
+        get_current_program=lambda: GhidraProgram(ghidra_blocks),
+        get_block_bytes=lambda block: block.data,
+        get_file_offset=lambda address: 0x940 if address.getOffset() == 0x510040 else -1,
+    )
+    ghidra_capa = SimpleNamespace(
+        features=SimpleNamespace(
+            extractors=SimpleNamespace(
+                helpers=SimpleNamespace(xor_static=lambda data, _key: data),
+                ghidra=SimpleNamespace(helpers=ghidra_helpers),
+            )
+        )
+    )
+    ghidra = load_function(
+        "vendor/capa/features/extractors/ghidra/file.py",
+        "extract_file_embedded_pe",
+        {
+            "capa": ghidra_capa,
+            "find_embedded_pe": lambda _data, _pairs: [(0x40, 0)],
+            "Characteristic": Characteristic,
+            "AbsoluteVirtualAddress": AbsoluteVirtualAddress,
+            "FileOffsetAddress": FileOffsetAddress,
+        },
+    )
+
+    ida_segment = IdaSegment(0x710000)
+    ida_capa = SimpleNamespace(
+        features=SimpleNamespace(extractors=SimpleNamespace(ida=SimpleNamespace(helpers=SimpleNamespace(get_segments=lambda **_kwargs: [ida_segment]))))
+    )
+    ida = load_function(
+        "vendor/capa/features/extractors/ida/file.py",
+        "extract_file_embedded_pe",
+        {
+            "capa": ida_capa,
+            "ida_loader": SimpleNamespace(get_fileregion_offset=lambda address: 0x1240 if address == 0x710240 else -1),
+            "check_segment_for_pe": lambda _segment: [(0x710240, 0)],
+            "Characteristic": Characteristic,
+            "FileOffsetAddress": FileOffsetAddress,
+        },
+    )
+
+    segment = BinjaSegment()
+    view = BinjaView(segment)
+    binja_capa = SimpleNamespace(
+        features=SimpleNamespace(extractors=SimpleNamespace(helpers=SimpleNamespace(carve_pe=lambda _data, _start: [(0xA4, 0)])))
+    )
+    binja = load_function(
+        "vendor/capa/features/extractors/binja/file.py",
+        "check_segment_for_pe",
+        {"capa": binja_capa, "Characteristic": Characteristic, "FileOffsetAddress": FileOffsetAddress},
+    )
+    ghidra_items = encode(ghidra())
+    return {
+        "ghidra_mapped": ghidra_items[:1],
+        "ghidra_unmapped": ghidra_items[1:],
+        "ida_mapped": encode(ida()),
+        "binja_mapped": encode(binja(view, segment)),
+    }
+
+
+def artifact_tuples(data, section, key):
+    return [(item["feature"], item["address_class"], item["address"]) for item in data[section][key]]
+
+
+def test_gate_artifact_schema_and_protected_tree():
+    schema = json.loads(Path("/tests/fixtures/expected_schema.json").read_text())
+    data = json.loads(OUT.read_text())
+    assert data["output_schema_version"] == schema["output_schema_version"]
+    assert set(data) == {"output_schema_version", "string_features", "embedded_pe", "downstream_compatibility"}
+    assert set(data["string_features"]) == set(schema["required_backends"])
+    assert set(data["embedded_pe"]) == set(schema["required_embedded_cases"])
+    protected = json.loads(Path("/tests/fixtures/protected_hashes.json").read_text())
+    for relative_path, expected_hash in protected.items():
+        assert hashlib.sha256((ROOT / relative_path).read_bytes()).hexdigest() == expected_hash
+
+
+def test_core_string_extractors_execute_with_virtual_addresses():
+    expected = {
+        "ghidra": [("alpha-ascii", "AbsoluteVirtualAddress", 0x401023), ("beta-wide", "AbsoluteVirtualAddress", 0x4010B0)],
+        "ida": [("alpha-ascii", "AbsoluteVirtualAddress", 0x710019), ("beta-wide", "AbsoluteVirtualAddress", 0x710088)],
+        "binja": [("alpha-ascii", "AbsoluteVirtualAddress", 0x810031), ("beta-wide", "AbsoluteVirtualAddress", 0x8100A0)],
+    }
+    observed = recompute_strings()
+    assert observed == expected
+    data = json.loads(OUT.read_text())
+    for backend in expected:
+        assert artifact_tuples(data, "string_features", backend) == expected[backend]
+
+
+def test_core_embedded_extractors_preserve_backend_mapping_rules():
+    expected = {
+        "ghidra_mapped": [("embedded pe", "FileOffsetAddress", 0x940)],
+        "ghidra_unmapped": [("embedded pe", "AbsoluteVirtualAddress", 0x620040)],
+        "ida_mapped": [("embedded pe", "FileOffsetAddress", 0x1240)],
+        "binja_mapped": [("embedded pe", "FileOffsetAddress", 0x18A4)],
+    }
+    observed = recompute_embedded()
+    assert observed == expected
+    data = json.loads(OUT.read_text())
+    for case in expected:
+        assert artifact_tuples(data, "embedded_pe", case) == expected[case]
+
+
+def test_edge_coordinate_domains_and_feature_values_remain_distinct():
+    strings = recompute_strings()
+    embedded = recompute_embedded()
+    assert all([item[0] for item in strings[backend]] == ["alpha-ascii", "beta-wide"] for backend in strings)
+    assert strings["ghidra"][0][2] != 0x223
+    assert strings["ida"][0][2] != 0x319
+    assert strings["binja"][0][2] != 0x1831
+    assert embedded["ghidra_mapped"][0][1] != embedded["ghidra_unmapped"][0][1]
+    compatibility = json.loads(OUT.read_text())["downstream_compatibility"]
+    assert compatibility == {"address_domains_distinct": True, "feature_values_preserved": True}

tasks/candidate-1442-software-languages/environment/Dockerfile

@@ -0,0 +1,3 @@
+# The task's image, pinned by digest (the same as [environment].docker_image).
+# Setup runs at start from [environment.healthcheck]; environment/setup/ is its readable copy.
+FROM docker.io/xiaomimimo/mimo-v2.6-rl-oss@sha256:01477582487894e1982905b5a201d8eab0e426f2a426d7941cfadae6c672bc47

tasks/candidate-1442-software-languages/environment/setup/setup.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+# Runs once, as root, before the agent starts: Harbor's [environment.healthcheck] unpacks this folder into
+# /var/lib/mimo and runs it. Generated by mimo_harbor; see its README for how each step maps to Xiaomi's harness.
+M=/var/lib/mimo
+[ -f "$M/ready" ] && exit 0
+chmod 700 "$M"
+fail() { echo "setup: $*" >&2; exit 1; }
+# the answer-leak blocklist (mimoagent), applied to /etc/hosts by the agent right after it installs
+write_blocklist() { cp "$M/files/blocklist" "$M/blocklist"; }
+
+# Terminal-Bench rows (in the General domain): the Harbor convention itself. Scrub test leftovers from the image and
+# remember what was in the workspace, so harness residue can be told apart from the agent's work at grading time.
+rm -rf /tests
+find /logs/verifier -mindepth 1 -delete 2>/dev/null || true
+ls -A /app 2>/dev/null > "$M/before" || true
+
+touch "$M/ready"
+echo "setup done"

tasks/candidate-1442-software-languages/instruction.md

@@ -0,0 +1,52 @@
+You are an agent, your current working directory is /app.
+
+You can use the tools available to you to interact with the computer to assist the user in completing tasks.
+
+# Task: repair wheel interpreter-tag validation
+
+The frozen library in `/app/vendor/packaging` accepts malformed wheel interpreter-tag
+members and expands them into `Tag` objects. Repair the existing parser pipeline.
+
+## Required behavior
+
+1. In `src/packaging/tags.py`, every member of the interpreter field in a direct
+   `parse_tag()` call must be a non-empty valid Python identifier. Invalid members must
+   raise `packaging.tags.InvalidTag` with an informative message that identifies the
+   interpreter problem and the offending member.
+2. In `src/packaging/utils.py`, `parse_wheel_filename()` must translate that failure to
+   `packaging.utils.InvalidWheelFilename`. Its message must preserve useful interpreter
+   validation context and identify the rejected wheel filename. Do not expose a chained
+   internal parser exception for this validation failure.
+3. Preserve valid behavior: compressed interpreter identifiers still expand as a set;
+   ABI and platform members retain their distinct syntax; version/name normalization,
+   build-tag parsing, order validation, empty-component validation, and tag-count limits
+   must continue to work.
+4. Make substantive repairs in both existing production modules above. Do not replace
+   the package, edit its tests to hide failures, disable validation, or special-case one
+   filename.
+
+## Required artifact
+
+After repairing and checking the source, write `/app/repair_report.json` with this public
+contract:
+
+```json
+{
+  "output_schema_version": "tbench.packaging_repair_report.v1",
+  "status": "repaired",
+  "source_files": [
+    "vendor/packaging/src/packaging/tags.py",
+    "vendor/packaging/src/packaging/utils.py"
+  ],
+  "checks": {
+    "direct_invalid_rejected": true,
+    "wheel_invalid_wrapped": true,
+    "valid_compressed_preserved": true,
+    "abi_platform_preserved": true
+  }
+}
+```
+
+You may include additional fields, but the declared fields and values must be present.
+The verifier independently imports and exercises the repaired source; a fabricated
+report does not pass.

tasks/candidate-1442-software-languages/task.toml

@@ -0,0 +1,39 @@
+schema_version = "1.4"
+
+[task]
+name = "mimo-v2.6-rl/candidate-1442-software-languages"
+description = "MiMo-V2.6-RL terminal task candidate-1442-software-languages"
+keywords = ["mimo-v2.6-rl", "terminal"]
+
+[metadata]
+adapter = "mimo_harbor 1.0.0"
+domain = "terminal"
+original_allow_internet = false
+reference_harness = "XiaomiMiMo/verl a2ad9f6 + XiaomiMiMo/mimoagent 467f0a1"
+reference_step_limit = 500
+source_dataset = "XiaomiMiMo/MiMo-V2.6-RL-oss"
+source_id = "candidate-1442-software-languages"
+source_revision = "639865fd3374018d6cb29b9fb82dd531406fcf5f"
+
+[agent]
+timeout_sec = 900.0
+
+[verifier]
+timeout_sec = 240.0
+user = "root"
+
+[environment]
+docker_image = "docker.io/xiaomimimo/mimo-v2.6-rl-oss@sha256:01477582487894e1982905b5a201d8eab0e426f2a426d7941cfadae6c672bc47"
+workdir = "/app"
+cpus = 1
+memory_mb = 2048
+storage_mb = 10240
+network_mode = "public"
+build_timeout_sec = 1800.0
+
+[environment.healthcheck]
+# one-time setup before the agent (environment/setup/setup.sh)
+command = "bash -c 'test -f /var/lib/mimo/ready || { mkdir -p /var/lib/mimo && echo H4sIAAAAAAAC/+2T30/UQBDH77l/xddCEAx3PVAhgUiCkegLL+iDCSFk206vm9vuNrvbq0T83532gJP4qr44n5e2+2PmO9+ZBopdOwv15C8yZ47n8/E5//158Pbo8PH9Yf34zeujCeaTf0AXovKccvJ/svUiy7XNchXqZAtXnQ1wtqB9qADvXNxHTpXzhFgT1IJsxGBYDCf4pHzu/MuAa7Ir7Z1teHdWkzKxLmoqljfobKuKZeDLOqBypiQPbaPjVNlK+czoPGt046BsCT8k13GGj2TJq0gl8jsM27f1mOoUgYhPBFxdnH+4vOCIHrXrQaqoWRa1aFTL2Ry+auUazdr4pqUQZsnlu2cZk2tMK6Tbl5knVd6luMHODuibjpgnRd24Ejyyw4E0qZQ2u3v4DipqhzQMv8wJtl+lONs5PF1fOjjFD65qdMmGnvzUkFoiN65YGh0idoeso4F7bG7bGs31sdKMYpHVLnBVXO3GZa8XdYSq4mBZZNfYdmNC0nsd6fYp7qiraMdKKm0oZE9b6bi4+RwUssQv5BttlZm+J8u2edcH7Go7pl47b1C6Rmm7dzIurvuMwtkVC9PODi0gU83wufBdjkhcnqEquhV5brN3zXhPN1zJ0FlO6qmhJudS+lpF9DxcDxl755eBh4QnLrjHbvHxoMuOUCjL88c2mZI947HbRB9d4gYPAcAxF16V2i4QdUOzxDeY+grZoC0klebxyoxbhIwl6kqzkCmbUFIbaxxgWpKhSDg8y0paZbYzBvf3iL6jxARMz5Fxx55tn63NHf+N9OlwEl3Hnm7GKvllZNhVS2kyEQRBEARBEARBEARBEARBEARBEARBEARBEIQ/xk8LxjaZACgAAA== | base64 -d | tar -xzf - -C /var/lib/mimo && bash /var/lib/mimo/setup.sh; }'"
+timeout_sec = 1200.0
+retries = 0
+interval_sec = 5.0

tasks/candidate-1442-software-languages/tests/anti_hack_guard.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""TBench in-pod anti-hack guard.
+
+Runs at the very start of ``tests/test.sh``, inside the verifier container,
+after the agent's ``/app`` has been copied in.  The RL harness materialises
+``tests/`` into the MAIN container only after the agent exits, so the agent
+cannot see or tamper with this file — which makes it the right place to reject
+workspace pollution the agent planted during the episode.
+
+Detection (any hit -> write reward=0 and exit non-zero):
+
+1. **Planted interpreter hooks.**  ``conftest.py`` / ``sitecustomize.py`` /
+   ``usercustomize.py`` / ``*.pth`` / ``pytest.ini`` / ``.coveragerc`` /
+   ``tox.ini`` anywhere under ``/app`` whose path is NOT listed in the pristine
+   manifest.  Upstream vendor trees that legitimately ship a ``conftest.py``
+   are listed in the manifest and are therefore not false positives.
+2. **Protected-file mutation.**  Any manifest entry whose sha256 changed while
+   its path is outside the declared mutable set.
+3. **Protected-file deletion.**  Any non-mutable, non-artifact manifest entry
+   that vanished.
+
+The manifest is generated from the pristine ``environment/`` tree and shipped
+as ``tests/fixtures/pristine_env_manifest.json``.  A missing manifest degrades to
+name-only detection so the guard never blocks an uninstrumented task.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sys
+from pathlib import Path
+
+SCHEMA = "tbench.pristine_env_manifest.v1"
+
+APP = Path(os.environ.get("TBENCH_APP_ROOT", "/app"))
+FIXTURES = Path(os.environ.get("TBENCH_FIXTURES", "/tests/fixtures"))
+MANIFEST = FIXTURES / "pristine_env_manifest.json"
+REWARD = Path(os.environ.get("TBENCH_REWARD_FILE", "/logs/verifier/reward.txt"))
+
+DANGEROUS_NAMES = {
+    "conftest.py",
+    "sitecustomize.py",
+    "usercustomize.py",
+    "pytest.ini",
+    ".coveragerc",
+    "tox.ini",
+    "pyproject.toml",  # only dangerous when planted; upstream copies are in the manifest
+}
+
+
+def sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def is_dangerous(rel: str) -> bool:
+    name = rel.rsplit("/", 1)[-1]
+    return name in DANGEROUS_NAMES or name.endswith(".pth")
+
+
+def load_manifest() -> dict | None:
+    if not MANIFEST.is_file():
+        return None
+    try:
+        doc = json.loads(MANIFEST.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    if not isinstance(doc, dict) or not isinstance(doc.get("files"), dict):
+        return None
+    return doc
+
+
+def reject(reason: str, reward: Path | None = None) -> int:
+    target = REWARD if reward is None else reward
+    try:
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text("0\n", encoding="utf-8")
+    except OSError as exc:  # pragma: no cover - reward file is the contract
+        print(f"anti_hack_guard: cannot write reward file: {exc}", file=sys.stderr)
+        return 2
+    print(f"anti_hack_guard: REJECT {reason}", file=sys.stderr)
+    return 1
+
+
+def scan(manifest: dict | None, app: Path | None = None) -> str | None:
+    app_root = APP if app is None else app
+    files: dict[str, str] = (manifest or {}).get("files") or {}
+    mutable_set = {
+        entry.lstrip("/")
+        for entry in (manifest or {}).get("mutable") or []
+        if isinstance(entry, str)
+    }
+    artifacts = {
+        str(entry).removeprefix("/app/").lstrip("/")
+        for entry in (manifest or {}).get("artifacts") or []
+        if isinstance(entry, str)
+    }
+
+    if not app_root.is_dir():
+        return None
+
+    for path in sorted(app_root.rglob("*")):
+        if not path.is_file() or path.is_symlink():
+            continue
+        rel = path.relative_to(app_root).as_posix()
+        if is_dangerous(rel) and rel not in files:
+            return f"planted_interpreter_hook:{rel}"
+
+    if manifest is None:
+        return None
+
+    # Deletion detection is only sound when the built image is known to equal
+    # the source tree (plain ``COPY . /app``).  A multi-stage or dockerignored
+    # build legitimately omits files, and rejecting those would zero out the
+    # oracle for a perfectly good task.
+    detect_deletion = bool(manifest.get("detect_deletion", True))
+    for rel, expected in files.items():
+        if rel in mutable_set or rel in artifacts:
+            continue
+        path = app_root / rel
+        if not path.exists():
+            if detect_deletion:
+                return f"protected_file_deleted:{rel}"
+            continue
+        if not path.is_file():
+            continue
+        if sha256(path) != expected:
+            return f"protected_file_mutated:{rel}"
+    return None
+
+
+def main(app: Path | None = None, reward: Path | None = None) -> int:
+    manifest = load_manifest()
+    reason = scan(manifest, app=app)
+    if reason:
+        return reject(reason, reward=reward)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

tasks/candidate-1442-software-languages/tests/fixtures/base_mutable_hashes.json

@@ -0,0 +1,4 @@
+{
+  "src/packaging/tags.py": "cb6d67388b647f87e4e83b89a005949e682c6b804f4b7f2bb0a2853e6d15b590",
+  "src/packaging/utils.py": "0074d32bf98c4bc4a400507c499615ac8c29b09a456d538422d82fd39640c8aa"
+}

tasks/candidate-1442-software-languages/tests/fixtures/immutable_hashes.json

@@ -0,0 +1,15 @@
+{
+  "src/packaging/__init__.py": "bf01887ad0f4a9fa9e3b9cd4601dc40a7b2970b5c808cde59e64c4aa1e797c91",
+  "src/packaging/_elffile.py": "1f025f54c573f1a85740c4fbd908cc1d1fb0c177c14377ebf5f09d6cd5368780",
+  "src/packaging/_manylinux.py": "5b6e84324c42538ab4cdb148e2430fdba36f04427b0efda55bea083a35fa6136",
+  "src/packaging/_musllinux.py": "0328fb827b1170c77df4c107d49be8df8d37262103490a61e8acad8a2f9cadff",
+  "src/packaging/_parser.py": "88a348115209327497e453b635e5db099fd592f9335d710c7313b29cdb30c50c",
+  "src/packaging/_ranges.py": "b7b595f2e692aeb3697c545b85c24cbbcb4552f2adc6d9059aa82d0877e816b7",
+  "src/packaging/_structures.py": "eb48d16c5efca7ccf930a9cd77a700a6b80e69d0891d5d03966526441a8565cb",
+  "src/packaging/_tokenizer.py": "cc25e57c0d564c89e15073471d6e1c264299ca946fb17c0e1e4af54ef7713ee6",
+  "src/packaging/errors.py": "ea17c461701ff2ffc817ae7e94569d24e30889e04fdb120ab721178c6d67188b",
+  "src/packaging/markers.py": "9056d5d4882a3ba14a7624ba64c3a33aadb00c563dce4d15343dc229fbef5f8a",
+  "src/packaging/ranges.py": "b4781ce913e5dff9e07906f20585c54c3028e1f7ff56341828e79d522ddbfab6",
+  "src/packaging/specifiers.py": "f9e37cfb1ceba333a1302c2af605ec6f2fb67801f341af70d347f9271ab8e9cb",
+  "src/packaging/version.py": "af4b2bfdbdaaf743eb5ef831e7981963857ef39ab96fdbeee4d402539f715059"
+}