You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
{{ message }}
Repository navigation
FD leak: container esgota 1024 file descriptors em ~2-3 dias e o healthcheck quebra por EMFILE #792
FD leak: container esgota 1024 file descriptors em ~2-3 dias e o healthcheck quebra por EMFILE
Versão:ai-memory 2.2.0 (imagem Docker akitaonrails/ai-memory, :latest em 2026-09-12) Ambiente: Docker Compose em VPS (Ubuntu), soft limit nofile = 1024, volume /data bind-montado, wiki watcher ativo.
Sintoma
Depois de ~30h de uptime o container fica unhealthy: o healthcheck (ai-memory status, timeout 5s) começa a estourar e os logs mostram EMFILE repetindo:
ERROR ai_memory_wiki::watcher: reconciliation failed error=Too many open files (os error 24) consecutive_failures=13
WARN ai_memory_cli::commands::serve: scheduled lint failed for scope ... error=Too many open files (os error 24)
WARN ai_memory_cli::commands::serve: scheduled maintenance job failed; retrying error=scheduled rule-based lint had 3 scope errors job="rule_lint"
Evidência
ls /proc/1/fd | wc -l = 1024/1024 (limite soft atingido).
Por classe: 1004 sockets, 11 arquivos em /data (SQLite/WAL), 6 anon_inode, 2 pipes.
Taxa medida após restart: 152 FDs → 208 FDs em ~4h (~12 FDs/hora), com o serviço ocioso (só capture/lifecycle de fundo).
Suspeita
Leak de conexões de rede: o crescimento dominante é de sockets que não são fechados. Os logs apontam para o ciclo de reconciliação do ai_memory_wiki::watcher e os lints agendados — que continuam tentando abrir arquivos/conexões depois que o pool esgota, sem recover.
Impacto
Com o pool de FDs esgotado, qualquer conexão nova falha — incluindo o próprio healthcheck HTTP/CLI — e o container é marcado unhealthy pelo orquestrador. restart do container resolve por horas/dias (mitigação), o leak volta a crescer.
Pergunta
Há correção conhecida para esse leak em 2.2.1/2.2.2/2.3.x? Podemos testar uma versão fixa e reportar de volta. Obrigado pelo projeto — usamos como camada de captura/continuidade cross-client no nosso stack.
Obrigado pelo relatório detalhado — os números de /proc/1/fd ajudam muito. Investigamos o código do serve (2.2.x → main) atrás de um vazamento de fd em caminho periódico/por-requisição e ainda não conseguimos localizar um vazamento no nosso código que explique o perfil medido:
Seu próprio recorte mostra 1004 sockets mas só 11 arquivos em /data — isso descarta as conexões SQLite (writer/reader pool) e os handles do git2/libgit2, que apareceriam como fds de arquivo.
O watcher da wiki é instalado uma única vez (não re-registra a cada ciclo) e o reconcile só faz I/O de disco/DB — os erros Too many open files dele são consequência do pool já esgotado, não a causa.
O healthcheck (ai-memory status) roda como processo separado; o handler /admin/status só lê contadores em memória — não abre fd por probe.
Os clientes HTTP de LLM/embeddings são criados uma vez e reutilizados (com timeout) — não há o vazamento clássico de reqwest::Client por requisição no servidor.
Para localizar, precisamos de:
ss -tanp | head -50 (ou lsof -p 1 -nP | grep -i sock | head) dentro do container com fd alto — queremos ver o estado TCP (ESTABLISHED/CLOSE_WAIT/…) e o peer de alguns sockets (loopback? endereço do provedor LLM? conexões de entrada dos seus clientes?).
Seu config.toml/env: qual provider de LLM e de embeddings, e se maintenance/auto_improve/consolidate_on_session_end estão ligados.
Como sua camada de captura cross-client conversa com o servidor — transporte MCP (streamable/SSE?), se abre conexão por evento/sessão e se as fecha.
Hipótese atual: sockets de entrada abertos por clientes e abandonados sem fechamento limpo, que o axum::serve hoje não recicla (sem idle-timeout nem TCP keepalive). Estamos avaliando adicionar keepalive + idle-timeout no listener como blindagem, independentemente de confirmar este caso. O ss acima confirma ou refuta rapidamente.
Obrigado pela análise — respondendo os 3 pontos com o que verificamos de fato:
2. Config/env: sem provider de LLM nem de embeddings configurado (envs do container: AI_MEMORY_BIND, AI_MEMORY_ALLOWED_HOSTS, AI_MEMORY_AUTH_TOKEN, AI_MEMORY_AUTO_IMPROVE__REQUIRE_APPROVAL; não usamos config.toml). Ou seja: os clientes HTTP de LLM/embeddings do servidor nem entram em cena neste caso — o caminho de conexões aqui é o do MCP server.
3. Transporte dos nossos clientes: o consumidor principal é o nosso dashboard (web-server). Ele fala JSON-RPC streamable HTTP em POST /mcp com fetch novo por chamada de tool (Accept: application/json, text/event-stream), sem MCP-Session-Id, sem teardown explícito, com AbortSignal.timeout(8s) no lado do cliente. Fonte: apps/web-server/src/lib/ai-memory-client.ts do nosso monorepo. Um segundo consumidor (bot de Telegram, captura de sessão) existe no host, mas não o mapeamos em detalhe ainda.
1. ss do pico: não temos — a imagem anterior morreu sem captura (recriamos o container aplicando ulimits nofile soft 4096 antes de coletar). O que fizemos para a próxima janela: o nosso dead-man's switch agora grava dump cru de /proc/net/tcp+tcp6 do container no momento em que os FDs cruzam 3000 (limiar do alerta; teto 4096). Pelo ritmo medido (~12 FDs/h), o dump chega em ~10 dias e trazemos aqui.
Sobre a hipótese de vocês:Inferido — consistente com o que vemos. Nosso cliente abandona a requisição em 8s por timeout; se o axum::serve não tem idle-timeout/keepalive no listener, cada timeout deixaria uma conexão de entrada viva para sempre no servidor — e o dashboard gera chamadas o dia todo. Não medimos isso no pico, então fica como inferência até o dump.
Um detalhe do nosso lado que a investigação trouxe: o nosso wrapper de entrega de alertas morria num filtro jq mal-formado justamente quando um alerta notificado virava stale — por isso ninguém viu "resolvido" quando reiniciamos o container. Corrigido no nosso repo.
Se 2.3.x trouxer idle-timeout/keepalive no listener, testamos na hora e reportamos a curva de FDs. Obrigado pela resposta rápida!
Avanço com a assinatura exata que você pediu — e um experimento que descarta um caminho:
Assinatura no container de produção (2.2.0, ~4,5h de uptime, 120 fds no total, crescendo ~20 fds/h):
sockets do processo (por inode × /proc/net/tcp+tcp6):
98 ESTAB -> 0.0.0.0:0 <- conexões mortas, fd nunca fechado
1 LISTEN -> 0.0.0.0:0
Ou seja: todos os sockets acumulados estão ESTABLISHED com peer indefinido (0.0.0.0:0) — a estrutura de conexão já não existe do lado do kernel, mas o processo mantém o fd. É leak de fd pós-desconexão, não conexões de clientes ativas.
300 POST /mcp completos (tools/list) → fds estáveis (20→20).
300 POST /mcpabandonados no meio (cliente corta em 50 ms, Accept: application/json, text/event-stream, tools/call) → fds estáveis (20→20; só LISTEN/TIME_WAIT).
Ou seja: request completo e request abortado cedo não reproduzem — o servidor recicla. O gatilho está num caminho que esse tráfego básico não toca. Nossa candidata: o stream SSE do rmcp interrompido no meio pelo timeout do cliente (nosso cliente aceita application/json, text/event-stream com AbortSignal.timeout(8s); quando o servidor decide responder em stream e o cliente some no meio, o fd do stream morre pendurado).
Pergunta para vocês: nesse perfil (ESTAB 0.0.0.0:0 no processo do serve), onde o ciclo de vida do rmcp/axum deveria fechar o fd quando a conexão morre no meio de um stream — e há algo em 2.2.1–2.3.x nesse caminho? Se vocês apontarem o handler, testamos a versão na hora. Nosso dump cru de /proc/net/tcp no próximo pico segue instrumentado como plano B.
Your signature (sockets stuck `ESTABLISHED → 0.0.0.0:0`, i.e. the peer is gone from the kernel but the process keeps the fd, all on the streamable-HTTP `POST /mcp` transport, no `MCP-Session-Id`, no LLM/embedding provider configured) matches GHSA-9pj6-vhgr-3mwh — "unauthenticated permanent session-table leak in the rmcp Streamable HTTP server transport leads to remote denial-of-service." That is an upstream rmcp transport bug, which is exactly the layer your dashboard talks to, and it is consistent with an isolated single-request abandon not reproducing while a long-lived real client that opens a fresh session per tool-call does.
We have bumped rmcp 1.7 → 2.2.0 (which carries the fix), merged as #819. It is on the current line and will ship in the next release.
Could you retest on a build that includes it (build from the current branch, or the next tagged image once it publishes) and report the fd curve? We are keeping this issue open until you confirm the leak is gone in production. Independently, we are also evaluating a TCP-keepalive + idle-timeout on the listener as defense-in-depth regardless of this specific cause.
Thanks again for the /proc/net/tcp signature and the controlled experiment — they are what let us tie this to the transport layer.
I'd like to take the defense-in-depth half of this: TCP keepalive plus a header-read/idle timeout on the HTTP listener, independent of the rmcp fix.
Shape I intend to build, so you can redirect before code lands:
Idle timeout: axum::serve doesn't expose hyper's timeouts, so I'd take over the accept loop at serve.rs:1488 with hyper_util::server::conn::auto::Builder (already in the tree, 0.1.20), keep the router and ConnectInfo exactly as they are, and set http1().header_read_timeout(...) plus a per-connection deadline for idle keep-alive connections. Graceful shutdown keeps the current bounded drain.
Keepalive: on every accepted socket, set SO_KEEPALIVE with an explicit idle/interval via socket2 (also already in the lock file, 0.6.3). Needed because both macOS and Linux default keepidle to 2h, so relying on the OS gives nothing useful for a dead peer.
Two config keys with conservative defaults, env overrides, documented in ARCHITECTURE.md and deploy.md; ### Added in the CHANGELOG. Names open to your preference; I'd go with http_idle_timeout_secs and http_keepalive_secs, 0 disabling each.
Tests with controls: a client that sends a partial request and goes silent is closed by the server within the timeout; with the timeout disabled the same socket survives. Plus a before/after fd count against the reporter's abandon pattern on a local build, pasted in the PR.
No new dependencies. If any of this collides with something already in flight on 2.4, tell me and I'll adjust.
Reteste em produção na 2.4.0 (imagem ad047823…, rmcp 2.2.0 dentro) — resultado dividido em dois:
O fix do rmcp funcionou (Obs): probe de 30 sessões completas (initialize → tool call → disconnect limpo) deixou o processo em 27→27→26 fds. A assinatura ESTAB → 0.0.0.0:0 do 2.2.0 não reapareceu — o session-table leak está resolvido no nosso tráfego.
Mas ~3h depois apareceu a segunda assinatura — a que vocês já previam no primeiro comentário (Obs):
fd count: 27 (estável ~3h) → 338 → 437 em ~40min (~20 fd/min no pico)
sockets do processo × /proc/net/tcp:
390 ESTAB -> 172.20.0.1:XXXXX <- conexões VIVAS no kernel, peer morto
0 CLOSE_WAIT / TIME_WAIT / órfãos de inode
timers (ss -o): 390/392 sem timer — sem keepalive, nada os recicla
Diferença para a assinatura anterior: desta vez todos os fds têm socket vivo em /proc/net/tcp (0 órfãos) — não é sessão esquecida, é conexão TCP formalmente ESTABLISHED cujo peer morreu sem FIN. O fix do rmcp cobre o disconnect notificado; peer-morto-sem-FIN nunca notifica, então a session-table pode estar limpa e o fd vazar mesmo assim.
Origem (Obs): SYNs novos chegam de 100.127.95.124 — nossa máquina Windows via Tailscale, passando pelo docker-proxy (publish 100.103.73.60:49374:49374). São processos efêmeros (hooks de lifecycle que os clients MCP instalam: SessionStart/PreToolUse/SessionEnd) — conectam, morrem, e o FIN se perde no caminho (sleep da máquina, flap do Tailscale, kill abrupto). O docker-proxy segura o backend ESTABLISHED porque o frontend ainda não foi declarado morto.
Prova de zumbi (Obs):ss -K dentro do netns com sport = :49374 derrubou 416 ESTABLISHED → 1 e fds 437→22, sem restart, e o serviço seguiu healthy — conexões legítimas reconectaram transparentes.
Mitigação rodando aqui: cron a cada 15min checa o fd count; acima de 512 faz ss -K no netns do container e loga. Zero disrupção em operação normal (~30 fds) e compra tempo infinito contra o acúmulo.
Amarração: é exatamente o caso do defense-in-depth que o @ranierelm descreveu no comentário acima — keepalive + idle-timeout no listener fecharia esses fds na fonte. Se ajudar no before/after, esse tráfego real é trivial de instrumentar aqui: fd count por minuto durante um storm de hooks sai de graça. Config atual: AI_MEMORY_BIND, AI_MEMORY_ALLOWED_HOSTS, AI_MEMORY_AUTH_TOKEN, provider openai_compat via proxy interno — o acúmulo independe do provider, é camada de transporte.
The remaining half (half-open sockets never reaped) is fixed on main for 2.4.1: ai-memory serve now enables TCP keepalive on every accepted connection via axum's ListenerExt::tap_io + socket2, so a dead peer (sleep / VPN flap / kill) is probed and its fd reclaimed instead of sitting ESTABLISHED forever. New tcp_keepalive_secs config (default 60s; AI_MEMORY_TCP_KEEPALIVE_SECS; 0 disables), with socket-level regression tests. The rmcp session-table half was already fixed in 2.4.0 (#794). Slowloris/idle-request-timeout hardening is noted as a separate follow-up. Thanks for the production capture and the precise ss//proc/net/tcp diagnosis.
Activity
akitaonrails commentedon Sep 19, 2026
Obrigado pelo relatório detalhado — os números de
/proc/1/fdajudam muito. Investigamos o código doserve(2.2.x → main) atrás de um vazamento de fd em caminho periódico/por-requisição e ainda não conseguimos localizar um vazamento no nosso código que explique o perfil medido:/data— isso descarta as conexões SQLite (writer/reader pool) e os handles do git2/libgit2, que apareceriam como fds de arquivo.reconcilesó faz I/O de disco/DB — os errosToo many open filesdele são consequência do pool já esgotado, não a causa.ai-memory status) roda como processo separado; o handler/admin/statussó lê contadores em memória — não abre fd por probe.reqwest::Clientpor requisição no servidor.Para localizar, precisamos de:
ss -tanp | head -50(oulsof -p 1 -nP | grep -i sock | head) dentro do container com fd alto — queremos ver o estado TCP (ESTABLISHED/CLOSE_WAIT/…) e o peer de alguns sockets (loopback? endereço do provedor LLM? conexões de entrada dos seus clientes?).config.toml/env: qual provider de LLM e de embeddings, e semaintenance/auto_improve/consolidate_on_session_endestão ligados.Hipótese atual: sockets de entrada abertos por clientes e abandonados sem fechamento limpo, que o
axum::servehoje não recicla (sem idle-timeout nem TCP keepalive). Estamos avaliando adicionar keepalive + idle-timeout no listener como blindagem, independentemente de confirmar este caso. Ossacima confirma ou refuta rapidamente.joseehilton147 commentedon Sep 20, 2026
Obrigado pela análise — respondendo os 3 pontos com o que verificamos de fato:
2. Config/env: sem provider de LLM nem de embeddings configurado (envs do container:
AI_MEMORY_BIND,AI_MEMORY_ALLOWED_HOSTS,AI_MEMORY_AUTH_TOKEN,AI_MEMORY_AUTO_IMPROVE__REQUIRE_APPROVAL; não usamosconfig.toml). Ou seja: os clientes HTTP de LLM/embeddings do servidor nem entram em cena neste caso — o caminho de conexões aqui é o do MCP server.3. Transporte dos nossos clientes: o consumidor principal é o nosso dashboard (web-server). Ele fala JSON-RPC streamable HTTP em
POST /mcpcom fetch novo por chamada de tool (Accept: application/json, text/event-stream), sem MCP-Session-Id, sem teardown explícito, comAbortSignal.timeout(8s)no lado do cliente. Fonte:apps/web-server/src/lib/ai-memory-client.tsdo nosso monorepo. Um segundo consumidor (bot de Telegram, captura de sessão) existe no host, mas não o mapeamos em detalhe ainda.1.
ssdo pico: não temos — a imagem anterior morreu sem captura (recriamos o container aplicandoulimits nofile soft 4096antes de coletar). O que fizemos para a próxima janela: o nosso dead-man's switch agora grava dump cru de/proc/net/tcp+tcp6do container no momento em que os FDs cruzam 3000 (limiar do alerta; teto 4096). Pelo ritmo medido (~12 FDs/h), o dump chega em ~10 dias e trazemos aqui.Sobre a hipótese de vocês:
Inferido— consistente com o que vemos. Nosso cliente abandona a requisição em 8s por timeout; se oaxum::servenão tem idle-timeout/keepalive no listener, cada timeout deixaria uma conexão de entrada viva para sempre no servidor — e o dashboard gera chamadas o dia todo. Não medimos isso no pico, então fica como inferência até o dump.Um detalhe do nosso lado que a investigação trouxe: o nosso wrapper de entrega de alertas morria num filtro jq mal-formado justamente quando um alerta notificado virava stale — por isso ninguém viu "resolvido" quando reiniciamos o container. Corrigido no nosso repo.
Se
2.3.xtrouxer idle-timeout/keepalive no listener, testamos na hora e reportamos a curva de FDs. Obrigado pela resposta rápida!joseehilton147 commentedon Sep 20, 2026
Avanço com a assinatura exata que você pediu — e um experimento que descarta um caminho:
Assinatura no container de produção (2.2.0, ~4,5h de uptime, 120 fds no total, crescendo ~20 fds/h):
Ou seja: todos os sockets acumulados estão
ESTABLISHEDcom peer indefinido (0.0.0.0:0) — a estrutura de conexão já não existe do lado do kernel, mas o processo mantém o fd. É leak de fd pós-desconexão, não conexões de clientes ativas.Experimento controlado (container limpo 2.2.0, rede isolada, tmpfs):
POST /mcpcompletos (tools/list) → fds estáveis (20→20).POST /mcpabandonados no meio (cliente corta em 50 ms,Accept: application/json, text/event-stream, tools/call) → fds estáveis (20→20; só LISTEN/TIME_WAIT).Ou seja: request completo e request abortado cedo não reproduzem — o servidor recicla. O gatilho está num caminho que esse tráfego básico não toca. Nossa candidata: o stream SSE do rmcp interrompido no meio pelo timeout do cliente (nosso cliente aceita
application/json, text/event-streamcomAbortSignal.timeout(8s); quando o servidor decide responder em stream e o cliente some no meio, o fd do stream morre pendurado).Pergunta para vocês: nesse perfil (
ESTAB 0.0.0.0:0no processo do serve), onde o ciclo de vida do rmcp/axum deveria fechar o fd quando a conexão morre no meio de um stream — e há algo em 2.2.1–2.3.x nesse caminho? Se vocês apontarem o handler, testamos a versão na hora. Nosso dump cru de/proc/net/tcpno próximo pico segue instrumentado como plano B.akitaonrails commentedon Sep 20, 2026
Update — a strong candidate fix just landed.
Your signature (sockets stuck `ESTABLISHED → 0.0.0.0:0`, i.e. the peer is gone from the kernel but the process keeps the fd, all on the streamable-HTTP `POST /mcp` transport, no `MCP-Session-Id`, no LLM/embedding provider configured) matches GHSA-9pj6-vhgr-3mwh — "unauthenticated permanent session-table leak in the rmcp Streamable HTTP server transport leads to remote denial-of-service." That is an upstream
rmcptransport bug, which is exactly the layer your dashboard talks to, and it is consistent with an isolated single-request abandon not reproducing while a long-lived real client that opens a fresh session per tool-call does.We have bumped
rmcp1.7 → 2.2.0 (which carries the fix), merged as #819. It is on the current line and will ship in the next release.Could you retest on a build that includes it (build from the current branch, or the next tagged image once it publishes) and report the fd curve? We are keeping this issue open until you confirm the leak is gone in production. Independently, we are also evaluating a TCP-keepalive + idle-timeout on the listener as defense-in-depth regardless of this specific cause.
Thanks again for the
/proc/net/tcpsignature and the controlled experiment — they are what let us tie this to the transport layer.ranierelm commentedon Sep 22, 2026
I'd like to take the defense-in-depth half of this: TCP keepalive plus a header-read/idle timeout on the HTTP listener, independent of the rmcp fix.
Shape I intend to build, so you can redirect before code lands:
axum::servedoesn't expose hyper's timeouts, so I'd take over the accept loop atserve.rs:1488withhyper_util::server::conn::auto::Builder(already in the tree, 0.1.20), keep the router andConnectInfoexactly as they are, and sethttp1().header_read_timeout(...)plus a per-connection deadline for idle keep-alive connections. Graceful shutdown keeps the current bounded drain.SO_KEEPALIVEwith an explicit idle/interval viasocket2(also already in the lock file, 0.6.3). Needed because both macOS and Linux defaultkeepidleto 2h, so relying on the OS gives nothing useful for a dead peer.ARCHITECTURE.mdanddeploy.md;### Addedin the CHANGELOG. Names open to your preference; I'd go withhttp_idle_timeout_secsandhttp_keepalive_secs,0disabling each.No new dependencies. If any of this collides with something already in flight on 2.4, tell me and I'll adjust.
joseehilton147 commentedon Sep 22, 2026
Reteste em produção na 2.4.0 (imagem
ad047823…, rmcp 2.2.0 dentro) — resultado dividido em dois:O fix do rmcp funcionou (Obs): probe de 30 sessões completas (initialize → tool call → disconnect limpo) deixou o processo em 27→27→26 fds. A assinatura
ESTAB → 0.0.0.0:0do 2.2.0 não reapareceu — o session-table leak está resolvido no nosso tráfego.Mas ~3h depois apareceu a segunda assinatura — a que vocês já previam no primeiro comentário (Obs):
Diferença para a assinatura anterior: desta vez todos os fds têm socket vivo em
/proc/net/tcp(0 órfãos) — não é sessão esquecida, é conexão TCP formalmenteESTABLISHEDcujo peer morreu sem FIN. O fix do rmcp cobre o disconnect notificado; peer-morto-sem-FIN nunca notifica, então a session-table pode estar limpa e o fd vazar mesmo assim.Origem (Obs): SYNs novos chegam de
100.127.95.124— nossa máquina Windows via Tailscale, passando pelodocker-proxy(publish100.103.73.60:49374:49374). São processos efêmeros (hooks de lifecycle que os clients MCP instalam: SessionStart/PreToolUse/SessionEnd) — conectam, morrem, e o FIN se perde no caminho (sleep da máquina, flap do Tailscale, kill abrupto). O docker-proxy segura o backend ESTABLISHED porque o frontend ainda não foi declarado morto.Prova de zumbi (Obs):
ss -Kdentro do netns comsport = :49374derrubou 416 ESTABLISHED → 1 e fds 437→22, sem restart, e o serviço seguiuhealthy— conexões legítimas reconectaram transparentes.Mitigação rodando aqui: cron a cada 15min checa o fd count; acima de 512 faz
ss -Kno netns do container e loga. Zero disrupção em operação normal (~30 fds) e compra tempo infinito contra o acúmulo.Amarração: é exatamente o caso do defense-in-depth que o @ranierelm descreveu no comentário acima — keepalive + idle-timeout no listener fecharia esses fds na fonte. Se ajudar no before/after, esse tráfego real é trivial de instrumentar aqui:
fd countpor minuto durante um storm de hooks sai de graça. Config atual:AI_MEMORY_BIND,AI_MEMORY_ALLOWED_HOSTS,AI_MEMORY_AUTH_TOKEN, provideropenai_compatvia proxy interno — o acúmulo independe do provider, é camada de transporte.fix(serve): enable TCP keepalive on accepted connections (#792)
akitaonrails commentedon Sep 22, 2026
The remaining half (half-open sockets never reaped) is fixed on
mainfor 2.4.1:ai-memory servenow enables TCP keepalive on every accepted connection via axum'sListenerExt::tap_io+socket2, so a dead peer (sleep / VPN flap / kill) is probed and its fd reclaimed instead of sittingESTABLISHEDforever. Newtcp_keepalive_secsconfig (default 60s;AI_MEMORY_TCP_KEEPALIVE_SECS; 0 disables), with socket-level regression tests. The rmcp session-table half was already fixed in 2.4.0 (#794). Slowloris/idle-request-timeout hardening is noted as a separate follow-up. Thanks for the production capture and the precisess//proc/net/tcpdiagnosis.