# AOM / Moment Coverage Matrix

Date: 2026-06-06

This file tracks the requested end state: AOM portfolio methods, reusable
winning linear/moment heads, and global preprocessing-selection methods in
`nirs4all-methods`, with CPU and CUDA-build behavior separated.

## Integrated Now

| Surface | User-facing entry | Native ABI | CPU | CUDA build | Status |
|---|---|---:|---:|---:|---|
| AOM logical Python facade | `n4m.aom`, `n4m.aom.available_methods()` | no new ABI | import tested | CUDA-device smoke tested | dedicated AOM import surface re-exporting campaign helpers, screen/refit pool helpers, native sklearn AOM presets and historical AOM portfolio classes while keeping the single `libn4m` runtime and existing top-level imports; inventory metadata identifies global screen/refit, screen/refit pool helpers, selected-winner reuse, chain-grid builders, candidate decode/evaluate helpers, audit/report IO helpers and diversity entries without adding a router, and now includes audit-only `config_options` for chain grids, refit/checkpoint controls, route policy, report serialization and supported CUDA PLS knobs; `benchmarks/cross_binding/aom_moment_cuda_facade_smoke.py` proves the facade aliases the shared runtime and that wide PLS1 AOM chain screens hit the CUDA device-CV route |
| Moment logical Python facade | `n4m.moment`, `n4m.moment.available_methods()` | no new ABI | import tested | CUDA-device smoke tested | dedicated moment import surface re-exporting sufficient-statistics helpers, `sweep_run`, `pls_cross_validate`, direct linear/component heads, direct native sklearn wrappers, `NativeMomentSweepRegressor`, native AOM preprocess/profile/chain sweep functions and wrappers, the AOM/moment fast screen-refit function, the mixed/PLS/Ridge `NativeAOMMoment*ScreenRefitRegressor` presets, the generic `NativeAOMScreenRefitRegressor`, staged winning presets, strict-linear AOM diversity/reuse wrappers (`NativeAOMRidgeBlenderRegressor`, superblocks, chain Ridge-PLS, operator PLS stack, robust HPO, AOM-PLS and POP-PLS), retained-pool/refit helpers, audit/report helpers and `NativeAOMFixedCandidateRegressor` winner reuse without shadowing the historical `n4m.moments` function; inventory metadata identifies sufficient-statistics, screen, PLS CV reference, direct-head, reusable-estimator, native AOM screen, AOM/moment preprocessing-selection, exact-refit, holdout audit, report IO, winner-reuse and backend-planning entries without adding a router, and now includes audit-only `config_options` for row subsets, CV grids, direct-head parameters, native AOM profile/chain controls, AOM chain/refit controls, holdout evaluation, report save/load, fixed-candidate reuse and supported CUDA PLS knobs; `benchmarks/cross_binding/aom_moment_cuda_facade_smoke.py` proves the facade aliases the shared runtime and that wide PLS1 moment screens hit the CUDA device-CV route |
| AOM strict global selector | `n4m.aom_pls` / `n4m.aom_global_select` / `NativeAOMPLSRegressor` (`aom_pop.aom_pls`) | yes | tested | smoke tested | existing catalog method now exposes `input_coefficients` + `intercept` and has ABI-close plus sklearn Python wrappers |
| AOM preprocessing | `n4m.aom_preprocess` / `n4m.aom.aom_preprocess` (`aom_pop.aom_preprocessing`) | yes | tested | existing build path | native operator-bank preprocessing primitive now has ABI-close Python binding, top-level alias, AOM facade inventory entry, catalog binding and CUDA smoke coverage for direct strict-linear identity, degree-1 detrend, Savitzky-Golay smooth/derivative, Norris-Williams, finite difference, Gaussian, Whittaker and FCK hard/soft gating; strict chains and model scoring remain covered by the sweep/campaign operator-moment paths |
| POP-PLS | `n4m.pop_pls` / `n4m.aom_per_component_select` / `NativePOPPLSRegressor` (`aom_pop.pop_pls`) | yes | tested | smoke tested | existing catalog method now exposes `input_coefficients` + `intercept` and has ABI-close plus sklearn Python wrappers |
| AOM robust-HPO strict screen | `n4m.aom_robust_hpo` / `NativeAOMRobustHPORegressor` | yes | tested | smoke tested | compact/wide product screen; compact has 12 chains and wide has 31 strict-linear chains including Gaussian, FCK and Whittaker variants; exports `input_coefficients` and sklearn replay wrapper; `benchmarks/cross_binding/aom_robust_hpo_timing_cuda_smoke.csv` covers both `native_abi` and `native_sklearn` wrapper replay rows on `build/cuda-on` across 3 shapes (6 rows), with `prediction_replay_max_abs_error <= 1e-10` for all `native_sklearn` rows |
| AOM configurable strict sweep | `n4m.aom_sweep_run` | yes | tested | smoke tested | configurable compact/wide chain bank plus Ridge/PLS grids |
| AOM user-defined strict chain sweep | `n4m.aom_chain_sweep_run` | yes | tested | smoke tested | arbitrary caller-provided strict-linear chains plus Ridge/PLS grids |
| AOM fixed selected-chain final fit | `n4m.aom_chain_fixed_fit_run`, `NativeAOMFixedCandidateRegressor(fit_mode="final_only")` (`aom_pop.aom_chain_fixed_fit`) | yes | tested | smoke tested | catalogued individual winner reuse surface; fits one already-verified strict-linear chain/head/parameter on all rows without running CV, folds coefficients back to original input space, and is used by `NativeAOMScreenRefitRegressor` after exact-CV refit so reusable model construction no longer repays CV |
| AOM campaign chain descriptors | `chain_offsets`, `op_kinds`, `param_offsets`, `chain_params`, `n4m.decode_aom_chains`, `n4m.aom_candidate_table` | yes-backed | tested | build path tested | every AOM sweep candidate row can be mapped back to the exact strict-linear preprocessing chain without dataset-name routing |
| AOM candidate route provenance | `candidate_routes`, `score_route_id`, `score_route`, `by_score_route` summaries | yes-backed | tested | smoke tested | every AOM sweep/campaign candidate can be tied to materialized, dense, banded or structured moment scoring without changing the stable candidate score table shape |
| AOM chunked strict-linear campaign helper | `n4m.build_aom_strict_chain_grid`, `n4m.aom_chain_score_campaign`, `n4m.aom_screen_refit_candidate_pool`, `n4m.aom_chain_screen_refit_campaign`, `n4m.aom_refit_candidates`, `n4m.aom_refit_execution_plan`, `n4m.aom_evaluate_candidates`, `n4m.aom_candidate_rank_diagnostics`, `n4m.aom_candidate_route_summary`, `n4m.aom_save_candidate_report`, `n4m.aom_load_candidate_report`, `n4m.aom_candidate_operator_summary` (`aom_pop.aom_chain_screen_refit`) | Python-backed | tested | smoke tested | deterministic compact/wide/lab strict-linear chain grids, including SavGol, Norris-Williams, finite-difference, Gaussian, FCK and Whittaker variants, plus chunked score-only global, per-head and per-score-route top-k aggregation from full chunk score tables, prefix-aware chunk packing via `chain_ordering="prefix"` to increase native moment-prefix cache reuse without changing scores or original chain ids, optional `split_head_scoring="auto"` for mixed Ridge/PLS chunks so the PLS subcall is PLS-only and can hit the native batched exact/proxy PLS path while merged rows keep the same `(chain_id, head, param)` scores, optional `cuda_pls_parallel_folds=True` scheduling for bounded stream-parallel exact PLS1 moment fold jobs, `cuda_pls_many_batched=True` opt-in for the experimental tiled/strided-batched many-job CUDA path with precedence over parallel-fold scheduling unless `N4M_CUDA_PLS_MANY_LEGACY=1`, and `cuda_pls_min_device_features=<positive int>` threshold control on CUDA builds, checkpoint/resume and incremental `max_chunks_per_run` execution for long screens, source-free retained-pool audit via `aom_screen_refit_candidate_pool`, one-call screen -> exact-CV refit campaign reports for retained candidates after proxy/score-only screens, optional `refit_per_head_top_k` inclusion so mixed Ridge/PLS screens can exact-refit per-head winners in addition to the global top rows, grouped exact-CV refit scoring for rows sharing a chain/head, signature-batched exact-CV scoring for retained chains sharing a head/parameter set, explicit union-parameter batching with scored/extra candidate counters, plan-driven `execution_mode="auto"` with bounded extra-score budget, and refit execution planning without touching `X/y`, native batch exact-CV PLS score-only scoring across PLS-only operator-moment chains before the Python campaign top-k aggregation, normalized throughput/route metrics including moment-prefix cache hit fraction, split-head launch counters, CUDA-parallel fold counters and CUDA many-batched batch/job counters, source-free per-head CPU/CUDA backend recommendations from `n_samples`, `n_features`, `head`, CUDA availability and the explicit PLS CUDA threshold, operator/head/route candidate summaries plus explicit route-coverage summaries by head and chain, explicit CV-vs-holdout candidate evaluation/rank-recall diagnostics over `aom_chain_sweep_run`, and JSON/JSONL/CSV candidate report export/reload |
| Staged strict-chain cartesian campaign | `n4m.aom_staged_chain_campaign`, `NativeAOMStagedChainCampaignRegressor`, `NativeAOMSavgolFocusRegressor`, `NativeAOMStrictFamilyLiteRegressor` (`aom_pop.aom_staged_chain_campaign`) | Python-backed over native helpers | tested | CUDA-device smoke tested | catalogued global staged preprocessing-selection method over `aom_pop.aom_chain_screen_refit`; staged compact/wide/lab, focused `savgol_focus` / `strict_family_focus` or custom strict-linear score-only screens over Ridge/PLS/mixed heads; cross-stage deduplication keeps global + per-head retained candidates, exact-CV refits the retained union once, can train-CV-select model config `scale_x_values` such as `[False, True]`, attaches preprocessing-impact and screen-vs-refit rank diagnostics, and can optionally run a held-out audit that is never used for production selection; reports expose `selection_uses_test_set=False`, selected model-config metadata, staged checkpoint/resume counters, `n_remaining_stage_chunks_total`, `n_screen_split_head_chunks`, `n_screen_chunk_score_calls`, Ridge screen counters and PLS CPU/CUDA route counters, all aggregated across model-config grids when present; the real-cohort runner and reusable sklearn estimators default mixed-head campaigns to score-preserving `split_head_scoring="auto"` while the low-level helper keeps `off` for explicit timing comparisons; the generic sklearn estimator omits `X_audit` / `y_audit`, selects by train `refit_cv_rmse`, then fits the chosen row through final-only fixed-candidate reuse with the selected model config; `NativeAOMSavgolFocusRegressor` is the winning fast SavGol-focused reusable preset, while `NativeAOMStrictFamilyLiteRegressor` is the cost-safe strict-family audit preset with a small retained refit budget; `benchmarks/cross_binding/aom_staged_chain_campaign_timing_cuda_smoke.csv` proves the staged PLS path can run through `build/cuda-on` with device exact-CV counters (`n_pls_moment_cuda_device_cv_fits=9`, host CV fits `0`) on one visible GPU, `benchmarks/cross_binding/aom_staged_real_cohort_diesel_pls_many_batched_cuda_smoke.csv` proves the real held-out runner on ABI `1.22.0` can persist train-only PLS exact-CV many-batched routing (`selection_uses_test_set=False`, screen/refit CUDA device jobs `12/6`, many-batched jobs `12/6`, host and parallel-fold jobs `0`), and `benchmarks/cross_binding/aom_moment_cuda_facade_smoke.json` proves the sklearn staged estimator, both staged presets and the PLS exact screen/refit preset alias both facades, reports CUDA device refit counters (`savgol_focus_estimator=8`, `strict_family_lite_estimator=4`, `pls_exact_screen_refit_estimator` screen/refit `8/4`, host CV fits `0`), and includes a mixed Ridge+PLS default-smoke proving split-head auto (`1` split chunk, `2` score calls), PLS screen CUDA routing (`8/0`) and Ridge screen counters (`8/1/8`); per-dataset diagnostics JSON from `--diagnostics-dir` now includes a compact `audit` section (offline only, `audit_only=True`) with the production-selected candidate's test-set rank/score (`selected_cv`), the test-rank oracle (`oracle`) and CV-vs-test Spearman correlation; `benchmarks/cross_binding/summarize_aom_rank_audit.py` reads a directory of such diagnostics and writes a CSV + Markdown comparing selected train-CV rank/score vs audit/test best rank/score; existing compact10 diagnostics artifacts pre-date this feature and lack the `audit` section — rerun campaign to populate |
| Native sklearn sweep/direct estimators | `NativeRidgeRegressor`, `NativePLSRegressor`, `NativePCRRegressor`, `NativeCPPLSRegressor`, `NativeContinuumRegressionRegressor`, `NativeECRRegressor`, `NativeMomentSweepRegressor`, `NativeAOMSweepRegressor`, `NativeAOMChainSweepRegressor`, `NativeAOMScreenRefitRegressor`, `NativeAOMMomentScreenRefitRegressor`, `NativeAOMMomentPLSScreenRefitRegressor`, `NativeAOMMomentPLSExactScreenRefitRegressor`, `NativeAOMMomentRidgeScreenRefitRegressor`, `NativeAOMStagedChainCampaignRegressor`, `NativeAOMSavgolFocusRegressor`, `NativeAOMStrictFamilyLiteRegressor`, `NativeAOMFixedCandidateRegressor` | yes/Python-backed | tested | build path tested | reusable sklearn-style wrappers over native direct heads, sweep MethodResults and campaign helpers; direct wrappers replay native Ridge/PLS/PCR/CPPLS/continuum/ECR predictions from input-space coefficients and reconstructed intercepts; AOM wrappers use exact `input_coefficients` folded into original feature space; preconfigured native AOM wrappers expose `profile_name`, expected compact/wide bank size and selected-head labels where applicable; screen-refit estimators run proxy/score-only campaign plus exact-CV verification before fitting the reusable candidate through final-only fixed fit and expose separate `screen`, `refit`, staged and `final_*` diagnostics; the mixed, PLS GCV, PLS exact-CV, Ridge, staged, SavGol-focused and strict-family-lite staged presets expose the common end-user workflows while keeping custom chain grids, checkpointing and exact-refit budgets configurable where appropriate; fixed candidates can be built from explicit rows or global/per-head/refit campaign winners |
| AOM route policy switch | `moment_policy="auto"`, `"materialized"` or `"force_moments"` on `n4m.aom_sweep_run` / `n4m.aom_chain_sweep_run` | yes | tested | smoke tested | explicit route control; materialized forces the legacy strict-linear chain screen, while force_moments rejects any candidate-screen fallback outside operator moments |
| AOM score-only screen output | `score_only=True` on `n4m.aom_sweep_run` / `n4m.aom_chain_sweep_run` | yes | tested | build path tested | returns candidate scores, route counters, selected ids and fold ids without final selected-chain refit outputs; useful for large preprocessing ranking campaigns |
| AOM PLS1 GCV proxy screen | `pls_score_mode="gcv_proxy"` with `score_only=True`, `n_pls_gcv_proxy_candidates`, `n_pls_gcv_proxy_fits`, `score_metric="pls_gcv_proxy_rmse"` | yes | tested | smoke tested | explicit moment-only first-pass PLS screen that scores all-sample transformed moments with a deterministic PLS1 GCV RMSE proxy; PLS-only operator-moment campaigns batch eligible chains through one internal native proxy-scoring dispatch and skip held-out moment transforms; it is not exact fold CV and must be followed by exact-CV/holdout verification of retained rows |
| PLS/Ridge screen fit-cost audit | `n_ridge_moment_candidates`, `n_ridge_dual_materialized_candidates`, `n_ridge_moment_cv_fits`, `n_ridge_dual_materialized_cv_fits`, `n_ridge_dual_cross_cv_fits`, `n_ridge_moment_score_batch_calls`, `n_ridge_moment_score_batch_jobs`, `n_ridge_moment_final_fits`, `n_ridge_dual_materialized_final_fits`, `n_pls_moment_cv_fits`, `n_pls_moment_host_cv_fits`, `n_pls_moment_cuda_device_cv_fits`, `n_pls_moment_cuda_parallel_fold_batches`, `n_pls_moment_cuda_parallel_fold_jobs`, `n_pls_materialized_cv_fits`, `n_pls_gcv_proxy_fits`, `n_pls_moment_final_fits`, `n_pls_moment_host_final_fits`, `n_pls_moment_cuda_device_final_fits`, `n_pls_materialized_final_fits`, `ridge_cv_fits_per_chain`, `ridge_cv_fits_per_candidate`, `pls_cv_fits_per_chain`, `pls_cv_fits_per_candidate`, `pls_gcv_proxy_fits_per_chain`, `pls_gcv_proxy_fits_per_candidate`, `chains_per_second`, `candidates_per_second`, `projected_200k_chains_seconds`, `n_refit_scored_candidates`, `n_refit_extra_scored_candidates`, `n_refit_global_candidates`, `n_refit_per_head_candidates`, `n_refit_per_head_extra_candidates`, `n_refit_union_candidates`, `bench_aom_screen_refit_scaling.py`, `bench_aom_sweep_timing.py`, `bench_moment_sweep_timing.py` | yes-backed | tested | smoke tested | exposes how many fold-local/final Ridge and PLS fits and explicit proxy fits the current sweep/campaign actually pays, split by moment vs materialized/proxy route, by host vs CUDA-device PLS1 moment execution, and by bounded CUDA stream-parallel exact fold scheduling; score-only moment sweeps avoid full `X/y` copies and Ridge moment score-only uses held-out moments for SSE; exact AOM Ridge-only and PLS-only score-only screens batch all eligible operator-moment chains into one internal native scoring dispatch while preserving exact fold CV scores, and GCV proxy PLS-only screens batch eligible chains while skipping held-out moment transforms; the exact/proxy batch counters are covered by internal tests, Ridge batch scoring parallelizes flattened chain/fold/lambda jobs when `N4M_WITH_OPENMP=ON`, and exact PLS batch scoring parallelizes per-chain held-out SSE/result aggregation in OpenMP builds after shared prefix fits are computed; CUDA PLS1 moment component calls reuse a thread-local device workspace across successive default-path calls to remove repeated allocation churn before a true fused IKPLS grinder exists; `cuda_pls_parallel_folds=True` can run independent exact PLS1 moment jobs in bounded stream/cuBLAS batches on one GPU and reports batches/jobs without changing scores; `cuda_pls_many_batched=True` explicitly selects the existing experimental tiled/strided-batched CUDA many-job route while preserving scores and default-off behavior; `cuda_pls_min_device_features` keeps the default 1024-feature guard but lets benchmark runs explicitly test medium-width PLS device routing; the screen/refit scaling benchmark varies `refit_top_k`, supports PLS, Ridge and mixed Ridge/PLS (`--head pls` / `--head ridge` / `--head mixed`), emits per-head retention counters for `--refit-per-head-top-k`, `--split-head-scoring`, `--cuda-pls-parallel-folds`, `--cuda-pls-many-batched`, `--cuda-pls-min-device-features`, and emits throughput plus 200k-chain projections, `individual` vs `grouped_score` vs `batched_score` vs `union_batched_score` exact-CV refit timings, planned-vs-observed group/scored/extra counters, and reusable final-only fit timing/counters; the main AOM sweep timing CSVs expose `--cuda-pls-parallel-folds`, `--cuda-pls-many-batched` and `--cuda-pls-min-device-features` for one-GPU CUDA device-route smokes and include `native_aom_chain_fixed_fit_pls`, `native_aom_chain_fixed_fit_ridge`, and `native_aom_chain_sweep_pls_exact_score_only` and `native_aom_chain_sweep_ridge_exact_score_only` rows to isolate winner reuse and exact score-only grinder cost, so batched IKPLS/fused CUDA work and Ridge lambda regrouping have measurable baselines |
| AOM Ridge/PLS1 operator-moment scoring | `n4m.aom_sweep_run`, `n4m.aom_chain_sweep_run` with Ridge candidates and compatible single-target PLS1 candidates in dense, banded, or structured strict-linear regimes | no new ABI | tested | tested | exact chain operators applied to raw moments; dense transforms are guarded, identity/SavGol/Norris/finite/Gaussian/FCK use a banded descriptor up to `p <= 256` for Ridge and `p <= 1024` for single-target NIPALS PLS1, `detrend_poly` uses a structured low-rank projection route, and Whittaker uses a structured pentadiagonal solve route; repeated strict-linear prefixes are cached for bounded medium-width operator-moment grids and exposed via cache hit/miss counters; CPU `auto` uses materialized dual Ridge when `p > n_train` and materialized PLS when `min_train < 4p`, while CUDA `auto` keeps the moment route; selected chain materialized once for predictions |
| Live CPU/CUDA moment crossover | `n4m.moment_screen_backend_recommendation`, `bench_moment_gpu_crossover.py`, `moment_gpu_crossover.csv`, `moment_gpu_crossover.md` | benchmark/Python | tested | live timed | launches separate CPU and CUDA Python processes against the rebuilt libs, times score-only Ridge/PLS `sweep_run` on matched synthetic shapes, records route counters plus `speedup_vs_cpu`, `speedup_vs_cuda_default`, `cuda_pls_profile` and `recommended_backend`, and can render a compact Markdown decision table; Python helper exposes the measured crossover as a source-free launch-planning rule using only `n_samples`, `n_features`, `head`, CUDA availability and the explicit PLS CUDA knobs; for PLS it also reports whether the CUDA component loop, exact-CV fold workspace and optional many-batched route are expected to run under the requested threshold; `--compare-cuda-pls-many-batched` runs the default and many-batched CUDA profiles in one CSV for controlled one-GPU comparison; current one-GPU ABI 1.22.0 comparison keeps CPU recommended for the measured small/medium PLS shapes and recommends CUDA default for PLS at `256x1024`, with PLS rows using `device_cv=5` when the device threshold is forced low for timing |
| AOM robust-HPO fold-local Python | `AOMRobustHPORegressor`, `AOMRobustHPOCompact`, `AOMRobustHPOWide` | no | tested | Python CPU reference | stateful-chain reference/preset layer |
| AOM portfolio policy/gates | `AOMStructuralPolicy`, `AOMTrueBankEndpointPortfolio`, `AOMMidPEndpointStack`, `AOMEndpointMarginStabilityGate`, `AOMFallbackBlendGate` | no | tested | Python CPU reference | source-free reference layer |
| AOM-Ridge blender | `n4m.aom_ridge_blender`, `NativeAOMRidgeBlenderRegressor`, `AOMRidgeBlender` | yes for native function | tested | smoke tested for native function and native sklearn wrapper; flexible Python estimator is CPU reference | native compact/wide strict-linear Ridge OOF simplex blend now exports replayable `input_coefficients`; wide has 31 strict-linear chains including Gaussian, FCK and Whittaker variants; `benchmarks/cross_binding/aom_ridge_blender_timing_cuda_smoke.csv` now includes `native_aom_ridge_blender_sklearn` rows with `prediction_replay_max_abs_error <= 1e-10`; Python estimator remains flexible explicit-candidate reference |
| AOM-Ridge global | `n4m.aom_ridge_global`, `NativeAOMRidgeGlobalRegressor` (`aom_pop.ridge_global`) | Python-backed over native `aom_chain_sweep_run` | tested | CUDA-build smoke tested, not fused GPU yet | catalogued donor-style strict-linear AOM Ridge global selector; converts strict single operators into one-op chains, selects one operator plus one positive Ridge alpha by native CV, and returns folded `input_coefficients` plus `intercept`; intentionally excludes donor branch-global reference-dependent, MKL/kernel and nonlinear modes; `benchmarks/cross_binding/aom_ridge_global_timing_cuda_smoke.csv` includes function + sklearn rows on `build/cuda-on` with `ridge_backend=native_aom_chain_sweep` and replay error at numerical-noise level |
| AOM-Ridge superblock | `n4m.aom_ridge_superblock`, `NativeAOMRidgeSuperblockRegressor` (`aom_pop.ridge_superblock`) | Python-backed over native `aom_preprocess` + native `ridge` | tested | CUDA-build smoke tested, not fused GPU yet | catalogued donor-style strict-linear AOM Ridge superblock reference over the moment-compatible single-operator bank; concatenates strict operator views, selects/fits Ridge alpha by fold-local CV or fixed alpha through the native Ridge binding, applies train-fold centering/block RMS scaling to validation folds, and folds the final superblock coefficients back into `input_coefficients` plus `intercept` for exact replay; intentionally excludes branch/global reference-dependent, MKL/kernel and nonlinear AOM Ridge modes; `benchmarks/cross_binding/aom_ridge_superblock_timing_cuda_smoke.csv` includes function + sklearn rows on `build/cuda-on` with `ridge_backend=native` and replay error at numerical-noise level |
| AOM-Ridge active superblock | `n4m.aom_ridge_active_superblock`, `NativeAOMRidgeActiveSuperblockRegressor` (`aom_pop.ridge_active_superblock`) | Python-backed over native `aom_preprocess` + native `ridge` | tested | CUDA-build smoke tested, not fused GPU yet | catalogued donor-style strict-linear AOM Ridge active-superblock reference; screens a train-only active operator subset inside every alpha-CV fold using response signatures from the actual `aom_preprocess` outputs, screens once on full calibration rows for the final fit, then folds the active superblock coefficients back into `input_coefficients` plus `intercept`; intentionally excludes branch/global reference-dependent, MKL/kernel and nonlinear AOM Ridge modes; `benchmarks/cross_binding/aom_ridge_active_superblock_timing_cuda_smoke.csv` includes function + sklearn rows on `build/cuda-on` with `ridge_backend=native` and replay error at numerical-noise level |
| AOM-Ridge MKL-light superblock | `n4m.aom_ridge_mkl_superblock`, `NativeAOMRidgeMKLSuperblockRegressor` (`aom_pop.ridge_mkl_superblock`) | Python-backed over native `aom_preprocess` + native `ridge` | tested | CUDA-build smoke tested, not fused GPU yet | catalogued donor-style strict-linear AOM Ridge MKL-light reference; learns non-negative train-only KTA weights over strict operator blocks inside every alpha-CV fold, refits weights on full calibration rows, fits native Ridge on the equivalent weighted superblock, and folds final coefficients back into `input_coefficients` plus `intercept`; intentionally excludes branch/global reference-dependent preprocessing, row-reference-dependent preprocessing, nonlinear kernels and nonlinear AOM Ridge modes; `benchmarks/cross_binding/aom_ridge_mkl_superblock_timing_cuda_smoke.csv` includes function + sklearn rows on `build/cuda-on` with `mkl_mode=alignment`, `ridge_backend=native` and replay error at numerical-noise level |
| AOM-PLS superblock | `n4m.aom_pls_superblock`, `NativeAOMPLSSuperblockRegressor` (`aom_pop.aom_pls_superblock`) | Python-backed over native `aom_preprocess` + native `pls` | tested | CUDA-device smoke tested, not fused GPU yet | catalogued donor-style strict-linear AOM-PLS superblock reference; concatenates strict operator views, selects the PLS component count by train CV, fits through the native PLS binding and folds final superblock coefficients back into `input_coefficients` plus `intercept`; intentionally excludes row-reference-dependent preprocessing, MKL/kernel, nonlinear lifts and dataset/source routing; `benchmarks/cross_binding/aom_pls_superblock_timing_cuda_smoke.csv` includes function + sklearn rows on `build/cuda-on` with `pls_backend=native`, CUDA device PLS final-route counters and replay error at numerical-noise level |
| AOM Ridge-PLS superblock | `n4m.aom_ridge_pls_superblock`, `NativeAOMRidgePLSSuperblockRegressor` (`aom_pop.aom_ridge_pls_superblock`) | Python-backed over native `aom_preprocess` + native `ridge_pls` | tested | CUDA-build smoke tested, not fused GPU yet | catalogued donor-style strict-linear AOM Ridge-PLS superblock reference; concatenates strict operator views, selects the PLS component count and Ridge-PLS penalty by train CV, fits through the native `ridge_pls` binding, and folds final superblock coefficients back into `input_coefficients` plus `intercept`; intentionally excludes row-reference-dependent preprocessing, MKL/kernel, nonlinear lifts and dataset/source routing; `benchmarks/cross_binding/aom_ridge_pls_superblock_timing_cuda_smoke.csv` includes function + sklearn rows on `build/cuda-on` with `ridge_pls_backend=native` and replay error at numerical-noise level |
| AOM chain Ridge-PLS | `n4m.aom_chain_ridge_pls`, `NativeAOMChainRidgePLSRegressor` (`aom_pop.aom_chain_ridge_pls`) | Python-backed over native strict AOM operators + native `ridge_pls` | tested | CUDA-build smoke tested, not fused GPU yet | catalogued donor-style strict/raw-base single-chain Ridge-PLS selector; applies each strict-linear AOM chain sequentially, selects chain, PLS component count and Ridge-PLS penalty by train CV, fits through native `ridge_pls`, and folds the selected chain coefficients back into `input_coefficients` plus `intercept`; intentionally excludes SNV, MSC, EMSC, OSC, row-reference-dependent preprocessing, nonlinear lifts, kernels and dataset/source routing; `benchmarks/cross_binding/aom_chain_ridge_pls_timing_cuda_smoke.csv` includes function + sklearn rows on `build/cuda-on` with `selection_mode=chain_ridge_pls`, `ridge_pls_backend=native` and replay error at numerical-noise level |
| AOM operator PLS stack | `n4m.aom_operator_pls_stack`, `NativeAOMOperatorPLSStackRegressor`, `AOMOperatorPLSStack` | yes for native function | tested | smoke tested for native function and native sklearn wrapper; flexible Python estimator is CPU reference | native compact/wide strict-operator PLS1 score stack with Ridge head now exports folded input-space coefficients; wide has 31 strict-linear operators including Gaussian, FCK and Whittaker variants; `benchmarks/cross_binding/aom_operator_pls_stack_timing_cuda_smoke.csv` now includes `native_aom_operator_pls_stack_sklearn` rows with `prediction_replay_max_abs_error <= 1e-10`; Python estimator remains flexible custom-operator/gated reference |
| Row-additive moment substrate | `n4m.moments`, `n4m.moments_train_from_heldout` | yes | tested | tested | raw/centered `X'X`, `X'Y`, `Y'Y` plus fold subtraction |
| Moment Ridge/PLS sweep | `n4m.sweep_run` | yes | tested | tested | exact Ridge CV; `p <= n_train` via moments, `p > n_train` via reused dual kernels with optional cross-kernel scoring; wide dual Gram/cross/prediction/coefficient products now use `linalg::gemm`, which routes to cuBLAS in CUDA builds; compatible single-target NIPALS/regression PLS1 grids score from train/held-out moments, with CPU/BLAS linalg kernels, a scalar host loop in CUDA builds for medium widths, and a device-resident cuBLAS component loop plus reused fold workspace for very wide `p >= 1024` PLS1 moment CV by default; `cuda_pls_min_device_features` can lower or raise that threshold for controlled timing campaigns; `cuda_pls_parallel_folds=True` optionally schedules independent exact PLS1 moment jobs in bounded CUDA stream batches and reports batches/jobs; `cuda_pls_many_batched=True` selects the experimental tiled/strided-batched many-design CUDA path before parallel-fold scheduling unless `N4M_CUDA_PLS_MANY_LEGACY=1` forces the non-batched route; materialized prefix fallback remains for other PLS regimes |
| Direct Ridge head | `n4m.ridge`, `NativeRidgeRegressor` | yes | smoke tested | smoke tested | reusable linear/moment head with direct function and sklearn wrapper; `bench_direct_moment_heads_timing.py` records native vs wrapper fit+predict timing and replay error |
| Direct PLS head | `n4m.pls`, `NativePLSRegressor` | Python-backed over native sweep | smoke tested | CUDA-device smoke tested | reusable moment PLS head over `n4m_sweep_run`; fixed `n_components` or train-CV `pls_components` grid, replayable input-space coefficients/intercept, route diagnostics and CUDA PLS knobs shared with the sweep path; `direct_moment_heads_timing_cuda_smoke.csv` forces `cuda_pls_min_device_features=1` and `cuda_pls_parallel_folds=True` and covers all 9 direct heads with function + sklearn replay rows across 3 shapes (54 rows total); PLS rows report device CV fits equal to total PLS moment CV fits and host CV fits at zero |
| Direct PCR head | `n4m.pcr`, `NativePCRRegressor` | yes | smoke tested | smoke tested | reusable PCR/SVD head with direct `n4m_pcr_fit` MethodResult ABI, original-input coefficients, predictions, centering/scaling metadata and sklearn replay wrapper |
| CPPLS head | `n4m.cppls`, `NativeCPPLSRegressor` | yes | smoke tested | smoke tested | reusable linear/moment head with direct function and sklearn wrapper; `bench_direct_moment_heads_timing.py` records native vs wrapper fit+predict timing and replay error |
| Continuum regression head | `n4m.continuum_regression`, `NativeContinuumRegressionRegressor` | yes | smoke tested | smoke tested | reusable linear/moment head with direct function and sklearn wrapper; `bench_direct_moment_heads_timing.py` records native vs wrapper fit+predict timing and replay error |
| ECR head | `n4m.ecr`, `NativeECRRegressor` | yes | smoke tested | smoke tested | reusable linear/moment head with direct function and sklearn wrapper; `bench_direct_moment_heads_timing.py` records native vs wrapper fit+predict timing and replay error |
| Weighted PLS head | `n4m.weighted_pls`, `NativeWeightedPLSRegressor` | yes | smoke tested | smoke tested | reusable direct head; sqrt(w)-prescaled weighted PLS route; exports replayable `coefficients`, `predictions`, `x_mean` and `y_mean`; sklearn wrapper reconstructs the intercept from the native means; `bench_direct_moment_heads_timing.py` records native and wrapper timing across three shapes |
| Robust PLS head | `n4m.robust_pls`, `NativeRobustPLSRegressor` | yes | smoke tested | smoke tested | reusable direct head; Huber IRLS over weighted PLS fits; Python helper default `max_irls_iter=5`; exports replayable `coefficients`, `predictions`, `x_mean` and `y_mean`; sklearn wrapper reconstructs the intercept from the native means; `bench_direct_moment_heads_timing.py` records native and wrapper timing across three shapes |
| Ridge-augmented PLS head | `n4m.ridge_pls`, `NativeRidgePLSRegressor` | yes | smoke tested | smoke tested | reusable direct head; ridge-regularised augmented SIMPLS route; exports replayable `coefficients`, `predictions`, `x_mean` and `y_mean`; sklearn wrapper reconstructs the intercept from the native means; `bench_direct_moment_heads_timing.py` records native and wrapper timing across three shapes |
| Moment-model OOF stack | `NativeMomentStackRegressor` (`models.ensembles.moment_stack`) | Python-backed over native heads | smoke tested | CUDA-device smoke tested for PLS base | train-only OOF Ridge meta-model over native Ridge/PLS/PCR/continuum/ECR/CPPLS predictions; the PLS base now reuses the direct `NativePLSRegressor` rather than a separate generic sweep wrapper; no transformed-spectrum stacking, nonlinear lift or dataset-name routing; fitted objects expose `base_oof_diagnostics_`, `base_final_diagnostics_` and aggregate PLS route counters for OOF and final base fits, so CPU/GPU routing can be audited without retaining validation data; `benchmarks/cross_binding/moment_stack_timing_cuda_smoke.csv` proves a PLS-only stack on `build/cuda-on` used CUDA for both OOF and final PLS base sweeps (`n_base_oof_pls_moment_cuda_device_cv_fits=16`, host `0`; final device CV fits `4`, host `0`) |

