src/tests/test_ctx_ab_swebench.py

from __future__ import annotations

from dataclasses import dataclass
import hashlib
import json
import os
from pathlib import Path
import shutil
import socket
import stat
import sys
import time
from typing import Any
import weakref

import pytest

from scripts import ctx_ab_benchmark as benchmark
from scripts import ctx_ab_swebench as bridge


REVISION = "a" * 40
FAIL_TO_PASS = ["tests/test_feature.py::test_new_behavior"]
PASS_TO_PASS = ["tests/test_feature.py::test_existing_behavior"]
DAEMON_ID = "ctx-test-daemon"
SERVER_VERSION = "28.3.2"
IMAGE_ID = f"sha256:{'b' * 64}"
PYTHON_ENVIRONMENT = "docker==7.1.0\nswebench==4.1.0\n"
PYTHON_ENVIRONMENT_SHA256 = bridge._sha256(
    bridge._canonical_bytes(sorted(PYTHON_ENVIRONMENT.splitlines()))
)
DOCKER_PACKAGE_CONTENT = b"# authenticated docker fixture\n"
DOCKER_PACKAGE_MANIFEST = {
    "file_count": 1,
    "sha256": bridge._sha256(
        bridge._canonical_bytes(
            [
                {
                    "bytes": len(DOCKER_PACKAGE_CONTENT),
                    "path": "__init__.py",
                    "sha256": bridge._sha256(DOCKER_PACKAGE_CONTENT),
                }
            ]
        )
    ),
}
DOCKER_PACKAGE_SHA256 = str(DOCKER_PACKAGE_MANIFEST["sha256"])


def test_verifier_process_runner_is_self_contained(
    monkeypatch: pytest.MonkeyPatch,
    tmp_path: Path,
) -> None:
    def poisoned_runner(*_args: Any, **_kwargs: Any) -> None:
        raise AssertionError("mutable benchmark process runner executed")

    monkeypatch.setattr(benchmark, "run_process", poisoned_runner)

    result = bridge._run_process(
        [sys.executable, "-c", "print('authenticated')"],
        cwd=tmp_path,
        timeout=10,
    )

    assert isinstance(result, bridge.CommandResult)
    assert result.returncode == 0
    assert result.stdout == "authenticated\n"


def _report_entry(*, resolved: bool) -> dict[str, Any]:
    if resolved:
        fail_success, fail_failure = FAIL_TO_PASS, []
    else:
        fail_success, fail_failure = [], FAIL_TO_PASS
    return {
        "patch_is_None": False,
        "patch_exists": True,
        "patch_successfully_applied": True,
        "resolved": resolved,
        "tests_status": {
            "FAIL_TO_PASS": {"success": fail_success, "failure": fail_failure},
            "PASS_TO_PASS": {"success": PASS_TO_PASS, "failure": []},
            "FAIL_TO_FAIL": {"success": [], "failure": []},
            "PASS_TO_FAIL": {"success": [], "failure": []},
        },
    }


@pytest.mark.parametrize("phase", ["green", "scored"])
def test_exact_red_green_and_scored_status_contract(phase: str) -> None:
    red = bridge.validate_outcome(
        phase="red",
        fail_to_pass=FAIL_TO_PASS,
        pass_to_pass=PASS_TO_PASS,
        statuses={
            FAIL_TO_PASS[0]: "FAILED",
            PASS_TO_PASS[0]: "PASSED",
        },
        report_entry=_report_entry(resolved=False),
        official_resolution="RESOLVED_NO",
    )
    passing = bridge.validate_outcome(
        phase=phase,
        fail_to_pass=FAIL_TO_PASS,
        pass_to_pass=PASS_TO_PASS,
        statuses={
            FAIL_TO_PASS[0]: "PASSED",
            PASS_TO_PASS[0]: "XFAIL",
        },
        report_entry=_report_entry(resolved=True),
        official_resolution="RESOLVED_FULL",
    )

    assert red["resolved"] is False
    assert red["fail_to_pass_count"] == 1
    assert passing["resolved"] is True
    assert passing["pass_to_pass_count"] == 1


