test(tiers): return every-run calibration and recovery cells to T1 and T2

Brief 40 of the August 2026 audit. Report: dev/review-2026-08/reports/40-t0-retier.md

Constituent changes:
- test(tiers): return the every-run tier's calibration and recovery cells to T1 and T2
- docs(tiers): state the every-run budget in the units CI reports

Author: MaartenMarsman

.github/workflows/fast-checks.yaml

@@ -10,8 +10,19 @@
 #       Every push to develop and every pull request. No gate, so the run is
 #       exactly what a maintainer sees locally: contracts, validation, wiring,
 #       the product surface, and the tight numerical unit guards that catch a
-#       shifted constant in one run. Budget ~90 s of tests (~4-6 min a job with
-#       dependency restore and compilation).
+#       shifted constant in one run. Budget: <= 15 min of tests in THIS job,
+#       which keeps the whole job near half its 30-minute timeout.
+#
+#       Read the budget off this job's own test phase. The tiering audit's
+#       "~90 s" is a different measurement -- an OPTIMIZED build on a developer
+#       machine -- and nothing this job prints can be compared against it.
+#       devtools::test() compiles a debug build (pkgbuild::compiler_flags(debug
+#       = TRUE) gives "-UNDEBUG -Wall -pedantic -g -O0"), and this job keeps it
+#       that way on purpose (see the extra-packages note below). Measured on
+#       identical content that build costs 2.38x, and this 2-core runner a
+#       further ~2.31x over one developer machine. So quote CI minutes here, or
+#       say which build a local number came from; a bare seconds figure is not
+#       comparable across the two and let this tier drift unnoticed once.
 #
 #   T1  nightly     .github/workflows/nightly-validation.yaml. Daily 03:00 UTC
 #       on develop, BGMS_RUN_SLOW_TESTS=true, <= 60 min, timeout 90.

dev/review-2026-08/MAINTAINERS.md

@@ -218,7 +218,7 @@ be T1. Budget is the tie-breaker, never the criterion.
 
 | Tier | Cadence | Content, by bug class | Budget | Gate |
 |---|---|---|---|---|
-| **T0** every run | local `devtools::test()`; every push to develop and every PR (`fast-checks.yaml`) | contracts, validation, wiring, unit guards, product surface | ~90 s of tests | none |
+| **T0** every run | local `devtools::test()`; every push to develop and every PR (`fast-checks.yaml`) | contracts, validation, wiring, unit guards, product surface | **≤ 15 min of tests** in the `fast-checks` job (`timeout-minutes: 30`) | none |
 | **T1** nightly heartbeat | daily 03:00 UTC on **develop** (`nightly-validation.yaml`) | curated calibration subset — graph-law and prior-chain identities, gauge detector, single surface-vs-gold cells, RB saturation, concordance smokes. "Does the settled math still hold tonight" | **≤ 60 min** on the 2-core runner; `timeout-minutes: 90` | `BGMS_RUN_SLOW_TESTS=true` |
 | **T2** weekly certification | Sunday 03:00 UTC on **develop** (`weekly-certification.yaml`) | the heavy Monte-Carlo machinery — SBC suites, full parameter-recovery sweeps, full NUTS-vs-MH condition grids, n = 2e6 MC channels, refit cross-validations (incl. the F-049 gate) | `timeout-minutes: 360` | `BGMS_RUN_CERTIFICATION=true` (the T2 workflow sets **both** vars, so a weekly run also carries T1) |
 
@@ -227,7 +227,19 @@ T2 uses the shared `skip_unless_certification()` in
 `tests/testthat/helper-tiers.R`, whose skip message says explicitly that
 `BGMS_RUN_SLOW_TESTS` alone does not enable the block.
 
-Two mechanics worth knowing before editing these workflows:
+**Budgets are in CI minutes, and a local number must say which build it came
+from.** The 2026-07-29 audit measured an *optimized* build on a developer
+machine and landed 89.7 s; `devtools::test()` and every CI tier compile a
+*debug* build (`pkgbuild::compiler_flags(debug = TRUE)` is `-UNDEBUG -Wall
+-pedantic -g -O0`). Measured on byte-identical content the build is worth
+**2.38x**, and the 2-core runner a further **~2.31x** over one developer
+machine (`dev/review-2026-08/reports/40-t0-retier.md`). So the audit's 89.7 s
+and anything CI reports were never comparable, and T0 drifted for five weeks
+without the drift being visible to either number. The reference instrument is
+the `fast-checks` job's own test phase. When re-tiering, measure from a run
+that FINISHED, in that job, and quote minutes.
+
+Three mechanics worth knowing before editing these workflows:
 
 - **Schedules fire from the default branch.** GitHub reads the cron from
   `main`'s copy of a workflow file, so the T1/T2 schedules only start firing

