Tighten SyntheticDiD set_params and TWFE Conley + wild_bootstrap guards

Closes two no-silent-failure gaps surfaced after the initial Phase 1 commit:

1. SyntheticDiD.set_params() now mirrors __init__'s Conley rejection contract.
   The constructor correctly raises TypeError on vcov_type="conley" /
   conley_*=... but set_params() previously only checked hasattr(self, key)
   and silently accepted those kwargs because SyntheticDiD inherits the
   conley_* attributes from DifferenceInDifferences. A user calling
   est.set_params(vcov_type="conley", conley_cutoff_km=100.0) followed by
   est.fit(...) would have gotten the bootstrap/jackknife/placebo variance
   silently with no Conley computation -- forbidden by feedback_no_silent_failures.

   The new set_params() rejects non-None vcov_type and any non-None conley_*
   kwarg with TypeError before mutation; None values for these keys are
   passthrough no-ops so get_params() -> set_params() round-trips cleanly.
   SyntheticDiD.get_params() now surfaces the inherited conley_* keys with
   None values for sklearn-style API consistency.

2. TwoWayFixedEffects(vcov_type="conley", inference="wild_bootstrap") now
   raises NotImplementedError. Conley analytical spatial-HAC and wild cluster
   bootstrap are different inference paths; combining them would route the
   bootstrap branch with cluster_ids=None (TWFE auto-cluster is disabled
   under Conley) and fail with a non-targeted error inside wild_bootstrap_se.
   Use inference='analytical' for Conley spatial HAC, or vcov_type='hc1'
   with inference='wild_bootstrap'.

3. DifferenceInDifferences and MultiPeriodDiD class docstrings now list
   vcov_type="conley" in the enum and document the four conley_* params
   (previously the Conley path was documented in REGISTRY/CHANGELOG/llms.txt
   but the in-code class docs still listed only {classical, hc1, hc2, hc2_bm}).

4. New tests:
   - SyntheticDiD().set_params(vcov_type="conley") raises TypeError + state
     unchanged
   - SyntheticDiD().set_params(conley_cutoff_km=100.0) raises + state unchanged
   - SyntheticDiD().get_params() includes conley_* keys with None values;
     round-trip set_params(**get_params()) is a no-op
   - TwoWayFixedEffects(vcov_type="conley", inference="wild_bootstrap") raises

5. TODO.md entries added for deferred follow-ups: callable-conley_metric
   shape/finiteness/symmetry validation, common Conley estimator-validator
   helper extraction, and a stronger TWFE Conley FWL invariance test that
   actually compares TWFE-within Conley to a full-dummy FE design (the
   current test only asserts finite SEs).

74 Conley tests pass (70 prior + 4 new); 261 tests pass on the targeted
regression surface (test_conley_vcov, test_estimators_vcov_type, test_linalg,
test_linalg_hc2_bm).

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

Author: igerber

TODO.md

