diff --git a/TODO.md b/TODO.md
index 96e8d23b9..b0c7e859a 100644
--- a/TODO.md
+++ b/TODO.md
@@ -22,7 +22,6 @@ Related tracking surfaces:
 | Issue | Location | Origin | Effort | Priority |
 |-------|----------|--------|--------|----------|
 | Consolidate the remaining estimator-entangled DR/logit score variants (`staggered.py::_doubly_robust` + RC twins, `triple_diff.py`, `lwdid.py`, `wooldridge.py`) onto the shared `_dr_scores.py` module, each migration with its own committed oracle capture (the ContinuousDiD lift's two-tier pattern in `tests/test_dr_scores.py`); and add a ridge vcov path to `solve_ridge` if an estimator ever needs analytical ridge inference | `diff_diff/_dr_scores.py` | dml-b0 | Mid | Low |
-| hc2/hc2_bm floor `1 - h_ii` at 1e-10 in the shared leverage meat, fabricating finite (if inflated) variances for leverage-one observations - hc3 now fails closed there (LWDiD fix wave) but the pre-existing hc2 family behavior is released surface; decide fail-closed vs keep-floor for hc2/hc2_bm | `diff_diff/linalg.py` | #588 | Quick | Low |
 | Numeric between-period cohorts (e.g. `first_treat=4.5` with integer times) are rejected by LWDiD while CallawaySantAnna estimates them and LWDiD's own datetime/Period cohorts map to the next observed period — close the dtype asymmetry by adopting the next-observed-period mapping for numeric cohorts too (contract documented in REGISTRY cohort-encodings Note + `docs/api/lwdid.rst` Input Contract). Lands only after PR #588 merges | `diff_diff/lwdid.py` | #588 | Quick | Low |
 | Implement the LW 2026 eq. 7.9/7.10 unit-average cohort estimand (regress per-unit post-average transformed outcomes on `[1, D_g]` vs never-treated) as an alternative to the documented cell-mass `cohort_effects` convention (REGISTRY within-cohort aggregation Note; the two differ on unbalanced panels, where cell-mass weights units by observed post periods). Needs the 7.10 regression + its covariance on the NT path. Lands only after PR #588 merges | `diff_diff/lwdid_staggered.py` | #588 | Quick | Low |
 | Expose cell-mass overall ATT (Stata `Post_avg` convention; = CS-simple on balanced panels) as an aggregate extra on LWDiD results — the fit's `.att` is the paper's `tau_omega` (cohort-mean-then-treated-weight, eq. 7.18); the authors' large-N display uses cell-mass weighting instead, and both are legitimate estimands (see the REGISTRY LWDiD Aggregation note). Lands only after PR #588 merges | `diff_diff/lwdid_results.py` | #588 | Quick | Low |
diff --git a/changelog.d/20260906-hc2-leverage-one-fail-closed.md b/changelog.d/20260906-hc2-leverage-one-fail-closed.md
new file mode 100644
index 000000000..3651ba73c
--- /dev/null
+++ b/changelog.d/20260906-hc2-leverage-one-fail-closed.md
@@ -0,0 +1,51 @@
+### Fixed
+- **`hc2` / `hc2_bm` no longer report an understated finite variance at a
+  leverage-one observation**: the shared one-way leverage meat floored
+  `1 - h_ii` at 1e-10, which did not inflate the perfectly-fitted row's
+  term but silently dropped its outcome noise (probe `[1, D]` with a single
+  treated unit: HC2 SE 0.19 against the exact classical 0.47), and
+  `hc2_bm` paired that finite SE with a NaN Satterthwaite DOF. Both now
+  fail closed exactly like `hc3` (see Behavioral Changes). The Rust HC2
+  kernel mirrors the change (no floor; it signals and the Python dispatcher
+  re-dispatches to the NumPy branch, which emits the single warning). The
+  sibling floor in the one-way Bell-McCaffrey DOF helper is removed: at
+  leverage one every contrast's DOF is NaN because the HC2 variance it
+  belongs to is undefined; below leverage one nothing changes.
+- **Zero-count `fweight` rows no longer trip the HC3 leverage guard or the
+  HC1 fallback**: under frequency weights the leverage of a zero-count row
+  is the unweighted quadratic form against the weighted bread and is
+  unbounded, so an inert row could NaN the `hc3` vcov or push `hc2` into an
+  HC1 fallback that broke expansion parity. Zero-count rows are excluded
+  from the guard and from the meat, so compressed HC2/HC3 equal the literal
+  `np.repeat` expansion at any leverage.
+- `LWDiD` no longer emits a second, differently worded "HC2 variance is
+  undefined" warning per cell on leverage-one designs; the shared kernel's
+  warning is the only one (behavior otherwise unchanged: LWDiD already
+  failed closed there).
+
+### Behavioral Changes
+- **Leverage-one designs under `vcov_type="hc2"` (every weight type) and
+  under unweighted, unclustered `vcov_type="hc2_bm"` now return an all-NaN
+  covariance and DOF vector with a `UserWarning`** ("HC2 variance is
+  undefined: N observation(s) have hat-matrix leverage ~1 ...") whenever a
+  positive-weight row has `h_ii >= 1 - 1e-8`, matching the released `hc3`
+  contract and R `sandwich::vcovHC` (NaN at hat values ~1). Point
+  estimates are unchanged; `se`, `t_stat`, `p_value` and confidence
+  intervals are NaN. The former warn-and-fall-back-to-HC1 branch for
+  over-one leverage is retired (that case is inside the new guard).
+  Affected surfaces: `DifferenceInDifferences`, `MultiPeriodDiD` and
+  `LinearRegression` on both families; `TwoWayFixedEffects` on explicit
+  `hc2` and on `hc2_bm` in event-study `spec="pooled"` without `unit=`;
+  `SunAbraham` and `WooldridgeDiD` (OLS) full-dummy fits under one-way
+  `hc2` whenever the design has a singleton cohort x period cell. Weighted
+  (pweight) `hc2_bm` — including a no-op `weights=np.ones(n)` — keeps the
+  clubSandwich singleton-CR2 generalized-inverse result and stays finite,
+  as does clustered CR2; this asymmetry is a documented deviation from
+  `clubSandwich` for the unweighted case (maintainer decision, 2026-09).
+  Remedy: `vcov_type="classical"` (exact inference under homoskedastic
+  normal errors; needs positive residual df) or add observations to the
+  perfectly-fitted cell. `hc1` is deliberately not offered as a remedy: it
+  also omits the zero-residual row and would return the understated number.
+- The shared leverage-one warning (also used by `hc3`) now names the
+  offending row indices and recommends classical exact inference or more
+  observations in the cell instead of "add treated units".
diff --git a/diff_diff/estimators.py b/diff_diff/estimators.py
index 07d81da20..60d5800db 100644
--- a/diff_diff/estimators.py
+++ b/diff_diff/estimators.py
@@ -109,7 +109,12 @@ class DifferenceInDifferences(BaseEstimator):
           (library default). With ``cluster=``, uses CR1 (Liang-Zeger).
         - ``"hc2"``: leverage-corrected meat (one-way only). Errors with
           ``cluster=``; use ``"hc2_bm"`` for clustered Bell-McCaffrey.
-        - ``"hc2_bm"``: one-way HC2 + Imbens-Kolesar (2016) Satterthwaite DOF;
+          A leverage-one observation has no defined HC2 variance and the
+          vcov fails closed (warning + NaN inference, point estimate
+          preserved) rather than flooring ``1 - h_ii``.
+        - ``"hc2_bm"``: one-way HC2 + Imbens-Kolesar (2016) Satterthwaite DOF
+          (unweighted and unclustered, it shares the ``hc2`` leverage-one
+          fail-closed contract);
           with ``cluster=``, Pustejovsky-Tipton (2018) CR2 cluster-robust.
           ``MultiPeriodDiD(cluster=..., vcov_type="hc2_bm")`` is supported and
           uses a cluster-aware Bell-McCaffrey contrast DOF for the
@@ -2513,9 +2518,14 @@ class MultiPeriodDiD(DifferenceInDifferences):
           (library default). With ``cluster=``, uses CR1 (Liang-Zeger).
         - ``"hc2"``: leverage-corrected meat (one-way only). Errors with
           ``cluster=``; use ``"hc2_bm"`` without cluster for Bell-McCaffrey.
+          A leverage-one observation has no defined HC2 variance and the
+          vcov fails closed (warning + NaN inference, point estimate
+          preserved) rather than flooring ``1 - h_ii``.
         - ``"hc2_bm"``: one-way HC2 + Imbens-Kolesar (2016) Satterthwaite DOF
           per coefficient plus a contrast-aware DOF for the post-period-average
-          ATT. With ``cluster=``, dispatches to Pustejovsky-Tipton (2018)
+          ATT (unclustered, it shares the ``hc2`` leverage-one fail-closed
+          contract: all-NaN vcov and DOF, point estimates preserved). With
+          ``cluster=``, dispatches to Pustejovsky-Tipton (2018)
           CR2 cluster-robust with a Bell-McCaffrey Satterthwaite contrast DOF
           on the post-period average (see ``cluster`` above for parity
           details). Weighted CR2-BM (``survey_design=``) is still gated.
diff --git a/diff_diff/linalg.py b/diff_diff/linalg.py
index 8252222e1..d68b2dabf 100644
--- a/diff_diff/linalg.py
+++ b/diff_diff/linalg.py
@@ -1170,7 +1170,11 @@ def solve_ols(
           (default). With ``cluster_ids``, dispatches to CR1 (Liang-Zeger).
         - ``"hc2"``: leverage-corrected meat. One-way only; raises with
           ``cluster_ids`` (use ``"hc2_bm"`` for clustered Bell-McCaffrey).
-        - ``"hc2_bm"``: HC2 + Imbens-Kolesar (2016) Satterthwaite DOF one-way;
+          An observation with leverage ``h_ii ~ 1`` has no defined HC2
+          variance and the vcov fails closed (warning + NaN) rather than
+          flooring ``1 - h_ii``; point estimates are unaffected.
+        - ``"hc2_bm"``: HC2 + Imbens-Kolesar (2016) Satterthwaite DOF one-way
+          (unweighted: same leverage-one fail-closed contract as ``hc2``);
           Pustejovsky-Tipton (2018) CR2 Bell-McCaffrey with ``cluster_ids``.
           With ``weights``, dispatches to the clubSandwich WLS-CR2 port —
           supported for ``weight_type="pweight"`` only. ``aweight`` and
@@ -2158,13 +2162,26 @@ def compute_robust_vcov(
     - ``"hc2"``: leverage-corrected meat
       ``sum_i (u_i^2 / (1 - h_ii)) x_i x_i'`` where ``h_ii`` are hat-matrix
       diagonals. No DOF adjustment beyond ``n - k``. One-way only; errors with
-      ``cluster_ids``.
+      ``cluster_ids``. A positive-weight observation with leverage
+      ``h_ii ~ 1`` (a perfectly fitted row, e.g. a single treated unit) has
+      no defined HC2 variance: the vcov fails closed (warning + all-NaN
+      vcov and DOF) rather than flooring ``1 - h_ii``, matching R
+      ``sandwich::vcovHC`` (NaN) and the ``hc3`` contract; point estimates
+      are unaffected. Under ``fweight`` a zero-count row is excluded from
+      the guard and the meat (compressed equals literal expansion).
     - ``"hc3"``: jackknife-style leverage correction, meat
       ``sum_i (u_i^2 / (1 - h_ii)^2) x_i x_i'`` (matches ``sandwich::vcovHC``
       type="HC3": no DOF factor). One-way only; errors with ``cluster_ids``.
+      Same leverage-one fail-closed contract as ``hc2``.
     - ``"hc2_bm"``: one-way HC2 meat plus Imbens-Kolesar (2016) Bell-McCaffrey
       Satterthwaite degrees of freedom per coefficient when ``cluster_ids`` is
-      ``None``. When ``cluster_ids`` is supplied, dispatches to the
+      ``None``; unweighted, this shares the ``hc2`` leverage-one fail-closed
+      contract (a documented deviation from R ``clubSandwich``, whose
+      singleton-cluster CR2 generalized inverse returns a finite variance
+      there). With ``weights`` (pweight) it routes through the clubSandwich
+      WLS-CR2 port and keeps that finite generalized-inverse result at
+      leverage one — so ``hc2_bm`` and ``hc2_bm + weights=ones`` differ on
+      such designs. When ``cluster_ids`` is supplied, dispatches to the
       Pustejovsky-Tipton (2018) CR2 Bell-McCaffrey cluster-robust estimator
       (matches R ``clubSandwich::vcovCR(..., type="CR2")``). Required by the
       Pierce-Schott (2016) TWFE application in de Chaisemartin et al. (2026)
@@ -2270,7 +2287,11 @@ def compute_robust_vcov(
     For HC2 one-way (weighted per review MEDIUM #3):
         h_ii = w_i * x_i' * (X'WX)^{-1} * x_i  (unweighted: w_i = 1)
         meat = sum_i (u_i^2 / (1 - h_ii)) x_i x_i'
-        Guards against h_ii > 1 - eps with a fall-back to HC1 plus warning.
+        Fails closed (warning + all-NaN vcov/DOF) when any positive-weight
+        row has h_ii >= 1 - 1e-8 (leverage one; the meat term is 0/0), the
+        same contract as hc3 and R sandwich::vcovHC. No floor, no HC1
+        fallback. Under fweight, zero-count rows are excluded from the
+        guard and the meat (replicated-data no-ops).
 
     For HC2 + Bell-McCaffrey one-way DOF (per Imbens-Kolesar 2016):
         For each coefficient j, let q_j = X (X'X)^{-1} e_j, let M = I - H.
@@ -2286,11 +2307,15 @@ def compute_robust_vcov(
         weights = _validate_weights(weights, weight_type, X.shape[0])
 
     # Rust HC2 (one-way, unweighted, no DOF): mirrors the NumPy hc2 branch
-    # exactly (leverage meat, no n/(n-k) factor). The near-singular
-    # hat-diagonal guard stays Python-side: the kernel returns a sentinel
-    # error and the documented warn-and-fall-back-to-HC1 fires here,
-    # identical to the NumPy branch's behavior. Imported independently
-    # (mixed-version safe) — None on a stale extension.
+    # exactly (leverage meat, no n/(n-k) factor, no floor). The leverage-one
+    # guard decision stays Python-side: the kernel only signals with a
+    # sentinel error, and the dispatcher re-dispatches to the NumPy branch,
+    # which recomputes the hat diagonals and fails closed (NaN vcov + the
+    # single user-facing warning, same stacklevel as the direct path).
+    # Imported independently (mixed-version safe) — None on a stale
+    # extension; a present-but-stale kernel still raises the legacy
+    # over-one sentinel, which takes the same re-dispatch (it cannot signal
+    # h == 1 exactly, so rebuild after changing the kernel).
     if (
         HAS_RUST_BACKEND
         and _rust_compute_robust_vcov_hc2 is not None
@@ -2305,19 +2330,21 @@ def compute_robust_vcov(
             return _rust_compute_robust_vcov_hc2(X_c, residuals_c)
         except ValueError as e:
             error_msg = str(e)
-            if "Hat-matrix diagonal exceeds 1" in error_msg:
-                warnings.warn(
-                    f"{error_msg} Falling back to HC1.",
-                    UserWarning,
-                    stacklevel=2,
-                )
+            if (
+                "Hat-matrix leverage ~1" in error_msg
+                or "Hat-matrix diagonal exceeds 1" in error_msg
+            ):
+                # Leverage-one sentinel (current kernel) or the legacy
+                # over-one sentinel (stale kernel): re-dispatch to the NumPy
+                # hc2 branch, whose family-wide guard emits the warning and
+                # returns the all-NaN vcov. No HC1 fallback (retired).
                 return _compute_robust_vcov_numpy(
                     X,
                     residuals,
                     cluster_ids=None,
                     weights=None,
                     weight_type=weight_type,
-                    vcov_type="hc1",
+                    vcov_type="hc2",
                     return_dof=return_dof,
                 )
             if "Matrix inversion failed" in error_msg:
@@ -2436,8 +2463,9 @@ def _compute_hat_diagonals(
     ``sandwich::vcovHC(..., type="HC2")`` in R and matches the per-observation
     effective leverage under WLS.
 
-    Returns an ``(n,)`` array. Values are clamped to ``[0, 1 - 1e-10]`` to
-    guard against numerical `` h_ii > 1`` from near-singular designs.
+    Returns an ``(n,)`` array. Values are NOT clamped: a diagonal at or
+    above ``1 - 1e-8`` is the leverage-one condition the callers fail closed
+    on (see :func:`compute_robust_vcov`).
     """
     # Compute x_i' (X'WX)^{-1} x_i via a single solve rather than per-row.
     # np.linalg.solve(bread, X.T) has shape (k, n); multiplying element-wise by
@@ -2455,8 +2483,8 @@ def _compute_hat_diagonals(
     h_diag = np.einsum("ij,ji->i", X, proj)
     if weights is not None:
         h_diag = weights * h_diag
-    # Numerical guard. Do not silently clip values materially exceeding 1 — that
-    # indicates a real design pathology; the caller warns and falls back.
+    # No clipping: a value at or above 1 - 1e-8 is a real design pathology
+    # (a perfectly fitted row); the callers warn and fail closed.
     return np.asarray(h_diag, dtype=np.float64)
 
 
@@ -3316,9 +3344,11 @@ def _compute_bm_dof_from_contrasts(
 
     Returns
     -------
-    ndarray of shape (m,) of Satterthwaite DOF per contrast column. NaN when
-    the denominator is non-positive or at/below the cancellation noise
-    floor (degenerate / extreme-leverage case; see the inline guard note).
+    ndarray of shape (m,) of Satterthwaite DOF per contrast column. All NaN
+    when any row has hat-matrix leverage ``>= 1 - 1e-8`` (the one-way HC2
+    vcov is undefined there, so its DOF is too); otherwise NaN per contrast
+    when the denominator is non-positive or at/below the cancellation noise
+    floor (extreme-but-defined leverage; see the inline guard note).
     """
     n, k = X.shape
     if contrasts.ndim != 2 or contrasts.shape[0] != k:
@@ -3350,7 +3380,16 @@ def _compute_bm_dof_from_contrasts(
         raise
     # q has shape (n, m); column j is X @ (bread_inv @ contrasts[:, j]).
     q = X @ bread_inv_c
-    one_minus_h = np.maximum(1.0 - h_diag, 1e-10)
+    # Leverage one (h_ii >= 1 - 1e-8): the one-way HC2 vcov is undefined on
+    # every path that reaches this helper (the shared kernel fails closed
+    # before calling it; the MultiPeriodDiD / TWFE pooled event-study caller
+    # receives the same all-NaN vcov from solve_ols), so the Satterthwaite
+    # DOF of that undefined variance is NaN for every contrast. The former
+    # max(1 - h, 1e-10) floor is gone; below leverage one the per-contrast
+    # noise-floor cancellation guard further down is unchanged.
+    if np.any(h_diag >= 1.0 - 1e-8):
+        return np.full(contrasts.shape[1], np.nan)
+    one_minus_h = 1.0 - h_diag
     one_minus_2h = 1.0 - 2.0 * h_diag
     m = contrasts.shape[1]
     dof = np.empty(m)
@@ -3388,6 +3427,42 @@ def _compute_bm_dof_from_contrasts(
     return dof
 
 
+_LEVERAGE_ONE_LABELS = {"hc2": "HC2", "hc2_bm": "HC2-BM", "hc3": "HC3"}
+
+
+def _leverage_one_message(label: str, lev_rows: np.ndarray) -> str:
+    """User-facing text for the leverage-one fail-closed warning.
+
+    ``lev_rows`` is the FULL index array of offending (positive-weight) rows;
+    the message states the total count and previews the first five. The
+    ``"<label> variance is undefined"`` prefix is a pinned contract (tests
+    match on it). The remedy names classical exact inference only: HC1/CR1
+    also omit a zero-residual leverage-one row and would hand back the
+    understated variance this guard suppresses under another label.
+    """
+    n_lev1 = int(lev_rows.size)
+    preview = ", ".join(str(int(i)) for i in lev_rows[:5])
+    if n_lev1 > 5:
+        preview += ", ..."
+    return (
+        f"{label} variance is undefined: {n_lev1} observation(s) have "
+        f"hat-matrix leverage ~1 (a perfectly fitted row, e.g. a single "
+        f"treated unit or a singleton cohort x period cell; rows [{preview}]). "
+        f"Returning NaN vcov; point estimates are unaffected. Use "
+        f"vcov_type='classical' (exact inference under homoskedastic normal "
+        f"errors) or add observations to the perfectly-fitted cell."
+    )
+
+
+def _nan_vcov_and_dof(k: int, return_dof: bool) -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray]]:
+    """All-NaN ``(k, k)`` vcov, plus an all-NaN length-``k`` DOF vector when
+    ``return_dof`` (the fail-closed return shape of :func:`compute_robust_vcov`)."""
+    nan_vcov = np.full((k, k), np.nan)
+    if return_dof:
+        return nan_vcov, np.full(k, np.nan, dtype=np.float64)
+    return nan_vcov
+
+
 def _compute_bm_dof_oneway(
     X: np.ndarray,
     bread_matrix: np.ndarray,
@@ -3576,7 +3651,12 @@ def _compute_robust_vcov_numpy(
         # because S_W = sum_j w_j² X_j X_j' ≠ X'WX. To match
         # `clubSandwich::vcovCR(cluster=1:n, type="CR2")`, route weighted
         # hc2_bm through the singleton-cluster CR2 path so vcov and DOF are
-        # consistent (both use the clubSandwich algebra).
+        # consistent (both use the clubSandwich algebra). Deliberately NOT
+        # subject to the leverage-one fail-closed guard below: clubSandwich's
+        # generalized inverse returns a finite (understated) variance at a
+        # leverage-one row, and the maintainer decision (2026-09) scopes
+        # fail-closed to hc2 and UNWEIGHTED, unclustered hc2_bm — so hc2_bm
+        # and hc2_bm + weights=ones differ at leverage one (REGISTRY Note).
         if vcov_type == "hc2_bm" and weights is not None:
             # Same `weight_type` gating as the cluster-CR2 branch above:
             # only pweight matches clubSandwich's WLS-CR2 algebra.
@@ -3607,60 +3687,56 @@ def _compute_robust_vcov_numpy(
             bread_matrix,
             weights=None if weight_type == "fweight" else weights,
         )
-        # Leverage-one observations make the HC3 leave-one-out residual
-        # undefined (and HC2 nearly so): flooring 1 - h_ii would fabricate
-        # an arbitrary finite variance for a perfectly-leveraged point
-        # (e.g. a single treated unit under [1, D]). HC3 fails closed with
-        # a NaN vcov instead (LWDiD fix-wave review finding); HC2/HC2-BM
-        # keep their long-standing floor behavior (released surface;
-        # pre-existing, tracked separately). This check runs BEFORE the
-        # generic over-one HC1 fallback below (round-10 review: numerically
-        # over-one leverage previously escaped into an HC1 result still
-        # labeled hc3 - h >= 1 - 1e-8 covers h > 1 + 1e-6 entirely).
-        if vcov_type == "hc3" and np.any(h_diag >= 1.0 - 1e-8):
-            n_lev1 = int(np.sum(h_diag >= 1.0 - 1e-8))
-            warnings.warn(
-                f"HC3 variance is undefined: {n_lev1} observation(s) have "
-                f"hat-matrix leverage ~1 (a perfectly-leveraged design, "
-                f"e.g. a single treated unit). Returning NaN vcov; use "
-                f"vcov_type='classical' exact inference or add treated "
-                f"units.",
-                UserWarning,
-                stacklevel=3,
-            )
-            nan_vcov = np.full((X.shape[1], X.shape[1]), np.nan)
-            if return_dof:
-                # Contract: a length-k DOF vector (round-24 review: None
-                # broke direct consumers indexing the result); NaN keeps
-                # the fail-closed semantics through safe_inference.
-                return nan_vcov, np.full(X.shape[1], np.nan)
-            return nan_vcov
-        if np.any(h_diag > 1.0 + 1e-6):
-            # hc2/hc2_bm only: hc3 designs with over-one leverage are
-            # already caught by the fail-closed guard above.
+        # Leverage-one guard (family-wide: HC2, HC2-BM one-way, HC3). A
+        # perfectly fitted row (e.g. the single treated unit under [1, D], a
+        # singleton cohort x period cell in a full-dummy design) has h_ii = 1
+        # and residual exactly 0, so the leverage-corrected meat term
+        # u_i^2 / (1 - h_ii) is 0/0. The pre-2026-09 floor
+        # max(1 - h, 1e-10) did not inflate that term: it silently DROPPED
+        # the row's outcome noise and reported an understated finite
+        # variance (probe [1, D], n=6: hc2 SE 0.19 vs the exact classical
+        # 0.47), and hc2_bm additionally reported a NaN Satterthwaite DOF
+        # next to that finite SE. Maintainer decision (2026-09): fail closed
+        # with an all-NaN vcov (+ all-NaN DOF vector) and a warning, matching
+        # R sandwich::vcovHC (NaN at hat values ~1) and the released hc3
+        # contract; point estimates are computed upstream and unaffected.
+        #
+        # The check covers h > 1 + 1e-6 entirely, so the former over-one
+        # "fall back to HC1" branch is retired (round-10 review ordering,
+        # now family-wide). Under fweight the leverage is the unweighted
+        # quadratic form against the weighted bread, so a ZERO-count row's
+        # leverage is unbounded and meaningless: such rows are replicated-
+        # data no-ops, excluded from the guard here and from the meat below
+        # (compressed HC2/HC3 stay equal to the literal np.repeat expansion
+        # at any leverage). See docs/methodology/REGISTRY.md ("IF-based
+        # variance estimators vs analytical-sandwich estimators").
+        lev_mask = h_diag >= 1.0 - 1e-8
+        if weights is not None and weight_type == "fweight":
+            lev_mask &= weights > 0
+        if np.any(lev_mask):
             warnings.warn(
-                f"Hat-matrix diagonal exceeds 1 (max={h_diag.max():.6f}); "
-                "the design is near-singular. Falling back to HC1.",
+                _leverage_one_message(_LEVERAGE_ONE_LABELS[vcov_type], np.flatnonzero(lev_mask)),
                 UserWarning,
                 stacklevel=3,
             )
-            return _compute_robust_vcov_numpy(
-                X,
-                residuals,
-                cluster_ids=None,
-                weights=weights,
-                weight_type=weight_type,
-                vcov_type="hc1",
-                return_dof=return_dof,
-            )
-        one_minus_h = np.maximum(1.0 - h_diag, 1e-10)
+            # Contract: a length-k DOF vector (round-24 review: None broke
+            # direct consumers indexing the result); NaN keeps the
+            # fail-closed semantics through safe_inference.
+            return _nan_vcov_and_dof(k, return_dof)
+        # Every positive-weight row now has 1 - h > 1e-8: no floor needed.
+        one_minus_h = 1.0 - h_diag
         # HC2 meat: sum_i (u_i^2 / (1 - h_ii)) x_i x_i'; HC3 squares the
         # leverage denominator (jackknife-style, sandwich::vcovHC type="HC3").
         # pweight scaling matches the HC1 convention (w_i * u_i / sqrt(denom)
         # as score).
         lev_denom = one_minus_h**2 if vcov_type == "hc3" else one_minus_h
         if weights is not None and weight_type == "fweight":
-            factor = weights * (residuals**2) / lev_denom
+            # Zero-count rows contribute nothing (replicated data with count
+            # 0) and may carry 1 - h <= 0: build the factor on positive
+            # counts only so no 0/0 or negative denominator is evaluated.
+            factor = np.zeros(n, dtype=np.float64)
+            pos = weights > 0
+            factor[pos] = weights[pos] * (residuals[pos] ** 2) / lev_denom[pos]
             meat = X.T @ (X * factor[:, np.newaxis])
         elif weights is not None and weight_type == "pweight":
             # pweight scores carry w in the score, so meat = sum (w u / sqrt(denom))^2 x x'
diff --git a/diff_diff/lwdid.py b/diff_diff/lwdid.py
index 1e8168104..f3ec85830 100644
--- a/diff_diff/lwdid.py
+++ b/diff_diff/lwdid.py
@@ -3129,25 +3129,13 @@ def _estimate_reg(
         used_scales[used_scales == 0] = 1.0
         X_scaled = X_used / used_scales
         xtx_inv = np.linalg.pinv(X_scaled.T @ X_scaled) / np.outer(used_scales, used_scales)
-        if self.vcov_type == "hc2" and cluster_ids is None:
-            # Round-21 review: the shared hc2 kernel keeps its RELEASED
-            # 1 - h floor (tracked separately), but the NEW LWDiD surface
-            # must not report a fabricated finite variance for a
-            # perfectly-leveraged design - fail closed HERE, mirroring
-            # hc3 (point retained, inference NaN).
-            leverage_used = np.sum((X_used @ xtx_inv) * X_used, axis=1)
-            if np.any(leverage_used >= 1.0 - 1e-8):
-                n_lev1 = int(np.sum(leverage_used >= 1.0 - 1e-8))
-                warnings.warn(
-                    f"HC2 variance is undefined for this design: {n_lev1} "
-                    f"observation(s) have hat-matrix leverage ~1 (e.g. a "
-                    f"single treated unit). Returning NaN inference (point "
-                    f"retained); use vcov_type='classical' exact inference "
-                    f"or add treated units.",
-                    UserWarning,
-                    stacklevel=2,
-                )
-                se = np.nan
+        # Leverage-one designs under hc2: the shared linalg kernel now fails
+        # closed (2026-09, family-wide with hc3) - solve_ols above returned an
+        # all-NaN vcov and emitted the single "HC2 variance is undefined"
+        # warning, so `se` is already NaN via the finiteness check. The
+        # round-21 local guard that duplicated this (and its second warning)
+        # is retired; the influence-vector guard in
+        # `_ols_treatment_influence` still NaNs psi under the same condition.
         influence = self._finalize_influence(
             self._ols_treatment_influence(
                 X_used,
diff --git a/diff_diff/sun_abraham.py b/diff_diff/sun_abraham.py
index b91570afd..bbee7f67d 100644
--- a/diff_diff/sun_abraham.py
+++ b/diff_diff/sun_abraham.py
@@ -580,7 +580,10 @@ class SunAbraham(BaseEstimator):
         - ``"hc2"``: Eicker-Huber-White HC2 leverage correction. One-way
           only; the linalg validator rejects combining ``hc2`` with
           clusters. The unit auto-cluster is dropped when ``hc2`` is
-          explicitly opted into.
+          explicitly opted into. A leverage-one row in the full-dummy
+          design (e.g. a singleton cohort x event-time cell) has no
+          defined HC2 variance: the whole vcov fails closed (warning +
+          NaN inference on every effect, point estimates preserved).
         - ``"hc2_bm"``: HC2 + Bell-McCaffrey CR2 Satterthwaite DOF for
           cluster-robust inference. Routes to CR2-BM at the cluster
           level; preserves the auto-cluster default.
diff --git a/diff_diff/twfe.py b/diff_diff/twfe.py
index 39891450b..7729f6565 100644
--- a/diff_diff/twfe.py
+++ b/diff_diff/twfe.py
@@ -127,7 +127,12 @@ class TwoWayFixedEffects(DifferenceInDifferences):
     ATT coefficient, its SE, and analytical inference are unchanged.
     Auto-cluster-at-unit is preserved on ``hc2_bm`` (routes to CR2-BM at
     unit) and on ``hc2``/``hc3`` + ``wild_bootstrap``; dropped on explicit
-    ``hc2``/``hc3`` + ``analytical`` to match the one-way contract. **This wording applies
+    ``hc2``/``hc3`` + ``analytical`` to match the one-way contract. On the
+    one-way paths — explicit ``hc2``/``hc3``, and ``hc2_bm`` in event-study
+    ``spec="pooled"`` with no ``unit=`` (no auto-cluster to fall back to) —
+    a leverage-one observation (a perfectly fitted cell, e.g. a single
+    treated unit) has no defined HC2/HC3 variance and the fit fails closed
+    (warning + NaN inference, point estimates preserved). **This wording applies
     to the non-survey analytical path**: under ``survey_design=`` with no
     explicit ``cluster=``, TWFE intentionally keeps the documented
     implicit-PSU path (auto-cluster is NOT injected into the survey PSU
diff --git a/diff_diff/wooldridge.py b/diff_diff/wooldridge.py
index fac91a168..fbcdfc666 100644
--- a/diff_diff/wooldridge.py
+++ b/diff_diff/wooldridge.py
@@ -909,7 +909,10 @@ class WooldridgeDiD(BaseEstimator):
         ``clubSandwich::vcovCR(lm(...), type="CR2") + coef_test()$df_Satt``).
         ``classical`` / ``hc2`` are supported via the same full-dummy route AND
         an auto-drop of the unit auto-cluster (one-way families don't compose
-        with cluster_ids per the linalg validator). Explicit ``cluster="X"`` +
+        with cluster_ids per the linalg validator). Under one-way ``hc2`` a
+        leverage-one row (e.g. a singleton cohort x period cell) has no
+        defined HC2 variance: the whole vcov fails closed (warning + NaN
+        inference on every cell and aggregate, point estimates preserved). Explicit ``cluster="X"`` +
         one-way ``vcov_type`` raises at the validator. ``"conley"`` (Conley 1999
         spatial-HAC) threads the ``conley_*`` params through ``solve_ols`` on the
         within-transform design (``conley_lag_cutoff=0`` = within-period spatial only;
diff --git a/docs/api/lwdid.rst b/docs/api/lwdid.rst
index 248047d51..9198e659f 100644
--- a/docs/api/lwdid.rst
+++ b/docs/api/lwdid.rst
@@ -247,10 +247,11 @@ permutation encodes — complete randomization of the treatment labels
 authors' package convention (inclusive Phipson-Smyth counting; see the
 methodology registry's RI Note).
 
-**HC3 caveat** — HC3 requires the leverage of every observation to be
-bounded away from one; a perfectly-leveraged design (e.g. a single
-treated unit) has no defined HC3 variance and fails closed with a
-warning and NaN inference. Use classical exact inference there.
+**HC2 / HC3 caveat** — HC2 and HC3 require the leverage of every
+observation to be bounded away from one; a perfectly-leveraged design
+(e.g. a single treated unit) has no defined HC2 or HC3 variance and fails
+closed with a warning and NaN inference (the point estimate is preserved).
+Use classical exact inference there.
 
 **PSM inference** — ``estimation_method='psm'`` reports the matched ATT
 point estimate with NaN inference: no valid matching variance estimator
diff --git a/docs/methodology/REGISTRY.md b/docs/methodology/REGISTRY.md
index e19c8601c..0ff8db625 100644
--- a/docs/methodology/REGISTRY.md
+++ b/docs/methodology/REGISTRY.md
@@ -298,7 +298,7 @@ where V is the VCV sub-matrix for post-treatment δ_e coefficients.
   `_compute_cr2_bm_contrast_dof` (DOF-only for arbitrary contrasts) are thin wrappers
   over that shared core, so every CR2 caller routes through one implementation. The
   consolidation is bit-identical to the prior two-call path (proven at atol=0).
-- **Note (unweighted per-coef DOF guard):** the unweighted clustered CR2-BM per-coefficient DOF (`_cr2_bm_dof_inner`, the simple `(tr B)²/tr(B²)` form) carries the same two-part reliability guard as the weighted P-array path. (1) **Noise floor:** for a high-leverage FE-dummy / collinear nuisance column `trace_B2 = Σ B_{g,h}²` collapses to float64 accumulation noise while `trace_B` stays O(1), inflating the ratio to a non-physical DOF (observed ~1e61 on the absorbed-FE golden); a contrast whose `max|B_{g,h}|` sits below the batch-relative (`1e-10×max`, computed on the scale-normalized `max|B|/‖c‖²` since `B ∝ ‖c‖²` while the DOF is scale-invariant) or absolute (`(EPS·n·k·bread_scale)²`) floor is NaN'd. (2) **Cluster-count bound:** the Bell-McCaffrey Satterthwaite DOF is `(tr B)²/tr(B²)` with `B` PSD and cluster-structured, so it is bounded by `rank(B) ≤ G` (number of clusters); the simple unweighted form is numerically less faithful than clubSandwich's P-array form on high-leverage columns and can return a finite-but-inflated DOF above `G` (observed ~32.7 and ~16.3 vs R's 6 and 3, `G=8`), which is NaN'd as non-physical. The well-conditioned contrasts estimators consume — the treatment effect, event-study coefficients, and the compound post-period-average — are unaffected and match R clubSandwich; only the non-user-facing high-leverage nuisance DOFs are suppressed (exact P-array reproduction of those is deferred). A `UserWarning` fires per fit. Regression: `tests/test_estimators_vcov_type.py::TestDiDAbsorbedFERParity::test_unweighted_cr2_bm_per_coef_dof_no_nonphysical`. **Evaluation (2026-07):** the pairwise `B` matrix is computed via the algebraic identity `B = Ω'MΩ = diag(‖ω_g‖²) − P' M_U P` with `P = X'Ω` (the Satterthwaite DOF itself is Pustejovsky-Tipton 2018 §3.1 Eq. 11; equivalently the `q=1` reduction of the AHT Eq. 13) — instead of contracting against an explicit dense `n×n` residual-maker (`O(n k + G² k)` per contrast; peak memory = two `O(n k)` input-scale score precomputes plus working buffers capped by a byte cap subject to a one-contrast lower bound (a single contrast intrinsically needs `O(n)` + `O(G k)` buffers) — q vectors, per-cluster omegas, and product buffers contrast-chunked with every width-scaled buffer counted in the chunk denominator, and the `(G, G)` pairwise matrix row-chunked (Frobenius sum and max are row-separable), so none of the `n×n` residual-maker, `O(n m)` score arrays, or `O(G²)` pairwise entries is ever held at once; chunk-count invariant to ~1 ULP — BLAS width-dependent column accumulation; algebraically identical, ~1e-12 float agreement locked by a frozen-oracle parity test). **One-way scores evaluation (2026-07):** the non-clustered unweighted BM DOF denominator `a'(M∘M)a` (`_compute_bm_dof_from_contrasts`) is likewise evaluated without the dense `n×n` residual-maker, via the Schur-product expansion `Σ a_i²(1−2h_ii) + tr((B S_a)²)` with `S_a = X'diag(a)X` — exact algebra, `O(n k² + k³)` per contrast (was `O(n²k)`), frozen-dense-oracle parity ~1e-12, with a noise-floor cancellation guard NaN-ing extreme-leverage contrasts whose expanded denominator collapses below float precision (`TestOneWayBMScoresDOF`). **Low-rank A_g factorization (2026-07):** the unweighted per-cluster adjustment operator `A_g = (I − H_gg)^{−1/2}` is evaluated from the k×k eigenproblem of `U_g'U_g` (`U_g = X_g M_U^{1/2}`; `A_g = I + (U_g Q) diag(γ) (U_g Q)'`, `γ = ((1−λ)^{−1/2}−1)/λ` via expm1/log1p, Moore-Penrose zeroing at `1−λ ≤ 1e-10` matching `_cr2_adjustment_matrix`'s convention) and only ever applied to skinny matrices — the dense `(n_g, n_g)` `A_g` (an `O(n_g³)` eigh per cluster) is never materialized for `n_g > k`; clusters with `n_g ≤ k` keep the (tiny) dense construction since it is the smaller Gram side. Algebraically identical; vcov/DOF match a frozen dense-eigh oracle at rtol 1e-12/1e-10 incl. the leverage-1 absorbed-cluster-FE and singleton-cluster regimes (`TestCR2BMLowRankAdjustment`). The weighted clubSandwich path keeps the dense construction (its `G_g` carries the `S_W` bias term).
+- **Note (unweighted per-coef DOF guard):** the unweighted clustered CR2-BM per-coefficient DOF (`_cr2_bm_dof_inner`, the simple `(tr B)²/tr(B²)` form) carries the same two-part reliability guard as the weighted P-array path. (1) **Noise floor:** for a high-leverage FE-dummy / collinear nuisance column `trace_B2 = Σ B_{g,h}²` collapses to float64 accumulation noise while `trace_B` stays O(1), inflating the ratio to a non-physical DOF (observed ~1e61 on the absorbed-FE golden); a contrast whose `max|B_{g,h}|` sits below the batch-relative (`1e-10×max`, computed on the scale-normalized `max|B|/‖c‖²` since `B ∝ ‖c‖²` while the DOF is scale-invariant) or absolute (`(EPS·n·k·bread_scale)²`) floor is NaN'd. (2) **Cluster-count bound:** the Bell-McCaffrey Satterthwaite DOF is `(tr B)²/tr(B²)` with `B` PSD and cluster-structured, so it is bounded by `rank(B) ≤ G` (number of clusters); the simple unweighted form is numerically less faithful than clubSandwich's P-array form on high-leverage columns and can return a finite-but-inflated DOF above `G` (observed ~32.7 and ~16.3 vs R's 6 and 3, `G=8`), which is NaN'd as non-physical. The well-conditioned contrasts estimators consume — the treatment effect, event-study coefficients, and the compound post-period-average — are unaffected and match R clubSandwich; only the non-user-facing high-leverage nuisance DOFs are suppressed (exact P-array reproduction of those is deferred). A `UserWarning` fires per fit. Regression: `tests/test_estimators_vcov_type.py::TestDiDAbsorbedFERParity::test_unweighted_cr2_bm_per_coef_dof_no_nonphysical`. **Evaluation (2026-07):** the pairwise `B` matrix is computed via the algebraic identity `B = Ω'MΩ = diag(‖ω_g‖²) − P' M_U P` with `P = X'Ω` (the Satterthwaite DOF itself is Pustejovsky-Tipton 2018 §3.1 Eq. 11; equivalently the `q=1` reduction of the AHT Eq. 13) — instead of contracting against an explicit dense `n×n` residual-maker (`O(n k + G² k)` per contrast; peak memory = two `O(n k)` input-scale score precomputes plus working buffers capped by a byte cap subject to a one-contrast lower bound (a single contrast intrinsically needs `O(n)` + `O(G k)` buffers) — q vectors, per-cluster omegas, and product buffers contrast-chunked with every width-scaled buffer counted in the chunk denominator, and the `(G, G)` pairwise matrix row-chunked (Frobenius sum and max are row-separable), so none of the `n×n` residual-maker, `O(n m)` score arrays, or `O(G²)` pairwise entries is ever held at once; chunk-count invariant to ~1 ULP — BLAS width-dependent column accumulation; algebraically identical, ~1e-12 float agreement locked by a frozen-oracle parity test). **One-way scores evaluation (2026-07):** the non-clustered unweighted BM DOF denominator `a'(M∘M)a` (`_compute_bm_dof_from_contrasts`) is likewise evaluated without the dense `n×n` residual-maker, via the Schur-product expansion `Σ a_i²(1−2h_ii) + tr((B S_a)²)` with `S_a = X'diag(a)X` — exact algebra, `O(n k² + k³)` per contrast (was `O(n²k)`), frozen-dense-oracle parity ~1e-12, with a noise-floor cancellation guard NaN-ing extreme-but-defined-leverage contrasts whose expanded denominator collapses below float precision (`TestOneWayBMScoresDOF`); at leverage one (`h_ii >= 1 - 1e-8`, 2026-09) the helper returns an all-NaN DOF vector for every contrast — the one-way HC2 vcov it belongs to is undefined (see the leverage-one Note in "IF-based variance estimators vs analytical-sandwich estimators") — and its former `1 - h` floor is gone (`TestOneWayBMScoresDOF::test_leverage_one_nans_every_contrast`). **Low-rank A_g factorization (2026-07):** the unweighted per-cluster adjustment operator `A_g = (I − H_gg)^{−1/2}` is evaluated from the k×k eigenproblem of `U_g'U_g` (`U_g = X_g M_U^{1/2}`; `A_g = I + (U_g Q) diag(γ) (U_g Q)'`, `γ = ((1−λ)^{−1/2}−1)/λ` via expm1/log1p, Moore-Penrose zeroing at `1−λ ≤ 1e-10` matching `_cr2_adjustment_matrix`'s convention) and only ever applied to skinny matrices — the dense `(n_g, n_g)` `A_g` (an `O(n_g³)` eigh per cluster) is never materialized for `n_g > k`; clusters with `n_g ≤ k` keep the (tiny) dense construction since it is the smaller Gram side. Algebraically identical; vcov/DOF match a frozen dense-eigh oracle at rtol 1e-12/1e-10 incl. the leverage-1 absorbed-cluster-FE and singleton-cluster regimes (`TestCR2BMLowRankAdjustment`). The weighted clubSandwich path keeps the dense construction (its `G_g` carries the `S_W` bias term).
 - **Note:** `LinearRegression.get_se()` / `get_inference()` clamp the vcov diagonal at 0
   before `sqrt`. A high-leverage / degenerate coefficient (an absorbed-FE dummy
   near-collinear with the treatment, whose Satterthwaite DOF already hits the noise-floor
@@ -733,6 +733,10 @@ clusters, centers, and applies the standard `G/(G-1)` correction
 IF is Williams (2000) / Hansen (2007) in all four cases — no new
 methodology is introduced.
 
+- **Note (leverage-one fail-closed rule for the one-way leverage family, 2026-09):** the shared `diff_diff/linalg.py` one-way branch for `hc2` (every weight type), unweighted unclustered `hc2_bm`, and `hc3` FAILS CLOSED whenever any positive-weight observation has hat-matrix leverage `h_ii >= 1 - 1e-8`: `UserWarning` ("<HC2|HC2-BM|HC3> variance is undefined: N observation(s) have hat-matrix leverage ~1 ..."), all-NaN `(k, k)` vcov and all-NaN length-`k` DOF vector, point estimates untouched (coefficients are computed before the vcov step; `safe_inference` turns the NaN se into NaN t/p/CI). Rationale: a perfectly fitted row has residual exactly 0, so the leverage-corrected meat term `u_i^2/(1 - h_ii)` is 0/0; the pre-2026-09 floor `max(1 - h, 1e-10)` did not inflate it but silently DROPPED that row's outcome noise (probe `[1, D]`, n=6, one treated: hc2 SE 0.19 vs the exact classical 0.47) and `hc2_bm` paired the finite SE with a NaN Satterthwaite DOF. R `sandwich::vcovHC` returns NaN for HC2/HC3 at hat values ~1, so the rule is R parity for those two. The former over-one (`h > 1 + 1e-6`) warn-and-fall-back-to-HC1 branch is retired (it is inside the guard). Under `fweight` the leverage is the unweighted quadratic form against the weighted bread, so a ZERO-count row's leverage is unbounded and meaningless: zero-count rows are excluded from the guard and from the meat (compressed HC2/HC3 stay equal to the literal `np.repeat` expansion at any leverage; this also retires a pre-existing hc3 NaN on such rows). The one-way Bell-McCaffrey DOF helper (`_compute_bm_dof_from_contrasts`) drops its sibling floor and returns an all-NaN DOF vector at leverage one (the variance it belongs to is undefined); below leverage one its per-contrast noise-floor guard is unchanged. The Rust HC2 kernel mirrors the branch (no floor; it signals "Hat-matrix leverage ~1" and the dispatcher re-dispatches to the NumPy branch, which owns the single warning). Reachable from `DifferenceInDifferences`, `MultiPeriodDiD`, `LinearRegression` (both families), `TwoWayFixedEffects` (explicit `hc2`; `hc2_bm` in event-study `spec="pooled"` with no `unit=`), `SunAbraham` and `WooldridgeDiD` OLS (one-way `hc2`; e.g. a singleton cohort x period cell in the full-dummy design), and `LWDiD` reg (`hc2`, which already failed closed via a now-retired local guard). Remedy named by the warning: `vcov_type='classical'` (exact inference under homoskedastic normal errors — requires positive residual df, so a fully saturated design must instead add observations) or add observations to the perfectly-fitted cell. **`hc1`/CR1 are deliberately NOT offered as a remedy**: at a leverage-one row they also omit the zero-residual observation (R `sandwich` warns "HC1 covariances become (close to) singular if hat values are (close to) 1"; probe hc1 SE 0.210 vs exact 0.469) and remain finite only because the maintainer decision scopes fail-closed to hc2/hc2_bm. Pinned by `tests/test_linalg_hc2_bm.py::TestLeverageOneFailsClosed`, the estimator fixtures in `tests/test_estimators_vcov_type.py::TestLeverageOneEstimators`, and `tests/test_rust_backend.py::TestRustHC2Vcov`.
+- **Deviation from R:** `clubSandwich::vcovCR(cluster = 1:n, type = "CR2")` returns a FINITE variance at a leverage-one row (its Moore-Penrose generalized inverse of `I - H_ii` sets that row's adjustment to 0 — probe SE 0.1915 with Satterthwaite df 4, numerically the same understated value the retired floor produced); diff-diff fails closed for UNWEIGHTED, UNCLUSTERED one-way `hc2_bm` (maintainer decision, 2026-09).
+- **Note (weighted / clustered hc2_bm are unchanged):** weighted (pweight) one-way `hc2_bm` routes through the clubSandwich WLS-CR2 port and keeps its generalized-inverse result at leverage one — INCLUDING under a no-op all-ones weight vector, so `hc2_bm` and `hc2_bm + weights=np.ones(n)` DIFFER on such designs (NaN vs finite, understated). Clustered CR2 (`hc2_bm` + `cluster_ids`) keeps the Moore-Penrose absorbed-cluster-FE convention (Pustejovsky-Tipton 2018). Point estimates are never affected by any of these paths.
+
 ---
 
 ## Cross-fitting, DR-score, and ridge infrastructure (DML)
@@ -2739,11 +2743,11 @@ Event-study/placebo transformations over ALL periods (Appendix D): demeaning (D.
 - **Note (review round 4: rank-aware advanced inference + cell guards):** the randomization-inference and wild-cluster-bootstrap modules fit through the shared rank-aware `solve_ols` (the pre-fix `np.linalg.lstsq` returned a finite MINIMUM-NORM treatment coefficient when a control duplicated the treatment column — execution-verified: a true ATT of 2.0 reported as 0.877 with finite p-values in both modules); an unidentified observed treatment coefficient raises, and a permutation draw whose treatment coefficient is dropped counts as a failed replication. The standalone wild wrapper requires an integer `n_bootstrap >= 2` (one draw supports neither a dispersion estimate nor test inversion), `n_reps` must be a non-boolean positive integer, and `LWDiDResults.wild_cluster_bootstrap` inherits the fitted `alpha` (override by argument). Staggered cells under `control_group='never_treated'` are non-estimable when transformation/finite drops leave fewer than 2 never-treated controls (the Registry's NT-only minimum, previously checked only on raw units pre-fit). Staggered `reference_periods` emit only OBSERVED anchors — an anchor `r` appears iff some treated cohort g has calendar period `g + r` in the panel (previously a numeric time gap synthesized a zero-valued reference row at a nonexistent event time).
 - **Note (review round 5: post-fit inference replays the fitted estimand):** `LWDiDResults.wild_cluster_bootstrap()` and `.randomization_test()` REPLAY the fit-time collapsed cross-section and the exact RA design `[1, D, X, D(X - Xbar_1)]` — no data arguments are accepted, the RI permutations RECOMPUTE the treated covariate mean (and interaction columns) per assignment (`design='ra_interacted'` on the standalone function), and the replayed observed statistic is asserted equal to `.att` before any p-value is cached (fail-closed RuntimeError on mismatch). The pre-fix methods accepted arbitrary caller arrays and a non-interacted `[1, D, X]` design, caching p-values for a DIFFERENT estimand (execution-verified: fitted ATT 3.98 vs tested 3.26 on a covariate-unbalanced RA fit). Both methods are defined for common-timing `estimation_method='reg'` fits only (re-estimating ipw/dr/psm per draw is not implemented — informative rejection); the standalone module functions keep their generic array contracts. The common-timing bootstrap resamples from units SURVIVING the transformation/finite filters, treats a draw collapsing onto one distinct cluster as failed, and fails closed (point retained, NaN inference) when fewer than 2 effective clusters survive — a requested bootstrap no longer overwrites the single-effective-cluster fail-closed state (pre-fix: SE ~ 2e-16 from the raw cluster map). `aggregate(balance_e=)` is REJECTED: LWDiD stores no per-cohort estimation kit from which a balanced-cohort sample and covariance could be recomputed post fit (pre-fix the argument was accepted and silently ignored).
 - **Note (review round 6: fixed-window estimand, scale-equivariant guards, fweight leverage):** the common-timing headline ATT is the paper's FIXED-WINDOW post average (LW 2026, denominator `T - S + 1`): units lacking a finite transformed outcome in every post period are dropped as complete cases with a warning, on the point path and the bootstrap alike (pre-fix, each unit averaged whichever post periods it observed, so calendar composition could masquerade as treatment effect — execution class: zero-effect panel, treated units observing one extra post period reported that period's trend as the ATT). If the drops empty a treatment arm, fit raises informatively instead of dispatching a one-arm design. The degenerate-SE guard is SCALE-EQUIVARIANT (`se <= sqrt(eps) * |effect|`, plus non-positive/non-finite): the former `max(1, |effect|)` floor NaN'd valid inference when the outcome was rescaled by 1e-10 while the t-statistic is scale-invariant. Constructor numerics are strictly validated (`pscore_trim` real/non-bool/finite before conversion; `n_jobs` rejects booleans). `n_jobs` is deliberately EXCLUDED from result provenance: since the round-2 SeedSequence fix the seeded bootstrap draws are identical for every `n_jobs`, so it is pure execution configuration with no effect on any reported number. `df_inference` serializes in `to_dict()`.
-- **Note (round 6, shared linalg — fweight leverage for HC2/HC3):** under `weight_type='fweight'` the HC2/HC3 leverage denominator uses each replicate row's UNWEIGHTED quadratic form against the weighted bread, `h_i = x_i'(X'WX)^{-1}x_i` — frequency weights mean replicated data (integer counts, `df = sum(w) - k`, HC1 expansion parity), and this makes compressed HC2/HC3 exactly equal literal `np.repeat` expansion (oracle-pinned). The WLS-hat convention `h_i = w_i x_i'(X'WX)^{-1}x_i` (R `sandwich::vcovHC`) continues to apply to aweight/pweight. Pre-fix, the weighted hat under fweight produced HC2/HC3 variances up to ~5x the expansion (hc3 was introduced by this fix wave; hc2's fweight surface predates it and carried the same mismatch — both now expansion-exact, unpinned by any golden).
+- **Note (round 6, shared linalg — fweight leverage for HC2/HC3):** under `weight_type='fweight'` the HC2/HC3 leverage denominator uses each replicate row's UNWEIGHTED quadratic form against the weighted bread, `h_i = x_i'(X'WX)^{-1}x_i` — frequency weights mean replicated data (integer counts, `df = sum(w) - k`, HC1 expansion parity), and this makes compressed HC2/HC3 exactly equal literal `np.repeat` expansion (oracle-pinned). The WLS-hat convention `h_i = w_i x_i'(X'WX)^{-1}x_i` (R `sandwich::vcovHC`) continues to apply to aweight/pweight. Pre-fix, the weighted hat under fweight produced HC2/HC3 variances up to ~5x the expansion (hc3 was introduced by this fix wave; hc2's fweight surface predates it and carried the same mismatch — both now expansion-exact, unpinned by any golden). 2026-09: zero-count rows, whose unweighted-quadform leverage is unbounded and meaningless, are excluded from the leverage-one guard and from the meat, so the expansion identity holds at any leverage (previously an inert zero-count row at `h >= 1` could NaN hc3 or push hc2 into the since-retired HC1 fallback).
 - **Note (review round 7: replay follows the fitted design; sensitivity runs the design check):** the post-fit replay mirrors `_estimate_reg`'s LW eq. 3.3 interaction gate (`N_1 > K+1` AND `N_0 > K+1`): small-arm fits use the plain `(1, D, X)` design and their replayed RI/WCR statistic matches `.att` (pre-fix the replay always interacted, so the round-5 coherence assert made small-arm fits' post-fit inference unusable — the fail-closed backstop working as designed, now with the correct design selected). `_prevalidate_frame` in the sensitivity helpers runs the full treatment-design check (absorbing treatment, common-timing onset homogeneity, D_it/cohort consistency, with fit's encode-then-normalize ordering), so structural design violations RAISE instead of being swallowed by the per-spec ValueError handler as `not_estimable`.
 - **Note (review round 8: calendar partition from S, tau_omega window counts, aweight leverage-family convention):** the common-timing pre/post partition derives from the SINGLE adoption period `S = min(observed treated period)`: `pre = {t < S}`, `post = {t >= S}` (the pre-fix per-period `max(D)` partition classified a post period with no observed treated rows as PRE-treatment, contaminating the rolling pre window — execution-verified: zero-effect trend panel biased to ATT 0.75); the common-timing design check likewise validates `D_it = 1[t >= S]` over observed rows, so a unit whose `t = S` row is missing is accepted (matching the staggered branch) while genuinely heterogeneous onsets still raise. The `tau_omega` complete-case semantics are CLARIFIED, not changed (round-8 reviewer proposed full-window per-period counting; NOT adopted): a unit contributes cohort g's component iff its OBSERVED post-g rows yield a finite average — partial post windows are averaged over observed rows, symmetrically for treated and control units. This is the adjudicated WS1 design pinned byte-frozen by the acceptance suite's independent reference oracle (`_complete_case_tau_omega_reference`) and its zero-drop metadata test; changing to every-period counting would change the estimand those tests pin. CAVEAT (documented): on unbalanced panels with time trends, differential post-period availability enters the composite through the observed-window averages — complete-case drops fire only when a required window is entirely missing/non-finite. Covariates must be numeric and FINITE at the front door (Inf passed the NaN check and was silently cell-filtered); `validate_staggered_data` rejects datetime64-vs-Period mixtures and Period-frequency mismatches exactly like the encoding step. **aweight + hc2/hc3 refutation (round 8):** the reviewer's proposed `w^2` score meat contradicts the documented aweight convention (this section, Weight Type Effects: "aweights use unweighted meat ... matches Stata convention" — known-heteroskedasticity WLS leaves ~homoskedastic errors) — hc2's aweight surface is RELEASED behavior retained byte-identical from main, and hc3 follows the same family branch (unweighted meat with the WLS-hat leverage). The convention is deliberate and documented, not a defect.
 - **Note (review round 9: one event-time convention, onset partition propagated, finite outcomes):** event-time labels follow ONE convention across the common and staggered interfaces: NUMERIC calendars use the Registry's arithmetic `r = t - g` (validated INTEGRAL — a fractional horizon raises instead of silently merging under the integer storage keys, which previously overwrote distinct horizons' estimates and covariance entries via `int(t - g)`); datetime/Period calendars use position differences on the ordered support (they are position-encoded before the staggered machinery). Pre-fix, the common interface used positional labels for ALL dtypes, so a gapped numeric calendar got different event keys per interface ({0,1} vs {0,2} on {1,2,4,6} with onset 4). The round-8 onset partition (`pre = {t < S}`) is propagated to `get_transformation_diagnostics` and the sensitivity helpers' pre/post sets (a controls-only post period is post everywhere; sensitivity subsets retain every `t >= S` period). Outcomes must be numeric and FINITE at the front door in both timing modes (Inf previously passed the NaN check and was silently np.isfinite-filtered inside staggered cells, changing the estimation sample without warning).
-- **Note (review round 10: guard ordering + sensitivity coherence):** hc3's undefined-leverage fail-closed check runs BEFORE the generic over-one HC1 fallback (numerically over-one leverage previously escaped into an HC1 result still labeled hc3), and the LWDiD hc3 influence vector fails closed to NaN under the same condition instead of clipping (aggregate inference matches the cell's NaN vcov; the NaN influence drops the cell from joint aggregation). The sensitivity helpers count treated cohorts on the NORMALIZED frame (beyond-window/inf encodings no longer masquerade as extra cohorts), their BASELINE full-frame fit propagates every fit error (a configuration/support failure such as covariate-free PSM raises instead of reporting `not_estimable`; only restricted-subset fits map failures to NaN specs), and zero-post-row units are counted by the fixed-window drop warning (previously they vanished silently in the merge).
+- **Note (review round 10: guard ordering + sensitivity coherence):** hc3's undefined-leverage fail-closed check runs BEFORE the generic over-one HC1 fallback (numerically over-one leverage previously escaped into an HC1 result still labeled hc3) — since 2026-09 that fallback no longer exists and the leverage-one guard is family-wide (hc2 / unweighted-unclustered hc2_bm / hc3), and the LWDiD hc3 influence vector fails closed to NaN under the same condition instead of clipping (aggregate inference matches the cell's NaN vcov; the NaN influence drops the cell from joint aggregation). The sensitivity helpers count treated cohorts on the NORMALIZED frame (beyond-window/inf encodings no longer masquerade as extra cohorts), their BASELINE full-frame fit propagates every fit error (a configuration/support failure such as covariate-free PSM raises instead of reporting `not_estimable`; only restricted-subset fits map failures to NaN specs), and zero-post-row units are counted by the fixed-window drop warning (previously they vanished silently in the merge).
 - **Note (review round 11: propensity linearization, reduced-rank propensity fits, identified-rank gate):** the IPW/DR influence functions build the logit score and Hessian from the RAW fitted probabilities (the actual MLE's estimating equation — its score is ~0 at the fit; the pre-fix code used the CLIPPED probabilities, breaking the linearization whenever `pscore_trim` fired), and the weight-derivative `dw/dgamma` is ZERO for clipped observations (a clipped weight is locally constant in gamma); the clipped probabilities remain the WEIGHTING choice for the point estimator. A rank-deficient propensity model (NaN logit coefficients from dropped collinear columns, finite probabilities) CONTINUES as an IPW/DR fit on the reduced-rank propensity (score/Hessian on the kept columns) — the pre-fix code silently substituted regression adjustment under ipw/dr provenance; only a genuinely failed solve (non-finite probabilities) falls back, with its warning. The RA interaction gate (`N_1 > K+1` and `N_0 > K+1`, eq. 3.3) counts the IDENTIFIED control dimension (matrix rank), mirrored exactly by the post-fit replay — a perfectly collinear control previously flipped the gate and changed the ATT while adding no information. `validate_staggered_data` marks duplicate `(unit, time)` cells invalid (a duplicate could mask a missing cell in the row-count balance check). Tutorial 27 re-executed against the final code: the single-treated California HC3 example now TEACHES the leverage-one fail-closed boundary (classical exact-t / RI are the small-N tools), and the CS-efficiency comparison states the paper-faithful serial-correlation trade-off instead of a dominance claim.
 - **Note (review round 12: rank-aware DR nuisances, identified parameter counts, survivor cohort masses):** the DR outcome WLS fits through the shared rank-aware solver and every outcome-model influence term (prediction, `S_beta`, `H_beta`, `dATT/dbeta`) uses the IDENTIFIED column mask (the pre-fix raw `inv`/`pinv` Gram was not scale-equilibrated — an exactly redundant 1e12-rescaled duplicate changed the DR SE by ~2.5x); IPW/DR report the identified propensity/outcome ranks as `n_params` (nominal counts let a redundant control shrink residual df and move p-values/CIs). On the tau_omega DROPS route, `.att` and its combined influence function weight cohorts by the SURVIVING cohort masses returned by the composite helper (the Registry complete-case rule; raw masses previously kept dropped treated units in the weights) — pinned by an independent survivor-mass oracle.
 - **Note (review round 13: scale-equilibrated influence bread, effective-rank guard):** the RA influence reconstruction inverts the COLUMN-EQUILIBRATED Gram and unscales (`(X'X)^{-1} = D^{-1}(Xs'Xs)^{-1}D^{-1}`) — the pre-fix raw-Gram pinv silently dropped low-scale directions at large covariate units, so cell ATT/SE (from the equilibrated `solve_ols`) were unit-invariant while every AGGREGATE SE/p/CI and the multiplier-bootstrap inputs were not (execution class: rescaling one covariate by 1e7 moved the overall SE from 0.128 to 0.028 with no warning). Aggregate-inference unit-invariance is pinned across the overall and event-study surfaces. The exact-inference small-sample guard uses the EFFECTIVE (equilibrated) design rank, so a redundant-column design with positive effective residual df fits while a genuinely saturated design still raises. docs/index.rst and the practitioner tree scope the heterogeneous-trends claim to `rolling='detrend'` and describe PSM as point-estimation-only.
@@ -2755,7 +2759,7 @@ Event-study/placebo transformations over ALL periods (Appendix D): demeaning (D.
 - **Note (review round 18):** the common-timing time-scale contract (Period rejected for detrend/detrendq; trend/seasonal transforms require numeric/datetime/Period time) lives in one shared validator called by BOTH `fit()` and `get_transformation_diagnostics()` (diagnostics previously reached the transforms' raw float-conversion errors). `randomization_inference` validates array shapes/lengths BEFORE the non-finite-outcome filter (a mismatched length combined with a non-finite y previously raised a raw boolean-index IndexError). RI citations point at the LW 2026 small-sample paper (the 2025 Section-5 reference concerned detrending, not RI), and the api-docs no longer call RI "assumption-free" (it does not require normality, conditional on the complete-randomization assignment mechanism).
 - **Note (review round 19: family-consistent multiplier contributions — deliberate, externally validated):** the influence contributions feeding the event-study multiplier bootstrap are NORMALIZED TO THE REQUESTED ANALYTICAL VARIANCE FAMILY (classical: per-cell scalar rescale to the classical magnitude; hc1/CR1: the small-sample factor; hc2/hc3: leverage adjustment), not the raw Appendix E.2 contributions. Consequences: per-cell SCALAR adjustments (classical/hc1/CR1) leave the sup-t critical value INVARIANT (draws and SEs scale together and the normalized statistic cancels the factor) while the per-event bootstrap SEs report magnitudes consistent with the requested family rather than the raw asymptotic form — a deliberate coherence choice, so a fit's analytical and bootstrap surfaces answer in the same family. External validation: the RA/hc1 configuration's multiplier-bootstrap SEs are gated against the AUTHORS' Stata package's high-B multiplier bootstrap within the Monte-Carlo bound (acceptance suite, `test_walmart_eventstudy_se_vs_stata`). PSM continues under a rank-deficient (finite-probability) propensity fit exactly like ipw/dr — matching needs only the probabilities — with the regression-point fail-closed fallback reserved for genuinely non-finite propensity fits.
 - **Note (review round 20):** point-only PSM is EXEMPT from the common-timing exact-OLS residual-df guard (its inference is NaN by contract and `df_inference=None`; the guard previously rejected valid matching fits whose nominal propensity width exhausted an OLS df count PSM never uses — the staggered path already retained the point). `get_transformation_diagnostics` rejects an all-never-treated staggered panel ("No treated cohorts found", matching `fit_staggered`) instead of returning an empty `by_cohort` that read as success. Non-numeric, non-datetime common-timing time columns must be ORDERED CATEGORICALS (encoded to their codes before any comparison; plain object labels are rejected — lexicographic order breaks at 'Q10' < 'Q2', silently corrupting the pre/post partition), replacing the former plain-string demean acceptance; declared-order chronology pinned on a Q1..Q10 zero-effect trend panel.
-- **Note (review round 21):** the NEW LWDiD surface fails closed for `vcov_type='hc2'` at leverage-one designs (warning + NaN inference, point retained), mirroring hc3 — the SHARED hc2/hc2_bm kernel keeps its released `1 - h` floor for the pre-existing estimators pending the tracked family decision (TODO row), so the fabricated-variance path is unreachable from LWDiD while released surfaces are unchanged. The common-timing HEADLINE and unit-bootstrap SEs run through the same scale-equivariant degenerate-SE guard as the staggered/event surfaces (an exactly fitted panel previously reported se ~ 1e-16 with t ~ 1e16). LWDiD plots render the FITTED interval endpoints (per-row t/df, fitted alpha, cband when present; sensitivity specs now carry `conf_int`) instead of a fabricated normal-theory `+/-1.96*SE`; inference-unavailable rows keep the omit-interval rule. PSM docstrings describe 1:`n_neighbors` matching (1:1 default).
+- **Note (review round 21):** the NEW LWDiD surface fails closed for `vcov_type='hc2'` at leverage-one designs (warning + NaN inference, point retained), mirroring hc3 — at the time the SHARED hc2/hc2_bm kernel kept its released `1 - h` floor pending the tracked family decision; that decision landed 2026-09 (the shared kernel now fails closed family-wide, see the leverage-one Note in "IF-based variance estimators vs analytical-sandwich estimators") and LWDiD's duplicate local guard was retired, so a leverage-one LWDiD hc2 fit now emits the shared kernel's warning once per cell instead of two differently worded warnings. The common-timing HEADLINE and unit-bootstrap SEs run through the same scale-equivariant degenerate-SE guard as the staggered/event surfaces (an exactly fitted panel previously reported se ~ 1e-16 with t ~ 1e16). LWDiD plots render the FITTED interval endpoints (per-row t/df, fitted alpha, cband when present; sensitivity specs now carry `conf_int`) instead of a fabricated normal-theory `+/-1.96*SE`; inference-unavailable rows keep the omit-interval rule. PSM docstrings describe 1:`n_neighbors` matching (1:1 default).
 - **Note (review round 23):** staggered overall/cohort masses count treated units CONTRIBUTING to each cohort's estimable post cells on every route (a raw cohort member with no estimable cell no longer raises its cohort's weight in `.att`, its combined influence function, or `cohort_effects[g]['n_treated']` — previously only the tau_omega drops route recomputed masses); pinned by a contributing-unit oracle (4/5 vs the raw 4/8 weighting on a mostly-unobserved cohort). `plot_cohort_trends(cohort=)` is IMPLEMENTED (one trajectory per treated cohort, never-treated control line, per-cohort onset markers — previously the parameter was accepted and silently ignored). `validate_staggered_data` marks missing unit/time values as ERRORS (fit rejects the same frame; warning-only let `valid: True` disagree with fit). Input-contract docs state the unit-constant covariate/cluster rule applies to BOTH timing paths and add `_lwdid_season` to the reserved-name list.
 - **Note (review round 24, final):** verdict "Looks good — no unmitigated P0 or P1 findings"; the three P2 nits are resolved: `randomization_inference` requires `n_reps >= 10` up front (the reliable-inference floor made smaller values fail after the permutation loop with a misleading hint); the HC3 leverage-one fail-closed path honors the `return_dof` contract with a length-k NaN vector (was `None`); datetime cohort positions relabel to the CANONICAL observed period (two raw between-period labels mapping to the same onset previously collided with row-order-dependent survivor).
 - **Note (round-2 refutations, evidence-anchored):** two reviewer claims were checked and REFUTED by execution: (1) pre-treatment placebo transformations — the implementation applies one per-cohort transformation over the full `t < g` pre window with anchor exclusions and the D.3 placebo control pools, and matches the authors' Stata `lwdid` 2.4.2 at full precision (~1e-9) on every Walmart placebo cell `r in [-22, -3]` (the fail-closed label-set gate pins the surface), so the horizon-specific future-window reading is not what the reference implementation does; (2) the IPW influence function's `p_bar = n_1/n` normalization (Lunceford-Davidian linearization of the Hajek ATT) was compared against the proposed finite-sample `B_hat = sum_ctrl(w)/n` variant by Monte Carlo (400 reps, strong propensity heterogeneity): the variants are first-order equivalent and `B_hat` calibrated no better (SE/SD 0.865 vs 0.873), so the implemented convention stands.
diff --git a/docs/methodology/variance-conventions.md b/docs/methodology/variance-conventions.md
index ee99a8c92..6ff0a7692 100644
--- a/docs/methodology/variance-conventions.md
+++ b/docs/methodology/variance-conventions.md
@@ -142,7 +142,7 @@ output).
   since the M-021 migration — and carries the K_reference increment there
   (+6, the [time, unit] no-intercept
   increment on df_0 — pinned via expected_adjustment on its matrix row).
-- **L4 — hc2/hc2_bm/hc3** (leverage / Satterthwaite DOF — no CR1 factor; hc3 squares the leverage denominator and is one-way only; under `fweight` the leverage is each replicate row's UNWEIGHTED quadratic form against the weighted bread — frequency weights are replicated data, and compressed HC2/HC3 equal literal expansion exactly — while aweight/pweight keep the WLS-hat `w_i x_i'(X'WX)^{-1}x_i` convention),
+- **L4 — hc2/hc2_bm/hc3** (leverage / Satterthwaite DOF — no CR1 factor; hc3 squares the leverage denominator and is one-way only; under `fweight` the leverage is each replicate row's UNWEIGHTED quadratic form against the weighted bread — frequency weights are replicated data, and compressed HC2/HC3 equal literal expansion exactly, and zero-count rows are excluded from both the leverage-one guard and the meat — while aweight/pweight keep the WLS-hat `w_i x_i'(X'WX)^{-1}x_i` convention; family-wide fail-closed rule (2026-09): any positive-weight row with `h_ii >= 1 - 1e-8` makes the one-way hc2 / unweighted-unclustered hc2_bm / hc3 vcov all-NaN with a warning, point estimates preserved; the former `1 - h` floor and over-one HC1 fallback are retired — see the REGISTRY "IF-based variance estimators vs analytical-sandwich estimators" Note),
   **survey TSL** (n_PSU - n_strata over the full design), and **Wooldridge
   cohort_trends full-dummy** (documented opt-in landing on the L1
   convention). **conley** is out of this matrix by decision: the spatial-HAC
diff --git a/docs/tutorials/31_lwdid.ipynb b/docs/tutorials/31_lwdid.ipynb
index 166e14735..d30cdf7a8 100644
--- a/docs/tutorials/31_lwdid.ipynb
+++ b/docs/tutorials/31_lwdid.ipynb
@@ -792,8 +792,8 @@
     "`\"classical\"`, `\"hc1\"`, `\"hc2\"`, and `\"hc3\"` for regression adjustment. HC3 is\n",
     "the conservative small-sample choice *when leverage is bounded away from one*;\n",
     "in single-treated-unit designs the treated observation has leverage exactly\n",
-    "one and HC3 is undefined (the library fails closed with NaN inference rather\n",
-    "than fabricating a number) - use exact classical-t or randomization inference\n",
+    "one and HC2 and HC3 are undefined (the library fails closed with NaN inference\n",
+    "rather than fabricating a number; the point estimate is preserved) - use exact classical-t or randomization inference\n",
     "there, as in Section 4.\n",
     "\n",
     "## 7. Transformation Diagnostics\n",
diff --git a/rust/src/linalg.rs b/rust/src/linalg.rs
index 660c6af73..604cd5544 100644
--- a/rust/src/linalg.rs
+++ b/rust/src/linalg.rs
@@ -242,12 +242,13 @@ pub fn compute_robust_vcov<'py>(
 /// Mirrors the NumPy `_compute_robust_vcov_numpy` unweighted `hc2` branch
 /// exactly (sandwich::vcovHC type="HC2" convention):
 ///   h_i    = x_i' (X'X)^{-1} x_i
-///   meat   = X' diag(u_i^2 / max(1 - h_i, 1e-10)) X
+///   meat   = X' diag(u_i^2 / (1 - h_i)) X        (no floor)
 ///   vcov   = (X'X)^{-1} meat (X'X)^{-1}          (NO n/(n-k) factor)
-/// A hat diagonal exceeding 1 + 1e-6 signals a near-singular design; this
-/// returns the sentinel error "Hat-matrix diagonal exceeds 1" so the Python
-/// dispatcher can reproduce the documented warn-and-fall-back-to-HC1
-/// behavior (the guard decision stays in one place, Python-side).
+/// A hat diagonal at or above 1 - 1e-8 (a perfectly fitted row) makes the
+/// meat term 0/0: this returns the sentinel error
+/// "Hat-matrix leverage ~1 (count=N)" so the Python dispatcher re-dispatches
+/// to the NumPy branch, which fails closed (warning + all-NaN vcov). The
+/// guard decision stays in one place, Python-side; the kernel only signals.
 ///
 /// # Arguments
 /// * `x` - Design matrix (n, k)
@@ -281,19 +282,19 @@ pub fn compute_robust_vcov_hc2<'py>(
     let x_bread = x_arr.dot(&xtx_inv); // (n, k)
     let h_diag: Array1<f64> = (&x_bread * &x_arr).sum_axis(Axis(1));
 
-    let h_max = h_diag.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
-    if h_max > 1.0 + 1e-6 {
+    let n_lev1 = h_diag.iter().filter(|&&h| h >= 1.0 - 1e-8).count();
+    if n_lev1 > 0 {
         return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(format!(
-            "Hat-matrix diagonal exceeds 1 (max={:.6}); the design is near-singular.",
-            h_max
+            "Hat-matrix leverage ~1 (count={}); the HC2 variance is undefined.",
+            n_lev1
         )));
     }
 
-    // meat = X' diag(u^2 / max(1 - h, 1e-10)) X
+    // meat = X' diag(u^2 / (1 - h)) X  (every h < 1 - 1e-8 here: no floor)
     let factor: Array1<f64> = residuals_arr
         .iter()
         .zip(h_diag.iter())
-        .map(|(u, h)| u * u / (1.0 - h).max(1e-10))
+        .map(|(u, h)| u * u / (1.0 - h))
         .collect();
     let factor_col = factor.insert_axis(Axis(1)); // (n, 1)
     let x_weighted = &x_arr * &factor_col; // (n, k)
diff --git a/tests/test_estimators_vcov_type.py b/tests/test_estimators_vcov_type.py
index 9ba7709d9..1da66b9d7 100644
--- a/tests/test_estimators_vcov_type.py
+++ b/tests/test_estimators_vcov_type.py
@@ -3321,3 +3321,211 @@ def test_roster_every_vcov_estimator_supports_or_rejects_hc3(self):
                 ), f"{name} rejected hc3 without naming it: {exc_info.value}"
         # The guard must actually be exercising a meaningful roster.
         assert len(checked) >= 8, f"roster unexpectedly small: {checked}"
+
+
+# =============================================================================
+# Leverage-one designs fail closed at estimator level (2026-09): hc2 on every
+# reachable one-way path and unweighted, unclustered hc2_bm. Point estimates
+# are preserved; every inference field is NaN. Every panel is built
+# unit-major from a fresh default_rng(0).
+# =============================================================================
+
+
+def _nan_scalar_inference(res, prefix=""):
+    from tests.conftest import assert_nan_inference
+
+    g = lambda name: getattr(res, f"{prefix}{name}")  # noqa: E731
+    assert_nan_inference(
+        {"se": g("se"), "t_stat": g("t_stat"), "p_value": g("p_value"), "conf_int": g("conf_int")}
+    )
+
+
+class TestLeverageOneEstimators:
+    LEV = "variance is undefined"
+
+    @staticmethod
+    def _did_panel():
+        rng = np.random.default_rng(0)
+        rows = []
+        for u in range(4):
+            for t in (0, 1):
+                rows.append(dict(unit=u, post=t, treated=int(u == 0), y=rng.normal()))
+        return pd.DataFrame(rows)
+
+    @pytest.mark.parametrize("vcov_type,label", [("hc2", "HC2"), ("hc2_bm", "HC2-BM")])
+    def test_did_single_treated_unit(self, vcov_type, label):
+        """4 units x 2 periods, one treated: the treated x post cell has one
+        row (h = 1). Non-saturated (n=8, k=4), so no unrelated df warning."""
+        df = self._did_panel()
+        kw = dict(outcome="y", treatment="treated", time="post")
+        ref = DifferenceInDifferences(vcov_type="classical").fit(df, **kw)
+        assert np.isfinite(ref.se)  # classical is defined here (residual df 4)
+        with pytest.warns(UserWarning, match=f"{label} {self.LEV}") as rec:
+            res = DifferenceInDifferences(vcov_type=vcov_type).fit(df, **kw)
+        assert sum(self.LEV in str(w.message) for w in rec) == 1
+        assert np.isclose(res.att, ref.att, atol=1e-12)
+        _nan_scalar_inference(res)
+
+    @staticmethod
+    def _mpd_panel():
+        rng = np.random.default_rng(0)
+        rows = []
+        for u in range(8):
+            for t in range(1, 5):
+                rows.append(
+                    dict(
+                        unit=u,
+                        time=t,
+                        treated=int(u == 0),
+                        y=rng.normal() + (1.0 if (u == 0 and t >= 3) else 0.0),
+                    )
+                )
+        return pd.DataFrame(rows)
+
+    def test_multi_period_unclustered_hc2_bm(self):
+        """The unclustered hc2_bm event-study path (also the only production
+        consumer of the one-way BM-DOF helper): per-period and post-average
+        inference all NaN, every point estimate preserved."""
+        df = self._mpd_panel()
+        kw = dict(outcome="y", treatment="treated", time="time", post_periods=[3, 4])
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            ref = MultiPeriodDiD(vcov_type="hc1").fit(df, **kw)
+        with warnings.catch_warnings(record=True) as rec:
+            warnings.simplefilter("always")
+            res = MultiPeriodDiD(vcov_type="hc2_bm").fit(df, **kw)
+        lev = [w for w in rec if self.LEV in str(w.message)]
+        assert len(lev) == 1 and "HC2-BM" in str(lev[0].message)
+        assert np.isclose(res.avg_att, ref.avg_att, atol=1e-12)
+        _nan_scalar_inference(res, prefix="avg_")
+        for p, eff in res.period_effects.items():
+            assert np.isfinite(eff.effect) and np.isclose(eff.effect, ref.period_effects[p].effect)
+            _nan_scalar_inference(eff)
+
+    def test_twfe_pooled_event_study_without_unit_hc2_bm(self):
+        """event_study=True, spec='pooled', no unit=: cluster_override is None,
+        so this is the one-way hc2_bm branch. Asserted elementwise on the
+        EventStudyResults arrays (reference row att is exactly 0.0)."""
+        df = self._mpd_panel()
+        kw = dict(
+            outcome="y",
+            treatment="treated",
+            event_study=True,
+            spec="pooled",
+            time="time",
+            post_periods=[3, 4],
+        )
+        with warnings.catch_warnings(record=True) as rec:
+            warnings.simplefilter("always")
+            r = TwoWayFixedEffects(vcov_type="hc2_bm").fit(df, **kw)
+        lev = [w for w in rec if self.LEV in str(w.message)]
+        assert len(lev) == 1 and "HC2-BM" in str(lev[0].message)
+        assert np.isfinite(r.att).all()
+        assert np.isclose(r.att[r.is_reference], 0.0).all()
+        for name in ("se", "t_stat", "p_value", "conf_int_lower", "conf_int_upper"):
+            assert np.isnan(getattr(r, name)).all(), name
+        # Control: unit= restores the auto-cluster -> clustered CR2 (unchanged
+        # path): no leverage warning, finite non-reference SEs, same points.
+        # t/p/CI are NOT asserted: on this small design they are already NaN
+        # from the pre-existing Satterthwaite-reliability guard.
+        with warnings.catch_warnings(record=True) as rec_c:
+            warnings.simplefilter("always")
+            rc = TwoWayFixedEffects(vcov_type="hc2_bm").fit(df, unit="unit", **kw)
+        assert not any(self.LEV in str(w.message) for w in rec_c)
+        assert np.isfinite(rc.se[~rc.is_reference]).all()
+        np.testing.assert_allclose(rc.att, r.att, atol=1e-12)
+
+    def test_twfe_static_explicit_hc2(self):
+        """Explicit hc2 drops the unit auto-cluster; a single treated
+        (unit, period) cell is leverage-one on the full-dummy design."""
+        rng = np.random.default_rng(0)
+        rows = []
+        for u in range(6):
+            for t in range(1, 4):
+                rows.append(
+                    dict(
+                        unit=u,
+                        time=t,
+                        post=int(t == 3),
+                        treated=int(u == 0 and t == 3),
+                        y=rng.normal(),
+                    )
+                )
+        df = pd.DataFrame(rows)
+        kw = dict(outcome="y", treatment="treated", post="post", unit="unit")
+        ref = TwoWayFixedEffects(vcov_type="classical").fit(df, **kw)
+        with pytest.warns(UserWarning, match=f"HC2 {self.LEV}") as rec:
+            res = TwoWayFixedEffects(vcov_type="hc2").fit(df, **kw)
+        assert sum(self.LEV in str(w.message) for w in rec) == 1
+        assert np.isclose(res.att, ref.att, atol=1e-12) and np.isclose(
+            res.att, 0.6273417, atol=1e-6
+        )
+        _nan_scalar_inference(res)
+
+    @staticmethod
+    def _staggered_panel():
+        rng = np.random.default_rng(0)
+        rows = []
+        for u in range(8):
+            g = 3 if u == 0 else (4 if u in (1, 2) else 0)
+            for t in range(1, 7):
+                rows.append(
+                    dict(
+                        unit=u,
+                        time=t,
+                        first_treat=g,
+                        y=rng.normal() + (1.0 if (g and t >= g) else 0.0),
+                    )
+                )
+        return pd.DataFrame(rows)
+
+    def test_sun_abraham_singleton_cohort_hc2(self):
+        """A singleton cohort makes every (cohort, event-time) interaction a
+        single-row column: whole-vcov NaN, every point estimate preserved."""
+        df = self._staggered_panel()
+        kw = dict(outcome="y", unit="unit", time="time", first_treat="first_treat")
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            ref = SunAbraham(vcov_type="hc1").fit(df, **kw)
+        with warnings.catch_warnings(record=True) as rec:
+            warnings.simplefilter("always")
+            res = SunAbraham(vcov_type="hc2").fit(df, **kw)
+        lev = [w for w in rec if self.LEV in str(w.message)]
+        assert len(lev) == 1 and "HC2 " in str(lev[0].message)
+        assert np.isclose(res.overall_att, ref.overall_att, atol=1e-10)
+        assert np.isclose(res.overall_att, 1.127459, atol=1e-6)
+        _nan_scalar_inference(res, prefix="overall_")
+        for e, d in res.event_study_effects.items():
+            assert np.isfinite(d["effect"]) and np.isnan(d["se"])
+        for c, d in res.cohort_effects.items():
+            assert np.isfinite(d["effect"]) and np.isnan(d["se"])
+
+    def test_wooldridge_ols_singleton_cohort_hc2(self):
+        """WooldridgeDiD has no hc3 arm, so this is the first time an all-NaN
+        one-way vcov flows through its cell extraction and aggregation:
+        overall and per-cell points preserved, every se NaN."""
+        from diff_diff import WooldridgeDiD
+
+        df = self._staggered_panel()
+        kw = dict(outcome="y", unit="unit", time="time", first_treat="first_treat")
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            ref = WooldridgeDiD(method="ols", vcov_type="hc1").fit(df, **kw)
+        with warnings.catch_warnings(record=True) as rec:
+            warnings.simplefilter("always")
+            res = WooldridgeDiD(method="ols", vcov_type="hc2").fit(df, **kw)
+        lev = [w for w in rec if self.LEV in str(w.message)]
+        assert len(lev) == 1 and "HC2 " in str(lev[0].message)
+        assert np.isfinite(res.overall_att) and np.isclose(
+            res.overall_att, ref.overall_att, atol=1e-10
+        )
+        _nan_scalar_inference(res, prefix="overall_")
+        assert res.cluster_name is None
+        assert len(res.group_time_effects) > 0
+        for key, d in res.group_time_effects.items():
+            assert np.isfinite(d["att"]) and np.isclose(
+                d["att"], ref.group_time_effects[key]["att"]
+            )
+            from tests.conftest import assert_nan_inference
+
+            assert_nan_inference(d)
diff --git a/tests/test_linalg.py b/tests/test_linalg.py
index 48888a1d8..e41f20700 100644
--- a/tests/test_linalg.py
+++ b/tests/test_linalg.py
@@ -2769,13 +2769,17 @@ def test_matches_frozen_dense_oracle(self, kw):
         assert fin.all(), "oracle produced NaN on a well-conditioned design"
         np.testing.assert_allclose(dof[fin], oracle[fin], rtol=1e-10)
 
-    def test_noise_floor_guard_nans_leverage_one_contrast(self):
+    def test_leverage_one_nans_every_contrast(self):
         """A dummy column firing on exactly one observation gives that row
-        leverage 1: for the dummy's own coefficient the expanded
-        denominator's two terms cancel at ~1e20 scale down to the float
-        noise floor, so the guard must NaN it (the prior dense den > 0
-        would have kept the noise and inflated the DOF) while every
-        ordinary contrast in the same design stays finite."""
+        leverage 1. Since 2026-09 the helper applies the design-level rule:
+        the one-way HC2 vcov is undefined on every path that reaches it in
+        this state (the shared kernel fails closed; the MultiPeriodDiD / TWFE
+        pooled event-study caller receives the same all-NaN vcov), so the
+        Satterthwaite DOF is NaN for EVERY contrast - the dummy's own (whose
+        expanded denominator used to cancel to the noise floor) and the
+        ordinary ones alike. The per-contrast noise-floor cancellation guard
+        still governs extreme-but-defined leverage (see
+        test_matches_frozen_dense_oracle[high-leverage])."""
         from diff_diff.linalg import _compute_bm_dof_from_contrasts
 
         rng = np.random.default_rng(9)
@@ -2786,10 +2790,10 @@ def test_noise_floor_guard_nans_leverage_one_contrast(self):
         h_diag = np.einsum("ij,ij->i", X @ np.linalg.pinv(bread), X)
         assert h_diag.max() > 1 - 1e-12
         with warnings.catch_warnings():
-            warnings.simplefilter("ignore")
+            warnings.simplefilter("error")
             dof = _compute_bm_dof_from_contrasts(X, bread, h_diag, np.eye(k))
-        assert np.isnan(dof[3]), "leverage-1 dummy coefficient must NaN"
-        assert np.isfinite(dof[:3]).all(), "ordinary contrasts must stay finite"
+        assert dof.shape == (k,)
+        assert np.isnan(dof).all(), "every contrast's DOF is NaN at leverage one"
 
 
 class TestCR2BMLowRankAdjustment:
diff --git a/tests/test_linalg_hc2_bm.py b/tests/test_linalg_hc2_bm.py
index 95f9b0ef8..c8f49afaa 100644
--- a/tests/test_linalg_hc2_bm.py
+++ b/tests/test_linalg_hc2_bm.py
@@ -21,6 +21,8 @@
 
 from __future__ import annotations
 
+import warnings
+
 import numpy as np
 import pytest
 
@@ -839,3 +841,268 @@ def test_dof_only_with_zero_weights_does_not_crash(self):
         dof = _compute_cr2_bm_contrast_dof(X, cluster, bread, C, weights=weights)
         assert dof.shape == (C.shape[1],)
         assert np.all(np.isfinite(dof))
+
+
+# =============================================================================
+# Leverage-one fail-closed contract (2026-09 maintainer decision): hc2 on
+# every weight type and unweighted, unclustered hc2_bm return an all-NaN vcov
+# (+ all-NaN DOF) with a warning, exactly like hc3, instead of flooring
+# 1 - h_ii. Point estimates are computed upstream and untouched.
+# =============================================================================
+
+
+def _probe_design():
+    """[1, D] with a single treated row (h_66 = 1, residual exactly 0)."""
+    X = np.column_stack([np.ones(6), np.array([0.0, 0.0, 0.0, 0.0, 0.0, 1.0])])
+    y = np.random.default_rng(0).normal(size=6)
+    resid = y - X @ np.linalg.lstsq(X, y, rcond=None)[0]
+    return X, resid
+
+
+def _wls_resid(X, y, w):
+    beta = np.linalg.solve(X.T @ (X * w[:, None]), X.T @ (w * y))
+    return y - X @ beta
+
+
+class TestLeverageOneFailsClosed:
+    """Family-wide leverage-one guard on the shared one-way kernel."""
+
+    @pytest.mark.parametrize("vcov_type,label", [("hc2", "HC2"), ("hc2_bm", "HC2-BM")])
+    @pytest.mark.parametrize("return_dof", [False, True])
+    @pytest.mark.parametrize("entry", ["dispatch", "numpy"])
+    def test_probe_design_fails_closed(self, vcov_type, label, return_dof, entry):
+        from diff_diff.linalg import _compute_robust_vcov_numpy
+
+        X, resid = _probe_design()
+        fn = compute_robust_vcov if entry == "dispatch" else _compute_robust_vcov_numpy
+        with pytest.warns(UserWarning, match=rf"{label} variance is undefined: 1 observation"):
+            out = fn(X, resid, vcov_type=vcov_type, return_dof=return_dof)
+        if return_dof:
+            vcov, dof = out
+            assert dof.shape == (2,) and np.isnan(dof).all()
+        else:
+            vcov = out
+        assert vcov.shape == (2, 2) and np.isnan(vcov).all()
+
+    def test_message_lists_count_and_first_five_rows(self):
+        """Six singleton dummies -> six offending rows; the message states the
+        total and previews exactly five (both backends: the Rust re-dispatch
+        hands the message to the NumPy branch)."""
+        n = 12
+        X = np.column_stack([np.ones(n), np.eye(n)[:, :6]])
+        y = np.random.default_rng(1).normal(size=n)
+        resid = y - X @ np.linalg.lstsq(X, y, rcond=None)[0]
+        with pytest.warns(UserWarning) as rec:
+            v = compute_robust_vcov(X, resid, vcov_type="hc2")
+        msgs = [str(w.message) for w in rec if "variance is undefined" in str(w.message)]
+        assert len(msgs) == 1
+        assert "6 observation(s)" in msgs[0]
+        assert "rows [0, 1, 2, 3, 4, ...]" in msgs[0]
+        assert "vcov_type='classical'" in msgs[0] and "hc1" not in msgs[0]
+        assert np.isnan(v).all()
+
+    @pytest.mark.parametrize("weight_type", ["aweight", "pweight"])
+    @pytest.mark.parametrize("uniform", [True, False])
+    def test_weighted_hc2_fails_closed(self, weight_type, uniform):
+        """The WLS hat diagonal of a perfectly fitted positive-weight row is
+        exactly 1 regardless of the weight vector."""
+        X, _ = _probe_design()
+        y = np.random.default_rng(0).normal(size=6)
+        w = np.ones(6) if uniform else np.array([1.0, 2.0, 0.5, 1.5, 1.0, 3.0])
+        resid = _wls_resid(X, y, w)
+        with pytest.warns(UserWarning, match="HC2 variance is undefined: 1 observation"):
+            v = compute_robust_vcov(X, resid, weights=w, weight_type=weight_type, vcov_type="hc2")
+        assert np.isnan(v).all()
+
+    def test_fweight_singleton_count_one_fails_closed_count_two_does_not(self):
+        """Replicated-data semantics: a count-1 singleton row is leverage-one
+        (h = 1.0); with count 2 the two replicates share the parameter
+        (h = 0.5) and HC2 is defined."""
+        X, _ = _probe_design()
+        y = np.random.default_rng(0).normal(size=6)
+        w1 = np.ones(6)
+        with pytest.warns(UserWarning, match="HC2 variance is undefined"):
+            v1 = compute_robust_vcov(
+                X, _wls_resid(X, y, w1), weights=w1, weight_type="fweight", vcov_type="hc2"
+            )
+        assert np.isnan(v1).all()
+        w2 = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 2.0])
+        bread = X.T @ (X * w2[:, None])
+        assert np.isclose(_compute_hat_diagonals(X, bread)[5], 0.5)
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+            v2 = compute_robust_vcov(
+                X, _wls_resid(X, y, w2), weights=w2, weight_type="fweight", vcov_type="hc2"
+            )
+        assert np.isfinite(v2).all()
+
+    @staticmethod
+    def _fw0(x6):
+        x = np.array([0.0, 1.0, 2.0, 3.0, 4.0, x6])
+        X = np.column_stack([np.ones(6), x])
+        w = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 0.0])
+        y = np.random.default_rng(1).normal(size=6) + x
+        return X, w, y
+
+    @pytest.mark.parametrize("vcov_type", ["hc2", "hc3"])
+    @pytest.mark.parametrize("x6", [2.0 + np.sqrt(8.0), 7.0])  # h6 = 1.0 and 2.7
+    def test_zero_count_fweight_row_equals_literal_expansion(self, vcov_type, x6):
+        """An inert zero-count fweight row (its unweighted-quadform leverage is
+        meaningless: exactly 1.0, or 2.7) neither trips the guard nor breaks
+        the compressed == np.repeat-expansion identity."""
+        from diff_diff.linalg import _compute_robust_vcov_numpy
+
+        X, w, y = self._fw0(x6)
+        resid = _wls_resid(X, y, w)
+        h6 = _compute_hat_diagonals(X, X.T @ (X * w[:, None]))[5]
+        assert h6 >= 1.0 - 1e-8
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+            v = _compute_robust_vcov_numpy(
+                X, resid, None, weights=w, weight_type="fweight", vcov_type=vcov_type
+            )
+        Xe, ye = X[:5], y[:5]
+        resid_e = ye - Xe @ np.linalg.lstsq(Xe, ye, rcond=None)[0]
+        v_e = _compute_robust_vcov_numpy(Xe, resid_e, None, vcov_type=vcov_type)
+        np.testing.assert_allclose(v, v_e, rtol=0, atol=1e-12)
+        assert np.isfinite(v).all()
+
+    @pytest.mark.parametrize("vcov_type,label", [("hc2", "HC2"), ("hc3", "HC3")])
+    def test_zero_count_mask_does_not_disable_guard(self, vcov_type, label):
+        """Mixed design: a positive-count singleton dummy (row 0, h = 1.0) next
+        to the zero-count row (h = 1.334): the guard fires, counts ONLY the
+        positive-count row, and lists only it."""
+        from diff_diff.linalg import _compute_robust_vcov_numpy
+
+        X, w, y = self._fw0(2.0 + np.sqrt(8.0))
+        X = np.column_stack([X, np.array([1.0, 0.0, 0.0, 0.0, 0.0, 0.0])])
+        h = _compute_hat_diagonals(X, X.T @ (X * w[:, None]))
+        assert np.isclose(h[0], 1.0) and h[5] > 1.0
+        resid = _wls_resid(X, y, w)
+        with pytest.warns(
+            UserWarning, match=rf"{label} variance is undefined: 1 observation"
+        ) as rec:
+            v = _compute_robust_vcov_numpy(
+                X, resid, None, weights=w, weight_type="fweight", vcov_type=vcov_type
+            )
+        assert "rows [0]" in str(rec[0].message)
+        assert np.isnan(v).all()
+
+    def test_weighted_hc2_bm_ones_keeps_clubsandwich_result(self):
+        """Documented boundary of the decision: pweight hc2_bm routes through
+        the clubSandwich singleton-CR2 port, whose generalized inverse returns
+        a finite (understated) variance at leverage one - even for no-op
+        weights. R clubSandwich::vcovCR(cluster=1:n, type="CR2") on this
+        design: SE 0.1915, Satterthwaite df 4."""
+        X, resid = _probe_design()
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+            v, dof = compute_robust_vcov(
+                X,
+                resid,
+                weights=np.ones(6),
+                weight_type="pweight",
+                vcov_type="hc2_bm",
+                return_dof=True,
+            )
+        assert np.isclose(np.sqrt(v[1, 1]), 0.19145263, atol=1e-6)
+        np.testing.assert_allclose(dof, [4.0, 4.0], atol=1e-8)
+
+    def test_over_one_leverage_fails_closed_no_hc1_fallback(self, monkeypatch):
+        """Numerically over-one leverage is inside the guard (round-10 ordering,
+        now family-wide): NaN + warning, never a result labeled hc2 that is
+        actually HC1. Runs the NumPy branch directly (the Rust dispatch does
+        not call the Python hat-diagonal helper)."""
+        import diff_diff.linalg as la
+
+        X, resid = small_design = _nondegenerate_design()
+        monkeypatch.setattr(
+            la,
+            "_compute_hat_diagonals",
+            lambda *a, **k: np.r_[1.0 + 1e-5, np.full(X.shape[0] - 1, 0.1)],
+        )
+        with pytest.warns(UserWarning) as rec:
+            v = la._compute_robust_vcov_numpy(X, resid, None, vcov_type="hc2")
+        msgs = [str(w.message) for w in rec]
+        assert any("HC2 variance is undefined" in m for m in msgs)
+        assert not any("Falling back to HC1" in m for m in msgs)
+        assert np.isnan(v).all()
+        del small_design
+
+    def test_legacy_rust_sentinel_re_dispatches(self, monkeypatch):
+        """A present-but-stale compiled kernel raises the retired over-one
+        sentinel; the dispatcher re-dispatches to the NumPy branch (fail
+        closed on a leverage-one design, finite on a defined design), never
+        HC1."""
+        import diff_diff.linalg as la
+
+        def _legacy(*a, **k):
+            raise ValueError(
+                "Hat-matrix diagonal exceeds 1 (max=1.000010); the design is near-singular."
+            )
+
+        monkeypatch.setattr(la, "HAS_RUST_BACKEND", True)
+        monkeypatch.setattr(la, "_rust_compute_robust_vcov_hc2", _legacy)
+        X, resid = _probe_design()
+        with pytest.warns(UserWarning, match="HC2 variance is undefined") as rec:
+            v = la.compute_robust_vcov(X, resid, vcov_type="hc2")
+        assert np.isnan(v).all()
+        assert not any("Falling back" in str(w.message) for w in rec)
+        Xn, rn = _nondegenerate_design()
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+            v_n = la.compute_robust_vcov(Xn, rn, vcov_type="hc2")
+        np.testing.assert_allclose(
+            v_n, la._compute_robust_vcov_numpy(Xn, rn, None, vcov_type="hc2"), rtol=1e-12
+        )
+
+    def test_high_but_defined_leverage_uses_true_denominator(self):
+        """No floor: the meat uses the true 1 - h_ii (h_max ~ 0.78 here)."""
+        from diff_diff.linalg import _compute_robust_vcov_numpy
+
+        X, resid = _nondegenerate_design()
+        bread = X.T @ X
+        h = _compute_hat_diagonals(X, bread)
+        assert 0.7 < h.max() < 1.0 - 1e-8
+        meat = X.T @ (X * (resid**2 / (1.0 - h))[:, None])
+        expected = np.linalg.solve(bread, np.linalg.solve(bread, meat).T).T
+        v = _compute_robust_vcov_numpy(X, resid, None, vcov_type="hc2")
+        np.testing.assert_allclose(v, expected, rtol=1e-12, atol=0)
+
+    def test_bm_dof_helper_all_nan_at_leverage_one(self):
+        from diff_diff.linalg import _compute_bm_dof_from_contrasts
+
+        X, _ = _probe_design()
+        bread = X.T @ X
+        h = _compute_hat_diagonals(X, bread)
+        contrasts = np.column_stack([np.eye(2), np.array([0.5, 0.5])])
+        dof = _compute_bm_dof_from_contrasts(X, bread, h, contrasts)
+        assert dof.shape == (3,) and np.isnan(dof).all()
+        Xn, _ = _nondegenerate_design()
+        bn = Xn.T @ Xn
+        dof_n = _compute_bm_dof_from_contrasts(
+            Xn, bn, _compute_hat_diagonals(Xn, bn), np.eye(Xn.shape[1])
+        )
+        assert np.isfinite(dof_n).all()
+
+    def test_warning_attributed_to_caller_numpy_path(self, monkeypatch):
+        import diff_diff.linalg as la
+
+        monkeypatch.setattr(la, "HAS_RUST_BACKEND", False)
+        X, resid = _probe_design()
+        with warnings.catch_warnings(record=True) as rec:
+            warnings.simplefilter("always")
+            la.compute_robust_vcov(X, resid, vcov_type="hc2")
+        lev = [w for w in rec if "variance is undefined" in str(w.message)]
+        assert len(lev) == 1 and lev[0].filename == __file__
+
+
+def _nondegenerate_design():
+    """Well-conditioned design with one high-leverage-but-defined row."""
+    rng = np.random.default_rng(3)
+    n = 40
+    X = np.column_stack([np.ones(n), rng.normal(size=(n, 2))])
+    X[0, 1] = 12.0  # h_max ~ 0.78
+    y = X @ np.array([1.0, 0.5, -0.3]) + rng.normal(size=n)
+    resid = y - X @ np.linalg.lstsq(X, y, rcond=None)[0]
+    return X, resid
diff --git a/tests/test_lwdid.py b/tests/test_lwdid.py
index 7bef8a227..e19a78593 100644
--- a/tests/test_lwdid.py
+++ b/tests/test_lwdid.py
@@ -4317,8 +4317,15 @@ def test_hc2_leverage_one_fails_closed_on_lwdid(self):
                 d = 1 if (u < 1 and t >= 4) else 0  # single treated unit
                 rows.append(dict(unit=u, time=t, treat=d, y=rng.normal() + d))
         df = pd.DataFrame(rows)
-        with pytest.warns(UserWarning, match="HC2 variance is undefined"):
+        with pytest.warns(UserWarning, match="HC2 variance is undefined") as rec:
             res = LWDiD(rolling="demean", vcov_type="hc2").fit(df, **self.KW)
+        # 2026-09: the SHARED kernel fails closed and owns the warning (one per
+        # leverage-one solve_ols call - this fit makes several); the former
+        # LWDiD-local guard and its differently worded duplicate are retired.
+        lev = [str(w.message) for w in rec if "HC2 variance is undefined" in str(w.message)]
+        assert len(lev) >= 1
+        assert all("Returning NaN vcov" in m for m in lev), "kernel-shaped warning expected"
+        assert not any("for this design" in m for m in lev), "retired local-guard wording"
         assert np.isfinite(res.att)
         from tests.conftest import assert_nan_inference
 
diff --git a/tests/test_methodology_wls_cr2.py b/tests/test_methodology_wls_cr2.py
index d507d5347..c895a3305 100644
--- a/tests/test_methodology_wls_cr2.py
+++ b/tests/test_methodology_wls_cr2.py
@@ -989,6 +989,11 @@ def test_unweighted_dof_path_equivalence(self, goldens):
         )
 
     def test_unweighted_one_way_dof_path_equivalence(self, goldens):
+        """Non-degenerate designs only: the simple unweighted formula and the
+        weights=ones P_array singleton-cluster reduction agree. The identity
+        does NOT hold at a leverage-one row (2026-09): the simple formula
+        fails closed (all-NaN DOF, like its vcov) while the P_array port
+        keeps clubSandwich's finite generalized-inverse DOF."""
         d = goldens["singletons_present"]
         X = np.column_stack([np.ones(len(d["x"])), np.asarray(d["x"])])
         y = np.asarray(d["y"])
@@ -1010,6 +1015,7 @@ def test_unweighted_one_way_dof_path_equivalence(self, goldens):
             atol=1e-12,
             err_msg=(
                 "One-way unweighted DOF: simple formula must agree with the "
-                "P_array singleton-cluster reduction at the unweighted limit."
+                "P_array singleton-cluster reduction at the unweighted limit "
+                "on a non-degenerate (no leverage-one row) design."
             ),
         )
diff --git a/tests/test_rust_backend.py b/tests/test_rust_backend.py
index c8dae731f..38c0c3f99 100644
--- a/tests/test_rust_backend.py
+++ b/tests/test_rust_backend.py
@@ -9,6 +9,8 @@
 Tests are skipped if the Rust backend is not available.
 """
 
+import warnings
+
 import numpy as np
 import pandas as pd
 import pytest
@@ -3543,9 +3545,12 @@ class TestRustHC2Vcov:
     """Rust HC2 (leverage-corrected) vcov parity with the NumPy hc2 branch.
 
     The kernel mirrors `_compute_robust_vcov_numpy`'s unweighted `hc2` path
-    exactly (hat diagonals off the same bread, `u^2 / max(1 - h, 1e-10)` meat,
-    NO n/(n-k) factor); the near-singular hat-diagonal guard stays Python-side
-    (sentinel error -> documented warn-and-fall-back-to-HC1)."""
+    exactly (hat diagonals off the same bread, `u^2 / (1 - h)` meat with NO
+    floor, NO n/(n-k) factor); the leverage-one guard decision stays
+    Python-side: the kernel raises the "Hat-matrix leverage ~1" sentinel and
+    the dispatcher re-dispatches to the NumPy branch, which fails closed
+    (warning + all-NaN vcov). A stale kernel's legacy over-one sentinel takes
+    the same re-dispatch."""
 
     @staticmethod
     def _design(n=400, k=5, seed=0):
@@ -3575,42 +3580,82 @@ def test_hc2_kernel_direct(self):
         np.testing.assert_allclose(v, v.T, rtol=0, atol=1e-12)
         assert np.all(np.diag(v) > 0)
 
-    def test_exact_unit_leverage_clamp_parity(self):
-        """h_ii == 1 exactly (a one-obs dummy is its own perfect predictor)
-        does NOT trip the > 1 + 1e-6 guard in either backend — both take the
-        max(1 - h, 1e-10) clamp path and must agree."""
-        from diff_diff.linalg import _compute_robust_vcov_numpy, compute_robust_vcov
-
-        n = 60
-        rng = np.random.default_rng(3)
+    @staticmethod
+    def _leverage_one_design(n=60, seed=3):
+        """h_00 == 1 exactly: a one-obs dummy is its own perfect predictor."""
+        rng = np.random.default_rng(seed)
         d = np.zeros(n)
         d[0] = 1.0
         X = np.column_stack([np.ones(n), d, rng.normal(size=n)])
         y = X @ np.array([1.0, 2.0, 0.5]) + rng.normal(size=n)
         resid = y - X @ np.linalg.lstsq(X, y, rcond=None)[0]
+        return X, resid
 
-        v_rust_path = compute_robust_vcov(X, resid, vcov_type="hc2")
-        v_numpy_path = _compute_robust_vcov_numpy(X, resid, None, vcov_type="hc2")
-        np.testing.assert_allclose(v_rust_path, v_numpy_path, rtol=1e-9, atol=1e-12)
+    def test_exact_unit_leverage_fails_closed_both_backends(self):
+        """h_ii == 1 exactly fails closed identically through the Rust
+        dispatch (sentinel -> NumPy re-dispatch) and the NumPy branch: one
+        "HC2 variance is undefined" warning and an all-NaN vcov each (asserted
+        with explicit isnan, never assert_allclose's NaN == NaN)."""
+        from diff_diff.linalg import _compute_robust_vcov_numpy, compute_robust_vcov
 
-    def test_sentinel_error_falls_back_to_hc1_with_warning(self, monkeypatch):
-        """The kernel's near-singular sentinel error must reproduce the NumPy
-        branch's warn-and-fall-back-to-HC1 through the dispatcher (the guard
-        decision is Python-side; the kernel only signals)."""
-        import diff_diff.linalg as la
+        X, resid = self._leverage_one_design()
+        with pytest.warns(UserWarning, match="HC2 variance is undefined: 1 observation") as r1:
+            v_rust_path = compute_robust_vcov(X, resid, vcov_type="hc2")
+        with pytest.warns(UserWarning, match="HC2 variance is undefined: 1 observation") as r2:
+            v_numpy_path = _compute_robust_vcov_numpy(X, resid, None, vcov_type="hc2")
+        assert v_rust_path.shape == v_numpy_path.shape == (3, 3)
+        assert np.isnan(v_rust_path).all() and np.isnan(v_numpy_path).all()
+        assert sum("variance is undefined" in str(w.message) for w in r1) == 1
+        assert sum("variance is undefined" in str(w.message) for w in r2) == 1
+
+    def test_kernel_raises_leverage_one_sentinel(self):
+        """Direct kernel call on a leverage-one design raises the sentinel the
+        dispatcher keys on. This is the stale-kernel diagnostic: a kernel
+        built before the 2026-09 change returns a floored finite vcov here."""
+        from diff_diff._rust_backend import compute_robust_vcov_hc2
 
-        X, resid = self._design()
+        X, resid = self._leverage_one_design()
+        with pytest.raises(ValueError, match=r"Hat-matrix leverage ~1 \(count=1\)"):
+            compute_robust_vcov_hc2(np.ascontiguousarray(X), np.ascontiguousarray(resid))
+
+    def test_legacy_sentinel_fails_closed(self, monkeypatch):
+        """A stale kernel's legacy over-one sentinel re-dispatches to the NumPy
+        branch (the guard decision is Python-side; the kernel only signals):
+        fail closed on a leverage-one design, the finite NumPy hc2 vcov with
+        no warning on a defined design - never an HC1 fallback."""
+        import diff_diff.linalg as la
 
         def _sentinel(*a, **k):
             raise ValueError(
                 "Hat-matrix diagonal exceeds 1 (max=1.000010); the design is near-singular."
             )
 
+        monkeypatch.setattr(la, "HAS_RUST_BACKEND", True)
         monkeypatch.setattr(la, "_rust_compute_robust_vcov_hc2", _sentinel)
-        with pytest.warns(UserWarning, match="Falling back to HC1"):
-            v = la.compute_robust_vcov(X, resid, vcov_type="hc2")
-        v_hc1 = la._compute_robust_vcov_numpy(X, resid, None, vcov_type="hc1")
-        np.testing.assert_allclose(v, v_hc1, rtol=1e-12, atol=1e-15)
+        X1, r1 = self._leverage_one_design()
+        with pytest.warns(UserWarning, match="HC2 variance is undefined") as rec:
+            v = la.compute_robust_vcov(X1, r1, vcov_type="hc2")
+        assert np.isnan(v).all()
+        assert not any("Falling back" in str(w.message) for w in rec)
+        X0, r0 = self._design()  # h_max ~ 0.05: defined
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+            v0 = la.compute_robust_vcov(X0, r0, vcov_type="hc2")
+        np.testing.assert_allclose(
+            v0, la._compute_robust_vcov_numpy(X0, r0, None, vcov_type="hc2"), rtol=1e-12, atol=1e-15
+        )
+
+    def test_warning_attributed_to_caller_rust_path(self):
+        """The re-dispatch warns from the NumPy branch at the same depth as the
+        direct path, so the warning is attributed to this test file."""
+        from diff_diff.linalg import compute_robust_vcov
+
+        X, resid = self._leverage_one_design()
+        with warnings.catch_warnings(record=True) as rec:
+            warnings.simplefilter("always")
+            compute_robust_vcov(X, resid, vcov_type="hc2")
+        lev = [w for w in rec if "variance is undefined" in str(w.message)]
+        assert len(lev) == 1 and lev[0].filename == __file__
 
     def test_dispatch_declined_for_dof_and_weights(self):
         """return_dof / weights / cluster requests stay on the NumPy path