## Not Yet Integrated

Grid note: `iter_aom_strict_chain_grid` now exposes the same deterministic
compact/wide/lab strict-linear bank as `build_aom_strict_chain_grid`, but with
stable chain ids, `start`/`stop` slicing and optional chunks for incremental
campaign launchers. It is an inventory/runtime helper only and does not change
candidate scores.

Benchmark note: campaign timing scripts now expose
`--backend-min-cuda-product` alongside the CUDA PLS knobs, so the source-free
CPU/CUDA launch recommendation used in reports can be reproduced or overridden
from scripted runs without changing candidate scores.

Timing artifact note: the strict AOM portfolio now has committed CPU
`build/dev-release` timing pairs for the previously CUDA-only smoke artifacts:
`aom_preprocess_timing.csv`, `aom_ridge_superblock_timing.csv`,
`aom_ridge_active_superblock_timing.csv`,
`aom_ridge_mkl_superblock_timing.csv`, `aom_pls_superblock_timing.csv`,
`aom_ridge_pls_superblock_timing.csv`, `aom_chain_ridge_pls_timing.csv`,
`aom_ridge_global_timing.csv` and `aom_staged_chain_campaign_timing.csv`.
Release guards assert those CPU rows use the host/dev-release route while the
existing CUDA smokes keep the one-GPU `build/cuda-on` route. The strict AOM
portfolio timing artifacts for preprocess, selectors, diversity wrappers,
superblocks, robust HPO and staged campaign are refreshed against ABI 1.22.0
for both CPU/dev-release and CUDA/cuda-on evidence. The moment sweep/stack
timing artifacts, AOM sweep timing artifacts, and live
`moment_gpu_crossover.csv`/`.md` CPU-vs-one-GPU evidence are also refreshed
against ABI 1.22.0 and guarded by release tests for ABI, route counters and
CPU/CUDA library paths.

