feat(congestion): BBR3 delay bound from the forward delay's trend

quest/m2/quic-realtime/README.md

@@ -39,7 +39,18 @@ spike assumed no consumer; teleoperation uplinks are one):
   in `moq-congestion`. The moq-shaper presets `cellular-step`,
   `cellular-bursty` and `cellular-deep` decide it. The report states the
   shaper's timing jitter, measured over `near-zero`, as the noise floor of the
-  delay signal.
+  delay signal. The BBR3 delay bound (`bbr3::Config::delay_bound`) brought
+  the harness: moq-quic's `tests::realtime` replays the three presets on the
+  sim, and the shared comparison adds the other candidates to it as
+  `Candidate`s (`just rs quic-sim` prints the table).
+- BBR3 delay bound decisions, ✅ 2026-11-01 (maintainer, on
+  [moq-dev/moq#7544](https://github.com/moq-dev/moq/pull/7544)): the brake
+  is a separate `bw_delay` bound beside `max_bw` and `bw_shortterm`, which
+  REFILL doesn't reset and which Startup and ProbeBW_UP raise. Its GoogCC-style
+  trend detector stays inside `moq-congestion`'s `bbr3/`, so dropping the
+  candidate deletes it, rather than sharing the GCC candidate's trendline.
+  The candidate reported on the sim replicas only; real sockets are the
+  shared comparison's job.
 - Native probing is required (decided 2026-10-25, maintainer). Every
   candidate implements `moq_congestion::Controller::probes` and reports
   `probe_inflight`, so moq-quic's native probing
@@ -84,6 +95,10 @@ Remaining work once the candidates finish (this README's own job):
 - Run the shared comparison on the uplink presets: queuing delay p50/p95/p99,
   throughput, reaction time to a capacity step down, and share against one
   competing CUBIC flow. Pick the winner on queuing delay.
+  It runs every candidate once over real moq-shaper sockets, measuring the
+  `near-zero` noise floor too, so a candidate's own report may stay on the
+  sim replicas (✅ 2026-11-01, maintainer, on
+  [moq-dev/moq#7544](https://github.com/moq-dev/moq/pull/7544)).
 - Run every candidate under both sender models in one harness: a bulk
   upload, and an encoder that follows `bandwidth_estimate` (the model moq-cli
   and moq-ffi use, and the one GoogCC is built for). Decided 2026-11-01
@@ -127,7 +142,6 @@ owns that feedback.
 
 ## Required
 
-- [BBR3 delay bound](/quest/m2/quic-realtime/bbr-delay-bound.md) - BBR3 with inflight capped when the forward delay gradient shows queue growth
 - [io_uring runs an application's controller](/quest/m2/quic-realtime/uring-controller.md) - moq-uring takes a controller factory, so the winner installs the same way on both runtimes
 - [moqsink encoder feedback](/quest/m2/quic-realtime/moqsink-feedback.md) - GStreamer publishers retune their encoder to the target rate
 

rs/justfile

@@ -347,6 +347,8 @@ quic-sim:
     # Forward delay against RTT as a queue-growth signal: deterministic in the simulation, then over real sockets through each cellular moq-shaper preset, one at a time so they do not add to each other's noise.
     bash sh/rs/nextest.sh cargo nextest run --locked --release -p moq-quic --lib --run-ignored only --no-capture -E 'test(/^tests::receive_ts::/)'
     bash sh/rs/nextest.sh cargo nextest run --locked --release -p moq-tokio --test integration --run-ignored only --no-capture --test-threads 1 -E 'test(/^receive_ts::/)'
+    # Each realtime congestion controller against BBR3 over sim replicas of the cellular presets: queueing delay, throughput, reaction to the drop, and share beside CUBIC.
+    bash sh/rs/nextest.sh cargo nextest run --locked --release -p moq-quic --lib --run-ignored only --no-capture -E 'test(/^tests::realtime::/)'
 
 # Prove downstream futures are Send at the default recursion limit on the
 # flake's pinned nightly. Nightly runs it; the land gate does not.

rs/moq-congestion/README.md

@@ -2,6 +2,8 @@
 
 BBR3, Cubic, GCC, SCReAMv2, and Unlimited congestion controllers, consumed by moq-quic and the native transport drivers.
 
+BBR3's optional delay bound (`bbr3::Config::delay_bound`) reads the peer's receive timestamps and brakes when the forward delay's trend shows the bottleneck queue growing.
+
 The controllers take explicit `kio::clock::Instant` values and never drive a runtime. The `Controller` trait names no transport types: `on_sent` returns an opaque per-packet state that the transport stores and hands back with each acknowledgement or loss, and the controller paces its own sends.
 
 Construct controllers with `Factory::build` on an `Arc<bbr3::Config>`, `Arc<cubic::Config>`, `Arc<gcc::Config>`, `Arc<scream::Config>`, or `Arc<Unlimited>`. `Bbr3`, `Cubic`, `Gcc`, `Scream`, `Unlimited`, and `Metrics` live at the crate root.