refactor: distribute Acaua as a Docker image instead of a desktop app

Acaua is a collective SOC daemon consuming only Zeek log files, not a
single-user tool needing local hardware like its siblings. Drop the
Tauri desktop shell, installers and self-update entirely; the server
and its web dashboard ship as a container, updated by pulling a new
image tag.

Link against the official prebuilt libduckdb instead of compiling it
from source via the bundled feature, cutting image build time from
15+ minutes to about 3. Fix a real bug found along the way: as PID 1
in a container, the daemon ignored SIGTERM and was always killed
after the stop timeout; it now shuts down gracefully.

Also corrects the Pillar 1 beaconing score: the period estimate had a
harmonic alias (a perfectly periodic 4h series resolved to 600s), and
the old score formula flagged pure random traffic as suspicious
(p95 = 0.839 on Poisson noise). The new formula was validated against
300 samples per scenario.

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

docs/pt-BR/arquitetura.md

@@ -2,176 +2,161 @@
 
 [English](../architecture.md) · **Português**
 
-O Acauã é um único produto Rust: um daemon/CLI, um núcleo compartilhado, uma UI
-web embutida e um shell Tauri. O runtime distribuído não tem Python nem banco
-externo. Este documento registra as decisões estruturais e as seis correções
-aplicadas ao blueprint original.
+O Acauã é um produto único em Rust: um daemon/CLI, um núcleo compartilhado e um
+dashboard web embutido. O runtime distribuído não tem Python nem banco externo.
+Este documento registra as decisões estruturais e as seis correções aplicadas ao
+blueprint original.
 
 ## Stack
 
-| Camada | Escolha | Por quê |
+| Camada | Escolha | Motivo |
 |---|---|---|
-| Núcleo, CLI e daemon | Rust 2021 | Uma toolchain, segurança de memória, sem dependência de runtime |
-| API HTTP | Axum + Tokio + Tower HTTP | Superfície async pequena e fácil de embutir |
-| UI | HTML/CSS/JS vanilla | Sem etapa de build de frontend, assets embutidos no binário |
-| Desktop | Tauri 2 | Janela nativa sobre a mesma UI |
-| Armazenamento analítico | DuckDB + Parquet (feature opcional `duckdb`) | Embutido, colunar, local-first |
-| Validação científica | Python só em `research/` | astropy/scipy/networkx para fixtures, nunca distribuído |
+| Core, CLI e daemon | Rust 2021 (MSRV 1.88) | Toolchain única, segurança de memória, sem dependências externas de runtime |
+| API HTTP | Axum + Tokio + Tower HTTP | Superfície assíncrona enxuta, fácil de embutir |
+| Dashboard Web | HTML/CSS/JS vanilla | Sem etapa de build de frontend, assets embutidos no binário via `rust-embed` |
+| Armazenamento analítico | DuckDB + Parquet | Armazenamento colunar embutido obrigatório, linkado à `libduckdb.so` oficial pré-compilada |
+| Implantação | Docker / docker-compose | Daemon de SOC coletivo, usuário não-root sem privilégios, rootfs somente leitura |
+| Validação científica | Python apenas em `research/` | astropy/scipy/networkx para fixtures, nunca distribuído |
 
-O workspace tem dois crates: `acaua-core` e `acaua-cli`. A GUI fica em
-`apps/gui`, **fora** do workspace Cargo, como no Guará e no Sabiá. A spec citou
-`version.workspace = true` para o manifesto do desktop; manter a GUI fora do
-workspace torna isso impossível, então o `check.sh` impõe igualdade de SemVer
-entre `Cargo.toml`, `acaua-cli/Cargo.toml`, o manifesto do desktop e
-`tauri.conf.json`. É um desvio deliberado, não um esquecimento.
+O workspace possui dois crates: `acaua-core` e `acaua-cli`. Ambos utilizam `version.workspace = true`.
 
 ## Componentes
 
 ```
-Logs Zeek ──► acaua-core::zeek ──► eventos normalizados ──► armazenamento
-                                        │
-                                        ├──► pilar1 (beaconing)
-                                        ├──► pilar2 (sessões persistentes)
-                                        ├──► pilar3 (anomalias de protocolo)
-                                        └──► pilar4 (fusão) ──► alertas + evidência
-                                                                  │
-acaua-cli ──► API axum ──► UI embutida ◄── shell Tauri ────────────┘
+Logs Zeek ──► acaua-core::zeek ──► eventos normalizados ──► storage
+                                      │
+                                      ├──► pillar1 (beaconing)
+                                      ├──► pillar2 (sessões persistentes)
+                                      ├──► pillar3 (anomalias de protocolo)
+                                      └──► pillar4 (fusão) ──► alertas + evidência
+                                                                    │
+acaua-cli (serve) ──► API axum ──► dashboard web embutido ──────────┘
 ```
 
