# Tests allowed to exceed the default lane's time budget.
#
# Read by scripts/report_test_durations.py in CI (.github/workflows/ci.yml).
# One pytest node id per line, then " # " and the reason. The budget, from
# docs/developer_guide/testing_standards.md:
#
#   up to 1 s   fine
#   1-5 s       watch list; optimise when you are in the file
#   over 5 s    mark @pytest.mark.slow (still runs in slow-tests.yml:
#               scheduled 3x a week on main only; on a release branch
#               only when dispatched by hand), make it much faster, or
#               keep it here with "kept: <why it must run on every push>"
#
# An unlisted test over 5 s gets a warning on the run; over 20 s it fails the
# job. The 4x gap is runner noise: the same test varies 1.7x between runs at
# the median, 3x at the 90th percentile.
#
# Every entry is "kept: <why>". The tests that were already over 5 s when
# the gate arrived (2026-09-24) have all been marked slow, sped up, or kept
# that way; add an entry only with the reason the test must run on every push.

tests/core/test_coupling_diagnostics_leave_the_state_alone.py::test_diagnostics_leave_an_accelerated_group_bit_identical[ift-gauss-seidel-aitken-mixed] # kept: the per-push case of the bit-identity claim under an accelerator (the acceleration="none" cells cannot see a rewrite that only an accelerator's extra carry triggers), which only a bit-for-bit comparison on every jaxlib sees; each ift cell compiles the spectral and gradient-bound machinery once (~6 s cold, nearly all XLA compile)
tests/core/test_coupling_diagnostics_leave_the_state_alone.py::test_diagnostics_leave_an_accelerated_group_bit_identical[ift-jacobi-iqn-imvj3-l2] # kept: the per-push case of the bit-identity claim under an accelerator (the acceleration="none" cells cannot see a rewrite that only an accelerator's extra carry triggers), which only a bit-for-bit comparison on every jaxlib sees; each ift cell compiles the spectral and gradient-bound machinery once (~6 s cold, nearly all XLA compile)
tests/core/test_coupling_diagnostics_leave_the_state_alone.py::test_diagnostics_leave_the_returned_state_bit_identical[gauss-seidel-interface-ift] # kept: diagnostics=True must leave the returned state bit-identical, a claim a compiler rewrite can break and only a bit-for-bit comparison on every jaxlib sees; each ift cell compiles the spectral and gradient-bound machinery once (~6 s cold, nearly all XLA compile)
tests/core/test_coupling_diagnostics_leave_the_state_alone.py::test_diagnostics_leave_the_returned_state_bit_identical[jacobi-interface-ift] # kept: diagnostics=True must leave the returned state bit-identical, a claim a compiler rewrite can break and only a bit-for-bit comparison on every jaxlib sees; each ift cell compiles the spectral and gradient-bound machinery once (~6 s cold, nearly all XLA compile)
tests/core/test_coupling_diagnostics_leave_the_state_alone.py::test_diagnostics_leave_the_returned_state_bit_identical[jacobi-l2-ift] # kept: diagnostics=True must leave the returned state bit-identical, a claim a compiler rewrite can break and only a bit-for-bit comparison on every jaxlib sees; each ift cell compiles the spectral and gradient-bound machinery once (~6 s cold, nearly all XLA compile)
tests/core/test_coupling_diagnostics_leave_the_state_alone.py::test_diagnostics_leave_the_returned_state_bit_identical[jacobi-mixed-ift] # kept: diagnostics=True must leave the returned state bit-identical, a claim a compiler rewrite can break and only a bit-for-bit comparison on every jaxlib sees; each ift cell compiles the spectral and gradient-bound machinery once (~6 s cold, nearly all XLA compile)
tests/core/test_coupling_fixture_invariants.py::test_every_l2_configuration_reaches_the_same_fixed_point[heterogeneous-2000] # kept: the per-push witness that every accelerator lands on the same fixed point on a group with four decades of scale (the shape that hid a 20.6% error), now that the generated-graph property is slow-marked; six configurations, each a compile of its own (12-17 s cold)
tests/core/test_coupling_solver_equivalence.py::test_a_converged_multirate_group_returns_one_state_from_either_solver # kept: the only per-push check that ift and fori return one state for a subcycled, waveform-relaxed group at the norm's float32 resolution; it pays for the multirate pair of graphs (~7 s cold, mostly tracing) that the residual-resolution test and two class-sweep cells then reuse
tests/nodes/adaptive/test_wavelet_node.py::test_eager_jit_and_graph_select_the_same_set_where_a_mirror_symmetry_ties_residuals[periodic-2d] # kept: the first test in its file to build a 2-D four-level wavelet node; the ~5 s of eager compiles it pays are reused by the theta sweep after it, so marking it slow only moves them (measured locally: the sweep goes from 5.4 s to 10.9 s)
tests/property/test_coupling_convergence_at_every_field_scale.py::test_a_small_field_is_not_dropped_merely_for_being_small # kept: the per-push field-scale convergence property now that its 36-configuration sibling is slow-marked; compiles once per norm (three graphs, was one per example), 3-5 s cold, over 5 s only on a slow runner
tests/property/test_coupling_error_bound.py::test_converged_implies_the_state_is_within_tolerance_of_the_fixed_point # kept: the invariant the 0.4.0 convergence criterion exists for (converged=True puts the state within tolerance of an independently re-solved fixed point), stated over generated graphs; the graph is the draw, so every example compiles its own and nothing can be shared (80-100 s cold); the example in tests/core/test_coupling_error_bound.py cannot rule out a configuration nobody built
tests/security/test_zmq_transport_auth.py::TestWorkerClientFailsFastOnAMismatch::test_a_worker_without_curve_does_not_hang_on_a_curve_coordinator # kept: its 4-5 s is the 3 s deadline it proves a CURVE-mismatched worker honours, plus the coordinator's 1 s poll on shutdown; a shorter deadline would loosen the overshoot bound it checks, and it is the only test that such a worker fails rather than hangs
tests/compliance/test_gate_scripts.py::TestAnomalyGateFailsClosedOnEvidence::test_deleting_a_shipped_entry_fails # kept: one whole run of the anomaly gate on a copy of the shipped registry with this one defect seeded (about 9 s on a workstation, 19 to 21 s on a runner, and it grows with the registry: 253 entries, 1712 references verified); the registry is edited in nearly every pull request, and this is the per-push check that the gate fails closed on it
tests/compliance/test_gate_scripts.py::TestAnomalyGateFailsClosedOnEvidence::test_stripping_a_shipped_resolved_entrys_evidence_fails # kept: one whole run of the anomaly gate on a copy of the shipped registry with this one defect seeded (about 9 s on a workstation, 19 to 21 s on a runner, and it grows with the registry: 253 entries, 1712 references verified); the registry is edited in nearly every pull request, and this is the per-push check that the gate fails closed on it
tests/compliance/test_gate_scripts.py::TestAPartialResolutionStatesWhatIsLeft::test_deleting_a_shipped_partial_resolutions_residual_risk_fails # kept: one whole run of the anomaly gate on a copy of the shipped registry with this one defect seeded (about 9 s on a workstation, 19 to 21 s on a runner, and it grows with the registry: 253 entries, 1712 references verified); the registry is edited in nearly every pull request, and this is the per-push check that the gate fails closed on it
tests/compliance/test_gate_scripts.py::TestAnomalyGateChecksWhatAReferenceIs::test_the_audits_duplicates_fail_on_the_shipped_registry # kept: one whole run of the anomaly gate on a copy of the shipped registry with this one defect seeded (about 9 s on a workstation, 19 to 21 s on a runner, and it grows with the registry: 253 entries, 1712 references verified); the registry is edited in nearly every pull request, and this is the per-push check that the gate fails closed on it
tests/compliance/test_gate_scripts.py::TestAnomalyGateHoldsEveryRangeToTheRegistrysVersion::test_the_shipped_defect_fails_the_full_gate_too # kept: one whole run of the anomaly gate on a copy of the shipped registry with this one defect seeded (about 9 s on a workstation, 19 to 21 s on a runner, and it grows with the registry: 253 entries, 1712 references verified); the registry is edited in nearly every pull request, and this is the per-push check that the gate fails closed on it
tests/compliance/test_gate_scripts.py::TestAnomalyGate::test_the_repository_registry_passes_with_the_prefix_ci_uses # kept: one whole run of the anomaly gate on the shipped registry, as CI's compliance job calls it (about 9 s on a workstation; 20 to 21 s on a runner once the registry passed 265 entries, and it grows with it); the registry is edited in nearly every pull request, and this is the per-push check that the shipped registry passes its own gate
tests/compliance/test_gate_scripts.py::TestAnomalyGateVerifiesSomething::test_the_summary_separates_verified_from_not_checked # kept: one whole run of the anomaly gate on the shipped registry (about 9 s on a workstation; 20 to 21 s on a runner once the registry passed 265 entries, and it grows with it); the per-push check that the gate's summary counts what it verified apart from what it did not check
tests/compliance/test_gate_scripts.py::TestTransformGate::test_the_repository_transform_references_all_resolve # kept: pays for the one transforms-gate run on the repository (a module fixture, ~5 s of imports) that three TestTransformLiveRegistration tests also read; together they are the only check that the gate verified references rather than degrading on an importable module
tests/core/test_compile_counts.py::test_the_committed_baseline_matches_what_the_code_compiles_to # kept: the compile-count gate itself (one scripts/compile_counts.py --check); no CI job runs it otherwise, and an extra retrace per step is silent everywhere else
tests/compliance/test_docs_snippets.py::test_every_runnable_snippet_runs # kept: the docs gate itself, the only thing that executes the guides' Python code blocks; its module fixture runs every runnable snippet in a fresh sandboxed process, in parallel (39 snippets in 28 processes, ~18 s on 2 pinned cores, most of it the wavelet quick start and the parameters chain), and the docs-only CI path runs only tests/compliance, so it cannot move to the slow lane
tests/property/test_differential_coupling_solvers.py::test_diagnostics_leave_gradients_through_run_scan_bit_identical[ift-0] # kept: the only per-push check that diagnostics=True leaves the IFT adjoint through run_scan bit-identical (the spectral and gradient-bound products sit behind stop_gradient; a compiler rewrite could still move the backward); 11-15 s on CI, nearly all the backward compile of two graphs
tests/property/test_differential_coupling_solvers.py::test_diagnostics_leave_every_returned_value_bit_identical[ift-aitken-interface-jacobi] # kept: the per-push ift case of the diagnostics bit-identity oracle on generated non-normal spectra (states, iterations, converged and warm starts, bit for bit on every jaxlib); compiling the spectral and gradient-bound machinery is most of its 5-8 s on CI, as for the chain-5 ift cells above
tests/cloud/multigpu/test_differential_sharding_builtins.py::test_a_generated_d2q9_channel_graph_answers_as_the_unsharded_channel # kept: the per-push sample of the sharded-vs-unsharded LBM oracle (walls, obstacle, slabs and pencils, body force and pressure faces), the only per-push check of the generated LBM matrix; each example compiles one LBM step per path (3.1 s warm, 9.7 s cold on a 6-core slice, nearly all XLA compile)
tests/cloud/multigpu/test_differential_sharding.py::test_a_gradient_through_a_partition_without_ghosts_does_not_crash # kept: the regression test of a jaxlib 0.11.2 segfault (reverse mode through run_scan of ShardedUnstructuredNode on a partition with no ghost cells, under both exchange transports); it must run in a subprocess, since a crash takes the test process with it, and on every push, because only the jaxlib 0.11.2 lane can crash and no other per-push test reaches a zero-ghost gradient; nearly all of its ~11 s on CI is the child importing JAX and maddening, which a warm cache does not remove
tests/core/test_cross_feature_edge_cases.py::test_fit_lm_through_ift_coupled_group_recovers_stiffness_from_nearby # kept: the only per-push Levenberg-Marquardt fit through an IFT-coupled group (the slow fit's witness); fit_lm's Jacobian through the IFT rule inside a scan is one trace whatever the record length (3.5 s of it locally at 12, 8 or 6 steps), 2.3-5.1 s on CI
tests/property/test_differential_transforms.py::test_a_vmapped_gradient_through_an_ift_step_is_the_gradient_per_member # kept: the only per-push vmap(grad) through the IFT rule's adjoint solve under the default linear_solver='gmres' (the drawn property is slow); a batched and an unbatched backward program, mostly tracing (5.4-7.5 s on CI); linear_solver='dense' is 35% faster but is the legacy path, not the one users run
tests/compliance/test_slow_only_rule.py::test_every_slow_framework_test_names_a_per_push_witness_or_is_in_the_slow_only_table # kept: the slow-only rule's check itself (every slow framework test names a per-push witness or a table row); marking it slow would take the rule off every push, and the docs-only CI path runs only tests/compliance; its one --collect-only subprocess over the files that can hold a slow mark is 3.7-5.6 s on CI, nearly all of it importing them
tests/property/test_differential_coupling_interactions.py::test_every_row_reproduces_the_monolithic_reference[r06] # kept: the one per-push row under ift with diagnostics; whichever of its oracles runs first compiles the spectral and gradient-bound machinery for a sub-cycled group with two waveform sweeps (5-6 s cold on CI, under 2 s with the base branch's compilation cache)
tests/property/test_differential_coupling_interactions.py::test_strict_convergence_raises_exactly_where_the_report_says_unconverged[r18] # kept: the per-push strict-convergence oracle on a sub-cycled group with two waveform sweeps, where an earlier sweep can stop at the cap while the report says converged (CPL-052); three graphs compile cold (the strict twin and the two-pass pair, 5-7 s on CI), under 2 s with the base branch's compilation cache
tests/property/test_rest_write_sequences_leave_a_graph_that_reloads.py::test_short_sequences_of_rest_writes_leave_a_graph_that_runs_as_its_reload # kept: the per-push run of the REST sequence oracle (twenty generated sequences of ten requests; after each accepted request the graph's save is reloaded and stepped beside the served graph, which compiles a reload whenever the config changed); the slow test it witnesses is the only other place sequences are generated, and the slow lane does not run on a release branch unless dispatched; 5-10 s on three pinned cores, most of it XLA compiles the base branch's cache does not hold
tests/property/test_sysid_targeted_search.py::test_no_wrong_fit_among_the_fixed_draws[converged-at-a-wrong-point] # kept: the per-push witness of the slow search for a fit_lm that says converged=True off an optimum; its seconds are the four model-side compiles (two precisions, masked or not) the file's other tests reuse
tests/property/test_sysid_targeted_search.py::test_no_wrong_fit_among_the_fixed_draws[worse-than-the-plain-fit] # kept: the per-push witness of the slow search for a transformed fit that misses what its transform=None control recovers; two fits an example at the house floor of 20 examples
tests/compliance/test_claims_inventories.py::test_every_cited_test_exists_and_runs_on_every_push[coupling_claims.yaml] # kept: the guard that every test a coupling claim cites exists and is collected per push; it must run on every push, and its time is a subprocess collection that grows with the number of cited tests (20.3 s and 20.8 s on CI)
tests/property/test_coupling_targeted_search.py::test_a_usable_error_bound_is_never_below_the_distance_per_push # kept: the per-push witness of the slow hunt over coupling_diagnostics()'s four numbers; its seconds are the four compiled cells (solver="ift" with diagnostics) that the other three searches, the seeds and the pins then share
tests/core/test_coupling_claims_in_every_domain.py::test_the_claim_holds_for_each_member_of_a_vmapped_step[CPL-006] # kept: the per-push witness of the vmap cell of CPL-006; its time is tracing a batched coupled step with diagnostics on, and it measured 20.2 s and 21.9 s on CI against the 20 s line (2026-10-06), the second with the ninth Jacobian-vector product of the spectral self-check
tests/property/test_coupling_nonlinear_search.py::test_the_reference_reproduces_the_closed_form_on_a_linear_cell # kept: the per-push check that the numerical coupling reference is the closed form (the reference is what the nonlinear cells and the later geometry cells are scored against); its seconds are one cell of the linear search compiled (which that search then does not pay) and its twin
tests/property/test_coupling_nonlinear_search.py::test_the_nonlinear_fixed_point_is_the_linear_one_and_the_jacobian_moves # kept: carries the compile of the one per-push nonlinear cell (solver="ift" with diagnostics) and of its float64 twin, which the four per-push nonlinear searches then share; the coupling search has no other nonlinear coverage per push
tests/property/test_coupling_nonlinear_search.py::test_a_settled_radius_is_the_radius_where_a_same_pass_rounding_moves_the_jacobian[a-radius-a-rounding-of-a-same-pass-value-moves-past-the-flag-s-margin] # kept: the per-push pin of the open MADD-ANO-239 (strict xfail: the fix must turn it green on the push that makes it); it carries the compile of the one appended cell the pins live on (solver="ift" with diagnostics) and of its float64 twin, which the other two pins on that cell then share
tests/property/test_interface_reading_twins.py::test_a_static_mapped_edge_under_the_interface_norm_reports_a_usable_spectrum[float32 {'max_iterations': 3}] # kept: carries the compile of the edge-mapped graph the per-push interface-reading comparison is made against (a group with diagnostics under the interface norm)
tests/property/test_interface_reading_twins.py::test_a_static_mapped_edge_under_the_interface_norm_reports_as_its_transform_twin[float32 {'max_iterations': 3}] # kept: the only per-push comparison of coupling_diagnostics() under the interface norm with a twin that has the same reading (a reading without its mapping moves the residual by 8.8% here and nothing else per push sees it); its seconds are the twin's compile
tests/property/test_coupling_geometry_search.py::test_a_reported_number_of_a_group_with_a_geometry_edge_holds_against_the_reference_per_push[bound] # kept: carries the compile of the one per-push geometry cell (solver="ift" with diagnostics and the self-check) and of its float64 twin, which every other test of the module then shares; the per-push witness of the slow hunt over a group with a multilinear_grid geometry edge
tests/core/test_the_interface_norm_reads_a_mapped_edge_on_its_compact_side.py::test_a_diagnosed_edge_mapped_pair_reports_every_number_of_its_marker_side_twin # kept: the only per-push comparison that holds the spectral analysis to the side the criterion reads on a mapped edge that delivers more entries than it reads (two small graphs compiled with diagnostics; a spectrum left on the delivered side passed every other per-push test)
tests/property/test_coupling_targeted_search.py::test_the_state_returned_under_the_interface_norm_holds_to_its_report_per_push # kept: the one per-push check, beside the searches that observe the accepted iterate, of the state a user gets under convergence_norm="interface"; its seconds are one cell compiled twice (the return rule on and off), which the pinned near-zero case then shares
tests/core/test_coupling_interface_norm_answers_for_the_state_it_returns.py::test_at_an_early_exit_every_returned_field_carries_the_accepted_iterates_implicit_derivative[tail-jacobi] # kept: the per-push witness that the gradient bound covers the state returned under the interface norm (CPL-093), fields measured whole beside recomputed ones; its seconds are two compiled graphs and one tangent map through the implicit rule with diagnostics
tests/core/test_coupling_interface_norm_answers_for_the_state_it_returns.py::test_at_an_early_exit_every_returned_field_carries_the_accepted_iterates_implicit_derivative[mapped-gauss-seidel] # kept: the same under a sweep that reads this pass's values, every field recomputed: the row a pass differentiated at the wrong reading shows on
tests/core/test_coupling_diagnostics_with_an_empty_field.py::test_the_twin_without_the_field_converges_and_reports_numbers[source_mapped-interface-ift+diag-iqn-ils-jacobi-f32] # kept: carries the compile of the mapped twin (solver="ift" with diagnostics under the interface norm and a quasi-Newton acceleration) that the per-push comparison below is made against
tests/core/test_coupling_diagnostics_with_an_empty_field.py::test_a_group_reports_what_its_twin_without_the_field_does[source_mapped-interface-ift+diag-iqn-ils-jacobi-f32] # kept: the only per-push comparison of a group whose report is taken on the interface reading (a mapped edge) with a field with no entries beside it; a regression there is a bare ValueError at trace or a bound that differs from the twin's
tests/core/test_coupling_diagnostics_with_an_empty_field.py::test_the_twin_without_the_field_converges_and_reports_numbers[unread-interface-ift+diag-none-gs-f32-none_f64] # kept: carries the compile, under x64, of the float32 twin (solver="ift" with diagnostics) that the per-push case of the wider-dtype exception is compared with
tests/property/test_coupling_geometry_search.py::test_the_flag_is_withdrawn_with_the_fixed_point_across_a_lattice_plane # kept: the per-push regression of MADD-ANO-242 (a usable bound 0.16x the true distance across a lattice plane); its seconds are the compile of the audited one-marker Gauss-Seidel cell with its diagnostics and of its float64 twin, which the reference needs to place the fixed point in its lattice cell; four seeded faults of the criterion are caught only here and in the tests that share that compile
tests/core/test_coupling_pairs_of_two_sizes_in_every_domain.py::test_a_diagnosed_pair_of_two_sizes_reports_the_spectrum_of_its_twin[sub_cycled-two-way-sparse-gauss-seidel-small-b-diagnosed] # kept: the only per-push comparison that holds the spectral analysis to the side the criterion reads outside a one-rate float64 pair (a sub-cycled group, the small field on the member it sub-steps; two small graphs compiled with diagnostics)
tests/property/test_coupling_geometry_search_under_the_interface_norm.py::test_what_a_group_with_a_geometry_edge_reports_under_the_interface_norm_per_push[reading] # kept: carries the compiles of the one per-push geometry cell under the interface norm (the graph observed at its accepted iterate, the same graph with the return rule on, and the float64 twin of the numerical reference); the [returned] score reuses them
tests/property/test_coupling_plane_sides.py::test_every_flagged_number_of_a_table_row_holds_against_the_reference[audited-the-gradient-bound-short-of-a-plane] # kept: carries the compiles of the per-push lattice-plane table (three structures; the per-push regression of MADD-ANO-252, a usable gradient bound 15x to 70,000x under the error)
tests/property/test_coupling_plane_sides.py::test_no_flag_stands_with_the_cell_polynomials_fixed_point_past_a_plane[kernel-float64] # kept: one compile; the per-push regression of MADD-ANO-252's spectral half (the flag on a distance bound 17x to 1,294x under the distance), on the kernel's own curvature
tests/property/test_coupling_plane_sides.py::test_no_flag_stands_with_the_cell_polynomials_fixed_point_past_a_plane[member-float32] # kept: one compile; the same regression in float32, on a member's quadratic response
tests/core/test_coupling_floor_at_the_groups_coarsest_dtype.py::test_a_float64_field_downstream_of_a_float32_member_is_floored_at_float32 # kept: the per-push case of the mixed-dtype floor (a bound with its flag set against the closed-form distance, the audited 0.21x case); a diagnostics step compiles in about 6 s and the pair takes 1e4 passes to stall
tests/core/test_the_float_floor_of_a_long_mapped_row.py::test_a_stalled_group_behind_a_long_row_withdraws_its_flags_and_says_why[scatter] # kept: carries the one compile of the per-push case of MADD-ANO-257 in the scatter layout (a diagnostics step of the audited pair behind a row of 300 entries, about 6 to 10 s); five tests read that one report, and the guard's seeded faults in the report and in compile() are caught by it alone on a push
tests/core/test_the_float_floor_of_a_long_mapped_row.py::test_a_stalled_group_behind_a_long_row_withdraws_its_flags_and_says_why[gather] # kept: the same per-push case in the gather layout, a second diagnostics compile: the guard counts every static kind, and a fault that leaves this layout out is caught here on a push (its bound fails only on one jax version, in the slow lane)
tests/core/test_the_float_floor_of_a_long_mapped_row.py::test_a_stalled_group_behind_a_long_row_withdraws_its_flags_and_says_why[dense] # kept: the same per-push case behind a dense matrix of three rows of 3000 entries, a third diagnostics compile: the one dense case whose bound is under its distance on every jax version, and what catches a fault that leaves the dense kinds out or counts them by their non-zeros' rows
tests/core/test_the_float_floor_of_a_long_mapped_row.py::test_a_row_within_the_limit_keeps_its_flags_on_a_bound_that_holds # kept: the control beside the per-push cases of MADD-ANO-257, a fourth diagnostics compile: a dense row of exactly the limit keeps its flags; without it a guard that withdrew every flag at the float floor would pass the per-push lane end to end
tests/cloud/multigpu/test_run_capacity_rungs_and_ramp.py::test_a_dry_run_ramp_over_three_sizes_passes_and_writes_what_the_summary_reads[2x2] # kept: the per-push run of the capacity script's ramp on the pencil mesh: three rungs, each a new grid whose sharded D3Q19 step and per-device build and comparison programs compile once (3.5 s on six cores, 5.0 s on four with jaxlib 0.10.2); the script runs for real for the first time on the pod, so its dry run is per push
tests/cloud/multigpu/test_run_capacity_rungs_and_ramp.py::test_a_dry_run_ramp_over_three_sizes_passes_and_writes_what_the_summary_reads[4x1] # kept: the same ramp on the 1-D mesh, the only one of the two on which a halo taken from the wrong neighbour shows; three more grids, three more compiles
tests/core/test_coupling_claims_helpers.py::test_arnoldi_costs_n_steps_plus_one_jacobian_vector_products # kept: CPL-013's per-push evidence (coupling_claims.yaml cites it); 20.2-20.4 s on 2026-10-12 on a cold-cache shard, about 65% compiling (425 cache misses), under 10 s warm
tests/nodes/adaptive/test_active_set_switch.py::test_integrated_gradient_plus_switch_jumps_reconstructs_the_objective_change # kept: MADD-ANO-003's evidence (known_anomalies.yaml cites it); 22.4 s on 2026-10-12 (running, not compiling) on the same shard
tests/test_examples_smoke.py::test_example_runs_headless[advanced.unstructured_sharding_demo --n-cells 256 --steps 20] # kept: the per-push run of the unstructured sharding example, the only code that composes ShardedUnstructuredNode, exchange_traffic and a differentiable, preconditioned sharded_cg as the sharding page tells a user to (a rename in any of them breaks it at run time, which the static lane cannot see); 5 to 8 s on a loaded 3-core slice, nearly all XLA compile (the CG adjoint about 2.6 s, three sharded graphs), so a smaller size saves little
