@@ -227,7 +227,20 @@ def fit(
                 f"Dose must be time-invariant. Units with varying dose: {bad_units[:5]}"
             )
 
-        # Normalize first_treat: inf → 0
+        # Normalize first_treat: inf → 0 (R-style never-treated encoding). Count
+        # rows recategorized so users can see how many units just crossed from
+        # "treated at some point" to "never treated" — silent recategorization
+        # here would shift the control composition (axis-E silent coercion).
+        inf_mask = np.isinf(df[first_treat].values)
+        n_inf_first_treat = int(inf_mask.sum())
+        if n_inf_first_treat > 0:
+            warnings.warn(
+                f"{n_inf_first_treat} row(s) have inf in '{first_treat}'; "
+                f"treating the corresponding units as never-treated. Pass an "
+                f"explicit never-treated marker (0) if this is not intended.",
+                UserWarning,
+                stacklevel=2,
+            )
         df[first_treat] = df[first_treat].replace([np.inf, float("inf")], 0)
 
         # Drop units with positive first_treat but zero dose (R convention)
 
@@ -925,7 +925,23 @@ def _compute_outcome_changes(
         data_sorted = data.sort_values([unit, time])
         data_sorted["_outcome_change"] = data_sorted.groupby(unit)[outcome].diff()
 
-        # Remove NaN from first period of each unit
+        # Remove NaN from first period of each unit. The first period per unit
+        # has no prior observation to diff against, so n_units drops are
+        # expected. Anything beyond that is a silent side-effect of gaps or
+        # NaN outcomes — surface the excess via warning (axis-E drop counter).
+        n_units_observed = int(data_sorted[unit].nunique())
+        n_dropped = int(data_sorted["_outcome_change"].isna().sum())
+        n_unexpected_drops = max(0, n_dropped - n_units_observed)
+        if n_unexpected_drops > 0:
+            warnings.warn(
+                f"check_parallel_trends dropped {n_dropped} row(s) with NaN "
+                f"first-differences; {n_units_observed} are the expected "
+                f"first-period-per-unit drops, and {n_unexpected_drops} came "
+                f"from gaps or NaN outcomes. Parallel-trend statistics are "
+                f"computed on the remaining rows.",
+                UserWarning,
+                stacklevel=3,
+            )
         changes_data = data_sorted.dropna(subset=["_outcome_change"])
 
         treated_changes = changes_data[changes_data[treatment_group] == 1]["_outcome_change"].values
 
@@ -13,6 +13,7 @@
 
 from __future__ import annotations
 
+import warnings
 from typing import Any, Dict, List, Optional, Tuple
 
 import numpy as np
@@ -128,7 +129,19 @@ def _filter_sample(
     (see _build_interaction_matrix).
     """
     df = data.copy()
-    # Normalise never-treated: fill NaN cohort with 0
+    # Normalise never-treated: fill NaN cohort with 0. Report the row count so
+    # callers can see how many rows were recategorized as never-treated — a
+    # silent recategorization here would quietly move units between the
+    # treated and control sides of the estimator (axis-E silent coercion).
+    n_nan_cohort = int(df[cohort].isna().sum())
+    if n_nan_cohort > 0:
+        warnings.warn(
+            f"{n_nan_cohort} row(s) have NaN cohort values; filling with 0 "
+            f"and treating the corresponding units as never-treated. Pass "
+            f"an explicit never-treated marker (0) if this is not intended.",
+            UserWarning,
+            stacklevel=3,
+        )
     df[cohort] = df[cohort].fillna(0)
 
     treated_mask = df[cohort] > 0
@@ -396,6 +409,18 @@ def fit(
             ``NotImplementedError``.
         """
         df = data.copy()
+        # See `_filter_sample` for the analogous warning; fit() does its own
+        # fillna earlier in the pipeline so we warn here too to cover the
+        # direct-fit path.
+        n_nan_cohort = int(df[cohort].isna().sum())
+        if n_nan_cohort > 0:
+            warnings.warn(
+                f"{n_nan_cohort} row(s) have NaN cohort values; filling with 0 "
+                f"and treating the corresponding units as never-treated. Pass "
+                f"an explicit never-treated marker (0) if this is not intended.",
+                UserWarning,
+                stacklevel=2,
+            )
         df[cohort] = df[cohort].fillna(0)
 
         # 0a. Validate cohort is time-invariant within unit
 
@@ -720,6 +720,7 @@ See `docs/methodology/continuous-did.md` Section 4 for full details.
 - [ ] Lowest-dose-as-control (Remark 3.1)
 - [x] Survey design support (Phase 3): weighted B-spline OLS, TSL on influence functions; bootstrap+survey supported (Phase 6)
 - **Note:** ContinuousDiD bootstrap with survey weights supported (Phase 6) via PSU-level multiplier weights
+- **Note:** The R-style convention of coding never-treated units as `first_treat=inf` is still accepted and normalized to `first_treat=0` internally, but the estimator now emits a `UserWarning` reporting the row count so the silent recategorization is surfaced (axis-E silent coercion under the Phase 2 audit). Pass `0` directly to avoid the warning.
 
 ---
 
@@ -1303,6 +1304,7 @@ The saturated ETWFE regression includes:
 The interaction coefficient `δ_{g,t}` identifies `ATT(g, t)` under parallel trends.
 - **Note:** OLS path uses iterative alternating-projection within-transformation (uniform weights) for exact FE absorption on both balanced and unbalanced panels. One-pass demeaning (`y - ȳ_i - ȳ_t + ȳ`) is only exact for balanced panels.
 - **Note:** The weighted within-transformation (`utils.within_transform` with `weights`) is invoked on every WooldridgeDiD fit (survey weights when provided, `np.ones` otherwise) and emits a `UserWarning` on non-convergence per the shared convention documented under *Absorbed Fixed Effects with Survey Weights*.
+- **Note:** NaN values in the `cohort` column are filled with 0 (treated as never-treated), both in `_filter_sample` and in `fit()`. This recategorization now emits a `UserWarning` reporting the affected row count so it is no longer silent (axis-E silent coercion under the Phase 2 audit). Pass `0` directly for never-treated units to avoid the warning.
 
 *Nonlinear extensions (Wooldridge 2023):*
 
 
@@ -641,16 +641,40 @@ def test_few_treated_units(self):
         assert isinstance(results, ContinuousDiDResults)
 
     def test_inf_first_treat_normalization(self):
-        """first_treat=inf should be treated as never-treated."""
+        """first_treat=inf should be treated as never-treated, and the caller
+        must receive a UserWarning reporting the affected row count so the
+        recategorization is not silent (axis-E counter)."""
         data = generate_continuous_did_data(n_units=50, n_periods=3, seed=42)
         data["first_treat"] = data["first_treat"].astype(float)
-        data.loc[data["first_treat"] == 0, "first_treat"] = np.inf
+        inf_mask = data["first_treat"] == 0
+        n_inf_rows = int(inf_mask.sum())
+        data.loc[inf_mask, "first_treat"] = np.inf
         est = ContinuousDiD()
-        results = est.fit(
-            data, "outcome", "unit", "period", "first_treat", "dose"
-        )
+
+        with pytest.warns(
+            UserWarning,
+            match=rf"{n_inf_rows} row\(s\) have inf in 'first_treat'",
+        ):
+            results = est.fit(
+                data, "outcome", "unit", "period", "first_treat", "dose"
+            )
         assert results.n_control_units > 0
 
+    def test_no_inf_first_treat_no_warning(self):
+        """No inf rows in first_treat — no recategorization warning."""
+        import warnings
+
+        data = generate_continuous_did_data(n_units=50, n_periods=3, seed=42)
+        data["first_treat"] = data["first_treat"].astype(float)
+        est = ContinuousDiD()
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            est.fit(data, "outcome", "unit", "period", "first_treat", "dose")
+
+        inf_warnings = [x for x in w if "inf in 'first_treat'" in str(x.message)]
+        assert inf_warnings == []
+
     def test_custom_dvals(self):
         data = generate_continuous_did_data(n_units=100, n_periods=3, seed=42)
         custom_grid = np.array([1.0, 2.0, 3.0])
 
@@ -827,6 +827,57 @@ def test_changes_reflect_trend(self):
         np.testing.assert_array_almost_equal(treated_changes, 2.0, decimal=5)
         np.testing.assert_array_almost_equal(control_changes, 2.0, decimal=5)
 
+    def test_silent_on_balanced_panel(self):
+        """Balanced panel: only first-period-per-unit drops, no warning."""
+        import warnings
+
+        rng = np.random.default_rng(0)
+        rows = []
+        for unit in range(10):
+            treated = int(unit >= 5)
+            for t in range(1, 5):
+                rows.append({
+                    "unit": unit, "period": t,
+                    "treated": treated, "outcome": rng.normal(),
+                })
+        df = pd.DataFrame(rows)
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            _compute_outcome_changes(
+                df, outcome="outcome", time="period",
+                treatment_group="treated", unit="unit",
+            )
+
+        drop_warnings = [
+            x for x in w if "check_parallel_trends dropped" in str(x.message)
+        ]
+        assert drop_warnings == []
+
+    def test_warns_on_nan_outcomes_with_excess_drop_count(self):
+        """Extra NaN-outcome rows beyond first-period drops must surface via
+        a UserWarning reporting the excess count (axis-E drop counter)."""
+        rng = np.random.default_rng(0)
+        rows = []
+        for unit in range(10):
+            treated = int(unit >= 5)
+            for t in range(1, 5):
+                rows.append({
+                    "unit": unit, "period": t,
+                    "treated": treated, "outcome": rng.normal(),
+                })
+        df = pd.DataFrame(rows)
+        df.loc[[5, 12, 22], "outcome"] = np.nan
+
+        with pytest.warns(
+            UserWarning,
+            match=r"check_parallel_trends dropped \d+ row\(s\).*first-period-per-unit",
+        ):
+            _compute_outcome_changes(
+                df, outcome="outcome", time="period",
+                treatment_group="treated", unit="unit",
+            )
+
 
 # =============================================================================
 # Tests for check_parallel_trends_robust
 
@@ -1593,3 +1593,50 @@ def test_survey_aggregate_and_summary(self, survey_panel):
         s = r.summary()
         assert "Survey Design" in s
         assert "pweight" in s
+
+
+class TestCohortNaNWarning:
+    """Axis-E: silent recategorization of NaN cohort rows as never-treated."""
+
+    @staticmethod
+    def _make_panel_with_nan_cohort():
+        rows = []
+        for unit in range(10):
+            cohort_val = np.nan if unit < 2 else 0.0
+            for t in range(1, 5):
+                rows.append({
+                    "unit": unit, "time": t, "cohort": cohort_val,
+                    "y": unit + t + np.random.default_rng(unit).normal(0, 0.1),
+                })
+        return pd.DataFrame(rows)
+
+    def test_fit_warns_on_nan_cohort_with_count(self):
+        df = self._make_panel_with_nan_cohort()
+        est = WooldridgeDiD(method="ols")
+        with pytest.warns(UserWarning, match=r"8 row\(s\) have NaN cohort values"):
+            try:
+                est.fit(df, outcome="y", unit="unit", time="time", cohort="cohort")
+            except Exception:
+                pass
+
+    def test_fit_silent_on_clean_cohort(self):
+        import warnings
+        df = self._make_panel_with_nan_cohort()
+        df["cohort"] = df["cohort"].fillna(0)
+        est = WooldridgeDiD(method="ols")
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            try:
+                est.fit(df, outcome="y", unit="unit", time="time", cohort="cohort")
+            except Exception:
+                pass
+        nan_warnings = [x for x in w if "NaN cohort values" in str(x.message)]
+        assert nan_warnings == []
+
+    def test_select_sample_helper_warns(self):
+        df = self._make_panel_with_nan_cohort()
+        with pytest.warns(UserWarning, match=r"8 row\(s\) have NaN cohort values"):
+            _filter_sample(
+                df, unit="unit", time="time", cohort="cohort",
+                control_group="never_treated", anticipation=0,
+            )