@pytest.mark.parametrize(
    ("fail_to_pass", "pass_to_pass", "statuses"),
    [
        (FAIL_TO_PASS, PASS_TO_PASS, {FAIL_TO_PASS[0]: "FAILED"}),
        (
            FAIL_TO_PASS,
            PASS_TO_PASS,
            {FAIL_TO_PASS[0]: "SKIPPED", PASS_TO_PASS[0]: "PASSED"},
        ),
        (
            FAIL_TO_PASS * 2,
            PASS_TO_PASS,
            {FAIL_TO_PASS[0]: "FAILED", PASS_TO_PASS[0]: "PASSED"},
        ),
        (
            FAIL_TO_PASS,
            PASS_TO_PASS,
            {
                FAIL_TO_PASS[0]: "FAILED",
                PASS_TO_PASS[0]: "PASSED",
                "tests/test_feature.py::test_unexpected": "PASSED",
            },
        ),
    ],
)
def test_missing_duplicate_skipped_and_extra_statuses_fail_closed(
    fail_to_pass: list[str],
    pass_to_pass: list[str],
    statuses: dict[str, str],
) -> None:
    with pytest.raises(bridge.SWEbenchVerificationError):
        bridge.validate_outcome(
            phase="red",
            fail_to_pass=fail_to_pass,
            pass_to_pass=pass_to_pass,
            statuses=statuses,
            report_entry=_report_entry(resolved=False),
            official_resolution="RESOLVED_NO",
        )


def test_file_qualified_status_aliases_must_agree() -> None:
    statuses = {
        FAIL_TO_PASS[0]: "FAILED",
        f"project/tests/test_feature.py:{FAIL_TO_PASS[0]}": "FAILED",
        PASS_TO_PASS[0]: "PASSED",
    }
    outcome = bridge.validate_outcome(
        phase="red",
        fail_to_pass=FAIL_TO_PASS,
        pass_to_pass=PASS_TO_PASS,
        statuses=statuses,
        report_entry=_report_entry(resolved=False),
        official_resolution="RESOLVED_NO",
    )
    assert outcome["parsed_status_key_count"] == 3

    statuses[f"project/tests/test_feature.py:{FAIL_TO_PASS[0]}"] = "PASSED"
    with pytest.raises(bridge.SWEbenchVerificationError, match="conflict"):
        bridge.validate_outcome(
            phase="red",
            fail_to_pass=FAIL_TO_PASS,
            pass_to_pass=PASS_TO_PASS,
            statuses=statuses,
            report_entry=_report_entry(resolved=False),
            official_resolution="RESOLVED_NO",
        )

    with pytest.raises(bridge.SWEbenchVerificationError, match="missing"):
        bridge.validate_outcome(
            phase="red",
            fail_to_pass=FAIL_TO_PASS,
            pass_to_pass=PASS_TO_PASS,
            statuses={
                f"project/tests/test_feature.py:{FAIL_TO_PASS[0]}": "FAILED",
                f"project/tests/test_feature.py:{PASS_TO_PASS[0]}": "PASSED",
            },
            report_entry=_report_entry(resolved=False),
            official_resolution="RESOLVED_NO",
        )


def test_mode_only_patch_requires_tracked_allowed_production_python() -> None:
    selected = bridge.select_mode_target(
        ["tests/test_core.py", "pkg/test.py", "pkg/core.py", "pkg/already_executable.py"],
        {
            "tests/test_core.py": "100644",
            "pkg/test.py": "100644",
            "pkg/core.py": "100644",
            "pkg/already_executable.py": "100755",
        },
    )

    assert selected == "pkg/core.py"
    assert bridge.mode_only_patch(selected) == (
        "diff --git a/pkg/core.py b/pkg/core.py\nold mode 100644\nnew mode 100755\n"
    )
    with pytest.raises(bridge.SWEbenchVerificationError, match="safe mode-only target"):
        bridge.select_mode_target(
            ["tests/test_core.py", "pkg/test.py", "pkg/already_executable.py"],
            {
                "tests/test_core.py": "100644",
                "pkg/test.py": "100644",
                "pkg/already_executable.py": "100755",
            },
        )


@dataclass(frozen=True)
class Inputs:
    checkout: Path
    python: Path
    docker: Path
    dataset: Path
    socket_path: Path
    run_dir: Path
    run_evaluation_sha256: str
    socket_cleanup: Any


def _executable(path: Path) -> Path:
    path.write_text("#!/bin/sh\nexit 0\n", encoding="utf-8")
    path.chmod(0o700)
    return path


def test_executable_authentication_preserves_virtualenv_entrypoint(tmp_path: Path) -> None:
    target = _executable(tmp_path / "python3.12")
    entrypoint = tmp_path / "python"
    entrypoint.symlink_to(target.name)

    assert bridge._executable(entrypoint.absolute(), label="Python") == entrypoint.absolute()


