Sync ctx b670e1c (part 3)

GitHub commit: b670e1c2a90ea6e7d3a49f2a2fed02f69d9b83f0

src/tests/test_ctx_ab_holdout_freeze.py

@@ -55,6 +55,138 @@ def _sha256(data: bytes) -> str:
     return hashlib.sha256(data).hexdigest()
 
 
+def _literal_tree_bundle(
+    tmp_path: Path,
+    *,
+    directory: str,
+    mode: bytes,
+    name: bytes,
+) -> tuple[Path, str, str, Path]:
+    source = tmp_path / directory
+    source.mkdir()
+    subprocess.run(["git", "init", "-q", "--initial-branch=main"], cwd=source, check=True)
+    subprocess.run(
+        ["git", "config", "user.email", "ctx@example.test"],
+        cwd=source,
+        check=True,
+    )
+    subprocess.run(
+        ["git", "config", "user.name", "ctx benchmark"],
+        cwd=source,
+        check=True,
+    )
+    blob = (
+        subprocess.run(
+            ["git", "hash-object", "-w", "--stdin"],
+            cwd=source,
+            input=b"literal tree fixture\n",
+            check=True,
+            capture_output=True,
+        )
+        .stdout.decode()
+        .strip()
+    )
+    tree = (
+        subprocess.run(
+            ["git", "hash-object", "-t", "tree", "--literally", "-w", "--stdin"],
+            cwd=source,
+            input=mode + b" " + name + b"\0" + bytes.fromhex(blob),
+            check=True,
+            capture_output=True,
+        )
+        .stdout.decode()
+        .strip()
+    )
+    commit = (
+        subprocess.run(
+            ["git", "commit-tree", tree],
+            cwd=source,
+            input=b"literal tree fixture\n",
+            check=True,
+            capture_output=True,
+        )
+        .stdout.decode()
+        .strip()
+    )
+    subprocess.run(
+        ["git", "update-ref", "refs/heads/base", commit],
+        cwd=source,
+        check=True,
+    )
+    bundle = tmp_path / f"{directory}.bundle"
+    subprocess.run(
+        ["git", "bundle", "create", str(bundle), "refs/heads/base"],
+        cwd=source,
+        check=True,
+    )
+    bundle.chmod(0o600)
+    return source, commit, tree, bundle
+
+
+def test_source_bundle_closure_accepts_legacy_zero_padded_tree_mode(tmp_path: Path) -> None:
+    source, commit, tree, bundle = _literal_tree_bundle(
+        tmp_path,
+        directory="legacy-source",
+        mode=b"0100644",
+        name=b"source.py",
+    )
+    strict = subprocess.run(
+        ["git", "fsck", "--full", "--strict", "--unreachable", "--no-reflogs"],
+        cwd=source,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    assert strict.returncode != 0
+    assert "zeroPaddedFilemode" in strict.stderr
+
+    freezer._validate_source_bundle_closure(
+        freezer.SourceBundle(
+            base_commit=commit,
+            bundle_path=bundle,
+            bundle_sha256=_sha256(bundle.read_bytes()),
+            tree_sha1=tree,
+        )
+    )
+
+
+def test_source_bundle_closure_rejects_unrelated_strict_fsck_error(tmp_path: Path) -> None:
+    source, commit, tree, bundle = _literal_tree_bundle(
+        tmp_path,
+        directory="invalid-source",
+        mode=b"120000",
+        name=b".gitmodules",
+    )
+    scoped = subprocess.run(
+        [
+            "git",
+            "-c",
+            "fsck.zeroPaddedFilemode=ignore",
+            "fsck",
+            "--full",
+            "--strict",
+            "--unreachable",
+            "--no-reflogs",
+        ],
+        cwd=source,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    assert scoped.returncode != 0
+    assert "gitmodulesSymlink" in scoped.stderr
+
+    with pytest.raises(freezer.FreezeError, match="closure validation failed"):
+        freezer._validate_source_bundle_closure(
+            freezer.SourceBundle(
+                base_commit=commit,
+                bundle_path=bundle,
+                bundle_sha256=_sha256(bundle.read_bytes()),
+                tree_sha1=tree,
+            )
+        )
+
+
 def test_committed_v1_protocol_checkout_preserves_authenticated_bytes() -> None:
     relative_path = freezer.V1_PROTOCOL_PATH.relative_to(freezer.ROOT).as_posix()
     attributes = (freezer.ROOT / ".gitattributes").read_text(encoding="utf-8").splitlines()

src/tests/test_ctx_ab_holdout_prepare.py

@@ -828,6 +828,47 @@ def test_command_runner_requires_descendant_containment(
     assert observed["timeout"] == 5
 
 
+def test_command_runner_preserves_bounded_private_failure_diagnostics(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    result = prepare.swebench.CommandResult(
+        17,
+        "private stdout",
+        "private stderr",
+        0.25,
+        reaped_descendants=2,
+        residual_descendants=(101, 202),
+    )
+    monkeypatch.setattr(prepare.swebench, "_run_process", lambda *_args, **_kwargs: result)
+
+    with pytest.raises(prepare.PrepareError) as raised:
+        prepare._command_bytes(["git", "fsck"], cwd=tmp_path, timeout=5)
+
+    prefix = "authenticated preparation command failed; private_result="
+    assert str(raised.value).startswith(prefix)
+    evidence = json.loads(str(raised.value).removeprefix(prefix))
+    assert evidence == {
+        "elapsed_seconds": 0.25,
+        "reaped_descendants": 2,
+        "residual_descendants": [101, 202],
+        "returncode": 17,
+        "stderr": {
+            "bytes": 14,
+            "sha256": _sha256(b"private stderr"),
+            "text": "private stderr",
+            "truncated": False,
+        },
+        "stdout": {
+            "bytes": 14,
+            "sha256": _sha256(b"private stdout"),
+            "text": "private stdout",
+            "truncated": False,
+        },
+        "timed_out": False,
+    }
+
+
 def _git(cwd: Path, *argv: str, check: bool = True) -> subprocess.CompletedProcess[str]:
     return subprocess.run(
         ["git", *argv],
@@ -838,6 +879,84 @@ def _git(cwd: Path, *argv: str, check: bool = True) -> subprocess.CompletedProce
     )
 
 
+def _literal_tree_source(
+    tmp_path: Path,
+    *,
+    directory: str,
+    mode: bytes,
+    name: bytes,
+) -> tuple[Path, str, str]:
+    source = tmp_path / directory
+    source.mkdir()
+    _git(source, "init", "--quiet", "--initial-branch=main")
+    _git(source, "config", "user.name", "Fixture")
+    _git(source, "config", "user.email", "fixture@example.com")
+    blob = (
+        subprocess.run(
+            ["git", "hash-object", "-w", "--stdin"],
+            cwd=source,
+            input=b"literal tree fixture\n",
+            check=True,
+            capture_output=True,
+        )
+        .stdout.decode()
+        .strip()
+    )
+    tree = (
+        subprocess.run(
+            ["git", "hash-object", "-t", "tree", "--literally", "-w", "--stdin"],
+            cwd=source,
+            input=mode + b" " + name + b"\0" + bytes.fromhex(blob),
+            check=True,
+            capture_output=True,
+        )
+        .stdout.decode()
+        .strip()
+    )
+    commit = (
+        subprocess.run(
+            ["git", "commit-tree", tree],
+            cwd=source,
+            input=b"literal tree fixture\n",
+            check=True,
+            capture_output=True,
+        )
+        .stdout.decode()
+        .strip()
+    )
+    _git(source, "update-ref", "refs/heads/main", commit)
+    return source, commit, tree
+
+
+def _replace_github_fetch_with_local_source(
+    monkeypatch: pytest.MonkeyPatch,
+    *,
+    source: Path,
+    commit: str,
+) -> None:
+    original_command = prepare._command_bytes
+
+    def command(argv: list[str], **kwargs: Any) -> bytes:
+        if "fetch" in argv and "origin" in argv:
+            repository = argv[argv.index("-C") + 1]
+            argv = [
+                "git",
+                "-C",
+                repository,
+                "-c",
+                "protocol.file.allow=always",
+                "fetch",
+                "--quiet",
+                "--force",
+                "--no-tags",
+                source.as_uri(),
+                f"{commit}:refs/heads/base",
+            ]
+        return original_command(argv, **kwargs)
+
+    monkeypatch.setattr(prepare, "_command_bytes", command)
+
+
 def test_authenticated_bundle_excludes_future_gold_refs_objects_and_remotes(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,
@@ -934,6 +1053,80 @@ def test_authenticated_bundle_excludes_future_gold_refs_objects_and_remotes(
     )
 
 
+def test_authenticated_bundle_accepts_legacy_zero_padded_tree_mode(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    source, commit, tree = _literal_tree_source(
+        tmp_path,
+        directory="legacy-source",
+        mode=b"0100644",
+        name=b"legacy.py",
+    )
+    strict = _git(
+        source,
+        "fsck",
+        "--full",
+        "--strict",
+        "--unreachable",
+        "--no-reflogs",
+        check=False,
+    )
+    assert strict.returncode != 0
+    assert "zeroPaddedFilemode" in strict.stderr
+
+    destination = tmp_path / "bundles" / "base.bundle"
+    destination.parent.mkdir()
+    _replace_github_fetch_with_local_source(monkeypatch, source=source, commit=commit)
+
+    observed_tree, bundle_sha256 = prepare._create_authenticated_bundle(
+        url="https://github.com/owner/legacy-repo.git",
+        commit=commit,
+        destination=destination,
+    )
+
+    assert observed_tree == tree
+    assert bundle_sha256 == _sha256(destination.read_bytes())
+
+
+def test_authenticated_bundle_rejects_unrelated_strict_fsck_error(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    source, commit, _tree = _literal_tree_source(
+        tmp_path,
+        directory="invalid-source",
+        mode=b"120000",
+        name=b".gitmodules",
+    )
+    scoped = _git(
+        source,
+        "-c",
+        "fsck.zeroPaddedFilemode=ignore",
+        "fsck",
+        "--full",
+        "--strict",
+        "--unreachable",
+        "--no-reflogs",
+        check=False,
+    )
+    assert scoped.returncode != 0
+    assert "gitmodulesSymlink" in scoped.stderr
+
+    destination = tmp_path / "invalid-bundles" / "base.bundle"
+    destination.parent.mkdir()
+    _replace_github_fetch_with_local_source(monkeypatch, source=source, commit=commit)
+
+    with pytest.raises(prepare.PrepareError, match="authenticated preparation command failed"):
+        prepare._create_authenticated_bundle(
+            url="https://github.com/owner/invalid-repo.git",
+            commit=commit,
+            destination=destination,
+        )
+
+    assert not destination.exists()
+
+
 def test_prepare_sources_bundles_in_bounded_parallel_and_writes_deterministic_map(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,
@@ -1686,6 +1879,65 @@ def test_cli_suppresses_private_failure_details(
     assert (failure_root / "artifact-manifest.json").is_file()
 
 
+def test_cli_privately_bounds_oversized_command_failure_details(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    private_stdout = "private-task-id-" + "x" * prepare.PRIVATE_COMMAND_TEXT_LIMIT
+    private_stderr = "private-task-error-" + "y" * prepare.PRIVATE_COMMAND_TEXT_LIMIT
+    result = prepare.swebench.CommandResult(19, private_stdout, private_stderr, 0.5)
+    monkeypatch.setattr(prepare.swebench, "_run_process", lambda *_args, **_kwargs: result)
+
+    def fail(**_kwargs: Any) -> str:
+        prepare._command_bytes(["git", "fsck"], cwd=tmp_path, timeout=5)
+        raise AssertionError("unreachable")
+
+    monkeypatch.setattr(prepare, "prepare_sources", fail)
+    failure_root = tmp_path / "oversized-command-failure"
+
+    with pytest.raises(SystemExit) as raised:
+        prepare.main(
+            [
+                "sources",
+                "--protocol",
+                str(tmp_path / "protocol"),
+                "--expected-acquisition-protocol-sha256",
+                "0" * 64,
+                "--exposure-ledger",
+                str(tmp_path / "exposure"),
+                "--rows",
+                str(tmp_path / "rows"),
+                "--selection",
+                str(tmp_path / "selection"),
+                "--cache-root",
+                str(tmp_path / "cache"),
+                "--output",
+                str(tmp_path / "map"),
+                "--failure-evidence-output",
+                str(failure_root),
+            ]
+        )
+
+    captured = capsys.readouterr()
+    assert raised.value.code == 2
+    assert captured.out == ""
+    assert captured.err == "benchmark preparation failed (PrepareError); evidence=preserved\n"
+    assert "private-task" not in captured.err
+    failure = json.loads((failure_root / "failure.json").read_text(encoding="utf-8"))
+    message = failure["exception_chain"][0]["message"]
+    prefix = "authenticated preparation command failed; private_result="
+    evidence = json.loads(message.removeprefix(prefix))
+    for stream, raw in (("stdout", private_stdout), ("stderr", private_stderr)):
+        stream_evidence = evidence[stream]
+        encoded = raw.encode()
+        assert stream_evidence["bytes"] == len(encoded)
+        assert stream_evidence["sha256"] == _sha256(encoded)
+        assert len(stream_evidence["text"].encode()) == prepare.PRIVATE_COMMAND_TEXT_LIMIT
+        assert stream_evidence["truncated"] is True
+    assert (failure_root / "artifact-manifest.json").is_file()
+
+
 def test_cli_rejects_used_failure_destination_before_private_work(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,