proto: land B4 and B2a — buffer bounds, budget knobs, effective readback (1.1.0)

Minor bump on 1.0.0, per core/docs/buffer-sizing.md.

B4 — bufferBytes bounds corrected in all four locations (DownloadSpec,
TaskDetail, download.update's patch, Settings.connection.bufferBytes): was
4 KiB-8 MiB with no stated default, now 64 KiB-16 MiB with a 1 MiB default.
64 KiB because 4 KiB is smaller than one libcurl HTTP/2 write-callback delivery;
16 MiB because throughput from write size is flat past ~1-4 MiB and past 16 MiB
there is stall-cover left to buy but no memory left to spend it on; 1 MiB
default because it is the only candidate for which docs/04's 60 MB RSS target
actually holds once buffers are counted per segment, not per download.

Two new settings keys: connection.maxTotalBufferBytes (128 MiB default) and
connection.maxActiveSegments (32 default). Without them CORE's clamp — reduce
every live segment's buffer to fit the global cap — has no wire configuration
surface, and "20 active downloads" has no meaning distinct from 160 live TLS
connections.

B2a — TaskDetail.effectiveBufferBytes: what a segment is actually using right
now, after the clamp. Placed on TaskDetail next to bufferBytes, following the
requested/effective pattern ADR 0010 already established for segments. The
download.get fixture now demonstrates a real clamp (16 MiB requested, 4 MiB
effective) rather than a case where the cap happens not to bind.

docs/04-engine-design.md §4 and §8 updated in the same change per CORE's
request and CLAUDE.md rule 5: the RSS target is now stated as conditional on
maxActiveSegments = 32, and the old 4 MiB/64 MiB/256 MiB numbers are corrected
to match the schema. ADR 0012 records the reasoning and explicitly keeps the
60 MB target over CORE's offered 120 MB alternative, with the arithmetic that
makes 60 MB achievable with margin.

Numbered 0012 rather than 0011: DAEMON is independently drafting ADR 0011
(admission control / segment budget split) in a peer session at time of
writing, so 0011 was reserved to avoid a collision.

Co-Authored-By: Claude Sonnet 5 <[email protected]>
Claude-Session: https://claude.ai/code/session_012fgjnqFCS5h5L7gZTZo3rV

docs/04-engine-design.md

@@ -67,13 +67,23 @@ One file, opened once, `O_WRONLY`. Each segment `pwrite()`s at its own absolute
 - `posix_fallocate()` the full size up front → contiguous extents, no ENOSPC surprise at
   99 %, no fragmentation.
 - Per-segment ring buffer, size = **`buffer_bytes`** (the user-visible "Buffer size"
-  setting). Default 4 MiB, range 64 KiB – 64 MiB. Curl's write callback appends; the
-  buffer is flushed with a single `pwrite` when full or when the segment ends.
+  setting, `connection.bufferBytes` on the wire). Default **1 MiB**, range **64 KiB –
+  16 MiB**. Curl's write callback appends; the buffer is flushed with a single `pwrite`
+  when full or when the segment ends.
   *This is the single biggest throughput knob and it is exposed in the UI: Options →
   Downloads → "Write buffer per connection".*
-- Global cap `max_total_buffer_bytes` (default 256 MiB) so 32 segments × 64 MiB can't OOM
-  the box. The per-segment value is silently reduced to fit and the effective value is
-  reported back to the UI.
+- Global cap `max_total_buffer_bytes` (`connection.maxTotalBufferBytes`, default
+  **128 MiB**) so a burst of large downloads with a large per-segment buffer can't OOM the
+  box. Combined with `max_active_segments` (`connection.maxActiveSegments`, default
+  **32**) — the ceiling on segments actually transferring at once, across every task, not
+  per download — every live segment's buffer is reduced to fit
+  `max_total_buffer_bytes / live_segment_count` (capped by `max_active_segments`), never
+  below the 64 KiB floor. The requested and effective values are both reported back to
+  the UI (`TaskDetail.bufferBytes` / `.effectiveBufferBytes`) so it can show, for example,
+  "16 MiB (using 4 MiB)". See `docs/adr/0012-buffer-and-segment-budget.md` for the
+  reasoning behind these numbers, including why 4 MiB / 64 MiB / 256 MiB (this section's
+  earlier draft) does not hold ≤ 60 MB RSS once buffers are counted per segment rather
+  than per download.
 - `posix_fadvise(POSIX_FADV_DONTNEED)` on written ranges — do not let a 40 GB ISO evict
   the user's entire page cache.
 - `fdatasync()` on a timer (default 5 s) and on pause, **not** per write.
@@ -122,6 +132,6 @@ toggles between Full speed / a saved limit, exactly as IDM does.
 ## 8. Performance targets (M7 gate, `tools/bench/`)
 
 - Saturate a 1 Gbit link with ≤ 8 % of one core.
-- ≤ 60 MB RSS with 20 active downloads at default buffers.
+- ≤ 60 MB RSS with 20 active downloads at default buffers, **given `max_active_segments = 32`** — without that cap, 20 downloads × 8 segments each is 160 live buffers even at the 1 MiB default, and the number does not hold. See `docs/adr/0012-buffer-and-segment-budget.md`.
 - 10 000-row task list: RPC `download.list` under 50 ms, GUI scroll at 60 fps.
 - No allocation in the curl write callback hot path (ring buffer is preallocated).