def _inputs(tmp_path: Path) -> Inputs:
    if not hasattr(socket, "AF_UNIX"):
        pytest.skip("Unix-domain Docker socket fixture is unavailable")
    checkout = tmp_path / "SWE-bench"
    run_evaluation = checkout / "swebench/harness/run_evaluation.py"
    run_evaluation.parent.mkdir(parents=True)
    run_evaluation.write_text("# pinned harness\n", encoding="utf-8")
    python = _executable(tmp_path / "swebench-python")
    docker = _executable(tmp_path / "docker")
    dataset = tmp_path / "dataset.jsonl"
    dataset.write_text("{}\n", encoding="utf-8")
    socket_path = Path("/tmp") / (
        "ctx-sb-" + hashlib.sha256(str(tmp_path).encode()).hexdigest()[:12] + ".sock"
    )
    socket_path.unlink(missing_ok=True)
    listener = socket.socket(socket.AF_UNIX)
    listener.bind(str(socket_path))
    listener.close()
    inputs = Inputs(
        checkout=checkout,
        python=python,
        docker=docker,
        dataset=dataset,
        socket_path=socket_path,
        run_dir=tmp_path / "private-run",
        run_evaluation_sha256=hashlib.sha256(run_evaluation.read_bytes()).hexdigest(),
        socket_cleanup=None,
    )
    object.__setattr__(
        inputs,
        "socket_cleanup",
        weakref.finalize(inputs, socket_path.unlink, missing_ok=True),
    )
    return inputs


def _write_worker_artifacts(request: dict[str, Any], run_dir: Path) -> None:
    phase = str(request["phase"])
    instance_id = str(request["instance_id"])
    model_name = str(request["model_name"])
    log_dir = run_dir / "logs/run_evaluation" / str(request["run_id"]) / model_name / instance_id
    log_dir.mkdir(parents=True)
    resolved = phase != "red"
    statuses = {
        FAIL_TO_PASS[0]: "PASSED" if resolved else "ERROR",
        PASS_TO_PASS[0]: "PASSED",
    }
    report = {instance_id: _report_entry(resolved=resolved)}
    raw = {
        "schema_version": 1,
        "phase": phase,
        "instance_id": instance_id,
        "expected": {
            "FAIL_TO_PASS": FAIL_TO_PASS,
            "PASS_TO_PASS": PASS_TO_PASS,
        },
        "statuses": statuses,
        "official_resolution": "RESOLVED_FULL" if resolved else "RESOLVED_NO",
    }
    files = {
        "report.json": json.dumps(report, sort_keys=True),
        "raw-status.json": json.dumps(raw, sort_keys=True),
        "eval.sh": "#!/bin/bash\npytest\n",
        "test_output.txt": "synthetic official output\n",
        "run_instance.log": "patch applied\n",
        "patch.diff": bridge.mode_only_patch("pkg/core.py")
        if phase == "red"
        else "diff --git a/pkg/core.py b/pkg/core.py\n",
    }
    for name, content in files.items():
        (log_dir / name).write_text(content, encoding="utf-8")
    if phase == "red":
        (run_dir / "mode-probe.log").write_text("tracked 100644 target\n", encoding="utf-8")
    result_path = run_dir / "worker-result.json"
    result_path.write_text(
        json.dumps(
            {
                "container_policy": [
                    {
                        "cap_drop": ["ALL"],
                        "cgroupns_mode": "private",
                        "image_id": IMAGE_ID,
                        "memory_bytes": bridge.CONTAINER_MEMORY_BYTES,
                        "mount_count": 0,
                        "nano_cpus": bridge.CONTAINER_NANO_CPUS,
                        "network_mode": "none",
                        "pids_limit": bridge.CONTAINER_PIDS_LIMIT,
                        "privileged": False,
                        "security_opt": bridge.CONTAINER_SECURITY_OPT,
                    }
                ],
                "image_id": IMAGE_ID,
                "ok": True,
                "phase": phase,
                "run_id": request["run_id"],
                "model_name": model_name,
                "log_dir": str(log_dir.relative_to(run_dir)),
            },
            sort_keys=True,
        ),
        encoding="utf-8",
    )


def _verify_kwargs(inputs: Inputs) -> dict[str, Any]:
    return {
        "phase": "red",
        "dataset_path": inputs.dataset,
        "instance_id": "owner__repo-1",
        "allowed_paths": ["pkg/core.py"],
        "swebench_checkout": inputs.checkout,
        "swebench_python": inputs.python,
        "expected_revision": REVISION,
        "expected_run_evaluation_sha256": inputs.run_evaluation_sha256,
        "expected_bridge_sha256": hashlib.sha256(bridge.SCRIPT_PATH.read_bytes()).hexdigest(),
        "expected_dataset_sha256": hashlib.sha256(inputs.dataset.read_bytes()).hexdigest(),
        "expected_python_sha256": hashlib.sha256(inputs.python.resolve().read_bytes()).hexdigest(),
        "expected_python_environment_sha256": PYTHON_ENVIRONMENT_SHA256,
        "expected_docker_package_sha256": DOCKER_PACKAGE_SHA256,
        "docker_cli": inputs.docker,
        "expected_docker_cli_sha256": hashlib.sha256(
            inputs.docker.resolve().read_bytes()
        ).hexdigest(),
        "docker_host": f"unix://{inputs.socket_path}",
        "expected_docker_daemon_id": DAEMON_ID,
        "expected_docker_server_version": SERVER_VERSION,
        "work_dir": inputs.run_dir,
        "timeout": 30,
        "allow_image_pull": True,
        "namespace": "swebench",
    }


