docs(series4): CORRECTED -- cellular cost is NOT independent of payload

I had it as "~0.65 s per round trip, independent of payload size", and based
design advice on it ("minimise round trips, not bytes").  The first claim is
wrong and the second is too strong.

Every measurement behind it had a SMALL payload -- 59 B status, 266 B setup
records, 1024 B download chunks.  With the byte term small and similar across all
of them, per-command cost looked constant.  It was a narrow-range fit
extrapolated past its evidence.

Measured against a 14,176 B single response on UM12947 over an RX55:

  1,024 B   0.67 s      8,192 B   3.59 s
  2,048 B   1.22 s     14,176 B   6.25 s
  4,096 B   2.13 s

  t ~ 0.21 s + bytes / 2,350   -- fits within +/-11% over a 14x size range

The old 0.65 s figure was right FOR A 1 KB RESPONSE and is that model evaluated
at 1 KB.  Round trips still cost (0.21 s each; 24 of them for a setup walk is
still 16 s), but bytes cost more than round trips on anything over ~500 B, and
that reverses the advice: for STATUS work minimise commands, for DOWNLOADS the
floor is throughput and batching does not beat it.

So the 16 KB chunk size is a ~30% win, not 14x.  UM20147's 72,560-byte event is
~46 s at THOR's 1024 B and ~32 s at 16,384 B, because ~31 s of it is bytes on the
wire.  Still worth keeping -- 30% faster, and 14x fewer requests is 14x fewer
chances for a link to drop mid-download -- but the earlier "~3.2 s" projection
was wrong and is withdrawn.

Corrected in all four places it had propagated: the protocol reference, the
CHUNK_SIZE comment, the probe's verdict, and mm_client_check's banner.  The probe
now also prints a net time per measurement, since its raw timings include the
idle gap while the control reads to frame completion -- comparing them directly
was misleading.

Also confirmed in the same run: 16 KB-class responses survive a cellular PAD.
1,024 / 2,048 / 4,096 / 8,192 / 14,176 B all arrived in one frame, byte-identical,
over an RX55.  14,176 B is UM12947's largest event so the ceiling itself was not
reached, but a 14 KB response crossing the PAD intact is what needed proving.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Ru8Lg9HkkYvX9VWWo65SmL

docs/micromate_protocol_reference.md

@@ -732,6 +732,15 @@ THOR's chunk size. The offset field is a **uint16**, so the structural ceiling i
 **65,535 bytes per request** — which would make that same event **2 requests,
 ~1.3 seconds**.
 
+#### ✅ Confirmed over a cellular modem too (2026-10-02)
+
+UM12947 on an RX55, every size checked byte-for-byte against a 1024 B control:
+**1,024 / 2,048 / 4,096 / 8,192 / 14,176 all served in one frame, intact.** Its
+largest event is 14,176 B, so the 16,384 ceiling itself was not reached — but a
+14 KB single response crossing the PAD unscathed is the thing that needed
+proving. The reader reads to frame completion rather than using idle-gap
+detection, which is why ~10 TCP segments reassemble without special handling.
+
 #### ✅ The ceiling is 16,384 bytes, and over it the device CLAMPS SILENTLY
 
 Measured on UM20147, each size checked byte-for-byte against a known-good
@@ -877,7 +886,37 @@ across reads, and the modem splits **less** than USB does. The client reads to
 frame completion rather than using `read_until_idle`'s idle-gap detection, and
 handled both without a retry.
 
-### 🔑 ~0.65 s per round trip over cellular, independent of payload
+### 🔑 The cellular cost model — ~0.21 s per request + ~2,350 B/s
+
+> #### ⚠ CORRECTED 2026-10-02 — it is NOT independent of payload
+>
+> This section previously read **"~0.65 s per round trip, independent of payload
+> size"**, and concluded *"minimise round trips, not bytes"*. The first claim is
+> wrong and the second is too strong.
+>
+> Every measurement behind it had a **small** payload — 59 B status, 266 B setup
+> records, 1024 B download chunks. With the byte term small and similar across
+> all of them, per-command cost looked constant. It was a narrow-range fit
+> extrapolated past its evidence.
+>
+> Measured against a 14,176 B single response on UM12947 over an RX55:
+>
+> | request | measured | model |
+> |---|---|---|
+> | 1,024 B | 0.67 s | 0.65 s |
+> | 2,048 B | 1.22 s | 1.08 s |
+> | 4,096 B | 2.13 s | 1.96 s |
+> | 8,192 B | 3.59 s | 3.70 s |
+> | 14,176 B | 6.25 s | 6.25 s |
+>
+> **`t ≈ 0.21 s + bytes / 2,350`** — fits within ±11% across a 14× size range.
+>
+> The old 0.65 s figure was *right for a 1024-byte response* and is simply that
+> model evaluated at 1 KB. Round trips still cost real money (0.21 s each, and
+> 24 of them for a setup walk is still 16 s), but **bytes cost more than round
+> trips on anything over ~500 B**, and that reverses the design advice: for
+> *status* work minimise commands; for *downloads* the floor is throughput and no
+> amount of batching beats it.
 
 This is the number that matters for SFM's design.