CUDA many-batched artifact note: the optional exact PLS many-job route is now
covered at multiple public surfaces.
`moment_sweep_timing_cuda_many_batched_smoke.csv` pins the direct moment sweep
route, `aom_sweep_timing_cuda_many_batched_smoke.csv` pins the AOM sweep route,
`aom_screen_refit_scaling_cuda_many_batched_smoke.csv` pins exact-CV refit
after a global screen, and
`aom_staged_real_cohort_diesel_pls_many_batched_cuda_smoke.csv` proves the real
held-out benchmark runner persists ABI `1.22.0`, train-only selection and
screen/refit many-batched route counters. These artifacts prove current route
telemetry and exact-CV compatibility, not the deferred fused cartesian/IKPLS
CUDA engine.

| Surface | Required shape before completion | Reason it is still open |
|---|---|---|
| Fused/batched IKPLS mode for `n4m_sweep_run` | native batch/sweep ABI for device/host-fused free component CV over many PLS variants | ABI 1.22.0 exposes `n4m_pls_cross_validate` as an exact PLS-only reference surface and tests equivalence to the PLS branch of `n4m_sweep_run`; `bench_pls_cross_validate_timing.py` now pins CPU/CUDA smoke artifacts and route counters for that reference hook; current ABI v1 already scores compatible single-target PLS1 grids from moment cross-products, i.e. an IKPLS-style sufficient-statistics route, and falls back to one max-component materialized fit per fold for other PLS regimes, but it is still not fused across many chains/folds/candidates |
| full arbitrary-chain AOM moment screen | strict-linear operator descriptors applying `A*S` and `A*C*A'` across Ridge/PLS and wide regimes without materializing transformed `X` | Banded descriptors now cover local linear operators, structured low-rank projection covers `detrend_poly`, and structured pentadiagonal solves cover Whittaker; multi-target/non-NIPALS PLS, very wide Ridge solves and fused batched GPU execution still fall back or remain open |
| CUDA fused sweep | grouped GEMM/operator kernels and backend parity vs CPU fp64 | CUDA build works; fused moment/sweep kernels are not shipped |
| WASM/WebGPU sweep | optional lite backends | design-only |

