M17: native window ops (conv-pool training)

Lift window_sum, window_max, window_min, window_product,
window_scatter_max, window_scatter_min off via_binary onto native MLX.
MLX has no direct primitives — each op is composed as mx::pad →
mx::as_strided (sliding-window view) → reduce, mirroring
nn/layers/pooling.py generalised to N-D so Nx's per-axis
window/stride/padding/dilation all lower cleanly. Scatter variants
add argmax-with-last-occurrence-tie-break (mask * arange(K) trick,
since mx::argmax is first-occurrence) → per-axis absolute-index
computation → mx::scatter_add into a mx::full(init_value) buffer →
slice back. Closes the training primitive set: grad(window_max) in Nx
rewrites to window_scatter_max, so every MaxPool backward pass now
stays on MLX instead of round-tripping through BinaryBackend.

Tests: backend_window_test (19 unit — shape × stride × padding ×
dilation × f32/bf16/s32/u8), backend_window_scatter_test (11 —
overlapping windows, tie-break, non-zero init, 1-D/3-D),
grad-equivalence extensions (3 new zoo fns: window_sum,
window_max_pool, window_avg_pool; bf16 equivalence auto-picks-up;
EXLA oracle skips un-regenerated entries via
ExlaGoldenData.has_golden?/1), cnn_curve_test (handwritten 2-conv +
max-pool CNN, 30 steps), mnist_cnn_full_test (:training_full, LeNet
≥97%, observed 1.60 → 0.12 loss over 5 epochs).

Author: ausimian

PLAN.md

@@ -855,6 +855,43 @@ cover the new ops, plus a small-CNN MNIST run in `:training_full`.
 **Exit:** grad-equivalence on window ops green; small-CNN MNIST
 training converges in `:training_full`.
 
+**Shipped.**
+
+- `c_src/ops/pooling.cpp` — six new NIFs. Reductions composed as
+  `mx::pad` → `mx::as_strided` (sliding-window view) → reduce, mirroring
+  `vendor/mlx/python/mlx/nn/layers/pooling.py` generalised to N-D.
+  Scatter variants add argmax-with-last-occurrence-tie-break
+  (`mask * arange(K)` + argmax, since MLX's native argmax is
+  first-occurrence) → per-axis absolute-index computation →
+  `mx::scatter_add` into a `mx::full(init_value)` padded buffer →
+  slice back to the input shape.
+- `Emily.Native`: 6 new NIF stubs
+  (`window_sum`/`max`/`min`/`product`/`scatter_max`/`scatter_min`).
+- `Emily.Backend` (`backend.ex:1101-1225`): `apply_window_reduce/5` and
+  `apply_window_scatter/6` helpers; `:valid`/`:same` padding resolution
+  and dtype-specific identity (0/1/±∞, plus `{:s, _}` / `{:u, _}`
+  min/max) done in Elixir before the NIF.
+- Forward-parity coverage:
+  `test/emily/backend_window_test.exs` (19 unit tests across shape ×
+  stride × padding × dilation × f32/bf16/s32/u8),
+  `test/emily/backend_window_scatter_test.exs` (11 tests including
+  overlapping windows, tie-break, non-zero `init_value`, 1-D/3-D).
+- Grad-equivalence extensions (`test/support/grad_zoo.ex` +
+  `test/emily/grad/grad_equivalence_test.exs`): three new zoo fns —
+  `grad_window_sum`, `grad_window_max_pool` (lands on
+  `window_scatter_max` via Nx's grad rule), and `grad_window_avg_pool`.
+  `bf16_grad_equivalence_test.exs` auto-picks-up the new zoo entries.
+  The EXLA oracle skips un-regenerated zoo entries via
+  `ExlaGoldenData.has_golden?/1` — run `mix run
+  bench/exla_golden_gen.exs` to add window goldens in a follow-up.
+- `test/emily/training/cnn_curve_test.exs` — handwritten 2-conv +
+  max-pool CNN, 30-step SGD, per-step loss trajectory match vs
+  BinaryBackend within rtol 1e-2 (looser than the MLP curve test
+  because the CNN stacks four reductions).
+- `test/emily/training/mnist_cnn_full_test.exs` — `:training_full`
+  LeNet-style Axon CNN on MNIST, ≥ 97% test accuracy. Validated:
+  5-epoch loss 1.60 → 0.12, test accuracy ≥ 97% on a 64-batch run.
+
 ### M18 — Observability & fallback telemetry
 
 Hitting `via_binary` is ~100× slower than native and emits no signal.

RELEASE.md

@@ -8,6 +8,37 @@
 
 ## Added
 
+- M17 — Conv-pool training (native window ops). Lifted `window_sum`,
+  `window_max`, `window_min`, `window_product`, `window_scatter_max`,
+  and `window_scatter_min` off the `via_binary` fallback onto native
+  MLX. No direct MLX primitives exist — each op is composed as
+  `mx::pad` → `mx::as_strided` (sliding-window view) → reduce (for
+  the four reductions) or → argmax-with-last-occurrence-tie-break →
+  `mx::scatter_add` (for the two scatters). Mirrors MLX's own
+  `nn/layers/pooling.py` but generalised to N-D so Nx's per-axis
+  window/stride/padding/dilation all lower cleanly.
+  - **Closes the training primitive set** — Nx rewrites
+    `grad(window_max)` to `window_scatter_max`, so every CNN with
+    MaxPool2d lands on the new scatter path on its backward pass. No
+    more `via_binary` round-trips during CNN training.
+  - **Tie-break** — Nx picks the last-occurrence argmax/min inside a
+    window; MLX's `argmax` is first-occurrence. The scatter path
+    uses a `mask * arange(K)` trick to recover last-occurrence.
+  - **New NIFs** in `c_src/ops/pooling.cpp`: `window_sum`,
+    `window_max`, `window_min`, `window_product`,
+    `window_scatter_max`, `window_scatter_min`. Corresponding
+    stubs in `Emily.Native`; `Emily.Backend` resolves `:valid`/`:same`
+    padding and dtype-specific identity values (0/1/±∞ or integer
+    min/max) in Elixir before dispatch.
+  - **Tests**: `backend_window_test.exs` (19 unit tests —
+    reductions × shape × stride × padding × dilation × f32/bf16/s32/u8),
+    `backend_window_scatter_test.exs` (11 unit tests — overlapping
+    windows + tie-break + non-zero init + 1-D/3-D), grad-equivalence
+    extensions for `window_sum`, `window_max` (max-pool grad),
+    `window_avg` (3 new zoo fns), `cnn_curve_test.exs` (handwritten
+    2-conv + max-pool CNN, 30 steps, per-step loss match), LeNet
+    MNIST canary (`:training_full`, target ≥ 97%).
+
 - M16 — Mixed-precision training. `Emily.MixedPrecision` delivers the
   standard bf16 recipe: `cast_params/2` (downcast f32 → bf16 for the
   forward pass), `accumulate_grad/2` (upcast bf16 grads → f32 for the