Address PR #353 CI review round 3 (1 P1 + 1 P3)

P1 - row-level non-negative-dose guard in `_aggregate_for_joint_test`:
On a 2-period direct call to `joint_pretrends_test` or
`joint_homogeneity_test`, the n_periods < 3 path skips
`_validate_had_panel_event_study` (which requires >= 3 periods) and
falls through to `_aggregate_for_joint_test`. That helper collapsed
unit dose via `groupby(unit_col)[dose_col].max()`, which silently
recodes a negative post dose to 0 (`max(0, -d) = 0` for positive
pre-period d), allowing finite joint-Stute output on data that
violates the HAD support restriction `D_{g,t} >= 0` (paper Section 2).

Fix: add a row-level `dose_col >= 0` check in
`_aggregate_for_joint_test` BEFORE the groupby/max collapse.
Centralizes the guard so both data-in wrappers inherit it on the
n_periods < 3 fallback path. The multi-period path already enforces
the same invariant via `_validate_had_panel_event_study`, so the
contract is consistent across both wrapper dispatch modes.

P3 - regression test: new
`TestJointHomogeneityTest::test_two_period_negative_post_dose_raises`
constructs a 2-period panel with a single unit carrying a negative
post dose and asserts the wrapper raises `ValueError` with the
"negative dose value" substring rather than producing a finite
statistic via the groupby-max collapse.

124 tests pass (123 + 1 new R3 regression); black/ruff/mypy clean.

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

Author: igerber

diff_diff/had_pretests.py

@@ -1737,6 +1737,26 @@ def _aggregate_for_joint_test(
                 f"silently drop rows; drop or impute before calling."
             )
 
+    # Row-level non-negative-dose guard (paper Section 2 HAD support
+    # restriction `D_{g,t} >= 0`). Must run BEFORE the groupby/max()
+    # collapse below, otherwise a negative post dose would silently
+    # become 0 in the per-unit dose vector (since `max(0, -d) = 0` for
+    # positive d), letting the wrappers run on invalid data and
+    # potentially return finite results. This is the direct-wrapper
+    # equivalent of the row-level check inside
+    # `_validate_had_panel_event_study`, centralized so both
+    # `joint_pretrends_test` and `joint_homogeneity_test` inherit it on
+    # the `n_periods < 3` fallback path that skips the validator.
+    negative_dose_mask = subset[dose_col] < 0
+    if bool(negative_dose_mask.any()):
+        n_neg = int(negative_dose_mask.sum())
+        raise ValueError(
+            f"{n_neg} negative dose value(s) found in column "
+            f"{dose_col!r} across periods {needed_periods}. HAD support "
+            f"restriction (paper Section 2) requires D_{{g,t}} >= 0 "
+            f"for every (unit, period)."
+        )
+
     counts = subset.groupby(unit_col).size()
     n_needed = len(needed_periods)
     if (counts != n_needed).any():

tests/test_had_pretests.py

@@ -2035,6 +2035,45 @@ def test_all_zero_dose_post_period_raises(self):
                 seed=0,
             )
 
+    def test_two_period_negative_post_dose_raises(self):
+        """R2 P1 regression: direct wrapper call on a 2-period panel
+        with a negative post dose must raise rather than silently
+        collapse to zero via ``groupby.max()`` and produce a finite
+        result. The 2-period path skips the event-study validator
+        (``n_periods < 3``) so the row-level non-negative guard must
+        live in ``_aggregate_for_joint_test`` itself."""
+        G = 20
+        rng = np.random.default_rng(601)
+        doses = rng.uniform(0.1, 1.0, size=G)
+        # Flip one unit's post dose to a negative value.
+        doses[0] = -0.3
+        rows = []
+        for g in range(G):
+            # pre-period
+            rows.append({"unit": g, "period": 0, "y": rng.normal(0, 0.1), "d": 0.0})
+            # post-period (with negative dose injected for unit 0)
+            rows.append(
+                {
+                    "unit": g,
+                    "period": 1,
+                    "y": rng.normal(0, 0.1) + 0.3 * doses[g],
+                    "d": float(doses[g]),
+                }
+            )
+        df = pd.DataFrame(rows)
+        with pytest.raises(ValueError, match="negative dose value"):
+            joint_homogeneity_test(
+                df,
+                "y",
+                "d",
+                "period",
+                "unit",
+                post_periods=[1],
+                base_period=0,
+                n_bootstrap=199,
+                seed=0,
+            )
+
 
 class TestMultiPeriodWorkflow:
     """Tests for :func:`did_had_pretest_workflow` event-study dispatch."""