## Invariants

- `models.pls.kernel` / `kernel_pls` (non-linear kernel PLS) is **intentionally
  excluded** from the AOM/moment porting scope. The moment substrate operates on
  linear operators applied to the raw feature matrix; non-linear kernel
  functions (`K = XX'`) do not fit the strict-linear AOM/operator-moment
  architecture and would require a separate kernel-moment substrate. Kernel PLS
  remains in the catalog but outside this porting track.
- Deployable selection must not route by dataset name, source name, database
  name, dataset id, or equivalent identity fields.
- Python portfolio metadata is audit-only; tests assert metadata changes do not
  change selected route or predictions.
- `n4m.aom_ridge_blender` uses outer-fold OOF predictions to solve a
  non-negative simplex blend and is now catalogued as `aom_pop.ridge_blender`.
  The native surface is restricted to compact/wide strict-linear AOM chains and
  positive Ridge lambdas. The native result folds the weighted candidate Ridge
  coefficients back into `input_coefficients` plus `intercept`, and
  `NativeAOMRidgeBlenderRegressor` predicts from that state. `AOMRidgeBlender`
  remains the Python reference layer for explicit custom estimators. Neither
  surface is a fused GPU blender yet.
- `n4m.aom_ridge_superblock` is deliberately narrower than donor
  `AOMRidgeRegressor`: it ports the strict-linear superblock idea only. It does
  not include `branch_global`, MKL/kernel routing, row-reference-dependent
  preprocessing, nonlinear lifts or any dataset/source-name routing. It is a
  Python orchestration over native `aom_preprocess` and native `ridge`; it is
  catalogued and timed, but still not a fused GPU superblock grinder.
