Address CI R13 P1: constant violation pattern is now a true level shift

R13 CI codex caught the next adjacent unit-mismatch — analogous to
R12's linear/level fix but for `violation_type='constant'`. REGISTRY
`## PreTrendsPower` documents the pattern as `δ_t = c` (per-period
level shift), but `_get_violation_weights('constant')` still
L2-normalized to `[1/√K, ..., 1/√K]`, so `δ_t = M/√K` not `δ_t = M`.

The Step 4 γ-unit fix for linear and the R12 holistic
`max_abs_pre_violation` fix uncovered this — once `mdv` is the
documented magnitude of a per-period shift on linear, the constant
pattern's silent `1/√K` re-scaling becomes visible and breaks the
documented contract.

**Holistic fix — constant/last_period skip L2 normalization**

- `_get_violation_weights('constant')`: early return `np.ones(n_pre)`,
  no L2 norm. Now `δ_t = M` exactly per period — matching the
  REGISTRY/API documented contract.
- `_get_violation_weights('last_period')`: also given an explicit
  early return for symmetry. The `[0, ..., 0, 1]` vector already had
  L2 norm 1, so this is a no-op numerically; the early return locks
  the contract uniformly across level-pattern violation types.
- `power_at()` legacy reconstruction (fallback for old serialized
  results without `violation_weights`): unchanged — still
  L2-normalizes, preserving pre-PR-B numerical output for legacy
  serialized fits per the same backwards-compat policy applied to
  the linear-legacy and constant-legacy paths.
- Docstring on `_get_violation_weights` rewritten to enumerate the
  per-type normalization convention explicitly: linear-with-times
  (γ-unit), linear-legacy (L2-norm), constant (level), last_period
  (level), custom (L2-norm).

**End-to-end regression** in `test_methodology_pretrends.py`:

- `test_constant_violation_pattern_is_level_shift`: real
  `SunAbraham`-fit results, asserts `violation_weights == [1, ..., 1]`
  (NOT L2-normalized → `||w||_2 = √K`), `max_abs_pre_violation == mdv`
  (level-scale and γ-scale coincide for constant), and
  `power_at(M) ≈ refit(M=M).power` at `atol=1e-4` so the
  level-shift contract holds end-to-end through `fit()` and
  `power_at()`. Codex specifically requested an end-to-end lock so
  future audits cannot drift between "per-period shift" and
  "normalized-direction magnitude".

- `test_constant_weights` in `tests/test_pretrends.py` flipped: was
  pinning `np.linalg.norm(weights) == 1.0` (the OLD L2-normalized
  contract); now asserts unnormalized `[1, 1, 1, 1]` with
  `||w||_2 = 2` (√4). Docstring explains the contract change.

**P3 fix — BR rendered label**

`BusinessReport.full_report()` still labeled the
`mdv_share_of_att` row as `MDV / |ATT|`, but R12 redefined the
numerator as `max_abs_pre_violation`. Fix: rename the rendered
label to "Max pre-period level deviation / |ATT|" and add an
explicit row for `Max pre-period level deviation at MDV` above it
so users can see both the raw `mdv` and the level-scale scalar.

**Behavior change for users:** any caller passing
`violation_type='constant'` will see a √K-factor change in the
reported `mdv` and downstream `mdv_share_of_att`. The shift is
documented in REGISTRY `## PreTrendsPower` (the pattern was
`δ_t = c` all along — the IMPLEMENTATION is now what the docs
have always said).

445 tests pass across pretrends + DR + BR + SA. 4 skipped (R-parity
+ 1 fixture skip).

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

Author: igerber

diff_diff/business_report.py

@@ -2467,11 +2467,18 @@ def _render_full_report(schema: Dict[str, Any]) -> str:
         if tier:
             lines.append(f"- Power tier: `{tier}`")
         mdv = pt.get("mdv")
+        max_abs_pre = pt.get("max_abs_pre_violation")
         ratio = pt.get("mdv_share_of_att")
         if isinstance(mdv, (int, float)):
             lines.append(f"- Minimum detectable violation (MDV): {mdv:.3g}")
+        if isinstance(max_abs_pre, (int, float)):
+            lines.append(f"- Max pre-period level deviation at MDV: {max_abs_pre:.3g}")
         if isinstance(ratio, (int, float)):
-            lines.append(f"- MDV / |ATT|: {ratio:.2g}")
+            # PR-B R12: ratio is now max_abs_pre_violation / |ATT|, the
+            # level-scale comparable to ATT (not raw γ-unit mdv on linear
+            # fits). Label updated to match the numerator definition in
+            # REPORTING.md "Power-aware phrasing" Note.
+            lines.append(f"- Max pre-period level deviation / |ATT|: {ratio:.2g}")
     else:
         lines.append(f"- Pre-trends not computed: {pt.get('reason', 'unavailable')}")
     lines.append("")

diff_diff/pretrends.py

