fix(python): ship SOTA bindings in release wheels; make parity tests arch-portable

Three coupled defects, all found by building the wheel and running the real
suite on Apple Silicon rather than trusting green CI.

1. THE P6 SOTA BINDINGS NEVER REACHED USERS (release blocker).
   `pip-release.yml`'s cibuildwheel built the DEFAULT feature set, so published
   wheels contained none of aether/mat/meridian. `pip install
   wifi-densepose[aether]` then raised ImportError — and the extra is empty, so
   its own error message ("install the [aether] extra") sent users in a circle.
   A pip extra cannot enable a Rust cargo feature on an already-built wheel, so
   the only way P6 reaches PyPI is to compile it in.

   Fix: the RELEASE build opts in via `MATURIN_PEP517_ARGS="--features sota"`
   (per-platform, since CIBW_ENVIRONMENT_LINUX overrides CIBW_ENVIRONMENT).
   `default = []` in Cargo.toml, the RuView#1387-default-wheel-budget-config
   fix-marker, and the wheel-size-budget job are all left UNTOUCHED — they keep
   guarding the small base compile. Measured published wheel: 1.68 MiB, well
   under the ADR-117 §5.4 5 MiB budget. Proven: built via the exact PEP517 path,
   `import wifi_densepose.aether/mat/meridian` all succeed.

2. THE WHEEL SMOKE TEST COULD NOT SEE #1.
   CIBW_TEST_COMMAND only asserted `hello()` and PRINTED `__build_features__`.
   The one signal that would reveal missing bindings was dumped to stdout and
   ignored, so a featureless wheel published green. It now ASSERTS the p6
   features are present and imports the three modules. Proven red→green: fails
   on the old featureless wheel ("missing SOTA bindings: [...]"), passes on the
   fixed one.

3. THE AETHER PARITY TESTS WERE NOT PORTABLE ACROSS THE WHEEL MATRIX.
   `test_aether.py` and the native `aether_parity.rs`/`aether_weights_parity.rs`
   hashed the raw f32 embedding bytes (SHA-256) against a committed golden. The
   embedding is pure f32 with transcendental ops (ln/sqrt/cos) that are not
   bit-reproducible across CPUs/libm, so the hash only ever matched the one arch
   that generated it. This passed in python-ci (x86) but fails on the aarch64 /
   macOS-arm wheels this same project ships — latent until #1 is fixed and the
   bindings actually load. Every tolerance/behavioral assertion already passed;
   only the two byte-hash tests failed, which is the signature of a non-portable
   golden, not a logic bug.

   Fix: compare to a committed golden VECTOR within tolerance
   (atol=rtol=1e-4 — ~100x cross-arch f32 drift, ~100x under any real algorithm
   change), on both the Python and native sides against the SAME golden. Native
   ≈ golden and binding ≈ golden together prove binding ≈ native, portably.
   `.sha256` goldens replaced by `.json` vectors.

Also: the aether/mat/meridian import shims told users to `pip install
wifi-densepose[<x>]` on a missing feature — an empty extra that cannot help.
Corrected to name the real fix (rebuild with `--features <x>`); message tests
updated to assert the honest message and forbid the misleading one.

Verified on aarch64/macOS: full `python/tests/` suite 227 passed against a wheel
built with the new mechanism; `cargo check --tests --features aether` clean.
The native `.rs` parity tests were converted by inspection and cargo-checked but
not executed — they link against the PyO3 crate and no workflow runs them today
(a pre-existing gap; wiring `cd python && cargo test --features sota` into
python-ci would make the native anchor actually run).

Co-Authored-By: Ruflo & AQE

python/tests/test_aether.py

@@ -1,14 +1,15 @@
 """ADR-185 P1 — AETHER binding tests, incl. the §4.1 bit-for-bit parity gate.
 
-The parity test packs the binding's embedding to little-endian f32 bytes
-and asserts its SHA-256 equals the committed golden produced by the
-native-Rust reference (`tests/aether_parity.rs`). A mismatch is a
+The parity test compares the binding's embedding to a committed golden VECTOR
+produced by the native-Rust reference (`tests/aether_parity.rs`), within a
+numerical tolerance. It is NOT a byte-hash: the embedding is f32 with
+transcendental ops, so exact bytes are not reproducible across the CPU
+architectures this project ships wheels for. A mismatch beyond tolerance is a
 release blocker, not a warning.
 """
 
 from __future__ import annotations
 
-import hashlib
 import json
 import math
 import struct
@@ -21,11 +22,41 @@ from wifi_densepose import aether
 
 GOLDEN = Path(__file__).parent / "golden"
 
+# Cross-architecture f32 parity tolerance. The AETHER embedding is pure f32 with
+# transcendental ops that differ in the last bits across CPUs/libm, so exact
+# byte equality is not portable across the wheels this project builds. 1e-4 is
+# ~100x the observed cross-arch drift on unit-normed values and ~100x smaller
+# than any real algorithm change. Combined atol+rtol so both small and larger
+# components are bounded. (ADR-185 §4.1.)
+PARITY_ATOL = 1e-4
+PARITY_RTOL = 1e-4
+
 
 def load_input() -> list[list[float]]:
     return json.loads((GOLDEN / "aether_input.json").read_text())
 
 