- `n4m.aom_ridge_active_superblock` ports the donor strict active-superblock
  idea without donor-private covariance helpers: active scores are defined on
  native `aom_preprocess` outputs, screened fold-locally during alpha CV and
  then re-screened on full calibration data for the final fit. It is an
  active-pruning model, not a screen-recall guarantee for arbitrary 200k-chain
  preprocessing campaigns.
- `n4m.aom_ridge_global` ports the donor strict global Ridge idea: select one
  strict operator and one Ridge alpha by train CV, then expose a reusable final
  model. It is intentionally narrower than the existing broad
  `NativeAOMMomentRidgeScreenRefitRegressor` campaign preset.
- `n4m.aom_pls_superblock` ports the donor strict AOM-PLS superblock idea:
  concatenate fixed strict-linear operator views and fit a PLS head whose
  coefficients are folded back to raw input space. It is not `soft` operator
  weighting, active PLS pruning, MKL/kernel weighting, or a fused GPU
  many-operator grinder.
- `n4m.aom_chain_ridge_pls` ports the donor strict/raw-base single-chain
  Ridge-PLS idea: each candidate is a sequential strict-linear chain, one PLS
  component count and one Ridge-PLS penalty scored by train CV. It deliberately
  excludes SNV, MSC, EMSC, OSC, row-reference-dependent preprocessing,
  nonlinear lifts, kernels and any dataset/source routing.
