Address thirtieth round of CI review findings on PR #318

P1 methodology (self-contradictory anticipation prose).
``_apply_anticipation_to_assumption`` previously only APPENDED an
anticipation-aware clause. Several base assumption descriptions in
``_describe_assumption`` hard-code a strict "plus no anticipation"
(CS / SA / Imputation / TwoStage / Wooldridge generic,
StackedDiD sub-experiment, dCDH, TripleDifference, SyntheticDiD,
TROP, ContinuousDiD) or "Also assumes no anticipation (Assumption
NA) ..." (EfficientDiD PT-All, PT-Post) clause. On an
anticipation-enabled fit BR would render both in the same paragraph,
contradicting REGISTRY.md's description of anticipation as a SHIFTED
effective treatment boundary rather than strict no-anticipation plus
an exception.

Add ``_strip_strict_no_anticipation`` that removes any of the
canonical strict phrasings from a description before the helper
appends the relaxed clause. Collapses dangling punctuation and
doubled whitespace left by the removal so the rewritten description
reads cleanly. The helper still flips ``no_anticipation = False`` and
records ``anticipation_periods`` on the block.

P3 docs drift. Round-29 added ``power_reason`` alongside
``power_status`` and updated one REPORTING.md reference, but a
second reference at line 142 still pointed at ``power_status`` for
the fallback explanation. Updated to name ``power_reason`` and note
that ``power_status`` carries the enum.

Tests: ``TestAnticipationStripsStrictNoAnticipationClause`` with
five regressions asserts that every anticipation-capable estimator's
rendered description under ``anticipation > 0`` drops both
"plus no anticipation" and "Also assumes no anticipation" AND still
carries the "Anticipation is allowed / not strict no-anticipation"
contract: generic group-time, EfficientDiD PT-All, EfficientDiD
PT-Post, StackedDiD sub-experiment, and an integration check of
``full_report()``'s rendered Identifying Assumption section.

249 BR / DR / practitioner tests pass.

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

Author: igerber

diff_diff/business_report.py

@@ -36,6 +36,7 @@
 
 from __future__ import annotations
 
+import re
 from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Union
 
@@ -822,17 +823,62 @@ def _control_group_choice(results: Any) -> Optional[str]:
     return None
 
 
+_STRICT_NO_ANTICIPATION_PATTERNS = (
+    # Ordered from most specific to least specific so the first match
+    # wins on strings that could match multiple patterns. Matches are
+    # case-sensitive because every occurrence in ``_describe_assumption``
+    # is a fixed canonical phrase.
+    ", plus no anticipation",
+    "plus no anticipation",
+    " Also assumes no anticipation (Assumption NA), overlap "
+    "(Assumption O), and absorbing / irreversible treatment.",
+    " Also assumes no anticipation.",
+    "Also assumes no anticipation.",
+    " and no anticipation",
+)
+
+
+def _strip_strict_no_anticipation(desc: str) -> str:
+    """Remove any strict no-anticipation phrasing from ``desc``.
+
+    Several base assumption descriptions in ``_describe_assumption``
+    hard-code a strict "plus no anticipation" / "Also assumes no
+    anticipation" clause (CS / SA / Imputation / TwoStage / Wooldridge
+    generic, StackedDiD sub-experiment, EfficientDiD PT-Post, EfficientDiD
+    PT-All, ContinuousDiD, TripleDifference, SyntheticDiD, TROP, dCDH,
+    and the fallback unconditional branch). When a fit actually allows
+    anticipation the helper must REPLACE that wording, not append a
+    contradictory clause on top of it. Round-30 P1 CI review on PR #318.
+    """
+    if not desc:
+        return desc
+    out = desc
+    for pattern in _STRICT_NO_ANTICIPATION_PATTERNS:
+        out = out.replace(pattern, "")
+    # Collapse any doubled whitespace or dangling punctuation left by
+    # the removal (e.g., "cohorts,  with..." -> "cohorts, with...";
+    # "cohorts .  " -> "cohorts.").
+    out = re.sub(r"\s+\.", ".", out)
+    out = re.sub(r"\s+,", ",", out)
+    out = re.sub(r" {2,}", " ", out)
+    return out.strip()
+
+
 def _apply_anticipation_to_assumption(block: Dict[str, Any], results: Any) -> Dict[str, Any]:
-    """If the fit used ``anticipation > 0``, flip ``no_anticipation`` off and
-    append an anticipation clause to the description.
+    """If the fit used ``anticipation > 0``, flip ``no_anticipation`` off,
+    strip any strict no-anticipation wording from the base description,
+    and append an anticipation-aware clause.
 
     Round-17 CI review flagged the strict "plus no anticipation" language
     on anticipation-enabled fits. Per REGISTRY.md §CallawaySantAnna lines
     355-395 and the matching sections for SA / MultiPeriod / Wooldridge /
     EfficientDiD, a fit with ``anticipation=k`` shifts the effective
     treatment boundary by ``k`` pre-periods; the identifying assumption
     becomes "no treatment effects earlier than ``k`` periods before the
