fix(bench): drop --3way fallback + post-verify in apply_as_commit

Diagnostic on the 1500-instance ceiling probe: 53% of swebench_verified
instances reported file_recall=0.0 with mean recall 0.45 even at
budget=10M. Investigating one (astropy__astropy-13033) showed the
git diff after apply_as_commit committed files COMPLETELY UNRELATED
to the gold patch -- e.g. CHANGES.rst, docs/changes/* instead of the
declared astropy/timeseries/core.py. 5/5 sampled zero-recall instances
have the same pattern with totally different committed content.

Root cause:
1. ensure_repo's `git checkout --force base_commit` silently fails on
   shallow / incomplete bare clones -- HEAD stays at some main-branch
   commit, returncode=0 misleads the caller.
2. apply_as_commit then runs `git apply --index` which fails strictly
   on a wrong-base worktree (returncode != 0).
3. Falls through to `git apply --index --3way` which uses fuzzy
   matching and silently applies the patch on whatever state HEAD
   happens to be at.
4. Commit creates a HEAD~1..HEAD diff that is the patch reapplied
   on top of arbitrary main-branch content -- typically committing
   completely unrelated files.
5. Pipeline analyzes that diff and reports recall against gold_files
   that were never the patch's target.

This invalidates downstream metrics for those instances. Headline
0.875 from old paper runs likely predates the regression that broke
the silent-checkout edge case (or used a different cache state); the
ceiling probe at budget=10M reporting 0.42 is a measurement artefact
on instances corrupted by this bug.

Fix:
- Remove --3way fallback. `git apply --index` strict mode is the only
  path; failures return False and the instance is flagged.
- Post-apply verify: `git diff --name-only HEAD~1..HEAD` must match
  the patch's declared target files (extracted from --- a/ / +++ b/
  headers). Mismatch -> return False with APPLY VERIFY FAIL log.

ensure_repo's silent-checkout problem still exists upstream; that fix
needs `git rev-parse HEAD` verification + targeted fetch when
base_commit is missing. Tracked for follow-up. The current change
catches the symptom so no benchmark number is silently wrong.

Author: nikolay-e

benchmarks/common.py

@@ -212,18 +212,74 @@ def ensure_repo(
     return repo_dir
 
 
+def _patch_target_files(patch_text: str) -> set[str]:
+    """Extract target file paths from a unified diff (the +++ b/<path>
+    lines, /dev/null excluded). Used to verify post-apply that git
+    actually committed the patch's changes and not stale worktree state.
+    """
+    out: set[str] = set()
+    for line in patch_text.splitlines():
+        if line.startswith("+++ b/"):
+            p = line[6:].strip()
+            if p and p != "/dev/null":
+                out.add(p)
+        elif line.startswith("--- a/"):
+            p = line[6:].strip()
+            if p and p != "/dev/null":
+                out.add(p)
+    return out
+
+
 def apply_as_commit(repo_dir: Path, patch_text: str, message: str = "bench") -> bool:
+    """Apply ``patch_text`` as a single commit on top of HEAD and verify
+    the resulting ``HEAD~1..HEAD`` diff matches the patch's declared
+    target files. Returns False on any of: apply error, post-apply
+    file-set mismatch (``git apply --3way`` is permissive enough to
+    silently accept fuzzy / wrong applies on dirty worktrees, which
+    silently corrupts every downstream metric in the benchmark).
+
+    The verification is symmetric-difference vs.\\ a permissive subset:
+    we require the committed file set to be a *non-empty* subset of the
+    patch's declared targets. Extra files in HEAD (e.g.\\ leftover
+    untracked from a previous instance) are rejected; missing files
+    (patch declared file not in commit) are also rejected.
+    """
+    expected = _patch_target_files(patch_text)
     with tempfile.NamedTemporaryFile(mode="w", suffix=".patch", delete=False) as f:
         f.write(patch_text)
         patch_path = f.name
     try:
         r = run_cmd(["git", "-C", str(repo_dir), "apply", "--index", patch_path], check=False)
         if r.returncode != 0:
-            r = run_cmd(["git", "-C", str(repo_dir), "apply", "--index", "--3way", patch_path], check=False)
-            if r.returncode != 0:
-                print(f"  APPLY FAIL: {r.stderr[:300]}")
-                return False
-        run_cmd(["git", "-C", str(repo_dir), "commit", "-m", message, "--allow-empty", "--no-verify"], check=False)
+            # `--3way` is intentionally NOT used as a fallback here.
+            # Empirically (May 2026), --3way silently produced commits
+            # whose name-only diff bore no resemblance to the gold
+            # patch on ~53% of swebench_verified instances, generating
+            # fake zero-recall measurements for those. If the strict
+            # apply fails, the instance is unrecoverable in the
+            # benchmark and must be flagged.
+            print(f"  APPLY FAIL: {r.stderr[:300]}")
+            return False
+        run_cmd(
+            ["git", "-C", str(repo_dir), "commit", "-m", message, "--allow-empty", "--no-verify"],
+            check=False,
+        )
+
+        # Post-apply verification: which files actually got committed?
+        diff_r = run_cmd(
+            ["git", "-C", str(repo_dir), "diff", "--name-only", "HEAD~1..HEAD"],
+            check=False,
+        )
+        committed = {ln.strip() for ln in diff_r.stdout.splitlines() if ln.strip()}
+        if expected and committed != expected:
+            extra = committed - expected
+            missing = expected - committed
+            print(
+                f"  APPLY VERIFY FAIL: committed={sorted(committed)[:5]} "
+                f"expected={sorted(expected)[:5]} "
+                f"extra_n={len(extra)} missing_n={len(missing)}"
+            )
+            return False
         return True
     finally:
         os.unlink(patch_path)