docs(rfc): record TCP buffer auto-tuning in RFC 9293 / RFC 7323 adherence

Refresh the adherence records for the Tier-3 buffer auto-tuning work
(steps 1-6), per the lockstep rule that RFC-governed runtime changes
update the relevant adherence record.

RFC 9293:
- New §3.8.6.4 "Advertised-window sizing (receive-buffer auto-tuning)":
  documents that rcv_wnd_max is seeded from SO_RCVBUF / tcp.rmem.default
  and grown by Dynamic Right-Sizing (_maybe_adjust_rcv_space toward
  2*copied + 16*advmss, clamped at min(tcp.rmem.max, 0xFFFF << rcv_wsc)),
  gated on tcp.moderate_rcvbuf and disabled under SOCK_RCVBUF_LOCK —
  Linux tcp_rcv_space_adjust parity.
- Coverage-table rows for §3.8.6.4 DRS and the renamed §3.10.2 SEND /
  SO_SNDBUF auto-tune (tcp_sndbuf_expand).

RFC 7323:
- §2.2 "Maximum shift count": the offered rcv_wsc is now derived at SYN
  from tcp.rmem.max via derive_rcv_wscale (Linux tcp_select_initial_window),
  capped at WINDOW_SCALE__MAX_SHIFT = 14, strengthening the max-14 MUST;
  default 6 MiB rmem.max still derives shift 7.
- New §4 extension "Receiver-side RTT estimator (DRS)": the TSecr-echo
  EWMA (RcvRttState.observe) and the no-timestamps window-time min-fold
  fallback (observe_window, Linux tcp_rcv_rtt_measure win_dep=1) that feed
  DRS without perturbing the RFC 6298 RTO.
- Coverage + overall-assessment rows for both.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: ccie18643

docs/rfc/tcp/rfc7323__timestamps_wscale_paws/adherence.md

@@ -64,16 +64,23 @@ option presence:
 > the error but MUST use 14 instead of the specified
 > value."
 
-**Adherence:** met (need to verify the clamp). The
-default `_rcv_wsc = 7`
-(`packages/pytcp/pytcp/protocols/tcp/tcp__session.py:165`) yields a
-~8 MB max receive window (65535 << 7), well within
-the 14 cap. The wire-level option's `shift_count`
-field accepts up to 255 at the assembler level
-(uint8); the protocol-level clamp to 14 happens at
-the inbound adoption site. A regression that
-adopted shift > 14 would manifest as oversized
-window field shifts.
+**Adherence:** met. The offered receive shift is no
+longer a flat default — `TcpSession.__init__` sets
+`rcv_wsc = derive_rcv_wscale(tcp.rmem.max)`
+(`packages/pytcp/pytcp/protocols/tcp/state/tcp__state__window.py`,
+`derive_rcv_wscale`), sizing the shift for the
+receive-buffer DRS ceiling (Linux
+`tcp_select_initial_window`). The derivation returns
+the smallest shift whose `0xFFFF << shift` covers
+`tcp.rmem.max` and is itself **capped at 14**
+(`WINDOW_SCALE__MAX_SHIFT`), so the outbound offer can
+never exceed the RFC limit regardless of how large an
+operator sets `tcp.rmem.max`. The default 6 MiB
+`tcp.rmem.max` derives shift 7 (65535 << 7 ≈ 8 MiB),
+the canonical Linux value. The wire-level option's
+`shift_count` field accepts up to 255 at the assembler
+level (uint8); the protocol-level clamp to 14 on the
+*inbound* adoption side is separate and unchanged.
 
 ### Window field unscaled on SYN / SYN+ACK
 
@@ -253,6 +260,31 @@ multiple per-RTT samples from TSecr-based RTTM
 correctly; the alpha=1/8 / beta=1/4 weights work
 correctly with multiple samples per RTT.
 