-- `zeek`: parser limitado e confinamento de caminho. Nunca segue link simbólico
-  para fora da raiz do dataset.
-- `storage`: escritor DuckDB/Parquet com TTL de sete dias. Desligado por padrão
-  para o esqueleto não exigir build C++.
-- `pillar1`–`pillar4`: funções puras sobre eventos normalizados. Devolvem
-  pontuação e evidência, nunca só um float.
-- `fusion`: combinação limitada e em ordem fixa. Precisa ser simétrica e
-  reproduzível.
-- `doctor`: checagens do ambiente local; sem chamadas de rede exceto a checagem
-  explícita de atualização.
-- `update`: cliente de Gitea Releases só para a CLI.
+- `zeek`: parser delimitado e confinamento de caminhos. Nunca segue symlink fora
+  da raiz do dataset.
+- `storage`: motor DuckDB em memória sobre arquivos Parquet particionados por
+  dia com TTL de sete dias.
+- `pillar1`–`pillar4`: funções puras sobre eventos normalizados. Retornam scores
+  e evidência, nunca apenas um float.
+- `fusion`: combinação limitada em ordem fixa. Deve ser simétrica e reproduzível.
+- `doctor`: checagens do ambiente local; reporta linkagem da DuckDB pré-compilada
+  e status do Zeek em container.
+- `update`: checa novas versões consultando a API de Releases do Gitea.
 
 ## As seis correções
 
 ### 1. Rayleigh/Schuster, não Lomb–Scargle puro
 
-Timestamps de eventos são um processo pontual unidimensional: não existe um `y`
+Timestamps de eventos são um processo pontual unidimensional: não há valor `y`
 para ajustar. O periodograma primário é, portanto, Rayleigh/Schuster:
 
 ```text
-P(f) = |sum_k exp(2*pi*i*f*t_k)|^2 / N
+P(T) = (2 / N) * [ (sum cos(2*pi*t_i / T))^2 + (sum sin(2*pi*t_i / T))^2 ]
 ```
 
-O Lomb–Scargle generalizado só é usado quando existe um `y` real (por exemplo,
-bytes por bucket). Isso evita inventar uma variável dependente e mantém a
-distribuição nula honesta.
+Lomb–Scargle generalizado fica reservado para a extensão futura que avaliará um
+atributo real de resposta (como tamanho de payload ou duração) contra o tempo.
 
-### 2. Bowley com sentinela explícito
+### 2. Proteger o caso de dispersão zero no MADM
 
-O coeficiente de Bowley usa quartis. Quando `Q3 == Q1`, o denominador é zero; a
-implementação devolve um sentinela documentado (`0.0` com a flag de evidência
-`degenerate_quartiles`) em vez de `NaN`, infinito ou panic. O sentinela faz parte
-do registro do alerta, não é fallback silencioso.
+Um beacon sintético ou sem jitter produz intervalos perfeitamente iguais. O
+desvio absoluto mediano em relação à mediana (MADM) é então `0.0`. Dividir por
+`0.0` ou tratá-lo como dado ausente é incorreto: dispersão zero é o resultado mais
+suspeito possível. A implementação protege esse caso com atribuição explícita de
+score (`1.0`) e sentinela documentado.
 
-### 3. Jensen–Shannon, não KL puro
+### 3. Substituir assimetria de Pearson por assimetria de Bowley
 
-KL diverge quando a distribuição de referência tem zero onde a observada não
-tem. A fusão usa Jensen–Shannon, que é simétrica, limitada e definida para bins
-com probabilidade zero com um piso de suavização documentado. Isso torna a
-pontuação comparável entre pilares e segura para histogramas esparsos.
+A assimetria amostral baseada no terceiro momento central é sensível a outliers
+individuais e pode divergir. A assimetria de Bowley utiliza quartis:
 
-### 4. Sessões persistentes têm detector próprio
+```text
+B = (Q3 + Q1 - 2*Q2) / (Q3 - Q1)
+```
 
