docs: replace invented memory figures with measured ones, ship the tuning knobs

The README claimed "~15 MB RSS" and, after the log-loading work, "~10 MB idle /
~19 MB with a 29 MB audit log". Those were TEST-INSTANCE numbers: one mock source
and one adapter. The real production config on this host (16 sources, 13
adapters, 59 models) sits at ~37-42 MB, and sat at ~105 MB before this series.
Quoting the single-source figure as the headline was misleading.

Both READMEs now state that memory scales with the number of configured sources
rather than with uptime, give a three-row measurement table (1 source / 1 source
with a 29 MB audit history / the 16-source production instance), and break the
production RSS down per region (Go heap, thread stacks + LuaJIT, mapped binary,
Go reservations, shared libs) so an operator can tell which part their own
deployment will grow.

Two runtime knobs are documented and now shipped by default in the desktop
build's core spawn (cmd/gui/main.js, overridable by exporting either variable):

  * MALLOC_ARENA_MAX=2 — LuaJIT allocates through cgo into glibc malloc, and
    glibc keeps up to 8*nproc per-thread arenas of ~1 MB that are never returned.
    Measured 8-15 arenas (7-12 MB) -> 0.
  * GOGC=50 — halves the Go heap target. Documented explicitly as useless ALONE
    (measured 20.3 -> 21.5 MB, i.e. worse, because the saved heap is eaten by
    more glibc arenas); only the pair cuts settled RSS, by ~19%.

Also corrects the binary size (8-12 MB, ~8 MB after the deploy script's -s -w)
and adds the elastic-pool / on-demand-log / self-healing-cooldown bullets that
README.md already had to README_EN.md.

README_EN.md

@@ -11,7 +11,7 @@ KimiCode…) behind a single endpoint. Pick a specific model or use **AUTO** mod
 which routes to the best healthy upstream by configured priority.
 
 > **Lightweight, no recompile to add sources**: the gateway is a single Go
-> binary (~10 MB, zero runtime dependencies). Adding or switching an upstream is
+> binary (8-12 MB, ~8 MB stripped; zero runtime dependencies). Adding or switching an upstream is
 > just a `sources` entry in `config.yaml` (or via the WebUI) or a `.lua`
 > adapter — **no Go changes, no recompile**. Changes submitted through the
 > WebUI take effect immediately (hot reload); editing `config.yaml` or a `.lua`
@@ -41,7 +41,21 @@ Extracted and independently evolved from the multi-source LLM adapter layer of
 - **Multimodal**: `content` arrays (`image_url` etc.) pass through losslessly;
   Anthropic/Gemini/Ollama are translated automatically.
 - **LuaJIT VM**: golua-binding LuaJIT; each adapter has its own VM + worker
-  pool for safe concurrency.
+  pool for safe concurrency. Pools are **elastic**: the sum of `max_concurrent`
+  over an adapter's sources is a ceiling, not a preallocation — states are booted
+  on demand and reclaimed when demand drops, so an idle gateway holds close to
+  zero Lua states. The grow step follows the adapter's max concurrency
+  (`clamp(ceil(max/8), 1, 8)`, and never exceeds the number of queued callers);
+  the shrink step follows the live connection count
+  (`clamp(ceil(slack/(1+in_use)), 1, slack)`), so an idle pool collapses in one
+  round while a busy one gives up a single state at a time.
+- **On-demand request logs**: the audit log is never held in memory — the
+  dashboard loads one screen, scrolling pages the rest straight off disk, CSV
+  export streams in O(1) memory, and leaving the page releases everything.
+- **Self-healing cooldown**: cooldown is capped at 5 minutes and, past the
+  window's midpoint, exactly one probe request is allowed through; a recovered
+  upstream (or a reset quota) returns to full rotation on that probe instead of
+  waiting out the window.
 - **disable_thinking**: `disable_thinking: true` toggles reasoning per-request.
 - **Lua adapter protocol**: each source mounts a `.lua` adapter with
   `transform_request` / `transform_response` / `transform_stream_chunk` — all
@@ -258,6 +272,59 @@ independently).
 A template is just a recipe — it doesn't become a source by itself. Only the
 key-bearing sources created from it carry real traffic.
 