+### §4 (extension) Receiver-side RTT estimator (DRS)
+
+Beyond the RTO sample above (which needs *our* data to
+be acked), PyTCP keeps a separate **receiver-side** RTT
+estimate for receive-buffer Dynamic Right-Sizing —
+mirroring Linux `rcv_rtt_est` / `tcp_rcv_rtt_measure_ts`
+— so a pure receiver that only sends ACKs still measures
+a round trip.
+
+**Adherence:** met (Linux-parity extension). On an
+inbound new-data segment carrying a valid TSecr,
+`RcvRttState.observe`
+(`packages/pytcp/pytcp/protocols/tcp/state/tcp__state__rcv_rtt.py`)
+folds `now_ms - TSecr` via an alpha=1/8 EWMA, deduped on
+the echoed TSecr so a within-RTT burst yields one
+sample (the phase-5 hook in
+`session/tcp__session__ack.py`). When TSopt was **not**
+negotiated, the fallback `observe_window` measures the
+wall-time to receive one advertised window of data
+(anchor at `rcv_nxt + rcv_wnd`) and takes the minimum,
+matching Linux `tcp_rcv_rtt_measure` (`win_dep=1`). The
+estimate feeds the DRS cadence gate (RFC 9293 §3.8.6.4)
+but never the RFC 6298 RTO, so it cannot perturb
+retransmission timing.
+
 ### §4.3 Which Timestamp to Echo (cases A, B, C)
 
 The §4.3 algorithm specifies the `TS.Recent` /
@@ -480,6 +512,23 @@ typical PyTCP use cases.
 
 **Status:** locked in.
 
+### §4 (extension) Receiver-side RTT estimator (DRS)
+
+- **Unit:**
+  `test__tcp__state__rcv_rtt.py::TestRcvRttState`
+  pins the TSecr EWMA fold + within-RTT dedup;
+  `::TestRcvRttStateWindowFallback` pins the
+  no-timestamps `observe_window` min-fold.
+- **Integration:**
+  `test__tcp__session__rcv_rtt.py` pins the RX-path
+  TSecr sample (seed / EWMA / dedup, and that a no-TS
+  connection stays unset after a single segment);
+  `test__tcp__session__rcv_rtt_no_ts.py` pins the
+  window-based fallback seeding the estimate and
+  enabling DRS growth on a timestamp-less connection.
+
+**Status:** locked in.
+
 ### §4.3 Which TSval to echo
 
 - **Integration:**
@@ -563,6 +612,7 @@ regression guard.
 | §3.2 TSopt on RST                               | n/a (gap)                                      |
 | §3.2 SHOULD drop missing-TSopt                  | n/a (gap)                                      |
 | §4 RTTM rule                                    | locked in                                      |
+| §4 Receiver-side RTT estimator (DRS)            | locked in (unit + integration, TS + no-TS)     |
 | §4.2 EWMA with multiple samples                 | locked in (covered by RFC 6298 audit)          |
 | §4.3 Which TSval to echo (A/B/C)                | locked in (Last.ACK.sent gate test)            |
 | §5.2 PAWS basic                                 | locked in                                      |
@@ -578,7 +628,7 @@ regression guard.
 |-------------------------------------------------|-----------------------------------------|
 | §2.2 WSCALE wire format                         | met                                     |
 | §2.2 Bilateral negotiation                      | met                                     |
-| §2.2 Max shift count = 14                       | met (default 7)                         |
+| §2.2 Max shift count = 14                       | met (derived from tcp.rmem.max, cap 14) |
 | §2.2 SYN window unscaled                        | met                                     |
 | §2.3 Snd/Rcv.Wind.Shift state                   | met                                     |
 | §2.4 Window retraction handling                 | met (cross-cut RFC 1122)                |
@@ -587,6 +637,7 @@ regression guard.
 | §3.2 TSopt on RST                               | met (synchronized states)               |
 | §3.2 SHOULD drop missing-TSopt                  | met                                     |
 | §4 RTTM rule                                    | met                                     |
+| §4 Receiver-side RTT estimator (DRS)            | met (Linux-parity; TS + no-TS)          |
 | §4.2 EWMA multi-sample                          | met                                     |
 | §4.3 TSval-to-echo (A/B/C)                      | met (Last.ACK.sent gate via RCV.NXT)    |
 | §5.2 PAWS                                       | met                                     |