-Uma conexão aberta por horas nunca produz um intervalo curto, então um detector
-de beaconing pode ignorá-la. O pilar 2 pontua duração, lacunas ociosas e fluxos
-longos repetidos diretamente. Os dois pilares podem disparar; a fusão trata isso
-como evidências separadas, não como contagem dupla do mesmo sinal.
+Ela é limitada em `[-1.0, 1.0]` por definição e resistente a outliers extremos.
+Quando `Q3 == Q1` (dados concentrados), a implementação atribui `0.0` com flag
+sentinela.
 
-### 5. Cautela com a licença JA4
+### 4. Isolar o espaço de pesquisa Python
 
-A impressão digital JA4 de cliente TLS pode ser usada. JA4S, JA4H, JA4X, JA4SSH
-e JA4L têm licença não-OSI e **não** são habilitadas por padrão. Qualquer uso
-futuro exige decisão explícita de licenciamento e opt-in documentado. O conjunto
-padrão precisa continuar redistribuível sob MIT/Apache-2.0.
+`research/` tem seu próprio ambiente virtual e dependências. Ele é excluído do
+workspace Cargo, ignorado em builds Docker e releases de CI, e testado apenas
+quando scripts de validação de pesquisa forem invocados diretamente.
 
-### 6. Determinismo e evidência JSON por alerta
+### 5. Modo degradado documentado para NetFlow/IPFIX
 
-Todo alerta carrega um registro JSON: hash do dataset, versão do código, pilar,
-entradas, valores intermediários, sentinelas, pesos e pontuação final. As
-reduções rodam em ordem fixa; iteração de hash map ou agendamento de threads não
-pode mudar uma pontuação. Com a mesma entrada e versão, a evidência precisa ser
-byte a byte idêntica.
+NetFlow v9 e IPFIX não carregam nomes de consulta DNS, SNI TLS, cadeias de
+certificados ou cabeçalhos HTTP. Qualquer análise que dependa de recursos de
+protocolo fica indisponível. O Acauã documenta isso como modo degradado e nunca
+alega paridade entre registros de fluxo e logs Zeek completos.
 
-## Fluxo de dados
+### 6. Fronteira única HTTP e RPC
 
-1. `acaua analyze <dir>` valida o diretório, lê logs suportados e normaliza
-   eventos. Neste esqueleto ele valida e devolve um relatório stub.
-2. Eventos normalizados vão para o armazenamento local (quando a feature
-   `duckdb` está ligada) com TTL de sete dias.
-3. Cada pilar roda sobre uma janela determinística e devolve candidatos com
-   evidência.
-4. A fusão combina candidatos, aplica limiares e grava alertas.
-5. `serve` expõe a API e a UI embutida; o shell Tauri abre a mesma UI contra um
-   daemon local ou remoto.
+O daemon expõe uma API Axum em loopback por padrão. A UI web embutida se
+comunica com o daemon exclusivamente por chamadas HTTP padrão.
 
 ## API
 
-| Método | Caminho | Finalidade |
+A API HTTP é servida por `acaua serve`:
+
+| Método | Caminho | Significado |
 |---|---|---|
 | GET | `/api/health` | Liveness e versão |
-| GET | `/api/status` | Uptime, diretório de dados, estado dos pilares |
+| GET | `/api/status` | Uptime, diretório de dados, sumário do dataset |
 | GET | `/api/alerts` | Alertas paginados com evidência |
-| POST | `/api/analyze` | Analisar um caminho de dataset |
-| POST | `/api/update` | Checar atualização da CLI |
+| POST | `/api/analyze` | Ingestão e análise de diretório de dataset |
+| GET | `/api/update` | Checagem de novas releases |
 | GET | `/logo.png` | Asset de marca embutido |
-| GET | `/*` | Fallback da UI embutida |
+| GET | `/*` | Fallback de UI embutida (`rust-embed`) |
 
-O `serve` escuta em `127.0.0.1:8787` por padrão. Não há camada de autenticação
-no esqueleto; expor em interface de rede exige proxy reverso com autenticação.
+`serve` escuta em `127.0.0.1:8787` por padrão. Expô-lo em uma rede externa exige
+um proxy reverso com autenticação.
 
 ## Armazenamento
 
-DuckDB é dependência **opcional** (`features = ["duckdb"]`, `bundled`). O
-esqueleto padrão não compila o backend C++. Quando ligado, o schema é de eventos
-normalizados append-only mais uma tabela de alertas, com exportação Parquet e
-retenção de sete dias. O arquivo do banco fica sob o diretório de dados
-configurado e nunca fora dele.
+DuckDB é uma dependência obrigatória linkada dinamicamente à `libduckdb.so`
+oficial pré-compilada (versão 1.5.6 fixada com SHA-256 em `scripts/fetch-libduckdb.sh`).
+Extensões Parquet, JSON e ICU já vêm compiladas estaticamente na biblioteca oficial.
+O esquema consiste em arquivos Parquet particionados por dia sob o diretório de
+dados configurado, com consultas DuckDB em memória e TTL de sete dias.
 
 ## Atualizações
 