+### Memory footprint (measured and tuned)
+
+Memory is not a constant: it scales with the **number of configured sources**
+(each source owns an `http.Transport` with its connection pool plus per-model
+health state), not with uptime. Measured on this machine (Linux x86_64, 12 cores):
+
+| Deployment shape | Startup RSS | Settled RSS |
+|---|---|---|
+| 1 source / 1 adapter (minimal) | ~4 MB | ~10 MB |
+| 1 source + a 29 MB audit history | ~19 MB | ~20 MB |
+| **16 sources / 13 adapters / 59 models (this host)** | ~28 MB | **~37-42 MB** |
+
+> For reference, the same production config used **~105 MB** before this round of
+> work. The reduction comes from three places: the audit log is no longer replayed
+> in full (~25 MB), Lua state pools no longer grow monotonically, and the two
+> runtime knobs below.
+
+Breakdown of the production instance (per-region, from `/proc/<pid>/smaps`):
+
+| Region | RSS | Notes |
+|---|---|---|
+| Go heap | ~14 MB | provider/registry/scheduler state + connection-pool buffers |
+| Other anonymous (thread stacks / LuaJIT chunks / runtime) | ~12 MB | scales with thread count and loaded adapters |
+| Binary text+rodata | ~8 MB | mapped executable pages (read-only, reclaimable by the kernel) |
+| Go runtime reservations | ~4 MB | the 2 GB+ you see in VSZ is address space, not physical memory |
+| Shared libraries | ~3 MB | libc / libluajit / libm |
+
+**Two recommended deployment knobs** (environment only, no code change):
+
+```ini
+# /etc/systemd/system/llmsproxy.service
+Environment=GOGC=50
+Environment=MALLOC_ARENA_MAX=2
+```
+
+- `MALLOC_ARENA_MAX=2`: LuaJIT allocates through cgo into glibc malloc, and glibc
+  allows up to `8 x nproc` per-thread arenas. Every OS thread that touches malloc
+  claims one (~1 MB each) and **never returns it to the OS**. Measured: 8-15
+  arenas (7-12 MB) down to **0**.
+- `GOGC=50`: halves the Go heap growth target. **It does nothing on its own** —
+  the heap it saves is immediately consumed by additional glibc arenas (measured
+  20.3 -> 21.5 MB, i.e. slightly worse) — so it must be paired with
+  `MALLOC_ARENA_MAX`. Together they cut settled RSS by **~19%**. The gateway is
+  I/O bound (1min10s of CPU per 9 hours here), so the extra GC cycles are free.
+
+> The desktop build (Electron) already injects both when spawning the embedded
+> core (`cmd/gui/main.js`); exporting either variable yourself overrides it. If you
+> write your own systemd unit or container spec, add them there.
+
+Optional: `GOMEMLIMIT=48MiB` as a soft ceiling saves roughly 1 MB more, at the
+cost of GC turning aggressive as the limit approaches. Not worth it for a relaxed
+deployment.
+
 ### disable_thinking
 
 With `"disable_thinking": true` in the request body, the gateway passes it to
@@ -354,7 +421,7 @@ Release installers ship in two flavors for different audiences:
 
 | Scenario | Pick | Why |
 | ---- | ---- | ---- |
-| Server / intranet gateway / unattended long-running | **Headless** (single binary) | ~10 MB, ~15 MB RSS, zero-dep single process — drop it into systemd or any container, remote admin |
+| Server / intranet gateway / unattended long-running | **Headless** (single binary) | ~8 MB binary; RSS scales with the number of sources (~10 MB for one, ~40 MB for 16 — see [Memory footprint](#memory-footprint-measured-and-tuned)), zero-dep single process — drop it into systemd or any container, remote admin |
 | Personal desktop daily use / multi-device intranet sharing | **Desktop** (GUI) | no-login embedded WebUI, tray one-click, autostart, silent background — for non-CLI users |
 | Windows desktop | **Desktop** | plain backend needs manual service registration; GUI ships native tray/autostart |
 | CI one-shot 3-platform installers | **Desktop packaging scripts** | `make gui-*` emits deb / AppImage / NSIS, drops straight into a release pipeline |