- `n4m.aom_operator_pls_stack` is catalogued as
  `aom_pop.operator_pls_stack`. It is single-target PLS1, uses fixed
  strict-linear compact/wide operator banks, and exposes the final score stack
  plus Ridge head. It also folds the selected strict-linear stack into
  `input_coefficients` plus `input_intercept`, so
  `NativeAOMOperatorPLSStackRegressor` can predict on new spectra without
  rebuilding stack features. `AOMOperatorPLSStack` remains the Python reference
  layer for custom operator matrices and optional baseline admission gates.
- The native `aom_robust_hpo` method is a compact/wide product screen. It now
  folds the selected strict-linear chain coefficients back into
  `input_coefficients`, so `X @ input_coefficients + intercept` exactly
  replays the native predictions and `NativeAOMRobustHPORegressor` can predict
  on new spectra. This is not a claim of 200k-chain fused GPU acceleration.
- `n4m.aom_sweep_run` is the configurable native strict-linear AOM sweep over
  fixed compact/wide banks. It allows custom Ridge/PLS grids and explicit folds,
  while `n4m.aom_chain_sweep_run` accepts arbitrary caller-provided
  strict-linear chains through a flat descriptor. Both expose
  `moment_policy="materialized"` to force the legacy materialized route for
  timing comparisons or production route guarding, and
  `moment_policy="force_moments"` / `"moments_only"` to fail fast whenever a
  candidate screen would need a materialized fallback. The selected chain may
  still be materialized once after scoring to populate public predictions and
  folded coefficients. Both now export `input_coefficients`, folded into the
  original feature space, so the native sklearn wrappers can predict on new
  `X` without Python-side chain replay.