tests/testthat/helper-tiers.R

@@ -7,7 +7,14 @@
 #   T0  every run (local devtools::test(), and every push/PR)
 #       Contracts, validation, wiring, the product surface, and the tight
 #       numerical unit guards that catch a shifted constant in one run.
-#       No gate. Budget ~90 s.
+#       No gate. Budget: <= 15 min of tests in the fast-checks job.
+#
+#       State which build any local number came from. devtools::test()
+#       compiles a debug build (-O0), the tiering audit measured an optimized
+#       one, and the two differ by 2.38x on identical content -- so the
+#       audit's "~90 s" cannot be compared with a devtools::test() wall time
+#       or with what CI prints. The fast-checks job is the reference
+#       instrument; see .github/workflows/fast-checks.yaml.
 #
 #       CRAN runs a SUBSET of T0: the heavy internal numerical guard files
 #       are excluded there via skip_heavy_guard_on_cran() below (maintainer

tests/testthat/test-bgm.R

@@ -18,6 +18,17 @@
 # This file focuses on tests that require special setup or unique assertions.
 # ==============================================================================
 
+# Tiers. The product surface stays local. The estimate-simulate-re-estimate
+# cycle is parameter recovery -- it proves the settled numerics still recover
+# what they planted -- so it runs nightly.
+
+skip_unless_slow = function() {
+  skip_if_not(
+    identical(Sys.getenv("BGMS_RUN_SLOW_TESTS"), "true"),
+    message = "Set BGMS_RUN_SLOW_TESTS=true to run the parameter-recovery cycle"
+  )
+}
+
 test_that("bgm is reproducible", {
   # Use cached fixture as fit1, run one fresh fit as fit2 with same params
   fit1 = get_bgms_fit_ordinal()
@@ -235,14 +246,15 @@ test_that("bgm GGM output has correct parameter ordering", {
 })
 
 test_that("bgm OMRF output has correct parameter ordering", {
+  # Ordering is structural: the chain only has to produce the vectors.
   skip_on_cran()
 
   data("Wenchuan", package = "bgms")
   x = na.omit(Wenchuan[, 1:5]) # p=5 to detect row/column-major bugs
 
   fit = bgm(
     x,
-    iter = 400, warmup = 300, chains = 1,
+    iter = 60, warmup = 60, chains = 1,
     edge_selection = TRUE, seed = 42,
     display_progress = "none"
   )
@@ -1139,6 +1151,7 @@ test_that("bgm GGM implied regression matches OLS for large n", {
 # Posterior mean parameters from the re-fit should correlate with the original.
 
 test_that("estimate-simulate-re-estimate cycle recovers parameters (OMRF)", {
+  skip_unless_slow()
   skip_on_cran()
 
   data("Wenchuan", package = "bgms")

tests/testthat/test-bgmCompare.R

@@ -17,6 +17,17 @@
 # This file focuses on tests that require special setup or unique assertions.
 # ==============================================================================
 
+# Tiers. Structure, ordering, labels, scale and the selection branches stay
+# local. Reading back a planted difference at its planted size is parameter
+# recovery, so it runs nightly.
+
+skip_unless_slow = function() {
+  skip_if_not(
+    identical(Sys.getenv("BGMS_RUN_SLOW_TESTS"), "true"),
+    message = "Set BGMS_RUN_SLOW_TESTS=true to run the compare recovery certification"
+  )
+}
+
 # ------------------------------------------------------------------------------
 # Reproducibility Tests (using fixtures to save one model fit)
 # ------------------------------------------------------------------------------
@@ -246,6 +257,7 @@ test_that("bgmCompare handles more than 2 groups", {
 # ==============================================================================
 
 test_that("bgmCompare output has correct parameter ordering", {
+  # Ordering is structural: the chain only has to produce the vectors.
   skip_on_cran()
 
   data("Wenchuan", package = "bgms")
@@ -255,7 +267,7 @@ test_that("bgmCompare output has correct parameter ordering", {
   fit = bgmCompare(
     x = x, group_indicator = group_ind,
     difference_selection = TRUE,
-    iter = 1000, warmup = 500, chains = 1,
+    iter = 60, warmup = 60, chains = 1,
     seed = 42,
     display_progress = "none"
   )
@@ -421,6 +433,7 @@ test_that("bgmCompare pairwise effects are on the association scale", {
 })
 
 test_that("bgmCompare recovers a planted group difference at its planted size", {
+  skip_unless_slow()
   skip_on_cran()
   # The guard above fits two groups drawn from the SAME omega, so every
   # difference in it is zero and a difference parameterization off by a factor

tests/testthat/test-calibration-check.R

@@ -1,3 +1,16 @@
+# Tiers. The contract cells -- what fitted_observed_data() returns, the band
+# geometry, the panel kinds, the paging and the newdata guards -- stay local.
+# The family-breadth cells (Blume-Capel, non-contiguous scores, per-group and
+# Blume-Capel compare fits) show the check also covers those families, which
+# is calibration breadth rather than wiring, so they are T1.
+
+skip_unless_slow = function() {
+  skip_if_not(
+    identical(Sys.getenv("BGMS_RUN_SLOW_TESTS"), "true"),
+    message = "Set BGMS_RUN_SLOW_TESTS=true to run the calibration breadth cells"
+  )
+}
+
 test_that("fitted_observed_data returns the fitted data on the input scale", {
   skip_on_cran()
   fit = get_bgms_fit_wenchuan5()
@@ -180,6 +193,7 @@ test_that("plot.bgms_calibration draws small multiples and checks variables", {
 })
 
 test_that("calibration_check handles Blume-Capel and mixed Blume-Capel fits", {
+  skip_unless_slow()
   skip_on_cran()
   x = Wenchuan[stats::complete.cases(Wenchuan[, 1:5]), 1:5]
 
@@ -224,6 +238,7 @@ test_that("calibration_check handles Blume-Capel and mixed Blume-Capel fits", {
 })
 
 test_that("calibration_check reads non-contiguous ordinal category scores", {
+  skip_unless_slow()
   skip_on_cran()
   x = Wenchuan[stats::complete.cases(Wenchuan[, 1:5]), 1:5] * 2L + 1L
 
@@ -323,6 +338,7 @@ test_that("fitted_observed_data puts a compare fit's Blume-Capel baseline back",
 })
 
 test_that("calibration_check runs per group on a compare fit", {
+  skip_unless_slow()
   fit = get_bgmcompare_fit_wenchuan5()
   check = calibration_check(fit, nrep = 20, seed = 2)
 
@@ -374,6 +390,7 @@ test_that("a compare check accepts the fitted rows as newdata, in input order",
 })
 
 test_that("calibration_check covers a Blume-Capel compare fit", {
+  skip_unless_slow()
   fit = get_bgmcompare_fit_blumecapel()
   check = calibration_check(fit, nrep = 15, seed = 5)
   expect_s3_class(check, "bgms_calibration")

tests/testthat/test-ggm-gibbs.R

@@ -12,8 +12,23 @@
 #      samplers target the same K | graph posterior, so their posterior means
 #      must agree within MCMC error. This catches a wrong target that a
 #      "runs without error" check would miss.
+#
+# Tiers. The closed-form anchors are unit guards against a shifted constant and
+# stay local, as does one agreement cell -- Normal, alpha = 1, delta = 0, the
+# smoke proving gibbs is wired into bgm() at all. The remaining agreement cells
+# sweep the prior conditions (xi shift, gamma shape, Cauchy slab, eta frame),
+# which is settled-numerics calibration, so they are T1. The edge-selection
+# cells compare two samplers' inclusion probabilities across a condition grid,
+# which the tier contract places in T2.
 # --------------------------------------------------------------------------- #
 
+skip_unless_slow = function() {
+  skip_if_not(
+    identical(Sys.getenv("BGMS_RUN_SLOW_TESTS"), "true"),
+    message = "Set BGMS_RUN_SLOW_TESTS=true to run the gibbs-vs-AM condition sweep"
+  )
+}
+
 
 # ---- Closed-form anchors ---------------------------------------------------- #
 
@@ -137,6 +152,7 @@ test_that("gibbs routes through bgm() and agrees with AM (Normal, alpha=1, delta
 
 
 test_that("gibbs agrees with AM at delta = 0.5 (xi shape shift)", {
+  skip_unless_slow()
   skip_on_cran()
   skip_if_not_installed("MASS")
   Y = ggm_agreement_data()
@@ -151,6 +167,7 @@ test_that("gibbs agrees with AM at delta = 0.5 (xi shape shift)", {
 
 
 test_that("gibbs agrees with AM at alpha = 2 (independent-MH on the diagonal)", {
+  skip_unless_slow()
   skip_on_cran()
   skip_if_not_installed("MASS")
   Y = ggm_agreement_data()
@@ -165,6 +182,7 @@ test_that("gibbs agrees with AM at alpha = 2 (independent-MH on the diagonal)",
 
 
 test_that("gibbs agrees with AM under a Cauchy slab (scale mixture of normals)", {
+  skip_unless_slow()
   skip_on_cran()
   skip_if_not_installed("MASS")
   Y = ggm_agreement_data()
@@ -180,6 +198,7 @@ test_that("gibbs agrees with AM under a Cauchy slab (scale mixture of normals)",
 
 
 test_that("gibbs agrees with AM under a non-unit Cauchy slab in the eta frame", {
+  skip_unless_slow()
   skip_on_cran()
   skip_if_not_installed("MASS")
   Y = ggm_agreement_data()
@@ -215,6 +234,7 @@ ggm_pips = function(Y, update_method, iter, warmup, shape = 1,
 }
 
 test_that("gibbs edge selection recovers the same inclusion probabilities as NUTS", {
+  skip_unless_certification()
   skip_on_cran()
   skip_if_not_installed("MASS")
   set.seed(11)
@@ -236,6 +256,7 @@ test_that("gibbs edge selection recovers the same inclusion probabilities as NUT
 })
 
 test_that("gibbs edge selection agrees with NUTS at Gamma shape = 2", {
+  skip_unless_certification()
   skip_on_cran()
   skip_if_not_installed("MASS")
   set.seed(11)
@@ -256,6 +277,7 @@ test_that("gibbs edge selection agrees with NUTS at Gamma shape = 2", {
 })
 
 test_that("gibbs edge selection agrees with NUTS under a Cauchy slab", {
+  skip_unless_certification()
   skip_on_cran()
   skip_if_not_installed("MASS")
   set.seed(11)

tests/testthat/test-prior-inclusion-probabilities.R

@@ -11,6 +11,19 @@
 # routes against each other.
 # --------------------------------------------------------------------------- #
 
+# Tiers. The acceptance-target wiring, the analytic pieces, the extractor
+# contracts and the hierarchical pass-through stay local. The cells that
+# check one route against another (table vs prior-only chain, the mixed
+# per-class split, the hierarchical edge-prior identity) are settled-numerics
+# agreement, so they are T1.
+
+skip_unless_slow = function() {
+  skip_if_not(
+    identical(Sys.getenv("BGMS_RUN_SLOW_TESTS"), "true"),
+    message = "Set BGMS_RUN_SLOW_TESTS=true to run the prior-PIP route agreement cells"
+  )
+}
+
 prior_pip_ggm_data = function() {
   set.seed(7)
   x = matrix(rnorm(80 * 3), 80, 3)
@@ -165,6 +178,7 @@ test_that("the Beta quadrature reduces to the Beta mean without reweighting", {
 # --------------------------------------------------------------------------- #
 
 test_that("GGM beta-bernoulli prior PIPs match the prior-only chain", {
+  skip_unless_slow()
   skip_on_cran()
 
   fit = small_fit(prior_pip_ggm_data(), "continuous",
@@ -234,6 +248,7 @@ test_that("GGM SBM prior PIPs come from a cached deterministic chain", {
 # --------------------------------------------------------------------------- #
 
 test_that("mixed beta-bernoulli prior PIPs split by edge class", {
+  skip_unless_slow()
   skip_on_cran()
 
   d = prior_pip_mixed_data()
@@ -338,6 +353,7 @@ test_that("posterior extractor maps mixed indicators through block order", {
 # --------------------------------------------------------------------------- #
 
 test_that("a hierarchical fit's prior inclusion probability is the edge prior", {
+  skip_unless_slow()
   skip_on_cran()
 
   x = prior_pip_hier_data()

tests/testthat/test-prior-sensitivity.R

@@ -361,6 +361,7 @@ test_that("compare_anchor_draws aligns every gated difference with its indicator
 
 
 test_that("the compare noise yardstick runs per indicator, not per gated parameter", {
+  skip_unless_slow()
   skip_on_cran()
   data("Wenchuan", package = "bgms")
   fit = bgmCompare(
@@ -533,9 +534,10 @@ test_that("the difference-scale reweighting reproduces a refit at that scale", {
 
 
 test_that("a warm-start list with the wrong length errors", {
+  # The guard reads the list's length, not the states it carries.
   data("Wenchuan", package = "bgms")
   fit = bgm(Wenchuan[, 1:5],
-    chains = 2, iter = 150, warmup = 200, seed = 3,
+    chains = 2, iter = 40, warmup = 40, seed = 3,
     display_progress = "none"
   )
   ws = extract_warm_state(fit)

tests/testthat/test-rb-inclusion-probabilities.R

@@ -357,10 +357,11 @@ test_that("extract_inclusion_bf pins the bgmCompare interleaved flattening", {
 })
 
 test_that("estimator = 'rb' errors without edge selection", {
+  # The guard reads edge_selection off the spec, before any draw.
   data("Wenchuan", package = "bgms")
   fit = bgm(
     Wenchuan[, 1:5],
-    iter = 200, warmup = 150, chains = 1, seed = 7,
+    iter = 20, warmup = 20, chains = 1, seed = 7,
     edge_selection = FALSE, display_progress = "none"
   )
   expect_error(