Merge branch 'dev' into feat/deploy

feat: saisie des logins pour accéder au vault
fix: déploiement pour le frontend
2026-09-23 09:50:54 +02:00 · 2026-09-22 15:26:30 +02:00 · 2026-09-21 16:07:43 +02:00 · 2026-09-21 14:06:42 +02:00 · 2026-09-21 14:05:55 +02:00 · 2026-09-21 11:49:10 +02:00
130 changed files with 1632 additions and 6442 deletions
@@ -69,27 +69,8 @@ PUBLIC_ORIGIN=
 # l'extérieur. Décaler aussi POSTGRES_PORT, MAILPIT_UI_PORT et AIRFLOW_PORT (5434, 8026, 8082).
 PROXY_HTTP_PORT=
 PROXY_HTTPS_PORT=
-# Écouteur PROXY protocol du proxy, que seul le frontal de la VM joint (infra/front, ADR 0018).
-# Vide : port aléatoire sur 127.0.0.1. VM : 127.0.0.1:10444 en prod, 8444 en recette, 9444 en dev.
-PROXY_FRONT_PORT=
 # Réglages mémoire de la stack déployée. Sans eux, timescaledb-tune réserve 25 % de la RAM de la
 # machine à chaque base au premier démarrage. L'api-server Airflow 3 n'a rien à régler ici : son
 # nombre de workers vaut 1 par défaut, contre 4 pour le webserver d'Airflow 2.
 TS_TUNE_MEMORY=2GB
 TS_TUNE_NUM_CPUS=2
-
-# Supervision (ADR 0016) : `monitoring` la démarre avec `make stack-up`, réglage de la prod.
-# Vide ailleurs, où `make monitoring-up` la lance à la demande.
-COMPOSE_PROFILES=
-# Jeton présenté par Prometheus sur `/metrics`, exigé par l'API dès qu'il est posé. Requis dès
-# que la supervision tourne ; même générateur que APP_SECRET_KEY.
-APP_METRICS_TOKEN=change_me
-# Compte `admin` de Grafana. Sans lui, le conteneur refuse de démarrer.
-GRAFANA_ADMIN_PASSWORD=change_me
-# Rôle PostgreSQL `supervision`, en lecture seule, de Grafana et de postgres-exporter
-# (db/roles/supervision.sql, posé par `make db-ensure-supervision`).
-SUPERVISION_DB_PASSWORD=change_me
-# Interfaces publiées sur 127.0.0.1 seulement, par tunnel SSH. 3000 est pris par le frontend.
-GRAFANA_PORT=3001
-PROMETHEUS_PORT=9090
-ALERTMANAGER_PORT=9093
@@ -1,3 +0,0 @@
-self-hosted-runner:
-  labels:
-    - eni-g3
@@ -20,17 +20,6 @@ updates:
      - dependency-name: "@vitest/coverage-v8"
        update-types: ["version-update:semver-major"]

-  # Tests de bout en bout, paquet npm distinct du frontend
-  - package-ecosystem: "npm"
-    directory: "/tests/e2e"
-    schedule:
-      interval: "weekly"
-    open-pull-requests-limit: 2
-    groups:
-      e2e-dependencies:
-        patterns:
-          - "*"
-
  # Backend — uv (lit pyproject.toml / uv.lock)
  - package-ecosystem: "uv"
    directory: "/apps/backend"
@@ -6,20 +6,42 @@ name: Airflow
 # Docker, dans son propre environnement (cf. etl/airflow/Dockerfile).
 #
 # Piège : l'image COPY les fichiers de dépendances et le code de ml/ et de apps/backend/. Une
-# modification de l'un ou de l'autre peut donc casser sa construction : le filtre `airflow` de
-# ci.yml, qui appelle ce workflow, inclut ces chemins alors qu'il ne teste ni le modèle ni l'API.
+# modification de l'un ou de l'autre peut donc casser sa construction, d'où ces chemins dans
+# les déclencheurs, alors même que ce workflow ne teste ni le modèle ni l'API.

 on:
-  workflow_call:
+  push:
+    paths:
+      - "etl/airflow/**"
+      - "ml/pyproject.toml"
+      - "ml/uv.lock"
+      - "ml/enervision_ml/**"
+      - "apps/backend/pyproject.toml"
+      - "apps/backend/uv.lock"
+      - "apps/backend/app/**"
+      - ".github/workflows/airflow.yml"
+  pull_request:
+    paths:
+      - "etl/airflow/**"
+      - "ml/pyproject.toml"
+      - "ml/uv.lock"
+      - "ml/enervision_ml/**"
+      - "apps/backend/pyproject.toml"
+      - "apps/backend/uv.lock"
+      - "apps/backend/app/**"
+      - ".github/workflows/airflow.yml"

 permissions:
  contents: read

+concurrency:
+  group: airflow-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
  verification:
    name: Lint et intégrité des DAGs
    runs-on: ubuntu-latest
-    timeout-minutes: 15
    defaults:
      run:
        working-directory: etl/airflow
@@ -28,19 +50,17 @@ jobs:
      - name: Récupère le dépôt
        uses: actions/checkout@v7

-      # Action tierce, épinglée sur le commit du tag (règle Sonar githubactions:S7637).
      - name: Installe uv
-        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+        uses: astral-sh/setup-uv@v7
        with:
          enable-cache: true
          cache-dependency-glob: etl/airflow/uv.lock
-          prune-cache: false

      - name: Installe l'interpréteur déclaré par .python-version
        run: uv python install

-      - name: Synchronise les dépendances sur le verrou
-        run: uv sync --all-groups --locked
+      - name: Synchronise les dépendances sans dévier du verrou
+        run: uv sync --all-groups --frozen

      - name: Vérifie le formatage
        run: uv run ruff format --check .
@@ -56,7 +76,6 @@ jobs:
  image:
    name: Construction de l'image
    runs-on: ubuntu-latest
-    timeout-minutes: 25

    steps:
      - name: Récupère le dépôt
@@ -74,6 +93,7 @@ jobs:

      # `--help` sort par argparse avant `get_settings()` : ni base ni secret requis, et
      # l'import des modules prouve que l'environnement /opt/backend est complet.
+      # Les commandes des DAGs `alertes`, historique et API Mock sont couvertes.
      - name: Vérifie que les quatre commandes backend s'importent sans réseau
        run: >
          docker run --rm --network none enervision-airflow:ci
@@ -81,4 +101,4 @@ jobs:
          && env -u VIRTUAL_ENV uv run --no-sync python -m app.detection.internal_alerts --help
          && env -u VIRTUAL_ENV uv run --no-sync python -m app.cli generate-recommendations --help
          && env -u VIRTUAL_ENV uv run --no-sync python -m app.etl.historical_import --help
-          && env -u VIRTUAL_ENV uv run --no-sync python -m app.etl.mock_api_import --help"
+          && env -u VIRTUAL_ENV uv run --no-sync python -m app.etl.mock_api_import --help"
@@ -2,20 +2,28 @@ name: Backend

 # Piège : la version de Python vient de apps/backend/.python-version, et elle doit rester
 # en 3.14. Le code utilise le PEP 758, qu'un interpréteur 3.13 refuse de compiler.
-# Pourquoi : aucun déclencheur propre. ci.yml appelle ce workflow quand le backend change, et
-# Sonar y reprend la couverture versée par le job `verification` (ADR 0014).

 on:
-  workflow_call:
+  push:
+    paths:
+      - "apps/backend/**"
+      - ".github/workflows/backend.yml"
+  pull_request:
+    paths:
+      - "apps/backend/**"
+      - ".github/workflows/backend.yml"

 permissions:
  contents: read

+concurrency:
+  group: backend-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
  verification:
    name: Lint, typage et tests
    runs-on: ubuntu-latest
-    timeout-minutes: 15
    defaults:
      run:
        working-directory: apps/backend
@@ -24,20 +32,17 @@ jobs:
      - name: Récupère le dépôt
        uses: actions/checkout@v7

-      # Action tierce, épinglée sur le commit du tag (règle Sonar githubactions:S7637).
      - name: Installe uv
-        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+        uses: astral-sh/setup-uv@v7
        with:
          enable-cache: true
          cache-dependency-glob: apps/backend/uv.lock
-          prune-cache: false

      - name: Installe l'interpréteur déclaré par .python-version
        run: uv python install

-      # `--locked` et non `--frozen` : un verrou qui ne suit plus pyproject.toml doit casser ici.
-      - name: Synchronise les dépendances sur le verrou
-        run: uv sync --all-groups --locked
+      - name: Synchronise les dépendances sans dévier du verrou
+        run: uv sync --all-groups --frozen

      - name: Vérifie le formatage
        run: uv run ruff format --check .
@@ -50,21 +55,14 @@ jobs:

      # Le marqueur `integration` est exclu par défaut, donc aucune base n'est nécessaire ici.
      - name: Tests et couverture
-        run: uv run pytest --cov-fail-under=85 --cov-report=xml
+        run: uv run pytest --cov-fail-under=85

-      - name: Verse la couverture pour Sonar
-        uses: actions/upload-artifact@v7
-        with:
-          name: backend-coverage
-          path: apps/backend/coverage.xml
-          if-no-files-found: error
-
-  # Piège : même image que docker-compose.yml, pas un `postgres` nu. La première migration refuse
-  # de s'appliquer sans TimescaleDB, et une autre image testerait une base qui n'est pas la nôtre.
+  # Piège : l'image est celle de docker-compose.yml, pas une image `postgres` nue. La première
+  # migration (`5353c0e4f094`) échoue volontairement si l'extension TimescaleDB manque, et un
+  # écart d'image entre la CI et le poste rendrait ce job vert sur une base qui n'est pas la nôtre.
  integration:
    name: Tests exigeant une base
    runs-on: ubuntu-latest
-    timeout-minutes: 15
    defaults:
      run:
        working-directory: apps/backend
@@ -95,17 +93,16 @@ jobs:
        uses: actions/checkout@v7

      - name: Installe uv
-        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+        uses: astral-sh/setup-uv@v7
        with:
          enable-cache: true
          cache-dependency-glob: apps/backend/uv.lock
-          prune-cache: false

      - name: Installe l'interpréteur déclaré par .python-version
        run: uv python install

-      - name: Synchronise les dépendances sur le verrou
-        run: uv sync --all-groups --locked
+      - name: Synchronise les dépendances sans dévier du verrou
+        run: uv sync --all-groups --frozen

      # Sur le poste, c'est db/init/110-test-database.sql qui pose l'extension. Ce fichier n'est
      # pas monté ici, et sans lui `alembic upgrade head` s'arrête sur la garde de la révision 1.
@@ -115,15 +112,14 @@ jobs:
      - name: Applique les migrations
        run: uv run alembic upgrade head

-      # Couverture désactivée : ce job ne joue qu'une partie de la suite, son taux n'aurait
-      # aucun sens face au seuil de 85 %.
+      # `-m` en ligne de commande écrase celui d'`addopts`. La couverture est désactivée : ce job
+      # ne joue qu'une partie de la suite, son taux n'aurait aucun sens face au seuil de 85 %.
      - name: Tests d'intégration
        run: uv run pytest -m integration --no-cov

  security-audit:
    name: Audit des dépendances
    runs-on: ubuntu-latest
-    timeout-minutes: 10
    defaults:
      run:
        working-directory: apps/backend
@@ -133,23 +129,21 @@ jobs:
        uses: actions/checkout@v7

      - name: Installe uv
-        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+        uses: astral-sh/setup-uv@v7
        with:
          enable-cache: true
          cache-dependency-glob: apps/backend/uv.lock
-          prune-cache: false

      # L'audit porte sur le verrou, pas sur l'environnement : sinon pip-audit auditerait
      # aussi les paquets que son propre `--with` injecte, hors dépendances du projet.
      - name: Audite les dépendances livrées
        # Piège : sans `shell: bash`, un échec de `uv export` serait masqué par le pipe.
        shell: bash
-        run: uv export --locked --no-dev --no-emit-project --no-hashes | uvx pip-audit --requirement /dev/stdin --no-deps
+        run: uv export --frozen --no-dev --no-emit-project --no-hashes | uvx pip-audit --requirement /dev/stdin --no-deps

  sast:
    name: Analyse statique de sécurité
    runs-on: ubuntu-latest
-    timeout-minutes: 10
    defaults:
      run:
        working-directory: apps/backend
@@ -161,9 +155,7 @@ jobs:
      # Pourquoi : pas de cache ici. uvx n'installe pas le projet, le verrou n'alimente donc
      # aucune clé de cache ; la seule roue téléchargée est celle de Bandit.
      - name: Installe uv
-        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
-        with:
-          enable-cache: false
+        uses: astral-sh/setup-uv@v7

      # Pourquoi : le périmètre est `app`, le code livré. Les tests emploient légitimement des
      # secrets factices et des `assert` que Bandit signalerait sans qu'aucun n'atteigne la prod.
@@ -1,225 +0,0 @@
-# Pourquoi : un seul point d'entrée pour toute la CI (ADR 0014) - workflow CI. Chaque composant
-# ne tourne que si ses fichiers changent, Sonar reprend les couvertures déjà produites au lieu de
-# tout rejouer, et le déploiement ne part que d'un commit dont la CI est verte.
-# Piège : le seul check à exiger dans les règles de branche est « CI ok ». Un job sauté par son
-# filtre ne publie pas les checks de son workflow, qui resteraient en attente s'ils étaient exigés.
-# Piège : sur un push vers dev ou main, tous les filtres valent vrai. paths-filter comparerait
-# sinon à la base de fusion avec main, et Sonar n'analyserait qu'une partie de la branche.
-# Piège : pas d'annulation des runs de push. Un run coupé en plein `make stack-up` laisserait la
-# stack à moitié redémarrée ; le groupe par SHA évite aussi de mettre `dev` en file derrière lui.
-
-name: CI
-
-on:
-  pull_request:
-  push:
-    branches: [dev, main]
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-concurrency:
-  group: ci-${{ github.event_name == 'pull_request' && github.ref || github.sha }}
-  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
-
-jobs:
-  changes:
-    name: Périmètre modifié
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    permissions:
-      contents: read
-      pull-requests: read
-    outputs:
-      backend: ${{ github.event_name != 'pull_request' || steps.filtre.outputs.ci == 'true' || steps.filtre.outputs.backend == 'true' }}
-      frontend: ${{ github.event_name != 'pull_request' || steps.filtre.outputs.ci == 'true' || steps.filtre.outputs.frontend == 'true' }}
-      ml: ${{ github.event_name != 'pull_request' || steps.filtre.outputs.ci == 'true' || steps.filtre.outputs.ml == 'true' }}
-      airflow: ${{ github.event_name != 'pull_request' || steps.filtre.outputs.ci == 'true' || steps.filtre.outputs.airflow == 'true' }}
-      terraform: ${{ github.event_name != 'pull_request' || steps.filtre.outputs.ci == 'true' || steps.filtre.outputs.terraform == 'true' }}
-      compose: ${{ github.event_name != 'pull_request' || steps.filtre.outputs.ci == 'true' || steps.filtre.outputs.compose == 'true' }}
-      workflows: ${{ github.event_name != 'pull_request' || steps.filtre.outputs.workflows == 'true' }}
-      e2e: ${{ github.event_name != 'pull_request' || steps.filtre.outputs.ci == 'true' || steps.filtre.outputs.e2e == 'true' }}
-      sonar: ${{ github.event_name != 'pull_request' || steps.filtre.outputs.ci == 'true' || steps.filtre.outputs.sonar == 'true' }}
-
-    steps:
-      # Sur une PR, la liste des fichiers vient de l'API : ni checkout ni historique requis.
-      - name: Calcule le périmètre de la PR
-        id: filtre
-        if: github.event_name == 'pull_request'
-        uses: dorny/paths-filter@ceb8a2b8f2d89434be7ff52d3de7ec3738c5cc9d # v4.0.3
-        with:
-          filters: |
-            ci:
-              - ".github/workflows/ci.yml"
-            backend:
-              - "apps/backend/**"
-              - ".github/workflows/backend.yml"
-            frontend:
-              - "apps/frontend/**"
-              - ".github/workflows/frontend.yml"
-            ml:
-              - "ml/**"
-              - "apps/backend/alembic/**"
-              - "apps/backend/app/models/**"
-              - "apps/backend/tests/test_chaine_ml_api.py"
-              - "apps/backend/pyproject.toml"
-              - "apps/backend/uv.lock"
-              - ".github/workflows/ml.yml"
-            airflow:
-              - "etl/airflow/**"
-              - "ml/pyproject.toml"
-              - "ml/uv.lock"
-              - "ml/enervision_ml/**"
-              - "apps/backend/pyproject.toml"
-              - "apps/backend/uv.lock"
-              - "apps/backend/app/**"
-              - ".github/workflows/airflow.yml"
-            terraform:
-              - "infra/terraform/**"
-              - ".github/workflows/infra.yml"
-            compose:
-              - "docker-compose*.yml"
-              - ".env.example"
-              - "infra/front/**"
-              - "monitoring/**"
-              - ".github/workflows/infra.yml"
-            workflows:
-              - ".github/**"
-            e2e:
-              - "apps/frontend/**"
-              - "apps/backend/app/**"
-              - "apps/backend/alembic/**"
-              - "apps/backend/Dockerfile"
-              - "apps/backend/pyproject.toml"
-              - "apps/backend/uv.lock"
-              - "infra/proxy/**"
-              - "docker-compose*.yml"
-              - "db/**"
-              - "tests/**"
-              - "scripts/comptes-test.sh"
-              - "scripts/tls-selfsigned.sh"
-              - "Makefile"
-              - ".env.example"
-              - ".github/workflows/e2e.yml"
-            sonar:
-              - "apps/backend/**"
-              - "apps/frontend/**"
-              - "ml/**"
-              - "etl/airflow/**"
-              - "sonar-project.properties"
-
-  backend:
-    name: Backend
-    needs: changes
-    if: needs.changes.outputs.backend == 'true'
-    uses: ./.github/workflows/backend.yml
-
-  frontend:
-    name: Frontend
-    needs: changes
-    if: needs.changes.outputs.frontend == 'true'
-    uses: ./.github/workflows/frontend.yml
-
-  ml:
-    name: ML
-    needs: changes
-    if: needs.changes.outputs.ml == 'true'
-    uses: ./.github/workflows/ml.yml
-
-  airflow:
-    name: Airflow
-    needs: changes
-    if: needs.changes.outputs.airflow == 'true'
-    uses: ./.github/workflows/airflow.yml
-
-  infra:
-    name: Infra
-    needs: changes
-    if: >-
-      needs.changes.outputs.terraform == 'true'
-      || needs.changes.outputs.compose == 'true'
-      || needs.changes.outputs.workflows == 'true'
-    uses: ./.github/workflows/infra.yml
-    with:
-      terraform: ${{ needs.changes.outputs.terraform == 'true' }}
-      compose: ${{ needs.changes.outputs.compose == 'true' }}
-      workflows: ${{ needs.changes.outputs.workflows == 'true' }}
-
-  e2e:
-    name: E2E
-    needs: changes
-    if: needs.changes.outputs.e2e == 'true'
-    uses: ./.github/workflows/e2e.yml
-
-  # Ni dependabot[bot] ni une PR de fork ne reçoivent SONAR_TOKEN : le scan échouerait sans rien
-  # analyser. Tests et couverture restent joués par leurs jobs.
-  sonar:
-    name: SonarQube
-    needs: [changes, backend, frontend, ml]
-    if: >-
-      always() && !cancelled()
-      && !contains(needs.*.result, 'failure')
-      && needs.changes.outputs.sonar == 'true'
-      && github.actor != 'dependabot[bot]'
-      && (github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository)
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-
-    steps:
-      - name: Récupère le dépôt
-        uses: actions/checkout@v7
-        with:
-          fetch-depth: 0
-
-      # Un téléchargement par rapport : backend et ML nomment tous deux le leur `coverage.xml`.
-      - name: Couverture du backend
-        if: needs.backend.result == 'success'
-        uses: actions/download-artifact@v8
-        with:
-          name: backend-coverage
-          path: apps/backend
-
-      - name: Couverture du pipeline ML
-        if: needs.ml.result == 'success'
-        uses: actions/download-artifact@v8
-        with:
-          name: ml-coverage
-          path: ml
-
-      - name: Couverture du frontend
-        if: needs.frontend.result == 'success'
-        uses: actions/download-artifact@v8
-        with:
-          name: frontend-coverage
-          path: apps/frontend/coverage/frontend
-
-      # Action tierce, épinglée sur le commit du tag (règle Sonar githubactions:S7637).
-      - name: Analyse SonarQube
-        uses: SonarSource/sonarqube-scan-action@ba9859eae8dd6bd29e412f25ddbbef3d032000f4 # v8.2.2
-        env:
-          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
-
-  ci-ok:
-    name: CI ok
-    needs: [changes, backend, frontend, ml, airflow, infra, e2e, sonar]
-    if: always()
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-
-    steps:
-      - name: Refuse si un job a échoué ou a été annulé
-        env:
-          RESULTATS: ${{ toJSON(needs.*.result) }}
-        run: |
-          echo "$RESULTATS"
-          if grep -qE '"(failure|cancelled)"' <<<"$RESULTATS"; then
-            echo "::error::Au moins un job de la CI a échoué ou a été annulé."
-            exit 1
-          fi
-
-  deploy:
-    name: Déploiement
-    needs: ci-ok
-    if: ${{ !cancelled() && needs.ci-ok.result == 'success' && github.event_name == 'push' }}
-    uses: ./.github/workflows/deploy.yml
@@ -1,9 +1,9 @@
 name: DAST

 # Scan dynamique OWASP ZAP de l'API (issue #41). Il attaque une API qui tourne : le job démarre
-# la base et le backend sur le runner, sème le jeu de démonstration (sans ça le scan ne frappe que
-# des gestionnaires d'erreur), crée des comptes jetables (scripts/dast-token.sh), puis lance ZAP
-# sur le contrat OpenAPI avec le jeton du `lecteur`.
+# la base et le backend sur le runner, sème un site et quelques relevés (sans ça le scan ne
+# frappe que des gestionnaires d'erreur), crée un compte `lecteur` jetable
+# (scripts/dast-token.sh), puis lance ZAP sur le contrat OpenAPI avec le jeton de ce compte.
 #
 # Non bloquant pour l'instant sur les alertes (`continue-on-error` sur la seule étape du scan) :
 # le volume d'un premier passage trié est inconnu. Deux étapes suivantes, elles, bloquent si le
@@ -24,8 +24,6 @@ on:
    paths:
      - ".github/workflows/dast.yml"
      - "scripts/dast-token.sh"
-      - "scripts/comptes-test.sh"
-      - "db/seeds/**"

 permissions:
  contents: read
@@ -79,7 +77,7 @@ jobs:
      - name: Installe uv
        # Épinglé sur le commit du tag v7 (règle Sonar githubactions:S7637 : dépendance tierce,
        # contrairement à actions/checkout ou actions/upload-artifact, premières parties).
-        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7
        with:
          enable-cache: true
          cache-dependency-glob: apps/backend/uv.lock
@@ -99,7 +97,7 @@ jobs:
      # `apps/backend`, comme dans son Dockerfile. Les `uv run` suivants portent `--frozen
      # --no-sync` pour ne rien résoudre ni reconstruire (règle S8544).
      - name: Synchronise les dépendances sans dévier du verrou
-        run: uv sync --locked --no-dev --no-install-project --no-build
+        run: uv sync --frozen --no-dev --no-install-project --no-build
        working-directory: apps/backend

      - name: Active TimescaleDB sur la base du scan
@@ -110,9 +108,22 @@ jobs:
        working-directory: apps/backend

      # Sans données, `GET /sites` rend `[]`, chaque `/{site_id}` rend 404 et le scan actif ne
-      # frappe que des gestionnaires d'erreur plutôt que la logique métier.
-      - name: Sème le jeu de démonstration
-        run: psql -h localhost -p 5433 -U enervision -d enervision_dast -v ON_ERROR_STOP=1 -f db/seeds/demo.sql
+      # frappe que des gestionnaires d'erreur plutôt que la logique métier. `db/seeds/` est vide
+      # (pas encore d'outillage de jeu de données pour la CI) : un site et deux relevés à la main,
+      # juste assez pour que les routes de lecture aient quelque chose à rendre.
+      - name: Insère un site et des relevés minimaux pour le scan
+        run: |
+          psql -h localhost -p 5433 -U enervision -d enervision_dast <<'SQL'
+          INSERT INTO site (site_id, site_name, site_type, location, capacity_kw, status)
+          VALUES ('dast-site', 'Site du scan DAST', 'bureau', 'CI', 50, 'actif')
+          ON CONFLICT (site_id) DO NOTHING;
+
+          INSERT INTO reading (site_id, timestamp, source, consumption_kw, consumption_kwh, is_working_hours, data_quality, raw_data)
+          VALUES
+            ('dast-site', now() - interval '2 hours', 'api_current', 12.5, 12.5, true, 'good', '{}'),
+            ('dast-site', now() - interval '1 hour',  'api_current', 13.0, 13.0, true, 'good', '{}')
+          ON CONFLICT DO NOTHING;
+          SQL

      - name: Démarre l'API
        run: |
@@ -288,11 +299,9 @@ jobs:
        if: always()
        run: |
          if [ -f zap-out/zap-report.md ]; then
-            {
-              awk '/^## Alert Detail/{exit} {print}' zap-out/zap-report.md
-              echo ""
-              echo "Rapport complet (HTML/JSON/Markdown) dans l'artefact \`zap-report\`."
-            } >> "$GITHUB_STEP_SUMMARY"
+            awk '/^## Alert Detail/{exit} {print}' zap-out/zap-report.md >> "$GITHUB_STEP_SUMMARY"
+            echo "" >> "$GITHUB_STEP_SUMMARY"
+            echo "Rapport complet (HTML/JSON/Markdown) dans l'artefact \`zap-report\`." >> "$GITHUB_STEP_SUMMARY"
          else
            echo "Aucun rapport ZAP produit, voir le journal du job." >> "$GITHUB_STEP_SUMMARY"
          fi
@@ -1,74 +1,57 @@
 # Pourquoi : le runner tourne sur la VM ENI, adresse privée que les runners hébergés par GitHub
 # ne joignent pas, et travaille dans un dossier stable par environnement plutôt que dans son
 # espace de travail : `.env`, certificats et volumes y survivent d'un déploiement à l'autre.
-# Pourquoi : appelé par ci.yml une fois « CI ok » vert, jamais directement par un push, et il
-# déploie `GITHUB_SHA`, le commit testé, pas la pointe de branche du moment (ADR 0014).
-# Pourquoi : `main` va en prod, `dev` en recette, et toute autre branche lancée à la main
-# (workflow_dispatch) va dans `dev`, la vitrine d'une branche de travail (ADR 0017).
 # Piège : jamais de déclencheur `pull_request` ici. Sur un dépôt public, une PR de fork
 # exécuterait son code sur la machine de production (ADR 0009) - job deploy.
-# Piège : les CI de deux push finissent parfois dans le désordre. Un commit qui précède celui déjà
-# déployé depuis la même branche est ignoré, et le verrou est un `flock` sur le dossier de
-# l'environnement plutôt qu'un groupe `concurrency` : GitHub n'y garde qu'un job en attente, et
-# le suivant l'évince sans bruit.

 name: Déploiement

 on:
-  workflow_call:
+  push:
+    branches: [dev, main]
  workflow_dispatch:

 permissions:
  contents: read

+concurrency:
+  group: deploy-${{ github.ref_name }}
+  cancel-in-progress: false
+
 jobs:
  deploy:
-    name: Déploie sur la VM
    runs-on: [self-hosted, linux, eni-g3]
    timeout-minutes: 30
    environment:
-      name: ${{ github.ref_name == 'main' && 'prod' || github.ref_name == 'dev' && 'rec' || 'dev' }}
-      url: ${{ github.ref_name == 'main' && 'https://prod.enervision-g3.dynv6.net' || github.ref_name == 'dev' && 'https://rec.enervision-g3.dynv6.net' || 'https://dev.enervision-g3.dynv6.net' }}
+      name: ${{ github.ref_name == 'main' && 'prod' || 'rec' }}
+      url: ${{ github.ref_name == 'main' && 'https://enervision.local' || 'https://rec.enervision.local:8443' }}
    env:
-      ENVIRONNEMENT: ${{ github.ref_name == 'main' && 'prod' || github.ref_name == 'dev' && 'rec' || 'dev' }}
-      PORT_HTTPS: ${{ github.ref_name == 'main' && '10443' || github.ref_name == 'dev' && '8443' || '9443' }}
+      ENVIRONNEMENT: ${{ github.ref_name == 'main' && 'prod' || 'rec' }}
+      PORT_HTTPS: ${{ github.ref_name == 'main' && '443' || '8443' }}
    steps:
-      # Un seul step : le verrou tombe avec le shell qui l'a posé.
-      - name: Déploie le commit testé, sans jamais reculer
+      - name: Aligner le dossier de l'environnement sur la branche poussée
        run: |
          cd "/srv/enervision/${ENVIRONNEMENT}"
-          exec 9>"$(git rev-parse --git-dir)/verrou-deploiement"
-          flock 9
-
-          echo "::group::Aligne le dossier de l'environnement sur le commit testé"
          git fetch --quiet origin "${GITHUB_REF_NAME}"
-          deploye="$(git rev-parse HEAD)"
-          if [ "$(git branch --show-current)" = "$GITHUB_REF_NAME" ] && [ "$deploye" != "$GITHUB_SHA" ] \
-            && git merge-base --is-ancestor "$GITHUB_SHA" "$deploye"; then
-            echo "::notice::${GITHUB_SHA:0:7} précède le commit déjà déployé (${deploye:0:7}) : rien à déployer."
-            exit 0
-          fi
          git checkout --quiet "${GITHUB_REF_NAME}"
-          git reset --quiet --hard "${GITHUB_SHA}"
+          git reset --quiet --hard "origin/${GITHUB_REF_NAME}"
          git log -1 --format='%h %s'
-          echo "::endgroup::"

-          echo "::group::Reconstruit et redémarre la stack"
-          # Un `.env` pas encore réaligné par provision-host.sh porte encore un nom en `.local`.
-          if [ -r ../dns.token ] && ! grep -q '^PUBLIC_HOST=.*\.local$' .env; then make tls-dns01; fi
+      - name: Reconstruire et redémarrer la stack
+        run: |
+          cd "/srv/enervision/${ENVIRONNEMENT}"
          make stack-up
-          if [ "${ENVIRONNEMENT}" = prod ]; then make front-up; fi
-          echo "::endgroup::"

-          echo "::group::Attend que l'API réponde derrière le proxy"
-          for _ in $(seq 1 36); do
+      - name: Attendre que l'API réponde derrière le proxy
+        run: |
+          for tentative in $(seq 1 36); do
            if curl --fail --silent --insecure "https://localhost:${PORT_HTTPS}/api/v1/health/ready"; then
              exit 0
            fi
            sleep 5
          done
-          echo "::endgroup::"
          echo "L'API ne répond pas après 3 minutes" >&2
+          cd "/srv/enervision/${ENVIRONNEMENT}"
          compose="docker compose -f docker-compose.yml -f docker-compose.prod.yml"
          $compose ps
          $compose logs --tail=50 backend proxy
@@ -1,135 +0,0 @@
-name: E2E
-
-# Pourquoi : les parcours tournent contre la stack telle qu'elle est déployée, derrière le proxy
-# TLS (cookie `__Secure-`, CSP, limitation de débit), pas contre `ng serve` - job parcours. Il
-# construit aussi les images backend et frontend, que rien d'autre ne construit avant le
-# déploiement (ADR 0015).
-# Piège : pas d'Airflow ici. `up` nomme ses services : sans eux, la construction de l'image
-# Airflow doublerait la durée du job sans rien tester de plus.
-
-on:
-  workflow_call:
-
-permissions:
-  contents: read
-
-jobs:
-  parcours:
-    name: Parcours Playwright et tirs k6
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    env:
-      COMPOSE_FILE: docker-compose.yml:docker-compose.prod.yml
-      PUBLIC_HOST: localhost
-      E2E_BASE_URL: https://localhost
-
-    steps:
-      - name: Récupère le dépôt
-        uses: actions/checkout@v7
-
-      - name: Prépare le .env de la stack
-        run: |
-          secret() { openssl rand -hex 32; }
-          sed -e "s|^POSTGRES_PASSWORD=.*|POSTGRES_PASSWORD=$(secret)|" \
-              -e "s|^APP_SECRET_KEY=.*|APP_SECRET_KEY=$(secret)|" \
-              -e "s|^PUBLIC_HOST=.*|PUBLIC_HOST=localhost|" \
-              .env.example > .env
-
-      - name: Génère le certificat de démonstration
-        run: ./scripts/tls-selfsigned.sh
-
-      - name: Construit et démarre la stack derrière le proxy
-        run: docker compose up --detach --build --wait --wait-timeout 300 db mailpit backend frontend proxy
-
-      - name: Applique les migrations
-        run: docker compose exec -T backend alembic upgrade head
-
-      # Même cible que `make stack-up` en prod : les droits du rôle portent sur le schéma réel.
-      - name: Pose le rôle de supervision en lecture seule
-        run: make db-ensure-supervision
-
-      - name: Sème le jeu de démonstration
-        run: docker compose exec -T db psql -U enervision -d enervision -v ON_ERROR_STOP=1 < db/seeds/demo.sql
-
-      - name: Crée les comptes de test
-        env:
-          BASE_URL: https://localhost
-          APP_CLI: docker compose exec -T backend python -m app.cli
-          COMPTES_FICHIER: ${{ runner.temp }}/comptes.json
-        run: ./scripts/comptes-test.sh
-
-      - name: Installe Node
-        uses: actions/setup-node@v7
-        with:
-          node-version: 26
-          cache: npm
-          cache-dependency-path: tests/e2e/package-lock.json
-
-      - name: Installe Playwright
-        working-directory: tests/e2e
-        run: npm ci
-
-      - name: Restaure les navigateurs de Playwright
-        uses: actions/cache@v6
-        with:
-          path: ~/.cache/ms-playwright
-          key: playwright-${{ runner.os }}-${{ hashFiles('tests/e2e/package-lock.json') }}
-
-      # `--with-deps` tourne même quand le cache a servi : il pose aussi les bibliothèques système.
-      - name: Installe Chromium
-        working-directory: tests/e2e
-        run: npx playwright install --with-deps chromium
-
-      - name: Joue les parcours
-        working-directory: tests/e2e
-        env:
-          E2E_COMPTES: ${{ runner.temp }}/comptes.json
-        run: npx playwright test
-
-      # Direct sur `backend:8000` : ce tir mesure l'API, pas la limitation de nginx.
-      - name: Tir k6 de fumée sur l'API
-        env:
-          K6_RESUME: /results/resume-smoke.md
-        run: |
-          K6_EMAIL="$(jq -r .lecteur.email "$RUNNER_TEMP/comptes.json")"
-          K6_PASSWORD="$(jq -r .lecteur.password "$RUNNER_TEMP/comptes.json")"
-          echo "::add-mask::$K6_PASSWORD"
-          export K6_EMAIL K6_PASSWORD
-          make load-smoke
-
-      - name: Vérifie par k6 que le proxy limite le débit
-        env:
-          K6_RESUME: /results/resume-limitation.md
-        run: make load-limits
-
-      - name: Publie la synthèse k6
-        if: ${{ !cancelled() }}
-        run: cat tests/load/results/resume-*.md >> "$GITHUB_STEP_SUMMARY" 2>/dev/null || true
-
-      - name: Publie les rapports k6
-        if: ${{ !cancelled() }}
-        uses: actions/upload-artifact@v7
-        with:
-          name: k6-rapports
-          path: tests/load/results/
-          if-no-files-found: ignore
-          retention-days: 14
-
-      - name: Publie le rapport Playwright
-        if: ${{ !cancelled() }}
-        uses: actions/upload-artifact@v7
-        with:
-          name: playwright-report
-          path: |
-            tests/e2e/playwright-report/
-            tests/e2e/test-results/
-          if-no-files-found: ignore
-          retention-days: 14
-
-      - name: Journaux de la stack en cas d'échec
-        if: failure()
-        run: docker compose logs --tail=200 backend proxy frontend
-
-      - name: Arrête la stack
-        if: always()
-        run: docker compose down --volumes
@@ -1,70 +1,64 @@
 name: Frontend

-# Pourquoi : aucun déclencheur propre. ci.yml appelle ce workflow quand le frontend change, et
-# Sonar y reprend la couverture versée par le job `verification` (ADR 0014).
-
 on:
-  workflow_call:
+  push:
+    paths:
+      - "apps/frontend/**"
+      - ".github/workflows/frontend.yml"
+  pull_request:
+    paths:
+      - "apps/frontend/**"
+      - ".github/workflows/frontend.yml"

 permissions:
  contents: read

 jobs:
-  # Un seul `npm ci` pour la construction et les tests : un job de plus ne ferait que le rejouer.
-  verification:
-    name: Construction et tests
+  build:
    runs-on: ubuntu-latest
-    timeout-minutes: 15
-    defaults:
-      run:
-        working-directory: apps/frontend
-
    steps:
-      - name: Récupère le dépôt
-        uses: actions/checkout@v7
-
-      - name: Installe Node
-        uses: actions/setup-node@v7
+      - uses: actions/checkout@v7
+      - uses: actions/setup-node@v7
        with:
          node-version: 26
          cache: npm
          cache-dependency-path: apps/frontend/package-lock.json

-      - name: Installe les dépendances
-        run: npm ci
-
-      - name: Construit l'application
-        run: npm run build
-
-      # Piège : `npm test --watch=false` garde l'option pour npm, `ng test` ne la reçoit jamais.
-      # La couverture lcov vient d'angular.json (`coverage: true`).
-      - name: Tests et couverture
-        run: npm run test:ci
-
-      - name: Verse la couverture pour Sonar
-        uses: actions/upload-artifact@v7
-        with:
-          name: frontend-coverage
-          path: apps/frontend/coverage/frontend/lcov.info
-          if-no-files-found: error
+      - run: npm ci
+        working-directory: apps/frontend
+      - run: npm run build
+        working-directory: apps/frontend

  security-audit:
    name: Audit des dépendances
    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    defaults:
-      run:
-        working-directory: apps/frontend
-
    steps:
-      - name: Récupère le dépôt
-        uses: actions/checkout@v7
-
-      - name: Installe Node
-        uses: actions/setup-node@v7
+      - uses: actions/checkout@v7
+      - uses: actions/setup-node@v7
        with:
          node-version: 26
-
      # Seuil high : une vulnérabilité moderate de devDependency ne doit pas bloquer une livraison.
-      - name: Audite le verrou
-        run: npm audit --audit-level=high --package-lock-only
+      - run: npm audit --audit-level=high --package-lock-only
+        working-directory: apps/frontend
+
+  test:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-node@v7
+        with:
+          node-version: 26
+          cache: npm
+          cache-dependency-path: apps/frontend/package-lock.json
+      - name : Installation des dépendances (Front)
+        run: npm ci 
+        working-directory: apps/frontend
+      - name : Lancement des tests et génénration du rapport de couverture (Front)
+        run: npm test --watch=false --code-coverage --coverageReporters=lcov
+        working-directory: apps/frontend
+      - name: Upload coverage
+        uses: actions/upload-artifact@v7
+        with:
+          name: frontend-coverage
+          path: apps/frontend/coverage/frontend/lcov.info
@@ -1,40 +1,38 @@
 name: Infra

-# Pourquoi : rien de ce qui décrit l'infrastructure ne s'exécute avant le déploiement. Terraform est
-# resté cassé sans que rien ne le dise, faute de job qui le joue : ce workflow n'applique rien, il
-# vérifie le Terraform, les fichiers Compose et les workflows eux-mêmes - jobs terraform, compose,
-# workflows. ci.yml choisit par ses entrées ceux qui tournent (ADR 0014).
-# Piège : la boucle Terraform parcourt `environments/*`, pour qu'une racine ajoutée soit couverte
-# sans toucher à ce fichier.
+# Pourquoi : le Terraform du dépôt est resté cassé sans que rien ne le dise, faute de job qui le
+# joue. Ce workflow n'applique rien : il vérifie le formatage et la validité de chaque racine.
+# Piège : la boucle parcourt `environments/*`, pour qu'une racine ajoutée soit couverte sans
+# toucher à ce fichier.

 on:
-  workflow_call:
-    inputs:
-      terraform:
-        type: boolean
-        default: false
-      compose:
-        type: boolean
-        default: false
-      workflows:
-        type: boolean
-        default: false
+  push:
+    paths:
+      - "infra/terraform/**"
+      - ".github/workflows/infra.yml"
+  pull_request:
+    paths:
+      - "infra/terraform/**"
+      - ".github/workflows/infra.yml"

 permissions:
  contents: read

+concurrency:
+  group: infra-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
  terraform:
    name: Formatage et validation Terraform
-    if: inputs.terraform
    runs-on: ubuntu-latest
-    timeout-minutes: 10

    steps:
      - name: Récupère le dépôt
        uses: actions/checkout@v7

-      # Action tierce, épinglée sur le commit du tag (règle Sonar githubactions:S7637).
+      # Action tierce, donc epinglee sur un SHA de commit et pas sur un tag mobile : un tag se
+      # redeplace, et ce workflow tourne avec les droits du depot (regle Sonar githubactions:S7637).
      - name: Installe Terraform
        uses: hashicorp/setup-terraform@dfe3c3f87815947d99a8997f908cb6525fc44e9e # v4.0.1
        with:
@@ -52,56 +50,3 @@ jobs:
            terraform -chdir="${racine}" validate
            echo "::endgroup::"
          done
-
-  compose:
-    name: Validation des fichiers Compose et de la supervision
-    if: inputs.compose
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-
-    steps:
-      - name: Récupère le dépôt
-        uses: actions/checkout@v7
-
-      # Compose interpole tout le fichier : les `:?` exigent une valeur, pas un vrai secret.
-      - name: Prépare un .env d'exemple
-        run: cp .env.example .env
-
-      - name: Valide la stack de développement
-        run: docker compose config --quiet
-
-      - name: Valide la stack déployée, profils compris
-        run: docker compose -f docker-compose.yml -f docker-compose.prod.yml --profile acme --profile monitoring --profile load config --quiet
-
-      - name: Valide le frontal SNI de la VM
-        run: |
-          docker compose -f infra/front/compose.yml config --quiet
-          docker run --rm -v "$PWD/infra/front/nginx.conf:/etc/nginx/nginx.conf:ro" nginx:1.31-alpine nginx -t
-
-      # Mêmes commandes que `make monitoring-check` : images et montages viennent du fichier Compose.
-      - name: Valide la configuration de Prometheus et ses règles
-        run: docker compose --profile monitoring run --rm --no-deps --entrypoint promtool prometheus check config /etc/prometheus/prometheus.yml
-
-      - name: Joue les tests unitaires des règles d'alerte
-        run: docker compose --profile monitoring run --rm --no-deps --entrypoint promtool prometheus test rules /etc/prometheus/tests/enervision.test.yml
-
-      - name: Valide la configuration d'Alertmanager
-        run: docker compose --profile monitoring run --rm --no-deps --entrypoint amtool alertmanager check-config /etc/alertmanager/alertmanager.yml
-
-      - name: Valide les tableaux de bord Grafana
-        run: for tableau in monitoring/grafana/dashboards/*.json; do jq empty "$tableau"; done
-
-  workflows:
-    name: Analyse des workflows
-    if: inputs.workflows
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-
-    steps:
-      - name: Récupère le dépôt
-        uses: actions/checkout@v7
-
-      # Image épinglée par tag, comme les images des fichiers Compose. Elle embarque shellcheck,
-      # qui analyse aussi les blocs `run:`.
-      - name: actionlint
-        run: docker run --rm -v "$PWD:/repo" --workdir /repo rhysd/actionlint:1.7.12 -color
@@ -2,20 +2,46 @@ name: ML

 # Piège : la version de Python vient de ml/.python-version, et doit rester en 3.14 (cf.
 # .github/workflows/backend.yml, même contrainte).
-# Pourquoi : aucun déclencheur propre. ci.yml l'appelle aussi quand les migrations ou les modèles
-# du backend changent, dont dépend le job `integration` (ADR 0014).

 on:
-  workflow_call:
+  push:
+    paths:
+      - "ml/**"
+      - ".github/workflows/ml.yml"
+      # Le job `integration` monte son schema avec les migrations du backend et joue le test de
+      # chaine qui vit dans ses tests : sans ces chemins, une migration modifiee ne declencherait
+      # rien et le schema deriverait du SQL du pipeline sans que rien ne casse. Meme raisonnement
+      # que le filtre d'airflow.yml, qui inclut deja des chemins de ml/ et de apps/backend/.
+      - "apps/backend/alembic/**"
+      - "apps/backend/app/models/**"
+      - "apps/backend/tests/test_chaine_ml_api.py"
+      - "apps/backend/pyproject.toml"
+      - "apps/backend/uv.lock"
+  pull_request:
+    paths:
+      - "ml/**"
+      - ".github/workflows/ml.yml"
+      # Le job `integration` monte son schema avec les migrations du backend et joue le test de
+      # chaine qui vit dans ses tests : sans ces chemins, une migration modifiee ne declencherait
+      # rien et le schema deriverait du SQL du pipeline sans que rien ne casse. Meme raisonnement
+      # que le filtre d'airflow.yml, qui inclut deja des chemins de ml/ et de apps/backend/.
+      - "apps/backend/alembic/**"
+      - "apps/backend/app/models/**"
+      - "apps/backend/tests/test_chaine_ml_api.py"
+      - "apps/backend/pyproject.toml"
+      - "apps/backend/uv.lock"

 permissions:
  contents: read

+concurrency:
+  group: ml-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
  verification:
    name: Lint, typage et tests
    runs-on: ubuntu-latest
-    timeout-minutes: 15
    defaults:
      run:
        working-directory: ml
@@ -24,19 +50,17 @@ jobs:
      - name: Récupère le dépôt
        uses: actions/checkout@v7

-      # Action tierce, épinglée sur le commit du tag (règle Sonar githubactions:S7637).
      - name: Installe uv
-        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+        uses: astral-sh/setup-uv@v7
        with:
          enable-cache: true
          cache-dependency-glob: ml/uv.lock
-          prune-cache: false

      - name: Installe l'interpréteur déclaré par .python-version
        run: uv python install

-      - name: Synchronise les dépendances sur le verrou
-        run: uv sync --all-groups --locked
+      - name: Synchronise les dépendances sans dévier du verrou
+        run: uv sync --all-groups --frozen

      - name: Vérifie le formatage
        run: uv run ruff format --check .
@@ -47,24 +71,17 @@ jobs:
      - name: Typage
        run: uv run mypy enervision_ml tests

-      # Les tests exigeant une base portent le marqueur `integration`, écarté par défaut et
-      # joué par le job `integration` ci-dessous.
-      - name: Tests et couverture
-        run: uv run pytest --cov-report=xml
+      # Les tests exigeant une base portent le marqueur `integration`, ecarte par defaut et
+      # joue par le job `integration` ci-dessous.
+      - name: Tests
+        run: uv run pytest

-      - name: Verse la couverture pour Sonar
-        uses: actions/upload-artifact@v7
-        with:
-          name: ml-coverage
-          path: ml/coverage.xml
-          if-no-files-found: error
-
-  # Piège : le schéma de la base ML est celui du backend (apps/backend/alembic, propriétaire du
-  # schéma). Le reconstruire ici à la main rendrait ce job vert sur une base qui n'est pas la nôtre.
+  # Le seul job du depot qui dispose a la fois des deux environnements uv et d'une base. Piege :
+  # le schema de la base ML est celui du backend (apps/backend/alembic, proprietaire du schema).
+  # Le reconstruire ici a la main rendrait ce job vert sur une base qui n'est pas la notre.
  integration:
    name: ML - DB et chaîne ML - DB - API
    runs-on: ubuntu-latest
-    timeout-minutes: 20

    services:
      db:
@@ -95,27 +112,26 @@ jobs:
        uses: actions/checkout@v7

      - name: Installe uv
-        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+        uses: astral-sh/setup-uv@v7
        with:
          enable-cache: true
          cache-dependency-glob: |
            ml/uv.lock
            apps/backend/uv.lock
-          prune-cache: false

      - name: Installe l'interpréteur déclaré par .python-version
        working-directory: ml
        run: uv python install

-      - name: Synchronise le pipeline ML sur le verrou
+      - name: Synchronise le pipeline ML sans dévier du verrou
        working-directory: ml
-        run: uv sync --all-groups --locked
+        run: uv sync --all-groups --frozen

      # Le backend est installé ici parce qu'il porte les migrations, seule source du schéma, et
      # le test de chaîne, qui interroge l'API.
-      - name: Synchronise le backend sur le verrou
+      - name: Synchronise le backend sans dévier du verrou
        working-directory: apps/backend
-        run: uv sync --all-groups --locked
+        run: uv sync --all-groups --frozen

      # db/init/110-test-database.sql n'est pas monté ici, et sans l'extension la première
      # révision Alembic refuse de s'appliquer.
@@ -126,8 +142,8 @@ jobs:
        working-directory: apps/backend
        run: uv run alembic upgrade head

-      # Couverture désactivée : ce job ne joue qu'une partie de la suite, son taux n'aurait pas
-      # de sens (même raison que backend.yml).
+      # `-m` en ligne de commande écrase celui d'addopts. Couverture désactivée : ce job ne joue
+      # qu'une partie de la suite, son taux n'aurait pas de sens (même raison que backend.yml).
      - name: Tests ML exigeant une base
        working-directory: ml
        run: uv run pytest -m integration --no-cov
@@ -143,7 +159,6 @@ jobs:
  sast:
    name: Analyse statique de sécurité
    runs-on: ubuntu-latest
-    timeout-minutes: 10
    defaults:
      run:
        working-directory: ml
@@ -155,9 +170,7 @@ jobs:
      # Pourquoi : pas de cache ici. uvx n'installe pas le projet, le verrou n'alimente donc
      # aucune clé de cache ; la seule roue téléchargée est celle de Bandit.
      - name: Installe uv
-        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
-        with:
-          enable-cache: false
+        uses: astral-sh/setup-uv@v7

      - name: Analyse le code livré (bloquant à partir de MEDIUM)
        run: uvx bandit==1.9.4 --recursive enervision_ml --severity-level medium --confidence-level medium
@@ -0,0 +1,172 @@
+name: SonarQube
+
+on:
+  push:
+    paths:
+      - "apps/frontend/**"
+      - "apps/backend/**"
+      - "ml/**"
+      - "etl/airflow/**"
+      - ".github/workflows/sonarqube.yml"
+  pull_request:
+    paths:
+      - "apps/frontend/**"
+      - "apps/backend/**"
+      - "ml/**"
+      - "etl/airflow/**"
+      - ".github/workflows/sonarqube.yml"
+
+
+# Build l'ensemble du projet, puis lance les tests
+# Génère les rapports de couverture, puis lance l'analyse SonarQube
+
+jobs:
+  build-front:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-node@v7
+        with:
+          node-version: 26
+          cache: npm
+          cache-dependency-path: apps/frontend/package-lock.json
+      
+      - run: npm ci 
+        working-directory: apps/frontend
+      - run: npm run build
+        working-directory: apps/frontend
+
+  test-front:  
+    needs: build-front
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-node@v7
+        with:
+          node-version: 26
+          cache: npm
+          cache-dependency-path: apps/frontend/package-lock.json
+
+      - name : Installation des dépendances (Front)
+        run: npm ci 
+        working-directory: apps/frontend
+
+      - name : Lancement des tests et génénration du rapport de couverture (Front)
+        run: npm test --watch=false --code-coverage --coverageReporters=lcov
+        working-directory: apps/frontend
+
+      - name: Upload coverage
+        uses: actions/upload-artifact@v7
+        with:
+          name: frontend-coverage
+          path: apps/frontend/coverage/frontend/lcov.info
+
+  build-back:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - name: Installe uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+          cache-dependency-glob: apps/backend/uv.lock
+      - name: Installe l'interpréteur déclaré par .python-version
+        run: uv python install
+        working-directory: apps/backend
+
+      - name: Synchronise les dépendances sans dévier du verrou
+        run: uv sync --all-groups --frozen
+        working-directory: apps/backend
+
+      - name: Vérifie le formatage
+        run: uv run ruff format --check .
+        working-directory: apps/backend
+
+      - name: Analyse statique
+        run: uv run ruff check --output-format=github .
+        working-directory: apps/backend
+
+      - name: Typage
+        run: uv run mypy app
+        working-directory: apps/backend
+
+
+  test-back:
+    needs: build-back
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - name: Installe uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+          cache-dependency-glob: apps/backend/uv.lock
+
+      - name : Lancement des tests et génénration du rapport de couverture (Back)
+        run: uv run pytest --cov-fail-under=85 --cov-report=xml
+        working-directory: apps/backend
+
+      - name: Upload coverage
+        uses: actions/upload-artifact@v7
+        with:
+          name: backend-coverage
+          path: apps/backend/coverage.xml
+
+  test-ml:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - name: Installe uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+          cache-dependency-glob: ml/uv.lock
+
+      - name: Installe l'interpréteur déclaré par .python-version
+        run: uv python install
+        working-directory: ml
+
+      - name: Synchronise les dépendances sans dévier du verrou
+        run: uv sync --all-groups --frozen
+        working-directory: ml
+
+      - name: Lancement des tests et génération du rapport de couverture (ML)
+        run: uv run pytest --cov-report=xml
+        working-directory: ml
+
+      - name: Upload coverage
+        uses: actions/upload-artifact@v7
+        with:
+          name: ml-coverage
+          path: ml/coverage.xml
+
+  sonarqube:
+    needs: [build-front, build-back, test-front, test-back, test-ml]
+    name: SonarQube
+    # Pourquoi : GitHub ne fournit pas les secrets aux workflows lancés par dependabot[bot].
+    # Sans SONAR_TOKEN le scan échoue sans rien analyser ; build et tests restent joués.
+    if: github.actor != 'dependabot[bot]'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+      - name: Téléchargement du rapport de couverture (Front)
+        uses: actions/download-artifact@v8
+        with:
+          name: frontend-coverage
+          path: apps/frontend/coverage/frontend
+      - name: Téléchargement du rapport de couverture (Back)
+        uses: actions/download-artifact@v8
+        with:
+          name: backend-coverage
+          path: apps/backend
+      - name: Téléchargement du rapport de couverture (ML)
+        uses: actions/download-artifact@v8
+        with:
+          name: ml-coverage
+          path: ml
+      - name: SonarQube Scan
+        uses: SonarSource/sonarqube-scan-action@v8
+        env:
+          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
@@ -22,12 +22,6 @@ apps/frontend/.angular/
 npm-debug.log*
 yarn-error.log*

-# Tests de bout en bout et de charge : rapports générés et identifiants des comptes de test
-playwright-report/
-blob-report/
-tests/e2e/.comptes.json
-tests/load/results/
-
 # Terraform
 .terraform/
 # .terraform.lock.hcl est versionne (pas ignore) pour figer les versions de provider entre contributeurs/CI
@@ -60,6 +54,8 @@ secrets/
 data/raw/*
 !data/raw/.gitkeep
 *.sqlite3
+monitoring/grafana/data/
+monitoring/prometheus/data/

 # ML : jeu de donnees, modeles entraines et suivi MLflow local, tous generes/volumineux
 ml/data/
@@ -75,7 +71,6 @@ etl/airflow/tests/.airflow_home/

 # TLS : certificats du reverse proxy, générés par script ou par certbot
 infra/proxy/tls/*.pem
-infra/proxy/acme/

 # IDE et OS
 .idea/
@@ -2,7 +2,6 @@ BACKEND := apps/backend
 FRONTEND := apps/frontend
 ML := ml
 AIRFLOW := etl/airflow
-E2E := tests/e2e
 COMPOSE_PROD := docker compose -f docker-compose.yml -f docker-compose.prod.yml

 # Piège : sans `export`, une valeur passée en ligne de commande n'atteindrait pas docker compose.
@@ -35,31 +34,6 @@ PG_TEST_DB ?= enervision_test
 TEST_DATABASE_URL ?= postgresql+asyncpg://$(PG_USER):$(PG_PASSWORD)@localhost:$(PG_PORT)/$(PG_TEST_DB)
 ML_TEST_DATABASE_URL ?= postgresql+psycopg://$(PG_USER):$(PG_PASSWORD)@localhost:$(PG_PORT)/$(PG_TEST_DB)

-# Piege : ni make ni ces cibles ne lisent `.env` pour COMPOSE_PROFILES, que docker compose y lit
-# seul. `stack-up` le relit ici pour savoir s'il doit poser le role `supervision` apres migration.
-SUPERVISION := $(findstring monitoring,$(COMPOSE_PROFILES) $(call env-val,COMPOSE_PROFILES))
-SERVICES_SUPERVISION := prometheus alertmanager grafana postgres-exporter node-exporter cadvisor
-GRAFANA_PORT := $(or $(strip $(call env-val,GRAFANA_PORT)),3001)
-PROMETHEUS_PORT := $(or $(strip $(call env-val,PROMETHEUS_PORT)),9090)
-supervision-garde = for cle in APP_METRICS_TOKEN GRAFANA_ADMIN_PASSWORD SUPERVISION_DB_PASSWORD; do \
-		sed -n "s/^$$cle=//p" .env 2>/dev/null | tail -1 | grep -q . \
-			|| { echo "$$cle manquant dans .env, requis par la supervision (cf. .env.example)"; exit 1; }; \
-	done
-MONITORING := docker compose --profile monitoring
-PROMTOOL := $(MONITORING) run --rm --no-deps --entrypoint promtool prometheus
-
-# Piege : `e2e-prepare` ajoute trois sites `demo-*` et des comptes `test-*` a la base visee. Elle
-# vise la base de `make dev` ; ne jamais la lancer contre la recette ou la prod.
-E2E_COMPTES ?= $(CURDIR)/$(E2E)/.comptes.json
-E2E_API ?= http://localhost:$(or $(strip $(call env-val,BACKEND_PORT)),8000)
-
-# Piege : `run` ne demarre que k6, la stack doit deja tourner. `--user` fait ecrire les rapports
-# de tests/load/results avec l'uid du poste, pas celui de l'image (12345), qui n'y a pas acces.
-k6-run = mkdir -p tests/load/results && $(COMPOSE_PROD) --profile load run --rm \
-	--user "$$(id -u):$$(id -g)" -e K6_WEB_DASHBOARD=true \
-	-e K6_WEB_DASHBOARD_EXPORT=/results/$(1)-$$(date +%Y%m%dT%H%M%S).html \
-	k6 run /scripts/$(1).js
-
 # Le jeu historique s'arrete au 31/12/2024 : score et detection ancres a l'horloge reelle ne
 # verraient qu'un parc muet depuis des mois. Cf. `--now` de enervision_ml.score.
 DEMO_NOW ?= 2024-12-31T00:00:00Z
@@ -73,12 +47,10 @@ DEMO_NOW ?= 2024-12-31T00:00:00Z
        migrate migrate-test bootstrap-admin services-up demo-data demo-data-force \
        ml-lint ml-typecheck ml-test ml-check ml-train ml-score mlflow-up detect-alerts recommendations \
        airflow-lint airflow-test airflow-check airflow-up airflow-down airflow-logs \
-        tls-selfsigned tls-acme tls-renew tls-dns01 front-up stack-up stack-down stack-logs \
-        e2e-install e2e-prepare e2e load-smoke load-test load-stress load-limits \
-        db-ensure-supervision monitoring-up monitoring-down monitoring-logs monitoring-check
+        tls-selfsigned tls-acme tls-renew stack-up stack-down stack-logs

 help: ## Liste les cibles disponibles
-	@grep -E '^[a-zA-Z0-9_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "  \033[36m%-16s\033[0m %s\n", $$1, $$2}'
+	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "  \033[36m%-16s\033[0m %s\n", $$1, $$2}'

 install: install-backend install-frontend install-ml install-airflow ## Installe les dépendances backend, frontend, ML et Airflow

@@ -211,10 +183,8 @@ stack-up: ## Démarre la stack derrière le reverse proxy, puis migre la base. P
 		|| { echo "Aucun certificat dans infra/proxy/tls. Lancer d'abord make tls-selfsigned"; exit 1; }
 	@openssl x509 -in infra/proxy/tls/fullchain.pem -noout -checkhost "$(PUBLIC_HOST)" >/dev/null \
 		|| { echo "Le certificat ne couvre pas $(PUBLIC_HOST). Relancer make tls-selfsigned PUBLIC_HOST=$(PUBLIC_HOST) FORCE=1"; exit 1; }
-	@$(if $(SUPERVISION),$(supervision-garde),true)
 	$(COMPOSE_PROD) up -d --build
 	$(COMPOSE_PROD) exec -T backend alembic upgrade head
-	@$(if $(SUPERVISION),$(MAKE) --no-print-directory db-ensure-supervision,true)

 stack-down: ## Arrête la stack complète en conservant les données
 	$(COMPOSE_PROD) stop
@@ -235,82 +205,6 @@ tls-renew: ## Renouvelle les certificats Let's Encrypt et recharge le proxy
 	$(COMPOSE_PROD) --profile acme run --rm certbot renew --deploy-hook /deploy-hook.sh
 	$(COMPOSE_PROD) exec proxy nginx -s reload

-# Pourquoi : la VM n'a qu'une IP privée, que Let's Encrypt ne joint pas ; le défi DNS-01 passe
-# par l'API du fournisseur DNS, dynv6 par défaut (ADR 0018). Le jeton ne passe jamais par `argv`.
-ACME_SH := neilpang/acme.sh:3.1.6
-DNS01_API ?= dns_dynv6
-DNS01_JETON_VAR ?= DYNV6_TOKEN
-DNS01_JETON_FICHIER ?= $(abspath $(CURDIR)/../dns.token)
-acme-sh = docker run --rm --user "$$(id -u):$$(id -g)" -e $(DNS01_JETON_VAR) -e AUTO_UPGRADE=0 \
-	-v "$(CURDIR)/infra/proxy/acme:/acme.sh" -v "$(CURDIR)/infra/proxy/tls:/tls" $(ACME_SH)
-
-# acme.sh sort en 2 quand le certificat n'est pas à renouveler, et recopie le jeton dans
-# acme/account.conf, d'où le chmod. `--dnssleep` : Let's Encrypt valide depuis plusieurs réseaux.
-tls-dns01: ## Certificat Let's Encrypt par DNS-01, renouvelé seulement à échéance. Jeton : ../dns.token
-	@case "$(PUBLIC_HOST)" in *.local | localhost) echo "PUBLIC_HOST=$(PUBLIC_HOST) n'est pas un nom public"; exit 1 ;; esac
-	@test -r "$(DNS01_JETON_FICHIER)" || { echo "Jeton DNS illisible : $(DNS01_JETON_FICHIER)"; exit 1; }
-	@mkdir -p infra/proxy/acme && chmod 700 infra/proxy/acme
-	@$(DNS01_JETON_VAR)="$$(tr -d '[:space:]' < "$(DNS01_JETON_FICHIER)")"; export $(DNS01_JETON_VAR); \
-		$(acme-sh) --issue --server letsencrypt --dns $(DNS01_API) --dnssleep 90 -d "$(PUBLIC_HOST)"; \
-		code=$$?; chmod -R go-rwx infra/proxy/acme; [ $$code -eq 0 ] || [ $$code -eq 2 ] || exit $$code
-	@$(acme-sh) --install-cert --ecc -d "$(PUBLIC_HOST)" \
-		--fullchain-file /tls/fullchain.pem --key-file /tls/privkey.pem
-	@$(COMPOSE_PROD) exec -T proxy nginx -s reload 2>/dev/null \
-		|| echo "Proxy arrêté : il lira le certificat à son démarrage"
-
-front-up: ## Démarre ou recharge le frontal SNI de la VM, sur les ports 80 et 443 de l'hôte
-	docker compose -f infra/front/compose.yml up -d
-	docker compose -f infra/front/compose.yml exec -T front nginx -s reload
-
-e2e-install: ## Installe Playwright et Chromium pour les tests de bout en bout
-	cd $(E2E) && npm ci && npx playwright install chromium
-
-e2e-prepare: ## Sème le jeu de démonstration et crée les comptes de test sur la base de `make dev`
-	docker compose exec -T db psql -U $(PG_USER) -d $(PG_DB) -v ON_ERROR_STOP=1 < db/seeds/demo.sql
-	cd $(BACKEND) && BASE_URL=$(E2E_API) COMPTES_FICHIER=$(E2E_COMPTES) ADMIN_SUPPLEMENTAIRE=1 \
-		../../scripts/comptes-test.sh
-
-e2e: ## Joue les parcours Playwright. E2E_BASE_URL= optionnel (défaut http://localhost:4200)
-	cd $(E2E) && E2E_COMPTES=$(E2E_COMPTES) npx playwright test
-
-load-smoke: ## Tir k6 d'une minute. K6_EMAIL= et K6_PASSWORD= d'un lecteur, K6_BASE_URL= optionnel
-	$(call k6-run,smoke)
-
-load-test: ## Charge nominale k6, 50 utilisateurs pendant 8 minutes. Rapport HTML dans tests/load/results
-	$(call k6-run,charge)
-
-load-stress: ## Monte le débit jusqu'à la rupture de l'API. Sur la VM, la prod partage la machine
-	$(call k6-run,stress)
-
-load-limits: ## Vérifie par le proxy que nginx limite le débit d'une même adresse (429)
-	$(call k6-run,limitation-debit)
-
-# Piege : le mot de passe est lu dans `.env` par le shell et passe a psql sur son entree
-# standard. Developpe par make, il apparaitrait en clair dans la ligne de commande (`ps`).
-db-ensure-supervision: ## Crée ou réaligne le rôle `supervision`, en lecture seule, de Grafana et de l'exportateur
-	@mdp="$$(sed -n 's/^SUPERVISION_DB_PASSWORD=//p' .env 2>/dev/null | tail -1)"; \
-	[ -n "$$mdp" ] || { echo "SUPERVISION_DB_PASSWORD manquant dans .env"; exit 1; }; \
-	{ printf '\\set mot_de_passe %s\n' "$$mdp"; cat db/roles/supervision.sql; } \
-		| docker compose exec -T db psql -U $(PG_USER) -d $(PG_DB) -v ON_ERROR_STOP=1 -v base=$(PG_DB) -q
-
-monitoring-up: ## Démarre la supervision sur la stack en cours : Prometheus, Alertmanager, Grafana, exporteurs
-	@$(supervision-garde)
-	$(MONITORING) up -d --no-deps $(SERVICES_SUPERVISION)
-	@$(MAKE) --no-print-directory db-ensure-supervision
-	@echo "grafana -> http://localhost:$(GRAFANA_PORT)  prometheus -> http://localhost:$(PROMETHEUS_PORT)"
-
-monitoring-down: ## Arrête la supervision en conservant ses données
-	$(MONITORING) stop $(SERVICES_SUPERVISION)
-
-monitoring-logs: ## Suit les journaux de Prometheus, Alertmanager et Grafana
-	$(MONITORING) logs -f prometheus alertmanager grafana
-
-monitoring-check: ## Valide la configuration de supervision et joue les tests des règles d'alerte, comme la CI
-	$(PROMTOOL) check config /etc/prometheus/prometheus.yml
-	$(PROMTOOL) test rules /etc/prometheus/tests/enervision.test.yml
-	$(MONITORING) run --rm --no-deps --entrypoint amtool alertmanager check-config /etc/alertmanager/alertmanager.yml
-	@for tableau in monitoring/grafana/dashboards/*.json; do jq empty "$$tableau" || exit 1; done
-
 db-up: ## Démarre la base PostgreSQL TimescaleDB
 	docker compose up -d db

@@ -27,8 +27,7 @@ Ce que la documentation apporte à chacun : [docs/architecture/00-vue-ensemble.m
 | Infra      | Terraform (k3s single-node)         | `infra/terraform`   | Initialise    |
 | Reverse proxy | Nginx, TLS                       | `infra/proxy`       | En place      |
 | CI/CD      | GitHub Actions                      | `.github/workflows` | En place |
-| Monitoring | Prometheus, Grafana, Alertmanager   | `monitoring`        | En place, profil Compose |
-| Tests e2e et de charge | Playwright, k6              | `tests`             | En place |
+| Monitoring | Prometheus, Grafana, Alertmanager   | `monitoring`        | A initialiser |
 | ML         | LightGBM, MLflow                    | `ml`                | En place |

 Le backend, la base et l'infrastructure (Terraform/k3s) sont initialises a ce stade. Le frontend
@@ -49,8 +48,7 @@ L'etat detaille de chaque brique et les vues d'architecture sont dans
 ├── db/
 │   ├── init/           Bootstrap PostgreSQL + TimescaleDB
 │   ├── migrations/     Migrations SQL versionnees
-│   ├── roles/          Roles PostgreSQL hors schema (supervision)
-│   └── seeds/          Jeu de demonstration des tests
+│   └── seeds/          Jeux de donnees de reference
 ├── etl/airflow/
 │   ├── dags/           DAGs d'orchestration (pipeline ML, alertes, imports, dérive)
 │   ├── plugins/        Operateurs et hooks maison
@@ -66,9 +64,6 @@ L'etat detaille de chaque brique et les vues d'architecture sont dans
 │   ├── prometheus/     Collecte et regles d'alerte
 │   ├── grafana/        Provisioning et dashboards
 │   └── alertmanager/   Routage des alertes
-├── tests/
-│   ├── e2e/            Parcours Playwright contre la stack
-│   └── load/           Scenarios de charge k6
 ├── docs/               ADR et vues d'architecture
 └── scripts/            Outillage local
 ```
@@ -153,25 +148,10 @@ nom de domaine public ne résout vers la machine. Routage, mode ACME et renouvel

 Sur la VM ENI, deux environnements cohabitent, recette sur `dev` et production sur `main`,
 chacun dans son dossier et son projet Compose : `scripts/provision-host.sh` les prépare, le
-workflow `deploy.yml` les redéploie par un runner auto-hébergé, une fois la CI du commit poussé
-verte ([ADR 0014](docs/adr/0014-pipeline-ci-unique-et-deploiement-conditionne.md)). Ports, noms
+workflow `deploy.yml` les redéploie à chaque push par un runner auto-hébergé. Ports, noms
 d'hôte et garde-fous dans [`docs/architecture/10-infra.md`](docs/architecture/10-infra.md) et
 [l'ADR 0009](docs/adr/0009-deux-environnements-compose-sur-la-vm-eni.md).

-## Tests de bout en bout, charge et supervision
-
-| Besoin | Commandes | Détail |
-|---|---|---|
-| Parcours utilisateur (Playwright) | `make e2e-install`, puis `make e2e-prepare e2e` contre `make dev` | [`tests/e2e/README.md`](tests/e2e/README.md) |
-| Tir de charge (k6) | `make load-smoke`, `load-test`, `load-stress`, `load-limits` | [`tests/load/README.md`](tests/load/README.md) |
-| Supervision | `make monitoring-up`, Grafana sur <http://localhost:3001> | [`monitoring/README.md`](monitoring/README.md) |
-
-La CI joue les parcours, un tir de fumée et le contrôle de la limitation de débit à chaque PR
-qui touche l'application, contre la stack de prod derrière le proxy
-([ADR 0015](docs/adr/0015-tests-e2e-et-de-charge-contre-la-stack-compose.md)). La supervision
-est active en prod, à la demande ailleurs
-([ADR 0016](docs/adr/0016-supervision-en-profil-compose.md)).
-
 ## Conventions

 - Branches : `feat/`, `fix/`, `chore/`, `docs/`, `test/` suivi d'un libelle court.
@@ -1,3 +1,8 @@
+# syntax=docker/dockerfile:1
+FROM docker
+COPY --from=docker/buildx-bin /buildx /usr/libexec/docker/cli-plugins/docker-buildx
+RUN docker buildx version
+
 FROM python:3.14-slim AS builder

 COPY --from=ghcr.io/astral-sh/uv:0.11.26 /uv /uvx /bin/
@@ -8,10 +13,8 @@ ENV UV_COMPILE_BYTECODE=1 \

 WORKDIR /app

-RUN --mount=type=cache,target=/root/.cache/uv \
-    --mount=type=bind,source=uv.lock,target=uv.lock \
-    --mount=type=bind,source=pyproject.toml,target=pyproject.toml \
-    uv sync --locked --no-install-project --no-dev --no-build
+COPY uv.lock pyproject.toml /app/
+RUN uv sync --locked --no-install-project --no-dev

 # Le projet lui-meme n'est pas installe (pas de second `uv sync`) : il tourne depuis /app, le
 # repertoire de travail, et rien ne lit ses metadonnees. L'installer imposerait de le construire
@@ -19,6 +22,7 @@ RUN --mount=type=cache,target=/root/.cache/uv \
 # l'installation des dependances n'execute aucun script de build (regle Sonar docker:S8541).
 COPY . /app

+RUN uv sync --locked --no-dev

 FROM python:3.14-slim AS runtime

@@ -16,9 +16,6 @@ EN_TETES: Final[dict[str, str]] = {
    "X-Content-Type-Options": "nosniff",
    "X-Frame-Options": "DENY",
    "Referrer-Policy": "no-referrer",
-    # same-origin : aucun client ne charge l'API en no-cors depuis une autre origine
-    # (proxy.conf.json en dev, reverse proxy nginx ensuite, cf. docs/architecture/20-backend.md).
-    "Cross-Origin-Resource-Policy": "same-origin",
 }

 PREFIXE_AUTHENTIFICATION: Final = "/auth"
@@ -1,7 +1,7 @@
 from functools import lru_cache
 from typing import Literal, Self

-from pydantic import Field, SecretStr, field_validator, model_validator
+from pydantic import Field, SecretStr, model_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict

 Environment = Literal["local", "dev", "staging", "prod"]
@@ -76,13 +76,6 @@ class Settings(BaseSettings):
    expose_api_docs: bool | None = None
    metrics_token: SecretStr | None = None

-    # Compose passe `APP_METRICS_TOKEN` vide quand aucun jeton n'est posé : vide vaut absent, sinon
-    # `/metrics` exigerait un `Bearer` sans valeur et plus rien ne pourrait le scruter.
-    @field_validator("metrics_token", mode="before")
-    @classmethod
-    def _jeton_vide_vaut_absent(cls, valeur: object) -> object:
-        return None if valeur == "" else valeur
-
    @property
    def allowed_origins(self) -> list[str]:
        return [origin.strip() for origin in self.cors_origins.split(",") if origin.strip()]
@@ -1,19 +1,17 @@
 # Contrainte : la réponse de l'API Mock est une entrée hostile, pas une source de confiance.
 # Voir OWASP API10 dans docs/architecture/owasp-traceabilite.md. Rien de ce qu'elle renvoie
 # n'atteint la base sans passer par build_site_row() ou build_reading_row() : seuls les champs
-# attendus sont recopiés, les grandeurs physiques sont bornées par PHYSICAL_BOUNDS, la taille des
-# tableaux est plafonnée par MAX_SITES et par limit_for_window() (dérivé de la fenêtre, jamais
-# fourni par l'appelant), et les lectures dont le timestamp déborde de la fenêtre demandée sont
-# écartées (fetch_readings). Une valeur hors bornes devient NULL et laisse sa trace dans
-# null_reasons plutôt que de lever : le mock émet des anomalies par construction, et raw_data
-# conserve de toute façon la réponse d'origine intacte.
+# attendus sont recopiés, les grandeurs physiques sont bornées par PHYSICAL_BOUNDS et la taille
+# des tableaux est plafonnée par MAX_SITES et par --limit. Une valeur hors bornes devient NULL
+# et laisse sa trace dans null_reasons plutôt que de lever : le mock émet des anomalies par
+# construction, et raw_data conserve de toute façon la réponse d'origine intacte.

 from __future__ import annotations

 import argparse
 import asyncio
 import json
-from datetime import UTC, datetime
+from datetime import datetime
 from typing import Any

 import httpx
@@ -21,7 +19,6 @@ from sqlalchemy import text
 from sqlalchemy.ext.asyncio import AsyncConnection, create_async_engine

 from app.core.config import get_settings
-from app.etl.historical_import import SOURCE_NAME as SOURCE_CSV

 SOURCE_HISTORY = "api_history"

@@ -184,19 +181,6 @@ async def upsert_sites(
    )


-def _timestamp_in_window(reading: dict[str, Any], start_time: datetime, end_time: datetime) -> bool:
-    valeur = reading.get("timestamp")
-    if not isinstance(valeur, str):
-        return False
-
-    try:
-        instant = parse_datetime(valeur)
-    except ValueError:
-        return False
-
-    return start_time <= instant < end_time
-
-
 async def fetch_readings(
    client: httpx.AsyncClient,
    site_id: str,
@@ -224,22 +208,7 @@ async def fetch_readings(
    if len(payload) > limit:
        raise ValueError(f"La réponse /api/v1/readings dépasse la limite demandée de {limit}.")

-    # Le garde-fou `refuse_if_overlaps_historical_dataset` ne vérifie que la fenêtre demandée :
-    # une réponse (bug du mock, ou hostile) dont les `timestamp` débordent de
-    # `[start_time, end_time)` contournerait ce contrôle et écrirait exactement le doublon
-    # inter-source qu'il doit empêcher. Écarter ces lectures ici rend le contrôle par fenêtre
-    # suffisant.
-    dans_la_fenetre = [
-        lecture
-        for lecture in payload
-        if isinstance(lecture, dict) and _timestamp_in_window(lecture, start_time, end_time)
-    ]
-
-    if len(dans_la_fenetre) != len(payload):
-        ecartees = len(payload) - len(dans_la_fenetre)
-        print(f"{site_id}: {ecartees} lecture(s) hors fenêtre écartée(s).")
-
-    return dans_la_fenetre
+    return payload


 def build_reading_row(
@@ -275,36 +244,6 @@ def build_reading_row(
    }


-# `uq_reading_source` autorise deux lignes au même (site_id, timestamp) dès que `source` diffère :
-# sans ce garde-fou, importer une fenêtre déjà couverte par le dataset historique (source='csv')
-# dupliquerait silencieusement chaque point plutôt que de lever une erreur. Ce garde-fou protège
-# l'ingestion ; il ne dit rien de la lecture (`GET /readings` renvoie les deux lignes en cas de
-# doublon malgré tout, cf. la section réconciliation de 40-data.md).
-OVERLAP_CHECK = text(
-    "SELECT count(*) FROM reading WHERE source = :source_csv "
-    "AND timestamp >= :start_time AND timestamp < :end_time"
-)
-
-
-async def refuse_if_overlaps_historical_dataset(
-    connection: AsyncConnection,
-    start_time: datetime,
-    end_time: datetime,
-) -> None:
-    resultat = await connection.execute(
-        OVERLAP_CHECK,
-        {"source_csv": SOURCE_CSV, "start_time": start_time, "end_time": end_time},
-    )
-    nombre = resultat.scalar_one()
-
-    if nombre > 0:
-        raise ValueError(
-            f"La fenêtre [{start_time.isoformat()}, {end_time.isoformat()}) recouvre "
-            f"{nombre} lecture(s) déjà importée(s) du dataset historique (source='{SOURCE_CSV}') : "
-            "import refusé pour éviter un doublon inter-source."
-        )
-
-
 # Le conflit vise l'index unique uq_reading_source plutôt que la table entière : sans cible
 # nommée, DO NOTHING avalerait aussi une violation de clé primaire.
 READING_INSERT = text(
@@ -363,57 +302,41 @@ def build_reading_batch(
    return [build_reading_row(reading) for reading in readings]


-def limit_for_window(start_time: datetime, end_time: datetime) -> int:
-    """Nombre de lectures à demander pour que l'API Mock en rende une par heure, alignée.
-
-    L'API ne renvoie pas un flux à un rythme naturel : elle répartit exactement `limit` lectures,
-    espacées uniformément, sur toute la fenêtre `[start_time, end_time)` demandée, la première
-    au tout début de la fenêtre (vérifié empiriquement). Deux façons d'obtenir une lecture
-    alignée sur l'heure :
-
-    - une fenêtre d'exactement N heures (`start_time` sur l'heure) donne, avec `limit=N`, N
-      lectures espacées d'1h pile, la première à `start_time` : c'est le chemin du backfill
-      manuel (plusieurs jours d'historique en un seul appel).
-    - une fenêtre plus courte qu'une heure, ou qui n'est pas un multiple entier d'heure, ne peut
-      espacer plusieurs lectures d'1h pile (l'espacement de l'API vaut toujours
-      `durée / limit`) : seule `limit=1` reste alignée, la lecture unique atterrissant à
-      `start_time`. C'est le chemin du DAG horaire, dont la fenêtre part de l'heure pile qui
-      précède son déclenchement jusqu'à l'instant du déclenchement lui-même (`:45`), donc plus
-      courte qu'une heure.
-
-    Dans les deux cas, `start_time` doit tomber pile sur l'heure : c'est elle qui ancre
-    l'alignement, jamais `end_time`. Un `limit` plus grand que celui rendu ici fabriquerait des
-    lectures infra-horaires, incompatibles avec les lags positionnels de `build_features`.
-    """
-    if start_time.minute or start_time.second or start_time.microsecond:
-        raise ValueError(
-            f"La fenêtre doit démarrer pile sur l'heure : {start_time.isoformat()} ne l'est pas."
-        )
-
-    duree = end_time - start_time
-    heures, reste = divmod(duree.total_seconds(), 3600)
-
-    # Fenêtre plus courte qu'une heure, ou pas un multiple entier : aucun `limit` supérieur à 1
-    # n'espacerait ses lectures d'1h pile (l'espacement vaut toujours durée / limit). Seule la
-    # lecture unique, ancrée sur `start_time`, reste alignée.
-    limit = int(heures) if reste == 0 and heures >= 1 else 1
-
-    if limit > MAX_LIMIT:
-        raise ValueError(
-            f"La fenêtre demandée couvre {limit}h, au-delà du plafond de {MAX_LIMIT} "
-            "lectures accepté par l'API Mock."
-        )
-
-    return limit
-
-
 async def import_mock_api_history(
    start_time: datetime,
    end_time: datetime,
+    limit: int,
    dry_run: bool,
 ) -> None:
    settings = get_settings()
-    limit = limit_for_window(start_time, end_time)
+
+    async with create_mock_api_client() as client:
+        sites = await fetch_sites(client)
+
+        print(f"Sites récupérés : {len(sites)}")
+
+        all_readings: list[dict[str, Any]] = []
+
+        for site in sites:
+            site_id = read_text(site, "site_id")
+
+            readings = await fetch_readings(
+                client=client,
+                site_id=site_id,
+                start_time=start_time,
+                end_time=end_time,
+                limit=limit,
+            )
+
+            print(f"{site_id}: {len(readings)} lectures")
+
+            all_readings.extend(readings)
+
+    print(f"Lectures récupérées : {len(all_readings)}")
+
+    if dry_run:
+        print("Dry-run terminé : aucune donnée écrite.")
+        return

    engine = create_async_engine(
        str(settings.database_url),
@@ -421,39 +344,6 @@ async def import_mock_api_history(
    )

    try:
-        # Garde-fou d'abord, y compris en dry-run : il est en lecture seule, et annoncer un
-        # succès pour une fenêtre que l'import réel refusera serait trompeur.
-        async with engine.connect() as connection:
-            await refuse_if_overlaps_historical_dataset(connection, start_time, end_time)
-
-        async with create_mock_api_client() as client:
-            sites = await fetch_sites(client)
-
-            print(f"Sites récupérés : {len(sites)}")
-
-            all_readings: list[dict[str, Any]] = []
-
-            for site in sites:
-                site_id = read_text(site, "site_id")
-
-                readings = await fetch_readings(
-                    client=client,
-                    site_id=site_id,
-                    start_time=start_time,
-                    end_time=end_time,
-                    limit=limit,
-                )
-
-                print(f"{site_id}: {len(readings)} lectures")
-
-                all_readings.extend(readings)
-
-        print(f"Lectures récupérées : {len(all_readings)}")
-
-        if dry_run:
-            print("Dry-run terminé : aucune donnée écrite.")
-            return
-
        async with engine.begin() as connection:
            await upsert_sites(
                connection,
@@ -475,14 +365,7 @@ async def import_mock_api_history(


 def parse_datetime(value: str) -> datetime:
-    # Sans fuseau, l'API le traite comme reçu, telle quelle, mais l'encodeur `timestamptz`
-    # d'asyncpg lirait un datetime naif dans le fuseau *local du processus* (correct dans le
-    # conteneur Airflow en UTC, décalé de 1-2h pour un import manuel lancé depuis un poste en
-    # Europe/Paris). Poser `tzinfo=UTC` explicitement, même pattern que `_vers_utc()` dans
-    # `app/services/reading.py`, garantit que la borne envoyée à l'API et celle comparée en SQL
-    # (refuse_if_overlaps_historical_dataset) désignent le même instant.
-    instant = datetime.fromisoformat(value.replace("Z", "+00:00"))
-    return instant if instant.tzinfo is not None else instant.replace(tzinfo=UTC)
+    return datetime.fromisoformat(value.replace("Z", "+00:00"))


 def parse_args() -> argparse.Namespace:
@@ -500,6 +383,12 @@ def parse_args() -> argparse.Namespace:
        type=parse_datetime,
    )

+    parser.add_argument(
+        "--limit",
+        type=int,
+        default=MAX_LIMIT,
+    )
+
    parser.add_argument(
        "--dry-run",
        action="store_true",
@@ -511,6 +400,9 @@ def parse_args() -> argparse.Namespace:
 def main() -> None:
    args = parse_args()

+    if args.limit < 1 or args.limit > MAX_LIMIT:
+        raise ValueError(f"--limit doit être compris entre 1 et {MAX_LIMIT}.")
+
    if args.start_time >= args.end_time:
        raise ValueError("--start-time doit être antérieur à --end-time.")

@@ -518,6 +410,7 @@ def main() -> None:
        import_mock_api_history(
            start_time=args.start_time,
            end_time=args.end_time,
+            limit=args.limit,
            dry_run=args.dry_run,
        )
    )
@@ -6,8 +6,7 @@ from fastapi import Depends, FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.openapi.docs import get_redoc_html, get_swagger_ui_html
 from fastapi.staticfiles import StaticFiles
-from prometheus_client import CollectorRegistry, GCCollector, PlatformCollector, ProcessCollector
-from prometheus_fastapi_instrumentator import Instrumentator, metrics
+from prometheus_fastapi_instrumentator import Instrumentator
 from starlette.requests import Request
 from starlette.responses import HTMLResponse

@@ -38,16 +37,6 @@ async def lifespan(_: FastAPI) -> AsyncIterator[None]:
    await get_engine().dispose()


-# Pourquoi : le registre global n'accepte chaque métrique qu'une fois. Toute application créée
-# après la première, dans les tests notamment, n'aurait rien mesuré.
-def _registre_de_metriques() -> CollectorRegistry:
-    registre = CollectorRegistry()
-    ProcessCollector(registry=registre)
-    PlatformCollector(registry=registre)
-    GCCollector(registry=registre)
-    return registre
-
-
 def create_app(settings: Settings | None = None) -> FastAPI:
    resolved = settings or get_settings()
    configure_logging(resolved)
@@ -113,14 +102,7 @@ def create_app(settings: Settings | None = None) -> FastAPI:

    register_error_handlers(application)

-    # Les sondes de santé tombent toutes les 30 s : comptées, elles fausseraient latences et débit.
-    # Seaux fins autour du seuil de charge (p95 < 500 ms, ADR 0015), route par route.
-    registre = _registre_de_metriques()
-    Instrumentator(
-        excluded_handlers=["/metrics", f"{resolved.api_prefix}/health/.*"], registry=registre
-    ).add(
-        metrics.default(latency_lowr_buckets=(0.05, 0.1, 0.25, 0.5, 1, 2.5), registry=registre)
-    ).instrument(application).expose(
+    Instrumentator().instrument(application).expose(
        application,
        endpoint="/metrics",
        include_in_schema=False,
@@ -23,9 +23,8 @@ async def interroge(
        ("x-content-type-options", "nosniff"),
        ("x-frame-options", "DENY"),
        ("referrer-policy", "no-referrer"),
-        ("cross-origin-resource-policy", "same-origin"),
    ],
-    ids=["nosniff", "anti_iframe", "referrer", "corp"],
+    ids=["nosniff", "anti_iframe", "referrer"],
 )
 async def test_every_response_carries_the_security_headers(
    client: AsyncClient, entete: str, valeur: str
@@ -72,20 +71,6 @@ async def test_metrics_stay_open_when_no_token_is_configured(client: AsyncClient
    assert response.status_code == 200


-async def test_an_empty_metrics_token_means_no_token() -> None:
-    assert (await interroge({"metrics_token": ""}, "/metrics")).status_code == 200
-
-
-async def test_metrics_ignore_health_probes_but_count_business_routes(client: AsyncClient) -> None:
-    await client.get("/api/v1/health/live")
-    await client.get("/api/v1/sites")
-
-    exposition = (await client.get("/metrics")).text
-
-    assert 'handler="/api/v1/health/live"' not in exposition
-    assert 'handler="/api/v1/sites"' in exposition
-
-
 async def test_metrics_demand_the_token_once_one_is_configured() -> None:
    surcharges = {"metrics_token": "un-jeton-de-supervision-assez-long"}

@@ -1,6 +1,6 @@
 import json
 import sys
-from datetime import UTC, datetime
+from datetime import datetime
 from types import SimpleNamespace
 from typing import Any
 from unittest.mock import AsyncMock, MagicMock
@@ -110,8 +110,8 @@ async def test_fetch_readings_sends_expected_query_parameters() -> None:

    transport = MockTransport(handler)

-    start_time = datetime.fromisoformat("2024-06-15T12:00:00+00:00")
-    end_time = datetime.fromisoformat("2024-06-15T13:00:00+00:00")
+    start_time = datetime.fromisoformat("2024-06-15T12:00:00")
+    end_time = datetime.fromisoformat("2024-06-15T13:00:00")

    async with AsyncClient(
        transport=transport,
@@ -127,61 +127,11 @@ async def test_fetch_readings_sends_expected_query_parameters() -> None:

    assert len(readings) == 1
    assert captured_params["site_id"] == "SITE001"
-    assert captured_params["start_time"] == "2024-06-15T12:00:00+00:00"
-    assert captured_params["end_time"] == "2024-06-15T13:00:00+00:00"
+    assert captured_params["start_time"] == "2024-06-15T12:00:00"
+    assert captured_params["end_time"] == "2024-06-15T13:00:00"
    assert captured_params["limit"] == "60"


-async def test_fetch_readings_discards_a_reading_outside_the_requested_window() -> None:
-    # Le garde-fou `refuse_if_overlaps_historical_dataset` ne vérifie que la fenêtre demandée :
-    # une réponse dont un `timestamp` déborde de `[start_time, end_time)` (bug du mock, ou
-    # hostile) contournerait ce contrôle si elle atteignait la base telle quelle.
-    dans_la_fenetre = make_reading()
-    dans_la_fenetre["timestamp"] = "2024-06-15T12:00:00Z"
-
-    hors_fenetre = make_reading()
-    hors_fenetre["timestamp"] = "2023-01-01T00:00:00Z"
-
-    def handler(request: Request) -> Response:
-        return Response(status_code=200, json=[dans_la_fenetre, hors_fenetre])
-
-    async with AsyncClient(
-        transport=MockTransport(handler),
-        base_url="https://mock.test",
-    ) as client:
-        readings = await fetch_readings(
-            client=client,
-            site_id="SITE001",
-            start_time=datetime.fromisoformat("2024-06-15T12:00:00+00:00"),
-            end_time=datetime.fromisoformat("2024-06-15T13:00:00+00:00"),
-            limit=2,
-        )
-
-    assert readings == [dans_la_fenetre]
-
-
-async def test_fetch_readings_discards_a_reading_with_an_unparseable_timestamp() -> None:
-    invalide = make_reading()
-    invalide["timestamp"] = "pas une date"
-
-    def handler(request: Request) -> Response:
-        return Response(status_code=200, json=[invalide])
-
-    async with AsyncClient(
-        transport=MockTransport(handler),
-        base_url="https://mock.test",
-    ) as client:
-        readings = await fetch_readings(
-            client=client,
-            site_id="SITE001",
-            start_time=datetime.fromisoformat("2024-06-15T12:00:00+00:00"),
-            end_time=datetime.fromisoformat("2024-06-15T13:00:00+00:00"),
-            limit=1,
-        )
-
-    assert readings == []
-
-
 async def test_fetch_readings_rejects_non_list_response() -> None:
    def handler(request: Request) -> Response:
        return Response(
@@ -202,8 +152,8 @@ async def test_fetch_readings_rejects_non_list_response() -> None:
            await fetch_readings(
                client=client,
                site_id="SITE001",
-                start_time=datetime.fromisoformat("2024-06-15T12:00:00+00:00"),
-                end_time=datetime.fromisoformat("2024-06-15T13:00:00+00:00"),
+                start_time=datetime.fromisoformat("2024-06-15T12:00:00"),
+                end_time=datetime.fromisoformat("2024-06-15T13:00:00"),
                limit=60,
            )

@@ -225,8 +175,8 @@ async def test_fetch_readings_raises_on_http_error() -> None:
            await fetch_readings(
                client=client,
                site_id="SITE999",
-                start_time=datetime.fromisoformat("2024-06-15T12:00:00+00:00"),
-                end_time=datetime.fromisoformat("2024-06-15T13:00:00+00:00"),
+                start_time=datetime.fromisoformat("2024-06-15T12:00:00"),
+                end_time=datetime.fromisoformat("2024-06-15T13:00:00"),
                limit=60,
            )

@@ -407,100 +357,6 @@ async def test_upsert_sites_with_empty_list_does_nothing() -> None:
    connection.execute.assert_not_awaited()


-async def test_refuse_if_overlaps_historical_dataset_lets_a_clear_window_through() -> None:
-    connection = AsyncMock()
-    connection.execute.return_value.scalar_one = MagicMock(return_value=0)
-
-    await mock_api_import.refuse_if_overlaps_historical_dataset(
-        connection,
-        datetime.fromisoformat("2026-01-01T00:00:00+00:00"),
-        datetime.fromisoformat("2026-01-01T01:00:00+00:00"),
-    )
-
-    connection.execute.assert_awaited_once()
-
-
-async def test_refuse_if_overlaps_historical_dataset_rejects_a_window_already_in_the_csv() -> None:
-    connection = AsyncMock()
-    connection.execute.return_value.scalar_one = MagicMock(return_value=5)
-
-    with pytest.raises(ValueError, match="doublon inter-source"):
-        await mock_api_import.refuse_if_overlaps_historical_dataset(
-            connection,
-            datetime.fromisoformat("2023-06-15T12:00:00+00:00"),
-            datetime.fromisoformat("2023-06-15T13:00:00+00:00"),
-        )
-
-
-def test_limit_for_window_returns_one_per_hour() -> None:
-    limite = mock_api_import.limit_for_window(
-        datetime.fromisoformat("2026-09-02T12:00:00+00:00"),
-        datetime.fromisoformat("2026-09-23T12:00:00+00:00"),
-    )
-
-    assert limite == 21 * 24
-
-
-def test_limit_for_window_falls_back_to_one_reading_under_an_hour() -> None:
-    # Le DAG horaire (`:45`) demande desormais [heure pile precedente, instant du declenchement) :
-    # une fenetre plus courte qu'une heure, dont l'espacement `duree/limit` ne peut jamais valoir
-    # 1h pile pour plus d'une lecture. Seule `limit=1`, ancree sur `start_time`, reste alignee.
-    limite = mock_api_import.limit_for_window(
-        datetime.fromisoformat("2026-09-02T12:00:00+00:00"),
-        datetime.fromisoformat("2026-09-02T12:45:00+00:00"),
-    )
-
-    assert limite == 1
-
-
-def test_limit_for_window_falls_back_to_one_reading_for_a_non_whole_hour_span() -> None:
-    # Meme raisonnement pour une fenetre de plus d'une heure mais qui n'en est pas un multiple
-    # entier : aucun `limit > 1` ne donnerait un espacement d'1h pile.
-    limite = mock_api_import.limit_for_window(
-        datetime.fromisoformat("2026-09-02T12:00:00+00:00"),
-        datetime.fromisoformat("2026-09-02T13:30:00+00:00"),
-    )
-
-    assert limite == 1
-
-
-def test_limit_for_window_rejects_a_start_time_not_on_the_hour() -> None:
-    with pytest.raises(ValueError, match="pile sur l'heure"):
-        mock_api_import.limit_for_window(
-            datetime.fromisoformat("2026-09-02T12:05:00+00:00"),
-            datetime.fromisoformat("2026-09-02T13:05:00+00:00"),
-        )
-
-
-def test_limit_for_window_rejects_a_window_above_the_api_cap() -> None:
-    with pytest.raises(ValueError, match="au-delà du plafond"):
-        mock_api_import.limit_for_window(
-            datetime.fromisoformat("2020-01-01T00:00:00+00:00"),
-            datetime.fromisoformat("2020-03-01T00:00:00+00:00"),
-        )
-
-
-def _mock_engine(*, overlap_count: int = 0) -> tuple[MagicMock, AsyncMock]:
-    """Engine dont `.connect()` (garde-fou) et `.begin()` (écriture) rendent tous deux la même
-    connexion, dont `scalar_one()` renvoie `overlap_count` : `import_mock_api_history` ouvre
-    désormais le garde-fou via `.connect()`, y compris en dry-run."""
-    connection = AsyncMock()
-    connection.execute.return_value.scalar_one = MagicMock(return_value=overlap_count)
-
-    def _context() -> MagicMock:
-        context = MagicMock()
-        context.__aenter__ = AsyncMock(return_value=connection)
-        context.__aexit__ = AsyncMock(return_value=None)
-        return context
-
-    engine = MagicMock()
-    engine.connect.return_value = _context()
-    engine.begin.return_value = _context()
-    engine.dispose = AsyncMock()
-
-    return engine, connection
-
-
 async def test_import_mock_api_history_dry_run_does_not_write(
    monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -540,24 +396,22 @@ async def test_import_mock_api_history_dry_run_does_not_write(
        ),
    )

-    engine, connection = _mock_engine(overlap_count=0)
+    create_engine_mock = MagicMock()

    monkeypatch.setattr(
        mock_api_import,
        "create_async_engine",
-        MagicMock(return_value=engine),
+        create_engine_mock,
    )

    await mock_api_import.import_mock_api_history(
-        start_time=datetime.fromisoformat("2024-06-15T12:00:00+00:00"),
-        end_time=datetime.fromisoformat("2024-06-15T13:00:00+00:00"),
+        start_time=datetime.fromisoformat("2024-06-15T12:00:00"),
+        end_time=datetime.fromisoformat("2024-06-15T13:00:00"),
+        limit=60,
        dry_run=True,
    )

-    # Le garde-fou tourne quand même (lecture seule), mais aucune écriture n'a lieu.
-    connection.execute.assert_awaited_once()
-    engine.begin.assert_not_called()
-    engine.dispose.assert_awaited_once()
+    create_engine_mock.assert_not_called()


 async def test_import_mock_api_history_loads_data(
@@ -599,8 +453,23 @@ async def test_import_mock_api_history_loads_data(
        ),
    )

-    engine, connection = _mock_engine(overlap_count=0)
-    create_engine_mock = MagicMock(return_value=engine)
+    connection = AsyncMock()
+
+    transaction_context = MagicMock()
+    transaction_context.__aenter__ = AsyncMock(
+        return_value=connection,
+    )
+    transaction_context.__aexit__ = AsyncMock(
+        return_value=None,
+    )
+
+    engine = MagicMock()
+    engine.begin.return_value = transaction_context
+    engine.dispose = AsyncMock()
+
+    create_engine_mock = MagicMock(
+        return_value=engine,
+    )

    upsert_sites_mock = AsyncMock()

@@ -617,8 +486,9 @@ async def test_import_mock_api_history_loads_data(
    )

    await mock_api_import.import_mock_api_history(
-        start_time=datetime.fromisoformat("2024-06-15T12:00:00+00:00"),
-        end_time=datetime.fromisoformat("2024-06-15T13:00:00+00:00"),
+        start_time=datetime.fromisoformat("2024-06-15T12:00:00"),
+        end_time=datetime.fromisoformat("2024-06-15T13:00:00"),
+        limit=60,
        dry_run=False,
    )

@@ -632,39 +502,7 @@ async def test_import_mock_api_history_loads_data(
        [make_site()],
    )

-    # Un appel pour le garde-fou (via .connect()), un pour READING_INSERT (via .begin()).
-    assert connection.execute.await_count == 2
-    dernier_appel = connection.execute.await_args_list[-1]
-    assert dernier_appel.args[0] is READING_INSERT
-    engine.dispose.assert_awaited_once()
-
-
-async def test_import_mock_api_history_refuses_when_it_overlaps_the_historical_dataset(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(
-        mock_api_import,
-        "get_settings",
-        lambda: SimpleNamespace(database_url="postgresql+asyncpg://test:test@localhost/test"),
-    )
-
-    engine, connection = _mock_engine(overlap_count=3)
-    monkeypatch.setattr(mock_api_import, "create_async_engine", MagicMock(return_value=engine))
-
-    # Le garde-fou tourne avant tout appel à l'API Mock : create_mock_api_client() ne doit
-    # jamais être invoqué pour une fenêtre refusée.
-    create_client_mock = MagicMock()
-    monkeypatch.setattr(mock_api_import, "create_mock_api_client", create_client_mock)
-
-    with pytest.raises(ValueError, match="doublon inter-source"):
-        await mock_api_import.import_mock_api_history(
-            start_time=datetime.fromisoformat("2023-06-15T12:00:00+00:00"),
-            end_time=datetime.fromisoformat("2023-06-15T13:00:00+00:00"),
-            dry_run=False,
-        )
-
    connection.execute.assert_awaited_once()
-    create_client_mock.assert_not_called()
    engine.dispose.assert_awaited_once()


@@ -678,23 +516,6 @@ def test_parse_datetime_accepts_z_suffix() -> None:
    )


-def test_parse_datetime_attaches_utc_to_a_naive_string() -> None:
-    # `--start-time`/`--end-time` du DAG sont formatés sans fuseau (Jinja `strftime`) : sans ce
-    # comportement, l'encodeur `timestamptz` d'asyncpg lirait le datetime naïf dans le fuseau
-    # *local du processus*, pas UTC, et le garde-fou comparerait une autre fenêtre que celle
-    # envoyée à l'API.
-    result = mock_api_import.parse_datetime("2024-06-15T12:00:00")
-
-    assert result == datetime.fromisoformat("2024-06-15T12:00:00+00:00")
-    assert result.tzinfo is UTC
-
-
-def test_parse_datetime_keeps_a_non_utc_offset_as_is() -> None:
-    result = mock_api_import.parse_datetime("2024-06-15T12:00:00+02:00")
-
-    assert result == datetime.fromisoformat("2024-06-15T12:00:00+02:00")
-
-
 def test_parse_args_reads_cli_parameters(
    monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -707,6 +528,8 @@ def test_parse_args_reads_cli_parameters(
            "2024-06-15T12:00:00Z",
            "--end-time",
            "2024-06-15T13:00:00Z",
+            "--limit",
+            "60",
            "--dry-run",
        ],
    )
@@ -719,9 +542,34 @@ def test_parse_args_reads_cli_parameters(
    assert args.end_time == datetime.fromisoformat(
        "2024-06-15T13:00:00+00:00",
    )
+    assert args.limit == 60
    assert args.dry_run is True


+def test_main_rejects_limit_out_of_bounds(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        sys,
+        "argv",
+        [
+            "mock_api_import",
+            "--start-time",
+            "2024-06-15T12:00:00Z",
+            "--end-time",
+            "2024-06-15T13:00:00Z",
+            "--limit",
+            "0",
+        ],
+    )
+
+    with pytest.raises(
+        ValueError,
+        match="--limit doit être compris entre 1 et 1000",
+    ):
+        mock_api_import.main()
+
+
 def test_main_rejects_invalid_period(
    monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -734,6 +582,8 @@ def test_main_rejects_invalid_period(
            "2024-06-15T14:00:00Z",
            "--end-time",
            "2024-06-15T13:00:00Z",
+            "--limit",
+            "60",
        ],
    )

@@ -762,6 +612,7 @@ def test_main_runs_import(
        lambda: SimpleNamespace(
            start_time=start_time,
            end_time=end_time,
+            limit=60,
            dry_run=True,
        ),
    )
@@ -777,6 +628,7 @@ def test_main_runs_import(
    import_mock.assert_awaited_once_with(
        start_time=start_time,
        end_time=end_time,
+        limit=60,
        dry_run=True,
    )

@@ -821,8 +673,8 @@ async def test_fetch_readings_rejects_a_response_above_the_requested_limit() ->
            await fetch_readings(
                client=client,
                site_id="SITE001",
-                start_time=datetime.fromisoformat("2024-06-15T12:00:00+00:00"),
-                end_time=datetime.fromisoformat("2024-06-15T13:00:00+00:00"),
+                start_time=datetime.fromisoformat("2024-06-15T12:00:00"),
+                end_time=datetime.fromisoformat("2024-06-15T13:00:00"),
                limit=2,
            )

@@ -26,20 +26,28 @@ RUN npm run build
 FROM nginx:1.31-alpine AS runner

 # Copie de la configuration de nginx
-COPY --chown=root:root --chmod=755 nginx.conf /etc/nginx/nginx.conf
+COPY --chown=root:root nginx.conf /etc/nginx/nginx.conf
+RUN chmod 755 /etc/nginx/nginx.conf

 # Copy the static build output from the build stage to Nginx's default HTML serving directory
-COPY --chown=root:root --chmod=755 --from=builder /app/dist/*/browser /usr/share/nginx/html
+COPY --chown=root:root --from=builder /app/dist/frontend/browser /usr/share/nginx/html
+RUN chmod 755 /usr/share/nginx/html
+

 # Create necessary directories with proper permissions for nginx
 RUN mkdir -p /var/log/nginx /var/cache/nginx && \
-    chown -R nginx:nginx /var/log/nginx /var/cache/nginx /usr/share/nginx/html
+    chown -R nginx:nginx /var/log/nginx /var/cache/nginx /usr/share/nginx/html &&\
+    chmod 755 /var/log/nginx /var/log
+
+# Permissions appropriées
+RUN find /usr/share/nginx/html -type f -exec chmod 644 {} \; && \
+    find /usr/share/nginx/html -type d -exec chmod 755 {} \; && \
+    chown -R nginx:nginx /var/log/nginx /var/cache/nginx

 # Use a non-root user for security best practices
 USER nginx

 # Frontend : port 3000
-# Backend : port 8000
 EXPOSE 3000

 # Start Nginx directly with custom config
@@ -86,9 +86,3 @@ describe('MonComposant', () => {
 - Un fichier ou un dossier seulement :
  `npx ng test --watch=false --coverage=false --include=src/app/core/services/alerts.service.spec.ts`
  (répéter `--include` pour plusieurs cibles ; un dossier joue tous ses specs)
-
-## Au-delà des tests unitaires
-Les parcours utilisateur complets (connexion, rôles, sites, recommandations, alertes) sont
-testés de bout en bout par Playwright, contre l'API et le proxy réels : voir
-[tests/e2e/README.md](../../tests/e2e/README.md). Un élément sans rôle ni libellé stable que ces
-parcours doivent viser reçoit un `data-testid`.
@@ -1,5 +1,5 @@
 worker_processes auto;
-error_log /var/log/nginx/error.log warn;
+error_log /dev/null warn;  # ← Envoyer les logs vers /dev/null
 pid /tmp/nginx.pid;

 events {
@@ -9,15 +9,14 @@ events {
 http {
    include /etc/nginx/mime.types;
    default_type application/octet-stream;
+    access_log /dev/null;  # ← Idem pour access logs

    sendfile on;
    keepalive_timeout 65;

-
    server {
        listen 3000;
        server_name _;
-
        root /usr/share/nginx/html;
        index index.html;

@@ -29,4 +28,4 @@ http {
            deny all;
        }
    }
-}
+}
@@ -4,10 +4,10 @@
  "scripts": {
    "ng": "ng",
    "start": "ng serve",
-    "build": "ng build",
+    "build": "node node_modules/@angular/cli/bin/ng.js build",
    "watch": "ng build --watch --configuration development",
    "test": "ng test",
-    "test:ci": "ng test --watch=false"
+    "test:ci": "ng test --watch=false" 
  },
  "private": true,
  "packageManager": "npm@11.19.0",
@@ -0,0 +1,18 @@
+sonar.projectKey=ProjetPiscine_EnerVision
+sonar.organization=groupe3-ener-vision
+sonar.sourceEncoding=UTF-8
+
+#  Dossier contenant le code source
+sonar.sources=apps/frontend/src,apps/backend/app
+sonar.tests=apps/backend/tests
+
+#  Liste des fichiers et dossiers à exclure de l'analyse
+#  Liste des fichiers et dossiers à exclure de l'analyse
+sonar.exclusions=**/node_modules/**,**/dist/**,**/*.spec.js,**/*.test.js,github,db,ml,docker-compose.yml,**/**/Dockerfile,**/**/proxy.conf.json,**/**/package.json,**/**/angular.json
+
+#  Chemin vers le rapport de couverture de code
+#  Fichier généré par Vitest
+#  Chemin vers le rapport de couverture de code
+#  Fichier généré par Vitest
+sonar.javascript.lcov.reportPaths=apps/frontend/coverage/frontend/lcov.info
+sonar.python.coverage.reportPaths=apps/backend/cov.info
@@ -43,31 +43,6 @@ describe('AuthService', () => {
    expect(service.isAuthenticated()).toBe(true);
  });

-  it('garde le mot de passe provisoire pour un seul changement quand il doit être changé', () => {
-    service.login({ email: 'a@a.com', password: 'Provisoire' }).subscribe();
-    httpMock.expectOne(`${environment.apiUrl}/auth/login`).flush({
-      ...tokenResponse,
-      principal: { ...tokenResponse.principal, must_change_password: true },
-    });
-
-    expect(service.takeProvisionalPassword()).toBe('Provisoire');
-    expect(service.takeProvisionalPassword()).toBeNull();
-  });
-
-  it('ne garde aucun mot de passe quand il est déjà définitif, ni après la fin de session', () => {
-    service.login({ email: 'a@a.com', password: 'Definitif' }).subscribe();
-    httpMock.expectOne(`${environment.apiUrl}/auth/login`).flush(tokenResponse);
-    expect(service.takeProvisionalPassword()).toBeNull();
-
-    service.login({ email: 'a@a.com', password: 'Provisoire' }).subscribe();
-    httpMock.expectOne(`${environment.apiUrl}/auth/login`).flush({
-      ...tokenResponse,
-      principal: { ...tokenResponse.principal, must_change_password: true },
-    });
-    service.clearSession();
-    expect(service.takeProvisionalPassword()).toBeNull();
-  });
-
  it('efface la session au logout', () => {
    service.login({ email: 'a@a.com', password: 'secret' }).subscribe();
    httpMock.expectOne(`${environment.apiUrl}/auth/login`).flush(tokenResponse);
@@ -19,9 +19,6 @@ export class AuthService {
  // mémoire. Un rechargement de page le perd, c'est voulu par le contrat.
  private accessTokenSignal = signal<string | null>(null);
  private principalSignal = signal<Principal | null>(null);
-  // Pourquoi : redemander le mot de passe provisoire qu'on vient de vérifier laisse un gestionnaire
-  // de mots de passe y coller un ancien mot de passe du site, et `/auth/password` répond 401.
-  private provisionalPassword: string | null = null;

  readonly principal = this.principalSignal.asReadonly();
  readonly isAuthenticated = computed(() => this.principalSignal() !== null);
@@ -40,26 +37,12 @@ export class AuthService {
  clearSession(): void {
    this.accessTokenSignal.set(null);
    this.principalSignal.set(null);
-    this.provisionalPassword = null;
  }

  login(credentials: LoginRequest): Observable<TokenResponse> {
    return this.http
      .post<TokenResponse>(`${environment.apiUrl}/auth/login`, credentials, { withCredentials: true })
-      .pipe(
-        tap((response) => {
-          this.setSession(response);
-          this.provisionalPassword = response.principal.must_change_password
-            ? credentials.password
-            : null;
-        })
-      );
-  }
-
-  takeProvisionalPassword(): string | null {
-    const password = this.provisionalPassword;
-    this.provisionalPassword = null;
-    return password;
+      .pipe(tap((response) => this.setSession(response)));
  }

  // Un seul rafraîchissement en vol à la fois, partagé entre tous les
@@ -7,18 +7,14 @@
        Votre mot de passe est provisoire, vous devez le modifier avant de continuer
      </p>

-      <input hidden type="email" autocomplete="username" [value]="email" readonly />
-
-      @if (asksCurrentPassword()) {
-        <label class="form-label" for="current_password">Mot de passe actuel</label>
-        <input
-          id="current_password"
-          class="form-input"
-          type="password"
-          formControlName="current_password"
-          autocomplete="current-password"
-        />
-      }
+      <label class="form-label" for="current_password">Mot de passe actuel</label>
+      <input
+        id="current_password"
+        class="form-input"
+        type="password"
+        formControlName="current_password"
+        autocomplete="current-password"
+      />

      <label class="form-label" for="new_password">Nouveau mot de passe</label>
      <input
@@ -28,7 +24,7 @@
        formControlName="new_password"
        autocomplete="new-password"
      />
-      <app-password-requirements [password]="newPassword()" />
+      <span class="form-hint">{{ passwordHint }}</span>

      @if (errorMessage()) {
        <ev-alert severity="danger">{{ errorMessage() }}</ev-alert>
@@ -1,29 +1,17 @@
 import { TestBed } from '@angular/core/testing';
 import { ReactiveFormsModule } from '@angular/forms';
 import { Router } from '@angular/router';
-import { HttpErrorResponse } from '@angular/common/http';
-import { signal } from '@angular/core';
 import { of, throwError } from 'rxjs';
 import { vi } from 'vitest';
 import { ChangePassword } from './change-password';
 import { AuthService } from '../../../core/services/auth.service';

-const NOUVEAU = 'Un-nouveau-mot-de-passe1!';
-
 describe('ChangePassword', () => {
-  let authMock: {
-    changePassword: ReturnType<typeof vi.fn>;
-    takeProvisionalPassword: ReturnType<typeof vi.fn>;
-    principal: ReturnType<typeof signal>;
-  };
+  let authMock: { changePassword: ReturnType<typeof vi.fn> };
  let routerMock: { navigate: ReturnType<typeof vi.fn> };

  beforeEach(async () => {
-    authMock = {
-      changePassword: vi.fn(),
-      takeProvisionalPassword: vi.fn().mockReturnValue(null),
-      principal: signal({ email: 'johan@enervision.fr' }),
-    };
+    authMock = { changePassword: vi.fn() };
    routerMock = { navigate: vi.fn() };

    await TestBed.configureTestingModule({
@@ -35,10 +23,6 @@ describe('ChangePassword', () => {
    }).compileComponents();
  });

-  function champActuel(fixture: { nativeElement: HTMLElement }): HTMLInputElement | null {
-    return fixture.nativeElement.querySelector('#current_password');
-  }
-
  it('ne soumet pas si le formulaire est invalide (mot de passe trop court)', () => {
    const fixture = TestBed.createComponent(ChangePassword);
    const component = fixture.componentInstance;
@@ -60,7 +44,7 @@ describe('ChangePassword', () => {
  it('redirige vers /dashboard après un changement réussi', () => {
    const fixture = TestBed.createComponent(ChangePassword);
    const component = fixture.componentInstance;
-    component.form.setValue({ current_password: 'ancien-mot-de-passe', new_password: NOUVEAU });
+    component.form.setValue({ current_password: 'ancien-mot-de-passe', new_password: 'Un-nouveau-mot-de-passe1!' });

    authMock.changePassword.mockReturnValue(of({ principal: { role: 'admin' } }));

@@ -68,94 +52,46 @@ describe('ChangePassword', () => {
    expect(routerMock.navigate).toHaveBeenCalledWith(['/dashboard']);
  });

-  it("demande le mot de passe actuel quand la connexion ne l'a pas transmis (page rechargée)", () => {
-    const fixture = TestBed.createComponent(ChangePassword);
-    fixture.detectChanges();
+  it("affiche un message d'erreur si le mot de passe actuel est incorrect", () => {
+  const fixture = TestBed.createComponent(ChangePassword);
+  const component = fixture.componentInstance;
+  component.form.setValue({ current_password: 'mauvais-mot-de-passe', new_password: 'Un-nouveau-mot-de-passe1!' });

-    expect(champActuel(fixture)).not.toBeNull();
-  });
+  authMock.changePassword.mockReturnValue(throwError(() => new Error('401')));

-  it('réutilise le mot de passe provisoire de la connexion sans le redemander', () => {
-    authMock.takeProvisionalPassword.mockReturnValue('Provisoire-24-caracteres');
-    authMock.changePassword.mockReturnValue(of({ principal: { role: 'admin' } }));
-    const fixture = TestBed.createComponent(ChangePassword);
-    const component = fixture.componentInstance;
-    fixture.detectChanges();
+  component.onSubmit();
+  fixture.detectChanges(); // rend le bloc @if (errorMessage())

-    expect(champActuel(fixture)).toBeNull();
-    component.form.controls.new_password.setValue(NOUVEAU);
-    component.onSubmit();
-
-    expect(authMock.changePassword).toHaveBeenCalledWith({
-      current_password: 'Provisoire-24-caracteres',
-      new_password: NOUVEAU,
-    });
-  });
-
-  it('associe le formulaire au compte connecté pour les gestionnaires de mots de passe', () => {
-    const fixture = TestBed.createComponent(ChangePassword);
-    fixture.detectChanges();
-
-    const identifiant = fixture.nativeElement.querySelector('input[autocomplete="username"]');
-    expect(identifiant.value).toBe('johan@enervision.fr');
-  });
-
-  it('sur un 401, dit que le mot de passe actuel est faux et le redemande', () => {
-    authMock.takeProvisionalPassword.mockReturnValue('Provisoire-perime');
-    authMock.changePassword.mockReturnValue(
-      throwError(() => new HttpErrorResponse({ status: 401 })),
-    );
-    const fixture = TestBed.createComponent(ChangePassword);
-    const component = fixture.componentInstance;
-    component.form.controls.new_password.setValue(NOUVEAU);
-
-    component.onSubmit();
-    fixture.detectChanges();
-
-    expect(component.errorMessage()).toContain('Mot de passe actuel incorrect');
-    expect(fixture.nativeElement.querySelector('.ev-alert')?.textContent).toContain('incorrect');
-    expect(champActuel(fixture)).not.toBeNull();
-    expect(component.form.controls.current_password.value).toBe('');
-  });
-
-  it('sur un 422, dit que le nouveau mot de passe ne respecte pas la politique', () => {
-    authMock.changePassword.mockReturnValue(
-      throwError(() => new HttpErrorResponse({ status: 422 })),
-    );
-    const fixture = TestBed.createComponent(ChangePassword);
-    const component = fixture.componentInstance;
-    component.form.setValue({ current_password: 'ancien-mot-de-passe', new_password: NOUVEAU });
-
-    component.onSubmit();
-
-    expect(component.errorMessage()).toContain('Nouveau mot de passe refusé');
-    expect(component.form.controls.current_password.value).toBe('ancien-mot-de-passe');
+  expect(component.errorMessage()).toContain('incorrect');
+  const errorEl = fixture.nativeElement.querySelector('.ev-alert');
+  expect(errorEl?.textContent).toContain('incorrect');
  });

  it('désactive le bouton tant que le formulaire est invalide', () => {
-    const fixture = TestBed.createComponent(ChangePassword);
-    fixture.detectChanges();
+  const fixture = TestBed.createComponent(ChangePassword);
+  fixture.detectChanges();

-    const button = fixture.nativeElement.querySelector('button[type="submit"]');
-    expect(button.disabled).toBe(true);
-    expect(fixture.nativeElement.querySelector('.ev-alert')).toBeNull();
+  const button = fixture.nativeElement.querySelector('button[type="submit"]');
+  expect(button.disabled).toBe(true);
+  expect(fixture.nativeElement.querySelector('.ev-alert')).toBeNull();
  });

  it('déclenche onSubmit via la soumission réelle du formulaire (ngSubmit)', () => {
-    const fixture = TestBed.createComponent(ChangePassword);
-    const component = fixture.componentInstance;
-    component.form.setValue({ current_password: 'ancien-mot-de-passe', new_password: NOUVEAU });
-    fixture.detectChanges();
+  const fixture = TestBed.createComponent(ChangePassword);
+  const component = fixture.componentInstance;
+  component.form.setValue({ current_password: 'ancien-mot-de-passe', new_password: 'Un-nouveau-mot-de-passe1!' });
+  fixture.detectChanges();

-    authMock.changePassword.mockReturnValue(of({ principal: { role: 'admin' } }));
+  authMock.changePassword.mockReturnValue(of({ principal: { role: 'admin' } }));

-    const form = fixture.nativeElement.querySelector('form');
-    form.dispatchEvent(new Event('submit'));
-    fixture.detectChanges();
+  const form = fixture.nativeElement.querySelector('form');
+  form.dispatchEvent(new Event('submit'));
+  fixture.detectChanges();

-    expect(authMock.changePassword).toHaveBeenCalledWith({
-      current_password: 'ancien-mot-de-passe',
-      new_password: NOUVEAU,
-    });
+  expect(authMock.changePassword).toHaveBeenCalledWith({
+    current_password: 'ancien-mot-de-passe',
+    new_password: 'Un-nouveau-mot-de-passe1!',
  });
 });
+
+});
@@ -1,20 +1,17 @@
 import { Component, inject, signal } from '@angular/core';
-import { toSignal } from '@angular/core/rxjs-interop';
 import { ReactiveFormsModule, FormBuilder, Validators } from '@angular/forms';
 import { Router } from '@angular/router';
-import { HttpErrorResponse } from '@angular/common/http';
 import { AuthService } from '../../../core/services/auth.service';
 import { Button } from '../../../shared/components/ui/button/button';
 import { Card } from '../../../shared/components/ui/card/card';
 import { Alert } from '../../../shared/components/ui/alert/alert';
 import { Brand } from '../../../shared/components/ui/brand/brand';
-import { PasswordRequirementsChecklist } from '../../../shared/components/password-requirements/password-requirements';
 import { passwordValidators, PASSWORD_HINT } from '../../../shared/validators/password.validator';

@Component({
  selector: 'app-change-password',
  standalone: true,
-  imports: [ReactiveFormsModule, Button, Card, Alert, Brand, PasswordRequirementsChecklist],
+  imports: [ReactiveFormsModule, Button, Card, Alert, Brand],
  templateUrl: './change-password.html',
  styleUrl: './change-password.scss',
 })
@@ -23,47 +20,30 @@ export class ChangePassword {
  private auth = inject(AuthService);
  private router = inject(Router);

-  private provisionalPassword = this.auth.takeProvisionalPassword();
-
  errorMessage = signal<string | null>(null);
  isLoading = signal(false);
-  asksCurrentPassword = signal(this.provisionalPassword === null);
-  email = this.auth.principal()?.email ?? '';
+  passwordHint = PASSWORD_HINT;

  form = this.fb.nonNullable.group({
-    current_password: [this.provisionalPassword ?? '', Validators.required],
+    current_password: ['', Validators.required],
    new_password: ['', passwordValidators],
  });

-  newPassword = toSignal(this.form.controls.new_password.valueChanges, { initialValue: '' });
-
  onSubmit(): void {
    if (this.form.invalid) return;
    this.isLoading.set(true);
    this.errorMessage.set(null);

    this.auth.changePassword(this.form.getRawValue()).subscribe({
-      next: () => {
+      next: (response) => {
        this.router.navigate(['/dashboard']);
      },
-      error: (error: HttpErrorResponse) => {
+      error: () => {
        this.isLoading.set(false);
-        this.errorMessage.set(this.explique(error));
-        if (error.status === 401) {
-          this.form.controls.current_password.reset('');
-          this.asksCurrentPassword.set(true);
-        }
+        this.errorMessage.set(
+          `Mot de passe actuel incorrect, ou nouveau mot de passe invalide (${this.passwordHint}).`,
+        );
      },
    });
  }
-
-  private explique(error: HttpErrorResponse): string {
-    if (error.status === 401) {
-      return 'Mot de passe actuel incorrect : saisissez le mot de passe provisoire qui vous a été transmis.';
-    }
-    if (error.status === 422) {
-      return `Nouveau mot de passe refusé (${PASSWORD_HINT}).`;
-    }
-    return 'Le changement de mot de passe a échoué, réessayez dans un instant.';
-  }
 }
@@ -20,7 +20,7 @@
  @if (data(); as d) {
    <div class="sites-grid">
      @for (site of d.sites; track site.site_id) {
-        <ev-card class="site-card" data-testid="site-card">
+        <ev-card class="site-card">
          <div class="site-card__header">
            <span class="site-card__name">{{ site.site_name }}</span>
            <ev-badge [tone]="badgeToneForOverall(site.overall)">{{ site.overall }}</ev-badge>
@@ -5,12 +5,7 @@ PostgreSQL 17 avec l'extension TimescaleDB, servie en local par le service `db`

 - `init` : scripts de bootstrap joues au premier demarrage du conteneur.
 - `migrations` : migrations SQL versionnees.
- `seeds` : jeux de donnees de reference. `demo.sql` seme trois sites `demo-*`, 72 heures de
-  releves, des alertes et des rapports de derive pour la CI, l'e2e et les tirs de charge. Base
-  jetable seulement.
- `roles` : roles PostgreSQL hors schema applicatif. `supervision.sql` pose le role en lecture
-  seule de Grafana et de postgres-exporter, rejoue par `make db-ensure-supervision` (et par
-  `make stack-up` quand la supervision est active) plutot que par `init`, qui ne rejoue jamais.
+- `seeds` : jeux de donnees de reference.

 Les migrations du schema applicatif expose par l'API vivent dans
 `apps/backend/alembic`, pas ici.
@@ -1,15 +0,0 @@
-- Contrainte : rôle en lecture seule de la supervision (Grafana, postgres-exporter) -
-- supervision.sql. Ses droits ne portent que sur les tables métier : jamais `app_user`, les
-- jetons ni le journal d'audit. `pg_monitor` donne à l'exportateur les vues de statistiques.
-- Rejoué par `make db-ensure-supervision`, qui passe `mot_de_passe` et `base` en variables psql :
-- crée le rôle au besoin, puis réaligne à chaque passage mot de passe et droits.
-- Piège : les tables doivent exister, d'où l'appel après `alembic upgrade head` dans `stack-up`.
-
-SELECT 'CREATE ROLE supervision LOGIN'
-WHERE NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'supervision') \gexec
-
-ALTER ROLE supervision WITH LOGIN PASSWORD :'mot_de_passe';
-GRANT pg_monitor TO supervision;
-GRANT CONNECT ON DATABASE :"base" TO supervision;
-GRANT USAGE ON SCHEMA public TO supervision;
-GRANT SELECT ON site, reading, alert, prediction, recommendation, drift_report TO supervision;
@@ -1,101 +0,0 @@
-- Contrainte : jeu de démonstration pour une base JETABLE (CI, e2e, charge, DAST) - demo.sql.
-- Rejouable : identifiants fixes et `ON CONFLICT DO NOTHING`, ou `NOT EXISTS` là où aucune
-- contrainte d'unicité ne protège la table.
-- Pourquoi : les horodatages suivent `now()`. La fenêtre par défaut de `GET /readings` couvre les
-- 24 dernières heures, et un jeu figé dans le passé laisserait le tableau de bord vide.
-- Piège : `demo-ecole` finit sur une lecture `partial` sans humidité, pour que la supervision des
-- capteurs montre un site dégradé ; au-delà de dix alertes, le fil affiche « Afficher plus ».
-
-BEGIN;
-
-INSERT INTO site (site_id, site_name, site_type, location, capacity_kw, status)
-VALUES
-    ('demo-siege', 'Siège Part-Dieu', 'office', 'Lyon', 450, 'actif'),
-    ('demo-usine', 'Usine de Vénissieux', 'factory', 'Vénissieux', 900, 'actif'),
-    ('demo-ecole', 'Groupe scolaire Gratte-Ciel', 'school', 'Villeurbanne', 250, 'maintenance')
-ON CONFLICT (site_id) DO NOTHING;
-
-WITH profil (site_id, base_kw, amplitude_kw) AS (
-    VALUES ('demo-siege', 180.0, 120.0), ('demo-usine', 520.0, 260.0), ('demo-ecole', 70.0, 60.0)
-),
-heures AS (
-    SELECT date_trunc('hour', now()) - make_interval(hours => n) AS horodatage, n
-    FROM generate_series(0, 71) AS n
-),
-lectures AS (
-    SELECT
-        p.site_id,
-        h.horodatage,
-        h.n,
-        round((p.base_kw + p.amplitude_kw * greatest(0, sin(pi() * (extract(hour FROM h.horodatage) - 6) / 14)))::numeric, 2)::double precision AS kw,
-        extract(isodow FROM h.horodatage) < 6 AND extract(hour FROM h.horodatage) BETWEEN 8 AND 18 AS ouvre
-    FROM profil AS p
-    CROSS JOIN heures AS h
-)
-INSERT INTO reading (
-    site_id, timestamp, source, consumption_kw, consumption_kwh, consumption_euros,
-    voltage_v, current_a, power_factor, temperature_celsius, humidity_percent,
-    is_working_hours, data_quality, null_reasons, raw_data
-)
-SELECT
-    site_id,
-    horodatage,
-    'api_current',
-    kw,
-    kw,
-    round((kw * 0.19)::numeric, 2),
-    230.0,
-    round((kw * 1000 / (230.0 * 3 * 0.95))::numeric, 1)::double precision,
-    0.95,
-    19.5 + 3 * sin(pi() * extract(hour FROM horodatage) / 12),
-    CASE WHEN site_id = 'demo-ecole' AND n = 0 THEN NULL ELSE 45.0 END,
-    ouvre,
-    CASE WHEN site_id = 'demo-ecole' AND n = 0 THEN 'partial' ELSE 'good' END,
-    CASE WHEN site_id = 'demo-ecole' AND n = 0 THEN ARRAY['humidity_sensor_failure'] END,
-    '{}'::jsonb
-FROM lectures
-ON CONFLICT DO NOTHING;
-
-INSERT INTO prediction (site_id, target_at, target_metric, period_minutes, predicted_value, model_reference, status)
-SELECT s.site_id, date_trunc('hour', now()) + interval '1 hour', 'consumption_kwh', 60, s.valeur, 'demo-seed', 'available'
-FROM (VALUES ('demo-siege', 214.0), ('demo-usine', 610.5), ('demo-ecole', 88.2)) AS s (site_id, valeur)
-WHERE NOT EXISTS (
-    SELECT 1 FROM prediction AS p
-    WHERE p.site_id = s.site_id
-      AND p.model_reference = 'demo-seed'
-      AND p.target_at = date_trunc('hour', now()) + interval '1 hour'
-);
-
-INSERT INTO alert (source_alert_id, site_id, source, timestamp, type, severity, message, value, threshold, metric, raw_data)
-SELECT a.id, a.site_id, 'enervision', now() - make_interval(hours => a.age_h), a.type, a.severite, a.message, a.valeur, a.seuil, a.metrique, '{}'::jsonb
-FROM (
-    VALUES
-        ('demo-01', 'demo-siege', 1, 'spike', 'high', 'Pic de consommation à 312 kW', 312.0, 250.0, 'consumption_kw'),
-        ('demo-02', 'demo-siege', 3, 'threshold', 'medium', 'Seuil de 80 % de la capacité franchi', 372.0, 360.0, 'consumption_kw'),
-        ('demo-03', 'demo-siege', 6, 'anomaly', 'low', 'Consommation nocturne inhabituelle', 205.0, NULL, 'consumption_kw'),
-        ('demo-04', 'demo-siege', 9, 'sensor', 'medium', 'Capteur de température muet', NULL, NULL, 'temperature_celsius'),
-        ('demo-05', 'demo-siege', 20, 'outage', 'critical', 'Coupure de courant de 2 heures', 0.0, NULL, 'consumption_kw'),
-        ('demo-06', 'demo-usine', 2, 'spike', 'critical', 'Pic de consommation à 1 020 kW', 1020.0, 850.0, 'consumption_kw'),
-        ('demo-07', 'demo-usine', 4, 'threshold', 'high', 'Seuil de 90 % de la capacité franchi', 830.0, 810.0, 'consumption_kw'),
-        ('demo-08', 'demo-usine', 8, 'anomaly', 'medium', 'Facteur de puissance dégradé', 0.71, 0.85, 'power_factor'),
-        ('demo-09', 'demo-usine', 14, 'outage', 'high', 'Perte de mesure sur la ligne principale', NULL, NULL, 'consumption_kw'),
-        ('demo-10', 'demo-usine', 30, 'sensor', 'low', 'Capteur électrique intermittent', NULL, NULL, 'voltage_v'),
-        ('demo-11', 'demo-ecole', 1, 'sensor', 'high', 'Capteur d''humidité muet', NULL, NULL, 'humidity_percent'),
-        ('demo-12', 'demo-ecole', 5, 'anomaly', 'low', 'Chauffage actif hors des heures d''ouverture', 96.0, NULL, 'consumption_kw'),
-        ('demo-13', 'demo-ecole', 12, 'threshold', 'medium', 'Seuil de 60 % de la capacité franchi', 158.0, 150.0, 'consumption_kw'),
-        ('demo-14', 'demo-ecole', 40, 'spike', 'medium', 'Pic de consommation à 190 kW', 190.0, 160.0, 'consumption_kw')
-) AS a (id, site_id, age_h, type, severite, message, valeur, seuil, metrique)
-ON CONFLICT DO NOTHING;
-
-INSERT INTO drift_report (window_start, window_end, n_observations, mae, mape, bias, reference_mae, coverage_ratio, insufficient_data_ratio, model_references, status, reason, site_id)
-SELECT date_trunc('day', now()) - interval '7 days', date_trunc('day', now()), d.n, d.mae, d.mape, d.biais, 11.0, 0.98, 0.0, ARRAY['demo-seed'], d.statut, d.raison, d.site_id
-FROM (
-    VALUES
-        ('demo-siege', 168, 9.4, 0.052, -1.2, 'stable', NULL),
-        ('demo-usine', 168, 31.8, 0.061, 14.5, 'derive', 'MAE supérieure à 1,5 fois la référence'),
-        ('demo-ecole', 120, 6.1, 0.083, 0.4, 'stable', NULL),
-        (NULL, 456, 16.9, 0.064, 5.1, 'stable', NULL)
-) AS d (site_id, n, mae, mape, biais, statut, raison)
-ON CONFLICT DO NOTHING;
-
-COMMIT;
@@ -58,8 +58,6 @@ services:
    ports:
      - "${PROXY_HTTP_PORT:-80}:80"
      - "${PROXY_HTTPS_PORT:-443}:443"
-      # Vide : port aléatoire sur la boucle locale, pour que deux stacks sans frontal cohabitent.
-      - "${PROXY_FRONT_PORT:-127.0.0.1:}:4443"
    volumes:
      - ./infra/proxy/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./infra/proxy/conf.d:/etc/nginx/conf.d:ro
@@ -107,7 +107,6 @@ services:
      APP_SMTP_PORT: "1025"
      APP_SMTP_USE_TLS: "false"
      APP_SMTP_FROM_ADDRESS: ${APP_SMTP_FROM_ADDRESS:-no-reply@enervision.fr}
-      APP_METRICS_TOKEN: ${APP_METRICS_TOKEN:-}
    ports:
      - "${BACKEND_PORT:-8000}:8000"
    restart: unless-stopped
@@ -194,137 +193,7 @@ services:
      airflow-init:
        condition: service_completed_successfully

-  # Profil `monitoring` : actif en prod par COMPOSE_PROFILES, à la demande ailleurs (ADR 0016).
-  # Aucun `depends_on` : `make monitoring-up` démarre en `--no-deps`, sans jamais recréer `db`.
-  prometheus:
-    image: prom/prometheus:v3.14.0
-    profiles: ["monitoring"]
-    command:
-      - --config.file=/etc/prometheus/prometheus.yml
-      - --storage.tsdb.path=/prometheus
-      - --storage.tsdb.retention.time=15d
-      - --storage.tsdb.retention.size=1GB
-    volumes:
-      - ./monitoring/prometheus:/etc/prometheus:ro
-      - prometheus_data:/prometheus
-    secrets:
-      - metrics_token
-    ports:
-      - "127.0.0.1:${PROMETHEUS_PORT:-9090}:9090"
-    mem_limit: 512m
-    restart: unless-stopped
-
-  alertmanager:
-    image: prom/alertmanager:v0.34.1
-    profiles: ["monitoring"]
-    command:
-      - --config.file=/etc/alertmanager/alertmanager.yml
-      - --storage.path=/alertmanager
-    volumes:
-      - ./monitoring/alertmanager:/etc/alertmanager:ro
-      - alertmanager_data:/alertmanager
-    ports:
-      - "127.0.0.1:${ALERTMANAGER_PORT:-9093}:9093"
-    mem_limit: 64m
-    restart: unless-stopped
-
-  # Sans mot de passe, Grafana créerait un compte admin/admin : le conteneur refuse de démarrer.
-  grafana:
-    image: grafana/grafana:13.2.2
-    profiles: ["monitoring"]
-    entrypoint:
-      - /bin/sh
-      - -c
-      - ': "$${GF_SECURITY_ADMIN_PASSWORD:?GRAFANA_ADMIN_PASSWORD manquant dans .env}" && exec /run.sh'
-    environment:
-      GF_SECURITY_ADMIN_USER: admin
-      GF_SECURITY_ADMIN_PASSWORD: ${GRAFANA_ADMIN_PASSWORD:-}
-      GF_USERS_ALLOW_SIGN_UP: "false"
-      GF_AUTH_ANONYMOUS_ENABLED: "false"
-      GF_ANALYTICS_REPORTING_ENABLED: "false"
-      GF_ANALYTICS_CHECK_FOR_UPDATES: "false"
-      GF_ANALYTICS_CHECK_FOR_PLUGIN_UPDATES: "false"
-      GF_NEWS_NEWS_FEED_ENABLED: "false"
-      GF_DASHBOARDS_DEFAULT_HOME_DASHBOARD_PATH: /etc/grafana/dashboards/api.json
-      POSTGRES_DB: ${POSTGRES_DB:-enervision}
-      SUPERVISION_DB_PASSWORD: ${SUPERVISION_DB_PASSWORD:-}
-    volumes:
-      - ./monitoring/grafana/provisioning:/etc/grafana/provisioning:ro
-      - ./monitoring/grafana/dashboards:/etc/grafana/dashboards:ro
-      - grafana_data:/var/lib/grafana
-    ports:
-      - "127.0.0.1:${GRAFANA_PORT:-3001}:3000"
-    mem_limit: 256m
-    restart: unless-stopped
-
-  postgres-exporter:
-    image: prometheuscommunity/postgres-exporter:v0.20.1
-    profiles: ["monitoring"]
-    environment:
-      DATA_SOURCE_URI: db:5432/${POSTGRES_DB:-enervision}?sslmode=disable
-      DATA_SOURCE_USER: supervision
-      DATA_SOURCE_PASS: ${SUPERVISION_DB_PASSWORD:-}
-    mem_limit: 64m
-    restart: unless-stopped
-
-  node-exporter:
-    image: prom/node-exporter:v1.12.1
-    profiles: ["monitoring"]
-    command:
-      - --path.rootfs=/host
-    pid: host
-    volumes:
-      - /:/host:ro,rslave
-    mem_limit: 64m
-    restart: unless-stopped
-
-  # Contrainte : cAdvisor lit les cgroups de tous les conteneurs de l'hôte, d'où `privileged` et
-  # ses montages en lecture seule. Aucun port publié : seul Prometheus le joint.
-  cadvisor:
-    image: gcr.io/cadvisor/cadvisor:v0.55.1
-    profiles: ["monitoring"]
-    privileged: true
-    devices:
-      - /dev/kmsg
-    command:
-      - --docker_only=true
-      - --housekeeping_interval=30s
-      - --store_container_labels=false
-    volumes:
-      - /:/rootfs:ro
-      - /var/run:/var/run:ro
-      - /sys:/sys:ro
-      - /var/lib/docker/:/var/lib/docker:ro
-      - /dev/disk/:/dev/disk:ro
-    mem_limit: 160m
-    restart: unless-stopped
-
-  # Pourquoi : sur le réseau du projet, k6 joint `backend:8000` sans passer par nginx, dont la
-  # limite par adresse (20 req/s) fausserait la mesure de l'API. `make load-*` le lance (ADR 0015).
-  k6:
-    image: grafana/k6:2.3.0
-    profiles: ["load"]
-    volumes:
-      - ./tests/load:/scripts:ro
-      - ./tests/load/results:/results
-    environment:
-      K6_BASE_URL: ${K6_BASE_URL:-http://backend:8000}
-      K6_PROXY_URL: ${K6_PROXY_URL:-https://proxy}
-      K6_EMAIL: ${K6_EMAIL:-}
-      K6_PASSWORD: ${K6_PASSWORD:-}
-      K6_RESUME: ${K6_RESUME:-}
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-
 volumes:
  pgdata:
  airflow_logs:
  airflow_ml_state:
-  prometheus_data:
-  alertmanager_data:
-  grafana_data:
-
-# Vide tant qu'APP_METRICS_TOKEN n'est pas posé : l'API n'exige alors aucun jeton.
-secrets:
-  metrics_token:
-    environment: APP_METRICS_TOKEN
@@ -20,6 +20,3 @@
 | [0011](adr/0011-enervision-procedure-deploiement.md) | Procédure de déploiement, telle qu'exécutée le 22/09/2026 |
 | [0012](adr/0012-enervision-deploiement-rec-prod-vm-eni.md) | État de la recette et de la production sur la VM ENI |
 | [0013](adr/0013-surveillance-de-derive-dans-le-backend.md) | La surveillance de dérive vit dans le backend et écrit sa propre table |
-| [0014](adr/0014-pipeline-ci-unique-et-deploiement-conditionne.md) | Un pipeline CI unique appelle les workflows de composant et conditionne le déploiement |
-| [0015](adr/0015-tests-e2e-et-de-charge-contre-la-stack-compose.md) | Les tests de bout en bout et de charge visent la stack Compose déployée |
-| [0016](adr/0016-supervision-en-profil-compose.md) | La supervision vit dans un profil Compose, active en prod |
@@ -1,79 +0,0 @@
-# 0014 - Un pipeline CI unique appelle les workflows de composant et conditionne le déploiement
-
- Statut : accepté
- Date : 2026-09-23
- Complète : [0009](0009-deux-environnements-compose-sur-la-vm-eni.md), qui reste en vigueur
-
-## Contexte
-
-Au 22/09, huit workflows se déclenchaient chacun de leur côté, et l'audit y a relevé :
-
- **Double exécution.** Chaque workflow partait sur `push` (toutes branches) **et** sur
-  `pull_request`. Un commit poussé sur une branche de PR jouait donc toute la CI deux fois,
-  à la même minute (constaté dans l'historique des runs de `test/integration-api-db-ml`).
- **Sonar refaisait tout.** `sonarqube.yml` reconstruisait le frontend et retestait frontend,
-  backend et ML pour produire ses rapports de couverture, en double exact de `frontend.yml`,
-  `backend.yml` et `ml.yml`. Son test backend tournait sans `uv sync`. Il n'avait ni
-  `permissions` ni `concurrency`.
- **Déploiement non conditionné.** `deploy.yml` partait à chaque push sur `dev` ou `main`,
-  que la CI du commit soit verte ou non, et déployait la pointe de branche du moment plutôt
-  que le commit poussé.
- **Erreurs silencieuses et hygiène.**
-  - `npm test --watch=false --code-coverage` : npm garde ces options pour lui, `ng test` ne
-    les reçoit jamais, et la CI ne tenait que par les réglages d'`angular.json`.
-  - `uv sync --frozen` ne vérifie pas que `uv.lock` suit `pyproject.toml`.
-  - Plusieurs actions tierces étaient épinglées par tag, contrairement à la règle Sonar
-    `githubactions:S7637`.
-  - Aucun job n'avait de `timeout-minutes` (360 minutes par défaut).
-
-## Décision
-
-**`ci.yml` est le seul workflow déclenché par `pull_request` et par les push sur `dev` et
-`main`.** Les workflows de composant (`backend`, `frontend`, `ml`, `airflow`, `infra`, `e2e`)
-passent en `workflow_call` et n'ont plus de déclencheur propre.
-
-1. **`changes`.** Un job initial calcule, par `dorny/paths-filter` épinglé sur un SHA, les
-   composants touchés par la PR, et chaque composant n'est appelé que si son filtre vaut vrai.
-   Sur un push vers `dev` ou `main`, tous les filtres valent vrai : l'analyse Sonar reste
-   complète sur les branches longues, et paths-filter ne compare pas à la base de fusion avec
-   `main`, qui a 80 commits de retard.
-2. **`sonar`.** Il ne reconstruit ni ne reteste plus rien : il télécharge, dans le même run, les
-   couvertures versées par les jobs `verification` des composants.
-3. **`CI ok`.** Le job agrège le résultat de tous les autres. Il tourne toujours (`if:
-   always()`) et échoue dès qu'un job est en `failure` ou `cancelled`. **C'est le seul check à
-   exiger dans les règles de branche** : un composant sauté par son filtre ne publie aucun check
-   interne, qui resterait « en attente » s'il était exigé.
-4. **`deploy`.** Il appelle `deploy.yml`, sur les seuls push, et seulement si `CI ok` a réussi.
-   `deploy.yml` aligne le dossier de l'environnement sur `GITHUB_SHA`, le commit testé, sauf
-   si ce commit précède celui déjà déployé : les CI de deux push peuvent finir dans le désordre,
-   et un environnement ne recule jamais. Les déploiements d'un même environnement passent un par
-   un sous un verrou `flock` sur la VM, et non dans un groupe `concurrency`, où GitHub ne garde
-   qu'un job en attente et annule le précédent quand un troisième arrive.
-
-`deploy.yml` n'a toujours **aucun déclencheur `pull_request`** : il n'accepte que
-`workflow_call` et `workflow_dispatch`, dans l'esprit de l'ADR 0009.
-
-## Alternatives écartées
-
-| Écartée | Raison |
-|---|---|
-| Garder huit workflows et restreindre seulement `push` à `dev` et `main` | Supprime la double exécution, pas le doublon Sonar : il faudrait toujours rejouer les tests pour que Sonar ait ses couvertures, les artefacts ne passant pas d'un workflow à l'autre. Et rien n'empêche un déploiement rouge. |
-| Déclencher le déploiement par `workflow_run` | `workflow_run` joue toujours le fichier de la branche par défaut, `main`, en retard de 80 commits : la recette ne se serait plus déployée avant la prochaine remontée vers `main`, sans erreur visible. |
-| `alls-green` ou une action tierce d'agrégation | Dix lignes de shell sur `toJSON(needs.*.result)` font le même travail, sans dépendance de plus à épingler. |
-| Cache de couches Docker (`bake-action`, `type=gha`) pour l'e2e | Quatre pièges (noms d'image, cibles Compose, buildx, `load`) pour deux à quatre minutes gagnées. Reporté après le rendu. |
-
-## Conséquences
-
- Une PR ne joue que ce qu'elle touche. Une PR de documentation ne joue que `changes` et
-  `CI ok`.
- Les checks s'appellent désormais « Backend / Lint, typage et tests », etc. Au 23/09, ni `dev`
-  ni `main` n'ont de règle de protection : à la première, exiger **« CI ok »** et rien d'autre.
- Modifier `ci.yml` rejoue toute la CI sur la PR (filtre `ci`).
- Le job `deploy` reste en file tant que le runner `eni-g3` n'est pas enregistré sur la VM,
-  comme avant. Le groupe de concurrence par SHA des push l'empêche de bloquer les runs suivants.
- La sécurité du runner auto-hébergé ne repose pas sur l'absence de `pull_request` dans
-  `deploy.yml`. Une PR de fork peut ajouter son propre workflow. Ce qui protège le runner :
-  - l'approbation obligatoire des workflows de tous les contributeurs externes ;
-  - les règles de branche des environnements `rec` (`dev`) et `prod` (`main` et un relecteur).
-
-  Ces deux réglages restent à poser par l'administratrice du dépôt.
@@ -1,70 +0,0 @@
-# 0015 - Les tests de bout en bout et de charge visent la stack Compose déployée
-
- Statut : accepté
- Date : 2026-09-23
-
-## Contexte
-
-Les issues #46 (Playwright) et #47 (k6) demandent des preuves de robustesse pour EC03 et EC04.
-Rien ne vérifiait un parcours utilisateur complet : les tests du frontend simulent l'API, ceux
-du backend n'ouvrent pas de navigateur. Rien ne mesurait non plus l'API sous charge, et le
-dépôt ne chiffre aucun temps de réponse ni aucun volume d'utilisateurs.
-
-Trois contraintes du système pèsent sur la manière de tester :
-
- **La session tient dans un cookie de refresh HttpOnly qui tourne à chaque usage.** Rejouer un
-  cookie déjà servi révoque toute la famille de session (ADR 0002).
- **Le cookie n'est `__Secure-` et `Secure` que hors `local`, derrière le proxy TLS.** Tester
-  contre `ng serve` ne dit rien de ce que voit un navigateur en prod (ADR 0007).
- **nginx limite chaque adresse IP** à 20 req/s sur l'API, avec une rafale de 40, et à 30
-  connexions par minute, avec une rafale de 20 (ADR 0007). Tout le trafic d'un tir parti d'une
-  seule machine partage la même adresse.
-
-## Décision
-
-**Playwright joue contre la stack de prod** (`docker-compose.yml` et
-`docker-compose.prod.yml`), sur `https://localhost` avec un certificat auto-signé.
- **En CI**, le workflow `e2e.yml` démarre `db`, `mailpit`, `backend`, `frontend` et `proxy`,
-  sème `db/seeds/demo.sql` et crée les comptes par `scripts/comptes-test.sh`.
- **Sur le poste**, la même suite vise `make dev` (`http://localhost:4200`).
- **Écriture des tests**, imposée par la rotation du refresh et par la zone `auth` :
-  - un seul worker ;
-  - une session par fichier, sans `storageState` partagé ;
-  - chaque parcours qui consomme un compte le crée lui-même.
-
-**k6 tourne en service Compose (profil `load`) sur le réseau du projet et vise `backend:8000`**,
-pour mesurer l'API et non la limite de nginx. Un seul scénario, `limitation-debit.js`, passe par
-`https://proxy`, pour vérifier que la limite tient : des 429, jamais de 5xx.
-
-**Hypothèses et seuils**, faute d'exigence chiffrée :
-
-| Hypothèse ou seuil | Valeur |
-|---|---|
-| Utilisateurs simultanés | 50 : 40 sur le tableau de bord, qui interroge `/stats/summary` toutes les 10 s et `/alerts` toutes les 60 s ; 10 qui explorent les sites |
-| Lectures, p95 | < 500 ms |
-| Lectures, p99 | < 1 s |
-| Échecs HTTP | < 1 % |
-| Vérifications réussies | > 99 % |
-
-**En CI de PR** : Playwright, le tir `smoke` (une minute) et `limitation-debit`. La charge
-nominale et le stress se lancent à la main (`make load-test`, `make load-stress`), en recette,
-parce que rec et prod partagent la VM (ADR 0009).
-
-## Alternatives écartées
-
-| Écartée | Raison |
-|---|---|
-| Playwright contre `ng serve` en CI | Pas de TLS, pas de cookie `__Secure-`, pas de CSP ni de limitation : le parcours testé ne serait pas celui des utilisateurs. |
-| `storageState` partagé entre fichiers | Chaque fichier rejouerait le même cookie de refresh ; le second usage révoque la famille, et la suite échoue de façon intermittente selon l'ordre. |
-| k6 depuis le runner, à travers le proxy | Au-delà de 20 req/s, on mesure nginx. Relever la limite pour le tir, ce serait tester une configuration qui n'est pas celle de la prod. |
-| Tir de charge complet à chaque PR | Huit minutes de plus par PR, sur un runner partagé dont les performances varient d'un run à l'autre : un seuil franchi n'y voudrait rien dire. |
-| Un workflow k6 en `workflow_dispatch` contre la recette | La recette partage la VM avec la prod ; un tir déclenché d'un clic ralentirait la prod sans que personne soit prévenu. La cible Makefile, lancée sur la VM, garde un humain dans la boucle. |
-
-## Conséquences
-
- La CI construit enfin les images backend et frontend avant le déploiement, par le job E2E.
- `db/seeds/demo.sql` et `scripts/comptes-test.sh` deviennent le jeu commun de la CI, repris par
-  le DAST. Les deux sont réservés aux bases jetables.
- Les seuils de k6 sont des hypothèses de l'équipe : à réviser dès qu'un besoin chiffré existe.
- L'API expose des seaux de latence fins autour de 500 ms, pour que Grafana lise le même seuil
-  que k6 (ADR 0016).
@@ -1,61 +0,0 @@
-# 0016 - La supervision vit dans un profil Compose, active en prod
-
- Statut : accepté
- Date : 2026-09-23
-
-## Contexte
-
-L'API expose `/metrics` au format Prometheus depuis le début, et `monitoring/` ne contenait que
-des `.gitkeep` : aucun collecteur, aucun tableau de bord, aucune alerte (issue #26). La VM ENI
-porte la recette et la prod, deux piles complètes, sur 8 Go de mémoire (ADR 0009).
-
-## Décision
-
-**Prometheus, Alertmanager, Grafana et trois exporteurs** sont des services de
-`docker-compose.yml` sous le profil `monitoring` : postgres-exporter, node-exporter et cAdvisor.
-
- **En prod**, `COMPOSE_PROFILES=monitoring` dans le `.env` : `make stack-up`, donc chaque
-  déploiement, les démarre avec le reste.
- **En recette et sur le poste**, ils se lancent à la demande (`make monitoring-up`, en
-  `--no-deps`). La recette ne paie rien tant qu'on ne les lance pas.
- **Mémoire.** Chaque service a un `mem_limit`, pour environ 700 Mo au total.
- **Accès.** Les interfaces n'écoutent que sur `127.0.0.1` et se consultent par tunnel SSH,
-  comme Airflow. Rien ne passe par le proxy : Grafana derrière nginx exigerait sa propre
-  authentification forte, et rendrait `/metrics` joignable à un routage près (ADR 0007).
- **Sécurité.**
-  - **Jeton.** Prometheus présente sur `/metrics` le jeton `APP_METRICS_TOKEN`, passé en
-    secret Compose. Il est exigé dès que la supervision tourne.
-  - **Lecture de la base.** Grafana et l'exportateur lisent la base par un rôle `supervision`
-    en lecture seule, limité aux tables métier (`db/roles/supervision.sql`). Ils n'ont
-    jamais accès à `app_user`, aux jetons ni à l'audit.
- **Alertes.**
-  - Neuf règles couvrent l'API, la base, l'hôte et les cibles, chacune avec un cas de test
-    joué par `promtool test rules` en CI.
-  - Alertmanager les envoie par courriel à Mailpit, le seul SMTP de la stack.
- **Dérive du modèle.** Elle s'affiche dans Grafana par une lecture SQL de `drift_report`.
-  L'ADR 0013 a écarté une jauge Prometheus calculée par un traitement par lot, pas la lecture
-  de sa table.
-
-## Alternatives écartées
-
-| Écartée | Raison |
-|---|---|
-| Supervision démarrée dans les deux environnements | Double la mémoire consommée sur une VM déjà serrée, pour des tableaux de recette que personne ne regarde. |
-| Une pile de supervision partagée, troisième projet Compose | Elle devrait rejoindre les réseaux des deux projets, par des réseaux externes à déclarer sur la VM : plus de pièces, et un couplage entre environnements que l'ADR 0009 évite. |
-| Publier Grafana derrière le proxy | Une interface d'administration de plus exposée au réseau de l'école, et un pas de plus vers une publication accidentelle de `/metrics`. |
-| Grafana avec le compte applicatif de la base | Le compte applicatif écrit partout, y compris dans `app_user`. Une requête libre dans Grafana y aurait accès. |
-| Une jauge de fraîcheur des relevés calculée par l'API au moment du scrape | Une requête SQL dans un collecteur synchrone, à chaque scrape. La même information se lit directement dans TimescaleDB depuis Grafana. |
-
-## Conséquences
-
- **Secrets.** `.env.example` gagne `COMPOSE_PROFILES`, `APP_METRICS_TOKEN`,
-  `GRAFANA_ADMIN_PASSWORD`, `SUPERVISION_DB_PASSWORD` et les ports.
-  `scripts/provision-host.sh` génère ces secrets pour un nouvel environnement. Le `.env` d'un
-  environnement déjà provisionné n'est jamais réécrit : il faut les y ajouter à la main.
-  `make stack-up` refuse de démarrer si le profil est actif et qu'un secret manque.
- **Instrumentation.** L'API ne compte plus les sondes de santé dans ses métriques, et chaque
-  application a son propre registre Prometheus.
- **cAdvisor tourne en `privileged`**, avec des montages en lecture seule et sans port publié.
-  C'est le prix de la mémoire par conteneur, l'indicateur qui compte le plus sur une VM partagée.
- **Données non couvertes.** L'ingestion et les DAG Airflow n'ont pas encore de métriques
-  (StatsD ou OpenTelemetry). Le tableau « Données » les supplée en lisant `reading`.
@@ -1,57 +0,0 @@
-# 0017 - Un troisième environnement, `dev`, déployé à la demande depuis n'importe quelle branche
-
- Statut : accepté
- Date : 2026-09-23
-
-## Contexte
-
-L'[ADR 0009](0009-deux-environnements-compose-sur-la-vm-eni.md) a posé deux environnements sur
-la VM ENI : la recette suit `dev`, la production suit `main`. Les environnements GitHub en
-comptent trois, `dev`, `rec` et `prod`, et le troisième ne déployait rien.
-
-Il manque un endroit où montrer une branche de travail avant son merge : la recette ne doit
-porter que ce qui est intégré à `dev`, sinon elle cesse d'être une recette. Un
-`workflow_dispatch` sur une branche de travail envoyait d'ailleurs cette branche dans la
-recette, puisque tout ce qui n'était pas `main` y partait.
-
-La VM est passée à 32 Go : une troisième TimescaleDB, réglée à 2 Go comme les deux autres,
-tient sans peine.
-
-## Décision
-
-**Un troisième projet Compose, `enervision-dev`, dans `/srv/enervision/dev`**, bâti exactement
-comme les deux autres : son clone, son `.env`, son certificat, préparés par
-`scripts/provision-host.sh`.
-
-**Déployé à la demande, jamais sur un push.** `deploy.yml` envoie `main` en prod, `dev` en
-recette, et toute autre branche lancée depuis l'onglet Actions dans `dev`. Seul un membre ayant
-le droit d'écriture sur le dépôt peut lancer un workflow.
-
-**Ports décalés d'un cran de plus** : HTTPS `9443`, et sur `127.0.0.1` la redirection HTTP
-`8083`, PostgreSQL `5435`, Mailpit `8027`, Airflow `8084`. Nom d'hôte `dev.enervision.local`,
-pour la même raison de cookie que la recette.
-
-**Le verrou de déploiement suit l'environnement** (un `flock` sur son dossier, ADR 0014), et non
-plus la branche : deux branches lancées coup sur coup écriraient sinon dans le même dossier en
-même temps.
-
-## Alternatives écartées
-
- **`dev` suit la branche `dev` à chaque push, la recette devient manuelle** : la recette
-  offrirait une version figée au jury, mais la doc CI/CD, l'ADR 0009 et l'habitude de l'équipe
-  basculeraient à deux jours du rendu.
- **Un environnement par branche de travail** : un projet Compose et une TimescaleDB par
-  branche, sans mécanisme de nettoyage. La machine ne le porterait pas longtemps.
- **Garder `dev` sur les postes seulement** : rien à montrer d'une branche non mergée sans
-  passer par la recette.
-
-## Conséquences
-
- Une branche de travail créée avant ce changement porte l'ancien `deploy.yml` : lancée à la
-  main, elle part encore dans la recette. Limiter l'environnement GitHub `rec` à la branche
-  `dev` ferme ce chemin, réglage que seul un administrateur du dépôt peut poser.
- `dev` ne garde aucune donnée d'une branche à l'autre au-delà de ce que ses migrations
-  acceptent : une branche dont les migrations divergent de `dev` peut laisser la base dans un
-  état que la suivante refuse. Recréer le volume, `docker compose down -v`, est alors le remède.
- Trois environnements construisent leurs images séparément : l'écart de l'ADR 0009, un même
-  commit construit deux fois, reste ouvert jusqu'au passage à GHCR.
@@ -1,92 +0,0 @@
-# 0018 - Noms publics, certificats Let's Encrypt par DNS-01 et frontal SNI sans port
-
- Statut : accepté
- Date : 2026-09-23
-
-## Contexte
-
-Les trois environnements de la VM ENI ([ADR 0009](0009-deux-environnements-compose-sur-la-vm-eni.md),
-[ADR 0017](0017-environnement-dev-a-la-demande.md)) répondaient sur `enervision.local`,
-`rec.enervision.local:8443` et `dev.enervision.local:9443`, avec des certificats auto-signés.
-Chaque poste devait éditer son `/etc/hosts` et accepter trois avertissements du navigateur :
-rien de présentable à un jury, et rien d'utilisable par quelqu'un qui n'a pas la main sur son
-poste.
-
-Contraintes : la VM n'a qu'une IP privée, `10.101.200.37`, que ni Internet ni Let's Encrypt ne
-joignent, et le réseau de l'école ne doit pas être touché. Vérifications faites le 23/09 : les
-résolveurs de l'école rendent bien une adresse privée pour un nom public, la VM sort en HTTPS
-vers Let's Encrypt et vers l'API de dynv6, mais le filtrage de l'école bloque duckdns.org, site
-et API, depuis les postes comme depuis la VM.
-
-## Décision
-
-**Des noms publics qui visent l'IP privée.** Dans `enervision-g3.dynv6.net`, zone gratuite de
-dynv6, trois enregistrements A portent `prod.`, `rec.` et `dev.`. `provision-host.sh` les publie
-par l'API dynv6 : le DNS est décrit par le code comme le reste. La prod n'est pas à la racine de
-la zone : dynv6 y sert mal un TXT `_acme-challenge`, que l'API ne liste ni ne supprime et qu'un
-seul de ses trois serveurs renvoie (constaté le 23/09), si bien que son défi DNS-01 échoue. Tout
-poste du réseau de l'école les résout sans configuration ; hors de ce réseau, l'IP ne mène
-nulle part.
-
-**Des certificats Let's Encrypt par défi DNS-01.** Le défi passe par l'API dynv6, qui pose
-l'enregistrement TXT : Let's Encrypt n'a jamais à joindre la VM. `make tls-dns01` (acme.sh
-épinglé) le joue dans chaque stack ; il ne renouvelle qu'à échéance, d'où son rejeu à chaque
-déploiement et chaque nuit par cron. `--dnssleep 90` laisse aux trois serveurs de dynv6 le temps
-de servir le TXT avant que Let's Encrypt ne le cherche depuis plusieurs réseaux. Un certificat par environnement plutôt qu'un joker : chaque
-stack garde le sien, et la clé de la prod n'est pas lisible depuis le clone de dev.
-
-**Un frontal SNI sur 443, le seul composant exposé.** `infra/front`, un nginx sur le réseau de
-l'hôte, lit le nom demandé dans le ClientHello et relaie le flux TLS intact vers la stack visée,
-publiée sur la boucle locale. Il ne détient aucun certificat. Le port 80 y redirige vers
-HTTPS. Les URL perdent leur port.
-
-**Le PROXY protocol entre frontal et stacks.** Relayé tel quel, le flux arriverait avec l'IP du
-frontal : `limit_req` et `get_client_ip()` compteraient tous les postes comme un seul, et un
-utilisateur bloquerait la connexion de tous. Chaque proxy de stack reçoit donc le frontal sur un
-écouteur dédié, 4443, qui exige l'en-tête PROXY protocol et en tire l'IP du client. Le 443 de
-la stack reste sans PROXY protocol, pour les postes de développement et la sonde du déploiement.
-
-**Le fournisseur est un paramètre.** `DNS01_API` et `DNS01_JETON_VAR` nomment le greffon acme.sh,
-le jeton vit dans `dns.token` quel que soit le fournisseur : passer à un domaine acheté chez
-Cloudflare ou OVH ne demande que ces deux variables et `domaine`, plus `publier_dns()`.
-
-**`scripts/provision-host.sh` fait foi pour l'adressage et les secrets.** Un `.env` existant
-garde ses secrets, reçoit ceux qui lui manquent et voit hôte, ports et profils réalignés sur le
-tableau du script. C'est ce qui permet de migrer trois `.env` nés avant ce changement, et le
-clone de la prod, en retard sur `main`, sans dépendre de son `.env.example`.
-
-## Alternatives écartées
-
- **Garder `/etc/hosts` et l'auto-signé** : trois manipulations par poste et trois
-  avertissements, précisément ce qu'il fallait supprimer.
- **DuckDNS** : premier choix, inscription en un clic, mais bloqué par le filtrage de l'école :
-  sans son API, pas de défi DNS-01.
- **deSEC (`dedyn.io`)** : joignable et associatif, mais les inscriptions de nouveaux domaines
-  `dedyn.io` étaient fermées le 23/09 ; il reste le bon choix pour un domaine acheté.
- **nip.io ou sslip.io** : résolution sans compte, mais aucun moyen d'y obtenir un certificat.
- **Services à certificat joker public (traefik.me, local-ip.co)** : leur clé privée est publiée
-  par conception, n'importe qui peut usurper ces noms.
- **Tunnel vers Internet (Cloudflare Tunnel, Tailscale Funnel)** : accès depuis l'extérieur,
-  mais l'application serait exposée hors de l'école, décision refusée.
- **Autorité de certification interne (mkcert, step-ca)** : chaque poste devrait l'installer.
- **Terminaison TLS au frontal** : un seul endroit pour les certificats, mais les stacks
-  recevraient du HTTP clair que leur proxy redirige vers HTTPS, et en-têtes de sécurité comme
-  limitation de débit seraient à déplacer. Le relais SNI ne touche à rien de tout cela.
- **Domaine acheté** : plus présentable, mais un achat et un compte de plus pour un bénéfice nul
-  sur l'accès. Seule `DOMAINE` changerait.
-
-## Conséquences
-
- L'objection de l'ADR 0009 à un proxy frontal, qui aurait dû joindre plusieurs réseaux Compose
-  aux services homonymes, tombe : le frontal ne joint que des ports de la boucle locale.
- Sans le frontal, plus rien n'est joignable sur la VM. `deploy.yml` le relance à chaque
-  déploiement de la prod, et son `restart: unless-stopped` le ramène après un redémarrage.
- Le jeton dynv6 vit dans `/srv/enervision/dns.token`, jamais dans git, GitHub ni le state
-  Terraform ; acme.sh en garde une copie dans `infra/proxy/acme/`, retirée à la lecture des
-  autres comptes. Qui le détient peut repointer les trois noms.
- dynv6 devient une dépendance : s'il tombe, les noms cessent de résoudre et les
-  renouvellements échouent. Les certificats valent 90 jours, la marge est large.
- Un filtrage de l'école qui viendrait à bloquer dynv6 arrêterait les renouvellements, pas les
-  noms : la résolution passe par les serveurs DNS de l'école, pas par le site.
- Les noms sont publics mais ne mènent qu'à une IP privée : ils révèlent l'existence de la VM,
-  pas son contenu.
@@ -51,8 +51,8 @@ flowchart TB
    api["API FastAPI<br/>apps/backend"]
    db[("PostgreSQL 17<br/>TimescaleDB")]
    airflow["Airflow<br/>etl/airflow"]
-    prom["Prometheus<br/>profil monitoring"]
-    grafana["Grafana<br/>profil monitoring"]
+    prom["Prometheus"]
+    grafana["Grafana"]
  end

  navigateur --> proxy
@@ -61,32 +61,23 @@ flowchart TB
  front -.-> api
  api --> db
  airflow --> db
-  prom --> api
-  grafana --> db
-  grafana --> prom
+  prom -.-> api
+  grafana -.-> db
+  grafana -.-> prom
 ```

 Le lien `front -.-> api` reste en pointillé : le frontend appelle bien une API, mais un
 intercepteur répond à sa place tant que les endpoints n'existent pas. Voir
 [30-frontend.md](30-frontend.md).

-Le lien `airflow --> db` est maintenant en trait plein : six DAGs tournent, deux pour
+Le lien `airflow --> db` est maintenant en trait plein : cinq DAGs tournent, deux pour
 l'entraînement et le scoring du modèle ML (issue #115), un pour la détection d'alertes et la
-génération des recommandations (issue #116), un pour la surveillance de dérive (issue #45),
-`historical_import` pour le dataset historique (issue #119) et `mock_api_import` pour l'ingestion
-horaire de l'API Mock (issue #15). La réconciliation entre les deux sources de lectures (issue
-#15) est tranchée : le trou entre la fin de l'historique (31/12/2024) et le début de l'ingestion
-API Mock est accepté comme définitivement perdu, aucune mesure réelle n'existant pour cette
-période. `mock_api_import` refuse toute fenêtre qui recouvrirait des lectures déjà importées du
-CSV plutôt que de laisser les deux sources dupliquer silencieusement un même instant, et le
-pipeline ML déduplique par construction (`DISTINCT ON`, source `csv` préférée) au cas où un
-recouvrement se produirait malgré tout, voir [40-data.md](40-data.md).
+génération des recommandations (issue #116), `historical_import` pour le dataset historique
+(issue #119) et `mock_api_import` pour l'ingestion horaire de l'API Mock (issue #15).
+La réconciliation globale des données provenant des deux sources reste à compléter dans l'issue #15.

-Les liens de la supervision sont en trait plein depuis le 23/09 (issue #26) : Prometheus scrute
-`/metrics` avec un jeton, Grafana lit Prometheus et, par un rôle en lecture seule, les tables
-métier de TimescaleDB. Ils tournent en prod sous le profil Compose `monitoring`, à la demande
-ailleurs ([ADR 0016](../adr/0016-supervision-en-profil-compose.md),
-[60-observabilite.md](60-observabilite.md)).
+Le lien `prom -.-> api` de même : l'API expose bien `/metrics` au format Prometheus, mais aucun
+collecteur ne vient le lire.

 ## État de la stack

@@ -97,9 +88,9 @@ ailleurs ([ADR 0016](../adr/0016-supervision-en-profil-compose.md),
 | Base | PostgreSQL 17 + TimescaleDB | `db` | `Fait` | Bootstrap de l'extension, base de test, chaîne Alembic. Schéma applicatif créé (`site`, `dataset`, `reading` en hypertable, `prediction`, `alert`, `recommendation`) |
 | ML | LightGBM, MLflow | `ml` | `En cours` | Pipeline d'entraînement et de scoring (`enervision_ml.train`/`.score`, features par lags/moyennes glissantes partagées entre les deux, baseline de persistance saisonnière, suivi MLflow local), exposé en lecture via `GET /predictions`, orchestré par Airflow (`ml_train`/`ml_score`). Voir [ADR 0005](../adr/0005-modele-prediction-lightgbm.md) et [ML-START.md](../ML-START.md). Surveillance de dérive livrée côté backend (`app.monitoring.drift`, table `drift_report`, `GET /monitoring/drift`, DAG `derive`), voir [ADR 0013](../adr/0013-surveillance-de-derive-dans-le-backend.md) |
 | Infra | Docker Compose, Nginx, Terraform, k3s single-node | `infra`, `docker-compose.prod.yml` | `En cours` | Reverse proxy et overlay de déploiement écrits et validés, jamais lancés sur le serveur ([ADR 0007](../adr/0007-terminaison-tls-et-reverse-proxy-nginx.md)). Provisionnement de la VM par Terraform, qui installe Docker, prépare les deux environnements et enregistre le runner, jamais appliqué ([ADR 0010](../adr/0010-terraform-provisionne-github-actions-deploie.md)). Module d'installation k3s jamais appliqué, aucune ressource Kubernetes déclarée |
-| Monitoring | Prometheus, Grafana, Alertmanager | `monitoring` | `Fait` | Profil Compose `monitoring`, actif en prod : Prometheus et trois exporteurs (PostgreSQL, hôte, conteneurs), neuf règles d'alerte testées par `promtool`, Alertmanager vers Mailpit, trois tableaux de bord Grafana provisionnés. Voir [60-observabilite.md](60-observabilite.md) |
-| ETL | Apache Airflow | `etl/airflow` | `En cours` | Webserver et scheduler avec LocalExecutor via Docker Compose, sur une base PostgreSQL dédiée. Six DAGs en sous-processus `uv run` : `ml_train`, `ml_score`, `alertes`, `historical_import`, `mock_api_import` et `derive` (quotidien, surveillance de dérive). L'import historique reste manuel et l'import API Mock s'exécute chaque heure. Réconciliation entre les deux sources (issue #15) : trou temporel accepté, recouvrement refusé à l'ingestion et dédupliqué en défense côté ML, voir [40-data.md](40-data.md). |
-| CI/CD | GitHub Actions | `.github/workflows` | `En cours` | Un orchestrateur `ci.yml` qui n'appelle que les composants modifiés ([ADR 0014](../adr/0014-pipeline-ci-unique-et-deploiement-conditionne.md)) : lint, typage, tests avec seuil de couverture bloquant, tests d'intégration sur TimescaleDB réel, audit de dépendances, SAST Bandit, quality gate SonarCloud, intégrité des DAGs Airflow, Terraform, Compose et supervision, parcours Playwright et tirs k6 contre la stack de prod ([ADR 0015](../adr/0015-tests-e2e-et-de-charge-contre-la-stack-compose.md)). Déploiement vers la VM ENI par `deploy.yml`, appelé une fois « CI ok » vert, `dev` en recette et `main` en production après approbation ([ADR 0009](../adr/0009-deux-environnements-compose-sur-la-vm-eni.md)), mais jamais exécuté : le runner n'est pas enregistré sur la machine. Détail dans [50-cicd.md](50-cicd.md) |
+| Monitoring | Prometheus, Grafana, Alertmanager | `monitoring` | `Cible` | Rien, hors le `/metrics` exposé par l'API |
+| ETL | Apache Airflow | `etl/airflow` | `En cours` | Webserver et scheduler avec LocalExecutor via Docker Compose, sur une base PostgreSQL dédiée. Six DAGs en sous-processus `uv run` : `ml_train`, `ml_score`, `alertes`, `historical_import`, `mock_api_import` et `derive` (quotidien, surveillance de dérive). L'import historique reste manuel et l'import API Mock s'exécute chaque heure. La réconciliation globale des deux sources reste à compléter dans l'issue #15. |
+| CI/CD | GitHub Actions | `.github/workflows` | `En cours` | 7 workflows, 19 jobs : lint, typage, tests avec seuil de couverture bloquant, tests d'intégration sur TimescaleDB réel, audit de dépendances, SAST Bandit, quality gate SonarCloud, intégrité des DAGs Airflow, formatage et validation du Terraform. Déploiement continu vers la VM ENI écrit par `deploy.yml`, `dev` en recette et `main` en production après approbation ([ADR 0009](../adr/0009-deux-environnements-compose-sur-la-vm-eni.md)), mais jamais exécuté : la machine n'est pas provisionnée et le runner n'y est pas enregistré. Détail dans [50-cicd.md](50-cicd.md) |

 ## Flux bout en bout

@@ -108,8 +99,7 @@ Statut : `En cours`. **Le chemin de lecture tourne** entre la base, l'API et le
 dataset CSV/JSON sur déclenchement manuel et `mock_api_import` collecte chaque heure les mesures
 de l'API Mock. Les DAGs `ml_train` et `ml_score` (issue #115), `alertes` (issue #116) et `derive`
 (issue #45) portent le pipeline ML, la détection d'alertes et la surveillance de dérive. La
-réconciliation entre les deux sources de lectures (issue #15) est close : voir
-[40-data.md](40-data.md) pour le détail du garde-fou d'ingestion et de la déduplication ML.
+réconciliation globale des données provenant des deux sources reste à compléter dans l'issue #15.

 ```mermaid
 sequenceDiagram
@@ -158,7 +148,7 @@ consolidée.
 - **Caviardage des journaux** : jetons, empreintes Argon2, mots de passe et cookies sont
  expurgés avant écriture.
 - **Documentation interactive fermée** en préproduction et en production, `/metrics` derrière un
-  jeton, exigé dès que la supervision tourne, sonde de disponibilité qui ne publie plus la version de TimescaleDB.
+  jeton facultatif, sonde de disponibilité qui ne publie plus la version de TimescaleDB.
 - **CI backend bloquante** : format, lint, typage strict et tests avec seuil de couverture.
 - **Conteneur backend non-root**, déclaré dans `apps/backend/Dockerfile`.
 - **Terminaison TLS au frontal** : un reverse proxy Nginx est le seul service publié, il redirige
@@ -37,8 +37,6 @@ flowchart TB
 |---|---|---|
 | `db` | `timescale/timescaledb-ha:pg17` | Publié sur **5433** côté hôte, 5432 souvent déjà pris. `healthcheck` `pg_isready`, 12 tentatives, `start_period` 40s |
 | `backend` | Construite depuis `apps/backend` | `depends_on: db, condition: service_healthy`. **N'embarque pas le source** : toute modification impose `docker compose up -d --build backend` |
-| `prometheus`, `alertmanager`, `grafana`, exporteurs | Images épinglées par tag | Profil `monitoring`, jamais démarrés par `make dev`. `make monitoring-up` les lance en `--no-deps`. Voir [60-observabilite.md](60-observabilite.md) |
-| `k6` | `grafana/k6` | Profil `load`, lancé par `make load-*` le temps d'un tir, sur le réseau du projet. Voir [`tests/load/README.md`](../../tests/load/README.md) |

 **La boucle de développement n'utilise pas le service `backend`.** `make db-up` puis `make dev` :
 seule la base tourne en conteneur, l'API et `ng serve` tournent sur le poste avec le rechargement
@@ -89,7 +87,7 @@ l'[ADR 0008](../adr/0008-airflow-execute-le-code-du-backend.md).
 | `ml_score` | `0 * * * *` | `enervision_ml.score`, dans `/opt/ml/.venv` |
 | `alertes` | `15 * * * *` | `app.detection.internal_alerts` puis `app.cli generate-recommendations`, dans `/opt/backend/.venv` |
 | `historical_import` | manuelle | `app.etl.historical_import`, dans `/opt/backend/.venv` ; les fichiers de `data/raw` sont montés en lecture seule dans `/opt/data/raw` |
-| `mock_api_import` | `45 * * * *` | `app.etl.mock_api_import`, dans `/opt/backend/.venv` ; importe depuis l'API Mock la mesure de l'heure pile précédant son déclenchement |
+| `mock_api_import` | `45 * * * *` | `app.etl.mock_api_import`, dans `/opt/backend/.venv` ; importe l'heure précédant son déclenchement depuis l'API Mock |
 | `derive` | `30 5 * * *` | `app.monitoring.drift`, dans `/opt/backend/.venv` ; quotidien parce que sa fenêtre couvre 168 h, et sans reprise parce qu'une dérive n'est pas une panne passagère |

 Le DAG `historical_import` réutilise le pipeline historique existant sans dupliquer sa logique.
@@ -99,10 +97,8 @@ modifier.

 Le DAG `mock_api_import` exécute le pipeline API Mock toutes les heures, à la minute `:45`.
 Un `CronTriggerTimetable` explicite lui attribue un intervalle d'une heure, y compris lors d'un
-déclenchement manuel, mais la fenêtre transmise au script backend part de l'heure pile qui
-précède le déclenchement (pas de l'intervalle Airflow tel quel), pour que la mesure importée
-tombe à :00 et non à :45, voir [40-data.md](40-data.md). Le pipeline charge la mesure dans les
-tables communes `site` et `reading`. Le décalage à `:45` laisse quinze minutes avant le
+déclenchement manuel. Il transmet cet intervalle au script backend et charge les mesures dans
+les tables communes `site` et `reading`. Le décalage à `:45` laisse quinze minutes avant le
 scoring exécuté à l'heure pile, puis quinze minutes supplémentaires avant les alertes à `:15`.
 `max_active_runs=1` empêche deux exécutions du DAG de se chevaucher.

@@ -205,12 +201,11 @@ flowchart LR
  navigateur["Navigateur"]

  subgraph machine["Machine on-premise"]
-    proxy["service proxy<br/>nginx:1.31-alpine<br/>:80 et :443"]
+    proxy["service proxy<br/>nginx:1.28-alpine<br/>:80 et :443"]
    front["service frontend<br/>nginx statique :3000"]
    api["service backend<br/>uvicorn :8000"]
    db[("service db<br/>:5432")]
    mail["service mailpit"]
-    sup["profil monitoring<br/>Prometheus, Alertmanager, Grafana"]
  end

  navigateur -->|"HTTPS"| proxy
@@ -218,9 +213,6 @@ flowchart LR
  proxy -->|"/api/"| api
  api --> db
  api --> mail
-  sup -->|"/metrics, jeton"| api
-  sup -->|"rôle supervision, lecture seule"| db
-  sup -->|"alertes par courriel"| mail
 ```

 Le proxy est **le seul service à publier des ports** sur le réseau. Backend et frontend ne sont
@@ -235,36 +227,27 @@ Deux conséquences se propagent jusqu'à l'application, et elles ne se devinent
 - `APP_TRUST_PROXY_HEADERS` passe à vrai en même temps, sinon la limitation de débit par IP
  compte sur l'IP du proxy et devient globale.

-### Trois environnements sur la même machine
+### Deux environnements sur la même machine

-Statut : `En cours`. Décision et motifs dans
-l'[ADR 0009](../adr/0009-deux-environnements-compose-sur-la-vm-eni.md), étendue à un troisième
-environnement par l'[ADR 0017](../adr/0017-environnement-dev-a-la-demande.md) ; noms,
-certificats et frontal sans port dans l'[ADR 0018](../adr/0018-noms-publics-certificats-dns01-et-frontal-sni.md).
-La VM `eadl-2025-nantes-g3` porte le développement, la recette et la production, chacun dans son
-clone du dépôt, son `.env` et son projet Compose. Le nom de projet préfixe volumes, réseau et
-conteneurs : rien n'est partagé. `scripts/provision-host.sh` prépare les trois dossiers, génère
-les secrets et les certificats, et ne démarre rien.
+Statut : `En cours`, la machine n'étant pas encore provisionnée. Décision et motifs dans
+l'[ADR 0009](../adr/0009-deux-environnements-compose-sur-la-vm-eni.md).
+La VM `eadl-2025-nantes-g3` portera la recette et la production, chacune dans son clone du dépôt,
+son `.env` et son projet Compose. Le nom de projet préfixe volumes, réseau et conteneurs : rien
+n'est partagé. `scripts/provision-host.sh` prépare les deux dossiers, génère les secrets et les
+certificats, et ne démarre rien.

-| | Développement | Recette | Production |
-|---|---|---|---|
-| Branche, environnement GitHub | toute branche lancée à la main, `dev` | `dev`, `rec` | `main`, `prod` |
-| Dossier, projet Compose | `/srv/enervision/dev`, `enervision-dev` | `/srv/enervision/rec`, `enervision-rec` | `/srv/enervision/prod`, `enervision-prod` |
-| URL | `https://dev.enervision-g3.dynv6.net` | `https://rec.enervision-g3.dynv6.net` | `https://prod.enervision-g3.dynv6.net` |
-| Proxy HTTP, HTTPS, PROXY protocol, sur `127.0.0.1` | `8083`, `9443`, `9444` | `8081`, `8443`, `8444` | `10080`, `10443`, `10444` |
-| PostgreSQL, Mailpit, Airflow, sur `127.0.0.1` | `5435`, `8027`, `8084` | `5434`, `8026`, `8082` | `5433`, `8025`, `8080` |
-| Supervision (profil `monitoring`) | à la demande, `make monitoring-up` | à la demande, `make monitoring-up` | active, `COMPOSE_PROFILES=monitoring` |
-| Grafana, Prometheus, Alertmanager, sur `127.0.0.1` | `3003`, `9092`, `9095` | `3002`, `9091`, `9094` | `3001`, `9090`, `9093` |
+| | Recette | Production |
+|---|---|---|
+| Branche, environnement GitHub | `dev`, `rec` | `main`, `prod` |
+| Dossier, projet Compose | `/srv/enervision/rec`, `enervision-rec` | `/srv/enervision/prod`, `enervision-prod` |
+| URL | `https://rec.enervision.local:8443` | `https://enervision.local` |
+| Proxy HTTP, HTTPS | `127.0.0.1:8081`, `8443` | `80`, `443` |
+| PostgreSQL, Mailpit, Airflow, sur `127.0.0.1` | `5434`, `8026`, `8082` | `5433`, `8025`, `8080` |

-Les trois noms sont publics chez dynv6 et visent l'IP privée de la VM : rien à déclarer sur
-les postes du réseau de l'école, et rien n'est joignable hors de ce réseau. Trois noms distincts
-sont nécessaires : le cookie `__Secure-ev_refresh` est posé par hôte, pas par port.
-
-Aucune stack ne publie hors de la boucle locale. Le frontal `infra/front`, sur le réseau de
-l'hôte, écoute 80 et 443 : il redirige le premier, et aiguille le second d'après le nom demandé
-(SNI) vers l'écouteur PROXY protocol de la stack visée, sans déchiffrer le TLS. Chaque stack
-garde son certificat Let's Encrypt, obtenu par défi DNS-01 (`make tls-dns01`) et renouvelé à
-chaque déploiement ainsi que chaque nuit par `/etc/cron.d/enervision-tls`.
+Les deux noms d'hôte visent la même IP, à déclarer dans le `/etc/hosts` des postes. Deux noms
+distincts sont nécessaires : le cookie `__Secure-ev_refresh` est posé par hôte, pas par port.
+La redirection HTTP de la recette est ramenée sur la boucle locale parce que la configuration
+Nginx renvoie vers `https://$host` sans port, c'est-à-dire vers la production.

 Le déploiement est décrit dans [50-cicd.md](50-cicd.md) : un runner GitHub Actions installé sur
 la VM aligne le dossier sur la branche poussée et lance `make stack-up`.
@@ -284,7 +267,7 @@ sequenceDiagram

  TF->>VM: SSH, get.docker.com puis docker compose version
  TF->>VM: copie et exécute scripts/provision-host.sh
-  VM->>VM: trois clones, trois .env, trois certificats
+  VM->>VM: deux clones, deux .env, deux certificats
  TF->>VM: installe actions-runner, config.sh, svc.sh
  VM->>GH: le runner s'enregistre avec le label eni-g3
 ```
@@ -370,13 +353,11 @@ Ces arbitrages sont pris. Ils ne vivaient jusqu'ici que dans des commentaires de
 | API | `8000` | Identique en conteneur et hors conteneur |
 | Frontend, `ng serve` | `4200` | Boucle de développement. Valeur par défaut d'`APP_CORS_ORIGINS` |
 | Frontend en conteneur | `3000` | Ce qu'écoute le nginx de l'image, en conteneur comme côté hôte |
-| Reverse proxy | `80` et `443`, plus `4443` | Les seuls ports publiés par `docker-compose.prod.yml`, via `PROXY_HTTP_PORT`, `PROXY_HTTPS_PORT` et `PROXY_FRONT_PORT`. 80 ne sert que la redirection et le défi ACME ; 4443 n'accepte que le PROXY protocol du frontal. Sur la VM, tous sur `127.0.0.1` |
-| Frontal SNI de la VM | `80` et `443` de l'hôte | `infra/front`, seul composant exposé sur le réseau de l'école (ADR 0018) |
+| Reverse proxy | `80` et `443` | Les seuls ports publiés par `docker-compose.prod.yml`, via `PROXY_HTTP_PORT` et `PROXY_HTTPS_PORT`. 80 ne sert que la redirection et le défi ACME. La recette publie `8443` et `127.0.0.1:8081` |
 | SSH du serveur | `22` par défaut | `ssh_port`, redéfinissable |
 | Base applicative | `enervision` | Variable `POSTGRES_DB` |
 | Base de test | `enervision_test` | Créée par `db/init/110-test-database.sql`, nom attendu en dur par `apps/backend/tests/conftest.py` |
 | Base de métadonnées Airflow | `airflow` | Créée par `db/init/120-airflow-database.sql`, même conteneur `db` |
-| Grafana, Prometheus, Alertmanager | `3001`, `9090`, `9093` | Sur `127.0.0.1` seulement, profil `monitoring`. `GRAFANA_PORT`, `PROMETHEUS_PORT`, `ALERTMANAGER_PORT`. 3000 est pris par le frontend |
 | API server Airflow | `8080` | `make airflow-up`. Api-server, scheduler et dag-processor ne publient que ce port ; les tâches (`LocalExecutor`) tournent côté scheduler, sans port propre |

 ## Le trou vers k3s
@@ -103,7 +103,7 @@ démarre ne prouve rien sur la base, la première connexion réelle a lieu au pr
 | `APP_LOGIN_MAX_FAILURES_PER_IDENTIFIER` | `50` | Signature d'une attaque distribuée |
 | `APP_TRUST_PROXY_HEADERS` | `false` | À vrai derrière un proxy, sinon le compteur par IP devient global |
 | `APP_EXPOSE_API_DOCS` | déduit | Faux en `staging` et `prod` si non renseigné |
-| `APP_METRICS_TOKEN` | absent | Si présent et non vide, `/metrics` exige `Authorization: Bearer`. Vide vaut absent |
+| `APP_METRICS_TOKEN` | absent | Si présent, `/metrics` exige `Authorization: Bearer` |

 Cinq gardes refusent de démarrer plutôt que de laisser passer une erreur silencieuse :
 secret de moins de 32 caractères ou laissé à sa valeur d'exemple, `debug` en `staging` ou
@@ -423,13 +423,8 @@ Le reste, par ordre de surface :
  écriture des journaux. C'est la troisième ligne de défense : la première est de ne rien passer
  de secret au logger, la deuxième de ne jamais mettre un jeton dans une URL.
 - En-têtes posés par l'application : `X-Content-Type-Options`, `X-Frame-Options`,
-  `Referrer-Policy`, `Cross-Origin-Resource-Policy: same-origin`, plus `Cache-Control: no-store`
-  sur `/auth/*`. Le CORP est fixé à `same-origin` parce qu'aucun client légitime ne charge l'API
-  en `no-cors` (image, script, média) depuis une autre origine : le frontend l'appelle en relatif
-  (`/api/v1`), sur sa propre origine, via `proxy.conf.json` en dev et le reverse proxy nginx
-  (`infra/proxy/conf.d/enervision.conf`) en recette et en production. Les appels `HttpClient`, en
-  mode `cors`, n'y sont de toute façon pas soumis. HSTS et CSP appartiennent au terminateur TLS, que
-  l'application ne connaît pas : le reverse proxy les pose
+  `Referrer-Policy`, plus `Cache-Control: no-store` sur `/auth/*`. HSTS et CSP appartiennent au
+  terminateur TLS, que l'application ne connaît pas : le reverse proxy les pose
  ([ADR 0007](../adr/0007-terminaison-tls-et-reverse-proxy-nginx.md)).
 - Le conteneur tourne en utilisateur non-root, avec un `HEALTHCHECK` sur `/api/v1/health/live`.
 - TLS, limitation de débit au frontal et journal d'accès sont portés par le reverse proxy.
@@ -440,17 +435,7 @@ Le reste, par ordre de surface :

 - Journalisation par `dictConfig` : format console en développement, JSON dès `APP_ENV=prod`.
  `sqlalchemy.engine` est forcé à `WARNING` pour ne pas noyer les journaux.
- `/metrics` au format Prometheus (`prometheus-fastapi-instrumentator`), scruté toutes les 15 s
-  par Prometheus sous le profil `monitoring` ([60-observabilite.md](60-observabilite.md)).
-  - **Séries publiées.** `http_requests_total` par route, méthode et classe de statut, et
-    `http_request_duration_seconds` par route, avec des seaux de 50 ms à 2,5 s autour du seuil
-    de charge de 500 ms (ADR 0015). Aussi `http_request_duration_highr_seconds`, fin mais sans
-    libellé de route, et les métriques du processus.
-  - **Exclusions.** Les sondes `/health/*` et `/metrics` lui-même sont exclus : la sonde Docker
-    de 30 s fausserait débit et latences.
-  - **Un registre par application** (`_registre_de_metriques()` dans `main.py`). Le registre
-    global de `prometheus_client` n'accepte chaque métrique qu'une fois : toute application créée
-    après la première, dans les tests notamment, ne mesurait rien.
+- `/metrics` au format Prometheus. **Aucun collecteur ne le lit** : `monitoring/` est vide.

 ## Tests

@@ -437,29 +437,10 @@ Les paramètres de ligne de commande disponibles pour l'import sont :
 ```text
 --start-time
 --end-time
+--limit
 --dry-run
 ```

-**Piège sur `limit`, corrigé dans le code plutôt que documenté** : l'API ne renvoie pas un flux à
-un rythme naturel, elle répartit exactement `limit` lectures, espacées uniformément, sur toute la
-fenêtre `[start_time, end_time)` demandée, la première au tout début de la fenêtre (vérifié
-empiriquement en interrogeant directement l'API). Une fenêtre d'une heure avec `limit=1000`, le
-réglage d'origine, renvoyait donc 1000 lectures espacées de 3,6 secondes à l'intérieur de cette
-heure, pas une lecture horaire, incompatible avec les lags positionnels de `build_features`.
-Plutôt que documenter la règle « `limit` = nombre d'heures de la fenêtre » et compter sur chaque
-appelant pour la respecter, `limit_for_window()` la porte : `import_mock_api_history()` calcule
-`limit` depuis la fenêtre reçue, refuse une fenêtre dont `start_time` ne tombe pas pile sur
-l'heure (c'est elle qui ancre l'alignement), et refuse un intervalle de plus de 1000 heures (le
-plafond `limit` de l'API). `--limit` n'existe donc plus côté CLI. Deux formes de fenêtre sont
-gérées : un multiple entier d'heures (`limit` = ce nombre d'heures, une lecture par heure
-espacée d'1h pile, chemin du backfill manuel) ou une fenêtre plus courte qu'une heure, ou qui
-n'en est pas un multiple entier (`limit=1`, seule valeur qui reste alignée quand l'espacement
-`durée / limit` ne peut valoir 1h pile). Le DAG `mock_api_import` est dans ce second cas : il
-demande la fenêtre `[heure pile précédant le déclenchement, instant du déclenchement)`, plus
-courte qu'une heure, plutôt que l'intervalle Airflow `[data_interval_start, data_interval_end)`
-tel quel (`[:45, :45)`) qui aurait placé l'unique lecture à :45, hors de la grille horaire du
-reste du schéma.
-
 ### Flux d'ingestion API Mock

 ```text
@@ -511,7 +492,7 @@ réponse est donc traitée comme une entrée hostile, conformément à API10 dan
 [la traçabilité OWASP](owasp-traceabilite.md). Le risque premier n'est pas la fausse alerte,
 c'est l'empoisonnement du jeu d'entraînement du modèle de prédiction.

-Cinq garde-fous, tous dans `mock_api_import.py` :
+Quatre garde-fous, tous dans `mock_api_import.py` :

 | Garde-fou | Mise en œuvre |
 |---|---|
@@ -519,7 +500,6 @@ Cinq garde-fous, tous dans `mock_api_import.py` :
 | Taille de tableau plafonnée | `MAX_SITES` sites, et au plus `--limit` mesures par site |
 | Bornes physiques | `PHYSICAL_BOUNDS`, une plage par grandeur |
 | Frontière d'anti-corruption | `build_site_row()` et `build_reading_row()`, qui ne recopient que les champs attendus |
-| Refus de recouvrir l'historique | `refuse_if_overlaps_historical_dataset()`, voir ci-dessous |

 Une valeur hors bornes, d'un type inattendu, `NaN` ou infinie devient `NULL`. Elle laisse sa
 trace dans `null_reasons` sous la forme `out_of_physical_bounds:<colonne>`, et `data_quality`
@@ -530,51 +510,6 @@ d'origine intacte : rien n'est perdu, seule son exploitation est bornée.
 Le plafond de taille s'applique après désérialisation de la réponse. Borner le corps HTTP
 lui-même demanderait une lecture en flux, et reste à faire.

-### Réconciliation entre les deux sources (issue #15)
-
-`historical_import` (source `csv`) et `mock_api_import` (source `api_history`) écrivent toutes
-deux dans `reading`. Trois décisions ferment cette réconciliation :
-
- **Le trou temporel est accepté.** Le dataset historique s'arrête au 31/12/2024, et
-  `mock_api_import` n'importe que l'heure précédant chaque déclenchement : rien ne comble
-  automatiquement la période intermédiaire, et rien ne le pourra jamais, aucune mesure réelle
-  n'existe pour ces instants. Conséquence pour le ML, pas nouvelle mais que ce trou rend
-  définitive : `build_features()` calcule ses lags par `shift(n)` positionnel, et `train.py`
-  n'écarte que les lignes où `lag_168h` est `NaN`. Pour un site présent dans les deux sources, les
-  168 premières lectures `api_history` qui suivent le trou héritent donc de lags et de moyennes
-  glissantes calculés sur décembre 2024 (et tant que l'ingestion a moins de 7 jours, c'est le cas
-  de toutes les lectures). Même effet, plus ponctuel, pour chaque heure que le DAG manque
-  (`mock_api_import` en échec, Airflow arrêté). Aucun garde-fou ne détecte aujourd'hui un lag
-  calculé sur un écart réel différent de celui attendu ; issue de suivi à ouvrir.
- **Le recouvrement est refusé à l'ingestion.** `uq_reading_source` autorise deux lignes au même
-  `(site_id, timestamp)` dès que `source` diffère : rien dans le schéma n'empêche donc un import
-  Mock API manuel avec une fenêtre passée (le script accepte `--start-time`/`--end-time`
-  arbitraires) de dupliquer un point déjà couvert par le CSV. `import_mock_api_history()` appelle
-  `refuse_if_overlaps_historical_dataset()` avant toute écriture, y compris en `--dry-run` (le
-  contrôle est en lecture seule) et avant le moindre appel à l'API Mock : si la fenêtre demandée
-  recouvre au moins une lecture `source='csv'`, l'import est refusé (`ValueError`) plutôt que
-  d'écrire un doublon inter-source silencieux. Le contrôle ne porte que sur la fenêtre demandée,
-  pas sur les lectures reçues : `fetch_readings()` écarte donc toute lecture dont le `timestamp`
-  déborde de `[start_time, end_time)`, pour qu'une réponse hors fenêtre (bug du mock, ou hostile)
-  ne puisse pas le contourner. Ce contrôle compare des instants, pas des chaînes : `parse_datetime()`
-  pose `tzinfo=UTC` sur une entrée sans fuseau (même pattern que `_vers_utc()` dans
-  `app/services/reading.py`), sans quoi l'encodeur `timestamptz` d'asyncpg lirait un datetime naïf
-  dans le fuseau local du **processus**, correct dans le conteneur Airflow (UTC) mais décalé pour
-  un import manuel lancé depuis un poste en Europe/Paris.
- **Le pipeline ML déduplique en défense.** Le garde-fou ci-dessus protège l'ingestion, pas
-  la lecture : si un recouvrement se produisait malgré tout (import direct en base, contournement
-  du script), `ml/enervision_ml/data.py` ne doit pas casser silencieusement l'hypothèse de
-  `build_features` (« une ligne par `(site_id, timestamp)` »). `load_from_database()` et
-  `load_recent_from_database()` utilisent donc `SELECT DISTINCT ON (site_id, timestamp)`, `source
-  = 'csv'` gagnant sur `'api_history'` en cas d'égalité, l'historique étant une source vérifiée,
-  l'API Mock une entrée hostile (cf. ci-dessus). **Cette préférence est spécifique au chargeur
-  ML.** `GET /readings` renvoie les deux lignes sans les fusionner, et `DriftRepository` /
-  `ReadingRepository.latest_by_site()` / `.latest_for_site()` départagent par `reading_id` le plus
-  grand (en pratique la ligne insérée en dernier, pas forcément `csv`) : en cas de recouvrement, la
-  dérive comparerait alors une prévision à une valeur différente de celle sur laquelle le modèle a
-  appris. Pas d'incohérence aujourd'hui tant que le recouvrement reste refusé à l'ingestion ; à
-  aligner si ce garde-fou devait un jour être contourné.
-
 ### Qualité des données de l'API Mock

 Les valeurs `NULL` ne sont pas remplacées pendant l'ingestion.
@@ -10,9 +10,8 @@ vérifié, ce qui bloque, et ce qui ne l'est pas.

 Le **D** de CI/CD est écrit depuis le 21/09 : `deploy.yml` déploie `dev` en recette et `main` en
 production sur la VM de l'école, par un runner auto-hébergé (issue #21,
-[ADR 0009](../adr/0009-deux-environnements-compose-sur-la-vm-eni.md)). Depuis le 23/09, il ne part
-plus qu'une fois la CI du commit verte ([ADR 0014](../adr/0014-pipeline-ci-unique-et-deploiement-conditionne.md)).
-Il n'a encore rien déployé : le runner n'est pas enregistré sur la machine. Statut à
+[ADR 0009](../adr/0009-deux-environnements-compose-sur-la-vm-eni.md)). Il n'a encore rien
+déployé : la machine n'est pas provisionnée et le runner n'y est pas enregistré. Statut à
 basculer sur `Fait` au premier déploiement vert. Sa limite, nommée ici plutôt que découverte en
 soutenance : les images sont construites sur la machine à chaque déploiement, aucun artefact
 n'est publié puis promu d'un environnement à l'autre.
@@ -25,67 +24,95 @@ GitHub Actions déploie ; aucun des deux ne fait le travail de l'autre.

 ## Vue d'ensemble

-`ci.yml` est le seul point d'entrée des PR et des push sur `dev` et `main`. Il appelle les
-workflows de composant, qui n'ont plus de déclencheur propre, selon les fichiers modifiés
-([ADR 0014](../adr/0014-pipeline-ci-unique-et-deploiement-conditionne.md)).
-
 ```mermaid
 flowchart TB
-  evt["pull_request, ou push sur dev et main"]
-  changes["changes<br/>paths-filter : composants touchés"]
+  push["push ou pull_request"]

-  subgraph comp["Workflows de composant (workflow_call)"]
-    back["backend.yml<br/>lint, typage, tests ≥ 85 %, intégration, pip-audit, bandit"]
-    front["frontend.yml<br/>build et tests, npm audit"]
-    mlw["ml.yml<br/>lint, typage, tests, ML ↔ DB, chaîne ML → API, bandit"]
-    afw["airflow.yml<br/>intégrité des DAGs, image"]
-    infw["infra.yml<br/>Terraform, Compose et supervision, actionlint"]
-    e2e["e2e.yml<br/>stack de prod, Playwright, k6 smoke et limitation"]
+  subgraph back["Backend · .github/workflows/backend.yml"]
+    bv["verification<br/>ruff, mypy, pytest --cov-fail-under=85"]
+    bi["integration<br/>TimescaleDB réel + alembic upgrade head"]
+    bd["security-audit<br/>uv export | pip-audit"]
+    bs["sast<br/>bandit"]
  end

-  sonar["sonar<br/>reprend les couvertures du run"]
-  ok["CI ok<br/>seul check à exiger"]
-  dep["deploy.yml<br/>runner eni-g3, rec ou prod"]
+  subgraph front["Frontend · frontend.yml"]
+    fb["build<br/>npm ci, npm run build"]
+    ft["test<br/>couverture lcov"]
+    fd["security-audit<br/>npm audit --audit-level=high"]
+  end

-  evt --> changes --> back & front & mlw & afw & infw & e2e
-  back & front & mlw --> sonar
-  back & front & mlw & afw & infw & e2e & sonar --> ok
-  ok -->|"push sur dev ou main"| dep
+  subgraph mlw["ML · ml.yml"]
+    mv["verification<br/>ruff, mypy, pytest"]
+    ms["sast<br/>bandit"]
+  end

-  planifie["chaque lundi 3h UTC, à la main,<br/>ou PR sur ses fichiers"]
-  dast["dast.yml<br/>seed + scan actif OWASP ZAP"]
-  planifie --> dast
+  subgraph afw["Airflow · airflow.yml"]
+    av["verification<br/>ruff, intégrité des DAGs"]
+    ab["image<br/>construction de l'image"]
+  end
+
+  subgraph infw["Infra · infra.yml"]
+    it["terraform<br/>fmt -check, init et validate par racine"]
+  end
+
+  subgraph sq["SonarQube · sonarqube.yml"]
+    sb1["build-front / test-front"]
+    sb2["build-back / test-back"]
+    sb3["test-ml"]
+    sscan["sonarqube<br/>quality gate SonarCloud"]
+  end
+
+  push --> bv & bi & bd & bs
+  push --> fb --> ft
+  push --> fd
+  push --> mv & ms
+  push --> av & ab
+  push --> it
+  push --> sb1 & sb2 & sb3 --> sscan
+
+  subgraph cd["Déploiement · deploy.yml"]
+    dep["deploy<br/>runner eni-g3, environnement rec ou prod"]
+  end
+
+  push -->|"push sur dev ou main"| dep
+
+  planifie["chaque lundi 3h UTC,<br/>ou à la main"]
+  subgraph dastw["DAST · dast.yml"]
+    zscan["zap<br/>seed + scan actif OWASP ZAP"]
+  end
+
+  planifie --> zscan
+  push -->|"PR sur dast.yml<br/>ou dast-token.sh"| zscan
 ```

 ## Déclenchement

-**Sur une PR**, le job `changes` lit la liste des fichiers modifiés par l'API GitHub
-(`dorny/paths-filter`, épinglé sur un SHA) et chaque composant n'est appelé que si son filtre
-vaut vrai. Une PR de documentation ne joue que `changes` et `CI ok`. Modifier `ci.yml` rejoue
-tout.
+Les six workflows hébergés par GitHub qui vérifient le code se déclenchent sur `push` **et** sur
+`pull_request`, filtrés par **chemin** : `backend.yml` sur `apps/backend/**`, `frontend.yml` sur
+`apps/frontend/**`, `ml.yml` sur `ml/**`, `infra.yml` sur `infra/terraform/**`, `airflow.yml` sur
+`etl/airflow/**` **plus des chemins de `ml/` et de `apps/backend/`**, chacun incluant son propre
+fichier de workflow dans le filtre pour qu'une modification du pipeline déclenche le pipeline.

-**Sur un push vers `dev` ou `main`**, tous les filtres valent vrai. C'est le moment où l'analyse
-Sonar doit couvrir tout le dépôt, et paths-filter comparerait sinon le push à sa base de fusion
-avec `main`, en retard de 80 commits. Une branche de travail ne déclenche plus rien par un push :
-la CI part de sa PR, une seule fois par commit.
+`dast.yml` s'en écarte volontairement (détail dans sa propre section plus bas) : aucun
+déclenchement sur `push`, seulement `workflow_dispatch`, une planification hebdomadaire, et
+`pull_request` restreint à ses deux seuls fichiers. Un scan actif est trop long pour tourner à
+chaque commit.

-Deux filtres écoutent plus que leur dossier, parce que ce qu'ils testent dépend d'autres modules :
+Le filtre d'`airflow.yml` mérite un mot : il inclut `ml/pyproject.toml`, `ml/uv.lock`,
+`ml/enervision_ml/**`, `apps/backend/pyproject.toml`, `apps/backend/uv.lock` et
+`apps/backend/app/**` parce que l'image Airflow copie le code et les dépendances des deux
+modules : celles du ML pour `ml_train`/`ml_score`, celles du backend depuis que le DAG `alertes`
+y exécute les commandes de détection ([ADR 0008](../adr/0008-airflow-execute-le-code-du-backend.md)).
+Une modification de l'un ou l'autre peut donc casser la construction de cette image, et le filtre
+le voit.

- `airflow` inclut `ml/pyproject.toml`, `ml/uv.lock`, `ml/enervision_ml/**`,
-  `apps/backend/pyproject.toml`, `apps/backend/uv.lock` et `apps/backend/app/**`. L'image
-  Airflow copie le code et les dépendances des deux modules
-  ([ADR 0008](../adr/0008-airflow-execute-le-code-du-backend.md)), et une modification de l'un
-  ou de l'autre peut casser sa construction.
- `e2e` inclut le frontend, l'API, ses migrations et son Dockerfile, le proxy, les fichiers
-  Compose, `db/`, `tests/` et les scripts qu'il appelle : tout ce qui change un parcours.
+**Piège à connaître** : il n'y a **aucun filtre de branche**. Une branche de travail déclenche la
+CI complète à chaque push, et un merge vers n'importe quelle branche la déclenche aussi. C'est
+délibéré pendant le projet (retour au plus tôt, et la CI tournera sur `main` dès la remontée sans
+rien changer), mais ce serait à borner sur un dépôt à forte fréquence de push.

-`dast.yml` reste hors de l'orchestrateur : un scan actif est trop long pour chaque PR. Il se
-lance à la main, chaque lundi, et sur une PR qui modifie le scan, son jeu de données ou ses
-comptes.
-
-Le groupe de concurrence de `ci.yml` annule le run d'une PR devenu obsolète par un push plus
-récent. Pour un push sur `dev` ou `main`, le groupe est le SHA et rien n'est annulé : un run
-coupé en plein `make stack-up` laisserait la stack à moitié redémarrée.
+`backend.yml`, `ml.yml` et `airflow.yml` déclarent en plus un groupe de concurrence par référence
+git avec `cancel-in-progress`, ce qui annule un run devenu obsolète par un push plus récent.

 **Piège de version** : `etl/airflow` tourne en **Python 3.12** et non 3.14 : c'est l'interpréteur
 de l'image `apache/airflow:3.3.2-python3.12` retenue, et les tests d'intégrité doivent tourner sur
@@ -94,52 +121,35 @@ environnement.

 ## Déploiement

-`deploy.yml` est le seul workflow qui ne tourne pas chez GitHub : il s'exécute sur un runner
-auto-hébergé installé sur la VM ENI, label `eni-g3`, parce que les runners hébergés ne joignent
-pas une adresse privée d'école. Le runner se connecte en sortie vers GitHub, aucun port entrant
-n'est ouvert. Il n'a pas de déclencheur propre en dehors de `workflow_dispatch` : c'est le job
-`deploy` de `ci.yml` qui l'appelle, sur un push, une fois « CI ok » vert.
+`deploy.yml` est le huitième workflow (`backend`, `frontend`, `ml`, `infra`, `airflow`,
+`sonarqube`, `dast`, plus lui-même), et le seul qui ne tourne pas chez GitHub : il s'exécute sur
+un runner auto-hébergé installé sur la VM ENI, label `eni-g3`, parce que les runners hébergés ne
+joignent pas une adresse privée d'école. Le runner se connecte en sortie vers GitHub, aucun port
+entrant n'est ouvert.

 | Événement | Environnement GitHub | Dossier sur la VM | Garde |
 |---|---|---|---|
-| `push` sur `dev`, « CI ok » vert | `rec` | `/srv/enervision/rec` | aucune de plus : la recette suit `dev` |
-| `push` sur `main`, « CI ok » vert | `prod` | `/srv/enervision/prod` | approbation d'un relecteur dans l'environnement `prod`, branche `main` seule autorisée |
-| `workflow_dispatch` sur toute autre branche | `dev` | `/srv/enervision/dev` | droit d'écriture sur le dépôt, seul à pouvoir lancer un workflow ([ADR 0017](../adr/0017-environnement-dev-a-la-demande.md)) |
+| `push` sur `dev` | `rec` | `/srv/enervision/rec` | aucune : la recette suit `dev` |
+| `push` sur `main` | `prod` | `/srv/enervision/prod` | approbation d'un relecteur dans l'environnement `prod`, branche `main` seule autorisée |

-Le job aligne le clone sur **le commit testé** (`fetch`, `checkout`, `reset --hard $GITHUB_SHA`),
-et non sur la pointe de branche du moment, qui a pu avancer pendant la CI. Il lance
+Le job aligne le clone sur la branche (`fetch`, `checkout`, `reset --hard`), lance
 `make stack-up`, qui reconstruit les images, redémarre les conteneurs puis applique les
 migrations Alembic dans le conteneur backend, et attend jusqu'à trois minutes que
 `/api/v1/health/ready` réponde derrière le proxy. Cette sonde ne vérifie que la connexion à la
 base et la présence de TimescaleDB : sans la migration, le déploiement serait vert sur une base
-sans schéma, et c'est pourquoi `make stack-up` la porte.
-
-Les CI de deux push rapprochés peuvent finir dans le désordre. Deux gardes empêchent un
-environnement de reculer ou de sauter un commit :
-
- un commit qui **précède** celui déjà déployé depuis la même branche est ignoré, avec une
-  annotation dans le run. Dans `dev`, une autre branche que celle en place est toujours déployée ;
- les déploiements d'un même environnement passent un par un sous un verrou `flock` posé dans le
-  clone de la VM, y compris deux branches lancées coup sur coup dans `dev`. Un groupe
-  `concurrency` ne convenait pas : GitHub n'y garde qu'un job en attente, et un troisième arrivé
-  l'annule sans erreur.
+sans schéma, et c'est pourquoi `make stack-up` la porte. Un groupe de concurrence par branche,
+sans annulation, empêche deux déploiements simultanés du même environnement.

 Le job ne fait pas de `actions/checkout` dans son espace de travail, et c'est voulu : le dossier
 de l'environnement est stable, hors du runner, parce que `.env`, certificats et volumes doivent
 survivre d'un déploiement à l'autre.

 **Piège à connaître.** Un runner auto-hébergé sur un dépôt public exécute ce qu'un workflow lui
-envoie, et une PR de fork peut ajouter son propre workflow qui vise le label `eni-g3`. L'absence
-de `pull_request` dans `deploy.yml` ne suffit donc pas. Ce qui protège vraiment le runner :
-
- le dépôt exige l'approbation des workflows de tous les contributeurs externes (Settings,
-  Actions, « Require approval for all external contributors ») ;
- les environnements `rec` et `prod` n'acceptent que leur branche (`dev`, `main` avec un
-  relecteur), ce qui bloque un job qui les déclare avant qu'il atteigne le runner ;
- le runner tourne sous un utilisateur dédié membre du groupe `docker`, jamais root.
-
-Les deux réglages de dépôt restent à activer par l'administratrice. Tous les autres workflows
-restent sur `ubuntu-latest`.
+envoie, et une PR de fork peut réécrire un workflow. Trois parades, et les trois sont
+nécessaires : `deploy.yml` ne se déclenche jamais sur `pull_request` ; le runner tourne sous un
+utilisateur dédié membre du groupe `docker`, jamais root ; le dépôt doit exiger une approbation
+pour les workflows des PR externes (Settings, Actions, « Require approval for all outside
+collaborators »), ce qui reste à activer. Les workflows de CI restent sur `ubuntu-latest`.

 Cet utilisateur dédié doit posséder `/srv/enervision` : sinon git refuse les deux clones pour
 propriété douteuse et le `.env` en `600` lui échappe. `PROPRIETAIRE=<utilisateur du runner>`
@@ -147,7 +157,7 @@ passé à `scripts/provision-host.sh` fixe ce propriétaire.

 La machine se prépare avec `scripts/provision-host.sh`, qui vérifie Docker et Compose 2.24.4 ou
 plus, clone les deux branches, génère les secrets de chaque `.env` et les certificats
-auto-signés, et ne démarre rien. Le détail des trois environnements, ports et noms d'hôte, est
+auto-signés, et ne démarre rien. Le détail des deux environnements, ports et noms d'hôte, est
 dans [10-infra.md](10-infra.md).

 ## Ce qui bloque un merge
@@ -169,14 +179,6 @@ dans [10-infra.md](10-infra.md).
 | Intégrité des DAGs | airflow | chargement des DAGs sans erreur d'import | Bloque |
 | Construction de l'image Airflow | airflow | `docker build` de `etl/airflow/Dockerfile` | Bloque |
 | Formatage et validité Terraform | infra | `fmt -check -recursive`, puis `init` et `validate` par racine | Bloque |
-| Verrous uv à jour | backend, ml, airflow | `uv sync --locked` : un `uv.lock` qui ne suit plus `pyproject.toml` échoue | Bloque |
-| Fichiers Compose | infra | `docker compose config` sur la stack de dev et la stack déployée, tous profils | Bloque |
-| Supervision | infra | `promtool check config`, `promtool test rules` (un cas par alerte), `amtool check-config`, JSON des tableaux | Bloque |
-| Workflows | infra | `actionlint`, shellcheck compris sur les blocs `run:` | Bloque |
-| Parcours de bout en bout | e2e | 18 parcours Playwright contre la stack de prod (proxy TLS) | Bloque |
-| Tir k6 de fumée | e2e | p95 < 500 ms et p99 < 1 s sur les lectures, moins de 1 % d'échecs | Bloque |
-| Limitation de débit | e2e | k6 par le proxy : des 429 au-delà de 20 req/s, aucune 5xx | Bloque |
-| **CI ok** | ci.yml | aucun job en `failure` ou `cancelled` | Bloque, **seul check à exiger** |

 Deux seuils portent une décision qu'il faut savoir défendre :

@@ -216,7 +218,7 @@ qu'évite déjà le choix de l'image `timescaledb-ha` plutôt qu'un `postgres` n
 donc les deux environnements uv, applique `alembic upgrade head`, puis joue `-m integration` côté
 `ml/` et `-m chaine` côté backend.

-Conséquence sur le déclenchement : le filtre `ml` de `ci.yml` inclut `apps/backend/alembic/**` et
+Conséquence sur le déclenchement : les `paths` de `ml.yml` incluent `apps/backend/alembic/**` et
 `apps/backend/app/models/**`. Sans eux, une migration qui renomme une colonne de `reading` ne
 déclencherait pas ce job, le SQL brut du pipeline dériverait du schéma, et **rien ne casserait
 avant la production**. Le prix est qu'une PR touchant seulement une migration lance aussi le lint
@@ -231,18 +233,10 @@ poste où `ml/` n'est pas installé.

 ## SonarCloud, et l'incident qui a immobilisé trois PR

-Le job `sonar` de `ci.yml` ne reconstruit ni ne reteste rien. Les jobs `verification` de
-`backend.yml`, `ml.yml` et `frontend.yml` versent leur rapport de couverture en artefact, et
-`sonar` les télécharge dans le même run, un par un (backend et ML nomment tous deux le leur
-`coverage.xml`), puis lance `SonarSource/sonarqube-scan-action`, épinglée sur un SHA, avec le
-secret `SONAR_TOKEN`. Il ne tourne ni pour Dependabot ni pour une PR de fork, qui n'ont pas ce
-secret. Le périmètre est décrit par `sonar-project.properties` à la racine, seul fichier de
-configuration Sonar du dépôt.
-
-Jusqu'au 23/09, un `sonarqube.yml` à part rejouait build et tests des trois modules pour produire
-ces rapports, en double exact des workflows qui le faisaient déjà. Les exclusions de
-`sonar-project.properties` sont aussi passées en globs (`**/tests/**`, `**/alembic/**`) : un
-motif sans `**` ne vise que la racine du dépôt.
+Le workflow `sonarqube.yml` exécute cinq jobs de préparation (`build-front`, `test-front`,
+`build-back`, `test-back`, `test-ml`) dont les tests produisent chacun un rapport de couverture en
+artefact, puis un dernier job qui les télécharge et lance `SonarSource/sonarqube-scan-action@v8`
+avec le secret `SONAR_TOKEN`. Le périmètre est décrit par `sonar-project.properties` à la racine.

 Le périmètre couvre `apps/frontend`, `apps/backend`, `ml/` et `etl/airflow` (les deux derniers
 ajoutés après coup : ils n'étaient pas analysés, une PR qui ne touchait qu'eux ne lançait pas
@@ -267,10 +261,9 @@ contournée** en désactivant la gate ou en excluant les fichiers gênants.

 ## Dependabot

-`.github/dependabot.yml` déclare **sept entrées hebdomadaires, sur cinq écosystèmes** : `npm`
-sur `/apps/frontend` et sur `/tests/e2e`, `uv` sur `/apps/backend`, `github-actions` sur `/`,
-`docker` sur les deux dossiers d'application, et `docker-compose` sur `/`, qui suit aussi les
-images de supervision et de k6. Les mises à jour arrivent en PR, donc
+`.github/dependabot.yml` déclare **six entrées hebdomadaires groupées, sur cinq écosystèmes** :
+`npm` sur `/apps/frontend`, `uv` sur `/apps/backend`, `github-actions` sur `/`, `docker` sur les
+deux dossiers d'application, et `docker-compose` sur `/`. Les mises à jour arrivent en PR, donc
 elles traversent les mêmes gates que n'importe quel changement : une montée de version qui casse
 les tests ne se merge pas.

@@ -307,10 +300,10 @@ UTC, et sur une PR qui modifie le scan lui-même. Pas à chaque PR : un scan act
 minutes.

 Le job démarre sur le runner la base (même image TimescaleDB que `docker-compose.yml`, base
-jetable), applique les migrations, y sème `db/seeds/demo.sql` (sans données, `GET /sites` rend
-`[]`, chaque `/{site_id}` rend 404, et le scan actif ne frappe que des gestionnaires d'erreur),
-démarre le backend, puis `scripts/dast-token.sh` s'appuie sur `scripts/comptes-test.sh` pour
-créer les comptes et rend le jeton du **`lecteur`**. Le jeu et les comptes sont ceux de l'e2e.
+jetable), applique les migrations, y sème un site et deux relevés (`db/seeds/` est vide, pas
+encore d'outillage de jeu de données pour la CI ; sans données, `GET /sites` rend `[]`, chaque
+`/{site_id}` rend 404, et le scan actif ne frappe que des gestionnaires d'erreur), démarre le
+backend, puis `scripts/dast-token.sh` crée un compte **`lecteur`** et rend son jeton.

 ZAP charge le contrat `/openapi.json` depuis un fichier (`zap-api-scan.py -f openapi -t
 /zap/wrk/openapi.json`) et en importe les 26 opérations **quel que soit le jeton** : c'est le
@@ -399,34 +392,15 @@ pas de TLS, pas de reverse proxy). Il remontera des alertes qui n'existent pas d
 (HSTS absent...) et ne dit **rien** des en-têtes ni du TLS que le proxy pose en production. Un
 second passage sur la stack complète reste à faire.

-## Tests de bout en bout et de charge
-
-Le workflow `e2e.yml` démarre la stack telle qu'elle est déployée, derrière le proxy TLS, sur
-`https://localhost` ([ADR 0015](../adr/0015-tests-e2e-et-de-charge-contre-la-stack-compose.md)) :
-
-1. Il construit et démarre `db`, `mailpit`, `backend`, `frontend` et `proxy` avec
-   `docker-compose.prod.yml`, sans Airflow. C'est le seul job qui construit les images backend et
-   frontend avant un déploiement.
-2. Il migre la base, pose le rôle `supervision`, sème `db/seeds/demo.sql` et crée les comptes
-   (`scripts/comptes-test.sh`).
-3. Il joue les 18 parcours Playwright de `tests/e2e`, sur un seul worker et avec une session par
-   fichier. Le rapport HTML et les traces du premier réessai sont versés en artefact.
-4. Il lance le tir k6 `smoke`, directement sur `backend:8000`, puis `limitation-debit` par le
-   proxy. Les synthèses s'affichent dans le résumé du job, et les rapports HTML sont versés en
-   artefact.
-
-La charge nominale (`make load-test`) et le stress (`make load-stress`) ne tournent pas en CI :
-voir `tests/load/README.md`.
-
 ## Ce qui manque, et pourquoi

 | Manque | Issue | Conséquence assumée |
 |---|---|---|
 | Images publiées et promues par digest (GHCR) | aucune | Chaque environnement reconstruit ses images : la production n'exécute pas l'artefact validé en recette, mais un second build du même commit |
 | DAST bloquant | #41 | Le scan ZAP existe mais ne bloque rien : aucun seuil n'est fixé tant que les alertes du premier passage ne sont pas triées |
-| Tir de charge nominal automatisé | #47 | Seul le smoke tourne en CI ; la charge à 50 utilisateurs se lance à la main en recette (`make load-test`), rec et prod partageant la VM |
-| Cache de couches Docker en CI | aucune | Le job E2E reconstruit les images backend et frontend à chaque run, deux à quatre minutes de plus |
-| Scan d'image de conteneur | aucune | Les images sont construites par le job E2E, pas analysées |
+| Tests end to end | #46 | Les parcours utilisateur ne sont pas vérifiés en CI |
+| Tests de charge | #47 | Aucun garde-fou de performance |
+| Scan d'image de conteneur | aucune | Les `Dockerfile` sont construits en local, pas analysés |

 ## Reproduire la CI en local

@@ -443,14 +417,6 @@ make ml-test-integration    # pipeline ML, marqueur `integration`
 make test-chaine            # vrais binaires ML puis relecture par l'API, marqueur `chaine`
 ```

-Les autres jobs se rejouent aussi sur le poste :
-
-```bash
-make e2e-prepare e2e        # parcours Playwright contre `make dev` (tests/e2e/README.md)
-make load-smoke K6_EMAIL=... K6_PASSWORD=...   # tir k6 d'une minute (tests/load/README.md)
-make monitoring-check       # promtool, amtool et JSON des tableaux de bord, comme le job Infra
-```
-
 Le SAST se rejoue à l'identique : `uvx bandit==1.9.4 --recursive app --severity-level medium
 --confidence-level medium` depuis `apps/backend`, et la même commande sur `enervision_ml` depuis
 `ml`.
@@ -1,113 +0,0 @@
-# Observabilité
-
-Ce document décrit ce qu'on voit du système en fonctionnement : métriques, tableaux de bord,
-alertes et journaux. Décision dans l'[ADR 0016](../adr/0016-supervision-en-profil-compose.md),
-mode d'emploi dans [`monitoring/README.md`](../../monitoring/README.md).
-
-| Brique | Sert à | Statut |
-|---|---|---|
-| Métriques de l'API | Débit, erreurs et latences par route | `Fait` |
-| Collecte et alertes | Prometheus, neuf règles testées, Alertmanager vers Mailpit | `Fait` |
-| Tableaux de bord | Grafana : API, données et modèle, infrastructure | `Fait` |
-| Métriques d'Airflow | StatsD ou OpenTelemetry des DAGs | `Cible` |
-| Journaux centralisés | Loki ou équivalent | `Cible` |
-
-## Vue d'ensemble
-
-```mermaid
-flowchart LR
-  subgraph projet["Projet Compose de la prod"]
-    api["backend<br/>/metrics"]
-    db[("db<br/>TimescaleDB")]
-    mail["mailpit"]
-
-    subgraph sup["Profil monitoring"]
-      prom["prometheus<br/>15 s, 15 jours"]
-      am["alertmanager"]
-      graf["grafana"]
-      pge["postgres-exporter"]
-      node["node-exporter"]
-      cad["cadvisor"]
-    end
-  end
-
-  hote["Hôte : VM ENI<br/>recette et prod"]
-
-  prom -->|"Bearer APP_METRICS_TOKEN"| api
-  prom --> pge & node & cad
-  pge -->|"rôle supervision"| db
-  node -.->|"/proc, /sys"| hote
-  cad -.->|"cgroups"| hote
-  prom -->|"règles franchies"| am -->|"SMTP"| mail
-  graf --> prom
-  graf -->|"rôle supervision, SQL"| db
-```
-
-Tout vit dans le projet Compose de la prod, sur son réseau. La recette n'a pas de supervision
-propre. node-exporter et cAdvisor voient pourtant tout l'hôte : la mémoire de la VM et de chaque
-conteneur couvre donc aussi la recette, qu'on distingue au préfixe `enervision-rec-`.
-
-## Ce que mesure chaque source
-
-| Source | Métriques utiles | Où les lire |
-|---|---|---|
-| API (`prometheus-fastapi-instrumentator`) | `http_requests_total` par route et classe de statut, `http_request_duration_seconds` par route (seaux 50 ms à 2,5 s), `http_request_duration_highr_seconds` global, mémoire du processus | Tableau « API » |
-| postgres-exporter | `pg_up`, connexions par état, `max_connections`, transactions validées, taille des bases | Tableau « Infrastructure » |
-| node-exporter | Processeur, mémoire disponible, espace disque de `/` | Tableau « Infrastructure » |
-| cAdvisor | Mémoire (`working_set`) et processeur par conteneur | Tableau « Infrastructure » |
-| TimescaleDB, en SQL | Fraîcheur des relevés par site, relevés ingérés par heure, alertes par sévérité, `drift_report` | Tableau « Données et modèle » |
-
-Deux choix de l'instrumentation se lisent dans ces courbes :
-
- **Les sondes `/health/*` et `/metrics` ne sont pas comptées.** La sonde Docker frappe toutes
-  les 30 s : incluse, elle ferait baisser la latence moyenne et gonfler le débit d'une API au
-  repos.
- **Les seaux par route encadrent 500 ms**, seuil de charge de l'ADR 0015. Grafana lit ainsi le
-  même p95 que k6 pendant un tir.
-
-## Alertes
-
-| Groupe | Alertes | Sévérité |
-|---|---|---|
-| API | Indisponible 2 min, 5xx au-delà de 5 %, p95 au-delà d'une seconde | critical, critical, warning |
-| Base | PostgreSQL injoignable 2 min, connexions au-delà de 80 % | critical, warning |
-| Hôte | Mémoire au-delà de 90 %, disque sous 10 %, processeur au-delà de 90 % | warning, critical, warning |
-| Supervision | Un exporteur muet 5 min | warning |
-
- **Tests des règles.** Chaque règle a un cas dans `monitoring/prometheus/tests/`, joué par
-  `promtool test rules` dans le job Infra de la CI. Une règle qui ne se déclenche plus, ou se
-  déclenche à tort, casse la CI avant d'atteindre la prod.
- **Envoi.** Alertmanager groupe les alertes par nom et sévérité et les envoie par courriel via
-  Mailpit, qui les capture sans rien relayer. Un `critical` est rappelé toutes les heures, un
-  `warning` toutes les douze. Un `critical` masque le `warning` de la même cible.
-
-## Sécurité
-
- **Aucune interface exposée.** Prometheus, Alertmanager et Grafana n'écoutent que sur
-  `127.0.0.1`, et rien ne passe par le proxy (ADR 0007). Accès par tunnel SSH.
- **`/metrics` gardé par jeton.** Il n'est pas routé par nginx, et Prometheus y présente
-  `APP_METRICS_TOKEN`, que l'API exige dès qu'il est posé. Le jeton lui parvient en secret
-  Compose, jamais en clair dans sa configuration.
- **Base en lecture seule.** Grafana et postgres-exporter lisent la base par le rôle
-  `supervision`, en lecture seule, limité aux tables métier (`db/roles/supervision.sql`). Ils
-  n'ont ni `app_user`, ni jetons, ni journal d'audit.
- **Grafana verrouillé.** Il refuse de démarrer sans `GRAFANA_ADMIN_PASSWORD`. Inscription,
-  accès anonyme et appels sortants (statistiques d'usage, vérification de mises à jour) y sont
-  désactivés.
- **cAdvisor en `privileged`.** Il tourne ainsi pour lire les cgroups, avec des montages en
-  lecture seule et sans port publié.
-
-## Journaux
-
-Les journaux restent ceux de Docker : `docker compose logs`, `make stack-logs`,
-`make monitoring-logs`. L'API écrit du JSON dès `APP_ENV=prod`, caviardé des jetons et des mots
-de passe (voir [20-backend.md](20-backend.md)). Aucune agrégation centralisée n'est en place.
-
-## Ce qui manque
-
-| Manque | Conséquence assumée |
-|---|---|
-| Métriques d'Airflow (StatsD, OpenTelemetry) | Un DAG qui échoue ne se voit que dans Airflow ; le tableau « Données » le trahit indirectement par des relevés qui vieillissent |
-| Alerte sur la fraîcheur des relevés | Visible dans Grafana, mais aucune règle Prometheus ne la porte : il faudrait une métrique calculée par l'API ou un exportateur SQL |
-| Journaux centralisés | Un incident se diagnostique conteneur par conteneur |
-| Destinataire réel des alertes | Mailpit capture tout : les alertes se lisent dans son interface, elles ne réveillent personne |
@@ -15,12 +15,12 @@ contredisent, c'est l'ADR qui fait foi et la vue qui est en retard.
 | [31-contrat-authentification.md](31-contrat-authentification.md) | Ce que le frontend doit savoir pour coder la connexion |
 | [32-design-systeme-frontend.md](32-design-systeme-frontend.md) | Tokens CSS, composants `ev-*` partagés, règle anti-couleur-en-dur |
 | [40-data.md](40-data.md) | Frontières `db/` et `alembic/`, cycle de vie d'une mesure, modèle |
-| [50-cicd.md](50-cicd.md) | Orchestrateur `ci.yml`, gates bloquantes, e2e et charge, SonarCloud, Dependabot, ce qui manque |
-| [60-observabilite.md](60-observabilite.md) | Métriques, Prometheus, alertes, tableaux de bord Grafana, ce qui manque |
+| [50-cicd.md](50-cicd.md) | Workflows, gates bloquantes, SonarCloud, Dependabot, ce qui manque |

-La CI/CD a son document : un orchestrateur et ses workflows de composant, c'est assez de
-matière pour qu'une section de plus dans une autre vue devienne illisible. L'observabilité a le
-sien depuis l'issue #26, qui lui a donné de la matière : collecte, alertes et tableaux de bord.
+La CI/CD a désormais son document : cinq workflows et seize jobs, c'est assez de matière pour
+qu'une section de plus dans une autre vue devienne illisible. L'observabilité, elle, n'en a
+toujours pas : `monitoring/` ne contient que des `.gitkeep`. Elle en sortira le jour où elle aura
+de la matière. Un fichier vide de plus n'aide personne.

 L'orchestration Airflow, elle, en a depuis les issues #115 et #116 : trois DAGs, leur image et
 leurs contraintes sont décrits dans [10-infra.md](10-infra.md).
@@ -39,7 +39,7 @@ lecture seule ; plusieurs lignes resteront à compléter une fois les endpoints
 | Cinq gardes de configuration qui refusent le démarrage plutôt que de dégrader silencieusement | `app/core/config.py` | A05 |
 | Documentation interactive fermée hors développement, `/metrics` derrière un jeton, sonde qui ne publie plus de version | `app/main.py`, `app/api/security.py` | A05 |
 | Scan dynamique OWASP ZAP de l'API authentifiée (compte `lecteur` jetable), non bloquant, configuration par défaut du backend uniquement (ni TLS ni en-têtes du reverse proxy) | `.github/workflows/dast.yml`, `scripts/dast-token.sh` | A05, API8 Security Misconfiguration |
-| En-têtes `nosniff`, `DENY`, `no-referrer`, `Cross-Origin-Resource-Policy: same-origin`, et `no-store` sur les routes d'authentification | `app/api/middleware.py` | A05 |
+| En-têtes `nosniff`, `DENY`, `no-referrer`, et `no-store` sur les routes d'authentification | `app/api/middleware.py` | A05 |
 | Refus de rétrograder ou désactiver le dernier administrateur actif | `app/services/user.py` | A04 Insecure Design |
 | Amorçage du premier administrateur hors dépôt, mot de passe jamais dans `argv` ni dans Git | `app/cli.py` | A02, A05 |
 | Réponse de l'API Mock bornée avant écriture : timeout, plafond de sites et de mesures, bornes physiques par grandeur, recopie des seuls champs attendus | `app/etl/mock_api_import.py` | API10 Unsafe Consumption of APIs |
@@ -668,18 +668,15 @@ le pipeline ML (`ml_train` et `ml_score`, issue #115), la détection d'alertes e
 des recommandations (`alertes`, issue #116), l'import historique (`historical_import`,
 issue #119) et l'import périodique de l'API Mock (`mock_api_import`, issue #15).

-Le DAG `mock_api_import` s'exécute chaque heure, à la minute `:45`, sur une fenêtre qui part de
-l'heure pile précédant son déclenchement jusqu'à l'instant du déclenchement lui-même (pas
-l'intervalle Airflow `data_interval_start`/`end` tel quel). L'API Mock génère autant de points que
-la limite demandée, répartis sur la fenêtre et le premier à son début :
-`app.etl.mock_api_import.limit_for_window()` dérive donc `limit` de la fenêtre reçue (une seule
-lecture ici, ancrée sur l'heure pile) plutôt que de dépendre d'une valeur fixée à la main côté
-DAG, et refuse une fenêtre qui ne démarre pas pile sur l'heure. Une fenêtre calée sur l'intervalle
-Airflow tel quel (`[:45, :45)`) placerait cette lecture à :45, hors de la grille horaire du reste
-du schéma (vérifié empiriquement contre l'API Mock) ; partir de l'heure pile évite ce décalage.
-Les deux pipelines normalisent leurs données vers les tables communes `site` et `reading`, tout en
-conservant leur source (`csv` ou `api_history`). La réconciliation entre les deux sources
-(issue #15) est close : voir `docs/architecture/40-data.md`.
+Le DAG `mock_api_import` s'exécute chaque heure, à la minute `:45`. Il appelle
+`app.etl.mock_api_import` avec un intervalle explicite d'une heure et une limite de 1 000 lectures
+par site. Les deux pipelines normalisent leurs données vers les tables communes `site` et
+`reading`, tout en conservant leur source (`csv` ou `api_history`). La réconciliation globale
+des deux sources reste à compléter dans l'issue #15.
+
+Le DAG `mock_api_import` exécute `app.etl.mock_api_import` toutes les heures. Chaque exécution
+traite l'intervalle Airflow précédent. Les deux pipelines normalisent leurs données vers les
+tables communes `site` et `reading`, tout en conservant leur source (`csv` ou `api_history`).

 Airflow permet de planifier les traitements, gérer leur ordre d'exécution, suivre leur état et remonter les erreurs. Il ne remplace pas la logique ETL Python existante : les scripts actuels restent responsables de l'extraction, de la validation, de la transformation et du chargement. `etl/airflow/dags/ml_train.py`, `ml_score.py`, `alertes.py`, `historical_import.py` et
 `mock_api_import.py` montrent le patron retenu (des `BashOperator` qui invoquent le script tel quel, dans l'environnement `uv` que l'image embarque pour lui).
@@ -1,7 +1,7 @@
 """DAG d'import périodique des données de l'API Mock EnerVision (issue #15).

 Orchestre le pipeline existant `app.etl.mock_api_import` sans dupliquer sa logique ETL.
-Chaque exécution importe la mesure de l'heure pile qui précède son déclenchement.
+Chaque exécution traite l'heure précédant son déclenchement.

 Le pipeline backend reste responsable de la validation, de la normalisation, du suivi de la
 qualité, de l'idempotence et du chargement dans PostgreSQL/TimescaleDB.
@@ -18,6 +18,10 @@ from airflow.timetables.trigger import CronTriggerTimetable
 # Le backend possède son propre environnement uv dans l'image Airflow (ADR 0008).
 COMMANDE_BACKEND = "cd /opt/backend && env -u VIRTUAL_ENV uv run --no-sync python -m"

+# Le pipeline backend et l'API acceptent au maximum 1 000 lectures par site.
+# Cette marge évite de perdre silencieusement une lecture si une heure en contient plus de 60.
+LIMITE_LECTURES = 1000
+
 # Deux reprises donnent trois tentatives au total. Même dans le pire cas, l'exécution reste
 # inférieure au pas horaire du DAG.
 NOMBRE_REPRISES = 2
@@ -26,11 +30,7 @@ PLAFOND_PAR_TENTATIVE = timedelta(minutes=10)

 # L'intervalle est déclaré explicitement pour ne pas dépendre de la valeur du paramètre Airflow
 # `create_cron_data_intervals`. Le déclenchement à :45 laisse quinze minutes avant `ml_score`,
-# exécuté à l'heure pile, puis avant `alertes`, exécuté à :15. La fenêtre demandée à l'API Mock
-# (voir `bash_command` ci-dessous) ne suit pas cet intervalle Airflow tel quel : elle part de
-# l'heure pile qui précède le déclenchement, pas de `data_interval_start`, pour que l'unique
-# lecture demandée (`app.etl.mock_api_import.limit_for_window()`) atterrisse à :00 et non à :45
-# (vérifié empiriquement sur l'API Mock), au pas horaire du reste du schéma, cf. 40-data.md.
+# exécuté à l'heure pile, puis avant `alertes`, exécuté à :15.
 PLANIFICATION = CronTriggerTimetable(
    "45 * * * *",
    timezone="UTC",
@@ -51,16 +51,9 @@ with DAG(
        task_id="import_mock_api",
        bash_command=(
            f"{COMMANDE_BACKEND} app.etl.mock_api_import "
-            # `--start-time` part de l'heure pile qui précède le déclenchement, pas de
-            # `data_interval_start` : sur `[:45, :45)`, l'API aurait placé son unique lecture
-            # à :45, hors de la grille horaire du reste du schéma (vérifié empiriquement).
-            "--start-time \"{{ data_interval_end.strftime('%Y-%m-%dT%H:00:00') }}\" "
-            "--end-time \"{{ data_interval_end.strftime('%Y-%m-%dT%H:%M:%S') }}\""
-            # Pas de --limit : app.etl.mock_api_import.limit_for_window() le dérive de la
-            # fenêtre (ici plus courte qu'une heure, donc une seule lecture, ancrée sur
-            # --start-time) et refuse une fenêtre qui ne démarre pas pile sur l'heure. Porter
-            # la règle dans le code, pas dans ce DAG, évite qu'un appel manuel oublie de la
-            # respecter.
+            "--start-time \"{{ data_interval_start.strftime('%Y-%m-%dT%H:%M:%S') }}\" "
+            "--end-time \"{{ data_interval_end.strftime('%Y-%m-%dT%H:%M:%S') }}\" "
+            f"--limit {LIMITE_LECTURES}"
        ),
        retries=NOMBRE_REPRISES,
        retry_delay=DELAI_ENTRE_REPRISES,
@@ -113,13 +113,12 @@ def test_mock_api_import_calls_the_existing_backend_module(dagbag: DagBag) -> No
    assert "app.etl.mock_api_import" in commande


-def test_mock_api_import_asks_for_the_on_the_hour_reading(dagbag: DagBag) -> None:
+def test_mock_api_import_uses_the_airflow_data_interval(dagbag: DagBag) -> None:
    commande = dagbag.dags["mock_api_import"].get_task("import_mock_api").bash_command

-    assert "--start-time \"{{ data_interval_end.strftime('%Y-%m-%dT%H:00:00') }}\"" in commande
+    assert "--start-time \"{{ data_interval_start.strftime('%Y-%m-%dT%H:%M:%S') }}\"" in commande
    assert "--end-time \"{{ data_interval_end.strftime('%Y-%m-%dT%H:%M:%S') }}\"" in commande
-    # Pas de --limit : app.etl.mock_api_import.limit_for_window() le dérive de la fenêtre.
-    assert "--limit" not in commande
+    assert "--limit 1000" in commande


@pytest.mark.parametrize("task_id", ["detection", "recommandations"])
@@ -8,9 +8,8 @@ Rien ici ne construit d'image ni ne lance de conteneur.
  - `k3s` : installe un cluster k3s single-node sur une machine distante via SSH
    (script officiel `get.k3s.io`) et rapatrie le kubeconfig en local.
 - `terraform/environments/<racine>` : une racine par machine provisionnee.
-  - `vm-eni` : la VM `eadl-2025-nantes-g3`, qui porte les environnements `dev`, `rec` et `prod`
-    ([ADR 0009](../docs/adr/0009-deux-environnements-compose-sur-la-vm-eni.md),
-    [ADR 0017](../docs/adr/0017-environnement-dev-a-la-demande.md)). Installe Docker,
+  - `vm-eni` : la VM `eadl-2025-nantes-g3`, qui porte les environnements `rec` et `prod`
+    ([ADR 0009](../docs/adr/0009-deux-environnements-compose-sur-la-vm-eni.md)). Installe Docker,
    execute `scripts/provision-host.sh`, enregistre le runner GitHub Actions.
  - `k3s-cible` : le cluster k3s, cible a terme de `docs/architecture/10-infra.md`. Jamais
    applique.
@@ -33,16 +32,9 @@ terraform apply
  Parametres du depot, Actions, Runners, New self-hosted runner. Seul un administrateur du depot
  peut le creer.

-Apres l'apply, la machine porte `/srv/enervision/dev`, `/srv/enervision/rec` et
-`/srv/enervision/prod`, chacun avec son `.env` et son certificat. Le premier demarrage reste
-manuel, `make stack-up` dans chaque dossier ; les suivants sont joues par le runner a chaque push
-sur `dev` et sur `main`, et a chaque lancement manuel d'une autre branche pour `dev`.
-
-Noms et certificats (ADR 0018) : avant l'apply, la zone `domaine` doit exister chez dynv6 et son
-jeton se trouver dans `<racine>/dns.token` (600, proprietaire). L'apply fait alors pointer la
-zone, `prod`, `rec` et `dev` vers la machine, obtient un certificat Let's Encrypt par environnement et planifie leur
-renouvellement ; sans jeton, chaque environnement garde un certificat auto-signe. Le frontal SNI (`infra/front`)
-se demarre une fois depuis le dossier de la prod, `make front-up`.
+Apres l'apply, la machine porte `/srv/enervision/rec` et `/srv/enervision/prod`, chacun avec son
+`.env` et son certificat. Le premier demarrage reste manuel, `make stack-up` dans chaque dossier ;
+les suivants sont joues par le runner a chaque push sur `dev` et sur `main`.

 Retirer le runner se fait a la main, depuis les parametres du depot : `terraform destroy` ne le
 desinscrit pas.
@@ -1,12 +0,0 @@
-# Pourquoi : le réseau de l'hôte, parce que les trois stacks publient leur écouteur PROXY protocol
-# sur 127.0.0.1 et que seul un conteneur sur l'hôte joint cette boucle locale (ADR 0018).
-
-name: enervision-front
-
-services:
-  front:
-    image: nginx:1.31-alpine
-    network_mode: host
-    volumes:
-      - ./nginx.conf:/etc/nginx/nginx.conf:ro
-    restart: unless-stopped
@@ -1,46 +0,0 @@
-# Pourquoi : trois environnements sur une seule IP, des URL sans port (ADR 0018). Ce frontal lit
-# le nom demandé dans le ClientHello (SNI) et relaie le flux TLS intact vers le proxy de la
-# stack visée : il ne détient aucun certificat, chaque stack garde le sien et ses en-têtes.
-# Piège : relayé tel quel, le flux arriverait avec l'IP du frontal, et les limitations de débit
-# de nginx et du backend deviendraient globales. D'où `proxy_protocol on`, reçu sur l'écouteur
-# 4443 de chaque stack (infra/proxy/conf.d/enervision.conf), qui y restaure l'IP du client.
-# Contrainte : ces ports sont ceux que `scripts/provision-host.sh` donne à PROXY_FRONT_PORT.
-
-worker_processes auto;
-error_log /var/log/nginx/error.log warn;
-pid /var/run/nginx.pid;
-
-events {
-    worker_connections 1024;
-}
-
-stream {
-    log_format aiguillage '$remote_addr [$time_local] $ssl_preread_server_name '
-                          '-> $upstream_addr $status $session_time';
-    access_log /var/log/nginx/access.log aiguillage;
-
-    map $ssl_preread_server_name $stack {
-        ~^rec\.  127.0.0.1:8444;
-        ~^dev\.  127.0.0.1:9444;
-        default  127.0.0.1:10444;
-    }
-
-    server {
-        listen 443;
-        ssl_preread on;
-        proxy_pass $stack;
-        proxy_protocol on;
-        proxy_connect_timeout 5s;
-    }
-}
-
-http {
-    server_tokens off;
-    access_log off;
-
-    server {
-        listen 80 default_server;
-        server_name _;
-        return 301 https://$host$request_uri;
-    }
-}
@@ -76,28 +76,8 @@ Renouvellement, à passer en tâche planifiée sur la machine :
 17 3 * * * cd /srv/enervision && make tls-renew >> /var/log/enervision-tls.log 2>&1
 ```

-### Let's Encrypt par DNS-01, le mode de la VM
-
-La VM n'a qu'une IP privée : le défi HTTP-01 y est impossible. Ses trois noms sont chez dynv6,
-dont l'API pose l'enregistrement TXT du défi DNS-01, et acme.sh le fait sans rien ouvrir
-([ADR 0018](../../docs/adr/0018-noms-publics-certificats-dns01-et-frontal-sni.md)).
-
-```bash
-make tls-dns01          # PUBLIC_HOST lu dans .env, jeton dans ../dns.token (600)
-```
-
-Autre fournisseur : `DNS01_API` et `DNS01_JETON_VAR` nomment le greffon acme.sh et sa variable
-(`dns_cf` et `CF_Token` pour Cloudflare, par exemple). La cible est rejouable : acme.sh ne renouvelle qu'à trente jours de l'échéance, installe le
-résultat dans `tls/` et recharge le proxy s'il tourne. Son état vit dans `acme/`, ignoré par git.
-`deploy.yml` la rejoue avant chaque `make stack-up`, et `/etc/cron.d/enervision-tls` chaque nuit.
-
-## Écouteur PROXY protocol
-
-Sur la VM, le frontal `infra/front` relaie les connexions TLS sans les déchiffrer. Reçues sur
-443, elles porteraient son adresse, et `limit_req` comme `get_client_ip()` compteraient tous les
-postes comme un seul. Le port 4443 ne les accepte qu'avec l'en-tête PROXY protocol, d'où
-`real_ip_header proxy_protocol` tire l'IP du client ; seules les adresses des réseaux Docker ont
-le droit de l'annoncer, et le port n'est publié que sur `127.0.0.1` (`PROXY_FRONT_PORT`).
+Pour un domaine sans port 80 entrant, le défi DNS-01 est l'alternative : elle demande un
+greffon certbot propre au fournisseur DNS et un jeton d'API, hors périmètre à ce jour.

 ## Vérifier la configuration sans démarrer la stack

@@ -7,8 +7,6 @@
 # variable et le résolveur interne de Docker : la résolution redevient dynamique.
 # Pourquoi : la redirection 80 vers 443 conserve `$host` plutôt qu'un nom canonique, faute de
 # quoi l'accès par IP cesserait de fonctionner sur la cible. Risque acté dans l'ADR 0007.
-# Piège : 4443 n'accepte que le PROXY protocol du frontal (infra/front, ADR 0018), qui y porte
-# l'IP du client. Seules les adresses des réseaux Docker ont le droit de l'annoncer.

 server {
    listen 80 default_server;
@@ -25,14 +23,9 @@ server {

 server {
    listen 443 ssl default_server;
-    listen 4443 ssl proxy_protocol default_server;
    http2 on;
    server_name _;

-    set_real_ip_from 172.16.0.0/12;
-    set_real_ip_from 192.168.0.0/16;
-    real_ip_header proxy_protocol;
-
    resolver 127.0.0.11 valid=10s ipv6=off;

    ssl_certificate     /etc/nginx/tls/fullchain.pem;
@@ -1,11 +1,31 @@
 # This file is maintained automatically by "terraform init".
 # Manual edits may be lost in future updates.

-provider "registry.terraform.io/hashicorp/null" {
-  version     = "3.3.2"
-  constraints = "~> 3.2"
+provider "registry.terraform.io/hashicorp/archive" {
+  version     = "2.8.1"
+  constraints = "~> 2.4"
  hashes = [
-    "h1:IQ1qrkht1sC1nibUR+AJ3ulryyhVDHfCHZhoJi0sg2Y=",
+    "h1:eehhIUcuegkswQDKArYBAhVV9wQmRVMhyYGaD7kHIj0=",
+    "zh:03de290604114a89fcd45c2e5bc7787d5a1ebfc5f964fb5989306bea7a4c79ec",
+    "zh:0a7d69dc9fbbc48960bc2f04588c8fb1bd92c78a8f306566b7fb17fc4a4f2058",
+    "zh:4df1f3981379c35f1757da957470f7f7724496b57219da3485177cf1647bdf59",
+    "zh:50f0e72ba53bfe6e11b03b7fc899e1f72536354381d302a743a274ae2a3f45f4",
+    "zh:5c4e15a04c98e2a8cafb1cd9632b48ad318051e8462d105b1153006277985c35",
+    "zh:66069e604bcf5c4af0278e15997d9e6bd755c54fb3801d78885838b889729c5f",
+    "zh:78d5eefdd9e494defcb3c68d282b8f96630502cac21d1ea161f53cfe9bb483b3",
+    "zh:979765db3f42601870ab377104ba70befb029547b278337ec4ada980e3582de6",
+    "zh:b165254da774f49945a73fbccc3ef1b63d70ea00a98fa9e14716665ba80ecaad",
+    "zh:c0bb2697b525da9fec4511f569ed2bd2b42f25d5c1f9fa00f8f3645b50cfc2e9",
+    "zh:c48f6695d12df0d0fa5231f7c1b8d518a4feae91a733fdd35a5804af3a303831",
+    "zh:d589954c93f075180c9f4e2ce91780d5edcb56dfd0d3cda8ba08e13c10b52249",
+    "zh:f5792ed06da65d0daf7ca3711f5399ff78c7cb4400afe53fbce9a926fbde4477",
+  ]
+}
+
+provider "registry.terraform.io/hashicorp/null" {
+  version = "3.3.2"
+  hashes = [
+    "h1:7rn0+p+fbrHfJxNVgTnlKp6C3yu0jENMXffz9Xb9XjQ=",
    "zh:10ec43b8b7b18d5639238c7fb9e111f6a4b038523dd66c7a426bf27b25fa4c08",
    "zh:60beb9cc2ad5b871c710860cee75b42850cc6acd43db0d77cb5e00fda7288b55",
    "zh:62538582d0a4a2f10ad8a8d9a6c3cd3f05af6c6d91c6641ffc78d4f0e8e69b27",
@@ -21,3 +41,23 @@ provider "registry.terraform.io/hashicorp/null" {
    "zh:faa01928c25d2a6ecd9c7eb8b88134cb08de55a6b11ca6c703ac0092845344ba",
  ]
 }
+
+provider "registry.terraform.io/kreuzwerker/docker" {
+  version     = "4.5.0"
+  constraints = "~> 4.5.0"
+  hashes = [
+    "h1:eXPMxNcZjz5gC7Nc1oEPJldpI6B5btbvldjLOgJQNbI=",
+    "zh:0ee4e9121632158a9ae1049bdd53c71fd9e06357de915dd193df2c1c55ae8814",
+    "zh:12c6991012b5a548a406e1960c323484f95a9538c2522af15ec82f47fdb832d1",
+    "zh:19c86ae59ed1e062e8402a49ea842f957fcda2f9689e06ecbd9480cc9bd1e41a",
+    "zh:3ac8bc9805acd20c40c0ed474c9f4605aa73b61cf52809e1131e335fcbfe8e49",
+    "zh:5a0e70d143759712fdda109f024a41d59d4758b5615378aa21ee6b959f65a416",
+    "zh:5d3599285f71cc53c88a5802fa6e2f8ba87b9deea03abe5fe8bb2639e9d95654",
+    "zh:a42f573a2526cddc9b8a93637a2c5478bc6e903ff29556ab8b2f1467681d5bde",
+    "zh:c8de50d902cc8457e565a5d959f1e3e49064d31c2f14f7adf5f3ec632cfe3695",
+    "zh:d40543d51eb4e902125d2c5a8a0f425a60edcec6c1dc07c4a89d92335ec05541",
+    "zh:dd3105018ffddc8114083dcf84798c32fdecca7ef708eceaee49eb4b306fc061",
+    "zh:e51e0199700698b962085683af4551d1f982dce37f3b6950da062c65e0145505",
+    "zh:ffe415d3d3deffffdbd3a7173e3a9f90b74601cb6d8acafec1ab701a5b91dbff",
+  ]
+}
@@ -0,0 +1,78 @@
+locals {
+  backend_dir            = "../../../../apps/backend"
+  backend_image_name     = "enervision-back"
+  backend_image_tag      = "latest"
+  backend_container_name = "enervision-backend"
+}
+
+resource "docker_image" "backend" {
+  name = "${local.backend_image_name}:${local.backend_image_tag}"
+
+  build {
+    context    = local.backend_dir
+    dockerfile = "Dockerfile"
+  }
+
+  triggers = {
+    build_hash = sha256(join("", [
+      for file in fileset(local.backend_dir, "**") :
+      filesha256("${local.backend_dir}/${file}")
+    ]))
+  }
+}
+
+resource "docker_container" "backend" {
+  image = docker_image.backend.image_id
+  name  = local.backend_container_name
+
+  ports {
+    internal = 8000
+    external = var.backend_port
+  }
+
+  volumes {
+    host_path      = "/var/log/enervision"
+    container_path = "/var/log/enervision"
+  }
+
+  depends_on = [docker_image.backend]
+}
+
+resource "null_resource" "deploy_backend_to_server" {
+  depends_on = [docker_image.backend]
+
+  triggers = {
+    image_id = docker_image.backend.image_id
+  }
+
+  connection {
+    type        = "ssh"
+    host        = var.ssh_host
+    port        = var.ssh_port
+    user        = var.ssh_user
+    password    = var.ssh_password
+    private_key = try(file(pathexpand(var.ssh_private_key_path)), null)
+    timeout     = "5m"
+  }
+
+  provisioner "file" {
+    source      = "${local.backend_dir}/Dockerfile"
+    destination = "/tmp/Dockerfile"
+  }
+  provisioner "file" {
+    source      = "${local.backend_dir}/"
+    destination = "/tmp/backend/"
+  }
+
+  provisioner "remote-exec" {
+    inline = [
+      "cd /tmp/backend",
+      "sudo docker stop ${local.backend_container_name} 2>/dev/null || true",
+      "sudo docker rm ${local.backend_container_name} 2>/dev/null || true",
+      "sudo docker build -t ${local.backend_image_name}:${local.backend_image_tag} .",
+      "sudo docker run -d --name ${local.backend_container_name} -p ${var.backend_port}:8000 --restart always -v /var/log/enervision:/var/log/enervision ${local.backend_image_name}:${local.backend_image_tag}"
+    ]
+  }
+}
+
+
@@ -0,0 +1,145 @@
+locals {
+  frontend_environments = {
+    dev = {
+      source_dir = "${path.root}/../../../../apps/frontend/dist/frontend/browser"
+      domain     = "dev.enervision"
+    }
+  }
+
+  frontend_dir   = "../../../../apps/frontend"
+  image_name     = "enervision-front"
+  image_tag      = "latest"
+  container_name = "enervision-frontend"
+
+  selected_frontend = local.frontend_environments[var.deployment_environment]
+}
+
+provider "docker" {
+  host = var.docker_host
+}
+
+#  Build le front
+resource "null_resource" "build_frontend" {
+  triggers = {
+    frontend_files = sha256(join("", [
+      for file in fileset(local.frontend_dir, "src/**,package.json") :
+      filesha256("${local.frontend_dir}/${file}")
+    ]))
+  }
+
+  provisioner "local-exec" {
+    command = "cd ${local.frontend_dir} && npm ci && chmod -R +x node_modules/@angular/cli/bin && chmod -R +x node_modules/.bin && npm exec ng build"
+  }
+}
+
+# Build l'image docker du front
+resource "docker_image" "frontend" {
+  name = "${local.image_name}:${local.image_tag}"
+
+  build {
+    context    = local.frontend_dir
+    dockerfile = "Dockerfile"
+  }
+
+  triggers = {
+    build_hash = sha256(join("", [
+      for file in fileset(local.frontend_dir, "**") :
+      filesha256("${local.frontend_dir}/${file}")
+    ]))
+  }
+
+  depends_on = [null_resource.build_frontend]
+}
+
+# Création du container Docker
+resource "docker_container" "frontend" {
+  image = docker_image.frontend.image_id
+  name  = local.container_name
+
+  ports {
+    internal = 3000
+    external = var.frontend_port
+  }
+
+  # Volume pour les logs
+  volumes {
+    host_path      = "/var/log/enervision"
+    container_path = "/var/log/nginx"
+  }
+
+  depends_on = [docker_image.frontend]
+}
+
+resource "null_resource" "create_network" {
+  provisioner "remote-exec" {
+    connection {
+      type        = "ssh"
+      host        = var.ssh_host
+      port        = var.ssh_port
+      user        = var.ssh_user
+      password    = var.ssh_password
+      private_key = try(file(pathexpand(var.ssh_private_key_path)), null)
+      timeout     = "5m"
+    }
+
+    inline = [
+      "sudo docker network create enervision_default 2>/dev/null || true"
+    ]
+  }
+}
+
+# Déploiement du container sur le serveur via SSH
+resource "null_resource" "deploy_to_server" {
+  depends_on = [docker_image.frontend]
+
+  triggers = {
+    image_id = docker_image.frontend.image_id
+  }
+
+  connection {
+    type        = "ssh"
+    host        = var.ssh_host
+    port        = var.ssh_port
+    user        = var.ssh_user
+    password    = var.ssh_password
+    private_key = try(file(pathexpand(var.ssh_private_key_path)), null)
+    timeout     = "5m"
+  }
+
+  # Copie le Dockerfile et nginx.conf
+  provisioner "file" {
+    source      = "${local.frontend_dir}/Dockerfile"
+    destination = "/tmp/Dockerfile"
+  }
+
+  provisioner "file" {
+    source      = "${local.frontend_dir}/nginx.conf"
+    destination = "/tmp/nginx.conf"
+  }
+
+  # Copie les sources pour le build
+  provisioner "file" {
+    source      = "${local.frontend_dir}/"
+    destination = "/tmp/frontend/"
+  }
+
+  # Build et lance le container sur le serveur
+  provisioner "remote-exec" {
+    inline = [
+      "cd /tmp/frontend",
+      "sudo docker stop ${local.container_name} 2>/dev/null || true",
+      "sudo docker rm ${local.container_name} 2>/dev/null || true",
+      "sudo docker build -t ${local.image_name}:${local.image_tag} .",
+      "sudo docker run -d \\",
+      "  --name ${local.container_name} \\",
+      "  --network enervision_default \\",
+      "  --network-alias frontend \\",
+      "  -p ${var.frontend_port}:3000 \\",
+      "  --restart always \\",
+      "  -v /var/log/enervision:/var/log/nginx \\",
+      "  ${local.image_name}:${local.image_tag}"
+    ]
+  }
+}
+
+
@@ -5,7 +5,24 @@ module "k3s" {
  ssh_port               = var.ssh_port
  ssh_user               = var.ssh_user
  ssh_private_key_path   = var.ssh_private_key_path
+  ssh_password           = var.ssh_password
  k3s_version            = var.k3s_version
  k3s_disable_components = var.k3s_disable_components
  kubeconfig_output_path = var.kubeconfig_output_path
 }
+
+provider "vault" {
+  # Adresse du serveur Vault (dev)
+  address = "https://10.101.200.37:8200"
+
+  # Auth par userpass 
+  auth_login {
+    path = "auth/userpass/login/${var.vault_username}"
+    parameters = {
+      login    = var.vault_username
+      password = var.vault_password
+    }
+  }
+  # Skip verify pour dev uniquement (pas en prod!)
+  # skip_client_verification = true
+}
@@ -21,6 +21,35 @@ variable "ssh_private_key_path" {
  sensitive   = true
 }

+variable "ssh_password" {
+  type      = string
+  sensitive = true
+}
+
+variable "remote_path" {
+  type        = string
+  description = "Chemin distant sur le serveur pour le deploiement."
+  default     = "/var/www/enervision"
+}
+
+variable "docker_host" {
+  type        = string
+  default     = "npipe:////.//pipe//docker_engine"
+  description = "Host Docker (local ou distant)"
+}
+
+variable "frontend_port" {
+  type        = number
+  default     = 3000
+  description = "Port externe du frontend"
+}
+
+variable "backend_port" {
+  type        = number
+  default     = 8000
+  description = "Port externe du backend"
+}
+
 variable "k3s_version" {
  type        = string
  description = "Version k3s a epingler pour un deploiement reproductible (ex: v1.31.5+k3s1). Voir https://github.com/k3s-io/k3s/releases."
@@ -37,3 +66,25 @@ variable "kubeconfig_output_path" {
  description = "Chemin local ou ecrire le kubeconfig recupere apres installation."
  default     = "./kubeconfig"
 }
+
+variable "deployment_environment" {
+  type    = string
+  default = "dev"
+
+  validation {
+    condition     = contains(["dev", "rec", "prod"], var.deployment_environment)
+    error_message = "L'environnement doit être dev, rec ou prod."
+  }
+}
+
+variable "vault_username" {
+  description = "Username Vault"
+  type        = string
+  sensitive   = false
+}
+
+variable "vault_password" {
+  description = "Password Vault"
+  type        = string
+  sensitive   = true
+}
@@ -0,0 +1,125 @@
+locals {
+  frontend_environments = {
+    prod = {
+      source_dir = "${path.root}/../../../apps/frontend/dist/frontend/browser"
+      domain     = "enervision"
+    }
+  }
+
+  frontend_dir   = "../../../../apps/frontend"
+  image_name     = "enervision-front"
+  image_tag      = "latest"
+  container_name = "enervision-frontend"
+
+  selected_frontend = local.frontend_environments[var.deployment_environment]
+}
+
+provider "docker" {
+  host = var.docker_host
+}
+
+# Build le front
+resource "null_resource" "build_frontend" {
+  triggers = {
+    frontend_files = sha256(join("", [
+      for file in fileset(local.frontend_dir, "src/**,package.json") :
+      filesha256("${local.frontend_dir}/${file}")
+    ]))
+  }
+
+  provisioner "local-exec" {
+    command = "cd ${local.frontend_dir} && npm ci && chmod -R +x node_modules/@angular/cli/bin && chmod -R +x node_modules/.bin && npm exec ng build"
+  }
+}
+
+# Build l'image docker du front
+resource "docker_image" "frontend" {
+  name = "${local.image_name}:${local.image_tag}"
+
+  build {
+    context    = local.frontend_dir
+    dockerfile = "Dockerfile"
+  }
+
+  triggers = {
+    build_hash = sha256(join("", [
+      for file in fileset(local.frontend_dir, "**") :
+      filesha256("${local.frontend_dir}/${file}")
+    ]))
+  }
+
+  depends_on = [null_resource.build_frontend]
+}
+
+# Création du container Docker
+resource "docker_container" "frontend" {
+  image = docker_image.frontend.image_id
+  name  = local.container_name
+
+  ports {
+    internal = 3000
+    external = var.frontend_port
+  }
+
+  # Volume pour les logs
+  volumes {
+    host_path      = "/var/log/enervision"
+    container_path = "/var/log/nginx"
+  }
+
+  depends_on = [docker_image.frontend]
+}
+
+# Déploiement du container sur le serveur via SSH
+resource "null_resource" "deploy_to_server" {
+  depends_on = [docker_image.frontend]
+
+  triggers = {
+    image_id = docker_image.frontend.image_id
+  }
+
+  connection {
+    type        = "ssh"
+    host        = var.ssh_host
+    port        = var.ssh_port
+    user        = var.ssh_user
+    password    = var.ssh_password
+    private_key = try(file(pathexpand(var.ssh_private_key_path)), null)
+    timeout     = "5m"
+  }
+
+  # Copie le Dockerfile et nginx.conf
+  provisioner "file" {
+    source      = "${local.frontend_dir}/Dockerfile"
+    destination = "/tmp/Dockerfile"
+  }
+
+  provisioner "file" {
+    source      = "${local.frontend_dir}/nginx.conf"
+    destination = "/tmp/nginx.conf"
+  }
+
+  # Copie les sources pour le build
+  provisioner "file" {
+    source      = "${local.frontend_dir}/"
+    destination = "/tmp/frontend/"
+  }
+
+  # Build et lance le container sur le serveur
+  provisioner "remote-exec" {
+    inline = [
+      "cd /tmp/frontend",
+      "sudo docker stop ${local.container_name} 2>/dev/null || true",
+      "sudo docker rm ${local.container_name} 2>/dev/null || true",
+      "sudo docker build -t ${local.image_name}:${local.image_tag} .",
+      "sudo docker run -d \\",
+      "  --name ${local.container_name} \\",
+      "  --network enervision_default \\",
+      "  --network-alias frontend \\",
+      "  -p ${var.frontend_port}:3000 \\",
+      "  --restart always \\",
+      "  -v /var/log/enervision:/var/log/nginx \\",
+      "  ${local.image_name}:${local.image_tag}"
+    ]
+  }
+}
@@ -0,0 +1,11 @@
+module "k3s" {
+  source = "../../modules/k3s"
+
+  ssh_host               = var.ssh_host
+  ssh_port               = var.ssh_port
+  ssh_user               = var.ssh_user
+  ssh_private_key_path   = var.ssh_private_key_path
+  k3s_version            = var.k3s_version
+  k3s_disable_components = var.k3s_disable_components
+  kubeconfig_output_path = var.kubeconfig_output_path
+}
@@ -0,0 +1,9 @@
+output "kubeconfig_path" {
+  description = "Chemin local du kubeconfig recupere apres installation."
+  value       = module.k3s.kubeconfig_path
+}
+
+output "node_host" {
+  description = "Adresse du serveur sur lequel k3s est installe."
+  value       = module.k3s.node_host
+}
@@ -0,0 +1,39 @@
+variable "ssh_host" {
+  type        = string
+  description = "Adresse IP ou nom d'hote du serveur on-premise de l'ecole."
+}
+
+variable "ssh_port" {
+  type        = number
+  description = "Port SSH du serveur."
+  default     = 22
+}
+
+variable "ssh_user" {
+  type        = string
+  description = "Utilisateur SSH utilise pour l'installation."
+  default     = "root"
+}
+
+variable "ssh_private_key_path" {
+  type        = string
+  description = "Chemin local vers la cle privee SSH."
+  sensitive   = true
+}
+
+variable "k3s_version" {
+  type        = string
+  description = "Version k3s a epingler pour un deploiement reproductible (ex: v1.31.5+k3s1). Voir https://github.com/k3s-io/k3s/releases."
+}
+
+variable "k3s_disable_components" {
+  type        = list(string)
+  description = "Composants embarques k3s a desactiver."
+  default     = ["traefik"]
+}
+
+variable "kubeconfig_output_path" {
+  type        = string
+  description = "Chemin local ou ecrire le kubeconfig recupere apres installation."
+  default     = "./kubeconfig"
+}
@@ -0,0 +1,14 @@
+terraform {
+  required_version = ">= 1.7"
+
+  required_providers {
+    null = {
+      source  = "hashicorp/null"
+      version = "~> 3.2"
+    }
+  }
+
+  backend "local" {
+    path = "terraform.tfstate"
+  }
+}
@@ -0,0 +1,57 @@
+locals {
+  frontend_environments = {
+    rec = {
+      source_dir = "${path.root}/../../../apps/frontend/dist/frontend-rec/browser"
+      domain     = "rec.enervision"
+    }
+  }
+
+  selected_frontend = local.frontend_environments[var.deployment_environment]
+}
+
+resource "null_resource" "frontend" {
+  depends_on = [module.k3s]
+
+  triggers = {
+    environment = var.deployment_environment
+    
+    build_hash = sha256(join("", [
+      for file in fileset("${path.root}/../../../apps/frontend/dist/frontend/browser", "**") :
+      filesha256("${path.root}/../../../apps/frontend/dist/frontend/browser/${file}")
+    ]))
+  }
+
+  // Variables pour la connexion SSH
+  connection {
+    type        = "ssh"
+    host        = var.ssh_host
+    port        = var.ssh_port
+    user        = var.ssh_user
+    private_key = file(pathexpand(var.ssh_private_key_path))
+  }
+
+  // Lancement de script en SSH avec remote-exec
+  // Installation de Nginx et initialisation du répertoire du frontend
+  provisioner "remote-exec" {
+    inline = [
+      "sudo apt-get update",
+      "sudo apt-get install -y nginx",
+      "sudo mkdir -p /var/www/enervision",
+      "sudo rm -rf /var/www/enervision/*"
+    ]
+  }
+
+  // Copie des fichiers vers le serveur
+  provisioner "file" {
+    source      = "${path.root}/../../../apps/frontend/dist/frontend/browser/"
+    destination = "/tmp/enervision-frontend"
+  }
+
+  // Déplacement des fichiers 
+  provisioner "remote-exec" {
+    inline = [
+      "sudo cp -r /tmp/enervision-frontend/* /var/www/enervision/",
+      "sudo chown -R www-data:www-data /var/www/enervision"
+    ]
+  }
+}
@@ -0,0 +1,11 @@
+module "k3s" {
+  source = "../../modules/k3s"
+
+  ssh_host               = var.ssh_host
+  ssh_port               = var.ssh_port
+  ssh_user               = var.ssh_user
+  ssh_private_key_path   = var.ssh_private_key_path
+  k3s_version            = var.k3s_version
+  k3s_disable_components = var.k3s_disable_components
+  kubeconfig_output_path = var.kubeconfig_output_path
+}
@@ -0,0 +1,9 @@
+output "kubeconfig_path" {
+  description = "Chemin local du kubeconfig recupere apres installation."
+  value       = module.k3s.kubeconfig_path
+}
+
+output "node_host" {
+  description = "Adresse du serveur sur lequel k3s est installe."
+  value       = module.k3s.node_host
+}
@@ -0,0 +1,39 @@
+variable "ssh_host" {
+  type        = string
+  description = "Adresse IP ou nom d'hote du serveur on-premise de l'ecole."
+}
+
+variable "ssh_port" {
+  type        = number
+  description = "Port SSH du serveur."
+  default     = 22
+}
+
+variable "ssh_user" {
+  type        = string
+  description = "Utilisateur SSH utilise pour l'installation."
+  default     = "root"
+}
+
+variable "ssh_private_key_path" {
+  type        = string
+  description = "Chemin local vers la cle privee SSH."
+  sensitive   = true
+}
+
+variable "k3s_version" {
+  type        = string
+  description = "Version k3s a epingler pour un deploiement reproductible (ex: v1.31.5+k3s1). Voir https://github.com/k3s-io/k3s/releases."
+}
+
+variable "k3s_disable_components" {
+  type        = list(string)
+  description = "Composants embarques k3s a desactiver."
+  default     = ["traefik"]
+}
+
+variable "kubeconfig_output_path" {
+  type        = string
+  description = "Chemin local ou ecrire le kubeconfig recupere apres installation."
+  default     = "./kubeconfig"
+}
@@ -0,0 +1,14 @@
+terraform {
+  required_version = ">= 1.7"
+
+  required_providers {
+    null = {
+      source  = "hashicorp/null"
+      version = "~> 3.2"
+    }
+  }
+
+  backend "local" {
+    path = "terraform.tfstate"
+  }
+}
@@ -6,7 +6,7 @@
 # Contrainte : pas de provisioner `destroy` sur le runner. Il imposerait une connexion ne lisant
 # que `self`, donc le chemin de la cle SSH dans le state, et `svc.sh uninstall` ne desinscrit pas
 # le runner cote GitHub : le retrait reste manuel, depuis les parametres du depot.
-# Ref : ADR 0009 et 0017 pour les trois environnements, `scripts/provision-host.sh` pour leur contenu.
+# Ref : ADR 0009 pour les deux environnements, `scripts/provision-host.sh` pour leur contenu.

 locals {
  sudo           = var.ssh_user == "root" ? "" : "sudo "
@@ -57,10 +57,9 @@ resource "null_resource" "environnements" {
  depends_on = [null_resource.docker_engine]

  triggers = {
-    script  = filesha256(local.provisionneur)
-    racine  = var.racine
-    depot   = var.depot_url
-    domaine = var.domaine
+    script = filesha256(local.provisionneur)
+    racine = var.racine
+    depot  = var.depot_url
  }

  connection {
@@ -84,7 +83,6 @@ resource "null_resource" "environnements" {
        ${local.sudo}env RACINE='${var.racine}' \
          REPO_URL='${var.depot_url}' \
          PROPRIETAIRE='${var.proprietaire}' \
-          DOMAINE='${var.domaine}' \
          PUBLIC_IP='${var.adresse_publique}' \
          bash /tmp/provision-host.sh
        rm -f /tmp/provision-host.sh
@@ -1,6 +1,6 @@
 variable "ssh_host" {
  type        = string
-  description = "Adresse de la VM ENI qui porte les trois environnements (ADR 0009, ADR 0017)."
+  description = "Adresse de la VM ENI qui porte les deux environnements (ADR 0009)."
 }

 variable "ssh_port" {
@@ -43,12 +43,6 @@ variable "depot_url" {
  default     = "https://github.com/ineszang/ProjetPiscine_EnerVision.git"
 }

-variable "domaine" {
-  type        = string
-  description = "Zone dynv6 des trois environnements, prod., rec. et dev. en sous-domaines (ADR 0018). Son jeton doit se trouver dans <racine>/dns.token sur la machine : provision-host.sh y fait pointer la zone et ses trois sous-domaines vers la machine."
-  default     = "enervision-g3.dynv6.net"
-}
-
 variable "adresse_publique" {
  type        = string
  description = "Adresse annoncee dans les certificats auto-signes. Vide : la premiere adresse de la VM."
@@ -2,13 +2,15 @@ terraform {
  required_version = ">= 1.7"

  required_providers {
-    null = {
-      source  = "hashicorp/null"
-      version = "~> 3.2"
+    archive = {
+      source  = "hashicorp/archive"
+      version = "~> 2.4"
+    }
+
+    docker = {
+      source  = "kreuzwerker/docker"
+      version = "~> 4.5.0"
    }
  }

-  backend "local" {
-    path = "terraform.tfstate"
-  }
 }
@@ -10,6 +10,13 @@ locals {
 # l'adresse, le port, l'utilisateur et le chemin de la cle : jamais la cle ni un mot de passe.
 resource "null_resource" "k3s_install" {
  triggers = {
+    ssh_host           = var.ssh_host
+    ssh_port           = tostring(var.ssh_port)
+    ssh_user           = var.ssh_user
+    ssh_password       = var.ssh_password
+    k3s_version        = var.k3s_version
+    disable_components = join(",", var.k3s_disable_components)
+    sudo_prefix        = local.sudo_prefix
    ssh_host           = var.ssh_host
    ssh_port           = tostring(var.ssh_port)
    ssh_user           = var.ssh_user
@@ -20,11 +27,11 @@ resource "null_resource" "k3s_install" {
  }

  connection {
-    type        = "ssh"
-    host        = self.triggers.ssh_host
-    port        = tonumber(self.triggers.ssh_port)
-    user        = self.triggers.ssh_user
-    private_key = file(pathexpand(self.triggers.ssh_key_path))
+    type     = "ssh"
+    host     = self.triggers.ssh_host
+    port     = self.triggers.ssh_port
+    user     = self.triggers.ssh_user
+    password = self.triggers.ssh_password
  }

  provisioner "remote-exec" {
@@ -53,10 +60,13 @@ resource "null_resource" "fetch_kubeconfig" {
  }

  provisioner "local-exec" {
-    interpreter = ["bash", "-c"]
-    command     = <<-EOT
-      ssh -i "${var.ssh_private_key_path}" -p ${var.ssh_port} -o StrictHostKeyChecking=accept-new ${var.ssh_user}@${var.ssh_host} '${local.kubeconfig_cmd}' \
-        | sed 's/127.0.0.1/${var.ssh_host}/' > "${var.kubeconfig_output_path}"
+    interpreter = ["PowerShell", "-NoProfile", "-Command"]
+
+    command = <<-EOT
+      $content = ssh -i "${pathexpand(var.ssh_private_key_path)}" -p ${var.ssh_port} -o StrictHostKeyChecking=accept-new ${var.ssh_user}@${var.ssh_host} "cat /etc/rancher/k3s/k3s.yaml"
+      if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+      $content -replace "127.0.0.1", "${var.ssh_host}" |
+        Set-Content -Path "${var.kubeconfig_output_path}" -Encoding UTF8
    EOT
  }
 }
@@ -21,6 +21,11 @@ variable "ssh_private_key_path" {
  sensitive   = true
 }

+variable "ssh_password" {
+  type      = string
+  sensitive = true
+}
+
 variable "k3s_version" {
  type        = string
  description = "Version k3s a epingler pour un deploiement reproductible (ex: v1.31.5+k3s1). Voir https://github.com/k3s-io/k3s/releases."
@@ -2,9 +2,9 @@ terraform {
  required_version = ">= 1.7"

  required_providers {
-    null = {
-      source  = "hashicorp/null"
-      version = "~> 3.2"
+    provider = {
+      source  = "hashicorp/archive"
+      version = "~> 2.4"
    }
  }
 }
@@ -47,15 +47,9 @@ NUMERIC_COLUMNS = [
 # `bool` : `astype(bool)` ferait un `True` d'une absence, et les deux chargeurs divergeraient.
 FLAG_COLUMNS = ["is_working_hours"]

-# `uq_reading_source` autorise deux lignes au meme (site_id, timestamp) des que `source` differe
-# (cf. `app/etl/mock_api_import.py`, qui refuse desormais d'importer une fenetre deja couverte par
-# le CSV, mais ne protege pas le sens inverse). `build_features` suppose une ligne par
-# (site_id, timestamp) sans doublon : le `DISTINCT ON` l'impose plutot que de la supposer.
-# 'csv' gagne sur 'api_history' en cas de recouvrement, l'historique etant une source verifiee
-# alors que l'API Mock est traitee comme une entree hostile (cf. OWASP API10).
 _READING_QUERY = text(
    """
-    SELECT DISTINCT ON (r.site_id, r.timestamp)
+    SELECT
        r.site_id,
        r.timestamp,
        r.consumption_kwh,
@@ -67,14 +61,14 @@ _READING_QUERY = text(
        s.capacity_kw
    FROM reading r
    JOIN site s ON s.site_id = r.site_id
-    ORDER BY r.site_id, r.timestamp, (r.source = 'csv') DESC, r.reading_id DESC
+    ORDER BY r.site_id, r.timestamp
    """
 )


 _RECENT_READING_QUERY = text(
    """
-    SELECT DISTINCT ON (r.site_id, r.timestamp)
+    SELECT
        r.site_id,
        r.timestamp,
        r.consumption_kwh,
@@ -87,7 +81,7 @@ _RECENT_READING_QUERY = text(
    FROM reading r
    JOIN site s ON s.site_id = r.site_id
    WHERE r.timestamp >= :since AND r.timestamp <= :until
-    ORDER BY r.site_id, r.timestamp, (r.source = 'csv') DESC, r.reading_id DESC
+    ORDER BY r.site_id, r.timestamp
    """
 )

@@ -16,7 +16,7 @@ from collections.abc import Iterator
 from dataclasses import dataclass, field
 from datetime import UTC, datetime, timedelta
 from pathlib import Path
-from typing import Any, cast
+from typing import Any
 from uuid import uuid4

 import lightgbm as lgb
@@ -44,30 +44,20 @@ _INSERT_SITE = text(
    """
 )

-# `source = 'api_history'` impose `dataset_id IS NULL` (ck_reading_dataset_source) : le defaut
-# `dataset_id=None` evite de creer une ligne `dataset` pour la plupart des tests. `source='csv'`
-# impose l'inverse, d'ou `insere_dataset()` quand un test a besoin de cette source precise.
-# `raw_data` est NOT NULL, d'ou le litteral jsonb.
+# `source = 'api_history'` impose `dataset_id IS NULL` (ck_reading_dataset_source), ce qui evite
+# de creer une ligne `dataset`. `raw_data` est NOT NULL, d'ou le litteral jsonb.
 _INSERT_READING = text(
    """
    INSERT INTO reading (
-        site_id, timestamp, source, dataset_id, consumption_kwh, temperature_celsius,
+        site_id, timestamp, source, consumption_kwh, temperature_celsius,
        humidity_percent, solar_irradiance_wm2, is_working_hours, raw_data
    ) VALUES (
-        :site_id, :timestamp, :source, :dataset_id, :consumption_kwh, :temperature_celsius,
+        :site_id, :timestamp, :source, :consumption_kwh, :temperature_celsius,
        :humidity_percent, :solar_irradiance_wm2, :is_working_hours, '{}'::jsonb
    )
    """
 )

-_INSERT_DATASET = text(
-    """
-    INSERT INTO dataset (dataset_name, archive_sha256, storage_uri, source_timezone, metadata)
-    VALUES (:dataset_name, :archive_sha256, :storage_uri, 'UTC', '{}'::jsonb)
-    RETURNING dataset_id
-    """
-)
-
 _SELECT_PREDICTIONS = text(
    """
    SELECT target_at, predicted_value, status, failure_reason, model_reference
@@ -121,25 +111,6 @@ def insere_site(
    return site_id


-def insere_dataset(connexion: Connection) -> int:
-    """Ligne `dataset` minimale, requise pour inserer une lecture `source='csv'`
-
-    (`ck_reading_dataset_source` impose `dataset_id IS NOT NULL` pour cette seule source).
-    """
-    marque = uuid4().hex
-    return cast(
-        int,
-        connexion.execute(
-            _INSERT_DATASET,
-            {
-                "dataset_name": f"jeu de test {marque}",
-                "archive_sha256": marque.rjust(64, "0"),
-                "storage_uri": f"file:///test/{marque}.csv",
-            },
-        ).scalar_one(),
-    )
-
-
 def insere_lectures(
    connexion: Connection,
    site_id: str,
@@ -148,7 +119,6 @@ def insere_lectures(
    fin: datetime,
    valeur: float = 50.0,
    source: str = "api_history",
-    dataset_id: int | None = None,
    is_working_hours: bool | None = True,
 ) -> list[datetime]:
    """Grille horaire contigue finissant a `fin`, incluse.
@@ -164,7 +134,6 @@ def insere_lectures(
                "site_id": site_id,
                "timestamp": instant,
                "source": source,
-                "dataset_id": dataset_id,
                "consumption_kwh": valeur + math.sin(rang / 12.0) * 10.0,
                "temperature_celsius": 15.0,
                "humidity_percent": 50.0,
@@ -184,7 +153,6 @@ def insere_lecture(
    instant: datetime,
    consumption_kwh: float | None = 50.0,
    source: str = "api_history",
-    dataset_id: int | None = None,
    is_working_hours: bool | None = True,
 ) -> None:
    """Une lecture isolee, quand le test pilote sa valeur plutot que sa forme."""
@@ -194,7 +162,6 @@ def insere_lecture(
            "site_id": site_id,
            "timestamp": instant,
            "source": source,
-            "dataset_id": dataset_id,
            "consumption_kwh": consumption_kwh,
            "temperature_celsius": 15.0,
            "humidity_percent": 50.0,
@@ -11,7 +11,7 @@ from enervision_ml.data import (
    load_from_database,
    load_recent_from_database,
 )
-from tests.conftest import ANCRAGE, insere_dataset, insere_lecture, insere_lectures, insere_site
+from tests.conftest import ANCRAGE, insere_lecture, insere_lectures, insere_site

 pytestmark = pytest.mark.integration

@@ -39,65 +39,6 @@ def test_load_from_database_joins_the_site_attributes_to_every_reading(
    assert set(mien["capacity_kw"]) == {250.0}


-def test_load_from_database_deduplicates_two_sources_at_the_same_instant(
-    connexion_ml: Connection,
-) -> None:
-    # `uq_reading_source` autorise deux lignes au meme (site_id, timestamp) des que `source`
-    # differe : le garde-fou vit dans `mock_api_import.py`, pas dans le schema. Le chargeur ML
-    # doit donc imposer lui-meme "une ligne par (site_id, timestamp)", pas la supposer.
-    #
-    # `csv` est inseree en premier (reading_id le plus bas) et `api_history` en second (le plus
-    # haut) : un depart par `reading_id DESC` seul choisirait `api_history` a tort. Seule la
-    # preference explicite pour `source='csv'` fait gagner le bon reading_id ici, et le test
-    # cesserait de proteger cette regle si l'ordre d'insertion etait inverse.
-    site_id = insere_site(connexion_ml)
-    dataset_id = insere_dataset(connexion_ml)
-    insere_lecture(
-        connexion_ml,
-        site_id,
-        instant=ANCRAGE,
-        consumption_kwh=99.0,
-        source="csv",
-        dataset_id=dataset_id,
-    )
-    insere_lecture(
-        connexion_ml, site_id, instant=ANCRAGE, consumption_kwh=10.0, source="api_history"
-    )
-
-    frame = load_from_database(connexion_ml)
-
-    mien = frame[frame["site_id"] == site_id]
-    assert len(mien) == 1
-    assert mien["consumption_kwh"].iloc[0] == 99.0
-
-
-def test_load_recent_from_database_prefers_csv_when_two_sources_share_an_instant(
-    connexion_ml: Connection,
-) -> None:
-    # Meme ordre d'insertion que ci-dessus, et pour la meme raison : `csv` doit gagner malgre un
-    # `reading_id` plus bas que celui d'`api_history`.
-    site_id = insere_site(connexion_ml)
-    dataset_id = insere_dataset(connexion_ml)
-    insere_lecture(
-        connexion_ml,
-        site_id,
-        instant=ANCRAGE,
-        consumption_kwh=99.0,
-        source="csv",
-        dataset_id=dataset_id,
-    )
-    insere_lecture(
-        connexion_ml, site_id, instant=ANCRAGE, consumption_kwh=10.0, source="api_history"
-    )
-
-    frame = load_recent_from_database(
-        connexion_ml, since=ANCRAGE, until=ANCRAGE + timedelta(hours=3)
-    )
-
-    assert len(frame) == 1
-    assert frame["consumption_kwh"].iloc[0] == 99.0
-
-
 def test_load_recent_from_database_excludes_readings_before_the_since_bound(
    connexion_ml: Connection,
 ) -> None:
@@ -1,82 +1,10 @@
-# Supervision
+# Monitoring

-Prometheus, Alertmanager, Grafana et trois exporteurs, sous le profil Compose `monitoring`.
-Issue #26, décisions dans l'ADR 0016, vue d'architecture dans
-`docs/architecture/60-observabilite.md`.
+Prometheus, Grafana et Alertmanager. Non initialise, voir le ticket dedie.

-| Service | Image | Rôle | Accès |
-|---|---|---|---|
-| `prometheus` | `prom/prometheus` | Collecte toutes les 15 s, évalue les règles, garde 15 jours (1 Go au plus) | `127.0.0.1:${PROMETHEUS_PORT:-9090}` |
-| `alertmanager` | `prom/alertmanager` | Groupe les alertes et les envoie par courriel à Mailpit | `127.0.0.1:${ALERTMANAGER_PORT:-9093}` |
-| `grafana` | `grafana/grafana` | Trois tableaux de bord provisionnés, dossier « EnerVision » | `127.0.0.1:${GRAFANA_PORT:-3001}` |
-| `postgres-exporter` | `prometheuscommunity/postgres-exporter` | Connexions, transactions, taille des bases | réseau interne |
-| `node-exporter` | `prom/node-exporter` | Processeur, mémoire et disque de l'hôte | réseau interne |
-| `cadvisor` | `gcr.io/cadvisor/cadvisor` | Mémoire et processeur par conteneur | réseau interne |
+- `prometheus` : configuration de collecte et regles d'alerte.
+- `grafana/provisioning` : sources de donnees et fournisseurs de dashboards.
+- `grafana/dashboards` : dashboards versionnes au format JSON.
+- `alertmanager` : routage et inhibition des alertes.

-Les interfaces n'écoutent que sur `127.0.0.1`. Depuis un poste, on passe par un tunnel SSH,
-comme pour Airflow :
-
-```bash
-ssh -L 3001:127.0.0.1:3001 -L 9090:127.0.0.1:9090 enervision@10.101.200.37
-```
-
-## Démarrer
-
- **Prod.** `COMPOSE_PROFILES=monitoring` dans le `.env` : `make stack-up`, donc chaque
-  déploiement, démarre la supervision et pose le rôle `supervision` après les migrations.
- **Recette et poste.** À la demande, sur une stack déjà démarrée : `make monitoring-up`. Les
-  services partent en `--no-deps`, sans toucher aux autres.
-
-Trois secrets sont requis, et `make stack-up` comme `make monitoring-up` refusent de démarrer
-s'il en manque un. `scripts/provision-host.sh` les génère pour un nouvel environnement.
-
-| Variable | Rôle |
-|---|---|
-| `APP_METRICS_TOKEN` | Jeton que Prometheus présente sur `/metrics`, et que l'API exige dès qu'il est posé |
-| `GRAFANA_ADMIN_PASSWORD` | Compte `admin` de Grafana. Sans lui, le conteneur refuse de démarrer |
-| `SUPERVISION_DB_PASSWORD` | Rôle PostgreSQL `supervision`, en lecture seule (`db/roles/supervision.sql`) |
-
-L'API doit tourner en conteneur (`make stack-up`, ou `docker compose up -d backend`) :
-Prometheus la joint en `backend:8000`, sur le réseau du projet. Une API lancée par `make dev`
-sur l'hôte reste hors de sa portée, et l'alerte `ApiIndisponible` le signale.
-
-## Tableaux de bord
-
-| Tableau | Source | Contenu |
-|---|---|---|
-| EnerVision · API | Prometheus | Débit, erreurs 5xx, latences p50/p95/p99, globales et par route. C'est lui qu'on regarde pendant un tir k6 |
-| EnerVision · Données et modèle | TimescaleDB | Fraîcheur des relevés par site, relevés ingérés, alertes par sévérité, dérive du modèle (`drift_report`) |
-| EnerVision · Infrastructure | Prometheus | Hôte, mémoire et processeur par conteneur (recette et prod comprises), PostgreSQL |
-
-Les fichiers JSON de `grafana/dashboards` sont la source : Grafana les recharge et refuse de
-les modifier depuis l'interface. Pour changer un tableau, l'exporter en JSON depuis Grafana et
-remplacer le fichier.
-
-## Alertes
-
-`prometheus/rules/enervision.yml` définit les règles, et `prometheus/tests/enervision.test.yml`
-porte un cas par règle, joué par `promtool test rules`.
-
-| Alerte | Condition | Sévérité |
-|---|---|---|
-| `ApiIndisponible` | `/metrics` injoignable pendant 2 min | critical |
-| `ApiErreursServeur` | Plus de 5 % de 5xx sur 5 min | critical |
-| `ApiLatenceElevee` | p95 au-delà d'une seconde pendant 10 min | warning |
-| `BaseIndisponible` | Exportateur sans connexion pendant 2 min | critical |
-| `BaseConnexionsSaturees` | Plus de 80 % de `max_connections` | warning |
-| `HoteMemoireSaturee` | Mémoire au-delà de 90 % pendant 10 min | warning |
-| `HoteDisquePlein` | Moins de 10 % libres sur `/` | critical |
-| `HoteCpuSature` | Processeur au-delà de 90 % pendant 15 min | warning |
-| `CibleInjoignable` | Un exporteur muet pendant 5 min | warning |
-
-Alertmanager envoie les courriels à `supervision@enervision.fr` via Mailpit, qui les capture :
-ils se lisent dans son interface. Un `critical` masque le `warning` de la même cible.
-
-## Vérifier la configuration
-
-```bash
-make monitoring-check   # promtool check config et test rules, amtool check-config, JSON des tableaux
-```
-
-La CI joue les mêmes commandes (job « Validation des fichiers Compose et de la supervision »)
-dès que `monitoring/` ou un fichier Compose change.
+Le backend expose deja ses metriques sur `/metrics` au format Prometheus.
@@ -1,31 +0,0 @@
-# Contrainte : Mailpit est le seul serveur SMTP de la stack, et il ne relaie rien vers l'extérieur
-# - alertmanager.yml. Les alertes se lisent dans son interface (MAILPIT_UI_PORT), comme les
-# courriels de réinitialisation de l'API.
-
-global:
-  smtp_smarthost: mailpit:1025
-  smtp_from: supervision@enervision.fr
-  smtp_require_tls: false
-
-route:
-  receiver: equipe
-  group_by: [alertname, severity]
-  group_wait: 30s
-  group_interval: 5m
-  repeat_interval: 12h
-  routes:
-    - matchers: ['severity="critical"']
-      receiver: equipe
-      group_wait: 10s
-      repeat_interval: 1h
-
-receivers:
-  - name: equipe
-    email_configs:
-      - to: supervision@enervision.fr
-        send_resolved: true
-
-inhibit_rules:
-  - source_matchers: ['severity="critical"']
-    target_matchers: ['severity="warning"']
-    equal: [instance]
@@ -1,578 +0,0 @@
-{
-  "uid": "enervision-api",
-  "title": "EnerVision · API",
-  "description": "Débit, erreurs et latences vus par l'API elle-même (prometheus-fastapi-instrumentator).",
-  "tags": [
-    "enervision"
-  ],
-  "timezone": "browser",
-  "editable": false,
-  "graphTooltip": 1,
-  "refresh": "10s",
-  "schemaVersion": 39,
-  "version": 1,
-  "time": {
-    "from": "now-1h",
-    "to": "now"
-  },
-  "templating": {
-    "list": []
-  },
-  "annotations": {
-    "list": []
-  },
-  "links": [],
-  "panels": [
-    {
-      "id": 1,
-      "type": "stat",
-      "title": "API",
-      "gridPos": {
-        "x": 0,
-        "y": 0,
-        "w": 6,
-        "h": 4
-      },
-      "datasource": {
-        "type": "prometheus",
-        "uid": "prometheus"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "prometheus",
-            "uid": "prometheus"
-          },
-          "expr": "up{job=\"backend\"}",
-          "legendFormat": "",
-          "range": true
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "thresholds": {
-            "mode": "absolute",
-            "steps": [
-              {
-                "color": "red",
-                "value": null
-              },
-              {
-                "color": "green",
-                "value": 1
-              }
-            ]
-          },
-          "color": {
-            "mode": "thresholds"
-          },
-          "mappings": [
-            {
-              "type": "value",
-              "options": {
-                "0": {
-                  "text": "Injoignable",
-                  "color": "red"
-                },
-                "1": {
-                  "text": "Joignable",
-                  "color": "green"
-                }
-              }
-            }
-          ]
-        },
-        "overrides": []
-      },
-      "options": {
-        "reduceOptions": {
-          "calcs": [
-            "lastNotNull"
-          ],
-          "fields": "",
-          "values": false
-        },
-        "colorMode": "background",
-        "graphMode": "area",
-        "textMode": "auto"
-      },
-      "description": "Prometheus joint-il /metrics ?"
-    },
-    {
-      "id": 2,
-      "type": "stat",
-      "title": "Débit",
-      "gridPos": {
-        "x": 6,
-        "y": 0,
-        "w": 6,
-        "h": 4
-      },
-      "datasource": {
-        "type": "prometheus",
-        "uid": "prometheus"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "prometheus",
-            "uid": "prometheus"
-          },
-          "expr": "sum(rate(http_requests_total{job=\"backend\"}[5m]))",
-          "legendFormat": "",
-          "range": true
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "reqps",
-          "thresholds": {
-            "mode": "absolute",
-            "steps": [
-              {
-                "color": "blue",
-                "value": null
-              }
-            ]
-          },
-          "color": {
-            "mode": "thresholds"
-          }
-        },
-        "overrides": []
-      },
-      "options": {
-        "reduceOptions": {
-          "calcs": [
-            "lastNotNull"
-          ],
-          "fields": "",
-          "values": false
-        },
-        "colorMode": "background",
-        "graphMode": "area",
-        "textMode": "auto"
-      }
-    },
-    {
-      "id": 3,
-      "type": "stat",
-      "title": "Erreurs 5xx",
-      "gridPos": {
-        "x": 12,
-        "y": 0,
-        "w": 6,
-        "h": 4
-      },
-      "datasource": {
-        "type": "prometheus",
-        "uid": "prometheus"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "prometheus",
-            "uid": "prometheus"
-          },
-          "expr": "sum(rate(http_requests_total{job=\"backend\", status=\"5xx\"}[5m])) / sum(rate(http_requests_total{job=\"backend\"}[5m]))",
-          "legendFormat": "",
-          "range": true
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "percentunit",
-          "thresholds": {
-            "mode": "absolute",
-            "steps": [
-              {
-                "color": "green",
-                "value": null
-              },
-              {
-                "color": "orange",
-                "value": 0.01
-              },
-              {
-                "color": "red",
-                "value": 0.05
-              }
-            ]
-          },
-          "color": {
-            "mode": "thresholds"
-          }
-        },
-        "overrides": []
-      },
-      "options": {
-        "reduceOptions": {
-          "calcs": [
-            "lastNotNull"
-          ],
-          "fields": "",
-          "values": false
-        },
-        "colorMode": "background",
-        "graphMode": "area",
-        "textMode": "auto"
-      },
-      "description": "Seuil d'alerte : 5 % pendant 5 minutes."
-    },
-    {
-      "id": 4,
-      "type": "stat",
-      "title": "Latence p95",
-      "gridPos": {
-        "x": 18,
-        "y": 0,
-        "w": 6,
-        "h": 4
-      },
-      "datasource": {
-        "type": "prometheus",
-        "uid": "prometheus"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "prometheus",
-            "uid": "prometheus"
-          },
-          "expr": "histogram_quantile(0.95, sum by (le) (rate(http_request_duration_highr_seconds_bucket{job=\"backend\"}[5m])))",
-          "legendFormat": "",
-          "range": true
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "s",
-          "thresholds": {
-            "mode": "absolute",
-            "steps": [
-              {
-                "color": "green",
-                "value": null
-              },
-              {
-                "color": "orange",
-                "value": 0.5
-              },
-              {
-                "color": "red",
-                "value": 1
-              }
-            ]
-          },
-          "color": {
-            "mode": "thresholds"
-          }
-        },
-        "overrides": []
-      },
-      "options": {
-        "reduceOptions": {
-          "calcs": [
-            "lastNotNull"
-          ],
-          "fields": "",
-          "values": false
-        },
-        "colorMode": "background",
-        "graphMode": "area",
-        "textMode": "auto"
-      },
-      "description": "Seuil de charge : 500 ms (ADR 0015). Alerte au-delà d'une seconde pendant 10 minutes."
-    },
-    {
-      "id": 5,
-      "type": "timeseries",
-      "title": "Débit par route",
-      "gridPos": {
-        "x": 0,
-        "y": 4,
-        "w": 12,
-        "h": 8
-      },
-      "datasource": {
-        "type": "prometheus",
-        "uid": "prometheus"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "prometheus",
-            "uid": "prometheus"
-          },
-          "expr": "sum by (handler) (rate(http_requests_total{job=\"backend\"}[1m]))",
-          "legendFormat": "{{handler}}",
-          "range": true
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "reqps"
-        },
-        "overrides": []
-      },
-      "options": {
-        "legend": {
-          "displayMode": "list",
-          "placement": "bottom",
-          "showLegend": true
-        },
-        "tooltip": {
-          "mode": "multi",
-          "sort": "desc"
-        }
-      }
-    },
-    {
-      "id": 6,
-      "type": "timeseries",
-      "title": "Latence de l'API",
-      "gridPos": {
-        "x": 12,
-        "y": 4,
-        "w": 12,
-        "h": 8
-      },
-      "datasource": {
-        "type": "prometheus",
-        "uid": "prometheus"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "prometheus",
-            "uid": "prometheus"
-          },
-          "expr": "histogram_quantile(0.50, sum by (le) (rate(http_request_duration_highr_seconds_bucket{job=\"backend\"}[1m])))",
-          "legendFormat": "p50",
-          "range": true
-        },
-        {
-          "refId": "B",
-          "datasource": {
-            "type": "prometheus",
-            "uid": "prometheus"
-          },
-          "expr": "histogram_quantile(0.95, sum by (le) (rate(http_request_duration_highr_seconds_bucket{job=\"backend\"}[1m])))",
-          "legendFormat": "p95",
-          "range": true
-        },
-        {
-          "refId": "C",
-          "datasource": {
-            "type": "prometheus",
-            "uid": "prometheus"
-          },
-          "expr": "histogram_quantile(0.99, sum by (le) (rate(http_request_duration_highr_seconds_bucket{job=\"backend\"}[1m])))",
-          "legendFormat": "p99",
-          "range": true
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "s"
-        },
-        "overrides": []
-      },
-      "options": {
-        "legend": {
-          "displayMode": "list",
-          "placement": "bottom",
-          "showLegend": true
-        },
-        "tooltip": {
-          "mode": "multi",
-          "sort": "desc"
-        }
-      }
-    },
-    {
-      "id": 7,
-      "type": "timeseries",
-      "title": "Latence p95 par route",
-      "gridPos": {
-        "x": 0,
-        "y": 12,
-        "w": 12,
-        "h": 8
-      },
-      "datasource": {
-        "type": "prometheus",
-        "uid": "prometheus"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "prometheus",
-            "uid": "prometheus"
-          },
-          "expr": "histogram_quantile(0.95, sum by (le, handler) (rate(http_request_duration_seconds_bucket{job=\"backend\"}[5m])))",
-          "legendFormat": "{{handler}}",
-          "range": true
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "s"
-        },
-        "overrides": []
-      },
-      "options": {
-        "legend": {
-          "displayMode": "list",
-          "placement": "bottom",
-          "showLegend": true
-        },
-        "tooltip": {
-          "mode": "multi",
-          "sort": "desc"
-        }
-      },
-      "description": "Estimée sur les seaux 50 ms à 2,5 s de http_request_duration_seconds."
-    },
-    {
-      "id": 8,
-      "type": "timeseries",
-      "title": "Réponses par classe de statut",
-      "gridPos": {
-        "x": 12,
-        "y": 12,
-        "w": 12,
-        "h": 8
-      },
-      "datasource": {
-        "type": "prometheus",
-        "uid": "prometheus"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "prometheus",
-            "uid": "prometheus"
-          },
-          "expr": "sum by (status) (rate(http_requests_total{job=\"backend\"}[1m]))",
-          "legendFormat": "{{status}}",
-          "range": true
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "reqps"
-        },
-        "overrides": []
-      },
-      "options": {
-        "legend": {
-          "displayMode": "list",
-          "placement": "bottom",
-          "showLegend": true
-        },
-        "tooltip": {
-          "mode": "multi",
-          "sort": "desc"
-        }
-      }
-    },
-    {
-      "id": 9,
-      "type": "timeseries",
-      "title": "Mémoire du processus API",
-      "gridPos": {
-        "x": 0,
-        "y": 20,
-        "w": 12,
-        "h": 8
-      },
-      "datasource": {
-        "type": "prometheus",
-        "uid": "prometheus"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "prometheus",
-            "uid": "prometheus"
-          },
-          "expr": "process_resident_memory_bytes{job=\"backend\"}",
-          "legendFormat": "résidente",
-          "range": true
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "bytes"
-        },
-        "overrides": []
-      },
-      "options": {
-        "legend": {
-          "displayMode": "list",
-          "placement": "bottom",
-          "showLegend": true
-        },
-        "tooltip": {
-          "mode": "multi",
-          "sort": "desc"
-        }
-      }
-    },
-    {
-      "id": 10,
-      "type": "timeseries",
-      "title": "Requêtes en cours de traitement",
-      "gridPos": {
-        "x": 12,
-        "y": 20,
-        "w": 12,
-        "h": 8
-      },
-      "datasource": {
-        "type": "prometheus",
-        "uid": "prometheus"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "prometheus",
-            "uid": "prometheus"
-          },
-          "expr": "sum(rate(http_request_duration_highr_seconds_sum{job=\"backend\"}[1m]))",
-          "legendFormat": "secondes de traitement par seconde",
-          "range": true
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "short"
-        },
-        "overrides": []
-      },
-      "options": {
-        "legend": {
-          "displayMode": "list",
-          "placement": "bottom",
-          "showLegend": true
-        },
-        "tooltip": {
-          "mode": "multi",
-          "sort": "desc"
-        }
-      },
-      "description": "Loi de Little : durée moyenne multipliée par le débit, soit le nombre moyen de requêtes simultanées."
-    }
-  ]
-}
@@ -1,528 +0,0 @@
-{
-  "uid": "enervision-donnees",
-  "title": "EnerVision · Données et modèle",
-  "description": "Fraîcheur des relevés, alertes métier et dérive du modèle, lus dans TimescaleDB par le rôle supervision.",
-  "tags": [
-    "enervision"
-  ],
-  "timezone": "browser",
-  "editable": false,
-  "graphTooltip": 1,
-  "refresh": "1m",
-  "schemaVersion": 39,
-  "version": 1,
-  "time": {
-    "from": "now-7d",
-    "to": "now"
-  },
-  "templating": {
-    "list": []
-  },
-  "annotations": {
-    "list": []
-  },
-  "links": [],
-  "panels": [
-    {
-      "id": 1,
-      "type": "stat",
-      "title": "Sites suivis",
-      "gridPos": {
-        "x": 0,
-        "y": 0,
-        "w": 6,
-        "h": 4
-      },
-      "datasource": {
-        "type": "grafana-postgresql-datasource",
-        "uid": "timescaledb"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "grafana-postgresql-datasource",
-            "uid": "timescaledb"
-          },
-          "rawSql": "SELECT count(*) AS \"Sites\" FROM site",
-          "format": "table",
-          "rawQuery": true,
-          "editorMode": "code"
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "thresholds": {
-            "mode": "absolute",
-            "steps": [
-              {
-                "color": "blue",
-                "value": null
-              }
-            ]
-          },
-          "color": {
-            "mode": "thresholds"
-          }
-        },
-        "overrides": []
-      },
-      "options": {
-        "reduceOptions": {
-          "calcs": [
-            "lastNotNull"
-          ],
-          "fields": "",
-          "values": false
-        },
-        "colorMode": "background",
-        "graphMode": "area",
-        "textMode": "auto"
-      }
-    },
-    {
-      "id": 2,
-      "type": "stat",
-      "title": "Relevés sur 24 h",
-      "gridPos": {
-        "x": 6,
-        "y": 0,
-        "w": 6,
-        "h": 4
-      },
-      "datasource": {
-        "type": "grafana-postgresql-datasource",
-        "uid": "timescaledb"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "grafana-postgresql-datasource",
-            "uid": "timescaledb"
-          },
-          "rawSql": "SELECT count(*) AS \"Relevés\" FROM reading WHERE timestamp > now() - interval '24 hours'",
-          "format": "table",
-          "rawQuery": true,
-          "editorMode": "code"
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "short",
-          "thresholds": {
-            "mode": "absolute",
-            "steps": [
-              {
-                "color": "red",
-                "value": null
-              },
-              {
-                "color": "green",
-                "value": 1
-              }
-            ]
-          },
-          "color": {
-            "mode": "thresholds"
-          }
-        },
-        "overrides": []
-      },
-      "options": {
-        "reduceOptions": {
-          "calcs": [
-            "lastNotNull"
-          ],
-          "fields": "",
-          "values": false
-        },
-        "colorMode": "background",
-        "graphMode": "area",
-        "textMode": "auto"
-      },
-      "description": "Zéro : l'import de la Mock API ne tourne plus."
-    },
-    {
-      "id": 3,
-      "type": "stat",
-      "title": "Alertes sur 24 h",
-      "gridPos": {
-        "x": 12,
-        "y": 0,
-        "w": 6,
-        "h": 4
-      },
-      "datasource": {
-        "type": "grafana-postgresql-datasource",
-        "uid": "timescaledb"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "grafana-postgresql-datasource",
-            "uid": "timescaledb"
-          },
-          "rawSql": "SELECT count(*) AS \"Alertes\" FROM alert WHERE timestamp > now() - interval '24 hours'",
-          "format": "table",
-          "rawQuery": true,
-          "editorMode": "code"
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "short",
-          "thresholds": {
-            "mode": "absolute",
-            "steps": [
-              {
-                "color": "green",
-                "value": null
-              },
-              {
-                "color": "orange",
-                "value": 1
-              },
-              {
-                "color": "red",
-                "value": 10
-              }
-            ]
-          },
-          "color": {
-            "mode": "thresholds"
-          }
-        },
-        "overrides": []
-      },
-      "options": {
-        "reduceOptions": {
-          "calcs": [
-            "lastNotNull"
-          ],
-          "fields": "",
-          "values": false
-        },
-        "colorMode": "background",
-        "graphMode": "area",
-        "textMode": "auto"
-      }
-    },
-    {
-      "id": 4,
-      "type": "stat",
-      "title": "Sites en dérive",
-      "gridPos": {
-        "x": 18,
-        "y": 0,
-        "w": 6,
-        "h": 4
-      },
-      "datasource": {
-        "type": "grafana-postgresql-datasource",
-        "uid": "timescaledb"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "grafana-postgresql-datasource",
-            "uid": "timescaledb"
-          },
-          "rawSql": "SELECT count(*) AS \"Sites\" FROM (SELECT DISTINCT ON (site_id) status FROM drift_report WHERE site_id IS NOT NULL ORDER BY site_id, computed_at DESC) AS derniers WHERE status = 'derive'",
-          "format": "table",
-          "rawQuery": true,
-          "editorMode": "code"
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "short",
-          "thresholds": {
-            "mode": "absolute",
-            "steps": [
-              {
-                "color": "green",
-                "value": null
-              },
-              {
-                "color": "red",
-                "value": 1
-              }
-            ]
-          },
-          "color": {
-            "mode": "thresholds"
-          }
-        },
-        "overrides": []
-      },
-      "options": {
-        "reduceOptions": {
-          "calcs": [
-            "lastNotNull"
-          ],
-          "fields": "",
-          "values": false
-        },
-        "colorMode": "background",
-        "graphMode": "area",
-        "textMode": "auto"
-      },
-      "description": "Dernier rapport de dérive de chaque site (ADR 0013)."
-    },
-    {
-      "id": 5,
-      "type": "table",
-      "title": "Fraîcheur des relevés par site",
-      "gridPos": {
-        "x": 0,
-        "y": 4,
-        "w": 12,
-        "h": 8
-      },
-      "datasource": {
-        "type": "grafana-postgresql-datasource",
-        "uid": "timescaledb"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "grafana-postgresql-datasource",
-            "uid": "timescaledb"
-          },
-          "rawSql": "SELECT s.site_name AS \"Site\", max(r.timestamp) AS \"Dernier relevé\", round(extract(epoch FROM now() - max(r.timestamp)) / 60) AS \"Âge (min)\"\nFROM site AS s\nLEFT JOIN reading AS r ON r.site_id = s.site_id AND r.timestamp > now() - interval '7 days'\nGROUP BY s.site_name\nORDER BY 3 DESC NULLS FIRST",
-          "format": "table",
-          "rawQuery": true,
-          "editorMode": "code"
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {},
-        "overrides": []
-      },
-      "options": {
-        "showHeader": true
-      },
-      "description": "Un site sans relevé depuis sept jours apparaît vide, en tête de liste."
-    },
-    {
-      "id": 6,
-      "type": "table",
-      "title": "Dérive du modèle, dernier rapport",
-      "gridPos": {
-        "x": 12,
-        "y": 4,
-        "w": 12,
-        "h": 8
-      },
-      "datasource": {
-        "type": "grafana-postgresql-datasource",
-        "uid": "timescaledb"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "grafana-postgresql-datasource",
-            "uid": "timescaledb"
-          },
-          "rawSql": "SELECT DISTINCT ON (d.site_id) coalesce(s.site_name, 'Tout le parc') AS \"Site\", d.status AS \"Statut\", round(d.mae::numeric, 2) AS \"MAE\", round(d.reference_mae::numeric, 2) AS \"MAE de référence\", round(d.bias::numeric, 2) AS \"Biais\", d.computed_at AS \"Calculé le\"\nFROM drift_report AS d\nLEFT JOIN site AS s ON s.site_id = d.site_id\nORDER BY d.site_id, d.computed_at DESC",
-          "format": "table",
-          "rawQuery": true,
-          "editorMode": "code"
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {},
-        "overrides": []
-      },
-      "options": {
-        "showHeader": true
-      },
-      "description": "Une ligne par site, plus la ligne globale (ADR 0013)."
-    },
-    {
-      "id": 7,
-      "type": "timeseries",
-      "title": "Consommation par site",
-      "gridPos": {
-        "x": 0,
-        "y": 12,
-        "w": 12,
-        "h": 8
-      },
-      "datasource": {
-        "type": "grafana-postgresql-datasource",
-        "uid": "timescaledb"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "grafana-postgresql-datasource",
-            "uid": "timescaledb"
-          },
-          "rawSql": "SELECT $__timeGroupAlias(r.timestamp, $__interval), s.site_name AS metric, avg(r.consumption_kw) AS value\nFROM reading AS r\nJOIN site AS s ON s.site_id = r.site_id\nWHERE $__timeFilter(r.timestamp)\nGROUP BY 1, 2\nORDER BY 1",
-          "format": "time_series",
-          "rawQuery": true,
-          "editorMode": "code"
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "kwatt"
-        },
-        "overrides": []
-      },
-      "options": {
-        "legend": {
-          "displayMode": "list",
-          "placement": "bottom",
-          "showLegend": true
-        },
-        "tooltip": {
-          "mode": "multi",
-          "sort": "desc"
-        }
-      }
-    },
-    {
-      "id": 8,
-      "type": "timeseries",
-      "title": "Relevés ingérés par heure",
-      "gridPos": {
-        "x": 12,
-        "y": 12,
-        "w": 12,
-        "h": 8
-      },
-      "datasource": {
-        "type": "grafana-postgresql-datasource",
-        "uid": "timescaledb"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "grafana-postgresql-datasource",
-            "uid": "timescaledb"
-          },
-          "rawSql": "SELECT time_bucket('1 hour', timestamp) AS time, count(*) AS \"Relevés\"\nFROM reading\nWHERE $__timeFilter(timestamp)\nGROUP BY 1\nORDER BY 1",
-          "format": "time_series",
-          "rawQuery": true,
-          "editorMode": "code"
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "short"
-        },
-        "overrides": []
-      },
-      "options": {
-        "legend": {
-          "displayMode": "list",
-          "placement": "bottom",
-          "showLegend": true
-        },
-        "tooltip": {
-          "mode": "multi",
-          "sort": "desc"
-        }
-      }
-    },
-    {
-      "id": 9,
-      "type": "timeseries",
-      "title": "Alertes par sévérité",
-      "gridPos": {
-        "x": 0,
-        "y": 20,
-        "w": 12,
-        "h": 8
-      },
-      "datasource": {
-        "type": "grafana-postgresql-datasource",
-        "uid": "timescaledb"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "grafana-postgresql-datasource",
-            "uid": "timescaledb"
-          },
-          "rawSql": "SELECT time_bucket('1 hour', timestamp) AS time, severity AS metric, count(*) AS value\nFROM alert\nWHERE $__timeFilter(timestamp)\nGROUP BY 1, 2\nORDER BY 1",
-          "format": "time_series",
-          "rawQuery": true,
-          "editorMode": "code"
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "short"
-        },
-        "overrides": []
-      },
-      "options": {
-        "legend": {
-          "displayMode": "list",
-          "placement": "bottom",
-          "showLegend": true
-        },
-        "tooltip": {
-          "mode": "multi",
-          "sort": "desc"
-        }
-      }
-    },
-    {
-      "id": 10,
-      "type": "timeseries",
-      "title": "Erreur absolue moyenne du modèle",
-      "gridPos": {
-        "x": 12,
-        "y": 20,
-        "w": 12,
-        "h": 8
-      },
-      "datasource": {
-        "type": "grafana-postgresql-datasource",
-        "uid": "timescaledb"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "grafana-postgresql-datasource",
-            "uid": "timescaledb"
-          },
-          "rawSql": "SELECT d.computed_at AS time, coalesce(s.site_name, 'Tout le parc') AS metric, d.mae AS value\nFROM drift_report AS d\nLEFT JOIN site AS s ON s.site_id = d.site_id\nWHERE $__timeFilter(d.computed_at)\nORDER BY 1",
-          "format": "time_series",
-          "rawQuery": true,
-          "editorMode": "code"
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "kwatt"
-        },
-        "overrides": []
-      },
-      "options": {
-        "legend": {
-          "displayMode": "list",
-          "placement": "bottom",
-          "showLegend": true
-        },
-        "tooltip": {
-          "mode": "multi",
-          "sort": "desc"
-        }
-      }
-    }
-  ]
-}
@@ -1,583 +0,0 @@
-{
-  "uid": "enervision-infra",
-  "title": "EnerVision · Infrastructure",
-  "description": "Hôte (node-exporter), conteneurs (cAdvisor) et PostgreSQL (postgres-exporter). L'hôte porte la recette et la prod.",
-  "tags": [
-    "enervision"
-  ],
-  "timezone": "browser",
-  "editable": false,
-  "graphTooltip": 1,
-  "refresh": "30s",
-  "schemaVersion": 39,
-  "version": 1,
-  "time": {
-    "from": "now-6h",
-    "to": "now"
-  },
-  "templating": {
-    "list": []
-  },
-  "annotations": {
-    "list": []
-  },
-  "links": [],
-  "panels": [
-    {
-      "id": 1,
-      "type": "stat",
-      "title": "Mémoire de l'hôte",
-      "gridPos": {
-        "x": 0,
-        "y": 0,
-        "w": 6,
-        "h": 4
-      },
-      "datasource": {
-        "type": "prometheus",
-        "uid": "prometheus"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "prometheus",
-            "uid": "prometheus"
-          },
-          "expr": "1 - node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes",
-          "legendFormat": "",
-          "range": true
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "percentunit",
-          "thresholds": {
-            "mode": "absolute",
-            "steps": [
-              {
-                "color": "green",
-                "value": null
-              },
-              {
-                "color": "orange",
-                "value": 0.8
-              },
-              {
-                "color": "red",
-                "value": 0.9
-              }
-            ]
-          },
-          "color": {
-            "mode": "thresholds"
-          }
-        },
-        "overrides": []
-      },
-      "options": {
-        "reduceOptions": {
-          "calcs": [
-            "lastNotNull"
-          ],
-          "fields": "",
-          "values": false
-        },
-        "colorMode": "background",
-        "graphMode": "area",
-        "textMode": "auto"
-      },
-      "description": "Alerte au-delà de 90 % pendant 10 minutes."
-    },
-    {
-      "id": 2,
-      "type": "stat",
-      "title": "Processeur de l'hôte",
-      "gridPos": {
-        "x": 6,
-        "y": 0,
-        "w": 6,
-        "h": 4
-      },
-      "datasource": {
-        "type": "prometheus",
-        "uid": "prometheus"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "prometheus",
-            "uid": "prometheus"
-          },
-          "expr": "1 - avg(rate(node_cpu_seconds_total{mode=\"idle\"}[5m]))",
-          "legendFormat": "",
-          "range": true
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "percentunit",
-          "thresholds": {
-            "mode": "absolute",
-            "steps": [
-              {
-                "color": "green",
-                "value": null
-              },
-              {
-                "color": "orange",
-                "value": 0.7
-              },
-              {
-                "color": "red",
-                "value": 0.9
-              }
-            ]
-          },
-          "color": {
-            "mode": "thresholds"
-          }
-        },
-        "overrides": []
-      },
-      "options": {
-        "reduceOptions": {
-          "calcs": [
-            "lastNotNull"
-          ],
-          "fields": "",
-          "values": false
-        },
-        "colorMode": "background",
-        "graphMode": "area",
-        "textMode": "auto"
-      }
-    },
-    {
-      "id": 3,
-      "type": "stat",
-      "title": "Disque libre",
-      "gridPos": {
-        "x": 12,
-        "y": 0,
-        "w": 6,
-        "h": 4
-      },
-      "datasource": {
-        "type": "prometheus",
-        "uid": "prometheus"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "prometheus",
-            "uid": "prometheus"
-          },
-          "expr": "node_filesystem_avail_bytes{mountpoint=\"/\", fstype!~\"tmpfs|overlay\"} / node_filesystem_size_bytes{mountpoint=\"/\", fstype!~\"tmpfs|overlay\"}",
-          "legendFormat": "",
-          "range": true
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "percentunit",
-          "thresholds": {
-            "mode": "absolute",
-            "steps": [
-              {
-                "color": "red",
-                "value": null
-              },
-              {
-                "color": "orange",
-                "value": 0.1
-              },
-              {
-                "color": "green",
-                "value": 0.2
-              }
-            ]
-          },
-          "color": {
-            "mode": "thresholds"
-          }
-        },
-        "overrides": []
-      },
-      "options": {
-        "reduceOptions": {
-          "calcs": [
-            "lastNotNull"
-          ],
-          "fields": "",
-          "values": false
-        },
-        "colorMode": "background",
-        "graphMode": "area",
-        "textMode": "auto"
-      }
-    },
-    {
-      "id": 4,
-      "type": "stat",
-      "title": "PostgreSQL",
-      "gridPos": {
-        "x": 18,
-        "y": 0,
-        "w": 6,
-        "h": 4
-      },
-      "datasource": {
-        "type": "prometheus",
-        "uid": "prometheus"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "prometheus",
-            "uid": "prometheus"
-          },
-          "expr": "pg_up",
-          "legendFormat": "",
-          "range": true
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "thresholds": {
-            "mode": "absolute",
-            "steps": [
-              {
-                "color": "red",
-                "value": null
-              },
-              {
-                "color": "green",
-                "value": 1
-              }
-            ]
-          },
-          "color": {
-            "mode": "thresholds"
-          },
-          "mappings": [
-            {
-              "type": "value",
-              "options": {
-                "0": {
-                  "text": "Injoignable",
-                  "color": "red"
-                },
-                "1": {
-                  "text": "Joignable",
-                  "color": "green"
-                }
-              }
-            }
-          ]
-        },
-        "overrides": []
-      },
-      "options": {
-        "reduceOptions": {
-          "calcs": [
-            "lastNotNull"
-          ],
-          "fields": "",
-          "values": false
-        },
-        "colorMode": "background",
-        "graphMode": "area",
-        "textMode": "auto"
-      }
-    },
-    {
-      "id": 5,
-      "type": "timeseries",
-      "title": "Mémoire par conteneur",
-      "gridPos": {
-        "x": 0,
-        "y": 4,
-        "w": 12,
-        "h": 8
-      },
-      "datasource": {
-        "type": "prometheus",
-        "uid": "prometheus"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "prometheus",
-            "uid": "prometheus"
-          },
-          "expr": "sum by (name) (container_memory_working_set_bytes{name!=\"\"})",
-          "legendFormat": "{{name}}",
-          "range": true
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "bytes"
-        },
-        "overrides": []
-      },
-      "options": {
-        "legend": {
-          "displayMode": "list",
-          "placement": "bottom",
-          "showLegend": true
-        },
-        "tooltip": {
-          "mode": "multi",
-          "sort": "desc"
-        }
-      },
-      "description": "Recette et prod partagent l'hôte : leurs conteneurs se distinguent par le préfixe du projet Compose."
-    },
-    {
-      "id": 6,
-      "type": "timeseries",
-      "title": "Processeur par conteneur",
-      "gridPos": {
-        "x": 12,
-        "y": 4,
-        "w": 12,
-        "h": 8
-      },
-      "datasource": {
-        "type": "prometheus",
-        "uid": "prometheus"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "prometheus",
-            "uid": "prometheus"
-          },
-          "expr": "sum by (name) (rate(container_cpu_usage_seconds_total{name!=\"\"}[5m]))",
-          "legendFormat": "{{name}}",
-          "range": true
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "short"
-        },
-        "overrides": []
-      },
-      "options": {
-        "legend": {
-          "displayMode": "list",
-          "placement": "bottom",
-          "showLegend": true
-        },
-        "tooltip": {
-          "mode": "multi",
-          "sort": "desc"
-        }
-      }
-    },
-    {
-      "id": 7,
-      "type": "timeseries",
-      "title": "Mémoire de l'hôte",
-      "gridPos": {
-        "x": 0,
-        "y": 12,
-        "w": 12,
-        "h": 8
-      },
-      "datasource": {
-        "type": "prometheus",
-        "uid": "prometheus"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "prometheus",
-            "uid": "prometheus"
-          },
-          "expr": "node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes",
-          "legendFormat": "utilisée",
-          "range": true
-        },
-        {
-          "refId": "B",
-          "datasource": {
-            "type": "prometheus",
-            "uid": "prometheus"
-          },
-          "expr": "node_memory_MemTotal_bytes",
-          "legendFormat": "totale",
-          "range": true
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "bytes"
-        },
-        "overrides": []
-      },
-      "options": {
-        "legend": {
-          "displayMode": "list",
-          "placement": "bottom",
-          "showLegend": true
-        },
-        "tooltip": {
-          "mode": "multi",
-          "sort": "desc"
-        }
-      }
-    },
-    {
-      "id": 8,
-      "type": "timeseries",
-      "title": "Connexions PostgreSQL par état",
-      "gridPos": {
-        "x": 12,
-        "y": 12,
-        "w": 12,
-        "h": 8
-      },
-      "datasource": {
-        "type": "prometheus",
-        "uid": "prometheus"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "prometheus",
-            "uid": "prometheus"
-          },
-          "expr": "sum by (state) (pg_stat_activity_count)",
-          "legendFormat": "{{state}}",
-          "range": true
-        },
-        {
-          "refId": "B",
-          "datasource": {
-            "type": "prometheus",
-            "uid": "prometheus"
-          },
-          "expr": "max(pg_settings_max_connections)",
-          "legendFormat": "maximum",
-          "range": true
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "short"
-        },
-        "overrides": []
-      },
-      "options": {
-        "legend": {
-          "displayMode": "list",
-          "placement": "bottom",
-          "showLegend": true
-        },
-        "tooltip": {
-          "mode": "multi",
-          "sort": "desc"
-        }
-      }
-    },
-    {
-      "id": 9,
-      "type": "timeseries",
-      "title": "Transactions validées par base",
-      "gridPos": {
-        "x": 0,
-        "y": 20,
-        "w": 12,
-        "h": 8
-      },
-      "datasource": {
-        "type": "prometheus",
-        "uid": "prometheus"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "prometheus",
-            "uid": "prometheus"
-          },
-          "expr": "sum by (datname) (rate(pg_stat_database_xact_commit{datname!~\"template.*|postgres\"}[5m]))",
-          "legendFormat": "{{datname}}",
-          "range": true
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "ops"
-        },
-        "overrides": []
-      },
-      "options": {
-        "legend": {
-          "displayMode": "list",
-          "placement": "bottom",
-          "showLegend": true
-        },
-        "tooltip": {
-          "mode": "multi",
-          "sort": "desc"
-        }
-      }
-    },
-    {
-      "id": 10,
-      "type": "timeseries",
-      "title": "Taille des bases",
-      "gridPos": {
-        "x": 12,
-        "y": 20,
-        "w": 12,
-        "h": 8
-      },
-      "datasource": {
-        "type": "prometheus",
-        "uid": "prometheus"
-      },
-      "targets": [
-        {
-          "refId": "A",
-          "datasource": {
-            "type": "prometheus",
-            "uid": "prometheus"
-          },
-          "expr": "pg_database_size_bytes{datname!~\"template.*|postgres\"}",
-          "legendFormat": "{{datname}}",
-          "range": true
-        }
-      ],
-      "fieldConfig": {
-        "defaults": {
-          "unit": "bytes"
-        },
-        "overrides": []
-      },
-      "options": {
-        "legend": {
-          "displayMode": "list",
-          "placement": "bottom",
-          "showLegend": true
-        },
-        "tooltip": {
-          "mode": "multi",
-          "sort": "desc"
-        }
-      }
-    }
-  ]
-}
@@ -1,10 +0,0 @@
-apiVersion: 1
-
-providers:
-  - name: enervision
-    folder: EnerVision
-    type: file
-    disableDeletion: true
-    allowUiUpdates: false
-    options:
-      path: /etc/grafana/dashboards
@@ -1,28 +0,0 @@
-# Pourquoi : Grafana lit la base avec le rôle `supervision`, en lecture seule sur les seules tables
-# métier (db/roles/supervision.sql) - datasources.yml. Jamais le compte applicatif.
-
-apiVersion: 1
-
-datasources:
-  - name: Prometheus
-    uid: prometheus
-    type: prometheus
-    access: proxy
-    url: http://prometheus:9090
-    isDefault: true
-    editable: false
-
-  - name: TimescaleDB
-    uid: timescaledb
-    type: grafana-postgresql-datasource
-    access: proxy
-    url: db:5432
-    user: supervision
-    jsonData:
-      database: ${POSTGRES_DB}
-      sslmode: disable
-      postgresVersion: 1700
-      timescaledb: true
-    secureJsonData:
-      password: ${SUPERVISION_DB_PASSWORD}
-    editable: false
@@ -1,43 +0,0 @@
-# Contrainte : Prometheus ne lit pas les variables d'environnement dans ce fichier - prometheus.yml.
-# Le jeton de `/metrics` lui parvient en secret Compose (`metrics_token`, tiré d'APP_METRICS_TOKEN) ;
-# vide, l'API n'en exige aucun (app/api/security.py).
-
-global:
-  scrape_interval: 15s
-  evaluation_interval: 15s
-
-rule_files:
-  - /etc/prometheus/rules/*.yml
-
-alerting:
-  alertmanagers:
-    - static_configs:
-        - targets: ["alertmanager:9093"]
-
-scrape_configs:
-  - job_name: backend
-    authorization:
-      type: Bearer
-      credentials_file: /run/secrets/metrics_token
-    static_configs:
-      - targets: ["backend:8000"]
-
-  - job_name: prometheus
-    static_configs:
-      - targets: ["localhost:9090"]
-
-  - job_name: alertmanager
-    static_configs:
-      - targets: ["alertmanager:9093"]
-
-  - job_name: postgres
-    static_configs:
-      - targets: ["postgres-exporter:9187"]
-
-  - job_name: node
-    static_configs:
-      - targets: ["node-exporter:9100"]
-
-  - job_name: cadvisor
-    static_configs:
-      - targets: ["cadvisor:8080"]
@@ -1,103 +0,0 @@
-# Contrainte : chaque règle a son cas dans tests/enervision.test.yml, joué par `promtool test
-# rules` en CI - enervision.yml. Une règle modifiée sans son test fait échouer le job Infra.
-# Pourquoi : `critical` réveille (mail immédiat, rappel toutes les heures), `warning` se lit le
-# lendemain ; alertmanager.yml masque le warning d'une cible déjà en critical.
-
-groups:
-  - name: api
-    rules:
-      - alert: ApiIndisponible
-        expr: up{job="backend"} == 0
-        for: 2m
-        labels:
-          severity: critical
-        annotations:
-          summary: "L'API ne répond plus"
-          description: "Prometheus ne joint plus {{ $labels.instance }} depuis 2 minutes."
-
-      - alert: ApiErreursServeur
-        expr: |
-          sum(rate(http_requests_total{job="backend", status="5xx"}[5m]))
-            / sum(rate(http_requests_total{job="backend"}[5m])) > 0.05
-        for: 5m
-        labels:
-          severity: critical
-        annotations:
-          summary: "Plus de 5 % de réponses 5xx"
-          description: "{{ $value | humanizePercentage }} des réponses de l'API sont des erreurs serveur."
-
-      - alert: ApiLatenceElevee
-        expr: |
-          histogram_quantile(0.95,
-            sum by (le) (rate(http_request_duration_highr_seconds_bucket{job="backend"}[5m]))
-          ) > 1
-        for: 10m
-        labels:
-          severity: warning
-        annotations:
-          summary: "p95 de l'API au-dessus d'une seconde"
-          description: "Le p95 des réponses vaut {{ $value | humanizeDuration }} depuis 10 minutes."
-
-  - name: base
-    rules:
-      - alert: BaseIndisponible
-        expr: pg_up == 0
-        for: 2m
-        labels:
-          severity: critical
-        annotations:
-          summary: "PostgreSQL ne répond plus"
-          description: "L'exportateur ne se connecte plus à la base depuis 2 minutes."
-
-      - alert: BaseConnexionsSaturees
-        expr: |
-          sum by (instance) (pg_stat_activity_count)
-            / max by (instance) (pg_settings_max_connections) > 0.8
-        for: 5m
-        labels:
-          severity: warning
-        annotations:
-          summary: "Connexions PostgreSQL au-delà de 80 %"
-          description: "{{ $value | humanizePercentage }} des connexions autorisées sont ouvertes."
-
-  - name: hote
-    rules:
-      - alert: HoteMemoireSaturee
-        expr: 1 - node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes > 0.9
-        for: 10m
-        labels:
-          severity: warning
-        annotations:
-          summary: "Mémoire de l'hôte au-delà de 90 %"
-          description: "{{ $value | humanizePercentage }} de la mémoire est utilisée, recette et prod comprises."
-
-      - alert: HoteDisquePlein
-        expr: |
-          node_filesystem_avail_bytes{mountpoint="/", fstype!~"tmpfs|overlay"}
-            / node_filesystem_size_bytes{mountpoint="/", fstype!~"tmpfs|overlay"} < 0.1
-        for: 10m
-        labels:
-          severity: critical
-        annotations:
-          summary: "Moins de 10 % de disque libre"
-          description: "Il reste {{ $value | humanizePercentage }} d'espace sur la racine de l'hôte."
-
-      - alert: HoteCpuSature
-        expr: 1 - avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) > 0.9
-        for: 15m
-        labels:
-          severity: warning
-        annotations:
-          summary: "Processeur de l'hôte au-delà de 90 %"
-          description: "Le processeur est occupé à {{ $value | humanizePercentage }} depuis 15 minutes."
-
-  - name: supervision
-    rules:
-      - alert: CibleInjoignable
-        expr: up{job!="backend"} == 0
-        for: 5m
-        labels:
-          severity: warning
-        annotations:
-          summary: "Cible de supervision injoignable"
-          description: "Prometheus ne joint plus {{ $labels.job }} ({{ $labels.instance }}) depuis 5 minutes."
@@ -1,112 +0,0 @@
-rule_files:
-  - ../rules/enervision.yml
-
-evaluation_interval: 1m
-
-tests:
-  - name: l'API injoignable déclenche une alerte critique au bout de 2 minutes
-    interval: 1m
-    input_series:
-      - series: 'up{job="backend", instance="backend:8000"}'
-        values: "1 0 0 0 0"
-    alert_rule_test:
-      - eval_time: 2m
-        alertname: ApiIndisponible
-        exp_alerts: []
-      - eval_time: 3m
-        alertname: ApiIndisponible
-        exp_alerts:
-          - exp_labels:
-              severity: critical
-              job: backend
-              instance: backend:8000
-            exp_annotations:
-              summary: "L'API ne répond plus"
-              description: "Prometheus ne joint plus backend:8000 depuis 2 minutes."
-
-  - name: une API qui répond ne déclenche rien
-    interval: 1m
-    input_series:
-      - series: 'up{job="backend", instance="backend:8000"}'
-        values: "1x10"
-    alert_rule_test:
-      - eval_time: 10m
-        alertname: ApiIndisponible
-        exp_alerts: []
-
-  - name: dix pour cent de 5xx déclenchent l'alerte d'erreurs serveur
-    interval: 1m
-    input_series:
-      - series: 'http_requests_total{job="backend", handler="/api/v1/sites", method="GET", status="5xx"}'
-        values: "0+10x20"
-      - series: 'http_requests_total{job="backend", handler="/api/v1/sites", method="GET", status="2xx"}'
-        values: "0+90x20"
-    alert_rule_test:
-      - eval_time: 12m
-        alertname: ApiErreursServeur
-        exp_alerts:
-          - exp_labels:
-              severity: critical
-            exp_annotations:
-              summary: "Plus de 5 % de réponses 5xx"
-              description: "10% des réponses de l'API sont des erreurs serveur."
-
-  - name: un p95 au-delà d'une seconde déclenche l'alerte de latence
-    interval: 1m
-    input_series:
-      - series: 'http_request_duration_highr_seconds_bucket{job="backend", le="0.5"}'
-        values: "0x30"
-      - series: 'http_request_duration_highr_seconds_bucket{job="backend", le="1"}'
-        values: "0x30"
-      - series: 'http_request_duration_highr_seconds_bucket{job="backend", le="2"}'
-        values: "0+10x30"
-      - series: 'http_request_duration_highr_seconds_bucket{job="backend", le="+Inf"}'
-        values: "0+10x30"
-    alert_rule_test:
-      - eval_time: 20m
-        alertname: ApiLatenceElevee
-        exp_alerts:
-          - exp_labels:
-              severity: warning
-            exp_annotations:
-              summary: "p95 de l'API au-dessus d'une seconde"
-              description: "Le p95 des réponses vaut 1.95s depuis 10 minutes."
-
-  - name: la mémoire de l'hôte au-delà de 90 % déclenche un avertissement
-    interval: 1m
-    input_series:
-      - series: 'node_memory_MemAvailable_bytes{job="node", instance="node-exporter:9100"}'
-        values: "500000000x15"
-      - series: 'node_memory_MemTotal_bytes{job="node", instance="node-exporter:9100"}'
-        values: "10000000000x15"
-    alert_rule_test:
-      - eval_time: 12m
-        alertname: HoteMemoireSaturee
-        exp_alerts:
-          - exp_labels:
-              severity: warning
-              job: node
-              instance: node-exporter:9100
-            exp_annotations:
-              summary: "Mémoire de l'hôte au-delà de 90 %"
-              description: "95% de la mémoire est utilisée, recette et prod comprises."
-
-  - name: un exportateur muet déclenche l'alerte de cible, pas celle de l'API
-    interval: 1m
-    input_series:
-      - series: 'up{job="postgres", instance="postgres-exporter:9187"}'
-        values: "0x10"
-    alert_rule_test:
-      - eval_time: 6m
-        alertname: CibleInjoignable
-        exp_alerts:
-          - exp_labels:
-              severity: warning
-              job: postgres
-              instance: postgres-exporter:9187
-            exp_annotations:
-              summary: "Cible de supervision injoignable"
-              description: "Prometheus ne joint plus postgres (postgres-exporter:9187) depuis 5 minutes."
-      - eval_time: 6m
-        alertname: ApiIndisponible
-        exp_alerts: []
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
ineszang44	6301ffedd7	Merge branch 'dev' into feat/deploy	2026-09-23 09:50:54 +02:00
ineszang44	da5d2d838a	feat: saisie des logins pour accéder au vault	2026-09-22 15:26:30 +02:00
ineszang44	8386e05f31	fix: déploiement pour le frontend	2026-09-21 16:07:43 +02:00
ineszang44	2a7e1c25fc	Merge branch 'dev' into feat/deploy	2026-09-21 14:06:42 +02:00
ineszang44	5d955ca991	fix: suppression du flag "--mount"	2026-09-21 14:05:55 +02:00
ineszang44	cefb07067d	init: fichier terraform pour le backend	2026-09-21 11:49:10 +02:00
ineszang44	3cc6c67e0d	Merge branch 'dev' into feat/deploy	2026-09-21 11:05:12 +02:00
ineszang44	93afc6031c	fix: lancement de la commande npm run build, source directe pour l'image du runner	2026-09-21 10:40:14 +02:00
ineszang44	99db807e3c	feat: création auto de l'image et du conteneur	2026-09-18 15:41:54 +02:00
ineszang44	47c4fd445b	init: terraform	2026-09-18 09:48:20 +02:00
ineszang44	667592033b	chore(frontend): suppression des variables inutiles, copie des fichiers terraform communs aux environnements	2026-09-17 15:01:17 +02:00
ineszang44	6785c70f6f	Merge remote-tracking branch 'origin/dev' into feat/deploy	2026-09-17 14:51:42 +02:00
ineszang44	692ec436a5	feat+chore(frontend): déploiement selon l'env sélectionné, commentaires sur le fichier terraform	2026-09-17 11:28:22 +02:00
ineszang44	a3d32a6fb1	chore(frontend): fichier tf pour le front	2026-09-16 16:24:59 +02:00