docs/rfc/tcp/rfc9293__tcp/adherence.md

@@ -380,6 +380,35 @@ Cross-cut with RFC 1122 §4.2.3.2 (audited).
 
 **Adherence:** met.
 
+#### §3.8.6.4 Advertised-window sizing (receive-buffer auto-tuning)
+
+RFC 9293 §3.8.6 leaves the *size* of the advertised
+receive window to the implementation. PyTCP sizes it
+dynamically, mirroring Linux receive-buffer Dynamic
+Right-Sizing (`tcp_rcv_space_adjust`).
+
+**Adherence:** met (Linux-parity extension). The
+advertised window is `max(0, rcv_wnd_max -
+len(rx_buffer))` (`session/tcp__session.py` `_rcv_wnd`
+property), scaled by `rcv_wsc` (RFC 7323). `rcv_wnd_max`
+is seeded from the socket's `SO_RCVBUF`, else
+`tcp.rmem.default`, and grown at runtime by DRS
+(`_maybe_adjust_rcv_space`, run from `receive()`): once
+per receiver-RTT, when the application has drained more
+than the previous per-RTT measurement, `rcv_wnd_max`
+grows toward `2*copied + 16*advmss` plus a sender-rate
+term, clamped at `min(tcp.rmem.max, 0xFFFF << rcv_wsc)`.
+DRS is gated on the `tcp.moderate_rcvbuf` sysctl and
+disabled when `SO_RCVBUF` is set explicitly
+(SOCK_RCVBUF_LOCK), so an explicit option pins the
+window. The receiver RTT it needs comes from the RFC
+7323 TSecr echo on inbound data, or — without negotiated
+timestamps — from the wall-time to receive one
+advertised window (Linux `tcp_rcv_rtt_measure`). The
+offered `rcv_wsc` is derived at SYN from `tcp.rmem.max`
+(RFC 7323 §2.2) so the negotiated scaling can express
+the whole grown window.
+
 ---
 
 ## §3.9 Interfaces
@@ -578,7 +607,9 @@ locations:
 | §3.8.6.1 Persist timer              | data_transfer__send / window persist tests              |
 | §3.8.6.2 SWS                        | window tests                                             |
 | §3.8.6.3 Delayed ACK                | data_transfer__recv tests                                |
+| §3.8.6.4 Advertised-window DRS      | `test__tcp__session__so_rcvbuf.py` (SO_RCVBUF sizing); `test__tcp__session__drs.py` (grow toward BDP, cadence gate, rmem.max clamp, moderate_rcvbuf/SO_RCVBUF lock, receive()-path trigger); `test__tcp__session__rcv_rtt.py` / `test__tcp__session__rcv_rtt_no_ts.py` (RTT source); `test__tcp__session__rcv_wscale.py` (WSCALE ceiling) |
 | §3.9 Interfaces                     | socket tests + harness_smoke; `sendmsg` in `test__socket__tcp__socket.py::TestTcpSocketSendmsg`; SO_LINGER setsockopt/getsockopt in `::TestTcpSocketSoLinger` + close-path in `test__tcp__session__so_linger.py` |
+| §3.10.2 SEND / SO_SNDBUF autotune   | `test__tcp__session__sndbuf_autotune.py` (grows with cwnd, wmem.max clamp, grow-only, SO_SNDBUF lock); `test__tcp__session__buffer_defaults.py` (wmem.default floor) |
 | §3.10.2 SEND / SO_SNDBUF backpressure | `test__tcp__session__so_sndbuf.py` (partial-write, non-blocking EAGAIN, oversized-into-empty, getsockopt parity, ACK-drain wake, close wake) |
 | §3.10.7 Per-state SEGMENT ARRIVES   | per-state test files                                     |
 | §3.10.8 Timeouts                    | RTO + persist + keep-alive + TIME-WAIT tests             |