docs: rewrite architecture/README, update deployment/development

- architecture.md: complete rewrite (French) with dual-database diagram,
  5-phase data flow, full table ownership, triple-voice ML pipeline,
  7 dictionaries, 13 SQL files, updated tech stack
- README.md: complete rewrite (English) with updated pipeline diagram,
  services table, scripts section, integration tests, full doc index,
  Go 1.24.6 workspace
- deployment.md: update to 13 SQL files, remove Anubis UA/Country refs,
  add scripts section, add ensemble env vars (AE_WEIGHT, XGB_WEIGHT),
  update verification queries and network diagram
- development.md: translate to French, add bot-detector 11-module structure,
  add Python ML deps, add scripts/integration test sections,
  fix bot-detector run command, add make targets

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

docs/development.md

@@ -1,65 +1,77 @@
-# Development Guide
+# Guide de développement
 
-This guide covers building, testing, packaging, and extending the ja4-platform monorepo. All build and test operations run inside Docker — no native Go, Python, or C toolchains are required on the host.
+Ce guide couvre la compilation, les tests, le packaging et l'extension du monorepo ja4-platform. Toutes les opérations de build et de test s'exécutent dans Docker — aucune toolchain Go, Python ou C n'est requise sur la machine hôte.
 
-## Prerequisites
+## Prérequis
 
-| Requirement | Minimum Version | Notes |
-|-------------|----------------|-------|
-| Docker | 20.10+ | BuildKit enabled (`DOCKER_BUILDKIT=1`) |
-| Docker Compose | 2.x | For bot-detector and dashboard |
+| Outil | Version minimale | Notes |
+|-------|-----------------|-------|
+| Docker | 20.10+ | BuildKit activé (`DOCKER_BUILDKIT=1`) |
+| Docker Compose | 2.x | Pour bot-detector et dashboard |
 | make | 3.81+ | GNU Make |
-| git | 2.x | For version tagging |
+| git | 2.x | Pour le versioning |
 
-No Go, Python, or C compilers are needed on the host machine.
+Aucun compilateur Go, Python ou C n'est nécessaire sur la machine hôte.
 
-## Building All Services
+## Compilation de tous les services
 
 ```bash
 make build-all
 ```
 
-This builds Docker images for:
+Cela construit les images Docker pour :
 - `ja4-platform/sentinel:latest`
 - `ja4-platform/correlator:latest`
 - `ja4-platform/bot-detector:latest`
 - `ja4-platform/dashboard:latest`
 
-mod-reqin-log is an Apache module and is only built as part of the RPM packaging process.
+mod-reqin-log est un module Apache et n'est construit que dans le cadre du processus RPM.
 
-### Building Individual Services
+### Compilation individuelle
 
 ```bash
-make build-sentinel      # Go binary in Docker
-make build-correlator    # Go binary in Docker
-make build-bot-detector  # Python image
-make build-dashboard     # FastAPI + React image
+make build-sentinel      # Binaire Go dans Docker
+make build-correlator    # Binaire Go dans Docker
+make build-bot-detector  # Image Python
+make build-dashboard     # Image FastAPI + Jinja2
 ```
 
-## Running Tests
+## Exécution des tests
 
 ```bash
 make test-all
 ```
 
-### Per-Service Testing
+### Tests par service
 
-| Service | Command | Details |
-|---------|---------|---------|
-| sentinel | `make test-sentinel` | Go tests with `-race` flag, requires `NET_RAW`/`NET_ADMIN` caps |
-| correlator | `make test-correlator` | Go tests with 80% coverage gate enforced |
-| mod-reqin-log | `make test-mod-reqin-log` | C unit tests (JSON serialization, config parsing, header handling) |
-| bot-detector | `make test-bot-detector` | Python pytest suite |
-| dashboard | `make test-dashboard` | Python pytest for FastAPI routes |
-| ja4_common (Python) | `make test-ja4common-python` | Shared Python library tests |
+| Service | Commande | Détails |
+|---------|----------|---------|
+| sentinel | `make test-sentinel` | Tests Go avec `-race`, nécessite `NET_RAW`/`NET_ADMIN` |
+| correlator | `make test-correlator` | Tests Go avec seuil de couverture 80% |
+| mod-reqin-log | `make test-mod-reqin-log` | Tests unitaires C (sérialisation JSON, config, headers) |
+| bot-detector | `make test-bot-detector` | Suite pytest Python |
+| dashboard | `make test-dashboard` | pytest pour les routes FastAPI |
+| ja4_common (Python) | `make test-ja4common-python` | Tests de la librairie Python partagée |
 
