Address PR #392 R6 review (2 P3, all non-blocking)

R6 was ✅ Looks good — 2 P3 polish items.

P3 #1 — version-aware repro installer:
benchmarks/R/requirements.R installed whatever CRAN currently
served via install.packages, while the generator and parity test
hard-pin DIDHAD == 2.0.0 / YatchewTest == 1.1.1 / nprobust ==
0.5.0. A fresh R environment regenerating the goldens would have
the generator's stopifnot(packageVersion == "X.Y.Z") immediately
abort.

Fix: add `install_pinned_version()` helper using
remotes::install_version with `upgrade = "never"`, run it after
the bulk CRAN install for DIDHAD/YatchewTest/nprobust. Idempotent
when the correct version is already installed. Bump procedure
documented in lockstep with the generator + parity-test pins.

P3 #2 — exact-set parity event_times:
_zip_r_python() previously asserted only that R-mapped horizons
were a SUBSET of Python's event_times (missing-in-python check).
Tighten to FULL SET EQUALITY: also reject horizons present in
Python but absent from R's requested set ("extra_in_python"). This
catches future event_study horizon-selection regressions in both
directions — e.g. if our effects/placebo cap drifts and Python
emits an extra row R didn't request.

Stats: 540 tests pass, 0 regressions. Still no estimator changes
— all P3 polish on the parity / repro infrastructure.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: igerber

benchmarks/R/requirements.R

@@ -36,6 +36,42 @@ install_if_missing <- function(pkg) {
   }
 }
 
+# PR #392 R6 P3: pinned-version installer for upstream packages whose
+# version is part of the parity contract. The HAD R-parity test
+# (`tests/test_did_had_parity.py`) and the generator
+# (`benchmarks/R/generate_did_had_golden.R`) hard-pin DIDHAD,
+# YatchewTest, and nprobust to specific versions; without a
+# version-aware installer here, a fresh R environment would silently
+# install whatever CRAN currently serves and the generator's
+# `stopifnot(packageVersion(...) == "X.Y.Z")` would abort.
+install_pinned_version <- function(pkg, version) {
+  if (requireNamespace(pkg, quietly = TRUE) &&
+      as.character(packageVersion(pkg)) == version) {
+    message(sprintf("%s is already at pinned version %s.", pkg, version))
+    return(invisible(NULL))
+  }
+  message(sprintf("Installing %s == %s (pinned for HAD R-parity)...", pkg, version))
+  if (!requireNamespace("remotes", quietly = TRUE)) {
+    install.packages("remotes", repos = "https://cloud.r-project.org/", quiet = TRUE)
+  }
+  remotes::install_version(
+    pkg,
+    version = version,
+    repos = "https://cloud.r-project.org/",
+    quiet = TRUE,
+    upgrade = "never"
+  )
+}
+
+# HAD R-parity (PR #392) version pins. Bump these in lockstep with
+# the generator's `stopifnot(packageVersion(...) == "X.Y.Z")` and the
+# parity test's `test_metadata_versions_match` when re-anchoring.
+pinned_versions <- list(
+  DIDHAD = "2.0.0",
+  YatchewTest = "1.1.1",
+  nprobust = "0.5.0"
+)
+
 install_github_if_missing <- function(pkg, repo) {
   if (!requireNamespace(pkg, quietly = TRUE)) {
     message(sprintf("Installing %s from GitHub...", pkg))
@@ -52,6 +88,15 @@ install_github_if_missing <- function(pkg, repo) {
 message("Installing CRAN packages...")
 lapply(required_packages, install_if_missing)
 
+# Reinforce the HAD R-parity pinned versions AFTER the bulk install
+# above (which may have installed any-CRAN-version of e.g. nprobust
+# as a transitive dep). install_pinned_version is idempotent if the
+# correct version is already installed.
+message("\nEnforcing HAD R-parity version pins...")
+for (pkg in names(pinned_versions)) {
+  install_pinned_version(pkg, pinned_versions[[pkg]])
+}
+
 # Install GitHub packages
 message("\nInstalling GitHub packages...")
 for (pkg in names(github_packages)) {

tests/test_did_had_parity.py

@@ -191,15 +191,22 @@ def _zip_r_python(
                 f"Python event_times = {py_event_times}. Mapping bug?"
             )
         pairs.append((i, py_idx_by_event_time[e], rowname))
-    # Exact-shape assertion: every R-mapped event time must be present
-    # in Python's event_times. Length-equality is too strict (Python
-    # may emit additional horizons R didn't request, e.g. e=0 anchor),
-    # but every R row must find a Python counterpart.
-    missing_in_python = set(expected_event_times) - set(py_event_times)
-    assert not missing_in_python, (
-        f"event_times mismatch: R requested {sorted(expected_event_times)} "
-        f"(mapped from R IDs); Python emitted {sorted(py_event_times)}; "
-        f"missing in Python: {sorted(missing_in_python)}."
+    # PR #392 R6 P3: exact set equality between R-mapped horizons and
+    # Python's event_times (was: subset inclusion). Catches
+    # horizon-selection regressions in BOTH directions:
+    #   - missing_in_python: Python silently dropped a horizon R requested
+    #   - extra_in_python: Python emitted an extra horizon R did not
+    #     request (e.g. effects/placebo cap drift in our event_study path)
+    expected_set = set(expected_event_times)
+    py_set = set(py_event_times)
+    missing_in_python = expected_set - py_set
+    extra_in_python = py_set - expected_set
+    assert not missing_in_python and not extra_in_python, (
+        f"event_times set-equality mismatch: "
+        f"R-mapped {sorted(expected_set)}; Python emitted "
+        f"{sorted(py_event_times)}; missing in Python: "
+        f"{sorted(missing_in_python)}; extra in Python: "
+        f"{sorted(extra_in_python)}."
     )
     return pairs