- Both AOM sweep surfaces expose `score_only=True` for large ranking passes.
  It keeps the candidate table, selected ids, route counters and fold ids, but
  skips selected-model output buffers and final refits. The result also keeps
  the flat chain descriptor (`chain_offsets`, `op_kinds`, `param_offsets`,
  `chain_params`), so broad campaigns can decode the exact preprocessing chain
  behind each `chain_id` through `n4m.decode_aom_chains` or
  `n4m.aom_candidate_table`. This is an output/cost control, not a new scoring
  rule; materialized candidate-screen routes still pay their fold-local
  scoring fits because they are not batched IKPLS yet.
- `n4m.build_aom_strict_chain_grid` and `n4m.aom_chain_score_campaign` are
  Python campaign helpers over the same native strict-linear ABI. They provide
  deterministic compact/wide/lab grids, custom cartesian family templates,
  chunked `score_only=True` execution, global top-k aggregation, per-head
  top-k aggregation for mixed Ridge/PLS audits, per-score-route top-k
  aggregation for materialized/dense/banded/structured route audits, and
  optional checkpoint/resume. `pls_score_mode="gcv_proxy"` is fingerprinted
  separately from exact-CV campaigns and keeps proxy rows labelled through
  `score_metric`.
  Checkpoints are guarded by a fingerprint of the chain grid, folds,
  hyperparameters and `X/y` contents, so an interrupted long screen can resume
  without mixing incompatible candidate scores. Loaded top-k rows are filtered
  to the chunks actually present in a checkpoint before new chunks are
  appended, which keeps manual partial checkpoints coherent for global,
  per-head and per-route top-k lists. The optional
  `max_chunks_per_run` budget lets schedulers advance a campaign in bounded
  increments; reports expose `complete`, `n_remaining_chunks` and
  `processed_chunks_this_run`. They do not add a new selection heuristic and
  do not route by dataset identity.
- `split_head_scoring` controls how mixed Ridge/PLS chunks are scored. A single
  mixed native call uses *none* of the batched head-homogeneous fast paths, so
  `"off"` keeps `n_ridge_moment_score_batch_calls`,
  `n_pls_moment_score_batch_calls` and `n_pls_gcv_proxy_batch_calls` at `0`.
  `"auto"` scores each mixed chunk as a Ridge-only call plus a PLS-only call and
  merges the rows, which turns on the Ridge moment batch (`C*L*K` jobs for `C`
  chains, `L` ridge lambdas, `K` folds) and the PLS exact moment batch
  (`pls_score_mode="cv"`, `C*K` jobs) or GCV-proxy batch
  (`pls_score_mode="gcv_proxy"`, `C` jobs). The merge is score-preserving: the
  retained `(chain_id, head, param)` candidate scores and the selected winner
  are identical to `"off"`, so it changes launch shape and route counters only,
  never scores, ranking or predictions. The low-level campaign helpers
  (`aom_chain_score_campaign`, `aom_chain_screen_refit_campaign`) default to
  `"off"`; the sklearn screen/refit estimators (`NativeAOMScreenRefitRegressor`
  and the `NativeAOMMomentScreenRefitRegressor` mixed preset) default to
  `"auto"`. For single-head screens `"auto"` is inert and `n_split_head_chunks`
  stays `0`.