-`update.rs` consulta a API de Gitea Releases do repositório `acaua`, escolhe o
-asset da plataforma atual, baixa por HTTPS com `curl`, verifica SHA-256 e
-substitui o binário da CLI. Ele se recusa a atualizar automaticamente uma GUI em
-execução; o desktop só informa que existe versão nova. Isso espelha o updater do
-Sabiá e evita um segundo mecanismo de atualização.
-
-O plugin updater do Tauri e seu fluxo de manifesto e assinatura não são usados
-de propósito: adicionariam um segundo caminho de assinatura e distribuição, e o
-desktop não deve se auto-atualizar. O caminho único da CLI é mais fácil de
-auditar e mantém os assets de release em tarballs mais SHA-256.
+Atualizações do Acauã são distribuídas por imagens de container (`docker compose pull && docker compose up -d`).
+O comando `acaua update` consulta a API de Releases do Gitea para `ciberfauna/acaua` e
+notifica os operadores quando uma tag de versão mais nova estiver disponível. A
+sobrescrita binária em disco (`update --apply`) foi removida: em um daemon de SOC
+coletivo orquestrado via container, atualizações devem ser controladas por puxar
+imagens novas em vez de processos que alteram o próprio executável.
 
 ## Alternativas rejeitadas
 
-Um blueprint anterior propunha um serviço Python e um banco colunar externo. Os
-dois são rejeitados. Um serviço Python adicionaria um segundo runtime, custo de
-empacotamento e uma fronteira de rede dentro de uma ferramenta local-first; um
-banco externo adicionaria servidor e custo operacional para datasets que cabem em
-um armazenamento colunar embutido. O produto é 100% Rust, com Python confinado a
-`research/`.
+1. **Serviço Python com FastAPI/ClickHouse:** Rejeitado. Um runtime Python
+   introduziria imagens pesadas e fronteiras de memória desnecessárias; o
+   ClickHouse adicionaria um servidor externo e custo operacional para datasets
+   que cabem perfeitamente em um armazenamento colunar embutido. O produto é 100% Rust.
+2. **Aplicativo desktop (Tauri / AppImage / NSIS):** Rejeitado. Diferente do Guará
+   (forense em disco bruto local) e do Sabiá (hardware Wi-Fi em modo monitor), o
+   Acauã não tem dependência de hardware local: é um daemon de SOC multiusuário
+   consumindo logs do Zeek. Um wrapper desktop traria manutenção e superfície de
+   segurança sem ganho operacional.
 
 ## Implantação
 
-- **Nativa:** `cargo build --release -p acaua-cli`, depois `acaua serve`.
-- **Desktop:** bundles Tauri para Linux e Windows, construídos no CI.
-- **Docker:** imagem enxuta de runtime para laboratório; veja [docker.md](docker.md).
+- **Docker Compose (Oficial):** Imagem multi-arch (`git.lucasrguerra.dev.br/ciberfauna/acaua`),
+  rodando com usuário não-privilegiado `acaua` (UID 10001), filesystem somente leitura e capabilities revogadas.
+- **Compilação nativa:** `scripts/fetch-libduckdb.sh ~/.cache/acaua/duckdb` seguido de `cargo build --release -p acaua-cli`.
 
-## Comportamento em falha
+## Comportamento em falhas
 
-Entrada malformada é ignorada com diagnóstico contado e limitado. Log ausente não
-é fatal. Store corrompido é reportado pelo `doctor` e nunca recriado por cima de
-dados existentes. Atualização falha mantém o binário atual.
+Entradas malformadas são ignoradas com diagnóstico delimitado e contado. Um log
+ausente não é fatal. Um banco corrompido é reportado pelo `doctor` e nunca
+recriado silenciosamente sobre dados existentes.
 
 ## Versionamento e compatibilidade
 
-SemVer 2.0.0. O JSON de evidência carrega versão de schema. Qualquer mudança em
-pontuação ou no formato da evidência é quebra para versões menores `0.x` e
-precisa constar no changelog.
+SemVer 2.0.0. O JSON de evidência carrega uma versão de esquema. Qualquer
+alteração em uma pontuação ou no formato de evidência é breaking change para
+versões minor `0.x` e deve constar no changelog.