+def assert_embedding_matches_golden(embedding: list[float], golden_name: str) -> None:
+    """Assert `embedding` matches the committed golden vector within tolerance."""
+    golden = json.loads((GOLDEN / golden_name).read_text())
+    assert len(embedding) == len(golden), (
+        f"{golden_name}: length {len(embedding)} != golden {len(golden)}"
+    )
+    worst = max(
+        (abs(a - b), i, a, b)
+        for i, (a, b) in enumerate(zip(embedding, golden))
+        if abs(a - b) > PARITY_ATOL + PARITY_RTOL * abs(b)
+    ) if any(
+        abs(a - b) > PARITY_ATOL + PARITY_RTOL * abs(b)
+        for a, b in zip(embedding, golden)
+    ) else None
+    assert worst is None, (
+        f"{golden_name}: element {worst[1]} diverged from native golden beyond "
+        f"tolerance (got {worst[2]}, golden {worst[3]}, |Δ|={worst[0]:.3e}) — "
+        "a real regression, not cross-arch f32 drift."
+    )
+
+
 def build_extractor() -> aether.EmbeddingExtractor:
     # Must match the native-Rust reference construction exactly.
     cfg = aether.AetherConfig(d_model=64, d_proj=128, temperature=0.07, normalize=True)
@@ -60,16 +91,21 @@ def test_embedding_shape_and_unit_norm() -> None:
     assert abs(norm - 1.0) < 1e-4, f"expected unit-norm embedding, got {norm}"
 
 
-def test_bit_for_bit_parity_with_native_rust() -> None:
-    """The release-blocking §4.1 gate: binding output == native Rust, byte-for-byte."""
+def test_binding_matches_native_golden_within_tolerance() -> None:
+    """The release-blocking §4.1 gate: binding output == native Rust reference.
+
+    Compares to a committed golden VECTOR within a numerical tolerance, not a
+    SHA-256 of the raw f32 bytes. The embedding is pure f32 and uses
+    transcendental ops (ln/sqrt/cos in the Gaussian init), which are NOT
+    bit-reproducible across CPU architectures or libm implementations. A
+    byte-hash therefore only ever matched the one arch that generated it, and
+    failed on every other wheel this project builds (aarch64, macOS-arm). The
+    tolerance below (1e-4) is orders of magnitude larger than cross-arch f32
+    drift yet far tighter than any real algorithm change, which moves
+    unit-normed elements by ~1e-2 or more. See ADR-185 §4.1.
+    """
     emb = build_extractor().embed(load_input())
-    packed = b"".join(struct.pack("<f", x) for x in emb)
-    got = hashlib.sha256(packed).hexdigest()
-    expected = (GOLDEN / "aether_embedding.sha256").read_text().strip()
-    assert got == expected, (
-        "Python binding embedding diverged from the native-Rust golden "
-        f"({got} != {expected}) — PyO3 marshalling is not byte-identical."
-    )
+    assert_embedding_matches_golden(emb, "aether_embedding.json")
 
 
 def test_embedding_is_deterministic() -> None:
@@ -110,11 +146,14 @@ def test_augment_pair_preserves_shape_and_differs() -> None:
     assert differs, "augment_pair should return two distinct views"
 
 
-def test_base_wheel_import_error_message() -> None:
-    # This wheel HAS the extra, so the import succeeds; assert the guard
-    # message is present in source so the base-wheel path stays honest.
+def test_missing_feature_message_names_the_real_fix() -> None:
+    # The guard fires only on a from-source build without the feature. Its
+    # message must name the real fix — rebuild with the feature — and must NOT
+    # tell users to `pip install [aether]`, which is an empty extra that cannot
+    # add compiled code to a built wheel.
     src = (Path(aether.__file__)).read_text()
-    assert "pip install wifi-densepose[aether]" in src
+    assert "--features aether" in src
+    assert "pip install wifi-densepose[aether]" not in src
 
 
 # ─── Weight loading (ADR-185 §13.a) ──────────────────────────────────
@@ -135,13 +174,10 @@ def test_load_weights_is_used_and_matches_native_golden() -> None:
     assert any(abs(a - b) > 1e-6 for a, b in zip(baseline, loaded)), (
         "load_weights had no effect — embedding still equals the random-init baseline"
     )
-    # (2) Bit-identical to the native-Rust reference that loaded the same weights.
-    packed = b"".join(struct.pack("<f", x) for x in loaded)
-    got = hashlib.sha256(packed).hexdigest()
-    expected = (GOLDEN / "aether_loaded_embedding.sha256").read_text().strip()
-    assert got == expected, (
-        f"binding loaded-weights embedding diverged from native golden ({got} != {expected})"
-    )
+    # (2) Matches the native-Rust reference that loaded the same weights, within
+    #     tolerance. See test_binding_matches_native_golden_within_tolerance for
+    #     why this is a tolerance compare and not a byte-hash.
+    assert_embedding_matches_golden(loaded, "aether_loaded_embedding.json")
 
 
 def test_save_then_load_weights_round_trips() -> None: