diff --git a/Cargo.toml b/Cargo.toml
index 43299cc..400aecc 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -83,3 +83,8 @@ unexpected_cfgs = { level = "warn", check-cfg = ['cfg(loom)'] }
 [[bench]]
 name = "cost_lookup"
 harness = false
+
+[[bench]]
+name = "wait_scenarios"
+harness = false
+required-features = ["parallel"]
diff --git a/README.md b/README.md
index efd0948..ac2ba7f 100644
--- a/README.md
+++ b/README.md
@@ -58,7 +58,8 @@ the token to kernels by value. Kernels never store a token and never mint one.
 | `Exec::team(f)` / `team_with(over, f)` | reserve `budget - 1` awake pool members for a scope and run barrier-bearing sections through `TeamExec` (`run`, `run_with`, `split`, `fork`, `reborrow`), or `Err(Refused::Unavailable)`; see the design record |
 | `Pool::into_team(width)` -> `Team` (owns the pool; `IntoTeamError` gives it back), `Team::exec(budget)` / `try_exec`, `Team::pool`, `Team::into_pool` | persistent reservation for an engine that owns its pool (`Pool` is not `Clone`); minted tokens are ordinary `Exec`s whose `fork`, `for_ranges`, `broadcast`, `team` dispatch on the reserved members; one leader at a time (`exec` blocks, `try_exec` -> `Refused::Busy`); idle members park while reserved |
 | `PoolBuilder::qos(Qos)`, `raise_current_thread_qos(Qos)` | worker QoS on macOS (default `UserInitiated`); raise the leading thread without ever lowering it |
-| `PoolBuilder::idle_spin`, `idle_runs_rayon`, `acquire_timeout`; `Pool::release_idle` | waiting policy of idle team members; a reserved member spins with one PAUSE per poll (never `sched_yield`), parks after the delay, and parks after a short spin in a root scope that has more participants than the caller's CPUs |
+| `PoolBuilder::idle_spin`, `idle_runs_rayon`, `acquire_timeout`; `Pool::release_idle` | waiting policy of idle team members (an idle member returns to Rayon after `idle_spin` or the spin budget, whichever comes first) |
+| `PoolBuilder::spin_polls`, `Pool::spin_polls` | spin budget of every team wait, in polls (the shape of libgomp's `GOMP_SPINCOUNT`): a reserved member waiting for work, the leader in a join and a participant in a barrier spin that many polls, yield a few times, then sleep until woken; throttled to 100 polls in an oversubscribed scope or after a waiter was descheduled ([`docs/design/waiting.md`](docs/design/waiting.md)) |
 | `PoolBuilder::pin_participants(bool)`, `Pool::pin_participants()` | opt-in placement of the **members** of a root team scope (Linux; off by default, which is consistent with the rule it protects): member `k` (participant `k >= 1`) pins itself onto the `k`-th CPU of the calling thread's affinity set, `S[0]` is left to the leader, and a member restores its own mask before it returns to Rayon or serves foreign work. **The leader is never pinned**, because a vendor library creates its thread team from the calling thread and a one-CPU caller would confine the whole provider team; a member that calls such a library directly inside a share does confine it, so use `Exec::external` (which restores the member's mask first) or leave pinning off. For tensor4all/faer#107; give each team its own CPU set (`taskset -c`), there is no CPU allocator |
 | `DispatchCosts`, `WidthCosts`, `PoolBuilder::dispatch_costs`, `Exec::dispatch_cost(width)`, `TeamExec::dispatch_cost(width)` | cost of one parallel section per kind of token (team, in pool, outside), steady state; one row per `HostClass` (`HostClass::detect()`, keyed by kernel dispatch: `x86_64-avx512`, `x86_64-avx2`, `x86_64-scalar`, `aarch64-apple`, `aarch64`, `generic`), `DispatchCosts::for_class(class)`; measured rows for `x86_64-avx512` (team anchors at widths 2, 4, 6 and 8) and `aarch64-apple`, a measured Zen2 team row for `x86_64-avx2` (anchors at ten widths from 2 to 64; its plain kinds stay generic), every other class takes the conservative `generic` row (3 / 15 / 40 us at the anchors 2, 4, 6); a row holds measured anchors (`WidthCosts::new`, `WidthCosts::flat`, or `WidthCosts::from_anchors` for measured anchors up to 64 and beyond), interpolates between them and grows linearly above the largest one, so a width above the anchors is never charged the cost of the largest anchor; `DispatchCosts::host_default()` is the detected class's row; `Duration::MAX` when serial; override per pool |
 | `pays_at(est, sections, cost)`, `Exec::pays(est, sections, width)`, `Exec::width_for(est, sections)`, `width_for_by`, `PAYS` | the one rule: parallel iff `est >= PAYS * sections * D(width)`; `width_for` minimises `sections * D(k) + est / k` |
@@ -107,6 +108,50 @@ Consumers assert `ledger::max_live(root) <= budget` in their own tests, and keep
 a test binary that runs serial and pooled work and then checks that
 `rayon::ThreadPoolBuilder::new().build_global()` still succeeds.
 
+## Wait benchmarks
+
+`benches/wait_scenarios.rs` measures how team threads wait, the way callers use them; the design
+is in [`docs/design/waiting.md`](docs/design/waiting.md). A change to the waits is judged by running
+it on the base and on the head of the change, on a quiet host and on a many-core shared host.
+
+| scenario | a call is | reports |
+| --- | --- | --- |
+| `sections` | 200 sections of 5, 20 or 50 µs, team held | per call, and the overhead over `sections * work` |
+| `gaps` | 10 sections of 5 µs, the caller sleeps 0 / 100 µs / 1 ms / 10 ms between calls | the first section (wake latency) and the call |
+| `acquire` | 50 sections of 20 µs: the team held (a token per call), the pool held (members acquired per call), a new pool per call | per call; for a new pool also the total from build to drop |
+| `nested` | 100 splits of the team into pairs, each pair one 20 µs section | per call |
+
+Each scenario runs at width = all CPUs of the affinity set and at three quarters of them, on
+threadteam and on a Rayon `scope`; `benches/omp/wait_omp.c` runs `sections` and `gaps` on libgomp
+(one `omp parallel` region per section, runtime defaults). `--load K:P` adds `K` child processes,
+each busy `P` % of every 10 ms, for the whole run: the stand-in for another user's processes.
+
+```sh
+# one checkout, both passes (quiet, then 8 processes at 10 %), rows appended to
+# docs/design/waiting-data/<host>.csv
+scripts/bench-waits.sh <label>                 # e.g. main-4c73c2b, then the PR head
+scripts/bench-waits.sh <label> 64,48 8:10      # explicit widths and load
+cargo bench --bench wait_scenarios -- --scenario gaps --widths 8   # one scenario; options in the file header
+```
+
+* **evo** (quiet): `scripts/bench-waits.sh <label> "" none` on the base and on the head. The
+  acceptance check is that `sections` and `gaps` do not regress.
+* **broccoli** (64 CPUs, shared): `taskset -c 0-63 scripts/bench-waits.sh <label> 64,48 8:10` on the
+  base and on the head, plus the faer#107 arms of `acquire_probe_107` (tensor4all/faer branch
+  `probe/107-acquire-per-call`). The acceptance check is that width 64 under load is no longer
+  slow and width 48 does not regress.
+
+To compare two commits on a shared host, `scripts/bench-ab.sh <base-rev> <head-rev> <rounds>
+[bench args]` builds both and alternates them, so a drift of other users' load falls on both sides;
+`HEAD_VARIANTS='--spin-polls 300000;--own-hold-ms 100'` adds head runs with tuning flags (this
+version only), and `OMP=1` runs the libgomp driver in every round with the same scenario, widths,
+calls and load (`acquire` is libgomp's held team). The base of the waits change is its bench commit `a3a9320` (the bench on the 0.1.3
+waits). Under every threadteam row, a `waits per call` line counts join and barrier sleeps, member
+parks and the preemptions waiters saw.
+
+Results are committed as CSV under [`docs/design/waiting-data/`](docs/design/waiting-data/), one
+file per host, with the label naming the commit; the summary tables live in `waiting.md`.
+
 ## License
 
 Licensed under either of MIT or Apache-2.0 at your option.
diff --git a/benches/omp/wait_omp.c b/benches/omp/wait_omp.c
new file mode 100644
index 0000000..f8db67c
--- /dev/null
+++ b/benches/omp/wait_omp.c
@@ -0,0 +1,169 @@
+/* The libgomp reference for benches/wait_scenarios.rs (docs/design/waiting.md).
+ *
+ * The same work as the Rust bench: a section is one `omp parallel` region in which every thread
+ * busy-waits `work` microseconds on the clock; a call is a run of sections. Prints rows in the
+ * Rust bench's format and appends them to a CSV file when one is given.
+ *
+ * Build and run with scripts/bench-waits.sh or scripts/bench-ab.sh (OMP=1), or:
+ *   gcc -O2 -fopenmp benches/omp/wait_omp.c -o target/wait_omp
+ *   target/wait_omp <width> <calls> [csv] [label]
+ * The OpenMP runtime runs with its defaults (no OMP_WAIT_POLICY, no GOMP_SPINCOUNT, no binding)
+ * unless the caller sets them.
+ *
+ * Environment:
+ *   WAIT_OMP_SCENARIO  all (default) | sections | gaps | acquire
+ *   WAIT_OMP_LOAD      K:P, foreign load: K child processes each busy P % of every 10 ms
+ *
+ * `acquire` / `held_team` is libgomp's counterpart of the Rust bench's held team: calls of 50
+ * sections of 20 us on the same (hot) team, back to back.
+ */
+#define _GNU_SOURCE
+#include <omp.h>
+#include <sched.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <signal.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+static double now_us(void) {
+  struct timespec t;
+  clock_gettime(CLOCK_MONOTONIC, &t);
+  return t.tv_sec * 1e6 + t.tv_nsec / 1e3;
+}
+
+static inline void relax(void) {
+#if defined(__x86_64__) || defined(__i386__)
+  __builtin_ia32_pause();
+#elif defined(__aarch64__)
+  __asm__ __volatile__("yield");
+#endif
+}
+
+static void busy(double us) {
+  double end = now_us() + us;
+  while (now_us() < end) relax();
+}
+
+static int cmp(const void *a, const void *b) {
+  double x = *(const double *)a, y = *(const double *)b;
+  return (x > y) - (x < y);
+}
+
+static FILE *csv;
+static char prefix[512];
+
+static void row(const char *scenario, int width, const char *param, const char *metric, double *v,
+                int n, double ideal) {
+  qsort(v, n, sizeof *v, cmp);
+  double med = v[n / 2], p90 = v[(n * 9 / 10) < n ? n * 9 / 10 : n - 1], max = v[n - 1];
+  printf("%-9s %-10s %5d %-22s %-7s %11.1f %11.1f %11.1f %10.1f\n", scenario, "libgomp", width,
+         param, metric, med, p90, max, med - ideal);
+  if (csv)
+    fprintf(csv, "%s,%s,libgomp,%d,%s,%s,%.2f,%.2f,%.2f,%.2f\n", prefix, scenario, width, param,
+            metric, med, p90, max, med - ideal);
+}
+
+/* One call: the time of the first section and of the whole call, in us. */
+static void call(int width, int sections, double work, double *first, double *whole) {
+  double t0 = now_us();
+  for (int s = 0; s < sections; s++) {
+#pragma omp parallel num_threads(width)
+    busy(work);
+    if (s == 0) *first = now_us() - t0;
+  }
+  *whole = now_us() - t0;
+}
+
+static pid_t load_children[256];
+static int load_n;
+
+/* Foreign load: K children each busy P % of every 10 ms, until killed. */
+static void load_start(const char *spec) {
+  int k = 0, p = 0;
+  if (!spec || sscanf(spec, "%d:%d", &k, &p) != 2) return;
+  for (int i = 0; i < k && i < 256; i++) {
+    pid_t c = fork();
+    if (c == 0) {
+      for (;;) {
+        double t = now_us();
+        while (now_us() - t < 100.0 * p) relax();
+        usleep((useconds_t)(10000 - 100 * p > 0 ? 10000 - 100 * p : 0));
+      }
+    }
+    if (c > 0) load_children[load_n++] = c;
+  }
+  usleep(200000);
+}
+
+static void load_stop(void) {
+  for (int i = 0; i < load_n; i++) {
+    kill(load_children[i], SIGKILL);
+    waitpid(load_children[i], NULL, 0);
+  }
+}
+
+static int want(const char *s) {
+  const char *w = getenv("WAIT_OMP_SCENARIO");
+  return !w || !strcmp(w, "all") || !strcmp(w, s);
+}
+
+int main(int argc, char **argv) {
+  if (argc < 3) {
+    fprintf(stderr, "usage: wait_omp <width> <calls> [csv] [label]\n");
+    return 2;
+  }
+  int width = atoi(argv[1]), calls = atoi(argv[2]);
+  cpu_set_t set;
+  int cpus = sched_getaffinity(0, sizeof set, &set) == 0 ? CPU_COUNT(&set) : 0;
+  char host[256] = "";
+  gethostname(host, sizeof host - 1);
+  const char *label = argc > 4 ? argv[4] : "";
+  const char *load_spec = getenv("WAIT_OMP_LOAD");
+  char load_text[64];
+  int lk = 0, lp = 0;
+  if (load_spec && sscanf(load_spec, "%d:%d", &lk, &lp) == 2)
+    snprintf(load_text, sizeof load_text, "%dx%d%%", lk, lp);
+  else
+    snprintf(load_text, sizeof load_text, "%s",
+             getenv("WAIT_BENCH_LOAD") ? getenv("WAIT_BENCH_LOAD") : "none");
+  const char *load = load_text;
+  snprintf(prefix, sizeof prefix, "%s,%s,%d,%s", host, label, cpus, load);
+  if (argc > 3) {
+    int fresh = access(argv[3], F_OK) != 0;
+    csv = fopen(argv[3], "a");
+    if (csv && fresh)
+      fprintf(csv, "host,label,cpus,load,scenario,impl,width,param,metric,median_us,p90_us,max_us,overhead_us\n");
+  }
+  double *a = malloc(sizeof(double) * calls), *b = malloc(sizeof(double) * calls);
+  char param[64];
+  load_start(load_spec);
+  /* warm the hot team */
+  for (int i = 0; i < 10; i++) call(width, 10, 5, a, b);
+
+  int works[3] = {5, 20, 50};
+  for (int k = 0; k < 3 && want("sections"); k++) {
+    for (int i = 0; i < calls; i++) call(width, 200, works[k], &a[i], &b[i]);
+    snprintf(param, sizeof param, "work=%dus,sections=200", works[k]);
+    row("sections", width, param, "call", b, calls, 200.0 * works[k]);
+  }
+  int gaps[4] = {0, 100, 1000, 10000};
+  for (int k = 0; k < 4 && want("gaps"); k++) {
+    for (int i = 0; i < calls / 2; i++) {
+      if (gaps[k]) usleep(gaps[k]);
+      call(width, 10, 5, &a[i], &b[i]);
+    }
+    snprintf(param, sizeof param, "gap=%dus", gaps[k]);
+    row("gaps", width, param, "first", a, calls / 2, 5);
+    row("gaps", width, param, "call", b, calls / 2, 50);
+  }
+  if (want("acquire")) {
+    for (int i = 0; i < calls / 2; i++) call(width, 50, 20, &a[i], &b[i]);
+    row("acquire", width, "held_team", "call", b, calls / 2, 1000);
+  }
+  load_stop();
+  if (csv) fclose(csv);
+  return 0;
+}
diff --git a/benches/wait_scenarios.rs b/benches/wait_scenarios.rs
new file mode 100644
index 0000000..ac04349
--- /dev/null
+++ b/benches/wait_scenarios.rs
@@ -0,0 +1,626 @@
+//! How team threads wait, measured the way callers use them (`docs/design/waiting.md`).
+//!
+//! `cargo bench --bench wait_scenarios -- [options]` prints one table row per cell and, with
+//! `--csv <file>`, appends the same rows to a CSV file (`docs/design/waiting-data/`). Every cell
+//! repeats a *call* and reports the median, the 90th percentile and the maximum per call.
+//!
+//! A section is `width` participants each busy-waiting `work` microseconds on the clock, so the
+//! ideal time of a call is `sections * work`; the `overhead` column is the median minus that.
+//!
+//! Scenarios (`--scenario`, default `all`):
+//! * `sections`: a call is 200 sections of 5, 20 or 50 µs, on a team held across calls;
+//! * `gaps`: a call is 10 sections of 5 µs, the caller sleeps 0 / 100 µs / 1 ms / 10 ms between
+//!   calls; reports the first section of each call (wake latency + 5 µs) and the whole call;
+//! * `acquire`: a call is 50 sections of 20 µs, with the team held and a token minted per call
+//!   (`held_team`, as tenferro's `CpuEngine`), with the pool held and the members acquired per
+//!   call (`held_pool`, `Exec::new(..).team(..)`), and with a new pool per call (`fresh_pool`, as
+//!   faer's `with_team`; `total` times the build, the acquisition, the call and the drop, and
+//!   `build`, `acquire`, `release` and `drop` time those phases one by one);
+//! * `nested`: a call is 100 splits of the team into pairs, each pair running one 20 µs
+//!   section: many child leaders join at once (they share one sleeping place in the pool).
+//!
+//! Every scenario runs at the widths given by `--widths` (default: all CPUs of the affinity set,
+//! and three quarters of them), on threadteam and, as a reference, on a Rayon `scope` of the same
+//! width (`--impl threadteam,rayon`). The libgomp reference is `benches/omp/wait_omp.c` (README,
+//! "Wait benchmarks").
+//!
+//! Foreign load (`--load K:P`): `K` child processes of this binary, each busy `P` % of every 10 ms
+//! period, unpinned, for the whole run. They stand for another user's processes on a shared host.
+//!
+//! Options: `--scenario sections|gaps|acquire|nested|all`, `--widths 64,48`, `--impl threadteam,rayon`,
+//! `--load K:P`, `--calls N` (default 200; `gaps` and `acquire` use N/2), `--csv <file>`,
+//! `--label <text>` (the version or commit, written to the CSV); tuning of the waits (this
+//! version only, `docs/design/waiting.md`): `--spin-polls N`, `--throttled-polls N`,
+//! `--pressure-hold-ms N` (0 throttles only the waiter that saw a preemption),
+//! `--pressure-events N` (preemptions within the hold that throttle the pool; 0 never),
+//! `--own-hold-ms N` (how long a preemption throttles the member that saw it; default 0),
+//! `--preempt-gap-us N` (the gap that counts as a preemption after the warm-up; default 0:
+//! no detection, as libgomp), `--warm-ms N` (how long after a pool is built preemptions are
+//! detected with a 200 µs gap; default 200; 0: none). Under each
+//! threadteam row a `waits per call` line counts join and barrier sleeps, member parks and the
+//! preemptions waiters saw.
+
+use std::io::Write;
+use std::time::{Duration, Instant};
+use threadteam::{Pool, Team, WaitCounters};
+
+fn busy(us: u64) {
+    let end = Instant::now() + Duration::from_micros(us);
+    while Instant::now() < end {
+        std::hint::spin_loop();
+    }
+}
+
+fn cpus() -> usize {
+    #[cfg(target_os = "linux")]
+    unsafe {
+        let mut set: libc::cpu_set_t = std::mem::zeroed();
+        if libc::sched_getaffinity(0, std::mem::size_of::<libc::cpu_set_t>(), &mut set) == 0 {
+            let n = libc::CPU_COUNT(&set) as usize;
+            if n > 0 {
+                return n;
+            }
+        }
+    }
+    std::thread::available_parallelism().map_or(1, |n| n.get())
+}
+
+fn load_average() -> f64 {
+    let mut l = [0f64; 3];
+    unsafe { libc::getloadavg(l.as_mut_ptr(), 3) };
+    l[0]
+}
+
+fn host() -> String {
+    let mut buf = [0u8; 256];
+    unsafe { libc::gethostname(buf.as_mut_ptr().cast(), buf.len()) };
+    let end = buf.iter().position(|&b| b == 0).unwrap_or(buf.len());
+    String::from_utf8_lossy(&buf[..end]).into_owned()
+}
+
+/// Child processes that burn a share of a CPU each until dropped.
+struct Load(Vec<std::process::Child>);
+
+impl Load {
+    fn start(spec: Option<(usize, u64)>) -> Self {
+        let Some((k, pct)) = spec else {
+            return Load(Vec::new());
+        };
+        let exe = std::env::current_exe().expect("own path");
+        Load(
+            (0..k)
+                .map(|_| {
+                    std::process::Command::new(&exe)
+                        .args(["--load-child", &pct.to_string()])
+                        .spawn()
+                        .expect("a load child")
+                })
+                .collect(),
+        )
+    }
+}
+
+impl Drop for Load {
+    fn drop(&mut self) {
+        for c in &mut self.0 {
+            let _ = c.kill();
+            let _ = c.wait();
+        }
+    }
+}
+
+fn load_child(pct: u64) -> ! {
+    let period = Duration::from_millis(10);
+    let on = period * pct.min(100) as u32 / 100;
+    loop {
+        let t = Instant::now();
+        while t.elapsed() < on {
+            std::hint::spin_loop();
+        }
+        if let Some(rest) = period.checked_sub(t.elapsed()) {
+            std::thread::sleep(rest);
+        }
+    }
+}
+
+struct Stats {
+    median: f64,
+    p90: f64,
+    max: f64,
+}
+
+fn stats(mut v: Vec<f64>) -> Stats {
+    v.sort_by(|a, b| a.partial_cmp(b).unwrap());
+    Stats {
+        median: v[v.len() / 2],
+        p90: v[(v.len() * 9 / 10).min(v.len() - 1)],
+        max: v[v.len() - 1],
+    }
+}
+
+/// Pool settings from the command line (`--spin-polls`, `--throttled-polls`,
+/// `--pressure-hold-ms`); `None` keeps the library default.
+type Tuning = (
+    Option<u32>,
+    Option<(u32, Duration, u32, Duration)>,
+    Option<Duration>,
+    Option<Duration>,
+);
+static TUNING: std::sync::OnceLock<Tuning> = std::sync::OnceLock::new();
+
+fn pool(width: usize) -> Pool {
+    let mut b = Pool::builder()
+        .threads(width)
+        .acquire_timeout(Duration::from_secs(30));
+    if let Some((spin, throttle, gap, warm)) = TUNING.get() {
+        if let Some(g) = gap {
+            b = b.preempt_gap(*g);
+        }
+        if let Some(w) = warm {
+            b = b.warm_up(*w);
+        }
+        if let Some(n) = spin {
+            b = b.spin_polls(*n);
+        }
+        if let Some((polls, hold, events, own)) = throttle {
+            b = b.wait_tuning(*polls, *hold, *events, *own);
+        }
+    }
+    b.build().expect("a pool")
+}
+
+/// Counters of the waits between two snapshots.
+fn waits_between(a: WaitCounters, b: WaitCounters) -> WaitCounters {
+    WaitCounters {
+        join_sleeps: b.join_sleeps - a.join_sleeps,
+        barrier_sleeps: b.barrier_sleeps - a.barrier_sleeps,
+        member_parks: b.member_parks - a.member_parks,
+        pressure_events: b.pressure_events - a.pressure_events,
+    }
+}
+
+fn waits_sum(a: WaitCounters, b: WaitCounters) -> WaitCounters {
+    WaitCounters {
+        join_sleeps: a.join_sleeps + b.join_sleeps,
+        barrier_sleeps: a.barrier_sleeps + b.barrier_sleeps,
+        member_parks: a.member_parks + b.member_parks,
+        pressure_events: a.pressure_events + b.pressure_events,
+    }
+}
+
+fn snap(t: &Option<Team>) -> WaitCounters {
+    t.as_ref()
+        .map(|t| t.pool().wait_counters())
+        .unwrap_or_default()
+}
+
+/// Prints what the waits of the cell just reported did (stdout only).
+fn waits_line(c: WaitCounters, calls: usize) {
+    let per = |n: u64| n as f64 / calls.max(1) as f64;
+    println!(
+        "          waits per call: join sleeps {:.1}, barrier sleeps {:.1}, member parks {:.1}, preemptions seen {:.2}",
+        per(c.join_sleeps),
+        per(c.barrier_sleeps),
+        per(c.member_parks),
+        per(c.pressure_events)
+    );
+}
+
+fn team(width: usize) -> Team {
+    pool(width).into_team(width).expect("an idle pool")
+}
+
+/// One call of `sections` sections of `work` µs on a team; the time of the first section and of
+/// the whole call, in µs.
+fn call_team(team: &Team, width: usize, sections: usize, work: u64) -> (f64, f64) {
+    let mut exec = team.exec(width);
+    exec.team(|mut t| {
+        let t0 = Instant::now();
+        t.reborrow().run(|_, _| busy(work));
+        let first = t0.elapsed().as_secs_f64() * 1e6;
+        for _ in 1..sections {
+            t.reborrow().run(|_, _| busy(work));
+        }
+        (first, t0.elapsed().as_secs_f64() * 1e6)
+    })
+    .expect("a team token")
+}
+
+/// One call of `splits` splits of the team into pairs, each pair running one section of
+/// `work` µs; the time of the call in µs.
+fn call_nested(team: &Team, width: usize, splits: usize, work: u64) -> f64 {
+    let mut exec = team.exec(width);
+    exec.team(|mut t| {
+        let pairs = vec![2usize; t.size().get() / 2];
+        let t0 = Instant::now();
+        for _ in 0..splits {
+            t.reborrow()
+                .split(&pairs, |_, child| child.run(|_, _| busy(work)))
+                .expect("a split into pairs");
+        }
+        t0.elapsed().as_secs_f64() * 1e6
+    })
+    .expect("a team token")
+}
+
+/// One call that acquires its members from a held pool (`Exec::new(..).team(..)`); the time of
+/// the acquisition and the call, in µs.
+fn call_pool(pool: &Pool, width: usize, sections: usize, work: u64) -> f64 {
+    let t0 = Instant::now();
+    threadteam::Exec::new(pool, width)
+        .expect("a token")
+        .team(|mut t| {
+            for _ in 0..sections {
+                t.reborrow().run(|_, _| busy(work));
+            }
+        })
+        .expect("members for the scope");
+    t0.elapsed().as_secs_f64() * 1e6
+}
+
+/// The same call on a Rayon pool: one `scope` per section, `width - 1` spawned shares and one on
+/// the caller.
+fn call_rayon(pool: &rayon::ThreadPool, width: usize, sections: usize, work: u64) -> (f64, f64) {
+    pool.install(|| {
+        let t0 = Instant::now();
+        let mut first = 0.0;
+        for s in 0..sections {
+            rayon::scope(|sc| {
+                for _ in 1..width {
+                    sc.spawn(|_| busy(work));
+                }
+                busy(work);
+            });
+            if s == 0 {
+                first = t0.elapsed().as_secs_f64() * 1e6;
+            }
+        }
+        (first, t0.elapsed().as_secs_f64() * 1e6)
+    })
+}
+
+struct Row<'a> {
+    scenario: &'a str,
+    imp: &'a str,
+    width: usize,
+    param: String,
+    metric: &'a str,
+    s: Stats,
+    ideal_us: f64,
+}
+
+struct Out {
+    csv: Option<std::fs::File>,
+    prefix: String,
+}
+
+impl Out {
+    fn row(&mut self, r: Row<'_>) {
+        println!(
+            "{:<9} {:<10} {:>5} {:<22} {:<7} {:>11.1} {:>11.1} {:>11.1} {:>10.1}",
+            r.scenario,
+            r.imp,
+            r.width,
+            r.param,
+            r.metric,
+            r.s.median,
+            r.s.p90,
+            r.s.max,
+            r.s.median - r.ideal_us
+        );
+        if let Some(f) = &mut self.csv {
+            writeln!(
+                f,
+                "{},{},{},{},{},{},{:.2},{:.2},{:.2},{:.2}",
+                self.prefix,
+                r.scenario,
+                r.imp,
+                r.width,
+                r.param,
+                r.metric,
+                r.s.median,
+                r.s.p90,
+                r.s.max,
+                r.s.median - r.ideal_us
+            )
+            .expect("csv write");
+        }
+    }
+}
+
+fn main() {
+    let args: Vec<String> = std::env::args().skip(1).collect();
+    let value = |name: &str| {
+        args.iter()
+            .position(|a| a == name)
+            .and_then(|i| args.get(i + 1).cloned())
+    };
+    if let Some(pct) = value("--load-child") {
+        load_child(pct.parse().expect("--load-child <percent>"));
+    }
+    let scenario = value("--scenario").unwrap_or_else(|| "all".into());
+    let n = cpus();
+    let widths: Vec<usize> = value("--widths")
+        .map(|v| v.split(',').map(|w| w.parse().expect("--widths")).collect())
+        .unwrap_or_else(|| {
+            let mut w = vec![n, (n * 3 / 4).max(1)];
+            w.dedup();
+            w
+        });
+    let imps: Vec<String> = value("--impl")
+        .unwrap_or_else(|| "threadteam,rayon".into())
+        .split(',')
+        .map(String::from)
+        .collect();
+    let load_spec = value("--load").map(|v| {
+        let (k, p) = v.split_once(':').expect("--load K:P");
+        (k.parse().expect("--load K"), p.parse().expect("--load P"))
+    });
+    let calls: usize = value("--calls").map_or(200, |v| v.parse().expect("--calls"));
+    let label = value("--label").unwrap_or_default();
+    let spin = value("--spin-polls").map(|v| v.parse().expect("--spin-polls"));
+    let throttle = match (
+        value("--throttled-polls"),
+        value("--pressure-hold-ms"),
+        value("--pressure-events"),
+        value("--own-hold-ms"),
+    ) {
+        (None, None, None, None) => None,
+        (t, h, e, o) => Some((
+            t.map_or(100, |v| v.parse().expect("--throttled-polls")),
+            Duration::from_millis(h.map_or(100, |v| v.parse().expect("--pressure-hold-ms"))),
+            e.map_or(4, |v| v.parse().expect("--pressure-events")),
+            Duration::from_millis(o.map_or(0, |v| v.parse().expect("--own-hold-ms"))),
+        )),
+    };
+    let gap = value("--preempt-gap-us")
+        .map(|v| Duration::from_micros(v.parse().expect("--preempt-gap-us")));
+    let warm = value("--warm-ms").map(|v| Duration::from_millis(v.parse().expect("--warm-ms")));
+    TUNING.get_or_init(|| (spin, throttle, gap, warm));
+    let load_text = load_spec.map_or("none".into(), |(k, p)| format!("{k}x{p}%"));
+
+    let csv = value("--csv").map(|path| {
+        let fresh = !std::path::Path::new(&path).exists();
+        let mut f = std::fs::OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(&path)
+            .expect("csv file");
+        if fresh {
+            writeln!(
+                f,
+                "host,label,cpus,load,scenario,impl,width,param,metric,median_us,p90_us,max_us,overhead_us"
+            )
+            .expect("csv header");
+        }
+        f
+    });
+    let mut out = Out {
+        csv,
+        prefix: format!("{},{label},{n},{load_text}", host()),
+    };
+
+    let _load = Load::start(load_spec);
+    if load_spec.is_some() {
+        std::thread::sleep(Duration::from_millis(200));
+    }
+    println!(
+        "host {} cpus {n} load average {:.2} foreign load {load_text} label {label}",
+        host(),
+        load_average()
+    );
+    println!(
+        "{:<9} {:<10} {:>5} {:<22} {:<7} {:>11} {:>11} {:>11} {:>10}",
+        "scenario", "impl", "width", "param", "metric", "median us", "p90 us", "max us", "overhead"
+    );
+
+    let want = |s: &str| scenario == "all" || scenario == s;
+    for &w in &widths {
+        let rayon_pool = imps.iter().any(|i| i == "rayon").then(|| {
+            rayon::ThreadPoolBuilder::new()
+                .num_threads(w)
+                .build()
+                .expect("a rayon pool")
+        });
+        let mut held = imps.iter().any(|i| i == "threadteam").then(|| team(w));
+
+        if want("sections") {
+            for work in [5u64, 20, 50] {
+                let sections = 200;
+                let param = format!("work={work}us,sections={sections}");
+                let ideal = (sections as u64 * work) as f64;
+                if let Some(t) = &held {
+                    let c0 = snap(&held);
+                    let v = (0..calls)
+                        .map(|_| call_team(t, w, sections, work).1)
+                        .collect();
+                    out.row(Row {
+                        scenario: "sections",
+                        imp: "threadteam",
+                        width: w,
+                        param: param.clone(),
+                        metric: "call",
+                        s: stats(v),
+                        ideal_us: ideal,
+                    });
+                    waits_line(waits_between(c0, snap(&held)), calls);
+                }
+                if let Some(p) = &rayon_pool {
+                    let v = (0..calls)
+                        .map(|_| call_rayon(p, w, sections, work).1)
+                        .collect();
+                    out.row(Row {
+                        scenario: "sections",
+                        imp: "rayon",
+                        width: w,
+                        param,
+                        metric: "call",
+                        s: stats(v),
+                        ideal_us: ideal,
+                    });
+                }
+            }
+        }
+
+        if want("gaps") {
+            for gap_us in [0u64, 100, 1_000, 10_000] {
+                let (sections, work) = (10, 5u64);
+                let param = format!("gap={gap_us}us");
+                let gap = Duration::from_micros(gap_us);
+                let run = |f: &mut dyn FnMut() -> (f64, f64)| {
+                    let mut first = Vec::new();
+                    let mut whole = Vec::new();
+                    for _ in 0..calls / 2 {
+                        if !gap.is_zero() {
+                            std::thread::sleep(gap);
+                        }
+                        let (a, b) = f();
+                        first.push(a);
+                        whole.push(b);
+                    }
+                    (stats(first), stats(whole))
+                };
+                if let Some(t) = &held {
+                    let c0 = snap(&held);
+                    let (a, b) = run(&mut || call_team(t, w, sections, work));
+                    let c = waits_between(c0, snap(&held));
+                    out.row(Row {
+                        scenario: "gaps",
+                        imp: "threadteam",
+                        width: w,
+                        param: param.clone(),
+                        metric: "first",
+                        s: a,
+                        ideal_us: work as f64,
+                    });
+                    out.row(Row {
+                        scenario: "gaps",
+                        imp: "threadteam",
+                        width: w,
+                        param: param.clone(),
+                        metric: "call",
+                        s: b,
+                        ideal_us: (sections as u64 * work) as f64,
+                    });
+                    waits_line(c, calls / 2);
+                }
+                if let Some(p) = &rayon_pool {
+                    let (a, b) = run(&mut || call_rayon(p, w, sections, work));
+                    out.row(Row {
+                        scenario: "gaps",
+                        imp: "rayon",
+                        width: w,
+                        param: param.clone(),
+                        metric: "first",
+                        s: a,
+                        ideal_us: work as f64,
+                    });
+                    out.row(Row {
+                        scenario: "gaps",
+                        imp: "rayon",
+                        width: w,
+                        param,
+                        metric: "call",
+                        s: b,
+                        ideal_us: (sections as u64 * work) as f64,
+                    });
+                }
+            }
+        }
+
+        if want("nested") && w >= 4 {
+            if let Some(t) = &held {
+                let (splits, work) = (100, 20u64);
+                let c0 = snap(&held);
+                let v = (0..calls / 2)
+                    .map(|_| call_nested(t, w, splits, work))
+                    .collect();
+                out.row(Row {
+                    scenario: "nested",
+                    imp: "threadteam",
+                    width: w,
+                    param: "pairs,splits=100,work=20us".into(),
+                    metric: "call",
+                    s: stats(v),
+                    ideal_us: (splits as u64 * work) as f64,
+                });
+                waits_line(waits_between(c0, snap(&held)), calls / 2);
+            }
+        }
+
+        if want("acquire") && imps.iter().any(|i| i == "threadteam") {
+            // No other team of this process stays reserved while these arms run.
+            drop(held.take());
+            let (sections, work) = (50, 20u64);
+            let ideal = (sections as u64 * work) as f64;
+            let mut row = |param: &str, metric: &'static str, v: Vec<f64>| {
+                out.row(Row {
+                    scenario: "acquire",
+                    imp: "threadteam",
+                    width: w,
+                    param: param.into(),
+                    metric,
+                    s: stats(v),
+                    ideal_us: ideal,
+                })
+            };
+            {
+                let t = team(w);
+                let c0 = t.pool().wait_counters();
+                let v = (0..calls / 2)
+                    .map(|_| call_team(&t, w, sections, work).1)
+                    .collect();
+                row("held_team", "call", v);
+                waits_line(waits_between(c0, t.pool().wait_counters()), calls / 2);
+            }
+            {
+                let p = pool(w);
+                let c0 = p.wait_counters();
+                let v = (0..calls / 2)
+                    .map(|_| call_pool(&p, w, sections, work))
+                    .collect();
+                row("held_pool", "call", v);
+                waits_line(waits_between(c0, p.wait_counters()), calls / 2);
+            }
+            // The phases of a pool built for one call: build, acquisition of its
+            // members, the call, the release of the team and the drop of the pool.
+            let (mut build, mut acquire, mut call, mut release, mut drop_pool, mut total) = (
+                Vec::new(),
+                Vec::new(),
+                Vec::new(),
+                Vec::new(),
+                Vec::new(),
+                Vec::new(),
+            );
+            let us = |a: Instant, b: Instant| (b - a).as_secs_f64() * 1e6;
+            let mut c = WaitCounters::default();
+            for _ in 0..calls / 2 {
+                let t0 = Instant::now();
+                let p = pool(w);
+                let t1 = Instant::now();
+                let t = p.into_team(w).expect("an idle pool");
+                let t2 = Instant::now();
+                let c0 = t.pool().wait_counters();
+                call.push(call_team(&t, w, sections, work).1);
+                c = waits_sum(c, waits_between(c0, t.pool().wait_counters()));
+                let t3 = Instant::now();
+                let p = t.into_pool();
+                let t4 = Instant::now();
+                drop(p);
+                let t5 = Instant::now();
+                build.push(us(t0, t1));
+                acquire.push(us(t1, t2));
+                release.push(us(t3, t4));
+                drop_pool.push(us(t4, t5));
+                total.push(us(t0, t5));
+            }
+            row("fresh_pool", "call", call);
+            row("fresh_pool", "total", total);
+            row("fresh_pool", "build", build);
+            row("fresh_pool", "acquire", acquire);
+            row("fresh_pool", "release", release);
+            row("fresh_pool", "drop", drop_pool);
+            waits_line(c, calls / 2);
+        }
+    }
+}
diff --git a/docs/design/placement.md b/docs/design/placement.md
index 7d489ee..da8c02b 100644
--- a/docs/design/placement.md
+++ b/docs/design/placement.md
@@ -326,11 +326,10 @@ closure, the participant count, a padded completion counter, a sense-reversing
 barrier, a cancellation flag and an atomic cell for the first panic payload.
 The leader stores the section address and the participant index into each
 member slot and bumps its `gen` counter with release ordering; members poll
-`gen` and `state` with one PAUSE per poll (`spin_loop`, no `sched_yield`) and
-run their share and decrement the completion counter. After the reservation's
-park delay (the effective `idle_spin`, or zero in an oversubscribed root scope,
-see below) without work, a member parks (see below). The leader runs
-share 0, then waits for the counter, polling the same way. Nothing is allocated and nobody is woken
+`gen` and `state`, run their share and decrement the completion counter. The
+leader runs share 0, then waits for the counter. Every one of these waits
+(a member waiting for work, the leader's join, a barrier) is a staged episode,
+spin, a few yields, then sleep, described in [`waiting.md`](waiting.md). Nothing is allocated, and a dispatch wakes only members that are asleep
 (`tests/team_alloc_free.rs`; acquisition allocates a small `Vec` and, for
 members not already awake, the claim jobs).
 
@@ -406,36 +405,35 @@ release it when they return, so a caller that needs the team across several
 entries keeps the token and lends it with `reborrow`. No thread-local state is
 involved (the owner's thread id is stored in the team).
 
-**Parking.** A reserved member that finds no new section for the park delay
-(the effective `idle_spin` of the reservation: the pool default or the
-`reserve_with` / `team_with` override) parks and stays reserved. All parked
-members of a pool wait on one condition variable (`park_lock`, `park_cv`), with
-a counter `parked` of members inside or entering the wait. The protocol:
+**Parking.** A reserved member that finds no new section within its staged
+wait (spin budget, a few yields; [`waiting.md`](waiting.md)) parks and stays
+reserved. Each member slot has its own `Parker`, and a leader wakes only
+the slots it changed (a publish, a release, a lend); the joins and barriers
+sleep on one pool-wide `Parker`. The protocol of every `Parker`:
 
-* A member raises `parked` (acquire-release increment), takes the lock,
-  re-checks `gen`, `state` and `lent` and waits only while none changed; it
+* A sleeper raises `parked` (acquire-release increment), takes the lock,
+  re-checks the state it waits on and waits only while it is unchanged; it
   lowers `parked` when it leaves.
-* A leader changes the state a member waits on (bumps `gen`, stores `IDLE`,
-  sets `lent`), then reads `parked` with an acquire-release `fetch_add(0)`. If it
-  is nonzero, the leader takes and drops the lock and calls `notify_all`. Either the member sees the changed
-  state after raising `parked`, or the leader sees `parked` (both are read-modify-writes of one atomic, so the
-  argument needs only its modification order and release sequences, not a total
-  order of SeqCst accesses, which `loom` does not model); and because the
-  leader takes the lock before notifying, the notification cannot fall between a
-  member's check and its wait (the usual condition-variable handshake).
-* With nobody parked a dispatch pays one uncontended atomic read-modify-write.
-  A broadcast also wakes parked members of other teams of the same pool, which
-  re-check and sleep again; the leader pays one syscall, not one per member.
-* Spurious wake-ups loop. There is no per-member wake state: every parked member
-  waits on the one condition variable, so no wake-up depends on the order in
-  which a leader publishes to individual members.
+* A waker changes the state (SeqCst), then reads `parked` with an
+  acquire-release `fetch_add(0)`. If it is nonzero, it takes and drops the lock
+  and calls `notify_all`. Either the sleeper sees the changed state after
+  raising `parked`, or the waker sees `parked` (both are read-modify-writes of
+  one atomic, so the argument needs only its modification order and release
+  sequences, not a total order of SeqCst accesses, which `loom` does not
+  model); and because the waker takes the lock before notifying, the
+  notification cannot fall between a sleeper's check and its wait.
+* With nobody asleep a wake costs one uncontended atomic read-modify-write.
+  Spurious wake-ups loop. Which parker each wait uses, and when it sleeps, is
+  in [`waiting.md`](waiting.md).
 
 The handshake is the small `Parker` type in `src/park.rs`, built on a `sync`
 shim (`std`, or `loom` under `--cfg loom`), and checked three ways:
 
 * **Model check.** `tests/loom_park.rs` runs the real `Parker` under `loom` with
-  one leader and two members: a published section, a released reservation, and a
-  member that parks twice. The correctness argument therefore uses only what loom
+  one leader and two members: a published section, a released reservation, a
+  member that parks twice, and per-slot parkers; and the exact join and barrier
+  code (`Completion`, `Barrier`): a leader asleep in a join, consecutive
+  barrier rounds, and a cancellation waking a sleeper. The correctness argument therefore uses only what loom
   models (modification order and release sequences of `parked`). CI job `loom`:
   `RUSTFLAGS="--cfg loom" cargo test --release --test loom_park`.
 * **Forced interleavings.** With the feature `test-hooks`, `test_hooks` lets a
@@ -454,63 +452,12 @@ with a zero idle spin and broadcasts, so the members return to Rayon at once.
 
 ### How a reserved member and a joining leader wait
 
-Two waits exist, both allocation-free and both unchanged in the handshake:
-
-* **Reserved members polling `gen`, and a leader in `Section::join` or
-  `Section::barrier`, in a scope that is not oversubscribed**: one
-  `std::hint::spin_loop()` per poll (PAUSE on x86, YIELD/ISB on aarch64), never
-  a `yield_now`. A thread that only issues PAUSE stays runnable but does not
-  re-enter the scheduler on every poll, so a pair the scheduler stacked on one
-  CPU can be separated instead of preempting each other in a yield loop, and a
-  share does not pay a syscall per poll. This is libgomp's shape. A reserved
-  member still parks after its park delay, which is what ends the spin; nothing
-  else wakes it.
-* **Acquisition, the cold claim, and the `IDLE` / leaving states**: `backoff`
-  as before (a bounded pure spin, then one `yield_now` per poll). Those threads
-  are not reserved yet or are on their way out, so they must cooperate to make
-  progress on a loaded host.
-
-**Oversubscription.** A root team scope is oversubscribed when its participants
-number more than the CPUs in the **entering thread's** affinity mask (on
-non-Linux targets: `std::thread::available_parallelism()`). It is decided at
-root-scope entry on that thread, whether or not participant pinning is on: at
-`Exec::team_with` (acquisition path and the carried path of a root token minted
-by a `Team`), and for a `Team` also when its root token is minted
-(`Team::exec`/`try_exec`), which is the pressure a token used without a team
-scope reports. Because the scope entry repeats it, a token minted on one CPU set
-and used on another is paced and placed by the set of the thread that enters the
-scope, never by the one it was minted on. The result is carried into
-`TeamExec`, team-carrying `Exec` tokens, `reborrow`, `limit`, `split` and `fork`
-children and every `Section`, so a nested section of an oversubscribed root
-knows it too; it is never recomputed from a child's size. The members' park
-delay is written to their slots at the same entry. In such a scope:
-
-* the park delay of the reserved members is **zero**, so a member that finds no
-  section spins one short episode (64 polls) and parks instead of holding a CPU
-  for the whole `idle_spin`. `polls` and `spins` are reset at the start of each
-  idle episode, so the episode is counted afresh;
-* `Section::join` and `Section::barrier` spin about 100 times and then
-  `yield_now` per poll, the shape libomp takes when it detects more threads than
-  CPUs, so the waiting participants do not hold every CPU while their peers are
-  queued behind them.
-
-The flag is per scope and per root; overlapping teams or pools are the caller's
-business (see the placement warning below). This is the behaviour libgomp
-throttles to about 100 spins when oversubscribed; measured on broccoli, parking
-alone did not remove the tensor4all/faer#107 slow mode, so the zero park delay is
-about the CPU a member burns, not about the mode.
-
-**Quality of service.** `PoolBuilder::qos(Qos)` sets the class of each worker
-when it starts (`pthread_set_qos_class_self_np` on Apple targets, nothing
-elsewhere; no platform type is public). The default is `UserInitiated` on
-macOS. `threadteam` never changes the caller's class, but the calling thread
-leads every section, so `raise_current_thread_qos(Qos)` raises the calling
-thread to at least the given class and never lowers it (the current class is
-read first); an engine calls it once for its leading thread. In the wake probe
-the class (builder default, explicit `Default`, `UserInteractive`) made no
-measurable difference to the wake latency on this host. Dropping the
-team stores `IDLE` with a zero idle spin and wakes them, so the members return to
-Rayon at once.
+Replaced by [`waiting.md`](waiting.md): every team wait spins for the pool's
+spin budget in polls, yields a few times, then sleeps; the leader's join and
+the barriers sleep on a pool-wide parker; a descheduled waiter throttles the
+pool's waits. The earlier design (PAUSE-only spin with a wall-time park delay
+for members and no sleep at all in joins and barriers) is in the history of
+this file.
 
 ### Participant placement (opt-in)
 
@@ -591,69 +538,13 @@ How it works:
 
 ### Waiting policy
 
-`PoolBuilder::idle_spin` (default 200 ms, may be zero) and
-`PoolBuilder::idle_runs_rayon` (default `false`) set `WaitPolicy` defaults; an
-oversubscribed root scope overrides the park delay with zero for its own
-reservation only;
-`acquire_timeout` is separate. `WaitOverride` (partial policy) applies to one
-operation: `Exec::team_with` for a root reservation, `TeamExec::with_wait` for a
-scope. Children inherit the effective policy and may override it for their own
-scope. The root reservation's effective policy is stored in its members' slots
-when it ends and governs the idle interval that follows; the interval starts
-when the reservation ends, not when the member last computed. A reserved member
-never leaves on a timeout and never runs an unrelated Rayon job (it parks, still
-reserved, after the park delay), whatever the policy, so an override cannot weaken a reservation, and a child's override
-expires when the child returns and cannot release its parent's members.
-With `idle_runs_rayon`, an idle member calls `rayon::yield_now`, whose job runs
-to completion before the member is claimable again. Without it, an idle member
-leaves its worker out of Rayon service for up to `idle_spin`; a following
-`broadcast` or a Rayon job that needs every worker then waits for them, so a
-caller that alternates with such work sets a short spin or calls
-`Pool::release_idle`.
-
-**Idle clock and the default delay.** The park delay of a reserved member is
-measured on a clock that belongs to that member alone: it starts when the
-member first finds nothing to do after its own last share (or after it started,
-or was taken back from a lend), and it restarts with every share the member
-runs. A share of another member does not move it, and neither does anything the
-leader does between sections. When the clock exceeds the delay the member
-parks. Consequences:
-
-* A team that runs no section costs CPU for the delay after the team is built
-  (or after its last section), then nothing: members that spin beyond that are a
-  bug.
-* Sections less than the delay apart keep every participating member spinning
-  the whole time. That is the intended behaviour, not a leak: it is what makes a
-  dispatch cost one atomic store and no syscall (about 0.3 us, against some tens of
-  us after a park on the reference M5, see `benches/spin_grid.rs`).
-* A CPU measurement over a window of sequential work therefore depends on where
-  the window sits relative to the last section (or the construction of the team):
-  a window inside the first 200 ms reads about `width - 1` extra cores, a window
-  after it reads one. Measure CPU after a settle time longer than the delay, or
-  say what the window contains.
-
-The default is 200 ms, the same as the default blocktime of the LLVM and Intel
-OpenMP runtimes (`KMP_BLOCKTIME`): long enough that a loop of small parallel
-regions with serial work between them never pays a wake-up, short enough that a
-program that stops using the team goes quiet within a fifth of a second. The
-sweep in `benches/spin_grid.rs` (6 participants) shows the trade: with a 200 ms
-delay a dispatch after a 100 ms gap costs 12 us (members still spinning, 4.9
-cores); with a zero delay it costs 37 us after any gap and members use no CPU.
-Callers with sparse sections set a shorter delay with `idle_spin` or
-`team_with`.
-
-The clock is explicit in the code (`last_work` in `member_loop`) and visible
-with the feature `trace`, which stamps every member transition (enter, share
-begin and end, park enter and exit, lend, leave) into a preallocated ring; the
-bench `idle_trace` prints each member's spin, park and run time per phase and
-`tests/idle_clock.rs` checks that a member parks neither before the delay since
-its own last share nor never.
-
-`Pool::release_idle` bumps an epoch: idle members leave at once, reserved
-members leave when their reservation ends. It never revokes a live token and
-does not wait, so it may be called inside a reservation. Dropping the pool
-signals shutdown, which idle members honour. `Pool::resident_members` reports
-the number of awake members (diagnostic).
+`PoolBuilder::idle_spin` (default 200 ms, may be zero) and `idle_runs_rayon`
+govern an *unreserved* idle member, the state a member is in after a scoped
+team (`Exec::team`) ended: it stays claimable without a Rayon wake-up until
+`idle_spin` passes or it has polled for the pool's spin budget, whichever
+comes first, then returns to Rayon. `WaitOverride` overrides them per scope.
+Reserved members do not use `idle_spin` any more; their waits, and the joins
+and barriers, follow [`waiting.md`](waiting.md).
 
 ### Unwind
 
diff --git a/docs/design/waiting-data/README.md b/docs/design/waiting-data/README.md
new file mode 100644
index 0000000..4db405e
--- /dev/null
+++ b/docs/design/waiting-data/README.md
@@ -0,0 +1,6 @@
+# Wait benchmark results
+
+One CSV per host, written by `scripts/bench-waits.sh` (columns: host, label, cpus, load, scenario,
+impl, width, param, metric, median_us, p90_us, max_us, overhead_us). `label` names the commit or
+version measured; `load` is the foreign load of that pass (`none` or `KxP%`). Times are per call in
+microseconds; `overhead_us` is the median minus the ideal `sections * work`.
diff --git a/docs/design/waiting.md b/docs/design/waiting.md
new file mode 100644
index 0000000..bf6de5b
--- /dev/null
+++ b/docs/design/waiting.md
@@ -0,0 +1,177 @@
+# How team threads wait
+
+This record covers how the threads of a team wait:
+- a reserved member, between sections and between calls;
+- the leader, in `Section::join`;
+- every participant, in `Section::barrier`.
+
+It replaces the waits of 0.1.3 with the shape of the OpenMP runtimes: a bounded spin, then a short yield phase, then a sleep on a futex. Maintainer decision, 2026-10-29: 「threadteam の待ち方を OpenMP に近づけるのがいいと思う」. The trigger is tensor4all/faer#107.
+
+## What 0.1.3 does, and why it stacks
+
+| wait | 0.1.3 |
+| --- | --- |
+| reserved member polling `gen` (between sections and between calls) | one PAUSE per poll; parks after `idle_spin` of **wall time** (200 ms), or after 64 polls when the scope is oversubscribed |
+| leader in `Section::join` | one PAUSE per poll, **never sleeps**; when oversubscribed, ~100 PAUSEs, then `yield_now` per poll |
+| participant in `Section::barrier` | same as `join` |
+| unreserved `IDLE` member | `backoff` (2^14 PAUSEs, then `yield_now`) for `idle_spin` of wall time, then returns to Rayon |
+
+"Oversubscribed" means more participants than CPUs in the caller's affinity set. Foreign load is not counted.
+
+faer#107, broccoli, 64 threads on 64 CPUs with another user's processes at 5-13 %:
+- a fresh pool per call is slow in 20/20 processes (gemm 128: a fixed 16 ms against 0.02 ms);
+- chol 2048 is slow in 10/10 processes even with the pool held;
+- at width 48 on 64 CPUs the slow mode disappears (0.02 ms, 0 % stacked).
+
+The mechanism:
+- At width = CPUs, every CPU holds a participant that is either working or spinning, so no CPU is ever idle.
+- Linux moves a runnable thread from a busy CPU to another CPU mainly when that CPU goes idle (newidle balancing). Periodic balancing has nothing to gain from a 2-to-1 move.
+- So once a member shares a CPU with another runnable thread (a peer, the spare worker, or a foreign process), the pair stays put. Every section then waits for the descheduled member's next time slice.
+- `yield_now` does not help: it hands the CPU to a thread that is already on it, and it leaves no CPU idle.
+
+The only wait that frees a CPU is a sleep.
+
+## What the OpenMP runtimes do (read from their sources; no code is taken)
+
+**libgomp** (gcc `libgomp/config/linux/wait.h`, `bar.c`, `team.c`, `env.c`):
+- **Wait.** `do_wait` polls the futex word up to `gomp_spin_count_var` times, with one `cpu_relax` (PAUSE) per poll, then calls `futex_wait`.
+- **Spin count.** The count is in polls, not in time. The default without `OMP_WAIT_POLICY` is 300000, "a rough estimation of 100000 spins per msec", so about 3 ms, "e.g. 5 times longer or 5 times shorter" depending on the CPU. It is 0 under `PASSIVE`, 3·10^10 under `ACTIVE`, and 1 on x86 hybrid CPUs (`config/linux/x86/spincount.h`).
+- **Throttling.** When libgomp's own threads outnumber the available CPUs (`gomp_managed_threads > gomp_available_cpus`), the count drops to `gomp_throttled_spin_count_var`: 100 by default, 1000 under `ACTIVE`.
+- **Foreign load.** It is not considered.
+- **Barriers.** A barrier is a generation word. The last arriving thread bumps it and calls `futex_wake(INT_MAX)`; the others `do_wait` on it.
+- **Region start.** Pool threads wait between regions on the `threads_dock` simple barrier, and the master's arrival releases them. That barrier covers the whole team, because a region always uses the whole team.
+
+**LLVM libomp** (`openmp/runtime/src/kmp_wait_release.h`, `kmp.h`, `kmp_global.cpp`, `kmp_runtime.cpp`):
+- **Wait.** `__kmp_wait_template` spins with `KMP_CPU_PAUSE` (TPAUSE where available). It yields only when the runtime's own threads exceed the available processors (`KMP_OVERSUBSCRIBED`, `__kmp_use_yield`). It suspends once `KMP_BLOCKTIME` is exhausted.
+- **Blocktime.** The blocktime is **wall time**, checked against `rdtsc` (`KMP_BLOCKING`). The default is 200 ms (`KMP_DEFAULT_BLOCKTIME`), and 0 on hybrid CPUs. With `KMP_ADJUST_BLOCKTIME`, it drops to 0 when there are more threads than processors.
+- **Library mode.** The default `KMP_LIBRARY=throughput` keeps the blocktime. `turnaround` yields only when oversubscribed.
+- **Hot teams.** A team's threads are kept across parallel regions and wait in the fork barrier under the same blocktime rule.
+- **Foreign load.** It is not considered either.
+
+**Implications for threadteam:**
+1. Both runtimes eventually sleep in **every** wait, and neither leaves a waiter spinning forever. That is what lets an idle CPU appear and pull a stacked thread.
+2. libgomp counts **polls**, and libomp counts **time**. A count is consumed only while the waiter runs, so a waiter that is descheduled behind a peer on the same CPU does not use up its budget by waiting in the run queue. A time budget expires there too, and makes the waiter sleep for the wrong reason. threadteam 0.1.3 uses time, like libomp, but 200 ms is far longer than any gap that matters.
+3. Neither runtime reads foreign load. threadteam does, below, because the faer#107 configuration (width = CPUs, foreign processes) is exactly where the static participants-against-CPUs test says "not oversubscribed".
+
+## Design
+
+### Waits
+
+Every wait is an episode of three phases.
+
+1. **Spin.** Poll the condition with one PAUSE (YIELD on aarch64) per poll, for at most `spin_polls` polls. The budget is a count, so it is consumed only while the waiter runs.
+2. **Yield.** Then `yield_now` between polls, for at most `YIELD_POLLS = 16` polls. A peer queued on the same CPU then gets the CPU without paying a futex round trip.
+3. **Sleep.** Then sleep on a `Parker`, until the condition changes or the episode is ended for that waiter.
+
+| wait | condition | sleeps on |
+| --- | --- | --- |
+| reserved member | `gen` changed, the reservation ended, or the member was lent | its slot's `Parker` (unchanged: the leader wakes only the slots it changed) |
+| leader in `join` | `remaining == 0` | the pool's `sync` `Parker`, woken by the member that brings `remaining` to 0 |
+| participant in `barrier` | `epoch` changed, or the section was cancelled | the pool's `sync` `Parker`, woken by the last arrival and by `fail` |
+| unreserved `IDLE` member (after a scoped `Exec::team` ended) | claimed, released, `idle_spin` elapsed, **or the spin budget of polls spent** | returns to Rayon (whose idle worker sleeps after 33 rounds); a team released between calls no longer keeps its members polling for the whole `idle_spin` |
+| acquisition (`acquire`, `claim_cold`) | unchanged (`backoff`) | — |
+
+The `sync` parker is **one per pool** (in `Awake`), not one per section:
+- Sections are stack objects on the hot path. A `Parker` is touched once when it is built (some platforms allocate lazily), so building one per section would cost on every section.
+- A member may touch the parker after its final decrement of `remaining`. By then the leader may have returned and freed the section, but the pool outlives every member loop.
+
+Every leader on a pool shares the parker: two teams on one pool, and also the child leaders of one team's `split` and `fork`, which join at the same time. A wake wakes every sleeper, and each re-checks its own condition. That is correct, and it is not rare: a split of 64 participants into 32 pairs can have 32 child leaders asleep at once. It is kept simple until a measurement shows the broad wake costs something; the `nested` bench scenario (100 splits into pairs per call) is that measurement.
+
+Both new wake points follow the existing `Parker` protocol, which `loom` already models:
+1. change the state with SeqCst: the final `remaining` decrement, the epoch bump, the `cancelled` store;
+2. then call `Parker::wake`, one `fetch_add(0)` that is enough when nobody is parked.
+
+The last member of a section therefore pays one extra uncontended read-modify-write. It reads the pool's parker before its final decrement and never touches the section after it (the leader may free the section as soon as it sees zero); the pool outlives every member loop. The join and the barrier are small types in `src/park.rs` (`Completion`, `Barrier`) that the sections use and that `tests/loom_park.rs` checks as they are: the last of two members waking a sleeping leader, two consecutive barrier rounds, and a cancellation waking a sleeper. Each model fails (deadlock) when its wake is removed.
+
+### Budget
+
+- **A count, as in libgomp.** The budget is `PoolBuilder::spin_polls`, a number of polls (one PAUSE, or YIELD on aarch64, per poll). A waiter that is descheduled does not spend it while it waits for its CPU.
+- **Default: 300000 polls on x86-64**, libgomp's `GOMP_SPINCOUNT` ("about 3 ms"; about 7 ms at the 24 ns per poll measured on Zen 3). 2^21 on aarch64, not measured yet.
+  - 12288 polls (about 300 µs) made the first section after a 1 ms or 10 ms gap 2.3x and 10.8x slower than 0.1.3 on a quiet host (evo): the members had gone to sleep. 131072 closed the 1 ms gap; 300000 also closes the 10 ms gap (evo, `d430347` runs), and is accepted as the OpenMP default (criterion d).
+  - libomp keeps 200 ms (`KMP_BLOCKTIME`); 0.1.3 kept 200 ms of wall time for members and never slept in joins.
+- **No calibration.** Converting a time to polls at pool build was considered and dropped (pre-review): a calibration taken while the CPU is contended yields too few polls, and a bare PAUSE loop is not the real poll anyway. The count is approximate in time, as libgomp's is.
+- **Throttled budget.** 100 polls (libgomp's value) when the root scope is statically oversubscribed, or while a new pool is under sustained pressure (below).
+
+### Scheduling pressure: only while a pool is new
+
+**Default: libgomp's waits.** Once a pool is past its warm-up, its waits detect nothing: every wait spins 300000 polls, yields 16 times and sleeps, as libgomp's do (`GOMP_SPINCOUNT`, futex).
+- On broccoli (`e76036c`, 16:58Z) this was the only configuration that met criteria (b) and (c) together: on quiet hosts held teams within 10 % of 0.1.3, and under load `held_team` at 0.91x libgomp, `held_pool` +7.8 %, gaps on par with libgomp.
+- Every detecting variant made held teams under load 3.5-4x slower than libgomp, because detection throttled waits that libgomp keeps spinning.
+- The main path of real use is a held pool: tenferro's `CpuEngine` holds its pool, and libomp and libgomp hold hot teams.
+
+**Warm-up: detection while a pool is new (default 200 ms after it is built).** Without any detection, a pool built for one call (`fresh_pool`, faer's `with_team`) collapsed (87.6 ms): its freshly spawned threads start stacked, because the scheduler places new threads before it knows their load, and spinning members never leave a CPU idle to pull one over. So during the warm-up a new pool's waiters detect preemptions and the pool can throttle, as in `c0c024b`, which kept the faer#107 arms at zero:
+- **Detection.** A spinning waiter reads the clock every 64 polls. A gap of more than 200 µs between two reads means it was descheduled while it spun: 64 polls take well under 10 µs, and a scheduler slice is 0.75 ms or more.
+- **Response.** That waiter ends its spin (yields, then sleeps). The pool counts the observations, and once 4 come within 100 ms of each other, every wait of the pool adopts the throttled budget (100 polls) at its first clock read, for 100 ms (`fetch_max`).
+- **Limits of the signal.** It is a pressure heuristic: foreign load, the team's own threads, interrupts and VM steal look alike, and it only shortens active waiting.
+- **Cost after the warm-up.** None in the poll loop: a wait's first clock read finds detection off, and that wait stops reading the clock.
+
+**What was tried and measured on the way** (broccoli and evo, threadteam-rs#14):
+
+| detection | quiet held teams | held teams under load | fresh pool |
+| --- | --- | --- | --- |
+| a pool-wide throttle on one preemption | 4x slower than 0.1.3 | — | fixed |
+| a pool-wide throttle on 4 preemptions within 100 ms (`c0c024b`) | within 10 % | 3.5-4x libgomp | fixed |
+| a per-thread 100 ms throttle (`2773c36`) | 1.2-1.8x slower | — | fixed |
+| none (`e76036c` variant) | within 10 % | about libgomp | collapsed (87.6 ms) |
+
+**Knobs and counters for the benchmarks** (`PoolBuilder::preempt_gap`, `warm_up`, `wait_tuning`, all hidden; bench flags `--preempt-gap-us`, `--warm-ms`, `--pressure-events`, `--pressure-hold-ms`, `--throttled-polls`, `--own-hold-ms`):
+- detection after the warm-up (a nonzero gap);
+- the warm-up length;
+- the pool threshold, the hold and the throttled budget;
+- a per-thread hold.
+
+`Pool::wait_counters` (hidden) counts join and barrier sleeps, member parks and observed preemptions, printed under every bench row.
+
+### Start of a section: no arrival barrier
+
+A section starts when its members observe their `gen`. There is no barrier in which every participant first announces itself. libgomp's region start is a whole-team dock barrier, because a region always uses the whole team. threadteam sections can be narrower than the team (faer narrows regions to the width that pays), and waking or waiting for members a section does not use would make narrow sections pay for the whole team.
+
+A member that slept is woken by the leader's publish on its slot. That wake only makes it runnable; no arrival acknowledgement is needed for a section's correctness, because the reservation's acknowledgement at acquisition already put every member on its own thread, and the section's publication and completion protect its storage. The join at the end of the section is the only barrier. `Section::barrier` inside a share is unchanged in meaning and gains the sleep phase.
+
+### The spare worker (threadteam-rs#12): not in this change
+
+A pool of `w` workers gives a team of at most `w` participants: the leader counts as one, and `w - 1` workers are reserved, so one worker is a spare that only Rayon uses. Letting `into_team(width)` reach `w + 1` from an outside thread would reserve every worker. The pre-review found that this breaks `Exec::external` on a team token:
+- `external` lends the token's `budget - 1` members and installs the callback on a pool worker.
+- Today the spare is the worker that hosts it. Without a spare, the callback occupies one of the lent members, so a callback that waits for `width` Rayon jobs at once deadlocks, and a full-width token advertises `w + 1` threads to a pool of `w`.
+
+Removing the spare therefore needs a new contract for `external`'s width and lending, covering full-width and narrowed tokens. broccoli also showed that the spare is not what separates the slow arms (faer#107, 13:10Z): `team_per_call` runs the same 65 threads and is fast. The spare stays, and threadteam-rs#12 carries the `external` constraint.
+
+## Evaluation
+
+`benches/wait_scenarios.rs` (README, "Wait benchmarks"), run on the base and on the head of the change:
+- `sections`: many short sections per call (5-50 µs of work, 200 sections);
+- `gaps`: the wake latency after a gap of 0 / 100 µs / 1 ms / 10 ms between calls;
+- `acquire`: a pool held with a team per call, against a new pool per call;
+- `nested`: 100 splits into pairs per call (the shared parker under many child leaders);
+- width = CPUs against width < CPUs;
+- with and without a foreign-load generator: child processes that each burn a few % of a CPU;
+- the same work under libgomp (`benches/omp/wait_omp.c`, when `gcc -fopenmp` is available) and under a Rayon `scope`.
+
+The change is accepted when (criteria set by the monitor, 2026-10-30):
+- **(a)** the faer#107 slow mode is zero in every arm of `acquire_probe_107` (tensor4all/faer branch `probe/107-acquire-per-call-wait`);
+- **(b)** on quiet hosts (evo, an unloaded broccoli), `held_team`, `held_pool` and `gaps` (0-1 ms) are within 10 % of the base;
+- **(c)** under foreign load (`--load 8:10`), the same scenarios are no worse than libgomp's. The base is not the reference there: it keeps its spinners on CPUs that other processes need;
+- **(d)** the 10 ms gap is tuned with the spin budget; if 300000 polls closes it, that is accepted as the OpenMP default.
+
+The comparison is `scripts/bench-ab.sh` with `OMP=1`, which runs libgomp's counterpart (`acquire`/`held_team`: calls of 50 sections of 20 µs on the same hot team) in every round, with and without load.
+
+**First reading, primerose (not an acceptance run).** EPYC 7713P, 64 CPUs, saturated by other users (load average 61-63). Width 6 on `taskset -c 0-5`, 40 calls, threadteam only. Base = the bench commit on 0.1.3; head = this change. Median µs per call:
+
+| scenario | param | base | head | ideal |
+| --- | --- | --- | --- | --- |
+| sections | 5 µs × 200 | 775 725 | 14 497 | 1 000 |
+| sections | 20 µs × 200 | 978 060 | 21 991 | 4 000 |
+| sections | 50 µs × 200 | 1 462 996 | 39 042 | 10 000 |
+| gaps (first section) | 0 | 10 972 | 19 | 5 |
+| gaps (first section) | 1 ms | 10 895 | 47 | 5 |
+| gaps (first section) | 10 ms | 12 003 | 1 033 | 5 |
+| gaps (call) | 10 ms | 124 883 | 9 832 | 50 |
+| nested | pairs, 100 × 20 µs | 741 969 | 37 894 | 2 000 |
+| acquire | team held, token per call | 16 055 | 9 551 | 1 000 |
+| acquire | pool held, members per call | 245 584 | 2 501 | 1 000 |
+| acquire | new pool per call (call) | 393 990 | 61 622 | 1 000 |
+| acquire | new pool per call (build to drop) | 408 038 | 67 548 | 1 000 |
+
+Empty-section dispatch (`benches/team_dispatch.rs`, same host, median ns): width 2, 519 (base) against 530 (head); width 6, 767 against 862; the load average moved from 64 to 74 between the two runs, so this bounds a regression only coarsely.
+
+On a host whose CPUs are all busy, 0.1.3's spinning waiters stack and stay stacked, and calls take hundreds of times their work. The staged waits bring them within about 2-10x of the ideal, the cost of sharing CPUs with other users' processes. A quiet host and broccoli decide the acceptance; these numbers only show the mechanism.
diff --git a/scripts/bench-ab.sh b/scripts/bench-ab.sh
new file mode 100755
index 0000000..36b8da6
--- /dev/null
+++ b/scripts/bench-ab.sh
@@ -0,0 +1,79 @@
+#!/usr/bin/env bash
+# Interleaved A/B of the wait benchmarks (docs/design/waiting.md): builds `benches/wait_scenarios.rs`
+# at two commits (the base is the bench commit a3a9320, which runs the bench on the 0.1.3 waits) and runs them alternately, so slow drifts of a shared host (other users' jobs)
+# fall on both sides. Rows go to $CSV (default docs/design/waiting-data/<host>-ab.csv), labelled
+# `<name>#<round>`; the `waits per call` lines go to $LOG.
+#
+#   scripts/bench-ab.sh <base-rev> <head-rev> <rounds> [bench args...]
+#
+# Example, the held-pool arms at width 64 (threadteam-rs#14, broccoli):
+#   taskset -c 0-63 scripts/bench-ab.sh a3a9320 feat/wait-openmp 20 \
+#     --scenario acquire --widths 64 --calls 40 --impl threadteam
+#
+# HEAD_VARIANTS adds head runs with extra arguments in every round, `;`-separated, each named by
+# its arguments, e.g. HEAD_VARIANTS='--spin-polls 300000;--own-hold-ms 100;--pressure-events 0'.
+# OMP=1 also runs the libgomp driver (benches/omp/wait_omp.c) in every round, with the same
+# --scenario (sections, gaps or acquire = libgomp's held team), --widths, --calls and --load.
+set -euo pipefail
+base=${1:?base rev}; head=${2:?head rev}; rounds=${3:?rounds}; shift 3
+host=$(hostname -s)
+csv=${CSV:-docs/design/waiting-data/$host-ab.csv}
+log=${LOG:-docs/design/waiting-data/$host-ab.log}
+mkdir -p "$(dirname "$csv")"
+work=$(mktemp -d)
+trap 'git worktree remove --force "$work/base" 2>/dev/null; git worktree remove --force "$work/head" 2>/dev/null; rm -rf "$work"' EXIT
+build() { # $1 = rev, $2 = dir name; prints the bench binary
+  git worktree add -q --detach "$work/$2" "$1"
+  (cd "$work/$2" && cargo build -j "${JOBS:-4}" --release --bench wait_scenarios >/dev/null 2>&1)
+  ls -t "$work/$2"/target/release/deps/wait_scenarios-* | grep -v '\.d$' | head -1
+}
+bin_base=$(build "$base" base)
+bin_head=$(build "$head" head)
+omp=""
+if [[ ${OMP:-0} == 1 ]]; then
+  gcc -O2 -fopenmp "$work/head/benches/omp/wait_omp.c" -o "$work/wait_omp"
+  omp="$work/wait_omp"
+fi
+arg() { # value of bench option $1 in "$@" after it, or $2
+  local name=$1 def=$2; shift 2
+  while [[ $# -gt 0 ]]; do [[ $1 == "$name" ]] && { echo "$2"; return; }; shift; done
+  echo "$def"
+}
+omp_scenario=$(arg --scenario all "$@"); omp_widths=$(arg --widths "$(nproc)" "$@")
+omp_calls=$(arg --calls 200 "$@"); omp_load=$(arg --load "" "$@")
+IFS=';' read -r -a variants <<<"${HEAD_VARIANTS:-}"
+echo "base $(git rev-parse --short "$base")  head $(git rev-parse --short "$head")  rounds $rounds  args $*" | tee -a "$log"
+for r in $(seq 1 "$rounds"); do
+  order=(base head); (( r % 2 == 0 )) && order=(head base)
+  for side in "${order[@]}"; do
+    if [[ $side == base ]]; then
+      "$bin_base" --label "base#$r" --csv "$csv" "$@" >>"$log"
+    else
+      "$bin_head" --label "head#$r" --csv "$csv" "$@" >>"$log"
+      if [[ -n $omp ]]; then
+        for w in ${omp_widths//,/ }; do
+          WAIT_OMP_SCENARIO=$omp_scenario WAIT_OMP_LOAD=$omp_load \
+            "$omp" "$w" "$omp_calls" "$csv" "libgomp#$r" >>"$log"
+        done
+      fi
+      for v in "${variants[@]}"; do
+        [[ -z $v ]] && continue
+        # shellcheck disable=SC2086
+        "$bin_head" --label "head[$v]#$r" --csv "$csv" "$@" $v >>"$log"
+      done
+    fi
+  done
+done
+echo "rows in $csv, waits in $log"
+python3 - "$csv" <<'PY'
+import csv, collections, statistics, sys
+rows = list(csv.DictReader(open(sys.argv[1])))
+cells = collections.defaultdict(list)
+for r in rows:
+    name = r["label"].split("#")[0]
+    cells[(r["scenario"], r["width"], r["param"], r["metric"], name)].append(float(r["median_us"]))
+print(f"{'scenario':<9} {'width':>5} {'param':<24} {'metric':<6} {'side':<40} {'n':>3} {'median of medians us':>21}")
+for k in sorted(cells):
+    v = cells[k]
+    print(f"{k[0]:<9} {k[1]:>5} {k[2]:<24} {k[3]:<6} {k[4]:<40} {len(v):>3} {statistics.median(v):>21.1f}")
+PY
diff --git a/scripts/bench-waits.sh b/scripts/bench-waits.sh
new file mode 100755
index 0000000..3abfe24
--- /dev/null
+++ b/scripts/bench-waits.sh
@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+# Runs the wait benchmarks (docs/design/waiting.md, README "Wait benchmarks") for one checkout:
+# the Rust bench (threadteam and Rayon) and, when `gcc -fopenmp` works, the libgomp driver, with
+# and without foreign load. Rows are appended to $CSV.
+#
+#   scripts/bench-waits.sh <label> [widths] [load K:P]
+#
+# label   the version or commit under test, written to every row (e.g. `main-4c73c2b`)
+# widths  comma separated (default: all CPUs of the affinity set and three quarters of them)
+# load    foreign load for the second pass (default 8:10, eight processes at 10 % each);
+#         `none` skips the loaded pass
+# CSV     output file (default docs/design/waiting-data/<host>.csv)
+set -euo pipefail
+label=${1:?label}
+widths=${2:-}
+load=${3:-8:10}
+host=$(hostname -s)
+csv=${CSV:-docs/design/waiting-data/$host.csv}
+mkdir -p "$(dirname "$csv")"
+cargo build -j "${JOBS:-4}" --release --bench wait_scenarios >/dev/null
+bench=$(ls -t target/release/deps/wait_scenarios-* | grep -v '\.d$' | head -1)
+wargs=()
+[[ -n $widths ]] && wargs=(--widths "$widths")
+
+omp=""
+if echo 'int main(void){return 0;}' | gcc -fopenmp -x c - -o /dev/null 2>/dev/null; then
+  gcc -O2 -fopenmp benches/omp/wait_omp.c -o target/wait_omp
+  omp=target/wait_omp
+else
+  echo "gcc -fopenmp not available: libgomp reference skipped" >&2
+fi
+cpus=$(nproc)
+ws=${widths:-$cpus,$((cpus * 3 / 4))}
+
+run_pass() { # $1 = load spec or none
+  local largs=()
+  [[ $1 != none ]] && largs=(--load "$1")
+  "$bench" --label "$label" --csv "$csv" "${wargs[@]}" "${largs[@]}"
+  if [[ -n $omp ]]; then
+    local pids=()
+    if [[ $1 != none ]]; then
+      for _ in $(seq "${1%%:*}"); do "$bench" --load-child "${1##*:}" & pids+=($!); done
+      sleep 0.2
+    fi
+    for w in ${ws//,/ }; do WAIT_BENCH_LOAD=$([[ $1 == none ]] && echo none || echo "${1%%:*}x${1##*:}%") \
+      "$omp" "$w" 200 "$csv" "$label"; done
+    [[ ${#pids[@]} -gt 0 ]] && kill "${pids[@]}" 2>/dev/null; wait 2>/dev/null || true
+  fi
+}
+run_pass none
+[[ $load != none ]] && run_pass "$load"
+echo "rows appended to $csv"
diff --git a/src/awake.rs b/src/awake.rs
index b6f2faf..a8da93e 100644
--- a/src/awake.rs
+++ b/src/awake.rs
@@ -11,10 +11,12 @@
 //! ```
 //!
 //! * `ABSENT`: no loop on this worker.
-//! * `RESERVED`: owned by one leader; the member spins on `gen` and runs the
-//!   section the leader published. It neither runs Rayon jobs nor leaves.
-//! * `IDLE`: loop alive but unreserved; spins for the policy's idle time, then
-//!   leaves (`ABSENT`). Claimable by a compare-and-swap, with no waiting.
+//! * `RESERVED`: owned by one leader; the member waits for `gen` (spin, yield,
+//!   then park) and runs the section the leader published. It neither runs
+//!   Rayon jobs nor leaves.
+//! * `IDLE`: loop alive but unreserved; polls for the policy's idle time or
+//!   the pool's spin budget, whichever ends first, then leaves (`ABSENT`).
+//!   Claimable by a compare-and-swap, with no waiting.
 //! * `YIELD`: an idle member inside `rayon::yield_now`; not claimable.
 //!
 //! A leader publishes a [`Section`] (a stack object) by writing its address
@@ -31,7 +33,7 @@
 use crate::error::Refused;
 use crate::park::Parker;
 use crate::policy::WaitPolicy;
-use core::sync::atomic::{AtomicBool, AtomicPtr, AtomicU64, AtomicUsize, Ordering};
+use core::sync::atomic::{AtomicBool, AtomicPtr, AtomicU32, AtomicU64, AtomicUsize, Ordering};
 use std::any::Any;
 use std::time::Duration;
 
@@ -50,17 +52,13 @@ const IDLE: usize = 1;
 const YIELD: usize = 2;
 const RESERVED: usize = 3;
 
-/// Alignment that keeps a hot atomic on its own cache line pair (128 bytes
-/// covers Apple Silicon and adjacent-line prefetch on x86).
-#[repr(align(128))]
-pub(crate) struct Padded<T>(pub(crate) T);
-
 /// Pure spin for a while, then yield the CPU between polls.
 ///
 /// Used where progress needs cooperation with other threads on the same CPUs:
 /// `acquire`, the cold claim, and the loops that are not reserved dispatch
-/// polls (`IDLE`, and the states a loop is leaving). Reserved members and a
-/// leader waiting on a section poll with [`spin_wait`] instead.
+/// polls (`IDLE`, and the states a loop is leaving). Reserved members, and a
+/// leader or participant waiting on a section, wait in staged episodes instead
+/// ([`crate::park::Waiter`]).
 #[inline]
 #[cfg_attr(not(feature = "parallel"), allow(dead_code))]
 pub(crate) fn backoff(spins: &mut u32) {
@@ -72,43 +70,6 @@ pub(crate) fn backoff(spins: &mut u32) {
     }
 }
 
-/// One PAUSE per poll (YIELD on aarch64), never a yield.
-///
-/// The wait of a reserved member polling `gen`, and of a leader in
-/// `Section::join` / `Section::barrier`, in a scope that is not oversubscribed:
-/// a thread that only spins with PAUSE stays runnable but does not repeatedly
-/// re-enter the scheduler, so a stacked pair can be separated and a share does
-/// not pay for a `sched_yield` on every poll. A parked member is woken by the
-/// leader through [`Parker`].
-#[inline]
-pub(crate) fn spin_wait() {
-    std::hint::spin_loop();
-}
-
-/// How many polls a joined section spins before it yields, in an oversubscribed
-/// scope (more participants than CPUs in the caller's set).
-const OVERSUBSCRIBED_SPINS: u32 = 100;
-
-/// One poll of a leader waiting on a section.
-///
-/// Not oversubscribed: [`spin_wait`]. Oversubscribed: about
-/// [`OVERSUBSCRIBED_SPINS`] PAUSE spins, then one `yield_now` per poll, so the
-/// waiting participants do not hold every CPU while their peers are queued
-/// behind them (the shape libomp takes when it detects oversubscription).
-#[inline]
-fn wait_poll(over: bool, polls: &mut u32) {
-    if !over {
-        spin_wait();
-        return;
-    }
-    if *polls >= OVERSUBSCRIBED_SPINS {
-        std::thread::yield_now();
-    } else {
-        *polls += 1;
-        std::hint::spin_loop();
-    }
-}
-
 /// One member's dispatch slot.
 #[repr(align(128))]
 struct Slot {
@@ -120,8 +81,14 @@ struct Slot {
     /// Idle policy written by the releasing leader before `IDLE` is stored.
     idle_spin_ns: AtomicU64,
     idle_yield: AtomicBool,
-    /// How long a reserved member spins without work before it parks.
-    park_ns: AtomicU64,
+    /// Spin budget, in polls, of this reserved member's waits for work (see
+    /// `docs/design/waiting.md`); written by the leader at root-scope entry.
+    spin_budget: AtomicU32,
+    /// Until when this member's waits start throttled: it saw itself
+    /// descheduled while it spun (`crate::park::Pressure`); its own thread
+    /// writes and reads it.
+    #[cfg_attr(not(feature = "parallel"), allow(dead_code))]
+    pressed_until: crate::sync::AtomicU64,
     /// Set by the leader while the member's thread is lent to Rayon
     /// (`Exec::external` on a team token).
     lent: AtomicBool,
@@ -129,8 +96,8 @@ struct Slot {
     /// of this slot touches it (see [`crate::pin::SavedMask`]).
     #[cfg_attr(not(feature = "parallel"), allow(dead_code))]
     saved: crate::pin::SavedMask,
-    /// Where this member sleeps once its park delay has passed; woken by the
-    /// leader after it changed `gen`, `state` or `lent` of this slot.
+    /// Where this member sleeps once its spin and yields are spent; woken by
+    /// the leader after it changed `gen`, `state` or `lent` of this slot.
     park: Parker,
 }
 
@@ -143,7 +110,8 @@ impl Slot {
             arg: AtomicUsize::new(0),
             idle_spin_ns: AtomicU64::new(0),
             idle_yield: AtomicBool::new(false),
-            park_ns: AtomicU64::new(u64::MAX),
+            spin_budget: AtomicU32::new(crate::park::THROTTLED_POLLS),
+            pressed_until: crate::sync::AtomicU64::new(0),
             lent: AtomicBool::new(false),
             saved: crate::pin::SavedMask::new(),
             park: Parker::new(),
@@ -151,9 +119,29 @@ impl Slot {
     }
 }
 
+/// The waiting state of one pool (`docs/design/waiting.md`).
+pub(crate) struct Waits {
+    /// Where leaders sleep in `join` and participants in `barrier`. One per
+    /// pool: a member may wake it after its last decrement, when the section
+    /// may already be gone, and the pool outlives every member loop.
+    pub(crate) sync: Parker,
+    /// Recent scheduling pressure seen by this pool's waiters.
+    pub(crate) pressure: crate::park::Pressure,
+    /// Spin budget of a wait, in polls (`PoolBuilder::spin_polls`).
+    pub(crate) spin_polls: u32,
+    /// Diagnostics (`Pool::wait_counters`): sleeps of leaders in joins, of
+    /// participants in barriers, and parks of members waiting for work.
+    pub(crate) join_sleeps: AtomicU64,
+    pub(crate) barrier_sleeps: AtomicU64,
+    pub(crate) member_parks: AtomicU64,
+}
+
 /// Shared state of the awake members of one pool.
 pub(crate) struct Awake {
     slots: Box<[Slot]>,
+    /// What the joins and barriers of this pool's sections sleep on, and the
+    /// pool's spin budget and scheduling pressure (`docs/design/waiting.md`).
+    pub(crate) waits: Waits,
     pub(crate) shutdown: AtomicBool,
     /// Bumped by `Pool::release_idle`; members that started earlier leave when idle.
     pub(crate) release_epoch: AtomicUsize,
@@ -174,9 +162,19 @@ impl Awake {
         acquire_timeout: Duration,
         costs: crate::cost::DispatchCosts,
         pin: bool,
+        spin_polls: u32,
+        pressure: crate::park::Pressure,
     ) -> Self {
         Awake {
             slots: (0..width).map(|_| Slot::new()).collect(),
+            waits: Waits {
+                sync: Parker::new(),
+                pressure,
+                spin_polls,
+                join_sleeps: AtomicU64::new(0),
+                barrier_sleeps: AtomicU64::new(0),
+                member_parks: AtomicU64::new(0),
+            },
             shutdown: AtomicBool::new(false),
             release_epoch: AtomicUsize::new(0),
             defaults,
@@ -209,15 +207,30 @@ impl Awake {
         }
     }
 
-    /// Sets the park delay of the given reserved members, in nanoseconds.
+    /// Spin budget, in polls, of a wait in a root scope: the pool's budget, or
+    /// the throttled one when the scope is oversubscribed.
+    pub(crate) fn spin_budget(&self, over: bool) -> u32 {
+        if over {
+            self.waits.pressure.throttled().min(self.waits.spin_polls)
+        } else {
+            self.waits.spin_polls
+        }
+    }
+
+    /// The spin budget a member slot currently has (tests).
+    #[cfg(all(test, feature = "parallel", target_os = "linux"))]
+    pub(crate) fn slot_spin_budget(&self, id: usize) -> u32 {
+        self.slots[id].spin_budget.load(Ordering::Relaxed)
+    }
+
+    /// Sets the spin budget of the given reserved members' waits for work.
     ///
-    /// A root team scope writes it once at entry: zero (park after the short
-    /// spin) when the scope is oversubscribed, the effective `idle_spin`
-    /// otherwise. Nothing else changes it, so a member keeps the value of the
+    /// A root team scope writes it once at entry ([`Self::spin_budget`] of its
+    /// pressure). Nothing else changes it, so a member keeps the value of the
     /// scope it was reserved for.
-    pub(crate) fn set_park_ns(&self, ids: &[usize], ns: u64) {
+    pub(crate) fn set_spin_budget(&self, ids: &[usize], polls: u32) {
         for &id in ids {
-            self.slots[id].park_ns.store(ns, Ordering::Relaxed);
+            self.slots[id].spin_budget.store(polls, Ordering::Relaxed);
         }
     }
 
@@ -295,7 +308,7 @@ impl Awake {
         pool: &crate::pool::Pool,
         need: usize,
         policy: WaitPolicy,
-        park_spin: Duration,
+        spin_budget: u32,
     ) -> Result<Reservation, Refused> {
         let mut ids = Vec::with_capacity(need);
         // Idle members are claimed with a compare-and-swap. A member that is
@@ -331,10 +344,7 @@ impl Awake {
                 return Err(Refused::Unavailable);
             }
         }
-        let ns = u64::try_from(park_spin.as_nanos()).unwrap_or(u64::MAX);
-        for &id in &ids {
-            self.slots[id].park_ns.store(ns, Ordering::Relaxed);
-        }
+        self.set_spin_budget(&ids, spin_budget);
         Ok(Reservation {
             awake: std::sync::Arc::clone(self),
             ids,
@@ -486,25 +496,29 @@ fn claim_job(aw: &std::sync::Arc<Awake>, acq: &std::sync::Arc<Acq>) {
 /// The member loop. Returns when the idle policy, `release_idle` or shutdown
 /// returns the thread to Rayon.
 ///
-/// Idle clock of a reserved member: `last_work` is the instant at which this
-/// member first found nothing to do after its last share (or after it started,
-/// or was taken back from Rayon). It belongs to the member alone, a share of
-/// another member does not move it, and it is read only while polling. When it
-/// is older than the member's park delay the member parks and stays reserved;
-/// a member whose team runs no section therefore costs CPU for the park delay
-/// at most, then nothing. The delay is zero in an oversubscribed root scope, so
-/// `polls` and `spins` are reset at the start of each idle episode there: the
-/// member then spins one short episode of `polls` and parks.
+/// A reserved member waits for work in episodes (`docs/design/waiting.md`): an
+/// episode starts when it first finds nothing to do after its last share (or
+/// after it started, or was taken back from Rayon), spins for the slot's spin
+/// budget in polls, yields a few times, then parks and stays reserved. The
+/// budget is a count, so a member that is descheduled does not spend it while
+/// it waits for its CPU; a long gap between its clock reads ends the spin at
+/// once (see [`crate::park::Pressure`]).
+///
+/// An unreserved (`IDLE`) member returns to Rayon after the policy's
+/// `idle_spin` of wall time or after the pool's spin budget of polls, whichever
+/// comes first, so a team released between calls does not keep every CPU busy
+/// for the whole `idle_spin`.
 #[cfg(feature = "parallel")]
 fn member_loop(aw: &Awake, id: usize, mut seen: usize, epoch: usize) {
+    use crate::park::{Step, Waiter};
     use std::time::Instant;
     let slot = &aw.slots[id];
     let mut idle_since: Option<Instant> = None;
-    let mut last_work: Option<Instant> = None;
+    let mut idle_polls = 0u64;
+    let mut waiter: Option<Waiter<'_>> = None;
     let mut was_lent = false;
     let mut reserved = true;
     let mut spins = 0u32;
-    let mut polls = 0u32;
     trace!(aw, Some(id), Enter);
     loop {
         let state = slot.state.load(Ordering::Acquire);
@@ -526,7 +540,7 @@ fn member_loop(aw: &Awake, id: usize, mut seen: usize, epoch: usize) {
                     trace!(aw, Some(id), LentBegin);
                 }
                 idle_since = None;
-                last_work = None;
+                waiter = None;
                 // Serve the pool's jobs; resume team service when taken back.
                 if !matches!(rayon::yield_now(), Some(rayon::Yield::Executed)) {
                     for _ in 0..32 {
@@ -542,31 +556,23 @@ fn member_loop(aw: &Awake, id: usize, mut seen: usize, epoch: usize) {
                 idle_since = None;
                 let g = slot.gen.load(Ordering::Acquire);
                 if g == seen {
-                    let fresh = last_work.is_none();
-                    let since = *last_work.get_or_insert_with(Instant::now);
-                    if fresh {
-                        // A new idle episode: the park check counts from here.
-                        spins = 0;
-                        polls = 0;
-                    }
-                    spin_wait();
-                    polls = polls.wrapping_add(1);
-                    if polls & 0x3F == 0 {
-                        let park_ns = slot.park_ns.load(Ordering::Relaxed);
-                        if since.elapsed().as_nanos() >= u128::from(park_ns) {
-                            trace!(aw, Some(id), ParkEnter);
-                            park_member(slot, seen);
-                            trace!(aw, Some(id), ParkExit);
-                            last_work = None;
-                            spins = 0;
-                            polls = 0;
-                        }
+                    let w = waiter.get_or_insert_with(|| {
+                        Waiter::of_thread(
+                            slot.spin_budget.load(Ordering::Relaxed),
+                            Some(&aw.waits.pressure),
+                            Some(&slot.pressed_until),
+                        )
+                    });
+                    if w.step() == Step::Sleep {
+                        aw.waits.member_parks.fetch_add(1, Ordering::Relaxed);
+                        trace!(aw, Some(id), ParkEnter);
+                        park_member(slot, seen);
+                        trace!(aw, Some(id), ParkExit);
+                        waiter = None;
                     }
                 } else {
                     seen = g;
-                    spins = 0;
-                    polls = 0;
-                    last_work = None;
+                    waiter = None;
                     let ptr = slot.ptr.load(Ordering::Relaxed);
                     let arg = slot.arg.load(Ordering::Relaxed);
                     // SAFETY: the leader keeps the section alive until its
@@ -578,16 +584,23 @@ fn member_loop(aw: &Awake, id: usize, mut seen: usize, epoch: usize) {
                         slot.saved.save_if_unpinned();
                     }
                     trace!(aw, Some(id), SectionBegin);
-                    // SAFETY: as above.
+                    // SAFETY: as above; `aw` outlives this loop, so the wake
+                    // after the last decrement does not touch the section.
                     unsafe { Section::execute_member(ptr, arg) };
                     trace!(aw, Some(id), SectionEnd);
                 }
             }
             IDLE => {
+                waiter = None;
+                if idle_since.is_none() {
+                    idle_polls = 0;
+                }
                 let since = *idle_since.get_or_insert_with(Instant::now);
+                idle_polls += 1;
                 let spin_ns = slot.idle_spin_ns.load(Ordering::Relaxed);
                 let leave = aw.shutdown.load(Ordering::Relaxed)
                     || aw.release_epoch.load(Ordering::Relaxed) != epoch
+                    || idle_polls > u64::from(aw.waits.spin_polls)
                     || since.elapsed().as_nanos() >= u128::from(spin_ns);
                 if leave {
                     if slot
@@ -654,19 +667,22 @@ pub(crate) struct Section {
     #[cfg_attr(not(feature = "parallel"), allow(dead_code))]
     pin: bool,
     /// Dispatched participants that have not finished.
-    remaining: Padded<AtomicUsize>,
-    arrived: Padded<AtomicUsize>,
-    epoch: Padded<AtomicUsize>,
-    cancelled: AtomicBool,
+    done: crate::park::Completion,
+    barrier: crate::park::Barrier,
+    cancelled: crate::sync::AtomicBool,
+    /// The pool's waiting state; null when the section has no pool (nothing is
+    /// dispatched, and its single participant never waits).
+    waits: *const Waits,
     /// First panic payload, boxed twice so that it fits an `AtomicPtr`.
     /// (A `Mutex` would allocate on first use on some platforms.)
     panic: AtomicPtr<Box<dyn Any + Send>>,
 }
 
-// SAFETY: `data` points to a `Sync` closure that outlives the section; every
-// other field is an atomic, a plain flag written before the section is
-// published (and read only after a member observed the publishing `gen` with
-// acquire ordering), or a function pointer.
+// SAFETY: `data` points to a `Sync` closure that outlives the section; `waits`
+// points to the pool's `Waits` (in `Awake`, which outlives every section and
+// member loop) and is only read; every other field is an atomic, a plain flag
+// written before the section is published (and read only after a member
+// observed the publishing `gen` with acquire ordering), or a function pointer.
 unsafe impl Sync for Section {}
 
 /// The geometry of a section: its shares, its participants, and the flags of
@@ -690,6 +706,7 @@ impl Section {
         slot_of: unsafe fn(*const (), usize) -> usize,
         slot_data: *const (),
         geometry: Geometry,
+        waits: Option<&Waits>,
     ) -> Self {
         let Geometry {
             dispatched,
@@ -706,10 +723,10 @@ impl Section {
             slot_data,
             over,
             pin,
-            remaining: Padded(AtomicUsize::new(dispatched)),
-            arrived: Padded(AtomicUsize::new(0)),
-            epoch: Padded(AtomicUsize::new(0)),
-            cancelled: AtomicBool::new(false),
+            done: crate::park::Completion::new(dispatched),
+            barrier: crate::park::Barrier::new(size),
+            cancelled: crate::sync::AtomicBool::new(false),
+            waits: waits.map_or(core::ptr::null(), |w| w as *const Waits),
             panic: AtomicPtr::new(core::ptr::null_mut()),
         }
     }
@@ -738,17 +755,51 @@ impl Section {
     /// decrement.
     #[cfg_attr(not(feature = "parallel"), allow(dead_code))]
     unsafe fn execute_member(ptr: *const Section, arg: usize) {
-        let sec = &*ptr;
-        let r = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| sec.call_here(arg)));
-        if let Err(p) = r {
-            sec.fail(p);
+        // The pool's waiting state outlives the section: read it now, use it
+        // after the decrement that may let the leader free the section.
+        let waits = (*ptr).waits;
+        {
+            let sec = &*ptr;
+            let r = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| sec.call_here(arg)));
+            if let Err(p) = r {
+                sec.fail(p);
+            }
+        }
+        crate::park::Completion::finish(
+            core::ptr::addr_of!((*ptr).done),
+            waits.as_ref().map(|w| &w.sync),
+        );
+    }
+
+    /// The pool's waiting state, if the section has a pool.
+    fn waits(&self) -> Option<&Waits> {
+        // SAFETY: `waits` is null or points into the pool's `Awake`, which
+        // outlives the section.
+        unsafe { self.waits.as_ref() }
+    }
+
+    /// A wait episode of this section's join or barrier.
+    fn waiter(&self) -> crate::park::Waiter<'_> {
+        match self.waits() {
+            Some(w) => crate::park::Waiter::new(
+                if self.over {
+                    w.pressure.throttled().min(w.spin_polls)
+                } else {
+                    w.spin_polls
+                },
+                Some(&w.pressure),
+            ),
+            None => crate::park::Waiter::new(u32::MAX, None),
         }
-        (*ptr).remaining.0.fetch_sub(1, Ordering::Release);
     }
 
     /// Records a participant's panic and cancels barriers.
     pub(crate) fn fail(&self, payload: Box<dyn Any + Send>) {
-        self.cancelled.store(true, Ordering::Release);
+        // SeqCst, then wake: barrier waiters may sleep on the pool's parker.
+        self.cancelled.store(true, Ordering::SeqCst);
+        if let Some(w) = self.waits() {
+            w.sync.wake();
+        }
         let fresh = Box::into_raw(Box::new(payload));
         if self
             .panic
@@ -780,42 +831,36 @@ impl Section {
         self.cancelled.load(Ordering::Acquire)
     }
 
-    /// Waits until every dispatched participant has finished.
-    ///
-    /// Polls with [`spin_wait`] (one PAUSE, no yield) unless the root scope is
-    /// oversubscribed, where it spins about 100 times and then yields per poll.
+    /// Waits until every dispatched participant has finished: a staged wait
+    /// (spin, yield, then sleep on the pool's parker until the last member's
+    /// decrement wakes it), throttled when the root scope is oversubscribed.
     pub(crate) fn join(&self) {
-        let mut polls = 0;
-        while self.remaining.0.load(Ordering::Acquire) != 0 {
-            wait_poll(self.over, &mut polls);
+        if self.done.is_done() {
+            return;
+        }
+        let mut waiter = self.waiter();
+        self.done.wait(self.waits().map(|w| &w.sync), &mut waiter);
+        if waiter.slept() {
+            if let Some(w) = self.waits() {
+                w.join_sleeps.fetch_add(1, Ordering::Relaxed);
+            }
         }
     }
 
     /// Sense-reversing barrier over the section's participants; `false` when
-    /// a participant failed, so that peers can leave instead of waiting.
+    /// a participant failed, so that peers can leave instead of waiting. Waits
+    /// like [`Self::join`].
     pub(crate) fn barrier(&self) -> bool {
-        if self.is_cancelled() {
-            return false;
-        }
-        if self.size == 1 {
-            return true;
-        }
-        let epoch = self.epoch.0.load(Ordering::Acquire);
-        if self.arrived.0.fetch_add(1, Ordering::AcqRel) + 1 == self.size {
-            self.arrived.0.store(0, Ordering::Relaxed);
-            self.epoch.0.store(epoch.wrapping_add(1), Ordering::Release);
-            return true;
-        }
-        let mut polls = 0;
-        loop {
-            if self.epoch.0.load(Ordering::Acquire) != epoch {
-                return true;
-            }
-            if self.is_cancelled() {
-                return false;
+        let mut waiter = self.waiter();
+        let passed =
+            self.barrier
+                .arrive(&self.cancelled, self.waits().map(|w| &w.sync), &mut waiter);
+        if waiter.slept() {
+            if let Some(w) = self.waits() {
+                w.barrier_sleeps.fetch_add(1, Ordering::Relaxed);
             }
-            wait_poll(self.over, &mut polls);
         }
+        passed
     }
 }
 
diff --git a/src/exec.rs b/src/exec.rs
index e568933..e033e6e 100644
--- a/src/exec.rs
+++ b/src/exec.rs
@@ -765,17 +765,14 @@ impl<'p> Exec<'p> {
             // child, a reborrow or a sub-team re-pins nothing of its own.
             if self._leader.is_some() {
                 // Root-scope entry, on the executing thread: the root pressure
-                // and the members' park delay are decided by *this* thread's CPU
+                // and the members' spin budget are decided by *this* thread's CPU
                 // set. A token minted on another thread (or another mask) is
                 // paced by the thread that enters the scope, exactly as its pin
                 // section is placed by that thread. Descendants inherit it.
                 let oversubscribed = crate::pin::oversubscribed(team.size().get());
                 team.over = oversubscribed;
                 if let Some(awake) = team.awake {
-                    awake.set_park_ns(
-                        team.ids,
-                        crate::pin::park_delay(team.policy, oversubscribed),
-                    );
+                    awake.set_spin_budget(team.ids, awake.spin_budget(oversubscribed));
                 }
                 if let Some(auth) = self.team.as_mut() {
                     auth.over = oversubscribed;
@@ -804,14 +801,12 @@ impl<'p> Exec<'p> {
         // placement of the participants and whether the scope is
         // oversubscribed, whatever the pool's pinning setting.
         let oversubscribed = crate::pin::oversubscribed(self.budget.get());
-        let park_spin = if oversubscribed {
-            Duration::ZERO
-        } else {
-            policy.idle_spin()
-        };
-        let reservation = pool
-            .awake
-            .acquire(pool, self.budget.get() - 1, policy, park_spin)?;
+        let reservation = pool.awake.acquire(
+            pool,
+            self.budget.get() - 1,
+            policy,
+            pool.awake.spin_budget(oversubscribed),
+        )?;
         let mut team = TeamExec {
             awake: Some(&pool.awake),
             ids: &reservation.ids,
diff --git a/src/lib.rs b/src/lib.rs
index 286262f..326820b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -67,7 +67,12 @@ pub use exec::Exec;
 #[cfg(loom)]
 #[doc(hidden)]
 pub use park::Parker;
+#[cfg(loom)]
+#[doc(hidden)]
+pub use park::{Barrier, Completion, Waiter};
 pub use policy::{raise_current_thread_qos, Qos, WaitOverride, WaitPolicy};
+#[doc(hidden)]
+pub use pool::WaitCounters;
 pub use pool::{Pool, PoolBuilder};
 pub use reserve::{IntoTeamError, Team};
 pub use team::{Cancelled, Participant, TeamExec};
diff --git a/src/park.rs b/src/park.rs
index 2d58fc7..a1d2227 100644
--- a/src/park.rs
+++ b/src/park.rs
@@ -20,7 +20,7 @@
 //! the latter and the exact code is model-checked. With nobody parked a wake is
 //! one uncontended atomic read-modify-write.
 
-use crate::sync::{AtomicUsize, Condvar, Mutex, Ordering};
+use crate::sync::{AtomicBool, AtomicU64, AtomicUsize, Condvar, Mutex, Ordering};
 
 /// Places where a test can pause a thread (feature `test-hooks`).
 #[doc(hidden)]
@@ -142,3 +142,419 @@ impl Parker {
         }
     }
 }
+
+// ---------------------------------------------------------------------------
+// Staged waits (`docs/design/waiting.md`): a bounded spin, a few yields, then a
+// sleep on a `Parker`. The join and the barrier of a section use them through
+// [`Completion`] and [`Barrier`], which are the exact code `loom` checks.
+
+/// Default spin budget, in polls, of a wait that starts throttled: the scope
+/// is oversubscribed, or the pool saw a waiter descheduled recently. libgomp's
+/// throttled spin count has the same value.
+pub(crate) const THROTTLED_POLLS: u32 = 100;
+
+/// Yields between the spin and the sleep. Each lets a thread queued on the same
+/// CPU run without a futex round trip.
+const YIELD_POLLS: u32 = if cfg!(loom) { 0 } else { 16 };
+
+/// A spinning waiter reads the clock once per this many polls.
+const CHECK_EVERY: u32 = 64;
+
+/// The gap between two clock reads of a spinning waiter that counts as a
+/// preemption while detection is on: 64 polls take well under 10 µs, and a
+/// scheduler slice is 0.75 ms or more.
+pub(crate) const PREEMPT_GAP_NS: u64 = 200_000;
+
+/// How long after a pool is built its waiters detect preemptions (with
+/// [`PREEMPT_GAP_NS`]) and the pool can throttle; after that, by default,
+/// nothing is detected and every wait spins, yields and sleeps as libgomp's
+/// do. A pool's first calls are where freshly spawned threads sit stacked
+/// (the scheduler places new threads before it knows their load): a pool
+/// built for one call (`with_team`) collapsed without detection (broccoli,
+/// threadteam-rs#14 `e76036c`: 87.6 ms), while a held pool, past its first
+/// moments, ran as fast as libgomp only without it.
+pub(crate) const WARM_NS: u64 = 200_000_000;
+
+/// Default time a pool keeps starting its waits throttled once its waiters
+/// were descheduled often enough (see [`CONTENDED_EVENTS`]).
+pub(crate) const CONTENDED_HOLD_NS: u64 = 100_000_000;
+
+/// Default number of observed preemptions, within one hold window, that
+/// throttle the whole pool; zero never throttles the whole pool. A single
+/// preemption (another user's job taking a CPU for a slice) only ends the spin
+/// of the waiter that saw it: throttling the pool on it made every section of
+/// a width-64 team on a mildly shared host pay futex wakes (threadteam-rs#14,
+/// broccoli). Sustained load produces many preemptions per window and still
+/// throttles.
+pub(crate) const CONTENDED_EVENTS: u32 = 4;
+
+/// What a waiting thread does after one [`Waiter::step`].
+#[doc(hidden)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Step {
+    /// It polled (spun or yielded); poll the condition again.
+    Poll,
+    /// The spin and the yields are spent: sleep until woken.
+    Sleep,
+}
+
+/// Recent scheduling pressure on one pool's waiters.
+///
+/// A waiter that finds a long gap between two of its clock reads was
+/// descheduled while it spun: something else ran on its CPU (another thread of
+/// the team, a foreign process, or interrupts and VM steal; the signal does not
+/// tell them apart). It records the time, and for its hold time (default
+/// [`CONTENDED_HOLD_NS`]) every wait of the pool starts with the throttled
+/// budget, so the pool's waiters free CPUs quickly while that pressure lasts.
+#[doc(hidden)]
+pub struct Pressure {
+    base: std::time::Instant,
+    /// Nanoseconds since `base` until which waits start throttled.
+    until: AtomicU64,
+    /// How long the pool's waits stay throttled once enough observations
+    /// came within one window of this length; zero throttles only the waiter
+    /// that saw a preemption.
+    hold_ns: u64,
+    /// Observations within one window that throttle the pool.
+    threshold: u32,
+    /// How long an observation throttles the thread that saw it (a member's
+    /// slot); zero, the default, throttles no thread beyond its own wait. On a
+    /// quiet broccoli a per-thread hold of 100 ms made held teams 1.2-1.8x
+    /// slower than 0.1.3: one member preempted once then slept at every
+    /// section for the hold (threadteam-rs#14, 2773c36). A benchmark knob.
+    own_hold_ns: u64,
+    /// The throttled budget, in polls.
+    throttled: u32,
+    /// After the warm-up: a gap between two clock reads longer than this is a
+    /// preemption; zero (the default) turns the detection, and with it every
+    /// throttle, off.
+    gap_ns: u64,
+    /// Nanoseconds since `base` until which waiters detect preemptions with
+    /// [`PREEMPT_GAP_NS`] whatever `gap_ns` says (the warm-up of a new pool).
+    warm_until: u64,
+    /// Start of the current observation window, and observations in it. A
+    /// heuristic: concurrent updates may lose a count, never an escalation by
+    /// a later window.
+    window: AtomicU64,
+    in_window: AtomicU64,
+    /// Observations so far (a diagnostic).
+    events: AtomicU64,
+}
+
+impl Default for Pressure {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Pressure {
+    /// No pressure recorded yet; the default hold and throttled budget.
+    pub fn new() -> Self {
+        Self::tuned(THROTTLED_POLLS, CONTENDED_HOLD_NS, CONTENDED_EVENTS, 0)
+    }
+
+    /// This pressure with a preemption gap of `gap_ns` after the warm-up (0: no
+    /// detection).
+    #[must_use]
+    pub fn with_gap(mut self, gap_ns: u64) -> Self {
+        self.gap_ns = gap_ns;
+        self
+    }
+
+    /// This pressure with a warm-up of `warm_ns` after its creation, during
+    /// which waiters detect preemptions whatever the gap after it (0: none).
+    #[must_use]
+    pub fn with_warm_up(mut self, warm_ns: u64) -> Self {
+        self.warm_until = warm_ns;
+        self
+    }
+
+    /// The preemption gap that applies at `now` (0: no detection).
+    fn gap_at(&self, now: u64) -> u64 {
+        if now < self.warm_until {
+            PREEMPT_GAP_NS
+        } else {
+            self.gap_ns
+        }
+    }
+
+    /// No pressure recorded yet, with a throttled budget of `throttled` polls,
+    /// held for `hold_ns` once `threshold` observations came within `hold_ns`
+    /// of each other (0 never throttles the pool; 1 throttles on the first), and
+    /// a per-thread hold of `own_hold_ns` (0: none).
+    pub fn tuned(throttled: u32, hold_ns: u64, threshold: u32, own_hold_ns: u64) -> Self {
+        Pressure {
+            base: std::time::Instant::now(),
+            until: AtomicU64::new(0),
+            hold_ns,
+            threshold,
+            own_hold_ns,
+            throttled,
+            gap_ns: 0,
+            warm_until: WARM_NS,
+            window: AtomicU64::new(0),
+            in_window: AtomicU64::new(0),
+            events: AtomicU64::new(0),
+        }
+    }
+
+    /// The throttled budget, in polls.
+    pub(crate) fn throttled(&self) -> u32 {
+        self.throttled
+    }
+
+    /// Observations so far.
+    pub(crate) fn events(&self) -> u64 {
+        self.events.load(Ordering::Relaxed)
+    }
+
+    pub(crate) fn now(&self) -> u64 {
+        u64::try_from(self.base.elapsed().as_nanos()).unwrap_or(u64::MAX)
+    }
+
+    /// Records a descheduled waiter at `now`. A later deadline is never
+    /// shortened by an older observation.
+    /// How long an observation throttles the thread that saw it.
+    pub(crate) fn own_hold_ns(&self) -> u64 {
+        self.own_hold_ns
+    }
+
+    pub(crate) fn note(&self, now: u64) {
+        self.events.fetch_add(1, Ordering::Relaxed);
+        if self.hold_ns == 0 || self.threshold == 0 {
+            return;
+        }
+        let start = self.window.load(Ordering::Relaxed);
+        let n = if now.saturating_sub(start) > self.hold_ns {
+            // A new window starts with this observation.
+            self.window.store(now, Ordering::Relaxed);
+            self.in_window.store(1, Ordering::Relaxed);
+            1
+        } else {
+            self.in_window.fetch_add(1, Ordering::Relaxed) + 1
+        };
+        if n >= u64::from(self.threshold) {
+            self.until
+                .fetch_max(now.saturating_add(self.hold_ns), Ordering::Relaxed);
+        }
+    }
+
+    pub(crate) fn active(&self, now: u64) -> bool {
+        self.until.load(Ordering::Relaxed) > now
+    }
+}
+
+/// One wait episode: up to `budget` spin polls (one PAUSE, or YIELD on
+/// aarch64, each), then [`YIELD_POLLS`] yields, then sleep.
+///
+/// The budget is a count: a waiter that is descheduled does not spend it while
+/// it waits for its CPU. Every [`CHECK_EVERY`] polls it reads the clock. At the
+/// first read it adopts the throttled budget if the pool is under
+/// [`Pressure`]; a long gap between reads ends the spin at once and records the
+/// pressure. A wait that ends within 64 polls never reads the clock.
+#[doc(hidden)]
+pub struct Waiter<'a> {
+    budget: u32,
+    polls: u32,
+    yields: u32,
+    pressure: Option<&'a Pressure>,
+    /// The waiting thread's own throttle deadline (a member's slot), if any.
+    own: Option<&'a AtomicU64>,
+    last: Option<u64>,
+    slept: bool,
+}
+
+impl<'a> Waiter<'a> {
+    /// A wait episode with a spin of `budget` polls.
+    pub fn new(budget: u32, pressure: Option<&'a Pressure>) -> Self {
+        Self::of_thread(budget, pressure, None)
+    }
+
+    /// A wait episode of a thread with its own throttle deadline `own`: a
+    /// preemption it observes throttles its later waits for the pool's hold,
+    /// and a deadline still running throttles this one.
+    pub(crate) fn of_thread(
+        budget: u32,
+        pressure: Option<&'a Pressure>,
+        own: Option<&'a AtomicU64>,
+    ) -> Self {
+        Waiter {
+            budget,
+            polls: 0,
+            yields: 0,
+            pressure,
+            own,
+            last: None,
+            slept: false,
+        }
+    }
+
+    /// Whether the episode reached its sleep phase.
+    pub fn slept(&self) -> bool {
+        self.slept
+    }
+
+    /// One poll of the episode; [`Step::Sleep`] once the spin and the yields
+    /// are spent (and on every call after that).
+    #[inline]
+    pub fn step(&mut self) -> Step {
+        if self.polls < self.budget {
+            self.polls += 1;
+            if self.polls.is_multiple_of(CHECK_EVERY) {
+                self.checkpoint();
+            }
+            std::hint::spin_loop();
+            return Step::Poll;
+        }
+        if self.yields < YIELD_POLLS {
+            self.yields += 1;
+            std::thread::yield_now();
+            return Step::Poll;
+        }
+        self.slept = true;
+        Step::Sleep
+    }
+
+    #[cold]
+    fn checkpoint(&mut self) {
+        let Some(p) = self.pressure else { return };
+        let now = p.now();
+        let gap = p.gap_at(now);
+        if gap == 0 {
+            // No detection now, and none later in this episode: stop reading
+            // the clock.
+            self.pressure = None;
+            return;
+        }
+        let own_active = || self.own.is_some_and(|o| o.load(Ordering::Relaxed) > now);
+        match self.last {
+            None if p.active(now) || own_active() => {
+                self.budget = self.budget.min(p.throttled().max(self.polls))
+            }
+            Some(last) if now.saturating_sub(last) > gap => {
+                p.note(now);
+                if let (Some(o), hold @ 1..) = (self.own, p.own_hold_ns()) {
+                    o.fetch_max(now.saturating_add(hold), Ordering::Relaxed);
+                }
+                self.budget = self.polls;
+            }
+            _ => {}
+        }
+        self.last = Some(now);
+    }
+}
+
+#[repr(align(128))]
+struct Pad<T>(T);
+
+/// The dispatched shares of a section that have not finished. The leader's
+/// join waits on it; the member that finishes the last share wakes the leader.
+#[doc(hidden)]
+pub struct Completion {
+    remaining: Pad<AtomicUsize>,
+}
+
+impl Completion {
+    /// `n` shares outstanding.
+    pub fn new(n: usize) -> Self {
+        Completion {
+            remaining: Pad(AtomicUsize::new(n)),
+        }
+    }
+
+    /// Whether every share has finished.
+    pub fn is_done(&self) -> bool {
+        self.remaining.0.load(Ordering::Acquire) == 0
+    }
+
+    /// One share finished; the last one wakes a sleeping leader through `sync`.
+    ///
+    /// # Safety
+    ///
+    /// `this` is valid when called. It is not dereferenced after the decrement,
+    /// because the leader may free it as soon as it observes zero; `sync` must
+    /// outlive the call independently of `this`.
+    pub unsafe fn finish(this: *const Completion, sync: Option<&Parker>) {
+        // SeqCst: the state change of the `Parker` protocol (rule 2).
+        if (*this).remaining.0.fetch_sub(1, Ordering::SeqCst) == 1 {
+            if let Some(sync) = sync {
+                sync.wake();
+            }
+        }
+    }
+
+    /// Waits until every share has finished: spin, yield, then sleep on `sync`.
+    pub fn wait(&self, sync: Option<&Parker>, waiter: &mut Waiter<'_>) {
+        while !self.is_done() {
+            if waiter.step() == Step::Sleep {
+                match sync {
+                    Some(sync) => sync.park_while(|| self.remaining.0.load(Ordering::SeqCst) != 0),
+                    None => std::hint::spin_loop(),
+                }
+            }
+        }
+    }
+}
+
+/// The sense-reversing barrier of a section's participants.
+#[doc(hidden)]
+pub struct Barrier {
+    size: usize,
+    arrived: Pad<AtomicUsize>,
+    epoch: Pad<AtomicUsize>,
+}
+
+impl Barrier {
+    /// A barrier over `size` participants.
+    pub fn new(size: usize) -> Self {
+        Barrier {
+            size,
+            arrived: Pad(AtomicUsize::new(0)),
+            epoch: Pad(AtomicUsize::new(0)),
+        }
+    }
+
+    /// Waits until all `size` participants arrived, or `cancelled` is raised
+    /// (then `false`). The last arrival opens the barrier and wakes sleepers
+    /// through `sync`; whoever raises `cancelled` must wake `sync` too.
+    pub fn arrive(
+        &self,
+        cancelled: &AtomicBool,
+        sync: Option<&Parker>,
+        waiter: &mut Waiter<'_>,
+    ) -> bool {
+        if cancelled.load(Ordering::Acquire) {
+            return false;
+        }
+        if self.size == 1 {
+            return true;
+        }
+        let epoch = self.epoch.0.load(Ordering::Acquire);
+        if self.arrived.0.fetch_add(1, Ordering::AcqRel) + 1 == self.size {
+            self.arrived.0.store(0, Ordering::Relaxed);
+            // SeqCst: the state change of the `Parker` protocol (rule 2).
+            self.epoch.0.store(epoch.wrapping_add(1), Ordering::SeqCst);
+            if let Some(sync) = sync {
+                sync.wake();
+            }
+            return true;
+        }
+        loop {
+            if self.epoch.0.load(Ordering::Acquire) != epoch {
+                return true;
+            }
+            if cancelled.load(Ordering::Acquire) {
+                return false;
+            }
+            if waiter.step() == Step::Sleep {
+                match sync {
+                    Some(sync) => sync.park_while(|| {
+                        self.epoch.0.load(Ordering::SeqCst) == epoch
+                            && !cancelled.load(Ordering::SeqCst)
+                    }),
+                    None => std::hint::spin_loop(),
+                }
+            }
+        }
+    }
+}
diff --git a/src/pin.rs b/src/pin.rs
index 53a2ddb..b1ae886 100644
--- a/src/pin.rs
+++ b/src/pin.rs
@@ -22,7 +22,7 @@
 //! The same CPU set decides whether a root scope is *oversubscribed* (see
 //! [`available`]): a team of more participants than the caller's mask has CPUs
 //! parks its members early instead of spinning (see `awake.rs`), and
-//! [`oversubscribed`] and [`park_delay`] are what the root-scope entries use.
+//! [`oversubscribed`] is what the root-scope entries use.
 
 use core::sync::atomic::{AtomicBool, Ordering};
 
@@ -61,17 +61,6 @@ pub(crate) fn oversubscribed(participants: usize) -> bool {
     participants > available()
 }
 
-/// The park delay of the reserved members of a root scope, in nanoseconds:
-/// zero when the scope is oversubscribed (park after the short spin), the
-/// scope's policy delay otherwise.
-pub(crate) fn park_delay(policy: crate::policy::WaitPolicy, oversubscribed: bool) -> u64 {
-    if oversubscribed {
-        0
-    } else {
-        u64::try_from(policy.idle_spin().as_nanos()).unwrap_or(u64::MAX)
-    }
-}
-
 /// Pins the calling thread onto the `k`-th CPU of `set` (wrapping).
 ///
 /// Called by a member for itself (`k >= 1`); the leader never calls it. Best
diff --git a/src/policy.rs b/src/policy.rs
index 39623fc..64d2742 100644
--- a/src/policy.rs
+++ b/src/policy.rs
@@ -11,7 +11,9 @@ use core::time::Duration;
 ///
 /// * `idle_spin`: how long an idle member keeps spinning, ready to be claimed
 ///   again without a Rayon wake-up, before it returns its thread to Rayon.
-///   Zero returns it immediately.
+///   Zero returns it immediately. The pool's spin budget of polls
+///   ([`PoolBuilder::spin_polls`](crate::PoolBuilder::spin_polls)) bounds it
+///   too, whichever ends first.
 /// * `idle_runs_rayon`: whether the spinning member runs queued Rayon jobs in
 ///   the meantime. When it does, a job it picked up runs to completion
 ///   (including nested work) before the member is claimable again, and an
diff --git a/src/pool.rs b/src/pool.rs
index 4b177a0..4a6aa4d 100644
--- a/src/pool.rs
+++ b/src/pool.rs
@@ -31,6 +31,20 @@ const DEFAULT_ACQUIRE_TIMEOUT: Duration = Duration::from_millis(2);
 /// pool.
 const PIN_PARTICIPANTS_DEFAULT: bool = false;
 
+/// Default spin budget of a wait, in polls (one PAUSE, or YIELD on aarch64,
+/// per poll); see `docs/design/waiting.md`. 300000 on x86-64, libgomp's default
+/// `GOMP_SPINCOUNT` ("about 3 ms"; about 7 ms at the 24 ns per poll measured on
+/// Zen 3, EPYC 7713P; longer on Intel cores whose PAUSE is slower). With it a
+/// team called again 10 ms later on a quiet host starts as fast as 0.1.3
+/// (evo); 12288 polls (about 300 µs) made that first section 10.8x slower,
+/// because the members had gone to sleep. On aarch64 a YIELD is much cheaper
+/// than a PAUSE; 2^21 aims at the same order of time and is not measured yet.
+const SPIN_POLLS_DEFAULT: u32 = if cfg!(target_arch = "aarch64") {
+    1 << 21
+} else {
+    300_000
+};
+
 /// A fixed set of worker threads that [`Exec`](crate::Exec) tokens place work on.
 ///
 /// `Pool` is the only way to make a pool. It wraps the scheduler privately: no
@@ -172,6 +186,27 @@ impl Pool {
         self.awake.pin
     }
 
+    /// The spin budget of this pool's team waits, in polls
+    /// ([`PoolBuilder::spin_polls`]).
+    pub fn spin_polls(&self) -> u32 {
+        self.awake.waits.spin_polls
+    }
+
+    /// How often this pool's waits slept, and how often a waiter saw itself
+    /// descheduled, since the pool was built: diagnostics for the wait
+    /// benchmarks (`docs/design/waiting.md`).
+    #[doc(hidden)]
+    pub fn wait_counters(&self) -> WaitCounters {
+        use core::sync::atomic::Ordering::Relaxed;
+        let w = &self.awake.waits;
+        WaitCounters {
+            join_sleeps: w.join_sleeps.load(Relaxed),
+            barrier_sleeps: w.barrier_sleeps.load(Relaxed),
+            member_parks: w.member_parks.load(Relaxed),
+            pressure_events: w.pressure.events(),
+        }
+    }
+
     /// Number of workers currently kept awake as team members, reserved or
     /// idle. Zero once idle members returned to Rayon. A diagnostic: the value
     /// can change at any moment.
@@ -252,6 +287,13 @@ pub struct PoolBuilder {
     qos: Option<Qos>,
     costs: DispatchCosts,
     pin_participants: bool,
+    spin_polls: u32,
+    throttled_polls: u32,
+    pressure_hold: Duration,
+    pressure_events: u32,
+    own_hold: Duration,
+    preempt_gap: Duration,
+    warm_up: Duration,
 }
 
 impl PoolBuilder {
@@ -266,6 +308,13 @@ impl PoolBuilder {
             qos: None,
             costs: DispatchCosts::host_default(),
             pin_participants: PIN_PARTICIPANTS_DEFAULT,
+            spin_polls: SPIN_POLLS_DEFAULT,
+            throttled_polls: crate::park::THROTTLED_POLLS,
+            pressure_hold: Duration::from_nanos(crate::park::CONTENDED_HOLD_NS),
+            pressure_events: crate::park::CONTENDED_EVENTS,
+            own_hold: Duration::ZERO,
+            preempt_gap: Duration::ZERO,
+            warm_up: Duration::from_nanos(crate::park::WARM_NS),
         }
     }
 
@@ -340,6 +389,8 @@ impl PoolBuilder {
 
     /// Default spin time of an unreserved idle team member before it returns
     /// its thread to Rayon. Defaults to 200 ms; zero returns it immediately.
+    /// The member also returns once it has polled for the pool's spin budget
+    /// ([`spin_polls`](Self::spin_polls)), whichever comes first.
     ///
     /// Operations may override it with [`WaitOverride`](crate::WaitOverride).
     /// A reserved member never leaves on a timeout.
@@ -531,6 +582,76 @@ impl PoolBuilder {
         self
     }
 
+    /// Spin budget of a team wait, in polls of one PAUSE (YIELD on aarch64):
+    /// how long a reserved member waiting for work, a leader in a section's
+    /// join, or a participant in a barrier spins before it yields a few times
+    /// and then sleeps until woken (`docs/design/waiting.md`; the shape of
+    /// libgomp's `GOMP_SPINCOUNT`). A count, so a waiter that is descheduled
+    /// does not spend it while it waits for its CPU. Zero sleeps after the
+    /// yields. An oversubscribed scope, or a pool whose waiters were recently
+    /// descheduled, uses at most 100 polls. It also bounds how long an idle
+    /// member released by a team keeps polling before it returns to Rayon,
+    /// together with [`idle_spin`](Self::idle_spin).
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// let pool = threadteam::Pool::builder().threads(2).spin_polls(4096).build()?;
+    /// assert_eq!(pool.spin_polls(), 4096);
+    /// # Ok::<(), threadteam::Error>(())
+    /// ```
+    #[must_use]
+    pub fn spin_polls(mut self, polls: u32) -> Self {
+        self.spin_polls = polls;
+        self
+    }
+
+    /// Tuning of the throttled waits, for the wait benchmarks only: the spin
+    /// budget of a throttled wait (default 100 polls), how long the pool's
+    /// waits stay throttled (default 100 ms; zero throttles only the waiter
+    /// that saw a preemption), how many observed preemptions within that time
+    /// throttle the pool (default 4; zero never), and how long a preemption
+    /// throttles the member that saw it (default zero: only its own wait). See
+    /// `docs/design/waiting.md`.
+    #[doc(hidden)]
+    #[must_use]
+    pub fn wait_tuning(
+        mut self,
+        throttled_polls: u32,
+        pressure_hold: Duration,
+        pressure_events: u32,
+        own_hold: Duration,
+    ) -> Self {
+        self.throttled_polls = throttled_polls;
+        self.pressure_hold = pressure_hold;
+        self.pressure_events = pressure_events;
+        self.own_hold = own_hold;
+        self
+    }
+
+    /// The gap between two clock reads of a spinning waiter that counts as a
+    /// preemption after the pool's warm-up, for the wait benchmarks only.
+    /// Zero (the default) turns the detection off: every wait then spins its
+    /// full budget, yields and sleeps, as libgomp's waits do. See
+    /// `docs/design/waiting.md`.
+    #[doc(hidden)]
+    #[must_use]
+    pub fn preempt_gap(mut self, gap: Duration) -> Self {
+        self.preempt_gap = gap;
+        self
+    }
+
+    /// How long after the pool is built its waiters detect preemptions (gap
+    /// 200 µs) and the pool can throttle, whatever [`preempt_gap`](Self::preempt_gap)
+    /// says (default 200 ms; zero: no warm-up), for the wait benchmarks only.
+    /// See `docs/design/waiting.md`.
+    #[doc(hidden)]
+    #[must_use]
+    pub fn warm_up(mut self, warm: Duration) -> Self {
+        self.warm_up = warm;
+        self
+    }
+
     /// Starts the workers.
     ///
     /// Without the `parallel` feature no thread is started and the pool has
@@ -613,6 +734,15 @@ impl PoolBuilder {
                 self.acquire_timeout,
                 self.costs,
                 self.pin_participants,
+                self.spin_polls,
+                crate::park::Pressure::tuned(
+                    self.throttled_polls,
+                    u64::try_from(self.pressure_hold.as_nanos()).unwrap_or(u64::MAX),
+                    self.pressure_events,
+                    u64::try_from(self.own_hold.as_nanos()).unwrap_or(u64::MAX),
+                )
+                .with_gap(u64::try_from(self.preempt_gap.as_nanos()).unwrap_or(u64::MAX))
+                .with_warm_up(u64::try_from(self.warm_up.as_nanos()).unwrap_or(u64::MAX)),
             )),
         })
     }
@@ -627,6 +757,15 @@ impl PoolBuilder {
                 self.acquire_timeout,
                 self.costs,
                 self.pin_participants,
+                self.spin_polls,
+                crate::park::Pressure::tuned(
+                    self.throttled_polls,
+                    u64::try_from(self.pressure_hold.as_nanos()).unwrap_or(u64::MAX),
+                    self.pressure_events,
+                    u64::try_from(self.own_hold.as_nanos()).unwrap_or(u64::MAX),
+                )
+                .with_gap(u64::try_from(self.preempt_gap.as_nanos()).unwrap_or(u64::MAX))
+                .with_warm_up(u64::try_from(self.warm_up.as_nanos()).unwrap_or(u64::MAX)),
             )),
         })
     }
@@ -670,3 +809,17 @@ mod tests {
             .expect("drop on a worker hung");
     }
 }
+
+/// Counters of [`Pool::wait_counters`] (a diagnostic for the wait benchmarks).
+#[doc(hidden)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct WaitCounters {
+    /// Leaders that slept in a section's join.
+    pub join_sleeps: u64,
+    /// Participants that slept in a barrier.
+    pub barrier_sleeps: u64,
+    /// Reserved members that parked waiting for work.
+    pub member_parks: u64,
+    /// Waiters that saw a gap of more than 200 µs between their clock reads.
+    pub pressure_events: u64,
+}
diff --git a/src/reserve.rs b/src/reserve.rs
index 4ec6b96..23a57b2 100644
--- a/src/reserve.rs
+++ b/src/reserve.rs
@@ -48,11 +48,13 @@ impl Drop for LeaderGuard<'_> {
 ///   returns. A lent job that is still running delays the next section until it
 ///   finishes.
 ///
-/// Reserved members spin for the reservation's `idle_spin`, then **park**
-/// while staying reserved: they do not return to Rayon until the `Team` is
-/// dropped. The next dispatch wakes them with one condition-variable broadcast,
-/// which costs a syscall on the first dispatch after a park
-/// (`benches/wake_probe.rs`) and one atomic load for a warm one.
+/// Reserved members wait for work in staged episodes: they spin for the pool's
+/// spin budget ([`PoolBuilder::spin_polls`](crate::PoolBuilder::spin_polls)),
+/// yield a few times, then **park** while staying reserved; they do not return
+/// to Rayon until the `Team` is dropped (`docs/design/waiting.md`). The next
+/// dispatch wakes a parked member through its slot's parker, which costs a
+/// syscall on the first dispatch after a park (`benches/wake_probe.rs`) and one
+/// atomic read-modify-write for a warm one.
 ///
 /// # Serialization of callers
 ///
@@ -150,8 +152,8 @@ impl Pool {
     ///
     /// `width` counts the leader and is clamped to the pool width; zero is
     /// treated as one. Acquisition never waits for a running Rayon job (see
-    /// [`Exec::team`](crate::Exec::team)). Members park after the pool's
-    /// `idle_spin` without work.
+    /// [`Exec::team`](crate::Exec::team)). Members park after the pool's spin
+    /// budget without work ([`PoolBuilder::spin_polls`](crate::PoolBuilder::spin_polls)).
     ///
     /// # Errors
     ///
@@ -174,8 +176,10 @@ impl Pool {
         self.into_team_with(width, WaitOverride::new())
     }
 
-    /// [`into_team`](Pool::into_team) with an override of the park delay
-    /// (`idle_spin`) of the reserved members.
+    /// [`into_team`](Pool::into_team) with an override of the wait policy of
+    /// the reservation. The reserved members' waits for work use the pool's spin
+    /// budget, not `idle_spin` (`docs/design/waiting.md`); the override is kept
+    /// for the policy the team reports.
     ///
     /// # Errors
     ///
@@ -185,13 +189,14 @@ impl Pool {
         let policy = self.wait_policy().with(over);
         // On drop the members leave at once.
         let release = WaitPolicy::new(Duration::ZERO, false);
-        let reservation = match self
-            .awake
-            .acquire(&self, width - 1, release, policy.idle_spin())
-        {
-            Ok(r) => r,
-            Err(reason) => return Err(IntoTeamError { pool: self, reason }),
-        };
+        let reservation =
+            match self
+                .awake
+                .acquire(&self, width - 1, release, self.awake.spin_budget(false))
+            {
+                Ok(r) => r,
+                Err(reason) => return Err(IntoTeamError { pool: self, reason }),
+            };
         let team = Team {
             reservation,
             policy,
@@ -306,15 +311,14 @@ impl Team {
         let ids = &self.reservation.ids[..budget - 1];
         // Root-scope entry of the token: `exec` is serialized (one leader at a
         // time), so the calling thread's CPU set decides here whether the scope
-        // is oversubscribed. When it is, the members park after their short
-        // spin instead of spinning for the whole park delay; otherwise they get
-        // the policy's delay. `Exec::team_with` on the minted token repeats
+        // is oversubscribed. When it is, the members' waits get the throttled
+        // spin budget; otherwise the pool's. `Exec::team_with` on the minted token repeats
         // this on the thread that enters each scope, so a token that travels to
         // a thread with a different CPU set is paced by that set.
         let oversubscribed = crate::pin::oversubscribed(budget);
         self.pool
             .awake
-            .set_park_ns(ids, crate::pin::park_delay(self.policy, oversubscribed));
+            .set_spin_budget(ids, self.pool.awake.spin_budget(oversubscribed));
         let auth = TeamAuth {
             awake: &self.pool.awake,
             ids,
diff --git a/src/sync.rs b/src/sync.rs
index 5567a42..01300c0 100644
--- a/src/sync.rs
+++ b/src/sync.rs
@@ -3,11 +3,11 @@
 
 #[cfg(loom)]
 pub(crate) use loom::sync::{
-    atomic::{AtomicUsize, Ordering},
+    atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering},
     Condvar, Mutex,
 };
 #[cfg(not(loom))]
 pub(crate) use std::sync::{
-    atomic::{AtomicUsize, Ordering},
+    atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering},
     Condvar, Mutex,
 };
diff --git a/src/team.rs b/src/team.rs
index 9bac2b4..0dbb1f6 100644
--- a/src/team.rs
+++ b/src/team.rs
@@ -79,13 +79,16 @@ impl Participant<'_> {
 ///   `budget - 1` pool workers. Before any section runs, every participant
 ///   acknowledged on its own thread (a rendezvous), so barriers inside
 ///   sections cannot deadlock for lack of threads.
-/// * Reserved members spin with one PAUSE per poll, then park once the park
-///   delay (`idle_spin`) has passed since their own last share; they run no
-///   unrelated Rayon job and do not leave on a timeout, also between sections
-///   and during a long serial phase of the leader. They are returned when the
-///   scope ends. In a root scope with more participants than CPUs in the
-///   caller's affinity mask the delay is zero, so they park after a short spin
-///   instead of holding a CPU.
+/// * Every wait of a team is a staged episode (`docs/design/waiting.md`): a
+///   reserved member waiting for work, the leader in a section's join, and a
+///   participant in a barrier spin with one PAUSE per poll for the pool's spin
+///   budget ([`PoolBuilder::spin_polls`](crate::PoolBuilder::spin_polls)), yield
+///   a few times, then sleep until woken. Members run no unrelated Rayon job and
+///   do not leave on a timeout, also between sections and during a long serial
+///   phase of the leader; they are returned when the scope ends. In a root scope
+///   with more participants than CPUs in the caller's affinity mask, or in a
+///   pool whose waiters were recently descheduled, the spin is throttled to 100
+///   polls, so waiters free their CPUs quickly.
 /// * If the pool pins members
 ///   ([`PoolBuilder::pin_participants`](crate::PoolBuilder::pin_participants)),
 ///   member `k` of a root scope (participant `k >= 1`) runs on the `k`-th CPU of
@@ -571,6 +574,7 @@ where
         slot_call::<S>,
         (slot_of as *const S).cast(),
         geometry,
+        awake.map(|a| &a.waits),
     );
     let dispatched = geometry.dispatched;
     let guard = JoinGuard(&sec);
diff --git a/src/tests/mod.rs b/src/tests/mod.rs
index ea7a00b..6e9b33c 100644
--- a/src/tests/mod.rs
+++ b/src/tests/mod.rs
@@ -1,3 +1,4 @@
 #[cfg(all(feature = "parallel", target_os = "linux"))]
 mod placement;
 mod split;
+mod waiting;
diff --git a/src/tests/placement.rs b/src/tests/placement.rs
index 5678605..16bf618 100644
--- a/src/tests/placement.rs
+++ b/src/tests/placement.rs
@@ -72,6 +72,7 @@ fn a_section_carries_the_oversubscription_flag_it_was_built_with() {
         slot_of,
         std::ptr::null(),
         geometry(false),
+        None,
     );
     assert!(!quiet.over);
     let crowded = Section::new(
@@ -80,6 +81,7 @@ fn a_section_carries_the_oversubscription_flag_it_was_built_with() {
         slot_of,
         std::ptr::null(),
         geometry(true),
+        None,
     );
     assert!(crowded.over);
 }
@@ -178,3 +180,50 @@ fn a_team_scope_takes_the_oversubscription_from_the_thread_that_enters_it() {
     );
     assert!(scoped.1, "a fork child inherits the root's pressure");
 }
+
+/// The budget a root scope chooses at entry: the throttled one when its
+/// participants outnumber the caller's CPUs, the pool's otherwise; and a
+/// persistent team's token does the same at every root-scope entry.
+#[test]
+fn a_root_scope_chooses_the_throttled_spin_budget_when_oversubscribed() {
+    use crate::park::THROTTLED_POLLS;
+    let budget = 50_000;
+    let pool = |width| {
+        Pool::builder()
+            .threads(width)
+            .spin_polls(budget)
+            .acquire_timeout(Duration::from_secs(10))
+            .build()
+            .unwrap()
+    };
+    on_two_cpus(|| {
+        let crowded = pool(4);
+        let mut exec = Exec::new(&crowded, 4).unwrap();
+        exec.team(|team| {
+            let awake = team.awake.expect("a pool");
+            assert!(!team.ids.is_empty());
+            for &id in team.ids {
+                assert_eq!(awake.slot_spin_budget(id), THROTTLED_POLLS);
+            }
+        })
+        .expect("an idle pool");
+        drop(exec);
+        let team = crowded.into_team(4).expect("an idle pool");
+        let mut exec = team.exec(4);
+        exec.team(|t| {
+            for &id in t.ids {
+                assert_eq!(t.awake.unwrap().slot_spin_budget(id), THROTTLED_POLLS);
+            }
+        })
+        .expect("a team token opens its scope");
+
+        let fits = pool(2);
+        let mut exec = Exec::new(&fits, 2).unwrap();
+        exec.team(|team| {
+            for &id in team.ids {
+                assert_eq!(team.awake.unwrap().slot_spin_budget(id), budget);
+            }
+        })
+        .expect("an idle pool");
+    });
+}
diff --git a/src/tests/waiting.rs b/src/tests/waiting.rs
new file mode 100644
index 0000000..5b01fdd
--- /dev/null
+++ b/src/tests/waiting.rs
@@ -0,0 +1,172 @@
+//! The staged wait of `crate::park::Waiter` (`docs/design/waiting.md`).
+//!
+//! Nothing here depends on how the scheduler runs this thread: the pressure
+//! deadlines are set explicitly, and the only real delay (a sleep) can only make
+//! a measured gap longer.
+
+use crate::park::{Pressure, Step, Waiter, CONTENDED_HOLD_NS, PREEMPT_GAP_NS, THROTTLED_POLLS};
+use std::time::Duration;
+
+/// Steps until the waiter says sleep; the number of `Poll` steps before it.
+fn polls_until_sleep(w: &mut Waiter<'_>) -> u32 {
+    let mut n = 0;
+    while w.step() == Step::Poll {
+        n += 1;
+        assert!(n < 10_000_000, "never sleeps");
+    }
+    n
+}
+
+#[test]
+fn a_wait_spins_its_budget_then_yields_sixteen_times_then_sleeps() {
+    for budget in [0u32, 1, 63, 64, 1000] {
+        let mut w = Waiter::new(budget, None);
+        assert_eq!(polls_until_sleep(&mut w), budget + 16, "budget {budget}");
+        // It stays asleep-ready: every further step says sleep.
+        assert_eq!(w.step(), Step::Sleep);
+    }
+}
+
+#[test]
+fn a_pool_under_pressure_starts_its_waits_throttled() {
+    // Throttle on the first observation, with a deadline that cannot pass
+    // during the test.
+    let p = Pressure::tuned(THROTTLED_POLLS, CONTENDED_HOLD_NS, 1, 0);
+    p.note(u64::MAX - CONTENDED_HOLD_NS);
+    let mut throttled = Waiter::new(100_000, Some(&p));
+    assert_eq!(polls_until_sleep(&mut throttled), THROTTLED_POLLS + 16);
+    // A small budget is never raised to the throttled one.
+    let mut small = Waiter::new(70, Some(&p));
+    assert_eq!(polls_until_sleep(&mut small), 70 + 16);
+}
+
+#[test]
+fn a_descheduled_spinner_ends_its_spin_and_records_the_pressure() {
+    // Detection on (as during a new pool's warm-up, or with a nonzero gap).
+    let p = Pressure::new().with_gap(PREEMPT_GAP_NS);
+    assert_eq!(p.events(), 0);
+    let mut w = Waiter::new(1_000_000, Some(&p));
+    // The first clock read is at poll 64; a gap longer than 200 µs before the
+    // second one (poll 128) stands for a descheduled waiter.
+    for _ in 0..64 {
+        assert_eq!(w.step(), Step::Poll);
+    }
+    std::thread::sleep(Duration::from_millis(2));
+    for _ in 64..128 {
+        assert_eq!(w.step(), Step::Poll);
+    }
+    // The spin is over: what remains is the sixteen yields.
+    assert_eq!(polls_until_sleep(&mut w), 16);
+    assert_eq!(p.events(), 1, "the pool records the observation");
+}
+
+#[test]
+fn a_burst_throttles_the_pool_and_isolated_preemptions_do_not() {
+    // Four observations within the hold window throttle the pool (the
+    // default threshold).
+    let p = Pressure::tuned(THROTTLED_POLLS, CONTENDED_HOLD_NS, 4, 0);
+    let t = 1_000_000_000;
+    for k in 0..3 {
+        p.note(t + k * 1_000_000);
+        assert!(!p.active(t + k * 1_000_000), "observation {k} alone");
+    }
+    p.note(t + 3_000_000);
+    assert!(p.active(t + 3_000_000), "the fourth within the window");
+    assert!(
+        !p.active(t + 3_000_000 + CONTENDED_HOLD_NS),
+        "the hold ends"
+    );
+    // Observations spread wider than the window never add up.
+    let q = Pressure::tuned(THROTTLED_POLLS, CONTENDED_HOLD_NS, 4, 0);
+    for k in 0..10 {
+        let at = t + k * (CONTENDED_HOLD_NS + 1);
+        q.note(at);
+        assert!(!q.active(at), "isolated observation {k}");
+    }
+}
+
+#[test]
+fn with_a_per_thread_hold_a_preemption_throttles_the_thread_that_saw_it() {
+    use core::sync::atomic::AtomicU64;
+    // The per-thread hold is a benchmark knob (off by default); the pool
+    // threshold is off here so that only the thread's own deadline acts.
+    let p = Pressure::tuned(THROTTLED_POLLS, CONTENDED_HOLD_NS, 0, CONTENDED_HOLD_NS)
+        .with_gap(PREEMPT_GAP_NS);
+    let own = AtomicU64::new(0);
+    // A member's wait sees itself descheduled (a gap before its second clock
+    // read): its spin ends, and its slot's deadline is set.
+    let mut w = Waiter::of_thread(1_000_000, Some(&p), Some(&own));
+    for _ in 0..64 {
+        assert_eq!(w.step(), Step::Poll);
+    }
+    std::thread::sleep(Duration::from_millis(2));
+    for _ in 64..128 {
+        assert_eq!(w.step(), Step::Poll);
+    }
+    assert_eq!(polls_until_sleep(&mut w), 16);
+    assert!(own.load(core::sync::atomic::Ordering::Relaxed) > 0);
+    // The pool is not throttled: another thread's wait spins its full budget.
+    let other_own = AtomicU64::new(0);
+    let mut other = Waiter::of_thread(100_000, Some(&p), Some(&other_own));
+    assert_eq!(polls_until_sleep(&mut other), 100_000 + 16);
+    // The same thread's next wait is throttled while its deadline runs (set
+    // here to one that cannot pass during the test).
+    own.store(u64::MAX, core::sync::atomic::Ordering::Relaxed);
+    let mut again = Waiter::of_thread(100_000, Some(&p), Some(&own));
+    assert_eq!(polls_until_sleep(&mut again), THROTTLED_POLLS + 16);
+}
+
+#[test]
+fn by_default_a_preemption_sets_no_per_thread_deadline() {
+    use core::sync::atomic::{AtomicU64, Ordering};
+    let p = Pressure::new().with_gap(PREEMPT_GAP_NS);
+    let own = AtomicU64::new(0);
+    let mut w = Waiter::of_thread(1_000_000, Some(&p), Some(&own));
+    for _ in 0..64 {
+        w.step();
+    }
+    std::thread::sleep(Duration::from_millis(2));
+    for _ in 64..128 {
+        w.step();
+    }
+    assert_eq!(polls_until_sleep(&mut w), 16, "its own spin ends");
+    assert_eq!(
+        own.load(Ordering::Relaxed),
+        0,
+        "no lasting per-thread deadline"
+    );
+}
+
+#[test]
+fn with_detection_off_a_descheduled_spinner_keeps_spinning() {
+    // A preemption gap of zero: no clock-based detection at all (libgomp's
+    // waits); the spin runs its whole budget whatever the scheduler did.
+    let p = Pressure::new().with_gap(0).with_warm_up(0);
+    let mut w = Waiter::new(1_000, Some(&p));
+    for _ in 0..64 {
+        assert_eq!(w.step(), Step::Poll);
+    }
+    std::thread::sleep(Duration::from_millis(2));
+    assert_eq!(polls_until_sleep(&mut w), 1_000 - 64 + 16);
+    assert_eq!(p.events(), 0);
+}
+
+#[test]
+fn by_default_a_new_pool_detects_preemptions_only_during_its_warm_up() {
+    let spin_through_a_gap = |p: &Pressure| {
+        let mut w = Waiter::new(1_000, Some(p));
+        for _ in 0..64 {
+            w.step();
+        }
+        std::thread::sleep(Duration::from_millis(2));
+        polls_until_sleep(&mut w)
+    };
+    // During the warm-up (a fresh pressure): the gap ends the spin.
+    let warm = Pressure::new();
+    assert_eq!(spin_through_a_gap(&warm), 64 + 16);
+    assert_eq!(warm.events(), 1);
+    // After it (here: no warm-up), the default detects nothing.
+    let steady = Pressure::new().with_warm_up(0);
+    assert_eq!(spin_through_a_gap(&steady), 1_000 - 64 + 16);
+    assert_eq!(steady.events(), 0);
+}
diff --git a/tests/idle_clock.rs b/tests/idle_clock.rs
index b14ce83..4507ef0 100644
--- a/tests/idle_clock.rs
+++ b/tests/idle_clock.rs
@@ -1,5 +1,9 @@
-//! The idle clock of a reserved member (feature `trace`): the time since the
-//! member's own last share (or since it started, or since it woke from a park).
+//! The idle episodes of a reserved member (feature `trace`): after its own last
+//! share (or its start, or a wake-up) a member spins for the pool's spin budget
+//! of polls, yields a few times and parks (`docs/design/waiting.md`). The budget
+//! is a count, so no wall-clock lower bound on a park exists; the gating of the
+//! count itself is unit tested (`src/tests/waiting.rs`). Here the budget is zero
+//! and the test checks the episode's order and the wake-up.
 //!
 //! Everything here is judged by the **order of a member's own trace events**,
 //! never by a wall-clock bound on how fast the leader gets around to the next
@@ -8,11 +12,11 @@
 //! slot ids are read from the trace as well, because the acquisition may claim
 //! any free slots.
 //!
-//! * Never before the delay: for every park of member `m` at time `t`,
-//!   `t - max(m's last share end, m's last wake-up, m's start) >= SPIN`. This
-//!   holds for every park in the whole test.
-//! * After the delay: once no section arrives, every member parks; polled until
-//!   it happens, with no upper bound on how late.
+//! * A park follows an anchor: every `ParkEnter` of member `m` comes after one of
+//!   `m`'s own `SectionEnd`, `ParkExit` or `Enter` events, with no other
+//!   `ParkEnter` of `m` in between (one park per idle episode).
+//! * Once no section arrives, every member parks; polled until it happens, with
+//!   no upper bound on how late.
 //! * A following section wakes every member that was parked: the number of
 //!   `ParkExit`s rises by the number of members parked at that moment.
 #![cfg(all(feature = "trace", feature = "parallel"))]
@@ -21,8 +25,6 @@ use std::time::{Duration, Instant};
 use threadteam::trace::{self, Kind};
 use threadteam::Pool;
 
-const SPIN: Duration = Duration::from_millis(40);
-
 /// Only a hang guard: no assertion below is a bound on how long the members or
 /// the leader take.
 const DEADLINE: Duration = Duration::from_secs(10);
@@ -30,7 +32,7 @@ const DEADLINE: Duration = Duration::from_secs(10);
 fn team(width: usize) -> threadteam::Team {
     Pool::builder()
         .threads(width)
-        .idle_spin(SPIN)
+        .spin_polls(0)
         .acquire_timeout(Duration::from_secs(10))
         .build()
         .unwrap()
@@ -109,8 +111,9 @@ fn every_member_parked_after_its_last_share(events: &[trace::Event]) -> bool {
         })
 }
 
-/// Asserts the "never before the delay" property over every park in the trace.
-fn assert_no_park_before_the_delay(team: &threadteam::Team) {
+/// Asserts that every park follows its own anchor (a share end, a wake-up or the
+/// start) with no second park in the same idle episode.
+fn assert_one_park_per_episode(team: &threadteam::Team) {
     let events = member_events(team);
     let parks: Vec<_> = events
         .iter()
@@ -118,36 +121,39 @@ fn assert_no_park_before_the_delay(team: &threadteam::Team) {
         .collect();
     assert!(!parks.is_empty(), "no member parked at all");
     for park in parks {
-        // The park delay runs from the later of the member's own last share
-        // end, its own last wake-up and its start.
-        let anchor = events
+        let before: Vec<_> = events
             .iter()
             .filter(|e| e.member == park.member && e.ns <= park.ns)
-            .filter(|e| matches!(e.kind, Kind::SectionEnd | Kind::ParkExit | Kind::Enter))
-            .map(|e| e.ns)
-            .max();
-        let Some(anchor) = anchor else {
-            panic!("member {} parked without an anchor event", park.member);
-        };
+            .filter(|e| {
+                matches!(
+                    e.kind,
+                    Kind::SectionEnd | Kind::ParkExit | Kind::Enter | Kind::ParkEnter
+                )
+            })
+            .collect();
+        // The last event before this park (itself excluded) is an anchor.
+        let prev = before
+            .iter()
+            .rev()
+            .find(|e| !std::ptr::eq(**e, park))
+            .unwrap_or_else(|| panic!("member {} parked without an anchor event", park.member));
         assert!(
-            park.ns - anchor >= SPIN.as_nanos() as u64,
-            "member {} parked {} us after its own last share, wake-up or start",
-            park.member,
-            (park.ns - anchor) / 1000
+            prev.kind != Kind::ParkEnter,
+            "member {} parked twice in one idle episode",
+            park.member
         );
     }
 }
 
 #[test]
-fn members_park_after_the_park_delay_since_their_own_last_share_or_wake() {
+fn members_park_once_per_idle_episode_and_wake_on_the_next_section() {
     let team = team(3);
     let mut exec = team.exec(3);
     if team.size().get() < 3 {
         return;
     }
-    // Sections a few milliseconds apart for about 150 ms. This does *not*
-    // assert that nobody parks: on a loaded host the leader's sleeps can wake
-    // late enough for a member to idle through its delay, and that is allowed.
+    // Sections a few milliseconds apart: with a zero budget the members park
+    // between them, and every section wakes them.
     for _ in 0..30 {
         exec.reborrow().broadcast(|_| {}).unwrap();
         std::thread::sleep(Duration::from_millis(5));
@@ -162,9 +168,8 @@ fn members_park_after_the_park_delay_since_their_own_last_share_or_wake() {
         team.size().get() - 1,
         "every member ran a share: {members:?}"
     );
-    // The "not before" property holds for every park of the whole test, the
-    // ones inside the phase of regular sections included.
-    assert_no_park_before_the_delay(&team);
+    // One park per idle episode, over the whole test.
+    assert_one_park_per_episode(&team);
     // A following section wakes every member that is parked now: the wake-ups
     // are exactly the parked members' `ParkExit`s.
     let parked = parked_now(&team);
@@ -178,7 +183,9 @@ fn members_park_after_the_park_delay_since_their_own_last_share_or_wake() {
     wait_until("every parked member woke", || {
         count(&team, Kind::ParkExit) >= exits + parked
     });
-    // The clock restarts from the share they just ran: a later park is again at
-    // least SPIN after it.
-    assert_no_park_before_the_delay(&team);
+    // The episode restarts from the share they just ran.
+    wait_until("every member parked again", || {
+        parked_now(&team) == team.size().get() - 1
+    });
+    assert_one_park_per_episode(&team);
 }
diff --git a/tests/loom_park.rs b/tests/loom_park.rs
index 0e0558a..6fa46c8 100644
--- a/tests/loom_park.rs
+++ b/tests/loom_park.rs
@@ -7,7 +7,7 @@
 //! shows up as a deadlock of the leader's join.
 #![cfg(loom)]
 
-use loom::sync::atomic::{AtomicUsize, Ordering};
+use loom::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use loom::sync::Arc;
 use loom::thread;
 use threadteam::Parker;
@@ -130,3 +130,78 @@ fn a_wake_of_one_slot_leaves_the_other_asleep_until_its_own_change() {
         }
     });
 }
+
+// ---------------------------------------------------------------------------
+// The staged waits of a section (`docs/design/waiting.md`): the exact
+// `Completion` and `Barrier` code, with a zero spin budget so every waiter goes
+// straight to sleep on the shared parker.
+
+use threadteam::{Barrier, Completion, Waiter};
+
+/// The leader sleeps in `join` until the last of two members finishes; the
+/// member that brings the count to zero wakes it. A lost wake-up deadlocks.
+#[test]
+fn the_last_member_wakes_a_leader_asleep_in_join() {
+    model(|| {
+        let done = Arc::new(Completion::new(2));
+        let sync = Arc::new(Parker::new());
+        let ms: Vec<_> = (0..2)
+            .map(|_| {
+                let (done, sync) = (done.clone(), sync.clone());
+                thread::spawn(move || unsafe {
+                    Completion::finish(Arc::as_ptr(&done), Some(&sync))
+                })
+            })
+            .collect();
+        done.wait(Some(&sync), &mut Waiter::new(0, None));
+        assert!(done.is_done());
+        for m in ms {
+            m.join().unwrap();
+        }
+    });
+}
+
+/// Two participants pass two consecutive barrier rounds, sleeping on the
+/// shared parker: the reset of `arrived` and the epoch bump of one round never
+/// lose the other's arrival or wake-up in the next.
+#[test]
+fn consecutive_barrier_rounds_wake_every_sleeper() {
+    model(|| {
+        let barrier = Arc::new(Barrier::new(2));
+        let cancelled = Arc::new(AtomicBool::new(false));
+        let sync = Arc::new(Parker::new());
+        let peer = {
+            let (barrier, cancelled, sync) = (barrier.clone(), cancelled.clone(), sync.clone());
+            thread::spawn(move || {
+                for _ in 0..2 {
+                    assert!(barrier.arrive(&cancelled, Some(&sync), &mut Waiter::new(0, None)));
+                }
+            })
+        };
+        for _ in 0..2 {
+            assert!(barrier.arrive(&cancelled, Some(&sync), &mut Waiter::new(0, None)));
+        }
+        peer.join().unwrap();
+    });
+}
+
+/// A participant asleep in a barrier that can never complete (the third
+/// participant failed) is woken by the cancellation and leaves with `false`.
+#[test]
+fn a_cancellation_wakes_a_participant_asleep_in_a_barrier() {
+    model(|| {
+        let barrier = Arc::new(Barrier::new(3));
+        let cancelled = Arc::new(AtomicBool::new(false));
+        let sync = Arc::new(Parker::new());
+        let waiter = {
+            let (barrier, cancelled, sync) = (barrier.clone(), cancelled.clone(), sync.clone());
+            thread::spawn(move || {
+                barrier.arrive(&cancelled, Some(&sync), &mut Waiter::new(0, None))
+            })
+        };
+        // `Section::fail`: raise the flag (SeqCst), then wake.
+        cancelled.store(true, Ordering::SeqCst);
+        sync.wake();
+        assert!(!waiter.join().unwrap());
+    });
+}
diff --git a/tests/oversubscribed.rs b/tests/oversubscribed.rs
index d9bd759..8865dc6 100644
--- a/tests/oversubscribed.rs
+++ b/tests/oversubscribed.rs
@@ -1,11 +1,13 @@
 //! A root team scope that has more participants than CPUs in the caller's set
-//! parks its members after a short spin instead of spinning for the whole park
-//! delay, and its nested sections keep that knowledge.
+//! parks its members, and its nested sections keep working, with members that
+//! sleep and wake between them.
 //!
-//! Nothing here is a wall-clock bound on the members: the park delay of the
-//! policy is set far above the deadline of the hang guard, so *reaching* the
-//! park proves the scope used its own (zero) delay, whatever the host's speed,
-//! and the wait itself is a poll of the trace with no upper bound.
+//! These are sleeping and waking smoke tests. The pool's spin budget is lifted
+//! to `u32::MAX` polls (minutes), so a member parks within the hang guard only
+//! through a short budget: the throttled one the oversubscribed scope chose, or
+//! the pressure heuristic of a loaded host (`docs/design/waiting.md`). Which
+//! budget a root scope chooses is checked directly in
+//! `src/tests/placement.rs`.
 #![cfg(all(feature = "trace", feature = "parallel", target_os = "linux"))]
 
 use std::sync::atomic::{AtomicUsize, Ordering};
@@ -13,10 +15,6 @@ use std::time::{Duration, Instant};
 use threadteam::trace::{self, Kind};
 use threadteam::Pool;
 
-/// The policy's park delay. Far above `DEADLINE`: a member that waited for it
-/// could not park within the deadline.
-const PARK_DELAY: Duration = Duration::from_secs(60);
-
 /// Only a hang guard.
 const DEADLINE: Duration = Duration::from_secs(10);
 
@@ -86,10 +84,9 @@ fn members_that_ran(events: &[trace::Event]) -> Vec<usize> {
 /// Polls (hang guard only) until every member that ran a share has a
 /// `ParkEnter` later than its own last `SectionEnd`.
 ///
-/// No upper bound on how late: what the deadline rules out is the opposite —
-/// with `PARK_DELAY` = 60 s, a member that kept the policy's delay cannot park
-/// before it, so parking within `DEADLINE` can only come from the scope's own
-/// (zero) delay.
+/// No upper bound on how late. With the pool's budget lifted to `u32::MAX`
+/// polls, parking within `DEADLINE` comes from a short budget (see the module
+/// documentation).
 fn wait_until_members_parked(team: &threadteam::Team) {
     let start = Instant::now();
     loop {
@@ -119,7 +116,7 @@ fn wait_until_members_parked(team: &threadteam::Team) {
         }
         assert!(
             start.elapsed() < DEADLINE,
-            "no member parked within {DEADLINE:?}: the scope kept the policy's {PARK_DELAY:?} delay"
+            "no member parked within {DEADLINE:?}: the scope kept the pool's lifted spin budget"
         );
         std::thread::sleep(Duration::from_millis(2));
     }
@@ -142,7 +139,7 @@ fn an_oversubscribed_root_scope_parks_its_members_quickly() {
 
     let pool = Pool::builder()
         .threads(4)
-        .idle_spin(PARK_DELAY)
+        .spin_polls(u32::MAX)
         .acquire_timeout(Duration::from_secs(10))
         .build()
         .unwrap();
@@ -185,7 +182,7 @@ fn the_scope_that_enters_decides_the_park_delay_not_the_mint() {
     // with the policy's 60 s park delay.
     let pool = Pool::builder()
         .threads(3)
-        .idle_spin(PARK_DELAY)
+        .spin_polls(u32::MAX)
         .acquire_timeout(Duration::from_secs(10))
         .build()
         .unwrap();
diff --git a/tests/team.rs b/tests/team.rs
index e68298c..e323bbe 100644
--- a/tests/team.rs
+++ b/tests/team.rs
@@ -37,10 +37,15 @@ fn pool(n: usize) -> Pool {
 }
 
 /// A pool whose acquisitions tolerate a loaded test host.
+/// A pool whose idle members stay for `spin` of wall time: the poll bound of
+/// an idle member (`spin_polls`) is lifted so that `idle_spin` alone decides,
+/// which these tests are about. `idle_members_return_after_the_spin_budget`
+/// covers the poll bound.
 fn builder(n: usize, spin: Duration) -> threadteam::PoolBuilder {
     Pool::builder()
         .threads(n)
         .idle_spin(spin)
+        .spin_polls(u32::MAX)
         .acquire_timeout(Duration::from_secs(5))
 }
 
@@ -483,6 +488,80 @@ fn a_panic_cancels_barriers_so_peers_leave_instead_of_deadlocking() {
     }
 }
 
+/// The same with every wait asleep (`spin_polls(0)`): the panicker raises the
+/// cancellation after its peers went to sleep in the barrier, and the
+/// cancellation wakes them (`Section::fail`).
+#[test]
+fn a_panic_wakes_peers_asleep_in_a_barrier() {
+    let _w = watchdog();
+    let pool = Pool::builder()
+        .threads(5)
+        .spin_polls(0)
+        .acquire_timeout(Duration::from_secs(5))
+        .build()
+        .unwrap();
+    for panicker in [0, 3] {
+        let mut exec = Exec::new(&pool, 5).unwrap();
+        let cancelled = AtomicUsize::new(0);
+        let r = catch_unwind(AssertUnwindSafe(|| {
+            exec.team(|team| {
+                team.run_with(|p| {
+                    if p.index() == panicker {
+                        // Let the peers reach the barrier and sleep first.
+                        std::thread::sleep(Duration::from_millis(20));
+                        panic!("boom");
+                    }
+                    if p.barrier() == Err(Cancelled) {
+                        cancelled.fetch_add(1, Ordering::SeqCst);
+                    }
+                });
+            })
+        }));
+        assert!(r.is_err());
+        assert_eq!(cancelled.load(Ordering::SeqCst), 4);
+    }
+}
+
+/// Every wait asleep (`spin_polls(0)`), many short sections with barriers,
+/// splits and forks: every section completes with every share counted. A lost
+/// wake-up hangs (watchdog).
+#[test]
+fn sleeping_waits_complete_every_section() {
+    let _w = watchdog();
+    let pool = Pool::builder()
+        .threads(6)
+        .spin_polls(0)
+        .acquire_timeout(Duration::from_secs(5))
+        .build()
+        .unwrap();
+    let team = pool.into_team(6).unwrap();
+    let mut exec = team.exec(6);
+    let sum = AtomicUsize::new(0);
+    let rounds = 300;
+    exec.team(|mut t| {
+        let size = t.size().get();
+        for _ in 0..rounds {
+            t.reborrow().run(|_, _| {
+                sum.fetch_add(1, Ordering::Relaxed);
+            });
+            t.reborrow().run_with(|p| {
+                p.barrier().unwrap();
+                p.barrier().unwrap();
+                sum.fetch_add(1, Ordering::Relaxed);
+            });
+            t.reborrow()
+                .split(&[size / 2, size - size / 2], |_, child| {
+                    child.run(|_, _| {
+                        sum.fetch_add(1, Ordering::Relaxed);
+                    });
+                })
+                .unwrap();
+        }
+        assert_eq!(sum.load(Ordering::Relaxed), rounds * 3 * size);
+    })
+    .unwrap();
+}
+
 #[test]
 fn a_child_panic_propagates_through_split_after_siblings_finish() {
     let _w = watchdog();
@@ -577,6 +656,25 @@ fn the_team_runs_from_a_pool_worker_with_members_from_the_others() {
     let _ = ok.load(Ordering::SeqCst);
 }
 
+#[test]
+fn idle_members_return_after_the_spin_budget() {
+    let _w = watchdog();
+    // An hour of `idle_spin`, but a budget of 1000 polls: a released member
+    // returns to Rayon after its polls, long before the hour.
+    let pool = Pool::builder()
+        .threads(4)
+        .idle_spin(Duration::from_secs(3600))
+        .spin_polls(1000)
+        .acquire_timeout(Duration::from_secs(5))
+        .build()
+        .unwrap();
+    let mut exec = Exec::new(&pool, 4).unwrap();
+    exec.team(|t| t.run(|_, _| {})).unwrap();
+    wait_until("idle members returned after their polls", || {
+        pool.resident_members() == 0
+    });
+}
+
 #[test]
 fn pool_drop_joins_idle_members() {
     let _w = watchdog();
diff --git a/tests/team_alloc_free.rs b/tests/team_alloc_free.rs
index 32e0ee5..d5ad57b 100644
--- a/tests/team_alloc_free.rs
+++ b/tests/team_alloc_free.rs
@@ -174,4 +174,46 @@ fn team_dispatch_does_not_allocate_after_warm_up() {
     for round in 0..20 {
         assert_eq!(allocs_in(|| token_phases(&team)), 0, "pinned round {round}");
     }
+    drop(team);
+
+    // A zero spin budget: every join and barrier wait that does not finish at
+    // once goes to sleep on the pool's parker (`docs/design/waiting.md`), and
+    // every member waits for work asleep. Neither the sleep nor the wake-up
+    // allocates. The shares are uneven, so that waiters do sleep.
+    let pool = Pool::builder()
+        .threads(4)
+        .spin_polls(0)
+        .acquire_timeout(Duration::from_secs(5))
+        .build()
+        .unwrap();
+    let team = pool.into_team(4).unwrap();
+    let mut exec = team.exec(4);
+    let sleeping_phases = |exec: &mut Exec<'_>| {
+        exec.reborrow()
+            .team(|mut t| {
+                t.reborrow().run(|i, _| {
+                    if i == 1 {
+                        std::thread::sleep(Duration::from_micros(200));
+                    }
+                });
+                t.reborrow().run_with(|p| {
+                    if p.index() == 2 {
+                        std::thread::sleep(Duration::from_micros(200));
+                    }
+                    p.barrier().unwrap();
+                    sink.fetch_add(p.index(), Ordering::Relaxed);
+                });
+            })
+            .unwrap();
+    };
+    for _ in 0..50 {
+        sleeping_phases(&mut exec);
+    }
+    for round in 0..20 {
+        assert_eq!(
+            allocs_in(|| sleeping_phases(&mut exec)),
+            0,
+            "sleeping round {round}"
+        );
+    }
 }