def _fake_package_snapshot(argv: list[str]) -> benchmark.CommandResult:
    destination = Path(argv[argv.index("--destination") + 1])
    destination.mkdir(parents=True)
    (destination / "__init__.py").write_bytes(DOCKER_PACKAGE_CONTENT)
    return benchmark.CommandResult(
        0,
        json.dumps(DOCKER_PACKAGE_MANIFEST),
        "",
        0.01,
    )


def _successful_process_fake(
    inputs: Inputs,
    calls: list[tuple[list[str], dict[str, Any]]],
) -> Any:
    def fake(argv: list[str], **kwargs: Any) -> benchmark.CommandResult:
        calls.append((list(argv), dict(kwargs)))
        if "clone" in argv:
            destination = Path(argv[-1])
            run_evaluation = destination / "swebench/harness/run_evaluation.py"
            run_evaluation.parent.mkdir(parents=True)
            run_evaluation.write_text("# pinned harness\n", encoding="utf-8")
            return benchmark.CommandResult(0, "", "", 0.01)
        if "checkout" in argv:
            return benchmark.CommandResult(0, "", "", 0.01)
        if "rev-parse" in argv:
            return benchmark.CommandResult(0, f"{REVISION}\n", "", 0.01)
        if "status" in argv:
            return benchmark.CommandResult(0, "", "", 0.01)
        if argv[0] == str(inputs.python.resolve()) and "pip" in argv:
            return benchmark.CommandResult(0, PYTHON_ENVIRONMENT, "", 0.01)
        if argv[0] == str(inputs.python.resolve()) and "package-snapshot" in argv:
            return _fake_package_snapshot(argv)
        if argv[0] == str(inputs.python.resolve()):
            request_path = Path(argv[argv.index("--request") + 1])
            request = json.loads(request_path.read_text(encoding="utf-8"))
            _write_worker_artifacts(request, inputs.run_dir)
            return benchmark.CommandResult(0, "worker output\n", "", 0.25)
        if argv[0] == str(inputs.docker.resolve()):
            if "info" in argv:
                return benchmark.CommandResult(0, f"{DAEMON_ID}\n", "", 0.01)
            if "version" in argv:
                return benchmark.CommandResult(0, f"{SERVER_VERSION}\n", "", 0.01)
            if "network" in argv:
                return benchmark.CommandResult(0, "network-a\n", "", 0.01)
            return benchmark.CommandResult(0, "", "", 0.01)
        raise AssertionError(f"unexpected command: {argv}")

    return fake


