fix(auth): corrige la CI cassee par le nouvel endpoint de validation

/auth/reset-password/validate manquait a la liste explicite des routes publiques (test_route_protection) et n'avait pas le modele de reponse 422 declare (openapi.json desynchronise du contrat genere).
feat(auth): verifie le lien de reset des le chargement, sans le consommer
2026-09-17 15:31:14 +02:00 · 2026-09-17 15:28:50 +02:00 · 2026-09-17 14:57:05 +02:00 · 2026-09-17 14:49:46 +02:00 · 2026-09-17 14:40:53 +02:00 · 2026-09-17 14:35:14 +02:00
79 changed files with 2527 additions and 3168 deletions
@@ -1,40 +0,0 @@
-version: 2
-updates:
-  # Frontend — npm
-  - package-ecosystem: "npm"
-    directory: "/apps/frontend"
-    schedule:
-      interval: "weekly"
-    open-pull-requests-limit: 5
-    groups:
-      frontend-dependencies:
-        patterns:
-          - "*"
-
-  # Backend — uv (lit pyproject.toml / uv.lock)
-  - package-ecosystem: "uv"
-    directory: "/apps/backend"
-    schedule:
-      interval: "weekly"
-    open-pull-requests-limit: 5
-    groups:
-      backend-dependencies:
-        patterns:
-          - "*"
-
-  # Les workflows GitHub Actions eux-mêmes ont aussi des dépendances à jour
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "weekly"
-
-  # Si un Dockerfile existe pour le backend
-  - package-ecosystem: "docker"
-    directory: "/apps/backend"
-    schedule:
-      interval: "weekly"
-
-  - package-ecosystem: "docker"
-    directory: "/apps/frontend"
-    schedule:
-      interval: "weekly"
@@ -1,59 +0,0 @@
-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).
-
-on:
-  push:
-    paths:
-      - "ml/**"
-      - ".github/workflows/ml.yml"
-  pull_request:
-    paths:
-      - "ml/**"
-      - ".github/workflows/ml.yml"
-
-permissions:
-  contents: read
-
-concurrency:
-  group: ml-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  verification:
-    name: Lint, typage et tests
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ml
-
-    steps:
-      - name: Récupère le dépôt
-        uses: actions/checkout@v4
-
-      - name: Installe uv
-        uses: astral-sh/setup-uv@v5
-        with:
-          enable-cache: true
-          cache-dependency-glob: ml/uv.lock
-
-      - name: Installe l'interpréteur déclaré par .python-version
-        run: uv python install
-
-      - 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 .
-
-      - name: Analyse statique
-        run: uv run ruff check --output-format=github .
-
-      - name: Typage
-        run: uv run mypy enervision_ml tests
-
-      # Aucun test ne touche PostgreSQL ni MLflow distant : tout tourne sur donnees
-      # synthetiques ou un magasin SQLite local jetable (cf. ml/tests/test_train.py).
-      - name: Tests
-        run: uv run pytest
@@ -58,14 +58,6 @@ data/raw/*
 monitoring/grafana/data/
 monitoring/prometheus/data/

-# ML : jeu de donnees, modeles entraines et suivi MLflow local, tous generes/volumineux
-ml/data/
-ml/models/*
-!ml/models/.gitkeep
-ml/mlruns/
-ml/mlartifacts/
-ml/mlflow.db
-
 # IDE et OS
 .idea/
 .vscode/
@@ -1,17 +1,15 @@
 BACKEND := apps/backend
 FRONTEND := apps/frontend
-ML := ml

 .DEFAULT_GOAL := help
-.PHONY: help install install-backend install-frontend install-ml dev dev-backend dev-frontend \
+.PHONY: help install install-backend install-frontend dev dev-backend dev-frontend \
        lint format typecheck test test-cov test-integration check \
-        openapi docker-build db-up db-down db-reset db-logs db-psql migrate bootstrap-admin \
-        ml-lint ml-typecheck ml-test ml-check ml-train
+        openapi docker-build db-up db-down db-reset db-logs db-psql migrate bootstrap-admin

 help: ## Liste les cibles disponibles
 	@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 ## Installe les dépendances backend, frontend et ML
+install: install-backend install-frontend ## Installe les dépendances backend et frontend

 install-backend: ## Installe les dépendances du backend
 	cd $(BACKEND) && uv sync --all-groups
@@ -19,9 +17,6 @@ install-backend: ## Installe les dépendances du backend
 install-frontend: ## Installe les dépendances du frontend
 	cd $(FRONTEND) && npm ci

-install-ml: ## Installe les dépendances du pipeline ML
-	cd $(ML) && uv sync --all-groups
-
 dev: ## Lance toute la stack (backend + frontend) en rechargement à chaud
 	@trap 'kill 0' EXIT INT TERM; \
 	$(MAKE) --no-print-directory dev-backend & \
@@ -60,20 +55,6 @@ check: lint typecheck test ## Chaîne de vérification complète
 openapi: ## Régénère apps/backend/openapi.json depuis les routes déclarées
 	cd $(BACKEND) && uv run python -m app.cli export-openapi

-ml-lint: ## Analyse statique du pipeline ML
-	cd $(ML) && uv run ruff check .
-
-ml-typecheck: ## Vérifie le typage du pipeline ML
-	cd $(ML) && uv run mypy enervision_ml tests
-
-ml-test: ## Exécute les tests du pipeline ML (donnees synthetiques, sans base ni serveur MLflow)
-	cd $(ML) && uv run pytest
-
-ml-check: ml-lint ml-typecheck ml-test ## Chaîne de vérification complète du pipeline ML
-
-ml-train: ## Entraine le modele LightGBM. CSV=chemin optionnel, sinon lit ML_DATABASE_URL
-	cd $(ML) && uv run python -m enervision_ml.train $(if $(CSV),--csv $(CSV),)
-
 docker-build: ## Construit l'image du backend
 	docker build -t enervision-backend:local $(BACKEND)

@@ -25,7 +25,6 @@ Ce que la documentation apporte à chacun : [docs/architecture/00-vue-ensemble.m
 | Infra      | Terraform (k3s single-node)         | `infra/terraform`   | Initialise    |
 | CI/CD      | GitHub Actions                      | `.github/workflows` | Backend en place |
 | Monitoring | Prometheus, Grafana, Alertmanager   | `monitoring`        | A initialiser |
-| ML         | LightGBM, MLflow                    | `ml`                | Entrainement initialise |

 Le backend, la base et l'infrastructure (Terraform/k3s) sont initialises a ce stade. Le frontend
 sert un tableau de bord sur `/dashboard`, dont les données proviennent de fixtures : les endpoints
@@ -54,7 +53,6 @@ L'etat detaille de chaque brique et les vues d'architecture sont dans
 ├── infra/terraform/
 │   ├── modules/        Modules reutilisables
 │   └── environments/   Racines Terraform, une par environnement
-├── ml/                 Pipeline d'entrainement LightGBM, suivi MLflow
 ├── monitoring/
 │   ├── prometheus/     Collecte et regles d'alerte
 │   ├── grafana/        Provisioning et dashboards
@@ -8,3 +8,13 @@ APP_SECRET_KEY=change_me

 APP_CORS_ORIGINS=http://localhost:4200
 DATABASE_URL=postgresql+asyncpg://enervision:change_me@localhost:5433/enervision
+
+# Mot de passe oublié : lien à usage unique valable 15 minutes par défaut.
+APP_FRONTEND_RESET_PASSWORD_URL=http://localhost:4200/reset-password
+
+# SMTP local de dev (Mailpit, cf. docker-compose.yml) : aucune authentification, aucun TLS.
+# À remplacer par un vrai relais en staging/prod.
+APP_SMTP_HOST=localhost
+APP_SMTP_PORT=1025
+APP_SMTP_USE_TLS=false
+APP_SMTP_FROM_ADDRESS=no-reply@enervision.fr
@@ -103,6 +103,8 @@ Le sens de dependance est unique : `endpoints` vers `services` vers `repositorie
 | `/api/v1/auth/logout` | Ferme la session courante | cookie, idempotente |
 | `/api/v1/auth/logout-all` | Ferme toutes les sessions du compte | jeton |
 | `/api/v1/auth/password` | Change son propre mot de passe | jeton |
+| `/api/v1/auth/forgot-password` | Demande un lien de réinitialisation par email | public |
+| `/api/v1/auth/reset-password` | Choisit un nouveau mot de passe depuis ce lien | public |
 | `/api/v1/auth/me` | Décrit le compte connecté | jeton |
 | `/api/v1/users` | Liste et crée des comptes | `admin` |
 | `/api/v1/users/{id}` | Change le rôle ou l'activation | `admin` |
@@ -0,0 +1,96 @@
+"""jetons et tentatives de reinitialisation de mot de passe
+
+Revision ID: c0adab96238c
+Revises: e6d2026091501
+Create Date: 2026-09-17 10:37:12.571314
+
+Meme schema que `refresh_token` pour `password_reset_token` : seule l'empreinte SHA-256 du
+jeton est stockee, jamais le jeton lui-meme, pour la meme raison (revocation en cascade,
+aucune session utilisable dans un pg_dump qui fuiterait).
+
+`password_reset_attempt` vit hors de `audit_log`, comme `login_attempt`, car son volume est
+pilote par l'attaquant : une campagne de demandes y ecrirait des lignes que l'audit, en ajout
+seul, ne devrait jamais purger.
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+revision: str = "c0adab96238c"
+down_revision: str | Sequence[str] | None = "e6d2026091501"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+JETONS_VIVANTS = "consumed_at is null"
+
+
+def upgrade() -> None:
+    op.create_table(
+        "password_reset_attempt",
+        sa.Column("id", sa.BigInteger(), sa.Identity(always=True), nullable=False),
+        sa.Column(
+            "occurred_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.text("now()"),
+            nullable=False,
+        ),
+        sa.Column("email_tried", sa.String(length=320), nullable=False),
+        sa.Column("client_ip", postgresql.INET(), nullable=True),
+        sa.PrimaryKeyConstraint("id", name="pk_password_reset_attempt"),
+    )
+    op.create_index(
+        "ix_password_reset_attempt_email_date",
+        "password_reset_attempt",
+        ["email_tried", "occurred_at"],
+    )
+    op.create_index(
+        "ix_password_reset_attempt_ip_date", "password_reset_attempt", ["client_ip", "occurred_at"]
+    )
+
+    op.create_table(
+        "password_reset_token",
+        sa.Column("id", sa.UUID(), server_default=sa.text("gen_random_uuid()"), nullable=False),
+        sa.Column("user_id", sa.UUID(), nullable=False),
+        sa.Column("token_hash", sa.LargeBinary(), nullable=False),
+        sa.Column(
+            "issued_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.text("now()"),
+            nullable=False,
+        ),
+        sa.Column("expires_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("consumed_at", sa.DateTime(timezone=True), nullable=True),
+        sa.Column("client_ip", postgresql.INET(), nullable=True),
+        sa.Column("user_agent", sa.Text(), nullable=True),
+        sa.ForeignKeyConstraint(
+            ["user_id"],
+            ["app_user.id"],
+            name="fk_password_reset_token_user",
+            ondelete="CASCADE",
+        ),
+        sa.PrimaryKeyConstraint("id", name="pk_password_reset_token"),
+        sa.UniqueConstraint("token_hash", name="uq_password_reset_token_hash"),
+    )
+    op.create_index("ix_password_reset_token_user", "password_reset_token", ["user_id"])
+    op.create_index(
+        "ix_password_reset_token_vivants",
+        "password_reset_token",
+        ["user_id"],
+        postgresql_where=JETONS_VIVANTS,
+    )
+
+
+def downgrade() -> None:
+    op.drop_index(
+        "ix_password_reset_token_vivants",
+        table_name="password_reset_token",
+        postgresql_where=JETONS_VIVANTS,
+    )
+    op.drop_index("ix_password_reset_token_user", table_name="password_reset_token")
+    op.drop_table("password_reset_token")
+    op.drop_index("ix_password_reset_attempt_ip_date", table_name="password_reset_attempt")
+    op.drop_index("ix_password_reset_attempt_email_date", table_name="password_reset_attempt")
+    op.drop_table("password_reset_attempt")
@@ -16,6 +16,7 @@ from sqlalchemy.ext.asyncio import AsyncSession

 from app.core.config import Settings, get_settings
 from app.core.hashing import Argon2Hasher, build_hasher
+from app.core.mailer import Mailer, SmtpConfig
 from app.core.principal import Principal
 from app.core.roles import AccountKind, Role, has_at_least
 from app.core.security import TokenExpiredError, TokenInvalidError, TokenPolicy
@@ -24,13 +25,15 @@ from app.db.session import get_session
 from app.repositories.alert import AlertRepository
 from app.repositories.audit_log import AuditLogRepository
 from app.repositories.login_attempt import LoginAttemptRepository
+from app.repositories.password_reset_attempt import PasswordResetAttemptRepository
+from app.repositories.password_reset_token import PasswordResetTokenRepository
 from app.repositories.reading import ReadingRepository
 from app.repositories.recommendation import RecommendationRepository
 from app.repositories.refresh_token import RefreshTokenRepository
 from app.repositories.site import SiteRepository
 from app.repositories.user import UserRepository
 from app.services.alert import AlertService
-from app.services.auth import AuthService, LoginPolicy
+from app.services.auth import AuthService, LoginPolicy, PasswordResetPolicy
 from app.services.reading import ReadingService
 from app.services.recommendation import RecommendationService
 from app.services.sensor import SensorService
@@ -98,11 +101,27 @@ def get_client_ip(request: Request, settings: SettingsDep) -> str | None:
    return request.client.host if request.client else None


+def get_mailer(settings: SettingsDep) -> Mailer:
+    return Mailer(
+        SmtpConfig(
+            host=settings.smtp_host,
+            port=settings.smtp_port,
+            username=settings.smtp_username,
+            password=(
+                settings.smtp_password.get_secret_value() if settings.smtp_password else None
+            ),
+            use_tls=settings.smtp_use_tls,
+            from_address=settings.smtp_from_address,
+        )
+    )
+
+
 def get_auth_service(
    session: SessionDep,
    settings: SettingsDep,
    hasher: Annotated[Argon2Hasher, Depends(get_hasher)],
    token_policy: Annotated[TokenPolicy, Depends(get_token_policy)],
+    mailer: Annotated[Mailer, Depends(get_mailer)],
 ) -> AuthService:
    return AuthService(
        users=UserRepository(session),
@@ -119,6 +138,16 @@ def get_auth_service(
            max_failures_per_identifier=settings.login_max_failures_per_identifier,
        ),
        refresh_ttl=timedelta(seconds=settings.refresh_token_ttl_seconds),
+        reset_tokens=PasswordResetTokenRepository(session),
+        reset_attempts=PasswordResetAttemptRepository(session),
+        reset_policy=PasswordResetPolicy(
+            window_seconds=settings.password_reset_window_seconds,
+            max_requests_per_identifier=settings.password_reset_max_requests_per_identifier,
+            max_requests_per_ip=settings.password_reset_max_requests_per_ip,
+            token_ttl=timedelta(seconds=settings.password_reset_ttl_seconds),
+            frontend_reset_url=settings.frontend_reset_password_url,
+        ),
+        mailer=mailer,
    )


@@ -164,3 +164,16 @@ REPONSE_ORIGINE_REFUSEE: Final[Reponses] = {
        "description": "Origine non autorisée (protection CSRF de `require_trusted_origin`).",
    },
 }
+
+REPONSE_LIMITE: Final[Reponses] = {
+    429: {
+        "model": ErrorResponse,
+        "description": "Trop de demandes sur cette fenêtre glissante.",
+        "headers": {
+            "Retry-After": {
+                "description": "Secondes à attendre avant une nouvelle tentative.",
+                "schema": {"type": "integer"},
+            }
+        },
+    },
+}
@@ -2,7 +2,7 @@
 # d'accès ne va jamais dans un cookie. C'est ce qui réduit la surface CSRF aux trois routes de
 # ce module : partout ailleurs, le navigateur n'attache rien de lui-même.

-from fastapi import APIRouter, Depends, HTTPException, Request, Response, status
+from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, Request, Response, status

 from app.api.deps import (
    AuthServiceDep,
@@ -12,6 +12,7 @@ from app.api.deps import (
    require_trusted_origin,
 )
 from app.api.openapi import (
+    REPONSE_LIMITE,
    REPONSE_ORIGINE_REFUSEE,
    REPONSE_VALIDATION,
    REPONSES_AUTHENTIFIEES,
@@ -21,15 +22,19 @@ from app.api.openapi import (
 from app.core.cookies import RefreshCookie, cookie_name
 from app.core.logging import get_logger
 from app.schemas.auth import (
+    ForgotPasswordRequest,
    LoginRequest,
    PasswordChangeRequest,
    PrincipalResponse,
+    ResetPasswordRequest,
+    ResetTokenValidationResponse,
    TokenResponse,
 )
 from app.schemas.errors import ErrorResponse
 from app.services.auth import (
    AuthenticatedSession,
    InvalidCredentialsError,
+    InvalidOrExpiredResetTokenError,
    RateLimitedError,
    SessionRejectedError,
 )
@@ -39,6 +44,7 @@ logger = get_logger(__name__)

 DETAIL_IDENTIFIANTS = "Identifiants invalides"
 DETAIL_SESSION = "Session invalide"
+DETAIL_LIEN_RESET = "Lien invalide ou expiré"

 REPONSES_LOGIN: Reponses = {
    **REPONSE_VALIDATION,
@@ -85,6 +91,20 @@ REPONSES_MOT_DE_PASSE: Reponses = {
    },
 }

+REPONSES_FORGOT_PASSWORD: Reponses = {
+    **REPONSE_VALIDATION,
+    **REPONSE_LIMITE,
+}
+
+REPONSES_RESET_PASSWORD: Reponses = {
+    **REPONSE_VALIDATION,
+    **REPONSE_ORIGINE_REFUSEE,
+    400: {
+        "model": ErrorResponse,
+        "description": "Lien invalide, déjà utilisé, ou expiré (durée de vie : 15 minutes).",
+    },
+}
+

 def repond(
    response: Response, settings: SettingsDep, session: AuthenticatedSession
@@ -267,3 +287,79 @@ async def change_password(

    logger.info("auth.password_changed user_id=%s", principal.id)
    return repond(response, settings, session)
+
+
+@router.post(
+    "/forgot-password",
+    status_code=status.HTTP_202_ACCEPTED,
+    summary="Demande un lien de réinitialisation par email",
+    responses=REPONSES_FORGOT_PASSWORD,
+)
+async def forgot_password(
+    payload: ForgotPasswordRequest,
+    request: Request,
+    response: Response,
+    service: AuthServiceDep,
+    background_tasks: BackgroundTasks,
+    client_ip: str | None = Depends(get_client_ip),
+) -> None:
+    response.headers["Cache-Control"] = "no-store"
+
+    try:
+        await service.request_password_reset(
+            email=payload.email,
+            client_ip=client_ip,
+            user_agent=request.headers.get("user-agent"),
+            background_tasks=background_tasks,
+        )
+    except RateLimitedError as erreur:
+        logger.warning("auth.password_reset.rate_limited ip=%s", client_ip)
+        raise HTTPException(
+            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+            detail="Trop de demandes, réessayez plus tard",
+            headers={"Retry-After": str(erreur.retry_after)},
+        ) from erreur
+
+
+@router.get(
+    "/reset-password/validate",
+    response_model=ResetTokenValidationResponse,
+    summary="Vérifie sans le consommer si un lien de réinitialisation est encore valide",
+    responses=REPONSE_VALIDATION,
+)
+async def validate_reset_token(token: str, service: AuthServiceDep) -> ResetTokenValidationResponse:
+    return ResetTokenValidationResponse(valid=await service.is_reset_token_valid(token=token))
+
+
+@router.post(
+    "/reset-password",
+    response_model=TokenResponse,
+    summary="Choisit un nouveau mot de passe depuis un lien reçu par email",
+    dependencies=[Depends(require_trusted_origin)],
+    responses=REPONSES_RESET_PASSWORD,
+)
+async def reset_password(
+    payload: ResetPasswordRequest,
+    request: Request,
+    response: Response,
+    settings: SettingsDep,
+    service: AuthServiceDep,
+    client_ip: str | None = Depends(get_client_ip),
+) -> TokenResponse:
+    response.headers["Cache-Control"] = "no-store"
+
+    try:
+        session = await service.confirm_password_reset(
+            token=payload.token,
+            new_password=payload.new_password,
+            client_ip=client_ip,
+            user_agent=request.headers.get("user-agent"),
+        )
+    except InvalidOrExpiredResetTokenError as erreur:
+        logger.warning("auth.password_reset.invalid_token ip=%s", client_ip)
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail=DETAIL_LIEN_RESET
+        ) from erreur
+
+    logger.info("auth.password_reset.success user_id=%s", session.principal.id)
+    return repond(response, settings, session)
@@ -9,6 +9,7 @@ import argparse
 import asyncio
 import json
 import secrets
+import string
 import sys
 from getpass import getpass
 from pathlib import Path
@@ -22,9 +23,9 @@ from app.core.roles import Role
 from app.db.session import get_session_factory
 from app.main import create_app
 from app.repositories.user import UserRepository
+from app.schemas.auth import PASSWORD_MIN_LENGTH, SPECIAL_CHARACTERS, valide_complexite

 LONGUEUR_MOT_DE_PASSE_GENERE = 24
-LONGUEUR_MINIMALE = 12
 CHEMIN_CONTRAT = Path(__file__).resolve().parent.parent / "openapi.json"


@@ -111,15 +112,34 @@ def build_parser() -> argparse.ArgumentParser:
    return parser


+def genere_mot_de_passe() -> str:
+    tirage = secrets.SystemRandom()
+    classes = [
+        string.ascii_uppercase,
+        string.ascii_lowercase,
+        string.digits,
+        SPECIAL_CHARACTERS,
+    ]
+    reste = LONGUEUR_MOT_DE_PASSE_GENERE - len(classes)
+    caracteres = [tirage.choice(classe) for classe in classes]
+    caracteres += [tirage.choice("".join(classes)) for _ in range(reste)]
+    tirage.shuffle(caracteres)
+    return "".join(caracteres)
+
+
 def read_password(*, generate: bool) -> str:
    if generate:
-        mot_de_passe = secrets.token_urlsafe(LONGUEUR_MOT_DE_PASSE_GENERE)
+        mot_de_passe = genere_mot_de_passe()
        print(f"Mot de passe généré, il ne sera plus affiché : {mot_de_passe}")
        return mot_de_passe

    mot_de_passe = getpass("Mot de passe : ")
-    if len(mot_de_passe) < LONGUEUR_MINIMALE:
-        raise SystemExit(f"Le mot de passe doit faire au moins {LONGUEUR_MINIMALE} caractères")
+    if len(mot_de_passe) < PASSWORD_MIN_LENGTH:
+        raise SystemExit(f"Le mot de passe doit faire au moins {PASSWORD_MIN_LENGTH} caractères")
+    try:
+        valide_complexite(mot_de_passe)
+    except ValueError as erreur:
+        raise SystemExit(str(erreur)) from erreur
    if mot_de_passe != getpass("Confirmation : "):
        raise SystemExit("Les deux saisies diffèrent")
    return mot_de_passe
@@ -54,6 +54,19 @@ class Settings(BaseSettings):
    login_max_failures_per_ip: int = Field(default=20, ge=1)
    login_max_failures_per_identifier: int = Field(default=50, ge=1)

+    password_reset_ttl_seconds: int = Field(default=900, ge=60, le=3600)
+    password_reset_window_seconds: int = Field(default=900, ge=60)
+    password_reset_max_requests_per_identifier: int = Field(default=3, ge=1)
+    password_reset_max_requests_per_ip: int = Field(default=10, ge=1)
+
+    smtp_host: str = "localhost"
+    smtp_port: int = Field(default=587, ge=1, le=65535)
+    smtp_username: str | None = None
+    smtp_password: SecretStr | None = None
+    smtp_use_tls: bool = False
+    smtp_from_address: str = "no-reply@enervision.fr"
+    frontend_reset_password_url: str = "http://localhost:4200/reset-password"  # noqa: S105
+
    trust_proxy_headers: bool = False
    expose_api_docs: bool | None = None
    metrics_token: SecretStr | None = None
@@ -0,0 +1,48 @@
+# Piège : l'URL de réinitialisation porte le jeton en clair. Ne jamais la journaliser :
+# `send_password_reset_email()` ne logue que le destinataire, jamais `reset_url`.
+
+from dataclasses import dataclass
+from email.message import EmailMessage
+
+import aiosmtplib
+
+from app.core.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+@dataclass(frozen=True, slots=True)
+class SmtpConfig:
+    host: str
+    port: int
+    username: str | None
+    password: str | None
+    use_tls: bool
+    from_address: str
+
+
+class Mailer:
+    def __init__(self, config: SmtpConfig) -> None:
+        self._config = config
+
+    async def send_password_reset_email(self, *, to: str, reset_url: str) -> None:
+        message = EmailMessage()
+        message["From"] = self._config.from_address
+        message["To"] = to
+        message["Subject"] = "Réinitialisation de votre mot de passe EnerVision"
+        message.set_content(
+            "Une réinitialisation de mot de passe a été demandée pour ce compte.\n\n"
+            f"Ouvrez ce lien dans les 15 minutes pour choisir un nouveau mot de passe : "
+            f"{reset_url}\n\n"
+            "Si vous n'êtes pas à l'origine de cette demande, ignorez cet email."
+        )
+
+        _, message_recu = await aiosmtplib.send(
+            message,
+            hostname=self._config.host,
+            port=self._config.port,
+            username=self._config.username,
+            password=self._config.password,
+            use_tls=self._config.use_tls,
+        )
+        logger.info("mailer.password_reset_sent to=%s smtp_response=%s", to, message_recu)
@@ -4,6 +4,8 @@
 from app.models.audit_log import AuditLog
 from app.models.energy import Alert, Dataset, Prediction, Reading, Recommendation, Site
 from app.models.login_attempt import LoginAttempt
+from app.models.password_reset_attempt import PasswordResetAttempt
+from app.models.password_reset_token import PasswordResetToken
 from app.models.refresh_token import RefreshToken
 from app.models.user import AppUser

@@ -13,6 +15,8 @@ __all__ = [
    "AuditLog",
    "Dataset",
    "LoginAttempt",
+    "PasswordResetAttempt",
+    "PasswordResetToken",
    "Prediction",
    "Reading",
    "Recommendation",
@@ -29,6 +29,8 @@ class AuditAction(StrEnum):
    COMPTE_ACTIVE = "user.enabled"
    COMPTE_MOT_DE_PASSE_REINITIALISE = "user.password_reset_by_admin"
    COMPTE_MOT_DE_PASSE_CHANGE = "user.password_changed"
+    MOT_DE_PASSE_OUBLIE_DEMANDE = "auth.password_reset_requested"
+    MOT_DE_PASSE_REINITIALISE_PAR_SOI = "auth.password_reset_self_service"
    REFRESH_REUTILISE = "auth.refresh_reuse_detected"
    SESSIONS_REVOQUEES = "auth.all_sessions_revoked"
    LIMITE_PAR_IDENTIFIANT = "auth.identifier_throttled"
@@ -0,0 +1,27 @@
+# Pourquoi : même séparation que `login_attempt` par rapport à `audit_log` : ce compteur est
+# piloté par l'attaquant (une campagne de demandes) et se purge, l'audit log est en ajout seul.
+# Piège : la tentative est enregistrée même quand l'email est inconnu, sinon le 429 apprendrait
+# qu'un compte existe.
+
+from datetime import datetime
+
+from sqlalchemy import BigInteger, DateTime, Identity, Index, String, func
+from sqlalchemy.dialects.postgresql import INET
+from sqlalchemy.orm import Mapped, mapped_column
+
+from app.db.base import Base
+
+
+class PasswordResetAttempt(Base):
+    __tablename__ = "password_reset_attempt"
+    __table_args__ = (
+        Index("ix_password_reset_attempt_email_date", "email_tried", "occurred_at"),
+        Index("ix_password_reset_attempt_ip_date", "client_ip", "occurred_at"),
+    )
+
+    id: Mapped[int] = mapped_column(BigInteger, Identity(always=True), primary_key=True)
+    occurred_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+    email_tried: Mapped[str] = mapped_column(String(320), nullable=False)
+    client_ip: Mapped[str | None] = mapped_column(INET, nullable=True)
@@ -0,0 +1,40 @@
+# Pourquoi : même schéma que `refresh_token` (chaîne opaque, jamais un JWT) pour la même
+# raison : un jeton de réinitialisation doit être révocable d'un coup, et un JWT ne figure
+# dans aucune ligne à invalider.
+
+import uuid
+from datetime import datetime
+
+from sqlalchemy import DateTime, ForeignKey, Index, LargeBinary, Text, func
+from sqlalchemy.dialects.postgresql import INET
+from sqlalchemy.dialects.postgresql import UUID as PG_UUID
+from sqlalchemy.orm import Mapped, mapped_column
+
+from app.db.base import Base
+
+
+class PasswordResetToken(Base):
+    __tablename__ = "password_reset_token"
+    __table_args__ = (
+        Index("ix_password_reset_token_user", "user_id"),
+        Index(
+            "ix_password_reset_token_vivants",
+            "user_id",
+            postgresql_where="consumed_at is null",
+        ),
+    )
+
+    id: Mapped[uuid.UUID] = mapped_column(
+        PG_UUID(as_uuid=True), primary_key=True, server_default=func.gen_random_uuid()
+    )
+    user_id: Mapped[uuid.UUID] = mapped_column(
+        PG_UUID(as_uuid=True), ForeignKey("app_user.id", ondelete="CASCADE"), nullable=False
+    )
+    token_hash: Mapped[bytes] = mapped_column(LargeBinary, nullable=False, unique=True)
+    issued_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, server_default=func.now()
+    )
+    expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
+    consumed_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
+    client_ip: Mapped[str | None] = mapped_column(INET, nullable=True)
+    user_agent: Mapped[str | None] = mapped_column(Text, nullable=True)
@@ -0,0 +1,42 @@
+from dataclasses import dataclass
+from datetime import UTC, datetime, timedelta
+
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models.password_reset_attempt import PasswordResetAttempt
+
+
+@dataclass(frozen=True, slots=True)
+class ResetRequestCounts:
+    per_identifier: int
+    per_ip: int
+
+
+class PasswordResetAttemptRepository:
+    def __init__(self, session: AsyncSession) -> None:
+        self._session = session
+
+    async def record(self, *, email: str, client_ip: str | None) -> None:
+        self._session.add(
+            PasswordResetAttempt(email_tried=email.strip().lower(), client_ip=client_ip)
+        )
+
+    async def count_recent(
+        self, *, email: str, client_ip: str | None, window_seconds: int
+    ) -> ResetRequestCounts:
+        identifiant = email.strip().lower()
+        meme_email = PasswordResetAttempt.email_tried == identifiant
+        meme_ip = PasswordResetAttempt.client_ip == client_ip
+
+        requete = select(
+            func.count().filter(meme_email),
+            func.count().filter(meme_ip),
+        ).where(
+            PasswordResetAttempt.occurred_at
+            > datetime.now(UTC) - timedelta(seconds=window_seconds),
+            meme_email | meme_ip,
+        )
+
+        par_identifiant, par_ip = (await self._session.execute(requete)).one()
+        return ResetRequestCounts(per_identifier=par_identifiant, per_ip=par_ip)
@@ -0,0 +1,78 @@
+# Piège : `consume()` est une seule instruction, sur le modèle de `claim_for_rotation()` du
+# jeton de rafraîchissement. Un SELECT puis un UPDATE laisseraient une fenêtre où deux
+# soumissions concurrentes du même lien réussiraient toutes les deux.
+
+from dataclasses import dataclass
+from datetime import datetime
+from uuid import UUID
+
+from sqlalchemy import func, select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models.password_reset_token import PasswordResetToken
+
+
+@dataclass(frozen=True, slots=True)
+class ConsumedResetToken:
+    id: UUID
+    user_id: UUID
+
+
+class PasswordResetTokenRepository:
+    def __init__(self, session: AsyncSession) -> None:
+        self._session = session
+
+    async def create(
+        self,
+        *,
+        user_id: UUID,
+        token_hash: bytes,
+        expires_at: datetime,
+        client_ip: str | None,
+        user_agent: str | None,
+    ) -> PasswordResetToken:
+        jeton = PasswordResetToken(
+            user_id=user_id,
+            token_hash=token_hash,
+            expires_at=expires_at,
+            client_ip=client_ip,
+            user_agent=user_agent,
+        )
+        self._session.add(jeton)
+        await self._session.flush()
+        return jeton
+
+    async def consume(self, token_hash: bytes) -> ConsumedResetToken | None:
+        requete = (
+            update(PasswordResetToken)
+            .where(
+                PasswordResetToken.token_hash == token_hash,
+                PasswordResetToken.consumed_at.is_(None),
+                PasswordResetToken.expires_at > func.clock_timestamp(),
+            )
+            .values(consumed_at=func.clock_timestamp())
+            .returning(PasswordResetToken.id, PasswordResetToken.user_id)
+        )
+        ligne = (await self._session.execute(requete)).one_or_none()
+        if ligne is None:
+            return None
+        return ConsumedResetToken(id=ligne.id, user_id=ligne.user_id)
+
+    # Piège : simple SELECT, volontairement pas atomique avec la consommation. Sert seulement
+    # au feedback UX (jeton encore valide ?) ; `consume()` reste la seule source de vérité.
+    async def exists_valid(self, token_hash: bytes) -> bool:
+        requete = select(PasswordResetToken.id).where(
+            PasswordResetToken.token_hash == token_hash,
+            PasswordResetToken.consumed_at.is_(None),
+            PasswordResetToken.expires_at > func.clock_timestamp(),
+        )
+        return (await self._session.execute(requete)).first() is not None
+
+    async def invalidate_all_for_user(self, user_id: UUID) -> int:
+        resultat = await self._session.execute(
+            update(PasswordResetToken)
+            .where(PasswordResetToken.user_id == user_id, PasswordResetToken.consumed_at.is_(None))
+            .values(consumed_at=func.clock_timestamp())
+            .returning(PasswordResetToken.id)
+        )
+        return len(resultat.all())
@@ -1,17 +1,45 @@
 # Contrainte : le mot de passe est borné à 128 caractères. Sans plafond, une chaîne de dix
 # mégaoctets ferait travailler Argon2 gratuitement, à la charge du serveur.
+# Contrainte : `SPECIAL_CHARACTERS` doit rester identique à `password.validator.ts` côté
+# frontend. `\w`/`\d` divergent entre Python (Unicode) et JavaScript (ASCII) : une classe
+# explicite, plutôt qu'une négation, évite qu'un mot de passe soit accepté d'un côté et
+# rejeté de l'autre (ex. "Sécurité1", où "é" comptait comme "spécial" pour Python seul).

+import re
 from typing import Literal, Self
 from uuid import UUID

-from pydantic import BaseModel, ConfigDict, EmailStr, Field
+from pydantic import BaseModel, ConfigDict, EmailStr, Field, field_validator

 from app.core.principal import Principal
 from app.core.roles import AccountKind, Role

-PASSWORD_MIN_LENGTH = 12
+PASSWORD_MIN_LENGTH = 8
 PASSWORD_MAX_LENGTH = 128

+SPECIAL_CHARACTERS = "!@#$%^&*()-_=+[]{};:,.?"
+
+_MAJUSCULE = re.compile(r"[A-ZÀ-ÖØ-Þ]")
+_MINUSCULE = re.compile(r"[a-zà-öø-þ]")
+_CHIFFRE = re.compile(r"[0-9]")
+_SPECIAL = re.compile(r"[" + re.escape(SPECIAL_CHARACTERS) + r"]")
+
+
+def valide_complexite(mot_de_passe: str) -> str:
+    manquants = [
+        nom
+        for nom, motif in (
+            ("une majuscule", _MAJUSCULE),
+            ("une minuscule", _MINUSCULE),
+            ("un chiffre", _CHIFFRE),
+            ("un caractère spécial", _SPECIAL),
+        )
+        if not motif.search(mot_de_passe)
+    ]
+    if manquants:
+        raise ValueError(f"Le mot de passe doit contenir au moins {', '.join(manquants)}")
+    return mot_de_passe
+

 class LoginRequest(BaseModel):
    email: EmailStr
@@ -22,6 +50,25 @@ class PasswordChangeRequest(BaseModel):
    current_password: str = Field(min_length=1, max_length=PASSWORD_MAX_LENGTH)
    new_password: str = Field(min_length=PASSWORD_MIN_LENGTH, max_length=PASSWORD_MAX_LENGTH)

+    @field_validator("new_password")
+    @classmethod
+    def _new_password_est_complexe(cls, valeur: str) -> str:
+        return valide_complexite(valeur)
+
+
+class ForgotPasswordRequest(BaseModel):
+    email: EmailStr
+
+
+class ResetPasswordRequest(BaseModel):
+    token: str = Field(min_length=1)
+    new_password: str = Field(min_length=PASSWORD_MIN_LENGTH, max_length=PASSWORD_MAX_LENGTH)
+
+    @field_validator("new_password")
+    @classmethod
+    def _new_password_est_complexe(cls, valeur: str) -> str:
+        return valide_complexite(valeur)
+

 class PrincipalResponse(BaseModel):
    model_config = ConfigDict(from_attributes=True)
@@ -37,6 +84,10 @@ class PrincipalResponse(BaseModel):
        return cls.model_validate(principal)


+class ResetTokenValidationResponse(BaseModel):
+    valid: bool
+
+
 class TokenResponse(BaseModel):
    access_token: str
    token_type: Literal["bearer"] = "bearer"  # noqa: S105
@@ -14,7 +14,11 @@ from datetime import UTC, datetime, timedelta
 from typing import NoReturn, Protocol
 from uuid import UUID, uuid4

+from fastapi import BackgroundTasks
+
 from app.core.hashing import Argon2Hasher
+from app.core.logging import get_logger
+from app.core.mailer import Mailer
 from app.core.principal import Principal
 from app.core.roles import AccountKind, Role
 from app.core.security import (
@@ -28,9 +32,13 @@ from app.models.login_attempt import LoginOutcome
 from app.models.refresh_token import RevocationReason
 from app.repositories.audit_log import AuditLogRepository
 from app.repositories.login_attempt import LoginAttemptRepository
+from app.repositories.password_reset_attempt import PasswordResetAttemptRepository
+from app.repositories.password_reset_token import PasswordResetTokenRepository
 from app.repositories.refresh_token import RefreshTokenRepository
 from app.repositories.user import UserRepository

+logger = get_logger(__name__)
+

 class Transaction(Protocol):
    async def commit(self) -> None: ...
@@ -54,6 +62,10 @@ class RateLimitedError(AuthError):
        self.retry_after = retry_after


+class InvalidOrExpiredResetTokenError(AuthError):
+    pass
+
+
@dataclass(frozen=True, slots=True)
 class LoginPolicy:
    window_seconds: int
@@ -62,6 +74,15 @@ class LoginPolicy:
    max_failures_per_identifier: int


+@dataclass(frozen=True, slots=True)
+class PasswordResetPolicy:
+    window_seconds: int
+    max_requests_per_identifier: int
+    max_requests_per_ip: int
+    token_ttl: timedelta
+    frontend_reset_url: str
+
+
@dataclass(frozen=True, slots=True)
 class AuthenticatedSession:
    principal: Principal
@@ -83,6 +104,10 @@ class AuthService:
        token_policy: TokenPolicy,
        login_policy: LoginPolicy,
        refresh_ttl: timedelta,
+        reset_tokens: PasswordResetTokenRepository,
+        reset_attempts: PasswordResetAttemptRepository,
+        reset_policy: PasswordResetPolicy,
+        mailer: Mailer,
    ) -> None:
        self._users = users
        self._attempts = attempts
@@ -93,6 +118,10 @@ class AuthService:
        self._token_policy = token_policy
        self._login_policy = login_policy
        self._refresh_ttl = refresh_ttl
+        self._reset_tokens = reset_tokens
+        self._reset_attempts = reset_attempts
+        self._reset_policy = reset_policy
+        self._mailer = mailer

    async def authenticate(
        self, *, email: str, password: str, client_ip: str | None, user_agent: str | None
@@ -200,6 +229,102 @@ class AuthService:
        rafraichi = await self._users.get_by_id(principal.id)
        return self._session(self._en_principal(rafraichi or compte), secret)

+    async def request_password_reset(
+        self,
+        *,
+        email: str,
+        client_ip: str | None,
+        user_agent: str | None,
+        background_tasks: BackgroundTasks,
+    ) -> None:
+        await self._refuse_si_limite_reset(email=email, client_ip=client_ip)
+
+        compte = await self._users.get_by_email(email)
+        # Piège : le hachage factice équilibre le temps de réponse sur un compte inconnu, comme
+        # `authenticate()`. La réponse et sa forme restent identiques dans tous les cas : compte
+        # inconnu, compte inactif, ou email envoyé avec succès. L'envoi SMTP lui-même est différé
+        # en tâche de fond : le laisser dans le chemin de réponse rouvrirait le même oracle par le
+        # temps (aller-retour réseau) et par la forme (500 si le relais SMTP échoue, contre 202).
+        if compte is None or not compte.is_active or compte.kind != AccountKind.HUMAIN.value:
+            await self._hasher.verify_dummy()
+            await self._reset_attempts.record(email=email, client_ip=client_ip)
+            await self._transaction.commit()
+            return
+
+        await self._reset_tokens.invalidate_all_for_user(compte.id)
+        secret = generate_refresh_secret()
+        await self._reset_tokens.create(
+            user_id=compte.id,
+            token_hash=fingerprint_refresh(secret),
+            expires_at=datetime.now(UTC) + self._reset_policy.token_ttl,
+            client_ip=client_ip,
+            user_agent=user_agent,
+        )
+        await self._reset_attempts.record(email=email, client_ip=client_ip)
+        await self._audit.record(
+            action=AuditAction.MOT_DE_PASSE_OUBLIE_DEMANDE,
+            actor_label=compte.email,
+            target_type="app_user",
+            target_id=str(compte.id),
+            client_ip=client_ip,
+            user_agent=user_agent,
+        )
+        await self._transaction.commit()
+
+        lien = f"{self._reset_policy.frontend_reset_url}?token={secret}"
+        background_tasks.add_task(self._envoie_email_reset, compte.email, lien)
+
+    async def _envoie_email_reset(self, email: str, reset_url: str) -> None:
+        try:
+            await self._mailer.send_password_reset_email(to=email, reset_url=reset_url)
+        except Exception:
+            logger.exception("auth.password_reset.mail_failed")
+
+    # Piège : lecture seule, pas d'appel à `consume()`. Aucune limitation de débit n'est
+    # nécessaire ici : le jeton est un secret de 256 bits (`generate_refresh_secret`), donc
+    # non brute-forçable, et cette route n'apprend rien sur l'existence d'un compte ou d'un
+    # email, seulement si le lien déjà en main du visiteur est encore valide.
+    async def is_reset_token_valid(self, token: str) -> bool:
+        return await self._reset_tokens.exists_valid(fingerprint_refresh(token))
+
+    async def confirm_password_reset(
+        self, *, token: str, new_password: str, client_ip: str | None, user_agent: str | None
+    ) -> AuthenticatedSession:
+        revendique = await self._reset_tokens.consume(fingerprint_refresh(token))
+        if revendique is None:
+            raise InvalidOrExpiredResetTokenError("Lien invalide ou expiré")
+
+        # Piège : le jeton peut avoir été émis avant une désactivation du compte. Sans cette
+        # relecture, un lien encore valide (15 min) changerait quand même le mot de passe d'un
+        # compte désactivé, réutilisable dès sa réactivation.
+        compte = await self._users.get_by_id(revendique.user_id)
+        if compte is None or not compte.is_active or compte.kind != AccountKind.HUMAIN.value:
+            raise InvalidOrExpiredResetTokenError("Lien invalide ou expiré")
+
+        await self._users.update_password(
+            revendique.user_id, await self._hasher.hash(new_password), must_change_password=False
+        )
+        revoquees = await self._refresh.revoke_all_for_user(
+            revendique.user_id, RevocationReason.CHANGEMENT_MOT_DE_PASSE
+        )
+        secret = await self._ouvre_une_famille(
+            user_id=revendique.user_id, client_ip=client_ip, user_agent=user_agent
+        )
+        await self._audit.record(
+            action=AuditAction.MOT_DE_PASSE_REINITIALISE_PAR_SOI,
+            target_type="app_user",
+            target_id=str(revendique.user_id),
+            client_ip=client_ip,
+            user_agent=user_agent,
+            detail={"sessions_revoquees": revoquees},
+        )
+        await self._transaction.commit()
+
+        compte = await self._users.get_by_id(revendique.user_id)
+        if compte is None:
+            raise SessionRejectedError("Compte introuvable")
+        return self._session(self._en_principal(compte), secret)
+
    async def logout_all(self, principal: Principal) -> int:
        revoquees = await self._refresh.revoke_all_for_user(
            principal.id, RevocationReason.DECONNEXION
@@ -307,6 +432,23 @@ class AuthService:
        await self._transaction.commit()
        raise RateLimitedError(politique.window_seconds)

+    async def _refuse_si_limite_reset(self, *, email: str, client_ip: str | None) -> None:
+        politique = self._reset_policy
+        compteurs = await self._reset_attempts.count_recent(
+            email=email, client_ip=client_ip, window_seconds=politique.window_seconds
+        )
+
+        depasse = (
+            compteurs.per_identifier >= politique.max_requests_per_identifier
+            or compteurs.per_ip >= politique.max_requests_per_ip
+        )
+        if not depasse:
+            return
+
+        await self._reset_attempts.record(email=email, client_ip=client_ip)
+        await self._transaction.commit()
+        raise RateLimitedError(politique.window_seconds)
+
    async def _echoue(
        self,
        email: str,
@@ -424,6 +424,196 @@
        ]
      }
    },
+    "/api/v1/auth/forgot-password": {
+      "post": {
+        "tags": [
+          "auth"
+        ],
+        "summary": "Demande un lien de réinitialisation par email",
+        "operationId": "forgot_password_api_v1_auth_forgot_password_post",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/ForgotPasswordRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "202": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "500": {
+            "description": "Erreur interne. `correlation` identifie la trace côté serveur, qui n'est pas renvoyée au client.",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/InternalErrorResponse"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Corps invalide. Le détail nomme le champ fautif et le type d'erreur, jamais la valeur envoyée.",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ValidationErrorResponse"
+                }
+              }
+            }
+          },
+          "429": {
+            "description": "Trop de demandes sur cette fenêtre glissante.",
+            "headers": {
+              "Retry-After": {
+                "description": "Secondes à attendre avant une nouvelle tentative.",
+                "schema": {
+                  "type": "integer"
+                }
+              }
+            },
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/v1/auth/reset-password/validate": {
+      "get": {
+        "tags": [
+          "auth"
+        ],
+        "summary": "Vérifie sans le consommer si un lien de réinitialisation est encore valide",
+        "operationId": "validate_reset_token_api_v1_auth_reset_password_validate_get",
+        "parameters": [
+          {
+            "name": "token",
+            "in": "query",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "title": "Token"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ResetTokenValidationResponse"
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Erreur interne. `correlation` identifie la trace côté serveur, qui n'est pas renvoyée au client.",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/InternalErrorResponse"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Corps invalide. Le détail nomme le champ fautif et le type d'erreur, jamais la valeur envoyée.",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ValidationErrorResponse"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/v1/auth/reset-password": {
+      "post": {
+        "tags": [
+          "auth"
+        ],
+        "summary": "Choisit un nouveau mot de passe depuis un lien reçu par email",
+        "operationId": "reset_password_api_v1_auth_reset_password_post",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/ResetPasswordRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/TokenResponse"
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Erreur interne. `correlation` identifie la trace côté serveur, qui n'est pas renvoyée au client.",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/InternalErrorResponse"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Corps invalide. Le détail nomme le champ fautif et le type d'erreur, jamais la valeur envoyée.",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ValidationErrorResponse"
+                }
+              }
+            }
+          },
+          "403": {
+            "description": "Origine non autorisée (protection CSRF de `require_trusted_origin`).",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Lien invalide, déjà utilisé, ou expiré (durée de vie : 15 minutes).",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
    "/api/v1/users": {
      "get": {
        "tags": [
@@ -1587,6 +1777,20 @@
        ],
        "title": "FieldError"
      },
+      "ForgotPasswordRequest": {
+        "properties": {
+          "email": {
+            "type": "string",
+            "format": "email",
+            "title": "Email"
+          }
+        },
+        "type": "object",
+        "required": [
+          "email"
+        ],
+        "title": "ForgotPasswordRequest"
+      },
      "InternalErrorResponse": {
        "properties": {
          "detail": {
@@ -1666,7 +1870,7 @@
          "new_password": {
            "type": "string",
            "maxLength": 128,
-            "minLength": 12,
+            "minLength": 8,
            "title": "New Password"
          }
        },
@@ -1993,6 +2197,40 @@
        ],
        "title": "RecommendationResponse"
      },
+      "ResetPasswordRequest": {
+        "properties": {
+          "token": {
+            "type": "string",
+            "minLength": 1,
+            "title": "Token"
+          },
+          "new_password": {
+            "type": "string",
+            "maxLength": 128,
+            "minLength": 8,
+            "title": "New Password"
+          }
+        },
+        "type": "object",
+        "required": [
+          "token",
+          "new_password"
+        ],
+        "title": "ResetPasswordRequest"
+      },
+      "ResetTokenValidationResponse": {
+        "properties": {
+          "valid": {
+            "type": "boolean",
+            "title": "Valid"
+          }
+        },
+        "type": "object",
+        "required": [
+          "valid"
+        ],
+        "title": "ResetTokenValidationResponse"
+      },
      "Role": {
        "type": "string",
        "enum": [
@@ -16,6 +16,7 @@ dependencies = [
    "pyjwt>=2.10",
    "argon2-cffi>=23.1",
    "anyio>=4.0",
+    "aiosmtplib>=5.1.3",
    "pandas>=3.0.5",
 ]

@@ -11,6 +11,7 @@ from app.core.roles import AccountKind, Role
 from app.services.auth import (
    AuthenticatedSession,
    InvalidCredentialsError,
+    InvalidOrExpiredResetTokenError,
    RateLimitedError,
    SessionRejectedError,
 )
@@ -27,15 +28,27 @@ PRINCIPAL = Principal(


 class FauxService:
-    def __init__(self, erreur: Exception | None = None) -> None:
+    def __init__(self, erreur: Exception | None = None, *, jeton_valide: bool = True) -> None:
        self._erreur = erreur
+        self._jeton_valide = jeton_valide

    async def refresh(self, **_: object) -> AuthenticatedSession:
        return await self.authenticate()

+    async def is_reset_token_valid(self, **_: object) -> bool:
+        return self._jeton_valide
+
    async def logout(self, **_: object) -> None:
        return None

+    async def request_password_reset(self, **_: object) -> None:
+        if self._erreur is not None:
+            raise self._erreur
+        return None
+
+    async def confirm_password_reset(self, **_: object) -> AuthenticatedSession:
+        return await self.authenticate()
+
    async def authenticate(self, **_: object) -> AuthenticatedSession:
        if self._erreur is not None:
            raise self._erreur
@@ -206,3 +219,126 @@ async def test_a_cookie_bearing_route_accepts_a_request_without_origin(
    response = await client.post("/api/v1/auth/logout")

    assert response.status_code != 403
+
+
+async def test_forgot_password_answers_202_when_the_account_exists(
+    fake_auth_service: list[Exception | None], client: AsyncClient
+) -> None:
+    response = await client.post(
+        "/api/v1/auth/forgot-password", json={"email": "operateur@enervision.fr"}
+    )
+
+    assert response.status_code == 202
+    assert response.headers["cache-control"] == "no-store"
+
+
+async def test_forgot_password_answers_202_identically_when_the_account_is_unknown(
+    fake_auth_service: list[Exception | None], client: AsyncClient
+) -> None:
+    response = await client.post(
+        "/api/v1/auth/forgot-password", json={"email": "inconnu@enervision.fr"}
+    )
+
+    assert response.status_code == 202
+
+
+async def test_forgot_password_returns_429_with_a_retry_after_when_the_rate_limit_is_reached(
+    fake_auth_service: list[Exception | None], client: AsyncClient
+) -> None:
+    fake_auth_service[0] = RateLimitedError(900)
+
+    response = await client.post(
+        "/api/v1/auth/forgot-password", json={"email": "operateur@enervision.fr"}
+    )
+
+    assert response.status_code == 429
+    assert response.headers["retry-after"] == "900"
+
+
+async def test_forgot_password_rejects_a_malformed_email(
+    fake_auth_service: list[Exception | None], client: AsyncClient
+) -> None:
+    response = await client.post("/api/v1/auth/forgot-password", json={"email": "pas-un-email"})
+
+    assert response.status_code == 422
+
+
+@pytest.fixture
+def fake_auth_service_reset_validity(app: FastAPI) -> Iterator[list[bool]]:
+    programme = [True]
+    app.dependency_overrides[get_auth_service] = lambda: FauxService(jeton_valide=programme[0])
+    yield programme
+    app.dependency_overrides.pop(get_auth_service, None)
+
+
+async def test_validate_reset_token_reports_a_living_token(
+    fake_auth_service_reset_validity: list[bool], client: AsyncClient
+) -> None:
+    response = await client.get(
+        "/api/v1/auth/reset-password/validate", params={"token": "un-secret-opaque"}
+    )
+
+    assert response.status_code == 200
+    assert response.json() == {"valid": True}
+
+
+async def test_validate_reset_token_reports_an_invalid_or_expired_token(
+    fake_auth_service_reset_validity: list[bool], client: AsyncClient
+) -> None:
+    fake_auth_service_reset_validity[0] = False
+
+    response = await client.get(
+        "/api/v1/auth/reset-password/validate", params={"token": "un-secret-perime"}
+    )
+
+    assert response.status_code == 200
+    assert response.json() == {"valid": False}
+
+
+async def test_reset_password_returns_the_token_and_the_cookie_on_success(
+    fake_auth_service: list[Exception | None], client: AsyncClient
+) -> None:
+    response = await client.post(
+        "/api/v1/auth/reset-password",
+        json={"token": "un-secret-opaque", "new_password": "Un-nouveau-mot-de-passe1!"},
+    )
+
+    assert response.status_code == 200
+    assert response.cookies.get("ev_refresh") is not None
+    assert "refresh_secret" not in response.text
+
+
+async def test_reset_password_rejects_an_invalid_or_expired_token(
+    fake_auth_service: list[Exception | None], client: AsyncClient
+) -> None:
+    fake_auth_service[0] = InvalidOrExpiredResetTokenError("Lien invalide ou expiré")
+
+    response = await client.post(
+        "/api/v1/auth/reset-password",
+        json={"token": "un-secret-perime", "new_password": "Un-nouveau-mot-de-passe1!"},
+    )
+
+    assert response.status_code == 400
+
+
+async def test_reset_password_rejects_a_weak_password(
+    fake_auth_service: list[Exception | None], client: AsyncClient
+) -> None:
+    response = await client.post(
+        "/api/v1/auth/reset-password",
+        json={"token": "un-secret-opaque", "new_password": "trop-simple"},
+    )
+
+    assert response.status_code == 422
+
+
+async def test_reset_password_refuses_a_foreign_origin(
+    fake_auth_service: list[Exception | None], client: AsyncClient
+) -> None:
+    response = await client.post(
+        "/api/v1/auth/reset-password",
+        json={"token": "un-secret-opaque", "new_password": "Un-nouveau-mot-de-passe1!"},
+        headers={"Origin": "https://malveillant.example"},
+    )
+
+    assert response.status_code == 403
@@ -18,6 +18,13 @@ ROUTES_PUBLIQUES = frozenset(
        ("POST", "/api/v1/auth/login"),
        # Sans cookie, la déconnexion ne fait rien et répond 204 : elle est idempotente.
        ("POST", "/api/v1/auth/logout"),
+        ("POST", "/api/v1/auth/forgot-password"),
+        # Protégée par le jeton dans le corps de la requête, pas par un `Principal` : aucune
+        # authentification préalable ne s'applique, c'est la validité du jeton qui tranche.
+        ("POST", "/api/v1/auth/reset-password"),
+        # Même raison : lecture seule, protégée par le jeton passé en paramètre, pas par un
+        # `Principal`. Le jeton est un secret de 256 bits, non brute-forçable.
+        ("GET", "/api/v1/auth/reset-password/validate"),
        ("GET", "/metrics"),
    }
 )
@@ -0,0 +1,142 @@
+# Le premier test démontre l'atomicité de `consume()` : sur un double, deux soumissions
+# concurrentes du même lien réussiraient toutes les deux.
+
+import uuid
+from datetime import UTC, datetime, timedelta
+
+import pytest
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.roles import Role
+from app.core.security import fingerprint_refresh, generate_refresh_secret
+from app.repositories.password_reset_token import PasswordResetTokenRepository
+from app.repositories.user import UserRepository
+
+pytestmark = pytest.mark.integration
+
+DUREE = timedelta(minutes=15)
+
+
+async def un_compte(session: AsyncSession) -> uuid.UUID:
+    compte = await UserRepository(session).create(
+        email=f"reset-{uuid.uuid4().hex[:12]}@enervision.fr",
+        password_hash="$argon2id$x",
+        role=Role.LECTEUR,
+    )
+    return compte.id
+
+
+async def un_jeton(
+    depot: PasswordResetTokenRepository, user_id: uuid.UUID, *, duree: timedelta = DUREE
+) -> str:
+    secret = generate_refresh_secret()
+    await depot.create(
+        user_id=user_id,
+        token_hash=fingerprint_refresh(secret),
+        expires_at=datetime.now(UTC) + duree,
+        client_ip="203.0.113.10",
+        user_agent="pytest",
+    )
+    return secret
+
+
+async def test_consume_only_succeeds_once(session: AsyncSession) -> None:
+    depot = PasswordResetTokenRepository(session)
+    secret = await un_jeton(depot, await un_compte(session))
+
+    premier = await depot.consume(fingerprint_refresh(secret))
+    second = await depot.consume(fingerprint_refresh(secret))
+    await session.rollback()
+
+    assert premier is not None
+    assert second is None
+
+
+async def test_consume_refuses_an_expired_token(session: AsyncSession) -> None:
+    depot = PasswordResetTokenRepository(session)
+    secret = await un_jeton(depot, await un_compte(session), duree=-timedelta(minutes=1))
+
+    revendique = await depot.consume(fingerprint_refresh(secret))
+    await session.rollback()
+
+    assert revendique is None
+
+
+async def test_consume_returns_nothing_for_an_unknown_fingerprint(
+    session: AsyncSession,
+) -> None:
+    revendique = await PasswordResetTokenRepository(session).consume(
+        fingerprint_refresh(generate_refresh_secret())
+    )
+
+    assert revendique is None
+
+
+async def test_invalidate_all_for_user_only_touches_living_tokens(
+    session: AsyncSession,
+) -> None:
+    depot = PasswordResetTokenRepository(session)
+    compte = await un_compte(session)
+    await un_jeton(depot, compte)
+    await un_jeton(depot, compte)
+
+    invalides = await depot.invalidate_all_for_user(compte)
+    second_passage = await depot.invalidate_all_for_user(compte)
+    await session.rollback()
+
+    assert invalides == 2
+    assert second_passage == 0
+
+
+async def test_exists_valid_is_true_for_a_living_token(session: AsyncSession) -> None:
+    depot = PasswordResetTokenRepository(session)
+    secret = await un_jeton(depot, await un_compte(session))
+
+    assert await depot.exists_valid(fingerprint_refresh(secret)) is True
+
+
+async def test_exists_valid_is_false_for_an_expired_token(session: AsyncSession) -> None:
+    depot = PasswordResetTokenRepository(session)
+    secret = await un_jeton(depot, await un_compte(session), duree=-timedelta(minutes=1))
+
+    assert await depot.exists_valid(fingerprint_refresh(secret)) is False
+
+
+async def test_exists_valid_is_false_once_the_token_is_consumed(session: AsyncSession) -> None:
+    depot = PasswordResetTokenRepository(session)
+    secret = await un_jeton(depot, await un_compte(session))
+    await depot.consume(fingerprint_refresh(secret))
+
+    assert await depot.exists_valid(fingerprint_refresh(secret)) is False
+
+
+async def test_exists_valid_is_false_for_an_unknown_fingerprint(session: AsyncSession) -> None:
+    depot = PasswordResetTokenRepository(session)
+
+    assert await depot.exists_valid(fingerprint_refresh(generate_refresh_secret())) is False
+
+
+async def test_the_database_refuses_two_tokens_sharing_a_fingerprint(
+    session: AsyncSession,
+) -> None:
+    depot = PasswordResetTokenRepository(session)
+    compte = await un_compte(session)
+    secret = generate_refresh_secret()
+    await depot.create(
+        user_id=compte,
+        token_hash=fingerprint_refresh(secret),
+        expires_at=datetime.now(UTC) + DUREE,
+        client_ip=None,
+        user_agent=None,
+    )
+
+    with pytest.raises(IntegrityError):
+        await depot.create(
+            user_id=compte,
+            token_hash=fingerprint_refresh(secret),
+            expires_at=datetime.now(UTC) + DUREE,
+            client_ip=None,
+            user_agent=None,
+        )
+    await session.rollback()
@@ -0,0 +1,61 @@
+import pytest
+from pydantic import ValidationError
+
+from app.schemas.auth import PasswordChangeRequest, valide_complexite
+
+MOT_DE_PASSE_VALIDE = "Un-mot-de-passe1!"
+
+
+def test_password_change_request_accepts_a_password_covering_the_four_classes() -> None:
+    requete = PasswordChangeRequest(
+        current_password="peu-importe", new_password=MOT_DE_PASSE_VALIDE
+    )
+
+    assert requete.new_password == MOT_DE_PASSE_VALIDE
+
+
+@pytest.mark.parametrize(
+    "new_password",
+    [
+        "un-mot-de-passe1!",
+        "UN-MOT-DE-PASSE1!",
+        "Un-mot-de-passe!",
+        "Un mot de passe 1",
+    ],
+    ids=["sans_majuscule", "sans_minuscule", "sans_chiffre", "sans_caractere_special"],
+)
+def test_password_change_request_rejects_a_password_missing_a_character_class(
+    new_password: str,
+) -> None:
+    with pytest.raises(ValidationError):
+        PasswordChangeRequest(current_password="peu-importe", new_password=new_password)
+
+
+def test_password_change_request_rejects_a_password_below_the_minimum_length() -> None:
+    with pytest.raises(ValidationError):
+        PasswordChangeRequest(current_password="peu-importe", new_password="Ab1!")
+
+
+def test_valide_complexite_names_every_missing_class_in_the_error() -> None:
+    with pytest.raises(ValueError, match=r"majuscule.*chiffre|chiffre.*majuscule"):
+        valide_complexite("minuscules-seulement")
+
+
+def test_valide_complexite_accepts_an_accented_password() -> None:
+    assert valide_complexite("Sécurité1!") == "Sécurité1!"
+
+
+@pytest.mark.parametrize("mot_de_passe", ["abcdefg1×", "abcdefg1÷"])  # noqa: RUF001
+def test_valide_complexite_rejects_a_password_without_uppercase_despite_times_or_divide(
+    mot_de_passe: str,
+) -> None:
+    with pytest.raises(ValueError, match="majuscule"):
+        valide_complexite(mot_de_passe)
+
+
+@pytest.mark.parametrize("mot_de_passe", ["ABCDEFG1×", "ABCDEFG1÷"])  # noqa: RUF001
+def test_valide_complexite_rejects_a_password_without_lowercase_despite_times_or_divide(
+    mot_de_passe: str,
+) -> None:
+    with pytest.raises(ValueError, match="minuscule"):
+        valide_complexite(mot_de_passe)
@@ -5,6 +5,7 @@ from typing import Any
 from uuid import UUID, uuid4

 import pytest
+from fastapi import BackgroundTasks

 from app.core.principal import Principal
 from app.core.roles import AccountKind, Role
@@ -16,11 +17,15 @@ from app.core.security import (
 from app.models.login_attempt import LoginOutcome
 from app.models.refresh_token import RevocationReason
 from app.repositories.login_attempt import FailureCounts
+from app.repositories.password_reset_attempt import ResetRequestCounts
+from app.repositories.password_reset_token import ConsumedResetToken
 from app.repositories.refresh_token import ClaimedToken
 from app.services.auth import (
    AuthService,
    InvalidCredentialsError,
+    InvalidOrExpiredResetTokenError,
    LoginPolicy,
+    PasswordResetPolicy,
    RateLimitedError,
    SessionRejectedError,
 )
@@ -37,6 +42,13 @@ POLITIQUE_CONNEXION = LoginPolicy(
    max_failures_per_ip=20,
    max_failures_per_identifier=50,
 )
+POLITIQUE_RESET = PasswordResetPolicy(
+    window_seconds=900,
+    max_requests_per_identifier=3,
+    max_requests_per_ip=10,
+    token_ttl=timedelta(minutes=15),
+    frontend_reset_url="http://localhost:4200/reset-password",
+)


@dataclass
@@ -168,6 +180,49 @@ class FausseTransaction:
        self.validations += 1


+class FauxDepotJetonsReset:
+    def __init__(
+        self, revendique: ConsumedResetToken | None = None, *, valide: bool = False
+    ) -> None:
+        self.revendique = revendique
+        self.valide = valide
+        self.crees: list[UUID] = []
+        self.invalidations: list[UUID] = []
+
+    async def create(self, *, user_id: UUID, **_: object) -> None:
+        self.crees.append(user_id)
+
+    async def consume(self, token_hash: bytes) -> ConsumedResetToken | None:
+        return self.revendique
+
+    async def exists_valid(self, token_hash: bytes) -> bool:
+        return self.valide
+
+    async def invalidate_all_for_user(self, user_id: UUID) -> int:
+        self.invalidations.append(user_id)
+        return len(self.invalidations)
+
+
+class FauxDepotTentativesReset:
+    def __init__(self, compteurs: ResetRequestCounts | None = None) -> None:
+        self.compteurs = compteurs or ResetRequestCounts(0, 0)
+        self.enregistrees: list[str] = []
+
+    async def count_recent(self, **_: object) -> ResetRequestCounts:
+        return self.compteurs
+
+    async def record(self, *, email: str, **_: object) -> None:
+        self.enregistrees.append(email)
+
+
+class FauxMailer:
+    def __init__(self) -> None:
+        self.envois: list[tuple[str, str]] = []
+
+    async def send_password_reset_email(self, *, to: str, reset_url: str) -> None:
+        self.envois.append((to, reset_url))
+
+
@dataclass
 class Attirail:
    service: AuthService
@@ -176,6 +231,9 @@ class Attirail:
    jetons: FauxDepotJetons
    audit: FauxDepotAudit
    hacheur: FauxHacheur
+    jetons_reset: FauxDepotJetonsReset
+    tentatives_reset: FauxDepotTentativesReset
+    mailer: FauxMailer


 def fabrique_service(
@@ -184,12 +242,17 @@ def fabrique_service(
    compteurs: FailureCounts | None = None,
    hacheur: FauxHacheur | None = None,
    jetons: FauxDepotJetons | None = None,
+    jetons_reset: FauxDepotJetonsReset | None = None,
+    compteurs_reset: ResetRequestCounts | None = None,
 ) -> Attirail:
    comptes = FauxDepotComptes(compte)
    tentatives = FauxDepotTentatives(compteurs)
    depot_jetons = jetons or FauxDepotJetons()
    audit = FauxDepotAudit()
    hacheur = hacheur or FauxHacheur()
+    depot_jetons_reset = jetons_reset or FauxDepotJetonsReset()
+    tentatives_reset = FauxDepotTentativesReset(compteurs_reset)
+    mailer = FauxMailer()
    service = AuthService(
        users=comptes,  # type: ignore[arg-type]
        attempts=tentatives,  # type: ignore[arg-type]
@@ -200,8 +263,22 @@ def fabrique_service(
        token_policy=POLITIQUE_JETON,
        login_policy=POLITIQUE_CONNEXION,
        refresh_ttl=timedelta(days=7),
+        reset_tokens=depot_jetons_reset,  # type: ignore[arg-type]
+        reset_attempts=tentatives_reset,  # type: ignore[arg-type]
+        reset_policy=POLITIQUE_RESET,
+        mailer=mailer,  # type: ignore[arg-type]
+    )
+    return Attirail(
+        service,
+        comptes,
+        tentatives,
+        depot_jetons,
+        audit,
+        hacheur,
+        depot_jetons_reset,
+        tentatives_reset,
+        mailer,
    )
-    return Attirail(service, comptes, tentatives, depot_jetons, audit, hacheur)


 async def connecte(service: AuthService, mot_de_passe: str = "un-mot-de-passe-valide") -> object:
@@ -493,3 +570,148 @@ async def test_change_password_refuses_a_wrong_current_password() -> None:

    assert attirail.jetons.revocations_par_compte == []
    assert attirail.jetons.crees == []
+
+
+async def test_request_password_reset_emails_a_link_when_the_account_exists() -> None:
+    compte = FauxCompte()
+    attirail = fabrique_service(compte=compte)
+    taches = BackgroundTasks()
+
+    await attirail.service.request_password_reset(
+        email=compte.email, client_ip="203.0.113.10", user_agent="pytest", background_tasks=taches
+    )
+
+    assert attirail.jetons_reset.invalidations == [compte.id]
+    assert attirail.jetons_reset.crees == [compte.id]
+    assert attirail.mailer.envois == [], "l'envoi doit être différé, pas fait dans la réponse"
+    await taches()
+    assert len(attirail.mailer.envois) == 1
+    assert attirail.mailer.envois[0][0] == compte.email
+    assert "auth.password_reset_requested" in attirail.audit.lignes[0][0]
+
+
+async def test_request_password_reset_stays_silent_when_the_account_is_unknown() -> None:
+    attirail = fabrique_service(compte=None)
+    taches = BackgroundTasks()
+
+    await attirail.service.request_password_reset(
+        email="inconnu@enervision.fr",
+        client_ip="203.0.113.10",
+        user_agent="pytest",
+        background_tasks=taches,
+    )
+    await taches()
+
+    assert attirail.jetons_reset.crees == []
+    assert attirail.mailer.envois == []
+    assert attirail.hacheur.verifications == 1, "le hachage factice doit tout de même tourner"
+
+
+async def test_request_password_reset_stays_silent_when_the_account_is_inactive() -> None:
+    compte = FauxCompte(is_active=False)
+    attirail = fabrique_service(compte=compte)
+    taches = BackgroundTasks()
+
+    await attirail.service.request_password_reset(
+        email=compte.email, client_ip="203.0.113.10", user_agent="pytest", background_tasks=taches
+    )
+    await taches()
+
+    assert attirail.jetons_reset.crees == []
+    assert attirail.mailer.envois == []
+
+
+async def test_request_password_reset_raises_when_the_rate_limit_is_reached() -> None:
+    attirail = fabrique_service(compteurs_reset=ResetRequestCounts(per_identifier=3, per_ip=0))
+    taches = BackgroundTasks()
+
+    with pytest.raises(RateLimitedError):
+        await attirail.service.request_password_reset(
+            email="operateur@enervision.fr",
+            client_ip="203.0.113.10",
+            user_agent="pytest",
+            background_tasks=taches,
+        )
+
+    await taches()
+    assert attirail.mailer.envois == []
+
+
+async def test_request_password_reset_logs_instead_of_raising_when_the_mailer_fails() -> None:
+    compte = FauxCompte()
+    attirail = fabrique_service(compte=compte)
+    taches = BackgroundTasks()
+
+    async def echoue(*, to: str, reset_url: str) -> None:
+        raise RuntimeError("relais SMTP indisponible")
+
+    attirail.mailer.send_password_reset_email = echoue  # type: ignore[method-assign]
+
+    await attirail.service.request_password_reset(
+        email=compte.email, client_ip="203.0.113.10", user_agent="pytest", background_tasks=taches
+    )
+
+    await taches()
+
+
+async def test_confirm_password_reset_revokes_every_session_then_reopens_the_current_one() -> None:
+    compte = FauxCompte()
+    jetons_reset = FauxDepotJetonsReset(
+        revendique=ConsumedResetToken(id=uuid4(), user_id=compte.id)
+    )
+    attirail = fabrique_service(compte=compte, jetons_reset=jetons_reset)
+
+    session = await attirail.service.confirm_password_reset(
+        token="un-secret-opaque",
+        new_password="Un-nouveau-mot-de-passe1!",
+        client_ip="203.0.113.10",
+        user_agent="pytest",
+    )
+
+    assert attirail.jetons.revocations_par_compte == [
+        (compte.id, RevocationReason.CHANGEMENT_MOT_DE_PASSE.value)
+    ]
+    assert len(attirail.jetons.crees) == 1
+    assert session.refresh_secret
+    assert "auth.password_reset_self_service" in attirail.audit.lignes[0][0]
+
+
+async def test_is_reset_token_valid_reflects_the_repository() -> None:
+    attirail_valide = fabrique_service(jetons_reset=FauxDepotJetonsReset(valide=True))
+    attirail_invalide = fabrique_service(jetons_reset=FauxDepotJetonsReset(valide=False))
+
+    assert await attirail_valide.service.is_reset_token_valid("un-secret-opaque") is True
+    assert await attirail_invalide.service.is_reset_token_valid("un-secret-opaque") is False
+
+
+async def test_confirm_password_reset_rejects_a_token_for_an_account_disabled_since() -> None:
+    compte = FauxCompte(is_active=False)
+    jetons_reset = FauxDepotJetonsReset(
+        revendique=ConsumedResetToken(id=uuid4(), user_id=compte.id)
+    )
+    attirail = fabrique_service(compte=compte, jetons_reset=jetons_reset)
+
+    with pytest.raises(InvalidOrExpiredResetTokenError):
+        await attirail.service.confirm_password_reset(
+            token="un-secret-opaque",
+            new_password="Un-nouveau-mot-de-passe1!",
+            client_ip="203.0.113.10",
+            user_agent="pytest",
+        )
+
+    assert attirail.comptes.mots_de_passe_changes == 0
+    assert attirail.jetons.revocations_par_compte == []
+
+
+async def test_confirm_password_reset_rejects_an_invalid_or_expired_token() -> None:
+    attirail = fabrique_service(jetons_reset=FauxDepotJetonsReset(revendique=None))
+
+    with pytest.raises(InvalidOrExpiredResetTokenError):
+        await attirail.service.confirm_password_reset(
+            token="un-secret-invalide",
+            new_password="Un-nouveau-mot-de-passe1!",
+            client_ip=None,
+            user_agent=None,
+        )
+
+    assert attirail.jetons.revocations_par_compte == []
@@ -4,6 +4,7 @@ from pathlib import Path
 import pytest

 from app import cli
+from app.schemas.auth import valide_complexite


 def test_build_parser_reads_the_create_admin_arguments() -> None:
@@ -34,26 +35,36 @@ def test_read_password_generates_a_long_secret_when_asked(

    assert len(mot_de_passe) >= cli.LONGUEUR_MOT_DE_PASSE_GENERE
    assert mot_de_passe in capsys.readouterr().out
+    valide_complexite(mot_de_passe)


 def test_read_password_accepts_two_matching_entries(monkeypatch: pytest.MonkeyPatch) -> None:
-    saisies = iter(["un-mot-de-passe-valide", "un-mot-de-passe-valide"])
+    saisies = iter(["Un-mot-de-passe-valide1", "Un-mot-de-passe-valide1"])
    monkeypatch.setattr(cli, "getpass", lambda _: next(saisies))

-    assert cli.read_password(generate=False) == "un-mot-de-passe-valide"
+    assert cli.read_password(generate=False) == "Un-mot-de-passe-valide1"


 def test_read_password_refuses_a_password_below_the_minimum_length(
    monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    monkeypatch.setattr(cli, "getpass", lambda _: "court")
+    monkeypatch.setattr(cli, "getpass", lambda _: "Court1!")
+
+    with pytest.raises(SystemExit):
+        cli.read_password(generate=False)
+
+
+def test_read_password_refuses_a_password_missing_a_character_class(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(cli, "getpass", lambda _: "un-mot-de-passe-sans-majuscule-ni-chiffre")

    with pytest.raises(SystemExit):
        cli.read_password(generate=False)


 def test_read_password_refuses_two_different_entries(monkeypatch: pytest.MonkeyPatch) -> None:
-    saisies = iter(["un-mot-de-passe-valide", "un-autre-mot-de-passe"])
+    saisies = iter(["Un-mot-de-passe-valide1", "Un-autre-mot-de-passe2"])
    monkeypatch.setattr(cli, "getpass", lambda _: next(saisies))

    with pytest.raises(SystemExit):
@@ -7,6 +7,15 @@ resolution-markers = [
    "sys_platform != 'emscripten' and sys_platform != 'win32'",
 ]

+[[package]]
+name = "aiosmtplib"
+version = "5.1.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9b/5c/9cabc5db6d607616e81ba6d8f1f231cd5a75955807a308c1090a59072d6d/aiosmtplib-5.1.3.tar.gz", hash = "sha256:ac2b418d3260ba62d9cfd0fe7359726e9dc009a4e8e8d9909fdfae332f522a7c", size = 77010, upload-time = "2026-09-08T02:11:20.532Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9c/0a/b56ab8163d54960337fdca475d3dfd56c8badf6172e79cf2ad00d5335dc1/aiosmtplib-5.1.3-py3-none-any.whl", hash = "sha256:f7d76ce3d4995a65a178c1f11e1bd1607706b921d00cb768e7a2c7f7ef5517a8", size = 30116, upload-time = "2026-09-08T02:11:19.352Z" },
+]
+
 [[package]]
 name = "alembic"
 version = "1.20.0"
@@ -311,6 +320,7 @@ name = "enervision-backend"
 version = "0.1.0"
 source = { editable = "." }
 dependencies = [
+    { name = "aiosmtplib" },
    { name = "alembic" },
    { name = "anyio" },
    { name = "argon2-cffi" },
@@ -339,6 +349,7 @@ dev = [

 [package.metadata]
 requires-dist = [
+    { name = "aiosmtplib", specifier = ">=5.1.3" },
    { name = "alembic", specifier = ">=1.20.0" },
    { name = "anyio", specifier = ">=4.0" },
    { name = "argon2-cffi", specifier = ">=23.1" },
@@ -5,6 +5,8 @@ export const routes: Routes = [
  { path: '', redirectTo: 'dashboard', pathMatch: 'full' },
  { path: 'login', loadComponent: () => import('./features/auth/login/login').then(m => m.Login) },
  { path: 'change-password', loadComponent: () => import('./features/auth/change-password/change-password').then(m => m.ChangePassword) },
+  { path: 'forgot-password', loadComponent: () => import('./features/auth/forgot-password/forgot-password').then(m => m.ForgotPassword) },
+  { path: 'reset-password', loadComponent: () => import('./features/auth/reset-password/reset-password').then(m => m.ResetPassword) },
  {
    path: 'dashboard',
    canActivate: [authGuard],
@@ -41,7 +41,10 @@ describe('authInterceptor', () => {
    httpMock = TestBed.inject(HttpTestingController);
  });

-  afterEach(() => httpMock.verify());
+  afterEach(() => {
+    httpMock.verify();
+    vi.restoreAllMocks();
+  });

  it('ajoute le header Authorization quand un token est disponible', () => {
    http.get('/api/v1/stats/summary').subscribe();
@@ -97,6 +100,19 @@ describe('authInterceptor', () => {
    expect(routerMock.navigate).toHaveBeenCalledWith(['/login']);
  });

+  it("ne redirige pas vers /login sur un 401 de /auth/refresh si on est déjà sur /reset-password", () => {
+    vi.spyOn(window, 'location', 'get').mockReturnValue({
+      pathname: '/reset-password',
+    } as Location);
+
+    http.post('/api/v1/auth/refresh', {}).subscribe({ error: () => {} });
+    const req = httpMock.expectOne('/api/v1/auth/refresh');
+    req.flush({}, { status: 401, statusText: 'Unauthorized' });
+
+    expect(authMock.clearSession).toHaveBeenCalled();
+    expect(routerMock.navigate).not.toHaveBeenCalled();
+  });
+
  it('rafraîchit puis rejoue la requête sur un 401 avec error="expired"', () => {
    authMock.refreshShared.mockReturnValue(of({ access_token: 'new-token' }));
    authMock.getAccessToken.mockReturnValueOnce('old-token').mockReturnValue('new-token');
@@ -11,6 +11,16 @@ function parseAuthError(response: HttpErrorResponse): string | null {
  return match ? match[1] : null;
 }

+const ROUTES_INVITEES = ['/login', '/forgot-password', '/reset-password'];
+
+// Piège : le rafraîchissement de session lancé au démarrage de l'app (provideAppInitializer)
+// échoue silencieusement sans cookie valide. `window.location.pathname` (pas `router.url`,
+// pas encore fiable à ce stade) évite qu'un 401 de fond écrase la navigation vers le lien de
+// reset reçu par email.
+function surRouteInvitee(): boolean {
+  return ROUTES_INVITEES.some((chemin) => window.location.pathname.startsWith(chemin));
+}
+
 export const authInterceptor: HttpInterceptorFn = (req, next) => {
  const auth = inject(AuthService);
  const router = inject(Router);
@@ -43,7 +53,9 @@ export const authInterceptor: HttpInterceptorFn = (req, next) => {

      if (req.url.endsWith('/auth/refresh')) {
        auth.clearSession();
-        router.navigate(['/login']);
+        if (!surRouteInvitee()) {
+          router.navigate(['/login']);
+        }
        return throwError(() => error);
      }

@@ -51,7 +63,9 @@ export const authInterceptor: HttpInterceptorFn = (req, next) => {

      if (kind === 'invalid_token') {
        auth.clearSession();
-        router.navigate(['/login']);
+        if (!surRouteInvitee()) {
+          router.navigate(['/login']);
+        }
        return throwError(() => error);
      }

@@ -65,7 +79,9 @@ export const authInterceptor: HttpInterceptorFn = (req, next) => {
          }),
          catchError((refreshError) => {
            auth.clearSession();
-            router.navigate(['/login']);
+            if (!surRouteInvitee()) {
+              router.navigate(['/login']);
+            }
            return throwError(() => refreshError);
          })
        );
@@ -83,4 +83,17 @@ describe('AuthService', () => {

  expect(result).toEqual(tokenResponse.principal);
 });
+
+  it('vérifie la validité du jeton de reset via GET /auth/reset-password/validate', () => {
+    let result: { valid: boolean } | undefined;
+    service.validateResetToken('un-secret-opaque').subscribe((r) => (result = r));
+
+    const req = httpMock.expectOne(
+      `${environment.apiUrl}/auth/reset-password/validate?token=un-secret-opaque`
+    );
+    expect(req.request.method).toBe('GET');
+    req.flush({ valid: true });
+
+    expect(result).toEqual({ valid: true });
+  });
 });
@@ -1,7 +1,14 @@
 import { Service, signal, computed, inject } from '@angular/core';
 import { HttpClient } from '@angular/common/http';
 import { Observable, tap, finalize, shareReplay } from 'rxjs';
-import { LoginRequest, PasswordChangeRequest, Principal, TokenResponse } from '../../shared/models/auth.model';
+import {
+  ForgotPasswordRequest,
+  LoginRequest,
+  PasswordChangeRequest,
+  Principal,
+  ResetPasswordRequest,
+  TokenResponse,
+} from '../../shared/models/auth.model';
 import { environment } from '../../../environments/environment';

@Service()
@@ -66,4 +73,20 @@ export class AuthService {
  me(): Observable<Principal> {
    return this.http.get<Principal>(`${environment.apiUrl}/auth/me`);
  }
+
+  forgotPassword(payload: ForgotPasswordRequest): Observable<void> {
+    return this.http.post<void>(`${environment.apiUrl}/auth/forgot-password`, payload);
+  }
+
+  resetPassword(payload: ResetPasswordRequest): Observable<TokenResponse> {
+    return this.http
+      .post<TokenResponse>(`${environment.apiUrl}/auth/reset-password`, payload, { withCredentials: true })
+      .pipe(tap((response) => this.setSession(response)));
+  }
+
+  validateResetToken(token: string): Observable<{ valid: boolean }> {
+    return this.http.get<{ valid: boolean }>(`${environment.apiUrl}/auth/reset-password/validate`, {
+      params: { token },
+    });
+  }
 }
@@ -18,7 +18,7 @@
      formControlName="new_password"
      autocomplete="new-password"
    />
-    <span class="auth-hint">12 à 128 caractères</span>
+    <span class="auth-hint">{{ passwordHint }}</span>

    @if (errorMessage()) {
      <p class="auth-error">{{ errorMessage() }}</p>
@@ -32,10 +32,19 @@ describe('ChangePassword', () => {
    expect(authMock.changePassword).not.toHaveBeenCalled();
  });

+  it('ne soumet pas si le mot de passe ne couvre pas les 4 classes de caractères', () => {
+    const fixture = TestBed.createComponent(ChangePassword);
+    const component = fixture.componentInstance;
+    component.form.setValue({ current_password: 'old', new_password: 'longueur-suffisante-sans-majuscule-ni-chiffre' });
+
+    component.onSubmit();
+    expect(authMock.changePassword).not.toHaveBeenCalled();
+  });
+
  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: 'un-nouveau-mot-de-passe-valide' });
+    component.form.setValue({ current_password: 'ancien-mot-de-passe', new_password: 'Un-nouveau-mot-de-passe1!' });

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

@@ -46,7 +55,7 @@ describe('ChangePassword', () => {
  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-passe-valide' });
+  component.form.setValue({ current_password: 'mauvais-mot-de-passe', new_password: 'Un-nouveau-mot-de-passe1!' });

  authMock.changePassword.mockReturnValue(throwError(() => new Error('401')));

@@ -70,7 +79,7 @@ describe('ChangePassword', () => {
  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: 'un-nouveau-mot-de-passe-valide' });
+  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' } }));
@@ -81,7 +90,7 @@ describe('ChangePassword', () => {

  expect(authMock.changePassword).toHaveBeenCalledWith({
    current_password: 'ancien-mot-de-passe',
-    new_password: 'un-nouveau-mot-de-passe-valide',
+    new_password: 'Un-nouveau-mot-de-passe1!',
  });
 });

@@ -2,6 +2,7 @@ import { Component, inject, signal } from '@angular/core';
 import { ReactiveFormsModule, FormBuilder, Validators } from '@angular/forms';
 import { Router } from '@angular/router';
 import { AuthService } from '../../../core/services/auth.service';
+import { passwordValidators, PASSWORD_HINT } from '../../../shared/validators/password.validator';

@Component({
  selector: 'app-change-password',
@@ -17,10 +18,11 @@ export class ChangePassword {

  errorMessage = signal<string | null>(null);
  isLoading = signal(false);
+  passwordHint = PASSWORD_HINT;

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

  onSubmit(): void {
@@ -34,7 +36,7 @@ export class ChangePassword {
      },
      error: () => {
        this.isLoading.set(false);
-        this.errorMessage.set('Mot de passe actuel incorrect, ou nouveau mot de passe invalide (12 à 128 caractères).');
+        this.errorMessage.set(`Mot de passe actuel incorrect, ou nouveau mot de passe invalide (${this.passwordHint}).`);
      },
    });
  }
@@ -0,0 +1,37 @@
+<div class="auth-page">
+  <form class="auth-card" [formGroup]="form" (ngSubmit)="onSubmit()">
+    <h1>Mot de passe oublié</h1>
+    <p class="auth-subtitle">Recevez un lien de réinitialisation par email</p>
+
+    @if (submitted()) {
+      <p class="auth-success">
+        Si un compte existe pour cet email, un lien de réinitialisation vient d'être envoyé.
+        Il expire dans 15 minutes.
+      </p>
+    } @else {
+      <label for="email">Email</label>
+      <input
+        id="email"
+        type="email"
+        formControlName="email"
+        autocomplete="username"
+        placeholder="vous@enervision.fr"
+      />
+
+      @if (errorMessage()) {
+        <p class="auth-error">
+          {{ errorMessage() }}
+          @if (retryAfterSeconds(); as seconds) {
+            (réessayez dans {{ seconds }}s)
+          }
+        </p>
+      }
+
+      <button type="submit" [disabled]="form.invalid || isLoading()">
+        {{ isLoading() ? 'Envoi...' : 'Envoyer le lien' }}
+      </button>
+    }
+
+    <p class="auth-link"><a routerLink="/login">Retour à la connexion</a></p>
+  </form>
+</div>
@@ -0,0 +1,104 @@
+:host {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  min-height: 100vh;
+  background: #f3f4f6;
+  font-family: 'Segoe UI', system-ui, sans-serif;
+}
+
+.auth-card {
+  background: #ffffff;
+  border: 1px solid #e5e7eb;
+  border-radius: 12px;
+  padding: 2.5rem;
+  width: 100%;
+  max-width: 360px;
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.06);
+  display: flex;
+  flex-direction: column;
+
+  h1 {
+    margin: 0;
+    font-size: 1.5rem;
+    font-weight: 700;
+    color: #1f2937;
+  }
+
+  .auth-subtitle {
+    margin: 0.25rem 0 1.5rem;
+    color: #6b7280;
+    font-size: 0.9rem;
+    line-height: 1.4;
+  }
+
+  label {
+    font-size: 0.85rem;
+    font-weight: 600;
+    color: #374151;
+    margin-bottom: 0.35rem;
+    margin-top: 1rem;
+  }
+
+  input {
+    padding: 0.6rem 0.75rem;
+    border: 1px solid #d1d5db;
+    border-radius: 8px;
+    font-size: 0.95rem;
+
+    &:focus {
+      outline: none;
+      border-color: #3b82f6;
+      box-shadow: 0 0 0 3px rgba(59, 130, 246, 0.15);
+    }
+  }
+
+  button {
+    margin-top: 1.5rem;
+    padding: 0.7rem;
+    background: #3b82f6;
+    color: #fff;
+    border: none;
+    border-radius: 8px;
+    font-size: 0.95rem;
+    font-weight: 600;
+    cursor: pointer;
+
+    &:disabled {
+      background: #9ca3af;
+      cursor: not-allowed;
+    }
+
+    &:not(:disabled):hover {
+      background: #2563eb;
+    }
+  }
+}
+
+.auth-hint {
+  font-size: 0.75rem;
+  color: #9ca3af;
+  margin-top: 0.25rem;
+}
+
+.auth-error {
+  margin: 0.75rem 0 0;
+  color: #dc2626;
+  font-size: 0.85rem;
+}
+
+.auth-success {
+  margin: 0.75rem 0 0;
+  color: #16a34a;
+  font-size: 0.85rem;
+}
+
+.auth-link {
+  margin-top: 1rem;
+  font-size: 0.85rem;
+  text-align: center;
+
+  a {
+    color: #3b82f6;
+  }
+}
@@ -0,0 +1,75 @@
+import { TestBed } from '@angular/core/testing';
+import { ReactiveFormsModule } from '@angular/forms';
+import { ActivatedRoute, Router } from '@angular/router';
+import { HttpErrorResponse, HttpHeaders } from '@angular/common/http';
+import { of, throwError } from 'rxjs';
+import { vi } from 'vitest';
+import { ForgotPassword } from './forgot-password';
+import { AuthService } from '../../../core/services/auth.service';
+
+describe('ForgotPassword', () => {
+  let authMock: { forgotPassword: ReturnType<typeof vi.fn> };
+  let routerMock: { navigate: ReturnType<typeof vi.fn> };
+
+  beforeEach(async () => {
+    authMock = { forgotPassword: vi.fn() };
+    routerMock = { navigate: vi.fn() };
+
+    await TestBed.configureTestingModule({
+      imports: [ForgotPassword, ReactiveFormsModule],
+      providers: [
+        { provide: AuthService, useValue: authMock },
+        { provide: Router, useValue: routerMock },
+        { provide: ActivatedRoute, useValue: {} },
+      ],
+    }).compileComponents();
+  });
+
+  it('ne soumet pas si le formulaire est invalide', () => {
+    const fixture = TestBed.createComponent(ForgotPassword);
+    fixture.componentInstance.onSubmit();
+    expect(authMock.forgotPassword).not.toHaveBeenCalled();
+  });
+
+  it('affiche le message générique après une soumission réussie', () => {
+    const fixture = TestBed.createComponent(ForgotPassword);
+    const component = fixture.componentInstance;
+    component.form.setValue({ email: 'operateur@enervision.fr' });
+    authMock.forgotPassword.mockReturnValue(of(undefined));
+
+    component.onSubmit();
+
+    expect(component.submitted()).toBe(true);
+  });
+
+  it('affiche le même message générique même quand le serveur répond une erreur autre que 429', () => {
+    const fixture = TestBed.createComponent(ForgotPassword);
+    const component = fixture.componentInstance;
+    component.form.setValue({ email: 'inconnu@enervision.fr' });
+    authMock.forgotPassword.mockReturnValue(throwError(() => new HttpErrorResponse({ status: 500 })));
+
+    component.onSubmit();
+
+    expect(component.submitted()).toBe(true);
+  });
+
+  it('affiche le délai à respecter quand le taux limite est atteint', () => {
+    const fixture = TestBed.createComponent(ForgotPassword);
+    const component = fixture.componentInstance;
+    component.form.setValue({ email: 'operateur@enervision.fr' });
+    authMock.forgotPassword.mockReturnValue(
+      throwError(
+        () =>
+          new HttpErrorResponse({
+            status: 429,
+            headers: new HttpHeaders({ 'Retry-After': '900' }),
+          })
+      )
+    );
+
+    component.onSubmit();
+
+    expect(component.submitted()).toBe(false);
+    expect(component.retryAfterSeconds()).toBe(900);
+  });
+});
@@ -0,0 +1,53 @@
+import { Component, inject, signal } from '@angular/core';
+import { ReactiveFormsModule, FormBuilder, Validators } from '@angular/forms';
+import { RouterLink } from '@angular/router';
+import { HttpErrorResponse } from '@angular/common/http';
+import { AuthService } from '../../../core/services/auth.service';
+
+@Component({
+  selector: 'app-forgot-password',
+  standalone: true,
+  imports: [ReactiveFormsModule, RouterLink],
+  templateUrl: './forgot-password.html',
+  styleUrl: './forgot-password.scss',
+})
+export class ForgotPassword {
+  private fb = inject(FormBuilder);
+  private auth = inject(AuthService);
+
+  errorMessage = signal<string | null>(null);
+  retryAfterSeconds = signal<number | null>(null);
+  submitted = signal(false);
+  isLoading = signal(false);
+
+  form = this.fb.nonNullable.group({
+    email: ['', [Validators.required, Validators.email]],
+  });
+
+  onSubmit(): void {
+    if (this.form.invalid) return;
+
+    this.isLoading.set(true);
+    this.errorMessage.set(null);
+    this.retryAfterSeconds.set(null);
+
+    this.auth.forgotPassword(this.form.getRawValue()).subscribe({
+      // Le message affiché ne dépend jamais du fait que le compte existe ou non : la réponse
+      // du serveur est déjà générique, l'écran doit l'être aussi.
+      next: () => {
+        this.isLoading.set(false);
+        this.submitted.set(true);
+      },
+      error: (error: HttpErrorResponse) => {
+        this.isLoading.set(false);
+        if (error.status === 429) {
+          const retryAfter = error.headers.get('Retry-After');
+          this.retryAfterSeconds.set(retryAfter ? Number(retryAfter) : null);
+          this.errorMessage.set('Trop de demandes, réessayez plus tard.');
+          return;
+        }
+        this.submitted.set(true);
+      },
+    });
+  }
+}
@@ -32,5 +32,7 @@
    <button type="submit" [disabled]="form.invalid || isLoading()">
      {{ isLoading() ? 'Connexion...' : 'Se connecter' }}
    </button>
+
+    <p class="auth-link"><a routerLink="/forgot-password">Mot de passe oublié ?</a></p>
  </form>
 </div>
@@ -79,3 +79,13 @@
  color: #dc2626;
  font-size: 0.85rem;
 }
+
+.auth-link {
+  margin-top: 1rem;
+  font-size: 0.85rem;
+  text-align: center;
+
+  a {
+    color: #3b82f6;
+  }
+}
@@ -1,27 +1,43 @@
 import { TestBed } from '@angular/core/testing';
 import { ReactiveFormsModule } from '@angular/forms';
-import { Router } from '@angular/router';
+import { ActivatedRoute, convertToParamMap, Router } from '@angular/router';
 import { HttpErrorResponse, HttpHeaders } from '@angular/common/http';
 import { of, throwError } from 'rxjs';
 import { vi } from 'vitest';
 import { Login } from './login';
 import { AuthService } from '../../../core/services/auth.service';
+import { MOTIF_LIEN_RESET_INVALIDE } from '../../../shared/models/auth-redirect-reason';
+
+function configure(queryParams: Record<string, string> = {}) {
+  const authMock = { login: vi.fn() };
+  const routerMock = { navigate: vi.fn() };
+
+  return {
+    authMock,
+    routerMock,
+    testBed: TestBed.configureTestingModule({
+      imports: [Login, ReactiveFormsModule],
+      providers: [
+        { provide: AuthService, useValue: authMock },
+        { provide: Router, useValue: routerMock },
+        {
+          provide: ActivatedRoute,
+          useValue: { snapshot: { queryParamMap: convertToParamMap(queryParams) } },
+        },
+      ],
+    }),
+  };
+}

 describe('Login', () => {
  let authMock: { login: ReturnType<typeof vi.fn> };
  let routerMock: { navigate: ReturnType<typeof vi.fn> };

  beforeEach(async () => {
-    authMock = { login: vi.fn() };
-    routerMock = { navigate: vi.fn() };
-
-    await TestBed.configureTestingModule({
-      imports: [Login, ReactiveFormsModule],
-      providers: [
-        { provide: AuthService, useValue: authMock },
-        { provide: Router, useValue: routerMock },
-      ],
-    }).compileComponents();
+    const attirail = configure();
+    authMock = attirail.authMock;
+    routerMock = attirail.routerMock;
+    await attirail.testBed.compileComponents();
  });

  it('ne soumet pas si le formulaire est invalide', () => {
@@ -84,6 +100,14 @@ describe('Login', () => {
    expect(errorEl?.textContent).toContain('30s');
  });

+  it('affiche le message standard quand on arrive avec ?motif=lien-expire', async () => {
+    const attirail = configure({ motif: MOTIF_LIEN_RESET_INVALIDE });
+    await attirail.testBed.compileComponents();
+    const fixture = TestBed.createComponent(Login);
+
+    expect(fixture.componentInstance.errorMessage()).toContain('expiré');
+  });
+
  it('désactive le bouton tant que le formulaire est invalide', () => {
    const fixture = TestBed.createComponent(Login);
    fixture.detectChanges();
@@ -1,13 +1,14 @@
 import { Component, inject, signal } from '@angular/core';
 import { ReactiveFormsModule, FormBuilder, Validators } from '@angular/forms';
-import { Router } from '@angular/router';
+import { ActivatedRoute, Router, RouterLink } from '@angular/router';
 import { HttpErrorResponse } from '@angular/common/http';
 import { AuthService } from '../../../core/services/auth.service';
+import { MESSAGE_LIEN_RESET_INVALIDE, MOTIF_LIEN_RESET_INVALIDE } from '../../../shared/models/auth-redirect-reason';

@Component({
  selector: 'app-login',
  standalone: true,
-  imports: [ReactiveFormsModule],
+  imports: [ReactiveFormsModule, RouterLink],
  templateUrl: './login.html',
  styleUrl: './login.scss',
 })
@@ -15,8 +16,13 @@ export class Login {
  private fb = inject(FormBuilder);
  private auth = inject(AuthService);
  private router = inject(Router);
+  private route = inject(ActivatedRoute);

-  errorMessage = signal<string | null>(null);
+  errorMessage = signal<string | null>(
+    this.route.snapshot.queryParamMap.get('motif') === MOTIF_LIEN_RESET_INVALIDE
+      ? MESSAGE_LIEN_RESET_INVALIDE
+      : null,
+  );
  retryAfterSeconds = signal<number | null>(null);
  isLoading = signal(false);

@@ -0,0 +1,32 @@
+<div class="auth-page">
+  <form class="auth-card" [formGroup]="form" (ngSubmit)="onSubmit()">
+    <h1>Nouveau mot de passe</h1>
+
+    @if (hasToken && !isCheckingToken()) {
+      <p class="auth-subtitle">Choisissez votre nouveau mot de passe</p>
+
+      <label for="new_password">Nouveau mot de passe</label>
+      <input
+        id="new_password"
+        type="password"
+        formControlName="new_password"
+        autocomplete="new-password"
+      />
+      <app-password-requirements [password]="password()" />
+
+      @if (errorMessage()) {
+        <p class="auth-error">{{ errorMessage() }}</p>
+      }
+
+      <button type="submit" [disabled]="form.invalid || isLoading()">
+        {{ isLoading() ? 'Modification...' : 'Valider' }}
+      </button>
+    }
+
+    @if (hasToken && isCheckingToken()) {
+      <p class="auth-subtitle">Vérification du lien...</p>
+    }
+
+    <p class="auth-link"><a routerLink="/forgot-password">Redemander un lien</a></p>
+  </form>
+</div>
@@ -0,0 +1,104 @@
+:host {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  min-height: 100vh;
+  background: #f3f4f6;
+  font-family: 'Segoe UI', system-ui, sans-serif;
+}
+
+.auth-card {
+  background: #ffffff;
+  border: 1px solid #e5e7eb;
+  border-radius: 12px;
+  padding: 2.5rem;
+  width: 100%;
+  max-width: 360px;
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.06);
+  display: flex;
+  flex-direction: column;
+
+  h1 {
+    margin: 0;
+    font-size: 1.5rem;
+    font-weight: 700;
+    color: #1f2937;
+  }
+
+  .auth-subtitle {
+    margin: 0.25rem 0 1.5rem;
+    color: #6b7280;
+    font-size: 0.9rem;
+    line-height: 1.4;
+  }
+
+  label {
+    font-size: 0.85rem;
+    font-weight: 600;
+    color: #374151;
+    margin-bottom: 0.35rem;
+    margin-top: 1rem;
+  }
+
+  input {
+    padding: 0.6rem 0.75rem;
+    border: 1px solid #d1d5db;
+    border-radius: 8px;
+    font-size: 0.95rem;
+
+    &:focus {
+      outline: none;
+      border-color: #3b82f6;
+      box-shadow: 0 0 0 3px rgba(59, 130, 246, 0.15);
+    }
+  }
+
+  button {
+    margin-top: 1.5rem;
+    padding: 0.7rem;
+    background: #3b82f6;
+    color: #fff;
+    border: none;
+    border-radius: 8px;
+    font-size: 0.95rem;
+    font-weight: 600;
+    cursor: pointer;
+
+    &:disabled {
+      background: #9ca3af;
+      cursor: not-allowed;
+    }
+
+    &:not(:disabled):hover {
+      background: #2563eb;
+    }
+  }
+}
+
+.auth-hint {
+  font-size: 0.75rem;
+  color: #9ca3af;
+  margin-top: 0.25rem;
+}
+
+.auth-error {
+  margin: 0.75rem 0 0;
+  color: #dc2626;
+  font-size: 0.85rem;
+}
+
+.auth-success {
+  margin: 0.75rem 0 0;
+  color: #16a34a;
+  font-size: 0.85rem;
+}
+
+.auth-link {
+  margin-top: 1rem;
+  font-size: 0.85rem;
+  text-align: center;
+
+  a {
+    color: #3b82f6;
+  }
+}
@@ -0,0 +1,129 @@
+import { TestBed } from '@angular/core/testing';
+import { ReactiveFormsModule } from '@angular/forms';
+import { ActivatedRoute, convertToParamMap, Router } from '@angular/router';
+import { HttpErrorResponse } from '@angular/common/http';
+import { of, throwError } from 'rxjs';
+import { vi } from 'vitest';
+import { ResetPassword } from './reset-password';
+import { AuthService } from '../../../core/services/auth.service';
+import { MOTIF_LIEN_RESET_INVALIDE } from '../../../shared/models/auth-redirect-reason';
+
+function configure(token: string | null) {
+  return TestBed.configureTestingModule({
+    imports: [ResetPassword, ReactiveFormsModule],
+    providers: [
+      {
+        provide: AuthService,
+        useValue: {
+          resetPassword: vi.fn(),
+          validateResetToken: vi.fn().mockReturnValue(of({ valid: true })),
+        },
+      },
+      { provide: Router, useValue: { navigate: vi.fn() } },
+      {
+        provide: ActivatedRoute,
+        useValue: { snapshot: { queryParamMap: convertToParamMap(token ? { token } : {}) } },
+      },
+    ],
+  }).compileComponents();
+}
+
+describe('ResetPassword', () => {
+  it("redirige vers /login avec le motif standard quand le jeton est absent de l'URL", async () => {
+    await configure(null);
+    const fixture = TestBed.createComponent(ResetPassword);
+    const router = TestBed.inject(Router) as unknown as { navigate: ReturnType<typeof vi.fn> };
+
+    fixture.detectChanges();
+
+    expect(fixture.componentInstance.hasToken).toBe(false);
+    expect(router.navigate).toHaveBeenCalledWith(['/login'], {
+      queryParams: { motif: MOTIF_LIEN_RESET_INVALIDE },
+    });
+  });
+
+  it('vérifie le jeton sans le consommer dès le chargement de la page', async () => {
+    await configure('un-secret-opaque');
+    const fixture = TestBed.createComponent(ResetPassword);
+    const auth = TestBed.inject(AuthService) as unknown as { validateResetToken: ReturnType<typeof vi.fn> };
+
+    fixture.detectChanges();
+
+    expect(auth.validateResetToken).toHaveBeenCalledWith('un-secret-opaque');
+    expect(fixture.componentInstance.isCheckingToken()).toBe(false);
+  });
+
+  it('redirige immédiatement vers /login si la vérification signale un jeton invalide', async () => {
+    await configure('un-secret-perime');
+    TestBed.overrideProvider(AuthService, {
+      useValue: { resetPassword: vi.fn(), validateResetToken: vi.fn().mockReturnValue(of({ valid: false })) },
+    });
+    const fixture = TestBed.createComponent(ResetPassword);
+    const router = TestBed.inject(Router) as unknown as { navigate: ReturnType<typeof vi.fn> };
+
+    fixture.detectChanges();
+
+    expect(router.navigate).toHaveBeenCalledWith(['/login'], {
+      queryParams: { motif: MOTIF_LIEN_RESET_INVALIDE },
+    });
+  });
+
+  it('ne soumet pas si le mot de passe ne respecte pas la politique de complexité', async () => {
+    await configure('un-secret-opaque');
+    const fixture = TestBed.createComponent(ResetPassword);
+    const component = fixture.componentInstance;
+    const auth = TestBed.inject(AuthService) as unknown as { resetPassword: ReturnType<typeof vi.fn> };
+    component.form.setValue({ new_password: 'trop-simple' });
+
+    component.onSubmit();
+
+    expect(auth.resetPassword).not.toHaveBeenCalled();
+  });
+
+  it('redirige vers /dashboard après une réinitialisation réussie', async () => {
+    await configure('un-secret-opaque');
+    const fixture = TestBed.createComponent(ResetPassword);
+    const component = fixture.componentInstance;
+    const auth = TestBed.inject(AuthService) as unknown as { resetPassword: ReturnType<typeof vi.fn> };
+    const router = TestBed.inject(Router) as unknown as { navigate: ReturnType<typeof vi.fn> };
+    component.form.setValue({ new_password: 'Un-nouveau-mot-de-passe1!' });
+    auth.resetPassword.mockReturnValue(of({ principal: { role: 'operateur' } }));
+
+    component.onSubmit();
+
+    expect(auth.resetPassword).toHaveBeenCalledWith({
+      token: 'un-secret-opaque',
+      new_password: 'Un-nouveau-mot-de-passe1!',
+    });
+    expect(router.navigate).toHaveBeenCalledWith(['/dashboard']);
+  });
+
+  it('redirige vers /login avec le motif standard quand le lien est invalide ou expiré', async () => {
+    await configure('un-secret-perime');
+    const fixture = TestBed.createComponent(ResetPassword);
+    const component = fixture.componentInstance;
+    const auth = TestBed.inject(AuthService) as unknown as { resetPassword: ReturnType<typeof vi.fn> };
+    const router = TestBed.inject(Router) as unknown as { navigate: ReturnType<typeof vi.fn> };
+    component.form.setValue({ new_password: 'Un-nouveau-mot-de-passe1!' });
+    auth.resetPassword.mockReturnValue(throwError(() => new HttpErrorResponse({ status: 400 })));
+
+    component.onSubmit();
+
+    expect(router.navigate).toHaveBeenCalledWith(['/login'], {
+      queryParams: { motif: MOTIF_LIEN_RESET_INVALIDE },
+    });
+  });
+
+  it('affiche un message générique sur une erreur inattendue (pas 400)', async () => {
+    await configure('un-secret-opaque');
+    const fixture = TestBed.createComponent(ResetPassword);
+    const component = fixture.componentInstance;
+    const auth = TestBed.inject(AuthService) as unknown as { resetPassword: ReturnType<typeof vi.fn> };
+    component.form.setValue({ new_password: 'Un-nouveau-mot-de-passe1!' });
+    auth.resetPassword.mockReturnValue(throwError(() => new HttpErrorResponse({ status: 500 })));
+
+    component.onSubmit();
+
+    expect(component.errorMessage()).toContain('invalide');
+  });
+});
@@ -0,0 +1,79 @@
+import { Component, OnInit, inject, signal } from '@angular/core';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { ReactiveFormsModule, FormBuilder } from '@angular/forms';
+import { ActivatedRoute, Router, RouterLink } from '@angular/router';
+import { HttpErrorResponse } from '@angular/common/http';
+import { AuthService } from '../../../core/services/auth.service';
+import { passwordValidators, PASSWORD_HINT } from '../../../shared/validators/password.validator';
+import { PasswordRequirementsChecklist } from '../../../shared/components/password-requirements/password-requirements';
+import { MOTIF_LIEN_RESET_INVALIDE } from '../../../shared/models/auth-redirect-reason';
+
+@Component({
+  selector: 'app-reset-password',
+  standalone: true,
+  imports: [ReactiveFormsModule, RouterLink, PasswordRequirementsChecklist],
+  templateUrl: './reset-password.html',
+  styleUrl: './reset-password.scss',
+})
+export class ResetPassword implements OnInit {
+  private fb = inject(FormBuilder);
+  private auth = inject(AuthService);
+  private router = inject(Router);
+  private route = inject(ActivatedRoute);
+
+  private token = this.route.snapshot.queryParamMap.get('token') ?? '';
+
+  errorMessage = signal<string | null>(null);
+  isLoading = signal(false);
+  passwordHint = PASSWORD_HINT;
+  hasToken = this.token.length > 0;
+
+  form = this.fb.nonNullable.group({
+    new_password: ['', passwordValidators],
+  });
+
+  password = toSignal(this.form.controls.new_password.valueChanges, { initialValue: '' });
+  isCheckingToken = signal(this.hasToken);
+
+  ngOnInit(): void {
+    if (!this.hasToken) {
+      this.redirigeVersLoginLienInvalide();
+      return;
+    }
+
+    this.auth.validateResetToken(this.token).subscribe({
+      next: ({ valid }) => {
+        this.isCheckingToken.set(false);
+        if (!valid) {
+          this.redirigeVersLoginLienInvalide();
+        }
+      },
+      error: () => this.isCheckingToken.set(false),
+    });
+  }
+
+  onSubmit(): void {
+    if (this.form.invalid || !this.hasToken) return;
+
+    this.isLoading.set(true);
+    this.errorMessage.set(null);
+
+    this.auth.resetPassword({ token: this.token, new_password: this.form.getRawValue().new_password }).subscribe({
+      next: () => {
+        this.router.navigate(['/dashboard']);
+      },
+      error: (error: HttpErrorResponse) => {
+        this.isLoading.set(false);
+        if (error.status === 400) {
+          this.redirigeVersLoginLienInvalide();
+          return;
+        }
+        this.errorMessage.set(`Nouveau mot de passe invalide (${this.passwordHint}).`);
+      },
+    });
+  }
+
+  private redirigeVersLoginLienInvalide(): void {
+    this.router.navigate(['/login'], { queryParams: { motif: MOTIF_LIEN_RESET_INVALIDE } });
+  }
+}
@@ -0,0 +1,8 @@
+<ul class="password-requirements">
+  @for (requirement of requirements(); track requirement.label) {
+    <li [class.met]="requirement.met" [class.unmet]="!requirement.met">
+      <span class="password-requirements-icon">{{ requirement.met ? '✓' : '○' }}</span>
+      {{ requirement.label }}
+    </li>
+  }
+</ul>
@@ -0,0 +1,29 @@
+:host {
+  display: block;
+}
+
+.password-requirements {
+  list-style: none;
+  margin: 0.25rem 0 0;
+  padding: 0;
+  font-size: 0.8rem;
+  line-height: 1.5;
+
+  li {
+    display: flex;
+    align-items: center;
+    gap: 0.4rem;
+  }
+
+  .password-requirements-icon {
+    font-weight: 700;
+  }
+
+  .unmet {
+    color: #9ca3af;
+  }
+
+  .met {
+    color: #16a34a;
+  }
+}
@@ -0,0 +1,39 @@
+import { TestBed } from '@angular/core/testing';
+import { PasswordRequirementsChecklist } from './password-requirements';
+
+describe('PasswordRequirementsChecklist', () => {
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      imports: [PasswordRequirementsChecklist],
+    }).compileComponents();
+  });
+
+  it('ne coche aucune règle pour un mot de passe vide', () => {
+    const fixture = TestBed.createComponent(PasswordRequirementsChecklist);
+    fixture.componentRef.setInput('password', '');
+    fixture.detectChanges();
+
+    expect(fixture.componentInstance.requirements().every((r) => !r.met)).toBe(true);
+  });
+
+  it('ne coche que les règles satisfaites pour un mot de passe partiel', () => {
+    const fixture = TestBed.createComponent(PasswordRequirementsChecklist);
+    fixture.componentRef.setInput('password', 'abcdefgh');
+    fixture.detectChanges();
+
+    const parLabel = new Map(fixture.componentInstance.requirements().map((r) => [r.label, r.met]));
+    expect(parLabel.get('8 caractères minimum')).toBe(true);
+    expect(parLabel.get('1 minuscule')).toBe(true);
+    expect(parLabel.get('1 majuscule')).toBe(false);
+    expect(parLabel.get('1 chiffre')).toBe(false);
+    expect(parLabel.get('1 caractère spécial')).toBe(false);
+  });
+
+  it('coche toutes les règles pour un mot de passe conforme', () => {
+    const fixture = TestBed.createComponent(PasswordRequirementsChecklist);
+    fixture.componentRef.setInput('password', 'Un-nouveau-mot-de-passe1!');
+    fixture.detectChanges();
+
+    expect(fixture.componentInstance.requirements().every((r) => r.met)).toBe(true);
+  });
+});
@@ -0,0 +1,19 @@
+import { Component, computed, input } from '@angular/core';
+import { PASSWORD_REQUIREMENTS } from '../../validators/password.validator';
+
+@Component({
+  selector: 'app-password-requirements',
+  standalone: true,
+  templateUrl: './password-requirements.html',
+  styleUrl: './password-requirements.scss',
+})
+export class PasswordRequirementsChecklist {
+  password = input('');
+
+  requirements = computed(() =>
+    PASSWORD_REQUIREMENTS.map((requirement) => ({
+      label: requirement.label,
+      met: requirement.test(this.password()),
+    })),
+  );
+}
@@ -0,0 +1,3 @@
+export const MOTIF_LIEN_RESET_INVALIDE = 'lien-expire';
+export const MESSAGE_LIEN_RESET_INVALIDE =
+  'Ce lien de réinitialisation est invalide ou a expiré. Connectez-vous ou redemandez-en un.';
@@ -10,6 +10,15 @@ export interface PasswordChangeRequest {
  new_password: string;
 }

+export interface ForgotPasswordRequest {
+  email: string;
+}
+
+export interface ResetPasswordRequest {
+  token: string;
+  new_password: string;
+}
+
 export interface Principal {
  id: string;
  email: string;
@@ -0,0 +1,26 @@
+import { FormControl } from '@angular/forms';
+import { passwordValidators } from './password.validator';
+
+function estValide(motDePasse: string): boolean {
+  return new FormControl(motDePasse, passwordValidators).valid;
+}
+
+describe('passwordValidators', () => {
+  it('accepte un mot de passe couvrant les quatre classes', () => {
+    expect(estValide('Un-mot-de-passe1!')).toBe(true);
+  });
+
+  it('accepte un mot de passe accentué (alignement avec le backend, ex: "Sécurité1")', () => {
+    expect(estValide('Sécurité1!')).toBe(true);
+  });
+
+  it('refuse un mot de passe sans majuscule même avec un "×" ou un "÷"', () => {
+    expect(estValide('abcdefg1×')).toBe(false);
+    expect(estValide('abcdefg1÷')).toBe(false);
+  });
+
+  it('refuse un mot de passe sans minuscule même avec un "×" ou un "÷"', () => {
+    expect(estValide('ABCDEFG1×')).toBe(false);
+    expect(estValide('ABCDEFG1÷')).toBe(false);
+  });
+});
@@ -0,0 +1,40 @@
+// Contrainte : `PASSWORD_PATTERN` doit rester identique au validateur Pydantic de
+// `app/schemas/auth.py` côté backend (mêmes plages de majuscules/minuscules, excluant
+// × et ÷, mêmes chiffres 0-9, même jeu de caractères spéciaux). `\w`/`\d` divergent entre
+// JavaScript (ASCII) et Python (Unicode) : une négation aurait accepté ou rejeté un même
+// mot de passe différemment d'un côté à l'autre (ex. "Sécurité1").
+
+import { Validators } from '@angular/forms';
+
+export const PASSWORD_MIN_LENGTH = 8;
+export const PASSWORD_MAX_LENGTH = 128;
+export const PASSWORD_HINT =
+  '8 à 128 caractères, avec au moins 1 majuscule, 1 minuscule, 1 chiffre et 1 caractère spécial';
+
+const SPECIAL_CHARACTERS = '!@#$%^&*()\\-_=+[\\]{};:,.?';
+const PASSWORD_PATTERN = new RegExp(
+  `^(?=.*[A-ZÀ-ÖØ-Þ])(?=.*[a-zà-öø-þ])` +
+    `(?=.*[0-9])(?=.*[${SPECIAL_CHARACTERS}]).*$`,
+);
+
+export const passwordValidators = [
+  Validators.required,
+  Validators.minLength(PASSWORD_MIN_LENGTH),
+  Validators.maxLength(PASSWORD_MAX_LENGTH),
+  Validators.pattern(PASSWORD_PATTERN),
+];
+
+export interface PasswordRequirement {
+  label: string;
+  test: (value: string) => boolean;
+}
+
+const SPECIAL_REGEX = new RegExp(`[${SPECIAL_CHARACTERS}]`);
+
+export const PASSWORD_REQUIREMENTS: PasswordRequirement[] = [
+  { label: `${PASSWORD_MIN_LENGTH} caractères minimum`, test: (v) => v.length >= PASSWORD_MIN_LENGTH },
+  { label: '1 majuscule', test: (v) => /[A-ZÀ-ÖØ-Þ]/.test(v) },
+  { label: '1 minuscule', test: (v) => /[a-zà-öø-þ]/.test(v) },
+  { label: '1 chiffre', test: (v) => /[0-9]/.test(v) },
+  { label: '1 caractère spécial', test: (v) => SPECIAL_REGEX.test(v) },
+];
@@ -27,11 +27,22 @@ services:
      start_period: 40s
    restart: unless-stopped

+  # Piege : Mailpit ne relaie rien vers l'exterieur, il capture tout email envoye par le
+  # backend. Aucun acces reseau sortant n'est requis ; l'UI web (8025) sert a lire les emails.
+  mailpit:
+    image: axllent/mailpit
+    ports:
+      - "${MAILPIT_SMTP_PORT:-1025}:1025"
+      - "${MAILPIT_UI_PORT:-8025}:8025"
+    restart: unless-stopped
+
  backend:
    build: ./apps/backend
    depends_on:
      db:
        condition: service_healthy
+      mailpit:
+        condition: service_started
    environment:
      APP_ENV: ${APP_ENV:-local}
      APP_DEBUG: ${APP_DEBUG:-false}
@@ -39,6 +50,11 @@ services:
      APP_SECRET_KEY: ${APP_SECRET_KEY:?}
      APP_CORS_ORIGINS: ${APP_CORS_ORIGINS:-http://localhost:4200}
      DATABASE_URL: postgresql+asyncpg://${POSTGRES_USER}:${POSTGRES_PASSWORD}@db:5432/${POSTGRES_DB}
+      APP_FRONTEND_RESET_PASSWORD_URL: ${APP_FRONTEND_RESET_PASSWORD_URL:-http://localhost:4200/reset-password}
+      APP_SMTP_HOST: mailpit
+      APP_SMTP_PORT: "1025"
+      APP_SMTP_USE_TLS: "false"
+      APP_SMTP_FROM_ADDRESS: ${APP_SMTP_FROM_ADDRESS:-no-reply@enervision.fr}
    ports:
      - "${BACKEND_PORT:-8000}:8000"
    restart: unless-stopped
@@ -1,101 +0,0 @@
-# 0005 - Modèle de prédiction de consommation : LightGBM
-
- Statut : accepté
- Date : 2026-09-17
-
-## Contexte
-
-Le schéma `prediction` contraint déjà la forme de la solution (deux cibles de régression,
-`consumption_kw` instantané et `consumption_kwh` sur `period_minutes`, un statut
-`insufficient_data` à détecter explicitement), mais aucun modèle n'était choisi. Trois
-contraintes non négociables cadrent le choix, discutées dans l'issue #89 :
-
-1. **EC06** (grille de notation individuelle) exige un modèle **entraîné, versionné avec
-   MLflow**, exposé via un endpoint fonctionnel, avec **surveillance du drift** en production.
-2. **Aucun GPU dédié** : l'infra tourne on-premise sur une VM à 4 CPU / 8 Gio RAM (ou
-   `Standard_B2s`/`B2ms` côté Azure, 2 vCPU max) — Azure Machine Learning est de toute façon
-   bloqué par la politique Azure du projet.
-3. **Délai serré** : le jalon J3 arrive à échéance le lendemain de la décision, J4 concentre déjà
-   26 issues sur 4 jours. Un modèle long à mettre en œuvre retarde la chaîne complète (service de
-   scoring #37, moteur de recommandations #38, tests ML #44/#45, tous bloqués par ce choix).
-
-Le jeu de données est déjà disponible (`all_sites_combined.csv`, fourni par le formateur) : 7
-sites, 2 ans au pas horaire (~17 500 lignes/site), avec `temperature_celsius`,
-`humidity_percent`, `solar_irradiance_wm2` en régresseurs exogènes et des features calendaires
-déjà dérivées.
-
-## Options comparées
-
-| Critère | Prophet | LightGBM/XGBoost | NeuralProphet | SARIMA | Holt-Winters | Mistral (LLM) |
-|---|---|---|---|---|---|---|
-| Saisonnalités multiples (jour/semaine/an) | Oui, nativement | Oui, via features engineered | Oui, nativement, + autorégression | Une seule, lourd à régler (SARIMAX) | Une seule, aucune | Non conçu pour ça |
-| Régresseurs exogènes | Oui, mais doivent être connus dans le futur au moment de la prédiction | Oui, via lags/moyennes glissantes sur le passé | Oui, natif | Difficile en multivarié | Aucun support | Contexte de prompt seulement, non appris |
-| Coût de calcul (VM sans GPU) | Faible | Faible | Élevé (deep learning) | Faible | Faible | Élevé à prohibitif |
-| Versionnable MLflow | Oui, nativement | Oui, nativement | Pas de support direct | Oui, générique | Pas de support direct | Rien à versionner (pas un modèle entraîné) |
-| Granularité | Un modèle par site (ou par site × métrique) | Un seul modèle global sur tous les sites | Un par site | Un par site | Un par site | — |
-| Effort avant l'échéance | Faible | Moyen (feature engineering) | Élevé | Moyen à élevé | Faible en soi | Élevé, ou factice |
-
-## Décision
-
-**LightGBM, un seul modèle global** couvrant tous les sites, plutôt qu'un modèle par site
-(Prophet) ou par famille de site. Cible : `consumption_kwh`, avec `period_minutes` comme feature
-d'entrée plutôt que comme étape d'agrégation post-prédiction. Suivi et versioning via **MLflow**
-(tracking + registre de modèles), sur le magasin local par défaut dans un premier temps —
-l'hébergement sur l'infra k3s reste une question ouverte, non bloquante pour démarrer.
-
-Raisons retenues, au-delà du tableau ci-dessus :
-
- **Un modèle global plutôt qu'un modèle par site** évite la fragilité des sites les moins
-  fournis en historique : ils bénéficient de ce qu'apprennent les autres sites, ce qu'un Prophet
-  par site ne permet pas.
- **Aucune dépendance à une prévision météo future.** Prophet exige que ses régresseurs
-  (`add_regressor`) soient connus au moment prédit ; `temperature_celsius`,
-  `humidity_percent` et `solar_irradiance_wm2` sont des mesures passées, pas des prévisions, et
-  aucune source de prévision météo n'existe dans le projet. LightGBM s'en sort avec des features
-  de lag/moyenne glissante calculées sur l'historique déjà présent dans `reading`, cf.
-  `ml/enervision_ml/features.py` — un choix qui vaut aussi bien à l'entraînement qu'au futur
-  scoring.
- **Apprentissage direct sur `consumption_kwh`** avec `period_minutes` en feature, sans étape
-  d'agrégation intermédiaire que la sortie continue de Prophet aurait demandée.
- **Coût de calcul compatible avec l'infra on-premise sans GPU.**
-
-Débat complet, comparatif détaillé et décision finale : issue #89 (Johan, phyri0s,
-ValentinDeFaria), actée en réunion d'équipe du 2026-09-17 et validée par l'ensemble de l'équipe.
-
-## Conséquences
-
- Le pipeline d'entraînement (`ml/`, ce commit) lit `reading` + `site` par connexion PostgreSQL
-  directe et construit ses features par lags/moyennes glissantes plutôt que par régresseurs
-  contemporains, cf. `docs/ML-START.md`.
- Le rôle PostgreSQL dédié `enervision_ml` (lecture seule sur `reading`/`site`) n'est pas encore
-  provisionné : dette déjà assumée par l'ADR 0003 pour les comptes ETL/ML, `ML_DATABASE_URL`
-  pointe pour l'instant vers la même base que le backend applicatif en développement.
- Le service de scoring (#37), le moteur de recommandations (#38) et les tests de dérive
-  (#44/#45) restent à construire ; ils consommeront le même module `enervision_ml.features`, qui
-  doit rester strictement identique entre entraînement et scoring pour éviter un train/serve skew
-  silencieux.
- La surveillance de drift exigée par EC06 n'est pas encore implémentée : ce ticket ne livre que
-  l'entraînement et son suivi MLflow (paramètres, métriques, artefact modèle), pas le monitoring
-  en production.
- L'hébergement de MLflow sur l'infra k3s reste une question ouverte ; le magasin SQLite local
-  (`ml/mlflow.db`, ignoré par git) suffit pour l'instant à comparer des runs sur un poste.
-
-## Alternatives écartées
-
- **Prophet** : proposition initiale, écartée après débat pour les raisons ci-dessus (modèle par
-  site, dépendance à une météo future indisponible, agrégation kWh en post-traitement). Reste un
-  candidat solide si un jour le projet doit produire une décomposition tendance/saisonnalité
-  explicable pour un usage différent.
- **Mistral (LLM)** : aucun produit dédié aux séries temporelles ; interroger un LLM généraliste
-  ne constitue pas un modèle entraîné et versionnable au sens MLflow, et le fine-tuning est hors
-  budget de calcul et hors délai.
- **SARIMA** : ne gère pas nativement plusieurs régresseurs exogènes ; réglage (p,d,q,P,D,Q) plus
-  long que le délai disponible.
- **NeuralProphet** : fait tout ce que fait Prophet et apprend en plus des motifs autorégressifs,
-  mais coûte plus cher en calcul (pas de GPU disponible) et n'a pas d'outil MLflow direct — piste
-  d'évolution possible, non engageante à ce stade.
- **Holt-Winters** : écarté d'entrée, pas seulement différé — aucun support de régresseurs
-  exogènes, alors que la météo et l'irradiance sont nécessaires ici.
- **CatBoost** : même famille que LightGBM, gère nativement les colonnes catégorielles (comme
-  `site_type`) sans encodage manuel. Non rejeté, différé : candidat à comparer si LightGBM
-  plafonne en précision.
@@ -77,7 +77,6 @@ collecteur ne vient le lire.
 | Backend | FastAPI, Python 3.14 | `apps/backend` | `En cours` | Factory, configuration, journalisation, 2 sondes de santé, `/metrics`, contrat OpenAPI versionné, routes `sites`, `alerts`, `recommendations`, `stats/summary` et `readings` en lecture (endpoints → services → repositories → models) |
 | Frontend | Angular 22, Node 24 | `apps/frontend` | `En cours` | Tableau de bord sur route `/dashboard`, deux services HTTP, graphiques Chart.js, données servies par des fixtures |
 | 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 (features par lags/moyennes glissantes, baseline de persistance saisonnière, suivi MLflow local), voir [ADR 0005](../adr/0005-modele-prediction-lightgbm.md) et [ML-START.md](../../ML-START.md). Scoring, endpoint et surveillance de dérive pas encore construits |
 | Infra | Terraform, k3s single-node | `infra/terraform` | `En cours` | Module d'installation du cluster. Jamais appliqué, aucune ressource Kubernetes déclarée |
 | Monitoring | Prometheus, Grafana, Alertmanager | `monitoring` | `Cible` | Rien, hors le `/metrics` exposé par l'API |
 | ETL | Apache Airflow | `etl/airflow` | `Cible` | Rien |
@@ -20,6 +20,8 @@ gérer : il suffit d'envoyer les requêtes avec `withCredentials`.
 | POST | `/api/v1/auth/logout` | cookie | `204` |
 | POST | `/api/v1/auth/logout-all` | jeton d'accès | `204` |
 | POST | `/api/v1/auth/password` | jeton d'accès | `200` `TokenResponse` |
+| POST | `/api/v1/auth/forgot-password` | aucune | `202` (toujours, que le compte existe ou non) |
+| POST | `/api/v1/auth/reset-password` | aucune (jeton dans le corps) | `200` `TokenResponse` |
 | GET | `/api/v1/auth/me` | jeton d'accès | `200` `PrincipalResponse` |
 | GET | `/api/v1/users` | jeton d'accès, `admin` | `200` `UserResponse[]` |
 | POST | `/api/v1/users` | jeton d'accès, `admin` | `201` `TemporaryPasswordResponse` |
@@ -51,7 +53,17 @@ codes d'erreur ci-dessous reste la référence de comportement, le schéma celle
 }

 // POST /auth/password
-{ "current_password": "...", "new_password": "..." }   // 12 à 128 caractères
+{ "current_password": "...", "new_password": "..." }   // 8 à 128 caractères, au moins 1 majuscule, 1 minuscule, 1 chiffre, 1 caractère spécial
+
+// POST /auth/forgot-password
+{ "email": "operateur@enervision.fr" }
+// Répond toujours 202, sans corps, que le compte existe, soit inactif, ou soit inconnu.
+
+// POST /auth/reset-password
+{ "token": "...", "new_password": "..." }   // même règle de complexité que /auth/password
+// Le jeton vient du lien reçu par email, valable 15 minutes, à usage unique. Répond
+// TokenResponse au succès (l'appareil qui pose le nouveau mot de passe reste connecté), ou 400
+// si le jeton est invalide, déjà utilisé, ou expiré.
 ```

 Le secret de rafraîchissement **n'apparaît jamais** dans le corps de la réponse.
@@ -70,6 +82,9 @@ Le secret de rafraîchissement **n'apparaît jamais** dans le corps de la répon
 | `403` avec `detail: "Droits insuffisants"` | rôle trop bas | masquer ou griser l'action, ne pas déconnecter |
 | `403` sur `/auth/refresh`, `/logout`, `/logout-all`, `/password` | origine hors liste autorisée (voir « Origines autorisées ») | erreur de configuration réseau, pas un cas à gérer par l'utilisateur |
 | `422` | corps invalide | le détail donne `champ` et `type`, jamais la valeur envoyée |
+| `429` sur `/auth/forgot-password` | trop de demandes | afficher l'attente, l'en-tête `Retry-After` donne les secondes |
+| `400` sur `/auth/reset-password` | lien invalide, déjà utilisé, ou expiré | inviter à redemander un lien depuis `/forgot-password` |
+| `403` sur `/auth/reset-password` | origine hors liste autorisée | erreur de configuration réseau, pas un cas à gérer par l'utilisateur |

 ## Les quatre règles qui comptent

@@ -1 +0,0 @@
-3.14
@@ -1,88 +0,0 @@
-# ML EnerVision
-
-Pipeline d'entrainement du modele de prevision de consommation energetique. Contexte complet :
-[ADR 0005](../docs/adr/0005-modele-prediction-lightgbm.md) (choix du modele) et
-[ML-START.md](../ML-START.md) (mecanisme d'acces aux donnees).
-
-| Element      | Choix                                        |
-|--------------|-----------------------------------------------|
-| Python       | 3.14                                          |
-| Gestionnaire | uv (`uv.lock` fait foi)                       |
-| Modele       | LightGBM (regression, un seul modele global)  |
-| Suivi        | MLflow (parametres, metriques, artefact)      |
-| Lint/format  | ruff                                          |
-| Typage       | mypy en mode strict                           |
-| Tests        | pytest, donnees synthetiques uniquement       |
-
-Projet Python independant de `apps/backend` : le service FastAPI n'a aucune raison d'embarquer
-LightGBM/MLflow en dependance de production juste pour un script d'entrainement lance a la main.
-
-## Installation
-
-```bash
-uv sync --all-groups
-```
-
-## Donnees
-
-Deux sources, qui produisent le meme schema en sortie de `enervision_ml.data` (voir le module
-pour le detail) :
-
- **CSV** (`--csv`), chemin de demarrage : lit directement `ml/data/all_sites_combined.csv`, le
-  jeu de donnees fourni pour le jalon J3. Ce dossier est ignore par git (gros fichier, local a
-  chaque poste) : recuperer le CSV et `dataset_metadata.json` aupres de l'equipe et les placer
-  dans `ml/data/` avant d'entrainer sur cette source.
- **PostgreSQL** (par defaut, sans `--csv`) : connexion directe a `reading` + `site` via
-  `ML_DATABASE_URL`, le chemin cible decrit dans `ML-START.md`. Le role PostgreSQL dedie
-  `enervision_ml` (lecture seule) n'est pas encore provisionne (dette assumee, cf. ADR 0003 et
-  ADR 0005) ; en attendant, pointer `ML_DATABASE_URL` vers la meme base que le backend suffit en
-  developpement.
-
-## Entrainement
-
-```bash
-uv run python -m enervision_ml.train --csv data/all_sites_combined.csv
-# ou, une fois la base peuplee et ML_DATABASE_URL positionnee :
-uv run python -m enervision_ml.train
-```
-
-Ecrit le modele entraine dans `models/lightgbm-consumption.txt` (`Booster.save_model()`, dossier
-ignore par git) et journalise la run dans MLflow : parametres, MAE/RMSE/MAPE du modele **et** de
-la baseline de persistance saisonniere (consommation de la meme heure, une semaine avant), et
-l'artefact modele. Sans `MLFLOW_TRACKING_URI`, MLflow ecrit dans un magasin SQLite local
-(`./mlflow.db`, ignore par git) : `uv run mlflow ui` pour le consulter.
-
-`--test-fraction` (0.15 par defaut) fixe la part la plus recente de l'historique reservee a la
-validation. La coupure est **chronologique**, jamais un tirage aleatoire de lignes : un tirage
-aleatoire laisserait des lignes de validation "voir" des lignes d'entrainement via leurs
-lags/moyennes glissantes, une fuite qui masquerait un surapprentissage.
-
-## Commandes
-
-```bash
-uv run ruff check .                       # lint
-uv run ruff format .                      # format
-uv run mypy enervision_ml tests           # typage strict
-uv run pytest                             # tests
-```
-
-Depuis la racine du monorepo, via le `Makefile` : `make install-ml`, `make ml-lint`,
-`make ml-typecheck`, `make ml-test`, `make ml-check`, `make ml-train` (`CSV=chemin` optionnel).
-
-## Ou ecrire les tests
-
-Aucun test ne touche PostgreSQL ni un serveur MLflow distant : `enervision_ml.data.load_from_csv`
-et le chargement CSV de test suffisent a exercer `build_features` sur des donnees reelles ou
-synthetiques, et `enervision_ml.train.train()` accepte un `tracking_uri` SQLite isole (`tmp_path`
-pytest) pour un test de bout en bout sans effet de bord. `enervision_ml.data.load_from_database`
-n'est pas encore couvert : il n'existe aucune base PostgreSQL a interroger en CI ni dans cet
-environnement de developpement pour le moment.
-
-## Piege a connaitre
-
-`enervision_ml.features.build_features` est **le seul endroit** qui doit construire les features
-du modele, a l'entrainement comme au futur scoring (service #37, pas encore construit). Si les
-deux divergent meme legerement (une fenetre de moyenne glissante calculee differemment, par
-exemple), le modele recoit en production des features qui ne ressemblent plus a ce qu'il a
-appris, et ses predictions deviennent silencieusement mauvaises sans qu'aucune erreur ne se
-declenche. Ne jamais reecrire cette logique ailleurs : importer `enervision_ml.features`.
@@ -1,16 +0,0 @@
-"""Baseline de persistance saisonniere, la barre a depasser pour justifier LightGBM.
-
-Predit la consommation de l'heure cible par celle de la meme heure, une semaine avant
-(`consumption_kwh_lag_168h`) : une consommation energetique horaire est dominee par le cycle
-hebdomadaire (jours ouvres contre week-end), donc ce naif-la est deja un concurrent serieux.
-"""
-
-import pandas as pd
-
-from enervision_ml.features import TARGET_COLUMN
-
-SEASONAL_LAG_COLUMN = f"{TARGET_COLUMN}_lag_168h"
-
-
-def seasonal_persistence_predictions(features: pd.DataFrame) -> pd.Series:
-    return features[SEASONAL_LAG_COLUMN]
@@ -1,38 +0,0 @@
-"""Configuration minimale du pipeline, lue depuis l'environnement.
-
-Pas de `BaseSettings` Pydantic ici : contrairement a `apps/backend`, ce n'est pas un service qui
-tourne en continu mais un script CLI lance a la main (cf. `docs/ML-START.md`), donc pas de
-surface de configuration a valider au demarrage d'un processus long.
-"""
-
-import os
-
-# Piege : ce n'est pas `DATABASE_URL` (celui du backend applicatif, proprietaire du schema).
-# `docs/ML-START.md` et l'ADR 0003 designent un role PostgreSQL dedie et restreint en lecture,
-# `enervision_ml`, non encore provisionne (dette assumee). Reutiliser `DATABASE_URL` par defaut
-# ferait tourner l'entrainement avec les droits d'ecriture complets de l'application, en
-# silence.
-ML_DATABASE_URL_ENV = "ML_DATABASE_URL"
-
-MLFLOW_EXPERIMENT_NAME = "consumption-forecast"
-MLFLOW_TRACKING_URI_ENV = "MLFLOW_TRACKING_URI"
-
-
-def database_url() -> str:
-    valeur = os.environ.get(ML_DATABASE_URL_ENV)
-    if not valeur:
-        raise RuntimeError(
-            f"{ML_DATABASE_URL_ENV} n'est pas defini. Elle doit pointer vers un role "
-            "PostgreSQL en lecture seule sur `reading`/`site` (voir docs/ML-START.md)."
-        )
-    return valeur
-
-
-def mlflow_tracking_uri() -> str | None:
-    """`None` laisse MLflow choisir son magasin local par defaut.
-
-    Piege : ce n'est plus `./mlruns` en clair depuis MLflow 3 (magasin fichier "maintenance
-    mode", refuse une URI `file:` explicite sauf `MLFLOW_ALLOW_FILE_STORE=true`), mais une base
-    SQLite locale (`./mlflow.db`).
-    """
-    return os.environ.get(MLFLOW_TRACKING_URI_ENV)
@@ -1,68 +0,0 @@
-"""Chargement des donnees d'entrainement.
-
-Deux chemins, qui doivent produire le meme schema de sortie (colonnes `site_id`, `timestamp`,
-`consumption_kwh`, `temperature_celsius`, `humidity_percent`, `solar_irradiance_wm2`,
-`is_working_hours`, `site_type`, `capacity_kw`), consomme ensuite par `enervision_ml.features` :
-
- `load_from_database` : le chemin cible decrit dans `docs/ML-START.md`, connexion PostgreSQL
-  directe (`reading` + `site`), pas par l'API. C'est celui qu'utilisera le pipeline en
-  production, une fois le role PostgreSQL dedie `enervision_ml` provisionne (dette assumee,
-  documentee dans `CLAUDE.md` et l'ADR 0003 : pour l'instant, la meme chaine de connexion que le
-  backend applicatif convient en developpement).
- `load_from_csv` : chemin de demarrage, tant que la base locale n'est pas peuplee. Lit
-  directement `ml/data/all_sites_combined.csv` (jeu de donnees fourni pour le jalon J3, cf.
-  issue #89), le meme fichier que celui consomme par
-  `apps/backend/app/etl/historical_import.py`. `capacity_kw` n'existe pas dans ce CSV : la
-  colonne est renvoyee a `NaN`, que LightGBM gere nativement comme valeur manquante.
-"""
-
-from pathlib import Path
-
-import pandas as pd
-from sqlalchemy import text
-from sqlalchemy.engine import Connectable
-
-OUTPUT_COLUMNS = [
-    "site_id",
-    "timestamp",
-    "consumption_kwh",
-    "temperature_celsius",
-    "humidity_percent",
-    "solar_irradiance_wm2",
-    "is_working_hours",
-    "site_type",
-    "capacity_kw",
-]
-
-_READING_QUERY = text(
-    """
-    SELECT
-        r.site_id,
-        r.timestamp,
-        r.consumption_kwh,
-        r.temperature_celsius,
-        r.humidity_percent,
-        r.solar_irradiance_wm2,
-        r.is_working_hours,
-        s.site_type,
-        s.capacity_kw
-    FROM reading r
-    JOIN site s ON s.site_id = r.site_id
-    ORDER BY r.site_id, r.timestamp
-    """
-)
-
-
-def load_from_database(connection: Connectable) -> pd.DataFrame:
-    """Lit l'historique complet `reading` + `site` depuis PostgreSQL."""
-    frame = pd.read_sql(_READING_QUERY, connection)
-    return frame[OUTPUT_COLUMNS]
-
-
-def load_from_csv(csv_path: Path) -> pd.DataFrame:
-    """Lit le jeu de donnees CSV historique (chemin de demarrage, hors base)."""
-    frame = pd.read_csv(csv_path, parse_dates=["timestamp"])
-    frame["capacity_kw"] = float("nan")
-    frame["is_working_hours"] = frame["is_working_hours"].astype(bool)
-
-    return frame[OUTPUT_COLUMNS]
@@ -1,129 +0,0 @@
-"""Construction des features pour le modele de consommation.
-
-Module partage entre l'entrainement et le futur scoring (cf. `docs/ML-START.md`) : la fonction
-qui construit les features doit rester strictement identique des deux cotes, sous peine de
-"train/serve skew" silencieux (le modele recoit en production des features qui ne ressemblent
-plus a ce qu'il a appris).
-"""
-
-from collections.abc import Sequence
-
-import pandas as pd
-
-# Cible de l'entrainement : consommation en kWh, jamais consumption_kw (absent des lectures
-# historiques CSV, cf. `apps/backend/app/etl/historical_import.py`).
-TARGET_COLUMN = "consumption_kwh"
-
-# Decalages horaires utilises pour les lags et moyennes glissantes : une heure avant, un jour
-# avant (meme heure), une semaine avant (meme heure, meme jour) - saisonnalites usuelles d'une
-# consommation energetique horaire.
-LAG_HOURS: Sequence[int] = (1, 24, 168)
-ROLLING_WINDOWS_HOURS: Sequence[int] = (24, 168)
-
-STATIC_FEATURE_COLUMNS: Sequence[str] = ("site_type", "capacity_kw")
-
-CALENDAR_FEATURE_COLUMNS: Sequence[str] = (
-    "hour",
-    "day_of_week",
-    "month",
-    "is_weekend",
-    "is_working_hours",
-)
-
-WEATHER_COLUMNS: Sequence[str] = (
-    "temperature_celsius",
-    "humidity_percent",
-    "solar_irradiance_wm2",
-)
-
-
-def build_features(frame: pd.DataFrame) -> pd.DataFrame:
-    """Construit la matrice de features a partir de lectures brutes triees par site.
-
-    `frame` doit porter au minimum : `site_id`, `timestamp`, `consumption_kwh`,
-    `is_working_hours`, les trois colonnes meteo, et les colonnes statiques de site
-    (`site_type`, `capacity_kw`). Une ligne par `(site_id, timestamp)`, sans doublon.
-
-    Piege : la meteo n'entre dans les features que decalee (lag/moyenne glissante), jamais a
-    l'instant cible. A l'entrainement comme au scoring, la meteo au moment predit n'est pas une
-    mesure mais une prevision que le projet n'a pas — l'utiliser telle quelle romprait le
-    contrat entre entrainement et usage reel (la feature ne serait tout simplement plus
-    disponible en production). Cf. debat d'architecture dans l'issue #89.
-    """
-    travail = frame.sort_values(["site_id", "timestamp"]).reset_index(drop=True)
-
-    calendrier = _calendar_features(travail["timestamp"])
-    decalees = _lagged_features(travail)
-
-    features = pd.concat(
-        [
-            travail[["site_id", "timestamp"]],
-            travail[list(STATIC_FEATURE_COLUMNS)],
-            calendrier,
-            travail[["is_working_hours"]],
-            decalees,
-            travail[[TARGET_COLUMN]],
-        ],
-        axis=1,
-    )
-
-    # `period_minutes` : resolution temporelle de la cible. Les lectures historiques sont toutes
-    # au pas horaire (cf. `dataset_metadata.json`, `frequency: "1h""), donc une constante pour
-    # l'instant. Exposee comme feature plutot que supposee implicitement, pour que le modele
-    # puisse un jour apprendre sur d'autres resolutions sans reentrainement de zero.
-    features["period_minutes"] = 60
-
-    return features
-
-
-def feature_columns() -> list[str]:
-    """Liste ordonnee des colonnes d'entree du modele (hors identifiants et cible)."""
-    lag_columns = [f"consumption_kwh_lag_{h}h" for h in LAG_HOURS]
-    rolling_columns = [
-        f"{colonne}_rolling_mean_{fenetre}h"
-        for colonne in (TARGET_COLUMN, *WEATHER_COLUMNS)
-        for fenetre in ROLLING_WINDOWS_HOURS
-    ]
-    weather_lag_columns = [f"{colonne}_lag_1h" for colonne in WEATHER_COLUMNS]
-
-    return [
-        *STATIC_FEATURE_COLUMNS,
-        *CALENDAR_FEATURE_COLUMNS,
-        "period_minutes",
-        *lag_columns,
-        *rolling_columns,
-        *weather_lag_columns,
-    ]
-
-
-def _calendar_features(timestamps: pd.Series) -> pd.DataFrame:
-    instants = pd.to_datetime(timestamps)
-
-    return pd.DataFrame(
-        {
-            "hour": instants.dt.hour,
-            "day_of_week": instants.dt.dayofweek,
-            "month": instants.dt.month,
-            "is_weekend": instants.dt.dayofweek.isin([5, 6]).astype(int),
-        }
-    )
-
-
-def _lagged_features(travail: pd.DataFrame) -> pd.DataFrame:
-    par_site = travail.groupby("site_id", sort=False)
-    colonnes: dict[str, pd.Series] = {}
-
-    for decalage in LAG_HOURS:
-        colonnes[f"{TARGET_COLUMN}_lag_{decalage}h"] = par_site[TARGET_COLUMN].shift(decalage)
-
-    for colonne in (TARGET_COLUMN, *WEATHER_COLUMNS):
-        decale = par_site[colonne].shift(1)
-        for fenetre in ROLLING_WINDOWS_HOURS:
-            colonnes[f"{colonne}_rolling_mean_{fenetre}h"] = decale.groupby(
-                travail["site_id"]
-            ).transform(lambda serie, fenetre=fenetre: serie.rolling(fenetre, min_periods=1).mean())
-
-    for colonne in WEATHER_COLUMNS:
-        colonnes[f"{colonne}_lag_1h"] = par_site[colonne].shift(1)
-
-    return pd.DataFrame(colonnes, index=travail.index)
@@ -1,24 +0,0 @@
-"""Metriques de regression partagees entre le modele et la baseline."""
-
-import numpy as np
-import pandas as pd
-from sklearn.metrics import mean_absolute_error, root_mean_squared_error
-
-
-def regression_metrics(y_true: pd.Series, y_pred: pd.Series) -> dict[str, float]:
-    """MAE, RMSE et MAPE (en %), sur les paires non nulles des deux series."""
-    valides = y_true.notna() & y_pred.notna()
-    reel = y_true[valides]
-    predit = y_pred[valides]
-
-    # MAPE diverge a consommation nulle : les mesures a zero (site a l'arret) sont exclues de ce
-    # seul ratio, pas des autres metriques.
-    non_nul = reel != 0
-    mape = float(np.mean(np.abs((reel[non_nul] - predit[non_nul]) / reel[non_nul])) * 100)
-
-    return {
-        "mae": float(mean_absolute_error(reel, predit)),
-        "rmse": float(root_mean_squared_error(reel, predit)),
-        "mape": mape,
-        "n_observations": int(valides.sum()),
-    }
@@ -1,245 +0,0 @@
-"""Entrainement du modele LightGBM de prevision de consommation energetique.
-
-CLI autonome, sur le meme gabarit que `apps/backend/app/etl/historical_import.py`
-(argparse, connexion directe a la base). Cf. `docs/ML-START.md`, section 1.
-
-    uv run python -m enervision_ml.train --csv ../ml/data/all_sites_combined.csv
-    uv run python -m enervision_ml.train  # lit ML_DATABASE_URL
-
-Le modele entraine est ecrit en fichier (`Booster.save_model()`) et suivi par MLflow (parametres,
-metriques, artefact). La base ne stocke jamais le modele lui-meme, seulement une reference vers
-lui (`prediction.model_reference`, pose par le futur service de scoring - hors perimetre ici).
-"""
-
-import argparse
-from pathlib import Path
-from typing import Any
-
-import lightgbm as lgb
-import mlflow
-import mlflow.lightgbm
-import pandas as pd
-from sqlalchemy import create_engine
-
-from enervision_ml import config
-from enervision_ml.baseline import seasonal_persistence_predictions
-from enervision_ml.data import load_from_csv, load_from_database
-from enervision_ml.features import TARGET_COLUMN, build_features, feature_columns
-from enervision_ml.metrics import regression_metrics
-
-CATEGORICAL_FEATURES = ["site_type"]
-
-LIGHTGBM_PARAMS: dict[str, Any] = {
-    "objective": "regression",
-    "metric": "mae",
-    "learning_rate": 0.05,
-    "num_leaves": 63,
-    "min_data_in_leaf": 50,
-    "feature_fraction": 0.8,
-    "bagging_fraction": 0.8,
-    "bagging_freq": 1,
-    "verbosity": -1,
-}
-
-NUM_BOOST_ROUND = 1000
-EARLY_STOPPING_ROUNDS = 50
-DEFAULT_TEST_FRACTION = 0.15
-
-
-def load_raw_frame(csv_path: Path | None) -> pd.DataFrame:
-    """Lit les lectures brutes, depuis le CSV de demarrage ou depuis PostgreSQL."""
-    if csv_path is not None:
-        return load_from_csv(csv_path)
-
-    engine = create_engine(config.database_url())
-    try:
-        return load_from_database(engine)
-    finally:
-        engine.dispose()
-
-
-def chronological_split(
-    features: pd.DataFrame, test_fraction: float
-) -> tuple[pd.DataFrame, pd.DataFrame]:
-    """Coupe par date de coupure, jamais par tirage aleatoire de lignes.
-
-    Une coupure aleatoire laisserait des lignes d'apres la coupure "voir" des lignes d'avant via
-    leurs lags/moyennes glissantes, une fuite qui masquerait un surapprentissage a l'evaluation.
-    """
-    coupure = features["timestamp"].quantile(1 - test_fraction)
-    entrainement = features[features["timestamp"] < coupure]
-    validation = features[features["timestamp"] >= coupure]
-    return entrainement, validation
-
-
-def prepare_dataset(frame: pd.DataFrame, columns: list[str]) -> tuple[pd.DataFrame, pd.Series]:
-    typee = frame.copy()
-    typee["site_type"] = typee["site_type"].astype("category")
-    return typee[columns], typee[TARGET_COLUMN]
-
-
-def train(
-    *,
-    csv_path: Path | None,
-    model_output: Path,
-    test_fraction: float = DEFAULT_TEST_FRACTION,
-    tracking_uri: str | None = None,
-) -> tuple[dict[str, float], dict[str, float]]:
-    """Execute le pipeline complet et rend (metriques du modele, metriques de la baseline)."""
-    raw = load_raw_frame(csv_path)
-    features = build_features(raw)
-    columns = feature_columns()
-
-    # Les premieres 168h par site n'ont pas de lag hebdomadaire complet : ni entrainables, ni
-    # comparables a la baseline saisonniere qui en depend.
-    utilisable = features.dropna(subset=[TARGET_COLUMN, f"{TARGET_COLUMN}_lag_168h"])
-
-    entrainement, validation = chronological_split(utilisable, test_fraction)
-    if entrainement.empty or validation.empty:
-        raise ValueError(
-            "Fenetre d'entrainement ou de validation vide : jeu de donnees trop court pour "
-            f"test_fraction={test_fraction}."
-        )
-
-    X_train, y_train = prepare_dataset(entrainement, columns)
-    X_valid, y_valid = prepare_dataset(validation, columns)
-
-    train_set = lgb.Dataset(
-        X_train,
-        label=y_train,
-        categorical_feature=CATEGORICAL_FEATURES,
-        free_raw_data=False,
-    )
-    valid_set = lgb.Dataset(
-        X_valid,
-        label=y_valid,
-        reference=train_set,
-        categorical_feature=CATEGORICAL_FEATURES,
-        free_raw_data=False,
-    )
-
-    booster = lgb.train(
-        LIGHTGBM_PARAMS,
-        train_set,
-        num_boost_round=NUM_BOOST_ROUND,
-        valid_sets=[valid_set],
-        callbacks=[
-            lgb.early_stopping(EARLY_STOPPING_ROUNDS, verbose=False),
-            lgb.log_evaluation(period=0),
-        ],
-    )
-
-    predictions = pd.Series(
-        booster.predict(X_valid, num_iteration=booster.best_iteration),
-        index=X_valid.index,
-    )
-    model_metrics = regression_metrics(y_valid, predictions)
-    baseline_metrics = regression_metrics(y_valid, seasonal_persistence_predictions(validation))
-
-    model_output.parent.mkdir(parents=True, exist_ok=True)
-    booster.save_model(str(model_output))
-
-    _log_to_mlflow(
-        tracking_uri=tracking_uri,
-        booster=booster,
-        model_metrics=model_metrics,
-        baseline_metrics=baseline_metrics,
-        n_train=len(X_train),
-        n_valid=len(X_valid),
-        test_fraction=test_fraction,
-        model_output=model_output,
-    )
-
-    return model_metrics, baseline_metrics
-
-
-def _log_to_mlflow(
-    *,
-    tracking_uri: str | None,
-    booster: lgb.Booster,
-    model_metrics: dict[str, float],
-    baseline_metrics: dict[str, float],
-    n_train: int,
-    n_valid: int,
-    test_fraction: float,
-    model_output: Path,
-) -> None:
-    uri = tracking_uri or config.mlflow_tracking_uri()
-    if uri is not None:
-        mlflow.set_tracking_uri(uri)
-    mlflow.set_experiment(config.MLFLOW_EXPERIMENT_NAME)
-
-    with mlflow.start_run():
-        mlflow.log_params(
-            {
-                **LIGHTGBM_PARAMS,
-                "num_boost_round": booster.best_iteration or NUM_BOOST_ROUND,
-                "test_fraction": test_fraction,
-                "n_train": n_train,
-                "n_valid": n_valid,
-            }
-        )
-        mlflow.log_metrics({f"model_{cle}": valeur for cle, valeur in model_metrics.items()})
-        mlflow.log_metrics({f"baseline_{cle}": valeur for cle, valeur in baseline_metrics.items()})
-        mlflow.lightgbm.log_model(booster, name="model")
-        mlflow.log_artifact(str(model_output))
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description="Entrainement du modele LightGBM EnerVision")
-
-    parser.add_argument(
-        "--csv",
-        type=Path,
-        default=None,
-        help=(
-            "Chemin vers le CSV historique (chemin de demarrage). Omis, lit ML_DATABASE_URL "
-            "et se connecte directement a PostgreSQL (reading + site)."
-        ),
-    )
-    parser.add_argument(
-        "--model-output",
-        type=Path,
-        default=Path("models/lightgbm-consumption.txt"),
-        help="Chemin d'ecriture du modele entraine. Defaut : models/lightgbm-consumption.txt.",
-    )
-    parser.add_argument(
-        "--test-fraction",
-        type=float,
-        default=DEFAULT_TEST_FRACTION,
-        help=(
-            "Part la plus recente de l'historique reservee a la validation. "
-            f"Defaut : {DEFAULT_TEST_FRACTION}."
-        ),
-    )
-    parser.add_argument(
-        "--mlflow-tracking-uri",
-        default=None,
-        help="Surcharge MLFLOW_TRACKING_URI. Omis, magasin SQLite local (./mlflow.db).",
-    )
-
-    return parser.parse_args()
-
-
-def main() -> None:
-    args = parse_args()
-
-    model_metrics, baseline_metrics = train(
-        csv_path=args.csv,
-        model_output=args.model_output,
-        test_fraction=args.test_fraction,
-        tracking_uri=args.mlflow_tracking_uri,
-    )
-
-    print("Modele LightGBM :", model_metrics)
-    print("Baseline saisonniere (t-168h) :", baseline_metrics)
-
-    if model_metrics["mae"] < baseline_metrics["mae"]:
-        gain = (1 - model_metrics["mae"] / baseline_metrics["mae"]) * 100
-        print(f"LightGBM bat la baseline de {gain:.1f}% de MAE.")
-    else:
-        print("LightGBM ne bat pas la baseline saisonniere sur ce decoupage.")
-
-
-if __name__ == "__main__":
-    main()
@@ -1,79 +0,0 @@
-[project]
-name = "enervision-ml"
-version = "0.1.0"
-description = "Pipeline d'entrainement et de scoring du modele de prediction EnerVision (LightGBM)"
-requires-python = ">=3.14,<3.15"
-dependencies = [
-    "pandas>=3.0.5",
-    "sqlalchemy>=2.0.52",
-    "psycopg[binary]>=3.2",
-    "lightgbm>=4.6",
-    "scikit-learn>=1.7",
-    "mlflow>=3.0",
-]
-
-[dependency-groups]
-dev = [
-    "ruff>=0.16.7",
-    "mypy>=2.3.1",
-    "pytest>=9.1.1",
-    "pandas-stubs>=3.0.5.260914",
-]
-
-[build-system]
-requires = ["hatchling>=1.32.0"]
-build-backend = "hatchling.build"
-
-[tool.hatch.build.targets.wheel]
-packages = ["enervision_ml"]
-
-[tool.ruff]
-line-length = 100
-target-version = "py314"
-src = ["enervision_ml", "tests"]
-
-[tool.ruff.lint]
-select = [
-    "E", "W",
-    "F",
-    "I",
-    "N",
-    "UP",
-    "B",
-    "C4",
-    "SIM",
-    "TID",
-    "RUF",
-    "S",
-    "PT",
-]
-# N806 : `X`/`y` (donnees/cible) est la convention scikit-learn/LightGBM, pas une variable mal
-# nommee.
-ignore = ["B008", "N806"]
-
-[tool.ruff.lint.per-file-ignores]
-"tests/**/*.py" = ["S101"]
-
-[tool.ruff.lint.isort]
-known-first-party = ["enervision_ml"]
-
-[tool.ruff.format]
-quote-style = "double"
-
-[tool.mypy]
-python_version = "3.14"
-strict = true
-warn_unreachable = true
-
-[[tool.mypy.overrides]]
-module = ["tests.*"]
-disallow_untyped_defs = false
-
-[[tool.mypy.overrides]]
-module = ["lightgbm.*", "mlflow.*", "sklearn.*"]
-ignore_missing_imports = true
-
-[tool.pytest.ini_options]
-testpaths = ["tests"]
-addopts = "-q --strict-markers -m 'not integration'"
-markers = ["integration: requiert une base PostgreSQL joignable"]
@@ -1,11 +0,0 @@
-import pandas as pd
-
-from enervision_ml.baseline import SEASONAL_LAG_COLUMN, seasonal_persistence_predictions
-
-
-def test_seasonal_persistence_predictions_returns_the_168h_lag_column() -> None:
-    features = pd.DataFrame({SEASONAL_LAG_COLUMN: [1.0, 2.0, 3.0], "autre_colonne": [9, 9, 9]})
-
-    predictions = seasonal_persistence_predictions(features)
-
-    assert predictions.tolist() == [1.0, 2.0, 3.0]
@@ -1,96 +0,0 @@
-from datetime import UTC, datetime, timedelta
-from typing import cast
-
-import pandas as pd
-
-from enervision_ml.features import TARGET_COLUMN, build_features, feature_columns
-
-
-def make_site_reading(
-    site_id: str, *, heures: int, depart: datetime, valeur: float = 10.0
-) -> pd.DataFrame:
-    instants = [depart + timedelta(hours=h) for h in range(heures)]
-    return pd.DataFrame(
-        {
-            "site_id": site_id,
-            "timestamp": instants,
-            TARGET_COLUMN: [valeur + h for h in range(heures)],
-            "temperature_celsius": [15.0] * heures,
-            "humidity_percent": [50.0] * heures,
-            "solar_irradiance_wm2": [0.0] * heures,
-            "is_working_hours": [True] * heures,
-            "site_type": "office",
-            "capacity_kw": 100.0,
-        }
-    )
-
-
-def two_site_frame(heures: int = 200) -> pd.DataFrame:
-    depart = datetime(2026, 1, 1, tzinfo=UTC)
-    return pd.concat(
-        [
-            make_site_reading("site-a", heures=heures, depart=depart, valeur=10.0),
-            make_site_reading("site-b", heures=heures, depart=depart, valeur=1000.0),
-        ],
-        ignore_index=True,
-    )
-
-
-def test_build_features_returns_every_declared_feature_column() -> None:
-    features = build_features(two_site_frame())
-
-    manquantes = set(feature_columns()) - set(features.columns)
-
-    assert manquantes == set()
-
-
-def test_build_features_sets_a_constant_period_minutes() -> None:
-    features = build_features(two_site_frame())
-
-    assert (features["period_minutes"] == 60).all()
-
-
-def test_build_features_lag_1h_matches_the_previous_hour_of_the_same_site() -> None:
-    features = build_features(two_site_frame(heures=200))
-    site_a = features[features["site_id"] == "site-a"].reset_index(drop=True)
-
-    assert site_a.loc[10, f"{TARGET_COLUMN}_lag_1h"] == site_a.loc[9, TARGET_COLUMN]
-
-
-def test_build_features_lag_168h_is_nan_before_a_full_week_of_history() -> None:
-    features = build_features(two_site_frame(heures=200))
-    site_a = features[features["site_id"] == "site-a"].reset_index(drop=True)
-
-    assert pd.isna(site_a.loc[100, f"{TARGET_COLUMN}_lag_168h"])
-    assert not pd.isna(site_a.loc[168, f"{TARGET_COLUMN}_lag_168h"])
-
-
-def test_build_features_never_leaks_lags_across_sites() -> None:
-    # site-b demarre a 1000 : si un lag de site-a s'y glissait, la valeur sortirait de son
-    # echelle (10, 11, 12, ...).
-    features = build_features(two_site_frame(heures=200))
-    site_b = features[features["site_id"] == "site-b"].reset_index(drop=True)
-
-    assert cast(float, site_b.loc[5, f"{TARGET_COLUMN}_lag_1h"]) >= 1000.0
-
-
-def test_build_features_rolling_mean_excludes_the_current_hour() -> None:
-    # Valeurs constantes sauf la derniere ligne : si la moyenne glissante incluait l'heure
-    # courante, la constante ne resterait pas stable jusqu'au bout.
-    depart = datetime(2026, 1, 1, tzinfo=UTC)
-    frame = make_site_reading("site-a", heures=200, depart=depart, valeur=10.0)
-    frame[TARGET_COLUMN] = 10.0
-    frame.loc[frame.index[-1], TARGET_COLUMN] = 10_000.0
-
-    features = build_features(frame).reset_index(drop=True)
-
-    assert features.loc[len(features) - 1, f"{TARGET_COLUMN}_rolling_mean_24h"] == 10.0
-
-
-def test_build_features_computes_calendar_fields_from_the_timestamp() -> None:
-    depart = datetime(2026, 1, 3, 6, tzinfo=UTC)  # un samedi, 6h
-    features = build_features(make_site_reading("site-a", heures=1, depart=depart))
-
-    assert features.loc[0, "hour"] == 6
-    assert features.loc[0, "day_of_week"] == 5
-    assert features.loc[0, "is_weekend"] == 1
@@ -1,45 +0,0 @@
-import pandas as pd
-import pytest
-
-from enervision_ml.metrics import regression_metrics
-
-
-def test_regression_metrics_computes_mae_and_rmse_on_known_values() -> None:
-    y_true = pd.Series([10.0, 20.0, 30.0])
-    y_pred = pd.Series([12.0, 18.0, 33.0])
-
-    resultat = regression_metrics(y_true, y_pred)
-
-    assert resultat["mae"] == pytest.approx(7 / 3)
-    assert resultat["n_observations"] == 3
-
-
-def test_regression_metrics_ignores_rows_with_a_missing_value() -> None:
-    y_true = pd.Series([10.0, None, 30.0])
-    y_pred = pd.Series([12.0, 18.0, None])
-
-    resultat = regression_metrics(y_true, y_pred)
-
-    assert resultat["n_observations"] == 1
-    assert resultat["mae"] == 2.0
-
-
-def test_regression_metrics_excludes_zero_actuals_from_mape_only() -> None:
-    y_true = pd.Series([0.0, 10.0])
-    y_pred = pd.Series([5.0, 12.0])
-
-    resultat = regression_metrics(y_true, y_pred)
-
-    assert resultat["n_observations"] == 2
-    assert resultat["mape"] == pytest.approx(20.0)
-
-
-def test_metrics_are_zero_for_a_perfect_prediction() -> None:
-    y_true = pd.Series([10.0, 20.0])
-    y_pred = pd.Series([10.0, 20.0])
-
-    resultat = regression_metrics(y_true, y_pred)
-
-    assert resultat["mae"] == 0.0
-    assert resultat["rmse"] == 0.0
-    assert resultat["mape"] == 0.0
@@ -1,76 +0,0 @@
-from datetime import UTC, datetime, timedelta
-from pathlib import Path
-
-import numpy as np
-import pandas as pd
-
-from enervision_ml.features import TARGET_COLUMN, build_features, feature_columns
-from enervision_ml.train import chronological_split, prepare_dataset, train
-
-
-def make_frame(site_id: str, *, heures: int, depart: datetime) -> pd.DataFrame:
-    instants = [depart + timedelta(hours=h) for h in range(heures)]
-    rng = np.random.default_rng(42)
-
-    return pd.DataFrame(
-        {
-            "site_id": site_id,
-            "timestamp": instants,
-            TARGET_COLUMN: 100.0 + 10.0 * np.sin(np.arange(heures) / 24) + rng.normal(0, 1, heures),
-            "temperature_celsius": 15.0,
-            "humidity_percent": 50.0,
-            "solar_irradiance_wm2": 0.0,
-            "is_working_hours": True,
-            "site_type": "office",
-            "capacity_kw": 100.0,
-        }
-    )
-
-
-def test_chronological_split_puts_the_most_recent_rows_in_validation() -> None:
-    depart = datetime(2026, 1, 1, tzinfo=UTC)
-    features = make_frame("site-a", heures=200, depart=depart)
-
-    entrainement, validation = chronological_split(features, test_fraction=0.2)
-
-    assert entrainement["timestamp"].max() < validation["timestamp"].min()
-    # La coupure vient d'un quantile sur les dates : une approximation du taux demande, pas un
-    # decompte exact de lignes.
-    assert abs(len(validation) - 0.2 * len(features)) <= 2
-
-
-def test_prepare_dataset_types_site_type_as_a_pandas_category() -> None:
-    depart = datetime(2026, 1, 1, tzinfo=UTC)
-    features = build_features(make_frame("site-a", heures=200, depart=depart))
-
-    X, y = prepare_dataset(features, feature_columns())
-
-    assert X["site_type"].dtype.name == "category"
-    assert y.name == TARGET_COLUMN
-
-
-def test_train_runs_end_to_end_on_synthetic_data_and_beats_a_dummy_baseline(
-    tmp_path: Path,
-) -> None:
-    depart = datetime(2026, 1, 1, tzinfo=UTC)
-    frame = pd.concat(
-        [
-            make_frame("site-a", heures=400, depart=depart),
-            make_frame("site-b", heures=400, depart=depart),
-        ],
-        ignore_index=True,
-    )
-    csv_path = tmp_path / "synthetic.csv"
-    frame.to_csv(csv_path, index=False)
-
-    model_metrics, baseline_metrics = train(
-        csv_path=csv_path,
-        model_output=tmp_path / "model.txt",
-        test_fraction=0.2,
-        tracking_uri=f"sqlite:///{tmp_path / 'mlflow.db'}",
-    )
-
-    assert (tmp_path / "model.txt").exists()
-    assert model_metrics["n_observations"] > 0
-    assert model_metrics["mae"] >= 0
-    assert baseline_metrics["n_observations"] == model_metrics["n_observations"]
Author	SHA1	Message	Date
Johan LEROY	c741ffc827	fix(auth): corrige la CI cassee par le nouvel endpoint de validation Backend / Lint, typage et tests (push) Successful in 1m19s Details /auth/reset-password/validate manquait a la liste explicite des routes publiques (test_route_protection) et n'avait pas le modele de reponse 422 declare (openapi.json desynchronise du contrat genere).	2026-09-17 15:31:14 +02:00
Johan LEROY	d7f775f9f7	feat(auth): verifie le lien de reset des le chargement, sans le consommer Ajoute GET /auth/reset-password/validate (lecture seule, sans rate limit : le jeton est un secret de 256 bits non brute-forcable) pour que la page reset-password redirige immediatement vers /login si le lien est invalide ou expire, plutot que d'attendre la soumission du formulaire. La verification a la soumission (confirm_password_reset) reste la seule source de verite atomique.	2026-09-17 15:28:50 +02:00
Johan LEROY	e381e0de09	feat(frontend): checklist de complexite du mot de passe sur reset-password Remplace l'indice statique sous le champ nouveau mot de passe par une checklist qui coche chaque regle (longueur, majuscule, minuscule, chiffre, caractere special) au fur et a mesure de la saisie. Les regles individuelles (PASSWORD_REQUIREMENTS) sont exposees depuis le meme validateur que PASSWORD_PATTERN pour rester la seule source de verite.	2026-09-17 14:57:05 +02:00
Johan LEROY	7674955637	fix(frontend): un lien de reset absent ou expire renvoie vers login avec un message standard Avant, un token absent affichait un message inline sur /reset-password, et un token invalide/expire ne se voyait qu'apres soumission du formulaire. Les deux cas redirigent maintenant vers /login avec le motif "lien-expire", qui y affiche le message standard "Ce lien de reinitialisation est invalide ou a expire. Connectez-vous ou redemandez-en un."	2026-09-17 14:49:46 +02:00
Johan LEROY	063092f2c7	fix(frontend): le rafraichissement de session au demarrage ne doit pas ecraser un lien de reset Le refresh de session lance par provideAppInitializer echoue silencieusement sans cookie valide, mais l'intercepteur forcait quand meme un router.navigate(['/login']) sur le 401 resultant, ecrasant la navigation vers /reset-password?token=... venue de l'email. L'intercepteur ne redirige plus quand on est deja sur une route invitee (login, forgot-password, reset-password).	2026-09-17 14:40:53 +02:00
Johan LEROY	921da48eb1	fix(auth): corrige 4 failles de la revue de securite sur la PR #90 Anti-enumeration cassee sur /auth/forgot-password : l'envoi SMTP etait synchrone dans le chemin de reponse, donc un email existant prenait plus de temps qu'un email inconnu (et pouvait renvoyer 500 si le relais SMTP echouait, contre 202 sinon). L'envoi part desormais en BackgroundTasks, apres que la reponse 202 a ete envoyee au client, avec un try/except qui logue plutot que de laisser une exception SMTP remonter. confirm_password_reset() ne revalidait pas is_active/kind du compte avant de changer le mot de passe : un compte desactive dans les 15 minutes suivant l'emission du lien pouvait quand meme voir son mot de passe change et son must_change_password efface. Les plages [A-ZA-Y]/[a-za-y] de la regle de complexite incluaient par erreur x et / (U+00D7, U+00F7), donc un mot de passe sans aucune majuscule ou minuscule pouvait passer la validation. Le validateur frontend (JS, \w ASCII) et le validateur backend (Python, \w Unicode) divergeaient sur les caracteres accentues : un mot de passe comme "Securite1" passait cote front puis se faisait rejeter en 422 cote back. Les deux cotes utilisent maintenant le meme jeu explicite de caracteres speciaux (SPECIAL_CHARACTERS, partage aussi avec cli.py).	2026-09-17 14:35:14 +02:00
Johan LEROY	916b5d246a	Merge remote-tracking branch 'origin/dev' into feat/password-policy-forgot-password # Conflicts: # apps/backend/app/api/deps.py # apps/backend/pyproject.toml	2026-09-17 12:18:48 +02:00
Johan LEROY	62932e57c3	style(backend): formatage ruff de cli.py	2026-09-17 11:42:44 +02:00
Johan LEROY	9161b74874	feat(auth): politique de complexite du mot de passe et flux de reinitialisation Remplace la regle de longueur seule (12 caracteres) par une exigence de composition (8 caracteres minimum, majuscule, minuscule, chiffre, caractere special), non documentee dans les exigences officielles du projet, par une regle explicite partagee entre le backend (validateur Pydantic) et le frontend. Ajoute un flux "mot de passe oublie" en libre-service, absent jusqu'ici : jeton a usage unique hache en base (meme principe que les refresh tokens), expirant a 15 minutes, envoye par email via un service SMTP (aiosmtplib, Mailpit en dev), avec limitation de debit dediee et reponse generique pour eviter l'enumeration des comptes. Closes #87	2026-09-17 10:53:58 +02:00