- `n4m.aom_moment_screen_refit_campaign` is the functional fast-profile
  counterpart to `NativeAOMMomentScreenRefitRegressor` and is exposed from both
  `n4m.aom` and `n4m.moment`. It wraps `aom_chain_screen_refit_campaign` with
  strict moment routes, prefix chunk ordering, split-head mixed scoring, PLS
  GCV-proxy screening, exact-CV refit and `refit_execution="auto"`. It adds
  `campaign_preset="moment_fast_screen_refit"` to the combined report but does
  not change the legacy defaults of the lower-level campaign helpers.
- Campaign and chunk reports expose normalized performance and route metrics
  (`candidates_per_second`, `ms_per_candidate`, route fractions, etc.) derived
  from native counters. These fields are for CPU/GPU audit and run planning;
  they do not affect candidate scores or ranking.
- `NativeAOMFixedCandidateRegressor.from_candidate(row)` is the reusable
  bridge from a decoded campaign row to a fitted model. `from_campaign(report,
  head=None|"ridge"|"pls", rank=0)` selects the global or per-head campaign
  winner directly before delegating to the same fixed-candidate path. It refits
  exactly that chain/head/parameter through `aom_chain_sweep_run` and predicts
  from folded input-space coefficients.
- `n4m.aom_evaluate_candidates` refits decoded top-k rows on an explicit train
  split and scores them on a caller-provided eval split. It reports
  `cv_rank`, `eval_rank` and `rank_delta` for CV-vs-holdout analysis, but it
  does not change the native fit or route selection.
- `n4m.aom_candidate_rank_diagnostics` summarizes screen-vs-holdout rank
  agreement from evaluated rows or reloaded reports. It reports rank
  correlation, rank drift and top-k overlap/recall. It is an audit tool for
  screen recall, not a selection rule.
- `n4m.aom_candidate_report_records` and `n4m.aom_save_candidate_report`
  serialize campaign/eval candidate rows for offline comparison and replay.
  They preserve decoded chains, add a CSV-friendly `chain_json`, and drop
  prediction arrays by default. They do not introduce a ranking heuristic or
  any dataset-identity route.
- `n4m.aom_load_candidate_report` reads JSON/JSONL/CSV candidate reports back
  into refittable rows. CSV rows restore `chain` from `chain_json`, so saved
  campaign winners can be passed directly to
  `NativeAOMFixedCandidateRegressor.from_candidate`.
- `n4m.aom_candidate_operator_summary` groups scored candidate rows by head,
  preprocessing operator, operator/head pair and chain length. It is an
  inspection aid for pruning or expanding future grids; it does not alter
  scores, top-k ordering or route selection.
- `n4m.aom_candidate_preprocessing_impact` adds stage/option/position impact
  summaries over the same scored rows, including improvement versus an identity
  baseline when such a row is present. It is an analysis surface only and does
  not introduce dataset-identity routing or a new selection rule.
- AOM sweep route counters are split by scoring route and model head:
  `n_ridge_operator_moment_candidates`, `n_pls_operator_moment_candidates`,
  `n_ridge_materialized_candidates`, and `n_pls_materialized_candidates`.
  This makes broad campaigns auditable without inferring route provenance from
  candidate table rows.
- AOM sweep result rows also include `candidate_routes`, with route codes
  `0=materialized`, `1=dense_operator_moment`,
  `2=banded_operator_moment`, and `3=structured_operator_moment`. Python
  decoded candidate rows expose `score_route_id` and `score_route`, and
  operator summaries include `by_score_route`. These fields are diagnostics
  only and do not change candidate scores or rank order.
- PLS sweep fit counters are split by scoring route and by CV/final phase:
  `n_pls_moment_cv_fits`, `n_pls_materialized_cv_fits`,
  `n_pls_moment_final_fits`, and `n_pls_materialized_final_fits`. Campaign
  reports also expose `pls_cv_fits_per_chain` and
  `pls_cv_fits_per_candidate`. These fields are diagnostics only; they do not
  affect scores, ranking, route policy or dataset selection.
- `n4m_moments_*` is now a reusable raw/centered sufficient-statistics layer;
  `n4m_sweep_run` uses moment fold subtraction where it is efficient,
  precomputed dual Ridge and optional held-out/train cross-kernel scoring when
  `p > n_train`, and train/held-out moment scoring for compatible
  single-target NIPALS/regression PLS1 component grids. The wide dual Ridge
  train Gram, held-out cross-kernel, held-out prediction and coefficient
  reconstruction products use the shared `linalg::gemm` dispatch, so CUDA
  builds execute those products through cuBLAS. Compatible PLS1 moment-prefix
  dense products use `linalg` in CPU/BLAS builds, but keep the scalar host-side
  path in CUDA builds because the current cuBLAS dispatch copies each
  micro-kernel host/device and benchmarked slower; this is an explicit guard
  until a device-resident batched IKPLS workspace exists. Other PLS regimes
  keep materialized prefix scoring with coefficient-prefix reuse across
  component counts.
- The CUDA PLS many-job dispatcher has an experimental opt-in tiled path
  (`N4M_CUDA_PLS_MANY_BATCHED=1`) that uses strided-batched cuBLAS for the
  component products plus a native CUDA sign-normalization kernel, preserves
  exact scores, and falls back to the legacy sequential-many workspace path.
  Broader timings still do not justify making it the default. The production
  gap is now the remaining device-resident scalar glue and a fused
  IKPLS-style cartesian screen.
- AOM Ridge candidate rows with `p <= n_train` transform strict-linear chain
  operators into moment space and score held-out SSE from moments, including
  inside mixed Ridge+PLS sweeps. Dense medium-wide Ridge grids use this exact
  path when all lambdas are strictly positive and `p <= 48`; local linear
  banded operators extend the route to `p <= 256` for Ridge in normal routing,
  to `p <= 512` for strict Ridge screens under
  `moment_policy="force_moments"`, and to `p <= 1024` for compatible
  single-target NIPALS PLS1. `detrend_poly` chains use an exact structured
  low-rank projection transform and Whittaker chains use the exact structured
  pentadiagonal solve for `(I + lambda D2'D2)^-1`; both can compose with the
  local banded operators. CPU `auto` routes Ridge `p > n_train` rows
  through the exact materialized dual-Ridge scorer and PLS rows with
  `min_train < 4p` through the exact materialized PLS prefix scorer; CUDA
  `auto` keeps the operator-moment route in those cells. Feature caps and
  backend route choices are compute-route guards, not scoring heuristics.
- `moment_policy="force_moments"` is the strict native screen mode: it accepts
  only chains/heads whose candidate scores are computed through operator
  moments and returns `UNSUPPORTED` instead of silently leaving the moment
  substrate. This does not change the post-selection materialization used to
  expose predictions and `input_coefficients`.
- The full moment-engine goal remains open until batched IKPLS, operator
  descriptors for the remaining regimes, and fused CUDA sweep/parity evidence
  exist.