fep: drop spurious minus in compute_hydration_dg + pin the sign

The composition formula had a spurious leading minus:

    ddg = solv - vac
    dG_hydration_kcalmol = -ddg   # ← bug

Per Hummer-Szabo (1996, J Chem Phys 105:2004), absolute hydration
ΔG is ΔG_solv_annihilate − ΔG_vac_annihilate — no leading minus.
The minus inverted every prediction; the first real sampled run
on an M5 Max (milestone-a-pilot-1, 2026-04-23) reported methane
at -1.85 vs expt +2.00 — exactly the sign flip this line
produced.

Fix: drop the minus. Methane now returns +1.25-+1.28 at smoke
params (expt +2.00; residual 0.75 at undersampled 7x500, will
converge tighter at production sampling).

Regression: added test_methane_hydration_sign_is_positive. Runs
~1-2 min on CPU, asserts ΔG_hyd(methane) > +0.2 kcal/mol. This
is the test that would have caught pilot-1. Existing scaffold
smoke only checked finiteness + vacuum≈0, never sign.

What's NOT in this commit (still open):
  - Polar-compound solvent-leg magnitude overshoot (ethanol
    ~3x high). Documented in BENCHMARKS.md; requires separate
    investigation (interactions between per-λ minimize, softcore
    endpoints, and Interchange PME handoff).
  - No re-run on friend's M5 Max yet. The sign fix alone would
    flip polars the wrong way; need the polar bug resolved
    before a clean FreeSolv-12 gate.

Other FEP smoke suites (scaffold, sampling, binding) all PASS
post-fix.

Author: Rockman6

src/fep/__init__.py

@@ -486,13 +486,22 @@ def compute_hydration_dg(
         result.wall_seconds = time.time() - t0
         return result
 
-    # ΔG_hyd = −(ΔG_solv_decouple − ΔG_vac_decouple). A positive
-    # value means gas → water transfer is unfavourable (hydro-
-    # phobic). For methane the experimental value is +2.0
-    # kcal/mol.
+    # ΔG_hyd = ΔG_solv_ann − ΔG_vac_ann, per Hummer-Szabo (1996,
+    # J Chem Phys 105:2004). The prior version of this line had a
+    # spurious leading minus ("dG_hydration = -ddg") that inverted
+    # every hydration prediction; the first real sampled run on an
+    # M5 Max (milestone-a-pilot-1, 2026-04-23) reported methane at
+    # -1.85 kcal/mol vs expt +2.00 — exactly the sign flip this
+    # minus produces. See BENCHMARKS.md § "Milestone A post-mortem".
+    #
+    # Sampling convention: sample_alchemical_windows returns
+    # Delta_f[K-1, 0] = f[0] - f[K-1] = f_decoupled - f_coupled
+    # (annihilation free energy). For methane: vac ≈ 0 (no intra
+    # nonbondeds), solv ≈ +2 → ΔG_hyd = solv - vac ≈ +2 (matches
+    # FreeSolv expt +2.00).
     import math
     ddg = solv_r.dG_kcalmol - vac_r.dG_kcalmol
-    result.dG_hydration_kcalmol = -ddg
+    result.dG_hydration_kcalmol = ddg
     result.dG_vacuum_decouple_kcalmol = vac_r.dG_kcalmol
     result.dG_solvent_decouple_kcalmol = solv_r.dG_kcalmol
     result.uncertainty_kcalmol = math.sqrt(

tests/fep/test_hydration_dg_smoke.py

@@ -14,7 +14,15 @@
   - the call returns ok=True
   - ΔG_hyd is finite
   - vacuum leg ≈ 0 for methane (physics sanity)
+  - ΔG_hyd SIGN is correct for methane (+, hydrophobic)
   - wall time stays under 3 min
+
+The sign check (test_methane_hydration_sign_is_positive) is load-
+bearing: the M5 Max pilot-1 run returned methane = -1.85 kcal/mol
+because compute_hydration_dg had a spurious minus on the
+composition formula. No test pinned the sign, so the Milestone A
+tag shipped with that bug intact. Without a sign test, a future
+regression could re-introduce the same flip silently.
 """
 
 from __future__ import annotations
@@ -49,15 +57,57 @@ def test_methane_hydration_pipeline_runs():
         "for methane should be ≈ 0; sampling pipeline broken.")
 
 
+def test_methane_hydration_sign_is_positive():
+    """Methane is hydrophobic — ΔG_hyd > 0 (FreeSolv expt: +2.00).
+
+    Pins the sign of compute_hydration_dg's composition formula.
+    This is the test that *would have caught* the Milestone A
+    pilot-1 sign bug (M5 Max returned -1.85 for methane;
+    milestone-a-pilot-1 tag shipped without ever checking sign).
+
+    Runs slightly more sampling than the scaffold smoke so the
+    sign is robust against noise: 7 windows × 500 prod steps ≈
+    1-2 min on CPU. Tolerance is generous (>0.2 kcal/mol) because
+    the true +2.00 converges only at production sampling; we just
+    need the SIGN to be right.
+    """
+    from src.fep import compute_hydration_dg
+    r = compute_hydration_dg(
+        "C", n_windows=7,
+        n_production_steps=500, n_equilibration_steps=100,
+        sample_stride=50, seed=1)
+    print(f"  {r.summary()}")
+    assert r.ok, r.reason
+    assert r.dG_hydration_kcalmol is not None
+    assert math.isfinite(r.dG_hydration_kcalmol)
+    # Gate: methane must be predicted hydrophobic (positive).
+    # Margin 0.2 kcal/mol to avoid flaky near-zero signs.
+    assert r.dG_hydration_kcalmol > 0.2, (
+        f"ΔG_hyd(methane) = {r.dG_hydration_kcalmol:+.3f} "
+        "kcal/mol; methane is hydrophobic, so ΔG_hyd must be "
+        ">+0.2. A negative value indicates the Milestone A sign "
+        "bug has returned (see BENCHMARKS.md § 'Milestone A "
+        "post-mortem'). Fix: check the composition formula in "
+        "compute_hydration_dg.")
+
+
 if __name__ == "__main__":
-    try:
-        test_methane_hydration_pipeline_runs()
-        print("PASS")
-    except AssertionError as e:
-        print(f"FAIL: {e}")
-        sys.exit(1)
-    except Exception as e:
-        import traceback
-        traceback.print_exc()
-        print(f"ERROR: {e}")
-        sys.exit(2)
+    funcs = [
+        test_methane_hydration_pipeline_runs,
+        test_methane_hydration_sign_is_positive,
+    ]
+    fails = []
+    for f in funcs:
+        try:
+            f()
+            print(f"[PASS] {f.__name__}")
+        except AssertionError as e:
+            print(f"[FAIL] {f.__name__}: {e}")
+            fails.append(f.__name__)
+        except Exception as e:
+            import traceback
+            traceback.print_exc()
+            print(f"[ERROR] {f.__name__}: {e}")
+            fails.append(f.__name__)
+    print(f"{len(funcs) - len(fails)}/{len(funcs)} PASS")
+    sys.exit(0 if not fails else 1)