def test_worker_environment_is_hermetic_and_retained_evidence_is_complete(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    inputs = _inputs(tmp_path)
    calls: list[tuple[list[str], dict[str, Any]]] = []
    monkeypatch.setenv("HF_TOKEN", "must-not-leak")
    monkeypatch.setenv("OPENAI_API_KEY", "must-not-leak")
    monkeypatch.setattr(bridge, "_run_process", _successful_process_fake(inputs, calls))
    monkeypatch.setattr(bridge, "_new_run_id", lambda _phase: "ctx-sb-red-fixed")

    evidence = bridge.verify_swebench(**_verify_kwargs(inputs))

    worker_call = next(call for call in calls if "worker" in call[0])
    worker_env = worker_call[1]["env"]
    request_path = Path(worker_call[0][worker_call[0].index("--request") + 1])
    request = json.loads(request_path.read_text(encoding="utf-8"))
    assert worker_call[1]["contain_descendants"] is True
    assert worker_call[1]["cwd"] == inputs.run_dir
    assert worker_env["PYTHONPATH"] == str(inputs.run_dir / "inputs" / f"swebench-{REVISION}")
    assert worker_env["DOCKER_HOST"] == f"unix://{inputs.socket_path.resolve()}"
    assert worker_env["HF_DATASETS_OFFLINE"] == "1"
    assert worker_env["HF_HUB_OFFLINE"] == "1"
    assert Path(worker_call[0][1]).parent == inputs.run_dir / "inputs"
    assert Path(request["dataset_path"]).parent == inputs.run_dir / "inputs"
    assert Path(request["dataset_path"]) != inputs.dataset
    assert Path(request["docker_package_path"]).name == "docker"
    assert Path(request["swebench_checkout"]).parent == inputs.run_dir / "inputs"
    assert "HF_TOKEN" not in worker_env
    assert "OPENAI_API_KEY" not in worker_env
    assert set(evidence["artifacts"]) >= {
        "report.json",
        "raw-status.json",
        "eval.sh",
        "test_output.txt",
        "run_instance.log",
        "patch.diff",
    }
    for artifact in evidence["artifacts"].values():
        assert artifact["present"] is True
        assert artifact["sha256"]
        assert "content" not in artifact
    assert evidence["command"]["executable"] == inputs.python.resolve().name
    assert evidence["command"]["sha256"]
    assert evidence["process"]["stdout_bytes"] == len("worker output\n")
    assert evidence["process"]["sha256"]
    assert evidence["cleanup"]["ok"] is True
    serialized = json.dumps(evidence)
    assert FAIL_TO_PASS[0] not in serialized
    assert PASS_TO_PASS[0] not in serialized
    assert "must-not-leak" not in serialized


@pytest.mark.parametrize("target", ["bridge", "dataset", "docker", "harness"])
def test_private_input_mutation_between_worker_start_and_parent_validation_fails(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
    target: str,
) -> None:
    inputs = _inputs(tmp_path)
    calls: list[tuple[list[str], dict[str, Any]]] = []
    base = _successful_process_fake(inputs, calls)

    def fake(argv: list[str], **kwargs: Any) -> benchmark.CommandResult:
        if "worker" in argv:
            request_path = Path(argv[argv.index("--request") + 1])
            request = json.loads(request_path.read_text(encoding="utf-8"))
            mutation = {
                "bridge": Path(argv[1]),
                "dataset": Path(request["dataset_path"]),
                "docker": Path(request["docker_package_path"]) / "__init__.py",
                "harness": (
                    Path(request["swebench_checkout"])
                    / "swebench"
                    / "harness"
                    / "run_evaluation.py"
                ),
            }[target]
            mutation.chmod(0o600)
            mutation.write_bytes(mutation.read_bytes() + b"# mutation\n")
        return base(argv, **kwargs)

    monkeypatch.setattr(bridge, "_run_process", fake)
    monkeypatch.setattr(bridge, "_new_run_id", lambda _phase: f"ctx-sb-red-mutate-{target}")

    with pytest.raises(bridge.SWEbenchVerificationError, match="inputs drifted"):
        bridge.verify_swebench(**_verify_kwargs(inputs))


@pytest.mark.parametrize("stale", ["revision", "run-evaluation"])
def test_stale_harness_authentication_rejects_before_worker(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
    stale: str,
) -> None:
    inputs = _inputs(tmp_path)
    calls: list[list[str]] = []

    def fake(argv: list[str], **_kwargs: Any) -> benchmark.CommandResult:
        calls.append(list(argv))
        if "clone" in argv:
            destination = Path(argv[-1])
            run_evaluation = destination / "swebench/harness/run_evaluation.py"
            run_evaluation.parent.mkdir(parents=True)
            run_evaluation.write_text("# pinned harness\n", encoding="utf-8")
            return benchmark.CommandResult(0, "", "", 0.01)
        if "checkout" in argv:
            return benchmark.CommandResult(0, "", "", 0.01)
        if "rev-parse" in argv:
            observed = "b" * 40 if stale == "revision" else REVISION
            return benchmark.CommandResult(0, f"{observed}\n", "", 0.01)
        if "status" in argv:
            return benchmark.CommandResult(0, "", "", 0.01)
        if argv[0] == str(inputs.python.resolve()) and "pip" in argv:
            return benchmark.CommandResult(0, PYTHON_ENVIRONMENT, "", 0.01)
        if argv[0] == str(inputs.python.resolve()) and "package-snapshot" in argv:
            return _fake_package_snapshot(argv)
        raise AssertionError("worker must not start")

    monkeypatch.setattr(bridge, "_run_process", fake)
    kwargs = _verify_kwargs(inputs)
    if stale == "run-evaluation":
        kwargs["expected_run_evaluation_sha256"] = "0" * 64

    with pytest.raises(bridge.SWEbenchVerificationError, match="authentication"):
        bridge.verify_swebench(**kwargs)

    assert not any("worker" in command for command in calls)


def test_timeout_still_cleans_docker_and_fails_closed(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    inputs = _inputs(tmp_path)
    docker_calls: list[list[str]] = []

    def fake(argv: list[str], **_kwargs: Any) -> benchmark.CommandResult:
        if "clone" in argv:
            destination = Path(argv[-1])
            run_evaluation = destination / "swebench/harness/run_evaluation.py"
            run_evaluation.parent.mkdir(parents=True)
            run_evaluation.write_text("# pinned harness\n", encoding="utf-8")
            return benchmark.CommandResult(0, "", "", 0.01)
        if "checkout" in argv:
            return benchmark.CommandResult(0, "", "", 0.01)
        if "rev-parse" in argv:
            return benchmark.CommandResult(0, f"{REVISION}\n", "", 0.01)
        if "status" in argv:
            return benchmark.CommandResult(0, "", "", 0.01)
        if argv[0] == str(inputs.python.resolve()) and "pip" in argv:
            return benchmark.CommandResult(0, PYTHON_ENVIRONMENT, "", 0.01)
        if argv[0] == str(inputs.python.resolve()) and "package-snapshot" in argv:
            return _fake_package_snapshot(argv)
        if argv[0] == str(inputs.python.resolve()):
            return benchmark.CommandResult(124, "", "timed out", 30.0, timed_out=True)
        if argv[0] == str(inputs.docker.resolve()):
            docker_calls.append(list(argv))
            if "info" in argv:
                return benchmark.CommandResult(0, f"{DAEMON_ID}\n", "", 0.01)
            if "version" in argv:
                return benchmark.CommandResult(0, f"{SERVER_VERSION}\n", "", 0.01)
            if "network" in argv:
                return benchmark.CommandResult(0, "network-a\n", "", 0.01)
            return benchmark.CommandResult(0, "", "", 0.01)
        raise AssertionError(f"unexpected command: {argv}")

    monkeypatch.setattr(bridge, "_run_process", fake)
    monkeypatch.setattr(bridge, "_new_run_id", lambda _phase: "ctx-sb-red-timeout")

    with pytest.raises(bridge.SWEbenchVerificationError) as raised:
        bridge.verify_swebench(**_verify_kwargs(inputs))

    assert raised.value.evidence["process"]["timed_out"] is True
    assert raised.value.evidence["cleanup"]["ok"] is True
    audit_path = inputs.run_dir / "verification-evidence.json"
    audit = json.loads(audit_path.read_text(encoding="utf-8"))
    assert stat.S_IMODE(audit_path.stat().st_mode) == 0o600
    assert audit["process"]["timed_out"] is True
    assert audit["process"]["residual_descendant_count"] == 0
    assert audit["cleanup"]["ok"] is True
    assert audit["cleanup"]["residual_container_count"] == 0
    assert audit["inventory"]["baseline"]["containers"] == audit["inventory"]["final"]["containers"]
    assert docker_calls


def test_residual_docker_container_fails_closed(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    inputs = _inputs(tmp_path)
    calls: list[tuple[list[str], dict[str, Any]]] = []
    successful = _successful_process_fake(inputs, calls)

    def fake(argv: list[str], **kwargs: Any) -> benchmark.CommandResult:
        if argv[0] == str(inputs.docker.resolve()):
            calls.append((list(argv), dict(kwargs)))
            if "info" in argv:
                return benchmark.CommandResult(0, f"{DAEMON_ID}\n", "", 0.01)
            if "version" in argv:
                return benchmark.CommandResult(0, f"{SERVER_VERSION}\n", "", 0.01)
            if "network" in argv:
                return benchmark.CommandResult(0, "network-a\n", "", 0.01)
            if "ps" in argv:
                return benchmark.CommandResult(0, "abc123def456\n", "", 0.01)
            if "rm" in argv:
                return benchmark.CommandResult(0, "abc123def456\n", "", 0.01)
        return successful(argv, **kwargs)

    monkeypatch.setattr(bridge, "_run_process", fake)
    monkeypatch.setattr(bridge, "_new_run_id", lambda _phase: "ctx-sb-red-residual")

    with pytest.raises(bridge.SWEbenchVerificationError, match="containment") as raised:
        bridge.verify_swebench(**_verify_kwargs(inputs))

    assert raised.value.evidence["cleanup"]["ok"] is False
    assert raised.value.evidence["cleanup"]["residual_container_ids"] == ["abc123def456"]


def test_scored_patch_cannot_change_hidden_tests(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    inputs = _inputs(tmp_path)
    calls: list[tuple[list[str], dict[str, Any]]] = []
    successful = _successful_process_fake(inputs, calls)

    def fake(argv: list[str], **kwargs: Any) -> benchmark.CommandResult:
        if "apply" in argv and "--numstat" in argv:
            return benchmark.CommandResult(
                0,
                "1\t1\ttests/test_feature.py\0",
                "",
                0.01,
            )
        if "apply" in argv and "--summary" in argv:
            return benchmark.CommandResult(0, "", "", 0.01)
        return successful(argv, **kwargs)

    monkeypatch.setattr(bridge, "_run_process", fake)
    kwargs = _verify_kwargs(inputs)
    kwargs.update(
        {
            "allow_image_pull": False,
            "expected_image_id": IMAGE_ID,
            "model_patch": (
                "diff --git a/tests/test_feature.py b/tests/test_feature.py\n"
                "--- a/tests/test_feature.py\n"
                "+++ b/tests/test_feature.py\n"
                "@@ -1 +1 @@\n-assert False\n+assert True\n"
            ),
            "phase": "scored",
        }
    )

    with pytest.raises(bridge.SWEbenchVerificationError, match="disallowed path"):
        bridge.verify_swebench(**kwargs)

    assert not any("worker" in call[0] for call in calls)


def test_scored_patch_cannot_rename_hidden_tests_into_allowlist(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    inputs = _inputs(tmp_path)
    calls: list[tuple[list[str], dict[str, Any]]] = []
    successful = _successful_process_fake(inputs, calls)

    def fake(argv: list[str], **kwargs: Any) -> benchmark.CommandResult:
        if "apply" in argv and "--numstat" in argv:
            return benchmark.CommandResult(0, "0\t0\tpkg/core.py\0", "", 0.01)
        if "apply" in argv and "--summary" in argv:
            return benchmark.CommandResult(
                0,
                " rename tests/test_feature.py => pkg/core.py (100%)\n",
                "",
                0.01,
            )
        return successful(argv, **kwargs)

    monkeypatch.setattr(bridge, "_run_process", fake)
    kwargs = _verify_kwargs(inputs)
    kwargs.update(
        {
            "allow_image_pull": False,
            "expected_image_id": IMAGE_ID,
            "model_patch": (
                "diff --git a/tests/test_feature.py b/pkg/core.py\n"
                "similarity index 100%\n"
                "rename from tests/test_feature.py\n"
                "rename to pkg/core.py\n"
            ),
            "phase": "scored",
        }
    )

    with pytest.raises(bridge.SWEbenchVerificationError, match="renames or copies"):
        bridge.verify_swebench(**kwargs)

    assert not any("worker" in call[0] for call in calls)


def test_authenticated_harness_is_clean_commit_only(tmp_path: Path) -> None:
    source = tmp_path / "source"
    source.mkdir()
    subprocess_commands = [
        ["git", "init", "-q"],
        ["git", "config", "user.email", "benchmark@example.invalid"],
        ["git", "config", "user.name", "Benchmark"],
    ]
    for command in subprocess_commands:
        result = benchmark.run_process(command, cwd=source, timeout=10)
        assert result.returncode == 0
    run_evaluation = source / "swebench/harness/run_evaluation.py"
    run_evaluation.parent.mkdir(parents=True)
    run_evaluation.write_text("# committed\n", encoding="utf-8")
    executable = source / "swebench/harness/run-evaluation"
    executable.write_text("#!/bin/sh\nexit 0\n", encoding="utf-8")
    executable.chmod(0o755)
    assert benchmark.run_process(["git", "add", "."], cwd=source, timeout=10).returncode == 0
    assert (
        benchmark.run_process(
            [
                "git",
                "update-index",
                "--chmod=+x",
                "--",
                "swebench/harness/run-evaluation",
            ],
            cwd=source,
            timeout=10,
        ).returncode
        == 0
    )
    assert (
        benchmark.run_process(
            ["git", "commit", "-qm", "fixture"], cwd=source, timeout=10
        ).returncode
        == 0
    )
    revision = benchmark.run_process(
        ["git", "rev-parse", "HEAD"],
        cwd=source,
        timeout=10,
    ).stdout.strip()
    git_path = shutil.which("git")
    assert git_path is not None
    run_evaluation.write_text("# malicious tracked edit\n", encoding="utf-8")
    ignored = source / "swebench/harness/grading.pyc"
    ignored.write_bytes(b"malicious ignored bytecode")
    destination = tmp_path / "clean"

    evidence = bridge._materialize_authenticated_harness(
        source_checkout=source,
        destination=destination,
        git=bridge._executable(Path(git_path), label="Git executable"),
        expected_revision=revision,
        expected_run_evaluation_sha256=hashlib.sha256(b"# committed\n").hexdigest(),
        deadline=time.monotonic() + 30,
    )

    assert (destination / "swebench/harness/run_evaluation.py").read_text() == "# committed\n"
    assert not (destination / "swebench/harness/grading.pyc").exists()
    tracked_mode = benchmark.run_process(
        [
            "git",
            "ls-files",
            "--stage",
            "--",
            "swebench/harness/run-evaluation",
        ],
        cwd=destination,
        timeout=10,
    )
    assert tracked_mode.returncode == 0
    assert tracked_mode.stdout.split(maxsplit=1)[0] == "100755"
    assert destination.joinpath("swebench/harness/run-evaluation").stat().st_mode & 0o111
    assert (
        benchmark.run_process(
            ["git", "status", "--porcelain=v1"],
            cwd=destination,
            timeout=10,
        ).stdout
        == ""
    )
    assert evidence["git_revision"] == revision


def test_worker_rejects_bridge_hash_drift_before_import(tmp_path: Path) -> None:
    checkout = tmp_path / "checkout"
    run_evaluation = checkout / "swebench/harness/run_evaluation.py"
    run_evaluation.parent.mkdir(parents=True)
    run_evaluation.write_text("# pinned\n", encoding="utf-8")
    git = _executable(tmp_path / "git")

    with pytest.raises(bridge.SWEbenchVerificationError, match="authentication"):
        bridge._worker_authenticate(
            {
                "expected_bridge_sha256": "0" * 64,
                "expected_revision": REVISION,
                "expected_run_evaluation_sha256": hashlib.sha256(
                    run_evaluation.read_bytes()
                ).hexdigest(),
                "git_cli": str(git.absolute()),
                "swebench_checkout": str(checkout.absolute()),
            }
        )


def test_official_instance_uses_readable_umask_and_restores_worker_umask(
    tmp_path: Path,
) -> None:
    observed: dict[str, int] = {}

    class FakeEvaluation:
        @staticmethod
        def run_instance(path: Path) -> str:
            artifact = path / "patch.diff"
            artifact.write_text("patch\n", encoding="utf-8")
            observed["mode"] = artifact.stat().st_mode & 0o777
            return "ok"

    original = os.umask(0o077)
    try:
        assert bridge._run_official_instance(FakeEvaluation, tmp_path) == "ok"
        worker_umask = os.umask(0o077)
        os.umask(worker_umask)
    finally:
        os.umask(original)

    assert observed["mode"] == 0o644
    assert worker_umask == 0o077


class _FakeContainer:
    def __init__(self) -> None:
        self.attrs: dict[str, Any] = {}

    def reload(self) -> None:
        return None


class _FakeCollection:
    def __init__(self) -> None:
        self.kwargs: dict[str, Any] = {}

    def create(self, *_args: Any, **kwargs: Any) -> _FakeContainer:
        self.kwargs = kwargs
        container = _FakeContainer()
        container.attrs = {
            "Config": {"Labels": kwargs["labels"]},
            "HostConfig": {
                "Binds": None,
                "CapDrop": kwargs["cap_drop"],
                "CgroupnsMode": kwargs["cgroupns"],
                "Memory": kwargs["mem_limit"],
                "NanoCpus": kwargs["nano_cpus"],
                "NetworkMode": kwargs["network_mode"],
                "PidsLimit": kwargs["pids_limit"],
                "Privileged": kwargs["privileged"],
                "SecurityOpt": kwargs["security_opt"],
            },
            "Image": kwargs["image"],
            "Mounts": [],
        }
        return container


class _FakeDockerClient:
    def __init__(self) -> None:
        self.containers = _FakeCollection()


def test_container_creation_enforces_network_resources_and_no_mounts() -> None:
    client = _FakeDockerClient()
    attestations: list[dict[str, Any]] = []
    hardened = bridge._HardenedDockerClient(
        client,
        run_id="ctx-sb-red-policy",
        expected_image_id=IMAGE_ID,
        attestations=attestations,
    )
    hardened.containers.create(image="fixture")
    assert client.containers.kwargs["image"] == IMAGE_ID
    assert client.containers.kwargs["cap_drop"] == ["ALL"]
    assert client.containers.kwargs["cgroupns"] == "private"
    assert client.containers.kwargs["network_mode"] == "none"
    assert client.containers.kwargs["mem_limit"] == bridge.CONTAINER_MEMORY_BYTES
    assert client.containers.kwargs["nano_cpus"] == bridge.CONTAINER_NANO_CPUS
    assert client.containers.kwargs["pids_limit"] == bridge.CONTAINER_PIDS_LIMIT
    assert attestations[0]["mount_count"] == 0
    assert attestations[0]["image_id"] == IMAGE_ID
    with pytest.raises(bridge.SWEbenchVerificationError, match="host resources"):
        hardened.containers.create(image="fixture", volumes={"/tmp": {}})
    with pytest.raises(bridge.SWEbenchVerificationError, match="privilege"):
        hardened.containers.create(image="fixture", cap_add=["SYS_ADMIN"])
    with pytest.raises(bridge.SWEbenchVerificationError, match="namespaces"):
        hardened.containers.create(image="fixture", pid_mode="host")
    with pytest.raises(bridge.SWEbenchVerificationError, match="namespaces"):
        hardened.containers.create(image="fixture", cgroupns="host")
    with pytest.raises(bridge.SWEbenchVerificationError, match="namespaces"):
        hardened.containers.create(image="fixture", ipc_mode="host")