-## Building RPM Packages
+## Tests d'intégration
+
+Les tests d'intégration full-stack s'exécutent contre Docker Compose avec une instance ClickHouse réelle :
+
+```bash
+make test-integration          # 8 phases : build → start → schema → traffic → pipeline → dashboard → bot-detector → sentinel
+make test-integration-keep     # idem mais laisse la stack en fonctionnement
+make test-integration-down     # démontage de la stack d'intégration
+```
+
+La suite de tests se trouve dans `tests/integration/` et réinitialise la base de données entre chaque exécution.
+
+## Construction des paquets RPM
 
 ```bash
 make rpm-all
 ```
 
-Builds RPMs for sentinel, correlator, and mod-reqin-log targeting Rocky Linux 8/9/10:
+Construit les RPMs pour sentinel, correlator et mod-reqin-log ciblant Rocky Linux 8/9/10 :
 
 ```bash
 make rpm-sentinel        # → services/sentinel/dist/rpm/
@@ -67,26 +79,26 @@ make rpm-correlator      # → services/correlator/dist/rpm/
 make rpm-mod-reqin-log   # → services/mod-reqin-log/dist/rpm/
 ```
 
-Each RPM build uses a multi-stage Docker pipeline:
-1. Builder stage compiles the binary (Go) or shared object (C)
-2. RPM builder stage runs `rpmbuild` for each target distro (el8, el9, el10)
-3. Output stage copies RPMs to the host via `--output type=local`
+Chaque build RPM utilise un pipeline Docker multi-étapes :
+1. L'étape builder compile le binaire (Go) ou l'objet partagé (C)
+2. L'étape rpmbuild exécute `rpmbuild` pour chaque distro cible (el8, el9, el10)
+3. L'étape de sortie copie les RPMs sur l'hôte via `--output type=local`
 
-### Distribution Packages
+### Paquets de distribution
 
 ```bash
 make dist    # Alias for rpm-all
 # RPMs in services/<service>/dist/rpm/el{8,9,10}/
 ```
 
-## Local Development Workflow
+## Développement local
 
-### Go Services (sentinel, correlator)
+### Services Go (sentinel, correlator)
 
-The `go.work` workspace links Go modules:
+Le fichier `go.work` relie les modules Go :
 
 ```
-go 1.21
+go 1.24.6
 
 use (
     ./services/sentinel
@@ -95,62 +107,119 @@ use (
 )
 ```
 
-If you have Go 1.21+ installed locally, you can develop without Docker:
+Si Go 1.24+ est installé localement, le développement sans Docker est possible :
 
 ```bash
-# Run sentinel tests locally
+# Tests sentinel en local
 cd services/sentinel && go test ./... -race -v
 
-# Run correlator tests locally
+# Tests correlator en local
 cd services/correlator && go test ./... -race -cover -v
 
-# Build sentinel binary locally (requires libpcap-dev)
+# Compilation du binaire sentinel (nécessite libpcap-dev)
 cd services/sentinel && go build -o ja4sentinel ./cmd/ja4sentinel/
 ```
 
-### Python Services (bot-detector, dashboard)
+### Services Python (bot-detector, dashboard)
 
 ```bash
-# Install shared library in development mode
+# Installer la librairie partagée en mode développement
 cd shared/python/ja4_common && pip install -e .
 
-# Run bot-detector locally
+# Lancer le bot-detector localement
 cd services/bot-detector && pip install -r bot_detector/requirements.txt
-python -m bot_detector.bot_detector
+python -m bot_detector
 
-# Run dashboard locally
+# Lancer le dashboard localement
 cd services/dashboard && pip install -r backend/requirements.txt
 uvicorn backend.main:app --reload --host 0.0.0.0 --port 8000
 ```
 
-### C Module (mod-reqin-log)
+#### Dépendances Python pour le développement local du bot-detector
 