-    treatment start" rather than strict no-anticipation.
+    treatment start" rather than strict no-anticipation. Round-30 CI
+    review caught that the previous implementation only appended — the
+    resulting prose said both "strict no-anticipation holds" and
+    "anticipation is allowed" in the same paragraph.
     """
     k = _anticipation_periods(results)
     if k <= 0:
@@ -849,7 +895,7 @@ def _apply_anticipation_to_assumption(block: Dict[str, Any], results: Any) -> Di
     )
     desc = block.get("description", "")
     if isinstance(desc, str):
-        block["description"] = desc + clause
+        block["description"] = _strip_strict_no_anticipation(desc) + clause
     return block
 
 

docs/methodology/REPORTING.md

@@ -139,7 +139,8 @@ not new inference.
     signal."
   - Power analysis not runnable → fall back to `underpowered`
     phrasing; the fallback reason is recorded in
-    `schema["pre_trends"]["power_status"]`.
+    `schema["pre_trends"]["power_reason"]` (plain-English explanation;
+    `power_status` carries the enum).
 
   Rationale: always-hedging phrasing under-sells well-designed
   studies; always-confident phrasing over-sells underpowered ones.

tests/test_business_report.py

@@ -1572,6 +1572,102 @@ class Stub:
         assert "beta^{het}_l" in desc
 
 
+class TestAnticipationStripsStrictNoAnticipationClause:
+    """Round-30 P1 CI review on PR #318: ``_apply_anticipation_to_assumption``
+    previously only appended an anticipation clause. Several base
+    descriptions already say "plus no anticipation" or "Also assumes
+    no anticipation", so an anticipation-enabled fit would render
+    self-contradictory prose: the strict clause AND the relaxed one in
+    the same paragraph. The helper now strips the strict phrasing
+    before appending. These regressions cover every anticipation-
+    capable estimator base description that previously carried such
+    wording.
+    """
+
+    _STRICT_PATTERNS = (
+        "plus no anticipation",
+        "Also assumes no anticipation",
+    )
+
+    @staticmethod
+    def _stub(class_name: str, **extras):
+        stub_cls = type(class_name, (), {})
+        stub = stub_cls()
+        stub.overall_att = 1.0
+        stub.overall_se = 0.2
+        stub.overall_p_value = 0.001
+        stub.overall_conf_int = (0.6, 1.4)
+        stub.alpha = 0.05
+        stub.n_obs = 400
+        stub.n_treated = 100
+        stub.n_control = 300
+        stub.survey_metadata = None
+        stub.event_study_effects = None
+        stub.anticipation = 2
+        for k, v in extras.items():
+            setattr(stub, k, v)
+        return stub
+
+    def _assert_no_strict_contract(self, description: str):
+        assert isinstance(description, str) and description
+        for pat in self._STRICT_PATTERNS:
+            assert pat not in description, (
+                f"Anticipation-enabled fit description must not carry "
+                f"the strict phrase {pat!r}. Got: {description!r}"
+            )
+        # Must still say anticipation is allowed (relaxed contract).
+        assert "Anticipation is allowed" in description
+        assert "not strict no-anticipation" in description
+
+    def test_generic_group_time_strips_strict_clause(self):
+        # Generic CS/SA/Imputation/TwoStage/Wooldridge branch.
+        stub = self._stub("CallawaySantAnnaResults")
+        block = BusinessReport(stub, auto_diagnostics=False).to_dict()["assumption"]
+        assert block["no_anticipation"] is False
+        assert block["anticipation_periods"] == 2
+        self._assert_no_strict_contract(block["description"])
+
+    def test_efficient_did_pt_all_strips_strict_clause(self):
+        stub = self._stub("EfficientDiDResults", pt_assumption="all")
+        block = BusinessReport(stub, auto_diagnostics=False).to_dict()["assumption"]
+        self._assert_no_strict_contract(block["description"])
+        # PT-All identifying content should still be present.
+        assert "PT-All" in block["description"]
+
+    def test_efficient_did_pt_post_strips_strict_clause(self):
+        stub = self._stub("EfficientDiDResults", pt_assumption="post")
+        block = BusinessReport(stub, auto_diagnostics=False).to_dict()["assumption"]
+        self._assert_no_strict_contract(block["description"])
+        assert "PT-Post" in block["description"]
+
+    def test_stacked_did_strips_strict_clause(self):
+        stub = self._stub(
+            "StackedDiDResults", clean_control="not_yet_treated"
+        )
+        block = BusinessReport(stub, auto_diagnostics=False).to_dict()["assumption"]
+        self._assert_no_strict_contract(block["description"])
+        # Stacked sub-experiment identifying content preserved.
+        assert "IC1" in block["description"] and "IC2" in block["description"]
+
+    def test_rendered_full_report_has_no_strict_contract_for_anticipation(self):
+        """Integration: the rendered markdown's Identifying Assumption
+        section must also be free of the strict phrase on an
+        anticipation-enabled fit.
+        """
+        stub = self._stub("CallawaySantAnnaResults")
+        md = BusinessReport(stub, auto_diagnostics=False).full_report()
+        assumption_section = md.split("## Identifying Assumption", 1)[1].split(
+            "\n## ", 1
+        )[0]
+        for pat in self._STRICT_PATTERNS:
+            assert pat not in assumption_section, (
+                f"Rendered assumption section must not carry the strict "
+                f"phrase {pat!r} under anticipation > 0. Got: "
+                f"{assumption_section!r}"
+            )
+        assert "Anticipation is allowed" in assumption_section
+
+
 class TestAnticipationAwareAssumptionBlock:
     """Round-17 P1 regression: ``_describe_assumption`` must drop the
     strict "plus no anticipation" language when the fit allows