@@ -890,11 +890,30 @@ def _get_violation_weights(
         Returns
         -------
         np.ndarray
-            Violation weights. For ``violation_type='linear'`` with
-            ``relative_times`` provided: ``|t|`` directly, NOT L2-normalized
-            (so ``M=γ`` directly under Roth's slope convention). For all
-            other paths (constant, last_period, custom, or
-            linear-without-relative_times): L2-normalized to unit norm.
+            Violation weights, with per-violation-type normalization
+            conventions chosen so the magnitude `M` matches what
+            ``REGISTRY.md`` documents for the pattern:
+
+            - ``'linear'`` with ``relative_times``: ``|t|`` directly,
+              NOT L2-normalized (so ``δ_t = M * |t|`` and the reported
+              MDV is in Roth's γ units). PR-B Step 4.
+            - ``'linear'`` without ``relative_times`` (legacy): the
+              count-based ``[n_pre-1, ..., 0]`` direction, L2-normalized
+              to unit norm (preserves pre-PR-B shipped behavior).
+            - ``'constant'``: ``[1, 1, ..., 1]`` directly, NOT
+              normalized — ``δ_t = M`` per period (a true level shift,
+              matching the documented ``δ_t = c`` convention). PR-B R13
+              fix: pre-R13 normalization gave ``δ_t = M/√K``, a silent
+              rescaling that the REGISTRY/API did not document.
+            - ``'last_period'``: ``[0, ..., 0, 1]`` directly. Already
+              unit-norm so the post-normalization output was identical;
+              the unconditional early return locks the level-shift
+              contract.
+            - ``'custom'``: user-supplied ``violation_weights``,
+              L2-normalized to unit norm (M is the magnitude along the
+              user's direction; downstream
+              ``max_abs_pre_violation = M * max(|weights|)`` exposes
+              the level-scale max under the MDV).
         """
         if self.violation_type == "custom":
             assert self.violation_weights is not None
@@ -930,18 +949,33 @@ def _get_violation_weights(
             weights = np.arange(-n_pre + 1, 1, dtype=float)
             weights = -weights  # Now [n-1, n-2, ..., 1, 0]
         elif self.violation_type == "constant":
-            # Same violation in all periods
-            weights = np.ones(n_pre)
+            # δ_t = M for all pre-periods (level shift). Skip L2
+            # normalization so M is exactly the per-period level shift
+            # the REGISTRY documents (`δ_t = c`). Pre-PR-B (and the
+            # pre-R13 PR-B state) divided by sqrt(K), making `δ_t =
+            # M/sqrt(K)` and silently re-scaling reported MDV/power on
+            # constant fits by sqrt(K). PR-B R13 fix: skip the norm
+            # so the public contract matches the docs.
+            return np.ones(n_pre, dtype=float)
         elif self.violation_type == "last_period":
-            # Violation only in last pre-period (period -1)
-            weights = np.zeros(n_pre)
+            # Violation only in last pre-period (period -1). Unnormalized
+            # `[0, ..., 0, 1]` already has L2 norm 1, so this path was
+            # always equivalent to the post-normalization output; keep
+            # the early return for symmetry with constant + linear-with-
+            # relative_times so the level-shift contract is uniform
+            # across all level-pattern violation types.
+            weights = np.zeros(n_pre, dtype=float)
             weights[-1] = 1.0
+            return weights
         else:
             raise ValueError(f"Unknown violation_type: {self.violation_type}")
 
         # Normalize to unit norm (if not all zeros). The early-return
-        # branch above for linear-with-relative_times intentionally skips
-        # this normalization to preserve the γ-unit scale.
+        # branches above for linear-with-relative_times, constant, and
+        # last_period intentionally skip this normalization to preserve
+        # the level-shift contract documented in REGISTRY.md
+        # `## PreTrendsPower`. This block only fires for the linear-
+        # legacy-fallback path and `violation_type='custom'`.
         norm = np.linalg.norm(weights)
         if norm > 0:
             weights = weights / norm

tests/test_methodology_pretrends.py

@@ -523,6 +523,44 @@ def test_max_abs_pre_violation_uses_weight_scale_on_irregular_grid(self):
             res.max_abs_pre_violation > 4 * mdv
         ), "max_abs_pre_violation must scale by max(|w|)=5, not collapse to mdv"
 
+    def test_constant_violation_pattern_is_level_shift(self, sa_results):
+        """``violation_type='constant'`` produces a per-period level shift,
+        not an L2-normalized direction (PR-B R13 fix).
+
+        REGISTRY ``## PreTrendsPower`` documents constant as ``δ_t = c``.
+        The implementation now returns unnormalized ``[1, 1, ..., 1]``
+        weights so the contract holds at the public API surface:
+
+        - ``violation_weights == [1, 1, ..., 1]`` after fit (no L2 norm).
+        - ``max_abs_pre_violation == mdv * 1 == mdv`` (level-scale and
+          γ-scale coincide for the constant pattern).
+        - ``power_at(M)`` evaluates the violation `δ_t = M` per period,
+          not `δ_t = M/√K`.
+
+        Pre-PR-B-R13 the constant path was silently divided by √K,
+        so a constant MDV of 0.5 was a per-period shift of 0.5/√K,
+        not 0.5 as the docs claimed. Locks the level-shift contract
+        end-to-end on a real fit.
+        """
+        pt = PreTrendsPower(violation_type="constant", pretest_form="nis")
+        result = pt.fit(sa_results)
+
+        n_pre = result.n_pre_periods
+        # Weights are exactly [1, 1, ..., 1] — NOT L2-normalized.
+        assert result.violation_weights is not None
+        np.testing.assert_allclose(result.violation_weights, np.ones(n_pre))
+        # L2 norm of weights is √K, not 1.
+        assert np.isclose(np.linalg.norm(result.violation_weights), np.sqrt(n_pre))
+        # Level-scale max coincides with raw mdv (max(|w|) = 1).
+        assert np.isclose(result.max_abs_pre_violation, result.mdv)
+
+        # power_at(M) round-trip: under the level-shift contract,
+        # power_at(M) for constant must equal power at `M=0.1` of a refit.
+        # Loose atol because scipy MVN CDF and the centered helper take
+        # slightly different paths with ~1e-6 sub-ULP roundoff.
+        refit = pt.fit(sa_results, M=0.1)
+        assert np.isclose(result.power_at(0.1), refit.power, atol=1e-4)
+
     def test_is_informative_uses_level_scale_not_raw_gamma(self):
         """``is_informative`` consumes ``max_abs_pre_violation`` (level scale)
         rather than raw ``mdv`` (slope scale) — locks the R12 fix on the