-Requires `apxs` (Apache extension tool) and development headers:
+Les dépendances principales sont listées dans `services/bot-detector/bot_detector/requirements.txt`. Les librairies ML clés sont :
+
+| Librairie | Usage |
+|-----------|-------|
+| `isotree` | Extended Isolation Forest (scoreur principal non supervisé) |
+| `torch` | Autoencoder (PyTorch, architecture n→64→32→16→32→64→n) |
+| `xgboost` | Modèle supervisé (entraîné sur les labels SOC) |
+| `hdbscan` | Clustering de campagnes d'attaque |
+| `shap` | Explicabilité des scores d'anomalie |
+| `scikit-learn` | Fallback pour Isolation Forest si isotree indisponible |
+| `clickhouse-connect` | Client ClickHouse (via ja4_common) |
+
+#### Structure modulaire du bot-detector (11 modules)
+
+```
+services/bot-detector/bot_detector/
+├── __init__.py          # Package init
+├── __main__.py          # Point d'entrée (python -m bot_detector)
+├── config.py            # Configuration (os.getenv, PAS pydantic-settings)
+├── log.py               # Configuration du logging
+├── infra.py             # Connexion ClickHouse, health check
+├── preprocessing.py     # Feature engineering, filtrage, normalisation
+├── models.py            # EIF, Autoencoder, XGBoost (entraînement + scoring)
+├── scoring.py           # Ensemble triple voix, seuils adaptatifs
+├── browser.py           # Détection de navigateur 5 axes multifactoriels
+├── pipeline.py          # Orchestration du cycle de détection
+├── cycle.py             # Boucle principale (cycle de 5 minutes)
+└── tests/               # Tests pytest (self-contained, pas d'import lourd)
+```
+
+### Module C (mod-reqin-log)
+
+Nécessite `apxs` (outil d'extension Apache) et les headers de développement :
 
 ```bash
 cd services/mod-reqin-log
-make build    # Compiles mod_reqin_log.so
-make test     # Runs unit tests
-make rpm      # Builds RPM packages
+make build    # Compile mod_reqin_log.so
+make test     # Exécute les tests unitaires
+make rpm      # Construit les paquets RPM
 ```
 
-## Adding a New Service
+## Scripts utilitaires
 
-### Go Service
+Les scripts dans `scripts/` facilitent l'initialisation et la gestion de l'environnement de développement :
 
-1. Create the service directory:
+| Script | Commande Make | Description |
+|--------|--------------|-------------|
+| `init-stack.sh` | `make init-stack` | Initialisation complète de la stack ClickHouse (schéma + données CSV) |
+| `import-prod-data.sh` | `make import-prod-data` | Import de données de prod avec décalage temporel |
+| `reload-prod-logs.sh` | `make reload-prod-logs` | Export prod → réimport dev avec décalage |
+| `update-csv-data.sh` | — | Téléchargement et génération de toutes les données CSV de référence |
+
+```bash
+# Initialisation complète (schéma + données CSV + import prod)
+make init-and-import
+
+# Initialisation seule (schéma + CSV)
+make init-stack
+
+# Import des données prod pré-exportées
+make import-prod-data
+
+# Rechargement depuis la prod
+make reload-prod-logs
+```
+
+## Ajout d'un nouveau service
+
+### Service Go
+
+1. Créer le répertoire du service :
    ```bash
    mkdir -p services/my-service/cmd/my-service
    mkdir -p services/my-service/internal
    ```
 
-2. Initialize the Go module:
+2. Initialiser le module Go :
    ```bash
    cd services/my-service
    go mod init github.com/antitbone/ja4/my-service
    ```
 
-3. Add to `go.work`:
+3. Ajouter au `go.work` :
    ```
    use (
        ./services/sentinel
@@ -160,7 +229,7 @@ make rpm      # Builds RPM packages
    )
    ```
 
-4. Import the shared library:
+4. Importer la librairie partagée :
    ```go
    import (
        "github.com/antitbone/ja4/ja4common/logger"
@@ -169,7 +238,7 @@ make rpm      # Builds RPM packages
    )
    ```
 
-5. Add Makefile targets:
+5. Ajouter les cibles Makefile :
    ```makefile
    build-my-service:
        docker build -f services/my-service/Dockerfile -t ja4-platform/my-service:latest .
@@ -179,21 +248,21 @@ make rpm      # Builds RPM packages
        docker run --rm ja4-platform/my-service-tests:latest
    ```
 
-6. Update `build-all` and `test-all` dependencies.
+6. Mettre à jour les dépendances `build-all` et `test-all`.
 
-### Python Service
+### Service Python
 
-1. Create the service directory with a `requirements.txt` or `pyproject.toml`.
-2. Add `ja4-common` as a dependency (installed from `shared/python/ja4_common`).
-3. Use `from ja4_common.clickhouse import get_client` for ClickHouse access.
-4. Add Makefile targets following the bot-detector/dashboard pattern.
+1. Créer le répertoire du service avec un `requirements.txt` ou `pyproject.toml`.
+2. Ajouter `ja4-common` comme dépendance (installée depuis `shared/python/ja4_common`).
+3. Utiliser `from ja4_common.clickhouse import get_client` pour l'accès ClickHouse.
+4. Ajouter les cibles Makefile en suivant le modèle bot-detector/dashboard.
 
-## go.work Workspace
+## Workspace go.work
 
-The `go.work` file at the repository root links all Go modules, allowing cross-module development without publishing:
+Le fichier `go.work` à la racine du dépôt relie tous les modules Go, permettant le développement cross-module sans publication :
 
 ```
-go 1.21
+go 1.24.6
 
 use (
     ./services/sentinel
@@ -202,30 +271,34 @@ use (
 )
 ```
 
-When adding a new Go module:
-1. `go mod init` in the service directory
-2. Add the path to `go.work`
-3. Reference shared packages via their module path: `github.com/antitbone/ja4/ja4common/...`
-4. Run `go work sync` to update the workspace
+Lors de l'ajout d'un nouveau module Go :
+1. `go mod init` dans le répertoire du service
+2. Ajouter le chemin dans `go.work`
+3. Référencer les packages partagés via leur chemin de module : `github.com/antitbone/ja4/ja4common/...`
+4. Exécuter `go work sync` pour mettre à jour le workspace
 
-## ja4_common Python Package
+Les deux services Go ont une directive `replace` dans leur `go.mod` pointant vers `../../shared/go/ja4common`. Le workspace prend priorité en développement local ; la directive `replace` est nécessaire pour les builds Docker où `go.work` n'est pas disponible.
 
-The shared Python package (`shared/python/ja4_common`) provides:
+## Package Python ja4_common
 
-- `ClickHouseSettings` — pydantic-settings model reading from `.env`
-- `ClickHouseClient` — singleton client with auto-reconnect
-- `get_client()` — module-level singleton accessor
+Le package Python partagé (`shared/python/ja4_common`) fournit :
 
-### Extending ja4_common
+- `ClickHouseSettings` — modèle pydantic-settings lisant depuis `.env`
+- `ClickHouseClient` — client singleton avec reconnexion automatique
+- `get_client()` — accesseur singleton au niveau du module
 
-1. Add new modules under `shared/python/ja4_common/ja4_common/`
-2. Export them in `__init__.py`
-3. Add dependencies to `pyproject.toml`
-4. Run tests: `make test-ja4common-python`
+> **Note :** le dashboard n'utilise PAS ja4_common — il possède son propre client léger `clickhouse-connect` dans `backend/database.py`.
 
-### Using in a New Service
+### Extension de ja4_common
 
-Add to `requirements.txt`:
+1. Ajouter de nouveaux modules sous `shared/python/ja4_common/ja4_common/`
+2. Les exporter dans `__init__.py`
+3. Ajouter les dépendances dans `pyproject.toml`
+4. Lancer les tests : `make test-ja4common-python`
+
+### Utilisation dans un nouveau service
+
+Ajouter dans `requirements.txt` :
 ```
 ja4-common @ file:///app/shared/python/ja4_common
 ```
@@ -236,11 +309,11 @@ COPY shared/python/ja4_common /app/shared/python/ja4_common
 RUN pip install /app/shared/python/ja4_common
 ```
 
-## Environment Variables
+## Variables d'environnement
 
-Each service reads configuration from environment variables and/or YAML config files. See individual service documentation for the full reference:
+Chaque service lit sa configuration depuis des variables d'environnement et/ou des fichiers YAML. Consultez la documentation de chaque service pour la référence complète :
 
-- [Sentinel configuration](services/sentinel.md#configuration-reference)
-- [Correlator configuration](services/correlator.md#configuration-reference)
-- [Bot Detector configuration](services/bot-detector.md#environment-variables)
-- [Dashboard configuration](services/dashboard.md#configuration)
+- [Configuration du Sentinel](services/sentinel.md#configuration-reference)
+- [Configuration du Correlator](services/correlator.md#configuration-reference)
+- [Configuration du Bot Detector](services/bot-detector.md#environment-variables)
+- [Configuration du Dashboard](services/dashboard.md#configuration)