@@ -117,6 +117,9 @@ Deferred items from PR reviews that were not addressed before merge.
 | Conley + survey weights / `survey_design`. Score-reweighted meat `s_i = w_i · X_i · ε_i` is mechanical, but PSU clustering interaction with the spatial kernel and replicate-weights variance under spatial correlation are non-trivial (Bertanha-Imbens 2014 covers cluster-sample but not the explicit Conley case). Phase 5 of the spillover-conley initiative; paper review prerequisite. Currently raises `NotImplementedError`. | `linalg.py::_validate_vcov_args`, `twfe.py`, `estimators.py` | Phase 5 (spillover-conley) | Medium |
 | Conley + `absorb=` (arbitrary FE projection beyond TWFE's two-FE within-transformation). FWL composability is proven analytically for TWFE's fixed two-FE design but not formally verified for arbitrary `absorb` dimensions; conservatively rejected at fit-time with a redirect to `fixed_effects=` dummies. Lift after empirical verification on multi-FE within-transformations. | `estimators.py::DifferenceInDifferences.fit`, `MultiPeriodDiD.fit` | follow-up (spillover-conley) | Low |
 | `SyntheticDiD(vcov_type="conley")` support. Currently raises `TypeError` at `__init__` because SyntheticDiD uses `variance_method ∈ {bootstrap, jackknife, placebo}` rather than the analytical sandwich that Conley plugs into. Wiring would require either reimplementing an analytical sandwich path for SyntheticDiD or designing a spatial-block bootstrap (new methodology, Politis-Romano 1994 territory). | `synthetic_did.py::SyntheticDiD` | follow-up (spillover-conley) | Low |
+| Validate user-supplied callable `conley_metric` for shape `(n, n)`, finiteness, non-negativity, and symmetry. Currently `np.asarray(metric(coords, coords))` is accepted unchecked; a malformed callable produces opaque matmul errors and a non-symmetric distance matrix produces a non-symmetric vcov. CI reviewer flagged as P2 M3 in PR #(spillover-conley). | `diff_diff/conley.py::_pairwise_distance_matrix`, `_compute_conley_vcov` | follow-up (spillover-conley) | Low |
+| Extract common Conley estimator-level validation helper. Today `cluster=`, `survey_design=`, `conley_coords=`, and `conley_cutoff_km=` checks are duplicated across `DifferenceInDifferences.fit` (estimators.py:~370-400), `MultiPeriodDiD.fit` (estimators.py:~1395-1455), and `TwoWayFixedEffects.fit` (twfe.py:~165-205). A future Conley-feature change risks updating one estimator but not the others. CI reviewer flagged as P2 MT1. | `diff_diff/estimators.py`, `diff_diff/twfe.py` | follow-up (spillover-conley) | Low |
+| Strengthen `tests/test_conley_vcov.py::TestConleyTWFE::test_twfe_conley_FWL_invariance` to actually verify FWL equivalence between TWFE-within Conley and a full-dummy-FE design (build the dummy regression explicitly and compare the ATT coefficient + Conley SE). The current test only asserts both fits produce finite SEs — the name overstates the assertion. CI reviewer flagged as P2 DT3. | `tests/test_conley_vcov.py` | follow-up (spillover-conley) | Low |
 
 #### Performance
 

diff_diff/estimators.py

@@ -57,7 +57,7 @@ class DifferenceInDifferences:
         ``vcov_type``: with ``"hc1"`` dispatches to CR1 (Liang-Zeger); with
         ``"hc2_bm"`` dispatches to CR2 Bell-McCaffrey (Pustejovsky-Tipton 2018
         symmetric-sqrt + Satterthwaite DOF).
-    vcov_type : {"classical", "hc1", "hc2", "hc2_bm"}, optional
+    vcov_type : {"classical", "hc1", "hc2", "hc2_bm", "conley"}, optional
         Variance-covariance family. Defaults to the ``robust`` alias.
 
         - ``"classical"``: non-robust OLS SEs, ``sigma_hat^2 * (X'X)^{-1}``.
@@ -69,6 +69,11 @@ class DifferenceInDifferences:
           with ``cluster=``, Pustejovsky-Tipton (2018) CR2 cluster-robust.
           (Note: ``MultiPeriodDiD`` does NOT yet support ``cluster=`` with
           ``"hc2_bm"`` — see ``MultiPeriodDiD`` docstring and REGISTRY.md.)
+        - ``"conley"``: Conley (1999) spatial-HAC sandwich. Requires
+          ``conley_coords`` (lat/lon column tuple) and ``conley_cutoff_km``
+          (positive bandwidth — REQUIRED, no default per the no-silent-failures
+          rule). Combining with ``cluster=``, ``survey_design=``, or ``absorb=``
+          raises ``NotImplementedError`` (deferred to Phase 2+).
     alpha : float, default=0.05
         Significance level for confidence intervals.
     inference : str, default="analytical"
@@ -88,6 +93,20 @@ class DifferenceInDifferences:
         - "warn": Issue warning and drop linearly dependent columns (default)
         - "error": Raise ValueError
         - "silent": Drop columns silently without warning
+    conley_coords : tuple of (str, str), optional
+        Column-name tuple ``(lat_col, lon_col)`` for Conley spatial HAC SE.
+        Required when ``vcov_type="conley"``; raises ``ValueError`` otherwise.
+    conley_cutoff_km : float, optional
+        Positive finite bandwidth in km (haversine) or coord units (euclidean).
+        Required when ``vcov_type="conley"``; no default per Conley 1999
+        Section 5 sensitivity-grid recommendation.
+    conley_metric : str, default "haversine"
+        Distance metric: ``"haversine"`` (lat/lon, km), ``"euclidean"`` (any
+        units), or a callable ``(coords1, coords2) -> n×n``.
+    conley_kernel : str, default "bartlett"
+        Kernel function: ``"bartlett"`` (PSD-guaranteed, default) or
+        ``"uniform"`` (emits ``UserWarning`` if the meat has a materially
+        negative eigenvalue per Conley 1999 footnote 11).
 
     Attributes
     ----------
@@ -1055,7 +1074,7 @@ class MultiPeriodDiD(DifferenceInDifferences):
         ``TODO.md``; also documented as a Note in
         ``docs/methodology/REGISTRY.md`` under the HeterogeneousAdoptionDiD
         requirements-checklist block.
-    vcov_type : {"classical", "hc1", "hc2", "hc2_bm"}, optional
+    vcov_type : {"classical", "hc1", "hc2", "hc2_bm", "conley"}, optional
         Variance-covariance family. Defaults to the ``robust`` alias.
 
         - ``"classical"``: non-robust OLS SEs, ``sigma_hat^2 * (X'X)^{-1}``.
@@ -1066,8 +1085,23 @@ class MultiPeriodDiD(DifferenceInDifferences):
         - ``"hc2_bm"``: one-way HC2 + Imbens-Kolesar (2016) Satterthwaite DOF
           per coefficient plus a contrast-aware DOF for the post-period-average
           ATT. **Unsupported with** ``cluster=`` — see ``cluster`` above.
+        - ``"conley"``: Conley (1999) spatial-HAC sandwich. Requires
+          ``conley_coords`` and ``conley_cutoff_km``. Combining with
+          ``cluster=``, ``survey_design=``, or ``absorb=`` raises
+          ``NotImplementedError`` (deferred to Phase 2+).
     alpha : float, default=0.05
         Significance level for confidence intervals.
+    conley_coords : tuple of (str, str), optional
+        Column-name tuple ``(lat_col, lon_col)`` for Conley spatial HAC SE.
+        Required when ``vcov_type="conley"``.
+    conley_cutoff_km : float, optional
+        Positive finite bandwidth for Conley spatial HAC. Required when
+        ``vcov_type="conley"`` (no default per Conley 1999 sensitivity-grid).
+    conley_metric : str, default "haversine"
+        Distance metric for Conley: ``"haversine"`` (lat/lon, km),
+        ``"euclidean"``, or a callable.
+    conley_kernel : str, default "bartlett"
+        Conley kernel: ``"bartlett"`` (PSD-guaranteed) or ``"uniform"``.
 
     Attributes
     ----------

diff_diff/synthetic_did.py

@@ -2706,6 +2706,16 @@ def get_params(self) -> Dict[str, Any]:
             "variance_method": self.variance_method,
             "n_bootstrap": self.n_bootstrap,
             "seed": self.seed,
+            # Conley kwargs are inherited from DifferenceInDifferences.__init__
+            # but rejected by SyntheticDiD's __init__ / set_params (Conley uses
+            # the analytical sandwich, SyntheticDiD uses bootstrap variance).
+            # Surface them here as None for sklearn-style API consistency; any
+            # non-None value is rejected by set_params/__init__.
+            "vcov_type": None,
+            "conley_coords": None,
+            "conley_cutoff_km": None,
+            "conley_metric": None,
+            "conley_kernel": None,
         }
 
     def set_params(self, **params) -> "SyntheticDiD":
@@ -2715,16 +2725,54 @@ def set_params(self, **params) -> "SyntheticDiD":
         post-update state, the instance is rolled back to the pre-call values
         so a raised ``ValueError`` leaves the object consistent with its
         pre-call configuration.
+
+        Mirrors ``__init__``'s defensive rejection of ``vcov_type`` /
+        ``conley_*`` non-None values: SyntheticDiD uses bootstrap/jackknife/
+        placebo variance, not the analytical sandwich, so any Conley kwarg
+        would be silently ignored otherwise (forbidden by
+        ``feedback_no_silent_failures``). Tracked in TODO.md for a follow-up
+        that wires Conley to a non-bootstrap variance path.
         """
+        # Reject Conley kwargs / non-None vcov_type before any mutation —
+        # mirrors __init__'s contract. Empty/None values are permitted so
+        # round-tripping get_params() back through set_params() is a no-op.
+        _conley_keys = ("conley_coords", "conley_cutoff_km", "conley_metric", "conley_kernel")
+        if params.get("vcov_type") is not None and params["vcov_type"] != "conley":
+            raise TypeError(
+                f"SyntheticDiD does not accept vcov_type={params['vcov_type']!r}. "
+                "SyntheticDiD's variance is bootstrap/jackknife/placebo based; "
+                "configure via variance_method=..."
+            )
+        if params.get("vcov_type") == "conley" or any(
+            k in params and params[k] is not None for k in _conley_keys
+        ):
+            raise TypeError(
+                "SyntheticDiD does not yet support vcov_type='conley' or any "
+                "conley_* kwargs. SyntheticDiD uses bootstrap/jackknife/placebo "
+                "variance (variance_method=...), not the analytical sandwich "
+                "routed through compute_robust_vcov. Tracked in TODO.md as "
+                "a follow-up."
+            )
         # Deprecated parameter names — emit warning and ignore
         _deprecated = {"lambda_reg", "zeta"}
+        # Conley kwargs are not stored as instance attributes; surfacing them
+        # in get_params() returns None unconditionally. set_params() with None
+        # values for these keys is a no-op (the rejection above only fires on
+        # non-None values).
+        _silent_conley_passthrough = {"vcov_type", *_conley_keys}
         # Snapshot original values for transactional rollback on validation failure.
         _rollback: Dict[str, Any] = {}
         for key in params:
+            if key in _silent_conley_passthrough:
+                continue
             if key not in _deprecated and hasattr(self, key):
                 _rollback[key] = getattr(self, key)
         try:
             for key, value in params.items():
+                if key in _silent_conley_passthrough:
+                    # No-op: explicitly None passthrough for round-trip
+                    # get_params() -> set_params() consistency.
+                    continue
                 if key in _deprecated:
                     warnings.warn(
                         f"{key} is deprecated and ignored. Use zeta_omega/zeta_lambda "

diff_diff/twfe.py

@@ -162,6 +162,22 @@ def fit(  # type: ignore[override]
                 "Conley; the unit auto-cluster default is also disabled "
                 "when vcov_type='conley'."
             )
+        # Conley + wild_bootstrap: Conley is an analytical spatial-HAC
+        # variance and wild cluster bootstrap is a different inference path
+        # that resamples residuals within clusters. There is no clean
+        # composition — the two methods target different things — and
+        # combining them would either silently drop one or fail downstream
+        # (TWFE auto-cluster is disabled under Conley, so the bootstrap
+        # would receive cluster_ids=None and fail with a non-targeted
+        # error in `wild_bootstrap_se`). Reject early.
+        if self.vcov_type == "conley" and self.inference == "wild_bootstrap":
+            raise NotImplementedError(
+                "TwoWayFixedEffects(vcov_type='conley', inference='wild_bootstrap') "
+                "is not supported: Conley is an analytical spatial-HAC variance and "
+                "wild cluster bootstrap is a different inference path. Use "
+                "inference='analytical' for Conley spatial HAC, or use "
+                "vcov_type='hc1' with inference='wild_bootstrap'."
+            )
         if self.vcov_type == "conley":
             if survey_design is not None:
                 raise NotImplementedError(

tests/test_conley_vcov.py

@@ -798,6 +798,22 @@ def test_twfe_conley_with_explicit_cluster_raises(self, panel):
                 conley_cutoff_km=2000.0,
             ).fit(panel, outcome="y", treatment="treated", time="time", unit="unit")
 
+    def test_twfe_conley_with_wild_bootstrap_raises(self, panel):
+        """Conley analytical spatial-HAC and wild cluster bootstrap are
+        different inference paths; combining them would either silently drop
+        one or fail downstream (TWFE auto-cluster is disabled under Conley,
+        so the bootstrap would receive cluster_ids=None). Reject early.
+        Closes CI reviewer P1 CQ2."""
+        from diff_diff import TwoWayFixedEffects
+
+        with pytest.raises(NotImplementedError, match="wild_bootstrap"):
+            TwoWayFixedEffects(
+                vcov_type="conley",
+                inference="wild_bootstrap",
+                conley_coords=("lat", "lon"),
+                conley_cutoff_km=2000.0,
+            ).fit(panel, outcome="y", treatment="treated", time="time", unit="unit")
+
     def test_twfe_conley_FWL_invariance(self, panel):
         """TWFE Conley SE matches DifferenceInDifferences with same kwargs
         (verifies FWL composability — Conley meat survives within-transformation
@@ -905,6 +921,52 @@ def test_synthetic_did_conley_kwarg_raises(self):
         with pytest.raises(TypeError, match="conley"):
             SyntheticDiD(conley_cutoff_km=100.0)  # type: ignore[call-arg]
 
+    def test_synthetic_did_set_params_conley_raises(self):
+        """SyntheticDiD.set_params(vcov_type='conley') must raise (mirrors
+        __init__'s contract — closes the silent-bypass gap CI reviewer flagged
+        as P1 CQ1)."""
+        from diff_diff import SyntheticDiD
+
+        est = SyntheticDiD()
+        # Snapshot pre-call state
+        before_variance = est.variance_method
+        before_n_boot = est.n_bootstrap
+        before_zeta = est.zeta_omega
+
+        with pytest.raises(TypeError, match="conley"):
+            est.set_params(vcov_type="conley")
+        # Verify nothing mutated
+        assert est.variance_method == before_variance
+        assert est.n_bootstrap == before_n_boot
+        assert est.zeta_omega == before_zeta
+
+    def test_synthetic_did_set_params_conley_kwarg_raises(self):
+        from diff_diff import SyntheticDiD
+
+        est = SyntheticDiD()
+        with pytest.raises(TypeError, match="conley"):
+            est.set_params(conley_cutoff_km=100.0)
+        # Verify the conley attr stays None (rejected before mutation)
+        assert getattr(est, "conley_cutoff_km", None) is None
+
+    def test_synthetic_did_get_params_includes_conley_keys(self):
+        """get_params() / set_params() round-trip must include the inherited
+        conley_* keys with None values for sklearn-style API consistency
+        (CI reviewer P2 CQ3)."""
+        from diff_diff import SyntheticDiD
+
+        est = SyntheticDiD(variance_method="placebo", n_bootstrap=10)
+        params = est.get_params()
+        assert "vcov_type" in params and params["vcov_type"] is None
+        assert "conley_coords" in params and params["conley_coords"] is None
+        assert "conley_cutoff_km" in params and params["conley_cutoff_km"] is None
+        assert "conley_metric" in params and params["conley_metric"] is None
+        assert "conley_kernel" in params and params["conley_kernel"] is None
+        # Round-trip: passing None values back into set_params is a no-op
+        est.set_params(**params)
+        assert est.variance_method == "placebo"
+        assert est.n_bootstrap == 10
+
 
 class TestConleySetParamsAtomicity:
     """set_params atomicity for Conley fields. Per