docs(auth): rendre la référence Pronote vérifiable

Qualifie sources et hypothèses (pronotepy 2.15.7, 2026-09-12), corrige le nombre d'ENT, exclut CAS/SAML/EduConnect générique, aligne la procédure QR sur .env.example et supprime les exemples copiables.

Refs #10

.env.example

@@ -1,6 +1,6 @@
 # --- Pronote ---
 PRONOTE_ICAL_URL=https://college.ent/pronote/ical/Edt_Jean.ics?icalsecurise=REPLACE_ME&version=2024
-PRONOTE_URL=https://college.ent/pronote/eleve.html
+PRONOTE_URL=https://college.ent/pronote/parent.html
 PRONOTE_ACCOUNT_TYPE=parent
 PRONOTE_USERNAME=parent.dupont
 PRONOTE_PASSWORD=your_secure_password
@@ -11,6 +11,20 @@ PRONOTE_AGENDA_SOURCE=auto
 PRONOTE_HOMEWORK_SOURCE=auto
 PRONOTE_MESSAGES_SOURCE=pronotepy
 
+# --- Authentification Pronote ---
+# Mode d'authentification : "password" (défaut) ou "qr_token"
+# qr_token : pour les instances utilisant HubEduConnect/EduConnect où le mot de passe échoue
+# Voir le wiki GuidePronote pour la procédure d'enrôlement QR code
+PRONOTE_AUTH_MODE=password
+
+# --- Mode qr_token (décommenter et renseigner pour l'authentification par QR code) ---
+# Le QR code se génère sur le site web Pronote (espace parent > paramètres > QR code)
+# Le QR code expire ~10 minutes après génération
+# PRONOTE_AUTH_MODE=qr_token
+# PRONOTE_QR_CODE_FILE=/path/to/qr_code.json
+# PRONOTE_QR_PIN=
+# Valeur à définir localement dans .env ; ne jamais la committer.
+
 # --- CalDAV ---
 CALDAV_URL=https://caldav.example.com/calendars/user/pronote/
 CALDAV_USERNAME=user@example.com
@@ -37,7 +51,11 @@ XMPP_HOST=example.com
 XMPP_PORT=5222
 XMPP_TO=parent@example.com
 XMPP_RESOURCE=pronote-sync
-XMPP_USE_TLS=true
+# Mode TLS : "starttls" (port 5222, défaut), "direct" (port 5223) ou "disabled" (localhost uniquement)
+XMPP_TLS_MODE=starttls
+# XMPP_USE_TLS=true/false est obsolète mais encore supporté (alias de XMPP_TLS_MODE)
+XMPP_CONNECT_TIMEOUT=15
+XMPP_CLEANUP_TIMEOUT=10
 XMPP_TIMEOUT=30
 
 # --- IA (optionnelle) ---

.gitignore

@@ -48,11 +48,16 @@ Thumbs.db
 # --- Project-specific state files ---
 .blog_rss_state.json
 .caldav_sync_state.json
+# État d'authentification pronotepy (QR code / token rotation)
+.pronote_auth_state.json
+.pronote_auth_state.json.lock
 *.state.json
 
 # --- Local scratch / WIP files ---
 FIXME_*
+FEAT_*
 TEST_*
+HANDOFF.md
 .worktrees/
 
 # --- Logs ---

.secrets.baseline

@@ -139,9 +139,8 @@
         "type": "Hex High Entropy String",
         "filename": "GUIDE_DEV_PYTHON.md",
         "hashed_secret": "90bd1b48e958257948487b90bee080ba5ed00caa",
-        "is_verified": true,
+        "is_verified": false,
-        "line_number": 5064,
+        "line_number": 5125
-        "is_secret": false
       }
     ],
     "tests/unit/test_caldav_gateway.py": [
@@ -175,7 +174,16 @@
         "is_verified": false,
         "line_number": 28
       }
+    ],
+    "tests/unit/test_xmpp_channel.py": [
+      {
+        "type": "Secret Keyword",
+        "filename": "tests/unit/test_xmpp_channel.py",
+        "hashed_secret": "b01bcded8826562355b3e32a8b31e214ff533511",
+        "is_verified": false,
+        "line_number": 1011
+      }
     ]
   },
-  "generated_at": "2026-09-08T10:45:46Z"
+  "generated_at": "2026-09-12T12:04:07Z"
 }

AGENTS.md

@@ -146,6 +146,36 @@ pronote-sync --dry-run
 - Réutiliser un téléchargement/parsing iCal pour l'agenda et les devoirs pendant un même run, sans
   cache global ni persistant.
 
+### Contrat d'authentification QR code / token
+
+- Le mode d'authentification est sélectionné par `PRONOTE_AUTH_MODE` :
+  - `password` (défaut) : authentification classique via URL, identifiant, mot de passe et ENT.
+  - `qr_token` : authentification par QR code puis token persistant (pour les instances Pronote
+    utilisant HubEduConnect/EduConnect où l'authentification par mot de passe échoue).
+- En mode `qr_token`, le premier login utilise `pronotepy.qrcode_login(qr_code, pin, uuid)` avec
+  les paramètres `PRONOTE_QR_CODE_FILE` (chemin du JSON QR) et `PRONOTE_QR_PIN` (PIN SecretStr). Le
+  QR code est obtenu depuis le site web Pronote (espace parent → paramètres → QR code), pas depuis
+  l'application mobile.
+- Après chaque login réussi, les credentials exportées par `pronotepy.export_credentials()` sont
+  persistées dans `.pronote_auth_state.json` (permissions `0600`, format JSON versionné, écriture
+  atomique). Le token rotate à chaque session et peut également être rafraîchi pendant l'exécution
+  (refresh automatique pronotepy après une `PronoteAPIError`). Les credentials sont persistées après
+  chaque login réussi **et après chaque opération de données réussie** (agenda, devoirs, messages,
+  informations) pour garantir la persistance du token valide.
+- Les logins suivants utilisent `pronotepy.token_login(**credentials)` avec le token persisté.
+- En cas d'échec de `token_login` (token expiré/invalide), une `PronoteAuthRotationError` est levée.
+  Cette erreur se propage sans wrapping à travers `PronoteFetcher` et `fetch_step` jusqu'à
+  `PipelineRunner.run()`, qui :
+  - journalise l'erreur (expurgée) ;
+  - envoie une notification XMPP actionnable si le canal est disponible et `dry_run` est inactif ;
+  - retourne un résultat dégradé `(None, errors)`.
+- `PronoteAuthRotationError` est re-levée telle quelle (`except PronoteAuthRotationError: raise`)
+  dans toutes les couches d'enveloppement du chemin critique (fetch_agenda, fetch_homework,
+  fetch_step). Ne pas l'attraper avec `except Exception` sans la re-léver d'abord.
+- Le fichier `.pronote_auth_state.json` ne doit jamais être committé (couvert par `.gitignore`).
+  Son contenu (token vivant) ne doit jamais apparaître dans les logs, les messages d'erreur ou
+  les notifications XMPP.
+
 ### Contrat du provider `openai-compatible`
 - Le provider `openai-compatible` réutilise `OpenAISynthesisProvider` avec un `base_url` personnalisé ; aucun nouveau provider n'est créé.
 - `AI_BASE_URL` et `AI_MODEL` sont requis ; `AI_API_KEY` est requis (MVP).
@@ -218,111 +248,3 @@ Le projet suit un plan séquentiel en **15 jalons** (M1-M15) décrits dans [`TOD
 |----------|------|
 | [`GUIDE_DEV_PYTHON.md`](./GUIDE_DEV_PYTHON.md) | Spécification complète (architecture, modèles, parsing, déploiement) |
 | [`TODO.md`](./TODO.md) | Plan de développement détaillé (15 jalons) |
-
----
-
-## 9. Agents OpenCode
-
-Cette section s'applique uniquement lorsque le travail est exécuté avec le système d'agents d'OpenCode.
-
-Les rôles d'agents disponibles pour ce projet sont les suivants :
-
-- `@architect` : Arbitrages d'architecture et choix techniques structurants. **Ne produit pas de code.**
-- `@coder` : Écrit et modifie du code, de la configuration et des scripts. **Ne valide pas** (ruff, mypy, pytest) — c'est le rôle de `@verifier`. **Ne diagnostique pas** — c'est le rôle de `@debugger`.
-- `@debugger` : Reproduit un symptôme et établit sa cause profonde. **Ne modifie pas le code.**
-- `@explorer` : Explore le dépôt en lecture seule. **Ne modifie rien, n'exécute pas de commandes.**
-- `@orchestrator` : Compréhension globale, définition des jalons, coordination et garantie du résultat. **N'écrit pas de code.**
-- `@planner` : Transforme une demande complexe en unités exécutables. **Ne dirige aucun technicien.**
-- `@reviewer` : Revues indépendantes de correction, régression, contrats et maintenabilité. **Ne modifie pas le code.**
-- `@security-auditor` : Audit indépendant d'une surface de sécurité. **Ne modifie pas le code.**
-- `@tech-writer` : Rédige et maintient la documentation. **N'écrit pas de code applicatif.**
-- `@test-engineer` : Conçoit, écrit et exécute des tests ciblés. **N'écrit pas de code de production.**
-- `@ui-designer` : Conçoit et implémente les interfaces Web et terminal.
-- `@verifier` : Vérifie indépendamment le comportement livré, les régressions et le respect des conventions (ruff, mypy, pytest, bandit, idempotence, mode dégradé). **Ne modifie pas le code.**
-- `@web-explorer` : Recherche et extrait des sources Web vérifiables. **Ne modifie pas le dépôt.**
-
-> **Note** : Ne pas utiliser `@coder` pour les tâches de documentation (`@tech-writer`) ni pour les tests (`@test-engineer`).
-
-### Séparation des rôles
-
-| Type de tâche | Agent responsable | Ne pas confier à |
-|---|---|---|
-| Écrire/modifier du code | `@coder` | `@verifier`, `@explorer` |
-| Valider (ruff, mypy, pytest, bandit) | `@verifier` | `@coder` |
-| Diagnostiquer un bug | `@debugger` | `@coder` |
-| Écrire un test | `@test-engineer` | `@coder` |
-| Rédiger de la documentation | `@tech-writer` | `@coder` |
-| Explorer le dépôt (lecture) | `@explorer` | `@coder`, `@verifier` |
-| Arbitrage technique structurant | `@architect` | `@coder`, `@planner` |
-| Revue de code | `@reviewer` | `@coder`, `@verifier` |
-| Audit de sécurité | `@security-auditor` | `@coder`, `@verifier` |
-| Recherche web | `@web-explorer` | `@explorer` |
-| Découpage de travail complexe | `@planner` | `@coder` |
-
----
-
-## 10. Workflow de modification
-
-1. Lire la demande, [`TODO.md`](./TODO.md), les sections pertinentes de
-   [`GUIDE_DEV_PYTHON.md`](./GUIDE_DEV_PYTHON.md), `git status` et les fichiers concernés.
-2. Préserver les changements existants de l'utilisateur.
-3. Pour une correction, reproduire d'abord le défaut avec un test automatisé lorsque c'est raisonnable.
-4. Faire une modification étroite et cohérente, en respectant les conventions du projet
-   (idempotence, modes explicites stricts et repli iCal → `pronotepy` uniquement en mode `auto`).
-5. Faire vérifier le comportement par `@verifier` (ruff, mypy, pytest, bandit) et les cas d'erreur, notamment :
-   - Succès de la synchronisation Pronote → CalDAV/XMPP.
-   - Repli d'iCal vers `pronotepy` en mode `auto`, sans repli dans les modes explicites.
-   - Distinction entre résultat vide et échec des sources.
-   - Gestion des erreurs explicites sans fuite dans les causes ou tracebacks.
-6. Mettre à jour la documentation et les exemples dans le même changement si leur comportement public évolue.
-7. Cocher dans [`TODO.md`](./TODO.md) uniquement les éléments entièrement réalisés et validés.
-8. Terminer avec un *handoff* concis : fichiers modifiés, validations exécutées, limites et prochaine étape.
-
-> **Pour les changements larges ou risqués** : Produire d'abord un audit ou un aperçu.
-> **Règle de commit** : Ne pas committer sans autorisation explicite. Une autorisation de commit ne vaut pas autorisation de push.
-
----
-
-## 11. Branches et commits
-
-- Une évolution cohérente se fait sur une **branche dédiée**.
-- Nommer les branches selon le format `<type>/<sujet-en-kebab-case>`, où `<type>` est l'un des suivants :
-  `feature`, `fix`, `docs`, `chore` ou `refactor`.
-- Partir de l'état validé de la branche principale (`main` ou `dev`), sauf demande explicite.
-- Garder **un commit atomique par objectif vérifiable**. Utiliser les préfixes conventionnels pour les messages de commit :
-  - `feat:` pour une nouvelle fonctionnalité.
-  - `fix:` pour une correction de bug.
-  - `docs:` pour une mise à jour de documentation.
-  - `chore:` pour une tâche de maintenance.
-  - `refactor:` pour une refactorisation de code.
-- Quand un agent a contribué au changement, ajouter un *trailer* Git standard au commit :
-  ```
-  Co-authored-by: <harness>/<modèle> <adresse@agents.invalid>
-  ```
-- Avant un commit autorisé, vérifier :
-  - `git status` (fichiers modifiés attendus).
-  - Le diff complet (`git diff`).
-  - L'absence de secret ou de configuration locale dans le diff.
-  - Les validations pertinentes (`ruff`, `mypy`, `pytest`, `bandit`).
-  - `git diff --check` (pas de problèmes d'espaces blancs).
-- Après le commit, rapporter :
-  - Le hash du commit.
-  - Le contenu du commit.
-  - Les validations exécutées.
-
-> **Règle absolue** : Ne jamais pousser (`git push`) sans demande distincte et explicite.
-
----
-
-## 12. Définition de terminé
-
-Un changement est considéré comme **terminé** lorsque :
-
-- Le cas nominal et les échecs pertinents sont testés (ex. : synchronisation réussie, repli
-  iCal → `pronotepy` en mode `auto`, modes explicites stricts, erreurs explicites).
-- Les outils de validation (`ruff`, `mypy`, `pytest`, `bandit`) passent sans erreur.
-- Aucun secret ni configuration locale n'apparaît dans le diff ou les fichiers suivis.
-- La documentation reste cohérente avec le code (ex. : mise à jour des exemples, des contrats ou des décisions d'architecture).
-- Le *handoff* distingue clairement :
-  - Ce qui a été vérifié localement (ex. : tests unitaires, linter).
-  - Ce qui nécessite encore une vérification manuelle (ex. : tests d'intégration avec un serveur CalDAV réel).

CHANGELOG.md

@@ -0,0 +1,65 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.2] - 2026-09-10
+
+### Added
+
+- **Authentification QR code / token** (`PRONOTE_AUTH_MODE=qr_token`) : alternative au mode `password` pour les instances Pronote utilisant HubEduConnect/EduConnect où l'authentification par mot de passe échoue (CAPTCHA, MFA, flux SAML modifié).
+  - Enrôlement initial via QR code (`pronotepy.qrcode_login`)
+  - Persistance du token rotatif dans `.pronote_auth_state.json` (permissions `0600`, écriture atomique, symlink-safe)
+  - Login subsequent via `pronotepy.token_login` avec token persisté
+  - Notification XMPP actionnable en cas d'échec de rotation (`PronoteAuthRotationError`)
+  - Persistance du token après chaque opération de données réussie et dans le chemin d'erreur (refresh pronotepy)
+  - `_is_pronotepy_configured()` mode-aware : `qr_token` ne requiert que `PRONOTE_URL`
+  - Redaction des secrets explicites (token, PIN, jeton QR) dans tous les logs
+- Nouvelles variables d'environnement : `PRONOTE_AUTH_MODE`, `PRONOTE_QR_CODE_FILE`, `PRONOTE_QR_PIN`
+- Documentation : section "Contrat d'authentification QR code / token" dans `AGENTS.md`, section QR code dans le wiki `GuidePronote`
+
+### Fixed
+
+- `PRONOTE_URL` ignoré à cause du double préfixe `env_prefix` (renommage `pronote_url` → `url` dans `PronoteSettings`)
+- `PRONOTE_ENT` rendu optionnel pour les connexions pronotepy directes
+- `.env.example` corrigé (`eleve.html` → `parent.html`)
+
+### Changed
+
+- Wiki `GuidePronote` enrichi : section "Quand l'ENT est obligatoire" (EduConnect/HubEduConnect), exemple Bordeaux
+- `AGENTS.md` : ajout de la section §13 "Versionnage et releases"
+
+### Known Issues
+
+- #20 — Triple authentification pronotepy (double INIT + refresh) lors d'un run
+- #21 — Erreur pronotepy 20 « La page a expiré ! (11) » sur `get_informations`
+
+### Tests
+
+- 694 tests passés, couverture 94.93%
+- 35 nouveaux tests QR/token : config, auth_state, client, propagation, intégration end-to-end
+
+
+## [0.1.0] - 2026-09-08
+
+Initial release covering milestones M1 through M15.
+
+### Added
+- **M1 (Scaffolding)**: Python project structure with `pyproject.toml`, and tooling configuration for `ruff`, `mypy`, `bandit`, and `pre-commit`.
+- **M2 (Configuration & secrets)**: Pydantic Settings for configuration management, `SecretStr` for sensitive fields, and redaction utilities (`redact_url`, `redact_secrets`, `redact_exception`) with `RedactingFormatter` for logging.
+- **M3 (Data models)**: 16 Pydantic models and 6 enums across 10 modules, including frozen contracts and mutable work results.
+- **M4 (Pronote sources)**: iCal fetch and parse, `pronotepy.ParentClient` integration, automatic fallback logic for `auto`, `ical`, and `pronotepy` modes, and error redaction for sensitive data.
+- **M5 (Blog RSS)**: `feedparser`-based RSS client with GUID deduplication, HTTP cache support (ETag/If-Modified-Since), and `BlogRSSState` persistence.
+- **M6 (Theoretical agenda)**: JSON provider with week parity (even/odd), school holidays calendar, and deterministic IDs for events.
+- **M7 (CalDAV sync)**: Differential synchronization by UID, `X-PRONOTE-SYNC-MANAGED` marker for managed events, idempotent operations, preserved cancelled events, and dry-run support.
+- **M8 (Agenda diff)**: `AgendaComparator` with deterministic matching, and generation of `AgendaDiff`/`AgendaChange` objects for tracking differences.
+- **M9 (AI synthesis)**: `SynthesisProvider` protocol, OpenAI provider, optional `litellm` provider, and `openai-compatible` provider with degraded mode (returns `None` on failure).
+- **M10 (XMPP channel)**: `XmppChannel` using `slixmpp`, formatted messages (synthesis, homeworks, changes, messages, blog), and error handling that returns `False` on failure.
+- **M11 (Pipeline orchestration)**: `PipelineRunner` as composition root, 7 pipeline steps, degraded error handling, dry-run mode, and iCal reuse within a single run.
+- **M12 (CLI entry point)**: `pronote-sync` command with `--dry-run` and `--log-level` options, redacted error display, and safe traceback in DEBUG mode.
+- **M13 (Tests & coverage)**: 636 tests with 95.67% coverage, test fixtures (`pronote-4e.ics`, `pronote-6e.ics`), shared `conftest.py`, and secret non-leak tests.
+- **M14 (Deployment)**: systemd service and timer (daily at 18:00), logrotate configuration (daily, rotate 7, compress), `check_secrets.py` pre-deployment scanner, and exploitation guide.
+- **M15 (Documentation)**: README, README.LLM.md (AI agent setup guide), MIT LICENSE, CHANGELOG, and Gitea Actions CI/CD reference for LXC/VPS (Debian/CentOS).
+- **Other**: MIT License. Gitea Actions CI/CD reference for LXC/VPS (Debian/CentOS) is planned and optional, not delivered in this release.

GUIDE_DEV_PYTHON.md

@@ -1,6 +1,6 @@
 # Guide de Développement : Synchronisation Pronote → CalDAV + XMPP (Python)
 
-> **Statut** : Guide de référence pour un futur projet Python inspiré de [`pronote-digest`](https://github.com/antoine-coulon/pronote-digest) (TypeScript).
+> **Statut** : Guide de référence pour un futur projet Python inspiré de [`pronote-digest`](https://github.com/yoanbernabeu/pronote-digest) (TypeScript) par [Yoan Bernabeu](https://yoanbernabeu.github.io/pronote-digest/).
 > **Public cible** : Développeurs Python (≥ 3.13.5) familiers avec les concepts de CLI, synchronisation de calendriers et messagerie instantanée.
 > **Objectif** : Fournir une base architecturale et technique pour un outil **synchronisant l'agenda Pronote vers CalDAV**, **comparant avec un agenda théorique**, **récupérant messages et informations**, et **envoyant une synthèse par XMPP**.
 
@@ -275,7 +275,8 @@ Le projet utilise **`pydantic-settings`** pour valider et charger la configurati
 
 > ⚠️ **Décision d'implémentation** :
 > `XMPP_RECIPIENT` a été renommé en `XMPP_TO` dans l'implémentation (aligné avec §10.2.1).
-> Des variables XMPP supplémentaires ont été ajoutées : `XMPP_ENABLED`, `XMPP_HOST`, `XMPP_PORT`, `XMPP_RESOURCE`, `XMPP_USE_TLS`, `XMPP_TIMEOUT`.
+> Des variables XMPP supplémentaires ont été ajoutées : `XMPP_ENABLED`, `XMPP_HOST`, `XMPP_PORT`, `XMPP_RESOURCE`, `XMPP_TLS_MODE`, `XMPP_TIMEOUT`, `XMPP_CONNECT_TIMEOUT`, `XMPP_CLEANUP_TIMEOUT`.
+> `XMPP_USE_TLS` reste supporté mais est **obsolète** (remplacé par `XMPP_TLS_MODE`).
 > Une section `BLOG_ENABLED` et `BLOG_RSS_URL` a été ajoutée dans `.env.example`.
 
 Les variables Pronote sont obligatoires selon les sources activées :
@@ -310,7 +311,7 @@ d'un besoin réel et testé.
 | `AI_API_KEY`                 | Clé API pour l'API IA.                                                       | `None`                  | `SecretStr`   |
 | `AI_MODEL`                   | Modèle IA à utiliser (exemple recommandé : `gpt-4o-mini`).                  | `None`                  | `str \| None`|
 | `AI_ALLOW_INSECURE_HTTP` | Autoriser HTTP (non sécurisé) pour `openai-compatible` uniquement. | `False`                 | `bool`        |
-| `DRY_RUN`                    | Mode dry-run (pas de modifications CalDAV/XMPP).                           | `False`                 | `bool`        |
+| `DRY_RUN`                    | Simulation sans sortie distante ni état local persistant ; incompatible avec `qr_token`. | `False` | `bool` |
 | `LOG_LEVEL`                  | Niveau de log (`DEBUG`, `INFO`, `WARNING`, `ERROR`).                         | `INFO`                  | `str`         |
 
 > ⚠️ **Décision d'implémentation** :
@@ -1531,6 +1532,14 @@ Sinon :
     retourner J+1 (no-school, avec libellé de vacances si applicable)
 ```
 
+Dans l'implémentation Python actuelle (`pronote_sync.pipeline.steps.fetch.resolve_target_date`),
+seuls les cours non annulés sont considérés comme effectifs ; un cours déplacé reste donc
+éligible. La recherche du prochain cours connu ne dépend pas de la présence d'un cours à J.
+Lorsqu'aucun cours futur n'est fourni et qu'un événement scolaire couvre J+1, sa borne
+`to_date` (exclusive) est utilisée comme reprise connue. Sinon, J+1 est conservé comme
+valeur de repli explicite. La fonction journalise la règle choisie avec la date et une raison
+non personnelle.
+
 **Exemple Python** :
 ```python
 Optional, Tuple, List
@@ -1892,6 +1901,20 @@ def generate_deterministic_uid(
 
 #### 5.1.6 Parsing complet du flux iCal (`sources/pronote/ical.py`)
 
+Le parseur de production accepte les variantes contrôlées des libellés et des
+balises `strong` générées par Pronote. Il distingue les catégories `Congés` /
+`Vacances` (`HOLIDAY`) des catégories `Jour(s) férié(s)` (`PUBLIC_HOLIDAY`),
+conserve la borne `DTEND` comme date exclusive et reconnaît les statuts
+annulé, déplacé ou modifié. Les sections de devoirs conservent un HTML
+nettoyé (scripts, styles et attributs exécutables supprimés) ainsi qu'un texte
+lisible. La déduplication utilise la date, la matière, les enseignants et le
+texte normalisé : une copie du même devoir est fusionnée, tandis qu'un devoir
+homonyme d'une autre matière ou d'un autre enseignant est conservé.
+
+Le champ `Partie(s) de classe` est conservé dans `Lesson.class_part` et dans
+la description iCalendar sérialisée. Les catégories ou sections inconnues ne
+doivent pas être interprétées comme des vacances, une annulation ou un devoir.
+
 ```python
 List, Optional, Tuple
 from datetime import datetime, date
@@ -2143,9 +2166,9 @@ def parse_ical(raw_ical: str) -> tuple[List[Lesson], List[HomeworkModel], List[S
         - school_events : Liste des événements scolaires (vacances).
 
     **Note importante** :
-    La déduplication globale des devoirs est effectuée **après le parsing** de tous les VEVENT,
+La déduplication globale des devoirs est effectuée **après le parsing** de tous les VEVENT,
-    une fois que `target_date` est connu (via `resolve_target_day`).
+une fois que `target_date` est connu (via `resolve_target_day`).
-    Voir la section [5.1.4 Déduplication des devoirs](#514-déduplication-des-devoirs) pour plus de détails.
+Voir la section [5.1.4 Déduplication des devoirs](#514-déduplication-des-devoirs) pour plus de détails.
     """
     cal = Calendar.from_ical(raw_ical)
 
@@ -2259,7 +2282,27 @@ d'informations sont non critiques et peuvent retourner une liste vide avec un wa
 Les objets renvoyés par `client.homework(start, end)` couvrent une fenêtre. Le résultat destiné à
 un jour cible est donc filtré explicitement sur `homework.date == target_date`.
 
-#### 5.1.8 Logique de repli (`sources/pronote/fallback.py`)
+#### 5.1.8 Verrou du cycle d'authentification QR/token
+
+En mode `qr_token`, le token Pronote est un état partagé et rotatif. Afin d'éviter que deux
+exécutions ne réutilisent ou n'écrasent cet état simultanément, le client protège chaque cycle
+d'authentification et de récupération par un verrou POSIX local non bloquant, situé dans
+`.pronote_auth_state.json.lock`, à côté de `.pronote_auth_state.json`.
+
+Le verrou couvre l'ensemble du cycle QR/token : chargement de l'état, connexion par token ou
+enrôlement QR initial, opération de données (agenda, devoirs, messages ou informations), puis
+persistance des credentials actualisées. Une tentative concurrente échoue immédiatement avec une
+erreur d'état d'authentification expurgée ; elle ne patiente pas et ne relance pas
+l'authentification. Le contenu du token, le PIN et les autres credentials ne sont jamais inclus
+dans les logs ni dans ce message d'erreur.
+
+Ce mécanisme est un contrat **local** : il coordonne des processus sur le même hôte Linux et un
+filesystem local. Pour des déploiements conteneurisés, les conteneurs qui partagent le même compte
+Pronote doivent également partager le fichier d'état et son fichier de verrou. Le verrou ne fournit
+aucune exclusion fiable entre plusieurs hôtes ou via NFS ; dans ces cas, l'opérateur doit prévoir
+une exclusion externe ou utiliser un token distinct par instance.
+
+#### 5.1.9 Logique de repli (`sources/pronote/fallback.py`)
 
 Le `PronoteFetcher` dépend de `Settings` et d'un protocole de client injecté ; il ne construit pas
 de singleton et ne contient pas d'identifiants dupliqués.
@@ -3221,7 +3264,8 @@ class CalDAVClient:
 ### 7.4 Points clés
 - **Différentielle** : La synchronisation compare les UID existants avec ceux à synchroniser.
 - **Idempotence** : Deux exécutions identiques ne modifient pas le calendrier.
-- **Dry-run** : Mode obligatoire pour tester sans effet de bord.
+- **Dry-run** : Les lectures sont autorisées, sans sortie distante ni état local persistant ; le
+  mode `qr_token` est refusé avant connexion car son authentification implique une rotation distante.
 - **Marquage** : Les événements gérés sont marqués avec `X-PRONOTE-SYNC-MANAGED: v1` pour éviter les conflits.
 - **Cours annulés** : Conservés avec `STATUS:CANCELLED` (ne pas supprimer).
 - **Plan explicite** : Le `CalDAVSyncPlan` est calculé avant l'exécution.
@@ -4045,7 +4089,9 @@ Si le besoin évolue (ex: **plusieurs destinataires**), les étapes suivantes so
 | `XMPP_PORT`                | Port XMPP (5222 pour STARTTLS, 5223 pour TLS direct).                           | `5222`               | `int`             | ❌ Non           |
 | `XMPP_TO`                  | Destinataire unique (ex: `parent@exemple.org`).                             | `None`                | `str`             | ✅ Oui           |
 | `XMPP_RESOURCE`            | Ressource XMPP (ex: `pronote-sync`).                                         | `"pronote-sync"`     | `str`             | ❌ Non           |
-| `XMPP_USE_TLS`             | Utiliser TLS pour la connexion.                                              | `True`                | `bool`            | ❌ Non           |
+| `XMPP_TLS_MODE`            | Mode TLS : `starttls` (défaut), `direct` ou `disabled` (localhost uniquement). | `"starttls"`          | `Literal`         | ❌ Non           |
+| `XMPP_CONNECT_TIMEOUT`     | Timeout de connexion (secondes).                                              | `15`                  | `float`           | ❌ Non           |
+| `XMPP_CLEANUP_TIMEOUT`     | Timeout de nettoyage (secondes).                                              | `10`                  | `float`           | ❌ Non           |
 | `XMPP_TIMEOUT`             | Timeout de connexion (secondes).                                             | `30`                 | `int`             | ❌ Non           |
 
 **⚠️ Notes** :
@@ -4053,6 +4099,7 @@ Si le besoin évolue (ex: **plusieurs destinataires**), les étapes suivantes so
 - **Pas de variables PubSub** : `XMPP_PUBSUB_NODE`, `XMPP_ROOM`, `XMPP_SUBSCRIBERS` **ne doivent pas être introduites** pour l'instant.
 - **Sécurité** : `XMPP_JID`, `XMPP_PASSWORD` et `XMPP_TO` **ne doivent jamais apparaître** dans les logs, erreurs ou fixtures.
 - **Standardisation** : `XMPP_TO` est mappé sur le champ `to` dans le modèle Pydantic.
+- **`XMPP_USE_TLS` obsolète** : remplacée par `XMPP_TLS_MODE` (`starttls`, `direct` ou `disabled`) ; `XMPP_USE_TLS=true` → `direct` et `XMPP_USE_TLS=false` → `starttls`, avec un `DeprecationWarning`.
 
 #### 10.2.2 Exemple de configuration dans `.env`
 
@@ -4065,13 +4112,19 @@ XMPP_HOST=exemple.org
 XMPP_PORT=5222
 XMPP_TO=parent@exemple.org
 XMPP_RESOURCE=pronote-digest
-XMPP_USE_TLS=true
+# XMPP_TLS_MODE : "starttls" (défaut), "direct" (port 5223) ou "disabled" (localhost uniquement)
+XMPP_TLS_MODE=starttls
+# XMPP_USE_TLS=true/false est obsolète mais encore supporté (alias de XMPP_TLS_MODE)
+XMPP_CONNECT_TIMEOUT=15
+XMPP_CLEANUP_TIMEOUT=10
 XMPP_TIMEOUT=30
 ```
 
 #### 10.2.3 Modèle Pydantic pour la configuration XMPP
 
 ```python
+from typing import Literal
+
 from pydantic import SecretStr, Field
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
@@ -4097,14 +4150,22 @@ class XmppSettings(BaseSettings):
     port: int = Field(default=5222, ge=1, le=65535)
     to: str | None = None
     resource: str = "pronote-sync"
-    use_tls: bool = True
+    tls_mode: Literal["direct", "starttls", "disabled"] = "starttls"
-    timeout: int = Field(default=30, gt=0)
+    use_tls: bool | None = Field(
+        default=None,
+        deprecated="Utiliser tls_mode à la place (XMPP_USE_TLS obsolète).",
+    )
+    timeout: float = Field(default=30, gt=0)
+    connect_timeout: float = Field(default=15, gt=0)
+    cleanup_timeout: float = Field(default=10, gt=0)
 ```
 
 > **⚠️ Mapping TLS** :
-> - `use_tls=True` → **TLS direct** (port 5223, `enable_direct_tls=True`, `enable_starttls=False`).
+> - `tls_mode="starttls"` (défaut) → **STARTTLS** (port 5222, `enable_starttls=True`, `enable_direct_tls=False`).
-> - `use_tls=False` → **STARTTLS** (port 5222, `enable_starttls=True`, `enable_direct_tls=False`).
+> - `tls_mode="direct"` → **TLS direct** (port 5223, `enable_direct_tls=True`, `enable_starttls=False`).
-> La validation refuse `use_tls=False` si `host` n'est pas un hôte de boucle locale (`localhost`, `127.0.0.1`, `::1`).
+> - `tls_mode="disabled"` → TLS désactivé ; **uniquement** autorisé sur un hôte de boucle locale (`localhost`, `127.0.0.1`, `::1`).
+> - `XMPP_USE_TLS` (`use_tls`) est **obsolète** : `use_tls=True` → `tls_mode="direct"` et
+>   `use_tls=False` → `tls_mode="starttls"` (avec `DeprecationWarning`).
 
 ---
 
@@ -5760,7 +5821,7 @@ repos:
 |----------------------------------------|-----------------------------------------------------------------------------------------------------|-----------------|------------|
 | Configuration des variables d'environnement | Vérifier que toutes les variables obligatoires sont définies (voir [Section 3.1](#31-variables-denvironnement)). | ✅ Oui           |            |
 | Vérification des secrets                | Exécuter le script de vérification de sécurité (voir [Section 13.6](#136-exemple-de-script-de-vérification-de-sécurité)). | ✅ Oui           |            |
-| Test en mode dry-run                    | Exécuter le pipeline avec `DRY_RUN=true` pour vérifier que tout fonctionne sans effet de bord. | ✅ Oui           |            |
+| Test en mode dry-run                    | Exécuter le pipeline avec `DRY_RUN=true` sans sortie distante ni état local persistant (`qr_token` exclu). | ✅ Oui |            |
 | Configuration des logs                  | Vérifier que les logs sont configurés avec masquage des secrets (voir [Section 4.2](#42-implémentation)). | ✅ Oui           |            |
 | Vérification des dépendances            | Exécuter `pip check` pour vérifier que toutes les dépendances sont installées. | ✅ Oui           |            |
 | Configuration du cron (si planifié)     | Configurer une tâche cron pour exécuter le script régulièrement (ex: tous les jours à 18h). | ⚠️ Non           |            |
@@ -5940,7 +6001,7 @@ Exemple de ligne cron (exécution tous les jours à 18h) :
 | **CalDAV**              | Protocole pour synchroniser des calendriers via HTTP.                                           |
 | **XMPP**                | Protocole de messagerie instantanée (anciennement Jabber).                                       |
 | **UID**                 | Identifiant unique pour un événement iCal/CalDAV.                                                |
-| **Dry-run**             | Mode de test où aucune modification n'est appliquée (lecture seule).                              |
+| **Dry-run**             | Simulation avec lectures autorisées, sans sortie distante ni état local persistant ; incompatible avec `qr_token`. |
 | **Idempotence**         | Propriété d'une opération qui produit le même résultat si elle est exécutée plusieurs fois.     |
 | **Reverse-engineering** | Technique consistant à analyser un logiciel pour en comprendre le fonctionnement interne.   |
 
@@ -6090,7 +6151,7 @@ Ce guide fournit une **base architecturale et technique solide** pour développe
 1. **Créer le dépôt** : Initialiser un nouveau dépôt Python avec la structure proposée.
 2. **Implémenter le cœur** : Commencer par les modules `models/`, `sources/pronote/ical.py` et `utils/`.
 3. **Ajouter les tests** : Écrire des tests unitaires pour chaque module dès le début.
-4. **Configurer CI/CD** : Mettre en place GitHub Actions pour exécuter les tests et vérifier la sécurité.
+4. **Configurer Gitea Actions** : Mettre en place Gitea Actions pour exécuter les tests et vérifier la sécurité, en vue d'un déploiement sur LXC/VPS (Debian/CentOS).
 5. **Tester en conditions réelles** : Utiliser des flux iCal Pronote anonymisés pour valider le parsing.
 
 > **⚠️ Rappel** : Ce guide est **volontairement détaillé** pour préserver les connaissances acquises sur les spécificités de Pronote. Certaines sections (ex: parsing iCal) contiennent des **observations précises** issues de l'analyse du code TypeScript existant. **Ne pas sous-estimer l'importance de ces détails** : ils sont critiques pour un fonctionnement fiable du projet.
@@ -6107,7 +6168,7 @@ Ce guide fournit une **base architecturale et technique solide** pour développe
 | **CalDAV**              | Protocole pour synchroniser des calendriers via HTTP.                                           |
 | **XMPP**                | Protocole de messagerie instantanée (anciennement Jabber).                                       |
 | **UID**                 | Identifiant unique pour un événement iCal/CalDAV.                                                |
-| **Dry-run**             | Mode de test où aucune modification n'est appliquée (lecture seule).                              |
+| **Dry-run**             | Simulation avec lectures autorisées, sans sortie distante ni état local persistant ; incompatible avec `qr_token`. |
 | **Idempotence**         | Propriété d'une opération qui produit le même résultat si elle est exécutée plusieurs fois.     |
 | **Reverse-engineering** | Technique consistant à analyser un logiciel pour en comprendre le fonctionnement interne.   |
 

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Antoine Van Elstraete
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.LLM.md

@@ -0,0 +1,148 @@
+# pronote-sync — AI Agent Setup Guide
+
+This document guides an AI agent through installing and pre-configuring the `pronote-sync` project on a fresh Linux host (Debian/CentOS). It covers environment setup, dependency installation, and configuration file preparation. It does **NOT** cover secrets provisioning — those must be provided by the operator.
+
+---
+
+## Prerequisites
+
+- Python ≥ 3.13.5 (check with `python3 --version`)
+- Git
+- A non-root service user (e.g., `pronote-sync`)
+- Target paths:
+  - `/opt/pronote-sync` (code)
+  - `/var/lib/pronote-sync` (state)
+  - `/var/log/pronote-sync` (logs)
+  - `/etc/pronote-sync` (config)
+
+---
+
+## Installation Steps
+
+```bash
+# Create service user
+sudo useradd --system --no-create-home --shell /usr/sbin/nologin pronote-sync
+
+# Clone the repository
+sudo git clone <repo-url> /opt/pronote-sync
+sudo chown -R pronote-sync:pronote-sync /opt/pronote-sync
+
+# Create virtual environment
+cd /opt/pronote-sync
+sudo -u pronote-sync python3.13 -m venv .venv
+sudo -u pronote-sync .venv/bin/pip install -e ".[dev]"
+
+# Create directories
+sudo install -d -m 0700 -o pronote-sync -g pronote-sync /etc/pronote-sync
+sudo install -d -m 0750 -o pronote-sync -g pronote-sync /var/lib/pronote-sync
+sudo install -d -m 0750 -o pronote-sync -g pronote-sync /var/log/pronote-sync
+```
+
+---
+
+## Configuration Preparation (Without Secrets)
+
+```bash
+# Copy the example config
+sudo -u pronote-sync cp /opt/pronote-sync/.env.example /etc/pronote-sync/pronote-sync.env
+
+# The operator must fill in secrets (PRONOTE_PASSWORD, CALDAV_PASSWORD, XMPP_PASSWORD, AI_API_KEY, etc.)
+# Do NOT populate secrets automatically — leave them for the operator.
+```
+
+### Non-Secret Environment Variables (Pre-Configurable)
+
+The following variables can be safely pre-configured in `/etc/pronote-sync/pronote-sync.env`:
+
+- **Pronote:**
+  - `PRONOTE_ACCOUNT_TYPE` (default: `parent`)
+  - `PRONOTE_ENT` (ENT slug, e.g., `lyceeconnecte`)
+  - `PRONOTE_AGENDA_SOURCE`, `PRONOTE_HOMEWORK_SOURCE`, `PRONOTE_MESSAGES_SOURCE` (`auto`, `ical`, or `pronotepy`)
+
+- **CalDAV:**
+  - `CALDAV_CALENDAR_PATH` (e.g., `/pronote-sync/`)
+  - `CALDAV_ALLOW_INSECURE_HTTP` (default: `false`)
+
+- **Sync Window:**
+  - `SYNC_PAST_DAYS`, `SYNC_FUTURE_DAYS`
+
+- **Theoretical Agenda:**
+  - `THEORETICAL_AGENDA_PATH`, `SCHOOL_HOLIDAYS_PATH`
+  - `THEORETICAL_WEEK_ANCHOR_DATE`, `THEORETICAL_WEEK_ANCHOR_TYPE`
+
+- **XMPP:**
+  - `XMPP_ENABLED`, `XMPP_HOST`, `XMPP_PORT`, `XMPP_TLS_MODE`, `XMPP_TIMEOUT`, `XMPP_CONNECT_TIMEOUT`, `XMPP_CLEANUP_TIMEOUT`, `XMPP_RESOURCE`
+  - `XMPP_USE_TLS` is deprecated but still supported (aliased to `XMPP_TLS_MODE`)
+
+- **AI:**
+  - `AI_ENABLED`, `AI_PROVIDER`, `AI_BASE_URL`, `AI_MODEL`, `AI_ALLOW_INSECURE_HTTP`
+
+- **Blog:**
+  - `BLOG_ENABLED`, `BLOG_RSS_URL`
+
+- **General:**
+  - `DRY_RUN`, `LOG_LEVEL`
+
+### Secret Variables (Operator Must Provide)
+
+**Do NOT set these variables automatically.** The operator must manually provide the following secrets:
+
+- **Pronote:**
+  - `PRONOTE_ICAL_URL`, `PRONOTE_URL`, `PRONOTE_USERNAME`, `PRONOTE_PASSWORD`
+
+- **CalDAV:**
+  - `CALDAV_URL`, `CALDAV_USERNAME`, `CALDAV_PASSWORD`
+
+- **XMPP:**
+  - `XMPP_JID`, `XMPP_PASSWORD`, `XMPP_TO`
+
+- **AI:**
+  - `AI_API_KEY`
+
+---
+
+## Pre-Deployment Checks
+
+```bash
+# Verify no secrets in the codebase
+/opt/pronote-sync/.venv/bin/python /opt/pronote-sync/scripts/check_secrets.py
+
+# Verify dependencies
+/opt/pronote-sync/.venv/bin/python -m pip check
+
+# Dry-run test (will fail without secrets, but verifies the environment)
+/opt/pronote-sync/.venv/bin/pronote-sync --dry-run
+```
+
+---
+
+## systemd Installation
+
+```bash
+# Install systemd units
+sudo install -m 0644 /opt/pronote-sync/deploy/systemd/pronote-sync.service /etc/systemd/system/
+sudo install -m 0644 /opt/pronote-sync/deploy/systemd/pronote-sync.timer /etc/systemd/system/
+
+# Install logrotate config
+sudo install -m 0644 /opt/pronote-sync/deploy/logrotate/pronote_sync /etc/logrotate.d/pronote_sync
+
+# Reload and enable
+sudo systemctl daemon-reload
+sudo systemctl enable --now pronote-sync.timer
+```
+
+---
+
+## Notes for the AI Agent
+
+- **Do NOT commit or write secrets** to any file in the repository.
+- **Do NOT modify** `.gitignore`, `pyproject.toml`, or existing source files.
+- If `python3.13` is not available, install it first:
+  - Debian: `sudo apt install python3.13`
+  - CentOS: Compile from source or use `dnf` if available.
+- The `check_secrets.py` script exits with:
+  - `0` (clean)
+  - `1` (secrets found)
+  - `2` (error)
+- All paths in the systemd unit assume `/opt/pronote-sync` — adjust if installed elsewhere.
+- The operator **must** provide real values for all **SECRET** variables before enabling the timer.

README.md

@@ -0,0 +1,75 @@
+# pronote-sync
+
+Synchronisation Pronote → CalDAV + XMPP.
+
+---
+
+Synchronise l'agenda et les devoirs de **Pronote** vers un calendrier **CalDAV** et envoie un résumé quotidien par **XMPP**. Supporte les sources iCal et `pronotepy` avec repli automatique. Synthèse IA optionnelle.
+
+---
+
+## 🚀 Démarrage rapide
+
+```bash
+# Cloner le dépôt
+git clone <repo-url>
+cd pronote-sync
+
+# Créer l'environnement virtuel
+python3.13 -m venv .venv
+source .venv/bin/activate
+
+# Installer
+pip install -e ".[dev]"
+
+# Configurer
+cp .env.example .env
+# Éditer .env avec vos paramètres (voir .env.example pour le détail)
+
+# Tester
+pronote-sync --dry-run --log-level DEBUG
+```
+
+---
+
+## 📖 Utilisation
+
+```bash
+pronote-sync                    # Exécute la synchronisation
+pronote-sync --dry-run          # Simulation : lectures autorisées, aucune écriture persistante ni sortie distante
+pronote-sync --log-level DEBUG  # Verbosité des journaux
+```
+
+En `--dry-run`, les données peuvent être lues pour construire la simulation, mais aucun état local
+de source n'est enregistré : l'état RSS reste en mémoire pendant l'exécution. Les écritures CalDAV
+et l'envoi XMPP sont également désactivés. Le mode
+`PRONOTE_AUTH_MODE=qr_token` est refusé avant toute connexion, car la rotation de son token ne peut
+pas garantir un état persistant cohérent pendant une simulation.
+
+---
+
+## 🛠️ Déploiement
+
+Les artefacts pour **systemd/timer** et **logrotate** sont fournis dans `deploy/`. Voir [docs/exploitation.md](docs/exploitation.md) pour plus de détails.
+
+---
+
+## 🙏 Remerciements
+
+Ce projet repose sur les bibliothèques open-source suivantes :
+- [pronotepy](https://github.com/bain3/pronotepy) — client Pronote
+- [icalendar](https://github.com/collective/icalendar) — parsing iCal
+- [caldav](https://github.com/python-caldav/caldav) — client CalDAV
+- [slixmpp](https://github.com/poezio/slixmpp) — client XMPP
+- [pydantic](https://github.com/pydantic/pydantic) — validation et configuration
+- [openai](https://github.com/openai/openai-python) — synthèse IA
+- [feedparser](https://github.com/kurtmckee/feedparser) — parsing RSS
+- [beautifulsoup4](https://www.crummy.com/software/BeautifulSoup/) — parsing HTML
+
+Inspiré de [pronote-digest](https://github.com/yoanbernabeu/pronote-digest) par [Yoan Bernabeu](https://yoanbernabeu.github.io/pronote-digest/).
+
+---
+
+## Licence
+
+MIT — voir [LICENSE](LICENSE).

TODO.md

@@ -147,7 +147,8 @@ Synchroniser différentiellement les événements Pronote vers le calendrier Cal
 
 - Le plan de sync est correctement calculé (données Pronote vs événements distants gérés).
 - Un changement de source iCal ↔ `pronotepy` ne crée ni doublon ni suppression/ajout artificiel pour un cours équivalent.
-- Un run dry-run n'écrit rien ; deux runs identiques donnent un résultat identique.
+- Un run dry-run autorise les lectures, mais ne produit aucune sortie distante ni écriture locale
+  persistante ; `qr_token` est refusé avant connexion. Deux runs identiques donnent le même résultat.
 - Les événements annulés restent (`STATUS:CANCELLED`) et sont marqués `MANAGED`.
 - Les événements non marqués ne sont jamais modifiés ni supprimés.
 
@@ -223,7 +224,9 @@ Composer et orchestrer toutes les étapes avec gestion d'erreurs dégradée et m
 - [x] Créer les étapes `pipeline/steps/` : `fetch.py`, `normalize.py`, `compare.py`, `caldav_sync.py`, `synthesis.py`, `send.py`, `fetch_blog.py`.
 - [x] Créer `pipeline/run.py` : `PipelineRunner` (composition root) orchestrant fetch → normalize → fetch_blog → compare → caldav_sync → synthesis → send.
 - [x] Gérer les erreurs dégradées (continuer sauf critique) et renvoyer `(PronoteData, erreurs + warns)`.
-- [x] Implémenter le mode `dry_run` (aucune écriture CalDAV/XMPP).
+- [x] Implémenter le mode `dry_run` : lectures autorisées, aucune écriture CalDAV/XMPP ni écriture
+  persistante locale ; l'état RSS reste en mémoire pendant l'exécution, et
+  `PRONOTE_AUTH_MODE=qr_token` est refusé avant toute connexion.
 - [x] Câbler l'injection des dépendances (Protocol + composition root), sans singleton global.
 - [x] Réutiliser, dans une même exécution, un unique téléchargement/parsing iCal pour l'agenda et les devoirs lorsque les sources sélectionnées le permettent ; rester sur un cache local au run, sans cache global ni persistant.
 
@@ -231,7 +234,9 @@ Composer et orchestrer toutes les étapes avec gestion d'erreurs dégradée et m
 - [x] Le pipeline complet s'exécute de bout en bout (mocks) dans le bon ordre.
 - [x] Une sélection iCal commune à l'agenda et aux devoirs ne déclenche qu'un téléchargement/parsing du flux par run.
 - [x] Une erreur non critique (ex : synthèse IA) n'empêche pas l'envoi XMPP.
-- [x] `dry_run=True` n'effectue aucune écriture ; aucune source disponible → erreur critique explicite.
+- [x] `dry_run=True` autorise les lectures mais n'effectue aucune écriture persistante locale ni
+  sortie distante ; aucune source disponible → erreur critique explicite. L'état RSS n'est pas
+  enregistré et `qr_token` est refusé avant toute connexion.
 - [x] Si `THEORETICAL_AGENDA_PATH` est absent, le pipeline produit un diff vide sans erreur et n'instancie pas `AgendaComparator` ; si présent, il instancie le comparateur et effectue la comparaison.
 - [x] Les erreurs critiques (`PipelineCriticalError`) propagées depuis une étape non-bloquante arrêtent le pipeline.
 
@@ -247,7 +252,8 @@ Exposer le lancement du pipeline via une interface en ligne de commande.
 - [x] Gérer le code de retour et l'affichage des erreurs (redactées).
 
 ### Critères d'acceptation
-- `pronote-sync --dry-run --log-level DEBUG` s'exécute sans effet de bord.
+- `pronote-sync --dry-run --log-level DEBUG` s'exécute sans sortie distante ni état local persistant ;
+  le mode `qr_token`, qui implique une rotation distante, est refusé avant connexion.
 - Le script console est installable (`[project.scripts]` dans `pyproject.toml`).
 - Les erreurs affichées ne contiennent aucun secret, y compris avec l'affichage d'un traceback complet en mode debug.
 
@@ -277,11 +283,11 @@ Couvrir l'ensemble du code par des tests sans réseau, avec fixtures anonymisée
 
 Mettre en production de façon supervisée (planification, rotation des logs, vérification des secrets).
 
-- [ ] Créer une unité systemd (`pronote-sync.service` + timer) ou une ligne cron (exécution quotidienne).
+- [x] Créer une unité systemd (`pronote-sync.service` + timer) ou une ligne cron (exécution quotidienne).
-- [ ] Créer `logrotate.d/pronote_sync` (daily, rotate 7, compress, delaycompress).
+- [x] Créer `logrotate.d/pronote_sync` (daily, rotate 7, compress, delaycompress).
-- [ ] Ajouter un script de vérification des secrets (§13.6) exécuté avant chaque déploiement.
+- [x] Ajouter un script de vérification des secrets (§13.6) exécuté avant chaque déploiement.
-- [ ] Documenter la supervision (logs, alertes en cas d'échec) et la maintenance (maj dépendances, dry-run avant MAJ).
+- [x] Documenter la supervision (logs, alertes en cas d'échec) et la maintenance (maj dépendances, dry-run avant MAJ).
-- [ ] Vérifier `pip check` et tester le dry-run avant mise en production.
+- [x] Vérifier `pip check` et tester le dry-run avant mise en production.
 
 ### Critères d'acceptation
 - Le service/timer systemd (ou cron) lance le pipeline quotidiennement.
@@ -294,13 +300,13 @@ Mettre en production de façon supervisée (planification, rotation des logs, v
 
 Rédiger la documentation utilisateur et finaliser le projet.
 
-- [ ] Créer `README.md` (installation, configuration `.env`, usage CLI, systemd/docker, limites, RGPD).
+- [x] Créer `README.md` (installation, configuration `.env`, usage CLI, systemd/docker, limites, RGPD).
-- [ ] Documenter l'architecture (pipeline, modules) en résumé.
+- [x] Documenter l'architecture (pipeline, modules) en résumé.
-- [ ] Ajouter `CHANGELOG` initial et la licence (MIT).
+- [x] Ajouter `CHANGELOG` initial et la licence (MIT).
-- [ ] Revue finale : cohérence avec le guide, aucun secret documenté en clair.
+- [x] Revue finale : cohérence avec le guide, aucun secret documenté en clair.
-- [ ] (Optionnel) Configurer GitHub Actions CI/CD (pytest + bandit + ruff + mypy) d'après §Prochaines étapes.
+- [ ] (Optionnel) Configurer Gitea Actions (pytest + bandit + ruff + mypy) pour le déploiement LXC/VPS (Debian/CentOS).
 
 ### Critères d'acceptation
 - `README.md` permet d'installer et de lancer le projet sans le guide.
-- La CI exécute tests + lint + sécurité.
+- Gitea Actions exécute tests + lint + sécurité.
 - Aucun secret dans la documentation.

data/school_holidays.json

@@ -0,0 +1,31 @@
+{
+  "zone": "A",
+  "school_year": "2026-2027",
+  "periods": [
+    {
+      "start_date": "2026-10-17",
+      "end_date": "2026-11-02",
+      "label": "Toussaint"
+    },
+    {
+      "start_date": "2026-12-19",
+      "end_date": "2027-01-04",
+      "label": "Noël"
+    },
+    {
+      "start_date": "2027-02-13",
+      "end_date": "2027-03-01",
+      "label": "Hiver"
+    },
+    {
+      "start_date": "2027-04-10",
+      "end_date": "2027-04-26",
+      "label": "Printemps"
+    },
+    {
+      "start_date": "2027-07-03",
+      "end_date": "2027-09-01",
+      "label": "Été"
+    }
+  ]
+}

deploy/logrotate/pronote_sync

@@ -0,0 +1,9 @@
+/var/log/pronote-sync/pronote-sync.log {
+    daily
+    missingok
+    rotate 7
+    compress
+    delaycompress
+    notifempty
+    create 0640 pronote-sync pronote-sync
+}

deploy/systemd/pronote-sync.service

@@ -0,0 +1,23 @@
+[Unit]
+Description=Synchronisation Pronote vers CalDAV et XMPP
+Wants=network-online.target
+After=network-online.target
+
+[Service]
+Type=oneshot
+User=pronote-sync
+Group=pronote-sync
+WorkingDirectory=/var/lib/pronote-sync
+EnvironmentFile=/etc/pronote-sync/pronote-sync.env
+Environment=PYTHONUNBUFFERED=1
+StateDirectory=pronote-sync
+LogsDirectory=pronote-sync
+ExecStartPre=/opt/pronote-sync/.venv/bin/python /opt/pronote-sync/scripts/check_secrets.py
+ExecStart=/opt/pronote-sync/.venv/bin/pronote-sync
+StandardOutput=append:/var/log/pronote-sync/pronote-sync.log
+StandardError=append:/var/log/pronote-sync/pronote-sync.log
+NoNewPrivileges=true
+PrivateTmp=true
+ProtectHome=true
+ProtectSystem=strict
+ReadWritePaths=/var/lib/pronote-sync /var/log/pronote-sync

deploy/systemd/pronote-sync.timer

@@ -0,0 +1,10 @@
+[Unit]
+Description=Exécution quotidienne de pronote-sync
+
+[Timer]
+OnCalendar=*-*-* 18:00:00
+Persistent=true
+Unit=pronote-sync.service
+
+[Install]
+WantedBy=timers.target

docs/exploitation.md

@@ -0,0 +1,172 @@
+# Exploitation de `pronote-sync`
+
+Ce guide décrit l'installation et l'exploitation des artefacts de déploiement
+fournis par le projet. Les paramètres de l'unité systemd fournie sont des
+exemples d'installation : adaptez-les à l'hôte cible avant son installation.
+Ne placez jamais de secret dans une unité systemd, une commande shell, un
+journal ou ce document.
+
+## Préparer l'hôte
+
+Installez le projet et ses dépendances dans le répertoire choisi, puis créez le
+fichier d'environnement référencé par l'unité à partir de `.env.example`. Il
+doit rester local et lisible uniquement par le compte de service :
+
+```bash
+sudo install -d -m 0700 -o <utilisateur-service> -g <groupe-service> <repertoire-configuration>
+sudo install -m 0600 -o <utilisateur-service> -g <groupe-service> .env <fichier-environnement>
+```
+
+Pour créer directement la configuration à partir du modèle versionné, utilisez
+la même installation protégée puis éditez le fichier avec un compte autorisé :
+
+```bash
+sudo install -m 0600 -o <utilisateur-service> -g <groupe-service> \
+  /opt/pronote-sync/.env.example <fichier-environnement>
+```
+
+Contrôlez ensuite uniquement les métadonnées du fichier, sans afficher son
+contenu :
+
+```bash
+stat -c 'mode=%a proprietaire=%U groupe=%G chemin=%n' <fichier-environnement>
+```
+
+Le résultat attendu est le mode `600` et le propriétaire/groupe du compte de
+service. Le répertoire de configuration doit rester en `0700`.
+
+Les unités fournies nécessitent l'interface CLI livrée au jalon M12. Avant de
+les installer, vérifiez que la version installée contient bien ce point
+d'entrée :
+
+```bash
+.venv/bin/pronote-sync --help
+```
+
+Avant toute activation ou mise à jour, exécutez les contrôles depuis la racine
+du projet :
+
+```bash
+.venv/bin/python scripts/check_secrets.py
+.venv/bin/python -m pip check
+.venv/bin/pronote-sync --dry-run
+```
+
+Le contrôle des secrets doit réussir avant le déploiement. Il inspecte les
+fichiers textuels de l'artefact, en excluant volontairement `.env`, les
+environnements virtuels, les répertoires générés, `tests/` et
+`GUIDE_DEV_PYTHON.md` ; les sentinelles et exemples de ces deux derniers ne
+bloquent donc pas le déploiement. Il ne valide ni les valeurs ni les permissions
+du fichier d'environnement. Pour analyser seulement le contenu indexé avant un
+commit, utilisez `scripts/check_secrets.py --staged`.
+
+Le dry-run autorise les lectures nécessaires à la simulation, mais n'applique aucune sortie
+CalDAV/XMPP et ne modifie aucun état local persistant. L'état RSS reste limité à la mémoire du
+processus. Le mode `PRONOTE_AUTH_MODE=qr_token` est incompatible avec cette garantie : la commande
+le refuse avant toute connexion afin de ne pas désynchroniser le token local du token distant.
+Le dry-run ne remplace pas une vérification des paramètres réellement chargés.
+
+En mode `PRONOTE_AUTH_MODE=qr_token`, le fichier
+`.pronote_auth_state.json` et son verrou frère sont créés dans le répertoire
+de travail du service (par exemple `/var/lib/pronote-sync`) avec le mode
+`0600`. Ils contiennent des credentials vivantes et ne doivent être ni copiés,
+ni versionnés, ni affichés. Le PIN du QR code et, si nécessaire, le PIN de
+second facteur du compte sont également des secrets ; configurez-les uniquement
+dans le fichier d'environnement protégé.
+
+## Installation systemd
+
+Les fichiers versionnés sont :
+
+- `deploy/systemd/pronote-sync.service` ;
+- `deploy/systemd/pronote-sync.timer`.
+
+Copiez-les dans le répertoire d'unités systemd de l'hôte. Avant de les activer,
+adaptez `User`, `Group`, `WorkingDirectory`, `EnvironmentFile`, les chemins des
+exécutables dans `ExecStartPre` et `ExecStart`, ainsi que les chemins de
+`StateDirectory`, `LogsDirectory` et `ReadWritePaths`. L'artefact fourni prend
+pour exemple le compte `pronote-sync`, le code dans `/opt/pronote-sync`, l'état
+dans `/var/lib/pronote-sync`, les logs dans `/var/log/pronote-sync` et le fichier
+d'environnement `/etc/pronote-sync/pronote-sync.env`. Ne copiez pas de valeur
+secrète dans l'unité.
+
+```bash
+sudo install -m 0644 deploy/systemd/pronote-sync.service /etc/systemd/system/
+sudo install -m 0644 deploy/systemd/pronote-sync.timer /etc/systemd/system/
+sudo systemctl daemon-reload
+sudo systemctl enable --now pronote-sync.timer
+systemctl list-timers pronote-sync.timer
+```
+
+Pour tester une exécution sans attendre la prochaine échéance :
+
+```bash
+sudo systemctl start pronote-sync.service
+sudo systemctl status pronote-sync.service
+```
+
+Une exécution en échec laisse l'unité `pronote-sync.service` en état `failed`.
+La supervision de l'hôte doit donc déclencher une alerte sur cet état ou sur un
+échec du timer/service ; le transport de cette alerte (courriel, XMPP ou système
+de supervision) relève de l'exploitation locale.
+
+## Journaux et alertes
+
+La configuration systemd redirige la sortie standard et la sortie d'erreur vers
+`/var/log/pronote-sync/pronote-sync.log`. Consultez ce fichier ou, selon la
+configuration de l'hôte, le journal de l'unité :
+
+```bash
+sudo tail -f /var/log/pronote-sync/pronote-sync.log
+sudo journalctl -u pronote-sync.service --since today
+sudo journalctl -u pronote-sync.service -f
+systemctl status pronote-sync.timer
+```
+
+Traitez un statut non nul ou une unité `failed` comme un échec à investiguer.
+Les logs applicatifs masquent les secrets configurés, mais évitez tout de même
+de partager sans relecture un export de journal : une donnée sensible issue de
+l'environnement ou d'un outil tiers ne doit pas être supposée sûre par défaut.
+
+## Rotation des journaux
+
+L'artefact `deploy/logrotate/pronote_sync` cible le fichier
+`/var/log/pronote-sync/pronote-sync.log` utilisé par l'unité fournie. Installez-
+le puis validez sa syntaxe avant activation :
+
+```bash
+sudo install -m 0644 deploy/logrotate/pronote_sync /etc/logrotate.d/pronote_sync
+sudo logrotate --debug /etc/logrotate.d/pronote_sync
+```
+
+La rotation configurée est quotidienne, conserve sept archives et utilise
+`compress` avec `delaycompress`. Elle recrée le fichier avec les droits `0640`
+pour le compte de service. Si vous modifiez le chemin de journal dans l'unité,
+mettez aussi à jour la règle logrotate correspondante.
+
+## Mise à jour et retour au service
+
+Avant de remplacer les dépendances ou le code, conservez une copie protégée du
+fichier d'environnement local, sans l'ajouter au dépôt. Après la mise à jour,
+réexécutez, dans cet ordre, les contrôles de secrets, de cohérence des paquets
+et le dry-run :
+
+```bash
+.venv/bin/python scripts/check_secrets.py
+.venv/bin/python -m pip check
+.venv/bin/pronote-sync --dry-run
+```
+
+Rechargez ensuite les unités si leurs fichiers ont changé, puis vérifiez une
+exécution et son journal :
+
+```bash
+sudo systemctl daemon-reload
+sudo systemctl restart pronote-sync.timer
+sudo systemctl start pronote-sync.service
+journalctl -u pronote-sync.service -n 100 --no-pager
+```
+
+En cas d'échec, ne relancez pas automatiquement après avoir modifié des
+identifiants : corrigez la configuration locale, repassez le contrôle des
+secrets et le dry-run, puis consultez le journal expurgé.

docs/fixtures-pronote.md

@@ -0,0 +1,16 @@
+# Corpus de fixtures Pronote
+
+Le corpus versionné de `tests/fixtures/` est limité à des exemples iCalendar
+minimaux et anonymisés. Il est rejouable sans connexion Pronote et sert à
+vérifier les modèles métier finaux, pas seulement l'absence d'exception.
+
+Chaque fichier `*.ics` de variante possède un manifeste JSON homonyme. Le
+manifeste indique la source, la version connue (ou `unknown`), les scénarios
+couverts et les invariants à préserver. Les réponses API Pronote ne sont pas
+stockées tant qu'elles ne peuvent pas être réduites sans conserver de données
+personnelles ou de secret.
+
+Avant d'ajouter un export : supprimer les URL, jetons, identifiants, noms,
+établissement et contenu personnel ; réduire le document aux propriétés
+nécessaires ; exécuter `scripts/check_secrets.py` ; puis ajouter un test qui
+vérifie les modèles `Lesson`, `Homework` et `SchoolEvent` obtenus.

docs/pronote-auth.md

@@ -0,0 +1,326 @@
+> ⚠️ **AVERTISSEMENT**
+>
+> Ce document **n'est pas un guide officiel**. Il n'est ni approuvé, ni validé, ni autorisé par le Ministère de l'Éducation Nationale française ni par Docaposte (éditeur de Pronote / Index Éducation). Les informations présentées reposent sur :
+> - des **observations directes** du code source de `pronotepy` (version **2.15.7**, vérifiée localement le 2026-09-12) ;
+> - des **issues publiques** du dépôt [bain3/pronotepy](https://github.com/bain3/pronotepy) (ex. #309, #344) ;
+> - des **tests d'intégration** du projet `pronote-sync`.
+>
+> **⚠️ Note importante (2026-09-12)** : Un essai réel sur l'instance Pronote cible est nécessaire avant tout usage en production. Les tests/mocks ne prouvent pas la compatibilité d'instance.
+>
+> **Convention de qualification** :
+> ✅ **Observé dans le code local** : Mécanisme vérifié dans le code source de `pronotepy` 2.15.7 ou `pronote-sync`.
+> 🔍 **Observé localement** : Comportement constaté dans les interfaces Pronote (version non spécifiée, hypothèse à valider).
+> ⚠️ **Hypothèse à valider** : Affirmation non vérifiée, nécessitant une confirmation par test sur une instance réelle.
+
+---
+
+# Authentification Pronote — Référence technique pour `pronote-sync`
+
+## Introduction
+
+Ce document documente **uniquement les méthodes d'authentification prises en charge ou délégables par `pronote-sync`**, en alignement strict avec :
+- Le code source de `pronote_sync/sources/pronote/client.py` (liste fermée `_ENT_NAMES`, gestion des tokens).
+- La bibliothèque `pronotepy` **2.15.7** (contrat des méthodes `qrcode_login`, `token_login`, `export_credentials`).
+- Les paramètres de configuration `.env.example` (lignes 21–25).
+
+**Périmètre** :
+- **Pris en charge** : Méthodes implémentées et testées dans `pronote-sync`.
+- **Délégable à pronotepy** : Méthodes gérées par `pronotepy` mais non directement exposées par `pronote-sync`.
+- **Non implémenté** : Méthodes non supportées (ex. CAS/SAML générique, EduConnect direct).
+
+**Public cible** : Développeurs et intégrateurs de `pronote-sync`.
+
+---
+
+## Tableau de compatibilité avec `pronote-sync`
+
+| Méthode | Statut dans `pronote-sync` | Implémentation | Source | Notes |
+|---------|----------------------------|----------------|--------|-------|
+| **URL iCal sécurisée** (`icalsecurise`) | ✅ Pris en charge | Source `ical` (prioritaire en mode `auto`) | 🔍 `pronote_sync/sources/ical.py` | Jeton dans l'URL traité comme secret. |
+| **Connexion directe (mot de passe + ENT)** | ✅ Pris en charge | Source `pronotepy` (repli si iCal échoue) | 🔍 `pronote_sync/sources/pronote/client.py` | Liste fermée `_ENT_NAMES` (lignes 52–84). |
+| **QR Code + token mobile** | ✅ Pris en charge | Mode `PRONOTE_AUTH_MODE=qr_token` | 🔍 `pronotepy.Client.qrcode_login` + `token_login` | Voir [Procédure QR](#procédure-qr-pour-pronote-sync). |
+| **SSO ENT (CAS/SAML)** | ❌ Non implémenté | — | — | Seuls les 30 ENT de la liste fermée `_ENT_NAMES` (pronotepy 2.15.7) sont supportés via `ent` dans `ParentClient`. **Pas de SSO générique CAS/SAML.** |
+| **EduConnect (HubEduConnect)** | ❌ Non implémenté | — | — | Nécessite une intégration CAS/SAML générique, **non supportée par ce projet**. |
+| **CAS direct** | ❌ Non implémenté | — | — | Non supporté. |
+| **API publique** | ❌ Inexistante | — | — | Aucune API publique n'est utilisée/implémentée par ce projet ; aucune API officielle publique n'a été vérifiée à la date du 2026-09-12.
+
+---
+
+## Méthode 1 : URL iCal sécurisée (`icalsecurise`)
+
+### Principe général
+Pronote expose un flux de calendrier en lecture seule conforme à la norme **iCalendar (RFC 5545)**. L'accès est contrôlé par un **jeton secret** intégré dans l'URL sous forme de paramètre de requête `icalsecurise`.
+
+✅ **Statut** : **Observé localement** (fonctionnalité native de Pronote, version non spécifiée).
+
+### Obtention du jeton
+1. Se connecter à Pronote (Espace Parents ou Élève) via n'importe quelle méthode.
+2. Accéder à la vue *« Emploi du temps »*.
+3. Utiliser la fonction *« Export iCal »* ou *« Exporter »*.
+4. Pronote génère une URL contenant un jeton secret `icalsecurise`.
+5. **Copier cette URL** : elle constitue une crédentiale unique sensible qui doit être protégée comme un mot de passe.
+
+🔹 **Source** : 🔍 Observé localement dans les interfaces Pronote (version non spécifiée, hypothèse à valider).
+⚠️ **Note** : Les étapes dépendent de l'instance et du type de compte. L'exemple ci-dessus est non fonctionnel et ne contient aucun secret.
+
+### Format de l'URL
+```
+https://{etablissement}.index-education.net/pronote/ical/Edt_{prenom}.ics?icalsecurise={jeton}&version={version}&param={param}
+```
+- `icalsecurise` : **Jeton secret** (crédentiale).
+- `version` : Version de Pronote (ex. `2024`).
+- `param` : Paramètres optionnels.
+
+🔹 **Source** : 🔍 Analysé via `pronote_sync/sources/ical.py`.
+
+### Cycle de vie
+- **Pérennité** : Le jeton reste valide jusqu'à :
+  - Révocation manuelle par l'utilisateur dans Pronote.
+  - Régénération par l'établissement (ex. à la rentrée scolaire).
+⚠️ **Hypothèse à valider** : La durée exacte dépend des politiques de l'établissement (non documentée officiellement).
+
+🔹 **Source** : ⚠️ Comportement variable selon les instances (à tester localement).
+
+### Sécurité
+1. **Surface d'attaque** : Le jeton est encodé dans l'URL → risque d'exposition via :
+    - Logs serveur/proxy.
+    - En-tête `Referer`.
+    - Historique du navigateur.
+2. **Recommandations** :
+    - **Ne jamais versionner** l'URL (ex. dans `.env` ou Git).
+    - Utiliser **HTTPS** (obligatoire).
+    - Masquer l'URL dans les logs (ex. via `redact_url()` dans `pronote-sync`).
+
+🔹 **Source** : ⚠️ Recommandation du projet (inspirée des bonnes pratiques générales de sécurité).
+
+### Intégration dans `pronote-sync`
+- **Paramètre** : `PRONOTE_ICAL_URL` (ex. `.env.example` ligne 2).
+- **Comportement** :
+  - Prioritaire en mode `PRONOTE_AGENDA_SOURCE=auto`.
+  - Si l'URL est invalide ou expire, repli automatique vers `pronotepy` (si `PRONOTE_AGENDA_SOURCE=auto`).
+  - **Aucun repli** si `PRONOTE_AGENDA_SOURCE=ical` (échec explicite).
+
+🔹 **Source** : 🔍 `pronote_sync/config/settings.py` + `pronote_sync/sources/ical.py`.
+
+---
+
+## Méthode 2 : Connexion directe (identifiant / mot de passe + ENT)
+
+### Principe général
+Connexion via le protocole propriétaire de Pronote (JSON sur HTTPS), avec **chiffrement AES-CBC utilisant une clé dérivée par MD5 (16 octets, soit AES-128) comme implémenté dans pronotepy 2.15.7** et mécanisme de défi-réponse. Utilisé par l'interface web.
+
+✅ **Statut** : **Observé dans le code local** (délégable à pronotepy via `ParentClient` ou `Client`).
+
+### Flux d'authentification
+1. **Initialisation** : Requête GET vers `/pronote/{espace}.html` (ex. `parent.html`).
+    - Récupère `h` (ID de session), `a` (ID espace), `sCrA`/`sCoA` (drapeaux chiffrement/compression).
+2. **Échange de clés** : Requête POST vers `/pronote/appelfonction/{a}/{h}/{numeroOrdre}`.
+3. **Identification** : Soumission de `identifiant`, `genreConnexion=0`, `genreEspace={a}`.
+4. **Résolution du défi** :
+    - Calcul de `mtp = MAJUSCULE(HEX(SHA256(alea + mot_de_passe)))`.
+    - Dérivation de `key_challenge = MD5(nom_utilisateur + mtp)`.
+    - Déchiffrement du `challenge` avec **AES-CBC utilisant une clé dérivée par MD5 (16 octets, soit AES-128)**.
+5. **Authentification** : Soumission de la réponse au défi.
+
+🔹 **Source** : 🔍 Observé dans le code local de `pronotepy` 2.15.7 (module `clients.py` et `pronoteAPI.py`, vérifié le 2026-09-12).
+
+### Intégration dans `pronote-sync`
+- **Paramètres** :
+  - `PRONOTE_URL` (ex. `.env.example` ligne 3).
+  - `PRONOTE_USERNAME`, `PRONOTE_PASSWORD`.
+  - `PRONOTE_ENT` (slug dans `_ENT_NAMES`).
+  - `PRONOTE_ACCOUNT_TYPE` (ex. `parent`).
+- **Comportement** :
+  - Utilise `pronotepy.ParentClient` pour les comptes parents.
+  - **Repli** : Si iCal échoue en mode `auto`, `pronotepy` est utilisé.
+  - **Pas de repli** si `PRONOTE_AGENDA_SOURCE=pronotepy` (échec explicite).
+
+🔹 **Source** : 🔍 `pronote_sync/sources/pronote/client.py` (méthode `_connect_password`).
+
+### ENT supportés
+Liste **fermée** des **30 ENT** résolubles (lignes 52–83 de `pronote_sync/sources/pronote/client.py`) :
+```python
+_monbureaunumerique, ent_elyco, bordeaux, ent_creuse, occitanie_montpellier, ...
+```
+
+⚠️ **Hypothèse à valider** : Les ENT non listés nécessitent une contribution à `pronotepy`.
+
+🔹 **Source** : 🔍 Code source local de `pronote-sync` (2026-09-12).
+
+---
+
+## Méthode 3 : QR Code + token mobile (pour `pronote-sync`)
+
+### Principe général
+Mécanisme d'appairage par QR code pour les appareils mobiles, **contournant l'authentification ENT/EduConnect**. Le QR code est généré **depuis l'interface web Pronote, espace parent → paramètres → QR code**, puis utilisé avec un **PIN à 4 chiffres** pour obtenir un token dont la durée dépend de l'instance/serveur.
+
+✅ **Statut** : **Pris en charge** par `pronote-sync` (mode `PRONOTE_AUTH_MODE=qr_token`).
+
+### Procédure QR pour `pronote-sync`
+
+#### Étape 1 : Génération du QR code (interface web)
+1. Se connecter à Pronote via un navigateur (espace **Parent**).
+2. Aller dans **Paramètres → Accès mobile / Application mobile**.
+3. Définir un **PIN temporaire à 4 chiffres**.
+4. Pronote affiche un **QR code** contenant un JSON avec les clés :
+     `login`, `jeton`, et `url` (ex. `https://[host]/pronote/mobile.parent.html`).
+     **Le fichier JSON réel contient des identifiants chiffrés et ne doit jamais être copié, partagé, ou committé.**
+  5. **Exporter le QR code** :
+     - Sauvegardez le fichier JSON localement ou scannez-le avec un appareil.
+     - **Ne jamais partager** le JSON ou le PIN.
+     - **Le fichier JSON du QR code contient des identifiants chiffrés : ne jamais le coller dans la documentation ni le committer.**
+
+🔹 **Source** : 🔍 Observé localement dans l'interface web Pronote (version non spécifiée, hypothèse à valider).
+
+#### Étape 2 : Configuration de `pronote-sync`
+1. **Enregistrer le QR code** :
+    - Sauvegarder le JSON dans un fichier (ex. `/path/to/qr_code.json`).
+    - **Permissions** : `chmod 600 /path/to/qr_code.json`.
+2. **Configurer `.env`** :
+    ```ini
+    PRONOTE_AUTH_MODE=qr_token
+    PRONOTE_QR_CODE_FILE=/path/to/qr_code.json
+    PRONOTE_QR_PIN=  # renseigner localement la valeur secrète du PIN (jamais committée)
+    ```
+    **⚠️ Note** : `.env.example` ne doit **jamais** contenir de PIN concret.
+
+🔹 **Source** : 🔍 Observé dans `.env.example` (lignes 21–25) et `pronote_sync/sources/pronote/client.py`.
+
+#### Étape 3 : Premier login (enrôlement)
+1. `pronote-sync` lit `PRONOTE_QR_CODE_FILE` et `PRONOTE_QR_PIN`.
+2. Appel à `pronotepy.ParentClient.qrcode_login(qr_code, pin, uuid)` :
+    - `qr_code` : JSON du fichier QR.
+    - `pin` : PIN à 4 chiffres.
+    - `uuid` : UUID permanent généré par `pronote-sync` (ex. `pronote-sync-{uuid4()}`).
+3. **Déchiffrement** :
+    - Algorithme : **AES-CBC utilisant une clé dérivée par MD5 (16 octets, soit AES-128)**.
+    - Clé : `MD5(PIN)` (dérivée du PIN secret).
+    - IV : 16 octets nuls.
+    - Résultat : `login` et `jeton` en clair.
+4. **Échange de token** : Pronote retourne un `jetonConnexionAppliMobile` (token dont la durée dépend de l'instance/serveur).
+5. **Persistance** : `pronote-sync` sauvegarde les credentials via `export_credentials()` dans `.pronote_auth_state.json` (mode `0600`).
+
+🔹 **Source** : 🔍 Observé dans le code local de `pronotepy` 2.15.7 (`clients.py` lignes 181–189) + `pronote_sync/sources/pronote/client.py` (méthode `_enroll_qr_code`).
+
+#### Étape 4 : Connexions ultérieures (auto-login)
+1. `pronote-sync` charge `.pronote_auth_state.json`.
+2. Appel à `pronotepy.ParentClient.token_login(**credentials)` :
+    - `pronote_url`, `username`, `password` (token), `uuid`.
+3. **Rotation du token** : Le token est **remplacé uniquement si le serveur renvoie `jetonConnexionAppliMobile`** (observé dans `pronotepy` 2.15.7, `clients.py:382–387`).
+4. **Persistance** : Les credentials sont sauvegardés dans `.pronote_auth_state.json` après chaque opération réussie.
+
+🔹 **Source** : 🔍 Observé dans le code local de `pronotepy` 2.15.7 (`clients.py` lignes 245–280) + `pronote_sync/sources/pronote/client.py` (méthode `_connect_qr_token`).
+
+### Cycle de vie des tokens
+- **QR code** : Valide **~10 minutes** après génération (⚠️ **Hypothèse à valider** : cette durée n'est attestée que par un message d'exception dans `pronotepy` et n'est pas une garantie officielle/indépendante de l'instance).
+- **`jetonConnexionAppliMobile`** :
+  - Durée **dépendante de l'instance/serveur** (observation du 2026-09-12, hypothèse : peut persister jusqu'à la fin de l'année scolaire, non garanti).
+  - **Remplacé uniquement si le serveur renvoie `jetonConnexionAppliMobile`** (observé dans `pronotepy` 2.15.7, `clients.py:382–387`).
+  - **Révocable** manuellement dans Pronote (Paramètres → Accès mobile).
+
+🔹 **Source** : ⚠️ Comportement variable selon les instances (à tester localement).
+
+### Sécurité
+1. **Fichiers sensibles** :
+   - `.pronote_auth_state.json` : **Ne jamais versionner** (couvert par `.gitignore`).
+   - `PRONOTE_QR_CODE_FILE` : **Ne jamais committer** (ex. dans Git).
+2. **Secrets** :
+   - Le PIN et le contenu du QR code sont **masqués** dans les logs (via `redact_secrets()`).
+   - Les exceptions sont **expurgées** (via `redact_exception()`).
+3. **Recommandations** :
+   - Utiliser un **PIN robuste** (éviter les codes simples comme `0000` ou des séquences évidentes).
+   - **Révoquer** le token en cas de compromission (via Pronote web).
+
+🔹 **Source** : 🔍 `pronote_sync/utils/redaction.py` + `pronote_sync/sources/pronote/client.py` (méthode `_collect_auth_secrets`).
+
+### Erreurs et repli
+- **`PronoteAuthRotationError`** : Levée si :
+  - Le token persisté est **invalide/expiré**.
+  - Le fichier QR ou le PIN est **manquant/invalide**.
+- **Action requise** :
+  1. Supprimer `.pronote_auth_state.json`.
+  2. Générer un **nouveau QR code depuis l'interface web Pronote, espace parent**.
+  3. Relancer `pronote-sync`.
+
+🔹 **Source** : 🔍 Observé dans `pronote_sync/errors.py` + `pronote_sync/sources/pronote/client.py` (lignes 346–364).
+
+### Incompatibilités
+- **Mode `dry-run`** : **Incompatible** avec `PRONOTE_AUTH_MODE=qr_token` (risque de désynchronisation du token local).
+  - `pronote-sync --dry-run` **refuse** le mode `qr_token` avant toute connexion.
+
+🔹 **Source** : 🔍 `docs/exploitation.md` (ligne 65–66).
+
+---
+
+## Annexe A : Bibliothèques tierces
+
+| Bibliothèque | Langage | Dépôt | Méthodes supportées | Statut dans `pronote-sync` |
+|--------------|---------|-------|---------------------|-----------------------------|
+| **pronotepy** | Python | [bain3/pronotepy](https://github.com/bain3/pronotepy) | Connexion directe, QR code/token, **30 ENT** (liste fermée) | ✅ **Dépendance principale** (version **2.15.7** vérifiée). |
+| **pronote-api** | TypeScript | [Litarvan/pronote-api](https://github.com/Litarvan/pronote-api) | Connexion directe, CAS, ENT | ❌ Non utilisée. |
+| **pronote-qrcode-api** | JavaScript | [Androz2091/pronote-qrcode-api](https://github.com/Androz2091/pronote-qrcode-api) | Déchiffrement QR code | ❌ Non utilisée (intégration native via `pronotepy`). |
+
+🔹 **Source** : 🔍 Observé dans `pyproject.toml` (dépendances) + code source local (2026-09-12).
+
+---
+
+## Annexe B : Tableau comparatif synthétique
+
+| Méthode | Périmètre | Identifiants | Expiration | Complexité | Statut dans `pronote-sync` |
+|---------|-----------|--------------|------------|-----------|-----------------------------|
+| **URL iCal sécurisée** | EDT + devoirs (si inclus dans le flux) | Jeton URL | Longue durée (dépend de l'instance) | Très faible | ✅ Pris en charge |
+| **Connexion directe (mot de passe + ENT)** | Agenda/EDT, devoirs, messages | Identifiant + mot de passe + ENT | Session dépendante de l'instance | Élevée | ✅ Pris en charge |
+| **QR Code + token mobile** | Agenda/EDT, devoirs, messages | PIN 4 chiffres → token + UUID | QR ~10 min (⚠️ hypothèse) ; token dépendant de l'instance | Modérée | ✅ Pris en charge |
+| **SSO ENT (CAS/SAML)** | — | Identifiants ENT | Session ENT | Très élevée | ❌ Non implémenté (seuls les 30 ENT de la liste fermée `_ENT_NAMES` sont supportés via `pronotepy`) |
+| **EduConnect** | — | Identifiants nationaux | Session EduConnect | Très élevée | ❌ Non implémenté |
+| **CAS direct** | — | Identifiants CAS | Ticket single-use | Modérée | ❌ Non implémenté |
+| **API publique** | N/A | N/A | N/A | N/A | ❌ Inexistante |
+
+**Légende** :
+- *Périmètre* : Les méthodes **iCal** sont en lecture seule (EDT + devoirs si inclus dans le flux). Les méthodes **Connexion directe** et **QR Code + token mobile** permettent les opérations `pronotepy` effectivement implémentées par ce projet (agenda, devoirs, messages ; informations ignorées en mode `qr_token`).
+- *QR ~10 min* : ⚠️ **Hypothèse non vérifiée** (observé dans `pronotepy` via un message d'exception, dépend de l'instance).
+- *Session dépendante de l'instance* : ⚠️ **Hypothèse non vérifiée** (nécessite un essai réel).
+
+---
+
+## Annexe C : Écarts et notes de cohérence
+
+### Alignement avec `.env.example`
+| Paramètre | Document | Code | Statut |
+|-----------|----------|------|--------|
+| `PRONOTE_ICAL_URL` | ✅ Lignes 2, 42–50 | ✅ `sources/ical.py` | **Cohérent** |
+| `PRONOTE_URL` | ✅ Ligne 3 | ✅ `client.py` (ligne 294) | **Cohérent** |
+| `PRONOTE_ENT` | ✅ Ligne 7 | ✅ `client.py` (ligne 297, `_ENT_NAMES`) | **Cohérent** |
+| `PRONOTE_AUTH_MODE=qr_token` | ✅ Ligne 23 | ✅ `client.py` (ligne 334) | **Cohérent** |
+| `PRONOTE_QR_CODE_FILE` | ✅ Ligne 24 | ✅ `client.py` (ligne 387) | **Cohérent** |
+| `PRONOTE_QR_PIN` | ✅ Ligne 25 | ✅ `client.py` (ligne 388) | **Cohérent** |
+| *« Le QR code se génère sur le site web »* | ✅ Ligne 21 | ✅ Section [Procédure QR](#procédure-qr-pour-pronote-sync) | **Cohérent** |
+
+### Écarts avec `docs/exploitation.md`
+| Élément | `exploitation.md` | Ce document | Action |
+|---------|-------------------|-------------|--------|
+| *« Le QR code expire ~10 minutes »* | Ligne 22 | ⚠️ **Hypothèse non vérifiée** (section [Cycle de vie](#cycle-de-vie-des-tokens)) | **Aucune** (hors périmètre). |
+| *« Mode `qr_token` incompatible avec dry-run »* | Lignes 65–66 | ✅ Section [Incompatibilités](#incompatibilités) | **Cohérent** |
+| *« Fichier `.pronote_auth_state.json` (mode 0600) »* | Lignes 70–75 | ✅ Section [Sécurité](#sécurité) | **Cohérent** |
+
+---
+
+## Glossaire
+
+| Terme | Définition |
+|-------|------------|
+| **ENT** | Espace Numérique de Travail (ex. Mon Bureau Numérique, Paris Classe Numérique). |
+| **Jeton `icalsecurise`** | Token secret intégré dans l'URL iCal, équivalent à un mot de passe. |
+| **`jetonConnexionAppliMobile`** | Token obtenu après appairage QR code, dont la durée dépend de l'instance/du serveur et n'est pas garantie. |
+| **UUID** | Identifiant unique permanent pour l'application (ex. `pronote-sync-{uuid4()}`). |
+| **PIN** | Code à 4 chiffres défini lors de la génération du QR code. |
+
+---
+
+## Historique des révisions
+
+| Date | Auteur | Modifications |
+|------|--------|---------------|
+| 2026-09-12 | Agent tech-writer | Refonte complète : qualification des affirmations, ajout des sources, tableau de compatibilité, procédure QR alignée sur pronotepy 2.15.7. |
+| 2026-09-12 | Agent tech-writer | Corrections suite à revue indépendante (ticket #10) : précision cryptographie (AES-128), qualification des sources, alignement nombre d'ENT (30), clarification SSO/CAS, exemples non copiables, note d'essai réel. |
+| 2026-09-12 | Agent tech-writer | Corrections suite à revue ticket #10 : suppression de tous les placeholders de secrets remplacés par de la prose descriptive ; clarification du périmètre réel des méthodes d'authentification (accès limité aux opérations implémentées) ; qualification de la durée du token `jetonConnexionAppliMobile` comme dépendante de l'instance/serveur et non garantie.

docs/pronote-auth.tex

@@ -0,0 +1,56 @@
+%!TEX TS-program = lualatex
+%!TEX encoding = UTF-8 Unicode
+%% =============================================================================
+%% FICHIER       : pronote-auth.tex
+%% DESCRIPTION   : Manuel technique & académique — Authentification Pronote
+%% TITRE         : Authentification Pronote — Référence technique
+%% AUTEUR        : Équipe Architecture & Sécurité
+%% DATE          : Septembre 2026
+%%
+%% INSTRUCTIONS DE COMPILATION :
+%%   Ce document est conçu pour être compilé avec LuaLaTeX :
+%%     lualatex -interaction=nonstopmode docs/pronote-auth.tex
+%%     lualatex -interaction=nonstopmode docs/pronote-auth.tex
+%%   (Deux passes nécessaires pour la génération de la table des matières,
+%%    des références croisées et des hyperliens).
+%%
+%% CHOIX TYPOGRAPHIQUES & DESIGN :
+%%   1. Police Principale (Sérif) : EB Garamond
+%%      Justification : Référence historique et académique de la typographie
+%%      française, apportant élégance, chaleur et excellente lisibilité sur
+%%      papier ou écran haute densité.
+%%   2. Police Sans-Sérif : Carlito (compatible métriquement Calibri)
+%%      Justification : Modernité sobre, sans empattement, idéale pour les
+%%      titres techniques, étiquettes de tableaux et métadonnées.
+%%   3. Police Chasse Fixe (Monospace) : DejaVu Sans Mono
+%%      Justification : Rendu précis des glyphes informatiques, alignement
+%%      parfait pour les algorithmes, JSON et requêtes HTTP.
+%%   4. Palette Chromatique : Palette "Bleu Institutionnel & Ardoise"
+%%      - primaryNavy (#142D55) : Titres, identité principale, reliure visuelle
+%%      - secondarySlate (#465F7D) : Sous-titres, filets, structure
+%%      - accentSteel (#007396) : Liens hypertexte, repères visuels
+%%      - Teintes fonctionnelles douces pour encadrés et callouts.
+%% =============================================================================
+
+\input{preamble}
+
+\begin{document}
+
+\input{frontmatter}
+
+\include{ch-introduction}
+\include{ch-overview}
+\include{ch-method1}
+\include{ch-method2}
+\include{ch-method3}
+\include{ch-method4}
+\include{ch-method5}
+\include{ch-method6}
+\include{ch-method7}
+
+\appendix
+
+\include{annex-libraries}
+\include{annex-comparison}
+
+\end{document}

pronote_sync/channels/xmpp.py

@@ -36,6 +36,24 @@ logger = logging.getLogger(__name__)
 __all__ = ["XmppChannel", "SyncXmppChannel", "XmppMessage"]
 
 
+async def _cancel_pending(
+    *futures: asyncio.Future[bool],
+) -> None:
+    """Annule les futures/tâches encore en attente et supprime le bruit.
+
+    À appeler avant chaque retour anticipé de :meth:`XmppChannel.send_async`
+    afin qu'aucune tentative de connexion ne survive au retour de la méthode.
+
+    :param futures: Futures ou tâches à annuler (les déjà terminées sont
+        ignorées pour la cancellation mais attendues pour purger l'attente).
+    :rtype: None
+    """
+    for future in futures:
+        if not future.done():
+            future.cancel()
+    await asyncio.gather(*futures, return_exceptions=True)
+
+
 def _secret_values(settings: XmppSettings) -> tuple[SecretStr | str, ...]:
     """Rassemble les secrets du canal XMPP pour le masquage des logs.
 
@@ -220,11 +238,14 @@ class XmppChannel:
         """Exécute le flux asynchrone d'envoi XMPP (U2).
 
         Connecte le client ``slixmpp`` avec un hôte et un port explicites,
-        configure TLS avant la connexion, puis attend l'un des événements
+        configure TLS avant la connexion selon ``tls_mode`` (``direct``,
-        ``session_start``, ``failed_auth`` ou ``disconnected`` sous un
+        ``starttls`` ou ``disabled``), attend la connexion sous
-        timeout unique avant d'envoyer un message direct ``chat`` au
+        ``connect_timeout`` puis l'un des événements ``session_start``,
+        ``failed_auth``, ``connection_failed`` ou ``disconnected`` sous
+        ``timeout`` avant d'envoyer un message direct ``chat`` au
         destinataire configuré. La déconnexion est garantie par un bloc
-        ``try/finally``. Aucun secret n'est journalisé (SEC-XMPP-02).
+        ``try/finally`` borné par ``cleanup_timeout``. Aucun secret n'est
+        journalisé (SEC-XMPP-02).
 
         :param message: Message final à envoyer.
         :return: ``True`` si l'envoi a réussi (ou a été simulé en dry-run),
@@ -244,55 +265,132 @@ class XmppChannel:
             logger.warning("Destinataire XMPP manquant.")
             return False
 
-        # Create typed client
+        # Client typed lazily: the construction is done inside the try block so that
-        client = ClientXMPP(
+        # any error is caught and converted to ``False`` (channel contract: never raise)
-            jid_str,
+        client: ClientXMPP | None = None
-            self.settings.password.get_secret_value() if self.settings.password else "",
-        )
-
-        # Configure TLS BEFORE connect
-        if self.settings.use_tls:
-            # TLS direct (port 5223 typically)
-            client.enable_direct_tls = True
-            client.enable_starttls = False
-        else:
-            # STARTTLS (port 5222 typically)
-            client.enable_starttls = True
-            client.enable_direct_tls = False
-
-        # Register handlers
         session_future: asyncio.Future[bool] = asyncio.get_event_loop().create_future()
+        failure_kind = "disconnected"
+        # Declared before the ``try`` so the exception handlers (CancelledError and
+        # Exception) can cancel any task still pending from ``asyncio.wait()``
+        connect_future: asyncio.Future[bool] | None = None
+        session_task: asyncio.Future[bool] | None = None
 
         def on_session_start(event: object) -> None:
             if not session_future.done():
                 session_future.set_result(True)
 
         def on_failed_auth(event: object) -> None:
+            nonlocal failure_kind
             if not session_future.done():
+                failure_kind = "failed_auth"
+                session_future.set_result(False)
+
+        def on_connection_failed(event: object) -> None:
+            nonlocal failure_kind
+            if not session_future.done():
+                failure_kind = "connection_failed"
                 session_future.set_result(False)
 
         def on_disconnected(event: object) -> None:
             if not session_future.done():
                 session_future.set_result(False)
 
-        client.add_event_handler("session_start", on_session_start)
-        client.add_event_handler("failed_auth", on_failed_auth)
-        client.add_event_handler("disconnected", on_disconnected)
-
         try:
+            # Create typed client
+            client = ClientXMPP(
+                jid_str,
+                self.settings.password.get_secret_value() if self.settings.password else "",
+            )
+
+            # Configure TLS BEFORE connect (canonical tls_mode)
+            match self.settings.tls_mode:
+                case "direct":
+                    client.enable_direct_tls = True
+                    client.enable_starttls = False
+                case "starttls":
+                    client.enable_direct_tls = False
+                    client.enable_starttls = True
+                case "disabled":
+                    client.enable_direct_tls = False
+                    client.enable_starttls = False
+
+            # Register handlers
+            client.add_event_handler("session_start", on_session_start)
+            client.add_event_handler("failed_auth", on_failed_auth)
+            client.add_event_handler("connection_failed", on_connection_failed)
+            client.add_event_handler("disconnected", on_disconnected)
+
             # Connect with explicit host and port
-            connect_future = client.connect(self.settings.host, self.settings.port)
+            connect_future = asyncio.ensure_future(
-            await connect_future  # connect() returns a Future, not a coroutine
+                client.connect(self.settings.host, self.settings.port)
+            )
 
-            # Wait for one of the three events under a single timeout
+            # Wrap the session future in a task so that cancelling pending tasks
-            try:
+            # during the concurrent wait never cancels ``session_future`` itself
-                success = await asyncio.wait_for(session_future, timeout=self.settings.timeout)
+            async def _await_session() -> bool:
-            except TimeoutError:
+                return await session_future
-                logger.warning("Délai d'attente de session XMPP dépassé.")
-                return False
 
-            if not success:
+            session_task = asyncio.ensure_future(_await_session())
-                logger.warning("Échec d'authentification ou déconnexion XMPP.")
+
+            # Wait for the connection and the session event concurrently, bounded by
+            # connect_timeout as the global time limit: a ``connection_failed`` event
+            # can thus trigger an early return before the connect timeout expires
+            done, _pending = await asyncio.wait(
+                {connect_future, session_task},
+                timeout=self.settings.connect_timeout,
+                return_when=asyncio.FIRST_COMPLETED,
+            )
+
+            if session_task in done:
+                if not session_future.result():
+                    # ``connection_failed``/``failed_auth``/``disconnected`` fired
+                    # before the connection was resolved: immediate failure (fail fast)
+                    if failure_kind == "connection_failed":
+                        logger.warning("Échec de connexion réseau XMPP.")
+                    else:
+                        logger.warning("Échec d'authentification ou déconnexion XMPP.")
+                    await _cancel_pending(connect_future, session_task)
+                    return False
+                # ``session_start`` fired: the connection succeeded even if the
+                # connect future is still pending; proceed to send the message
+                await _cancel_pending(connect_future, session_task)
+            elif connect_future in done:
+                # The connection resolved: surface a connect error (redacted) if any
+                if not connect_future.cancelled():
+                    connect_exc = connect_future.exception()
+                    if connect_exc is not None and isinstance(connect_exc, Exception):
+                        logger.warning(
+                            "Échec de connexion XMPP : %s",
+                            redact_exception(
+                                connect_exc,
+                                extra_secrets=_secret_values(self.settings),
+                            ),
+                        )
+                        await _cancel_pending(connect_future, session_task)
+                        return False
+
+                # Connection established: wait for a session event under ``timeout``
+                try:
+                    success = await asyncio.wait_for(
+                        asyncio.shield(session_future), timeout=self.settings.timeout
+                    )
+                except TimeoutError:
+                    logger.warning("Délai d'attente de session XMPP dépassé.")
+                    await _cancel_pending(connect_future, session_task)
+                    return False
+                if not success:
+                    if failure_kind == "connection_failed":
+                        logger.warning("Échec de connexion réseau XMPP.")
+                    else:
+                        logger.warning("Échec d'authentification ou déconnexion XMPP.")
+                    await _cancel_pending(connect_future, session_task)
+                    return False
+            else:
+                # connect_timeout expired: cancel everything and fail fast
+                logger.warning(
+                    "Délai de connexion XMPP dépassé (%ss).", self.settings.connect_timeout
+                )
+                await _cancel_pending(connect_future, session_task)
                 return False
 
             # Send the message
@@ -300,19 +398,39 @@ class XmppChannel:
             client.send_message(mto=JID(self.settings.to), mbody=formatted, mtype="chat")
             return True
 
+        except asyncio.CancelledError:
+            # Contrat du canal : toujours retourner un booléen, même en cas
+            # d'annulation de la tâche appelante (cleanup exécuté par le finally).
+            logger.debug("Envoi XMPP annulé avant la fin de l'opération.")
+            pending = [f for f in (connect_future, session_task) if f is not None]
+            if pending:
+                await _cancel_pending(*pending)
+            return False
         except Exception as exc:
-            redacted = redact_exception(exc)
+            redacted = redact_exception(exc, extra_secrets=_secret_values(self.settings))
             extra = _secret_values(self.settings)
             logger.warning("Erreur XMPP: %s", redact_secrets(redacted, extra_secrets=extra))
+            pending = [f for f in (connect_future, session_task) if f is not None]
+            if pending:
+                await _cancel_pending(*pending)
             return False
         finally:
-            try:
+            if client is not None:
-                disconnect_future = client.disconnect()
+                try:
-                await disconnect_future
+                    disconnect_future = client.disconnect()
-            except Exception as cleanup_exc:
+                    await asyncio.wait_for(disconnect_future, timeout=self.settings.cleanup_timeout)
-                logger.debug(
+                except asyncio.CancelledError:
-                    "Erreur lors de la déconnexion XMPP: %s", redact_exception(cleanup_exc)
+                    logger.debug("Déconnexion XMPP annulée.")
-                )
+                except TimeoutError:
+                    logger.debug(
+                        "Délai de déconnexion XMPP dépassé (%ss), abandon.",
+                        self.settings.cleanup_timeout,
+                    )
+                except Exception as cleanup_exc:
+                    logger.debug(
+                        "Erreur lors de la déconnexion XMPP : %s",
+                        redact_exception(cleanup_exc, extra_secrets=_secret_values(self.settings)),
+                    )
 
 
 class SyncXmppChannel:
@@ -363,7 +481,7 @@ class SyncXmppChannel:
         try:
             return asyncio.run(self._channel.send_async(message))
         except Exception as exc:
-            redacted = redact_exception(exc)
+            redacted = redact_exception(exc, extra_secrets=_secret_values(self.settings))
             redacted = redact_secrets(redacted, extra_secrets=_secret_values(self.settings))
             logger.warning("XMPP : erreur lors de l'envoi synchrone : %s", redacted)
             return False

pronote_sync/cli/main.py

@@ -32,7 +32,10 @@ def _parse_arguments(arguments: Sequence[str] | None = None) -> argparse.Namespa
         "--dry-run",
         action="store_true",
         default=None,
-        help="Simule la synchronisation sans écrire vers CalDAV ni XMPP.",
+        help=(
+            "Simule la synchronisation sans sortie distante ni état local persistant "
+            "(incompatible avec PRONOTE_AUTH_MODE=qr_token)."
+        ),
     )
     parser.add_argument(
         "--log-level",

pronote_sync/config/settings.py

@@ -8,6 +8,7 @@ depuis les variables d'environnement (préfixées par groupe) et le fichier
 
 from __future__ import annotations
 
+import warnings
 from datetime import date
 from typing import Literal
 from urllib.parse import urlparse
@@ -18,6 +19,7 @@ from pydantic import (
     ValidationInfo,
     field_serializer,
     field_validator,
+    model_validator,
 )
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
@@ -37,11 +39,14 @@ class PronoteSettings(BaseSettings):
     username: str | None = None
     password: SecretStr | None = None
     ent: str | None = None
-    pronote_url: str | None = None
+    url: str | None = None
     account_type: Literal["student", "parent"] = "parent"
     agenda_source: Literal["auto", "ical", "pronotepy"] = "auto"
     homework_source: Literal["auto", "ical", "pronotepy"] = "auto"
     messages_source: Literal["pronotepy"] = "pronotepy"
+    auth_mode: Literal["password", "qr_token"] = "password"
+    qr_code_file: str | None = None
+    qr_pin: SecretStr | None = None
 
     @field_serializer("ical_url")
     def _serialize_ical_url(self, value: SecretStr | None) -> str | None:
@@ -55,6 +60,18 @@ class PronoteSettings(BaseSettings):
             return None
         return "**********"
 
+    @field_serializer("qr_pin")
+    def _serialize_qr_pin(self, value: SecretStr | None) -> str | None:
+        """Masque le code PIN QR lors de la sérialisation (repr, str, JSON).
+
+        :param value: Valeur du champ ``qr_pin``.
+        :return: ``"**********"`` si la valeur est définie, ``None`` sinon.
+        :rtype: str | None
+        """
+        if value is None:
+            return None
+        return "**********"
+
 
 class CalDAVSettings(BaseSettings):
     """Paramètres d'accès au serveur CalDAV de destination.
@@ -143,10 +160,16 @@ class XmppSettings(BaseSettings):
     Contraintes de champs : ``port`` est borné entre 1 et 65535 et ``timeout``
     doit être strictement positif.
 
-    Politique TLS : la désactivation de TLS (``use_tls`` à ``False``) n'est
+    Politique TLS : le mode ``tls_mode`` détermine la négociation TLS
-    autorisée que sur un hôte de boucle locale (``localhost``, ``127.0.0.1``,
+    (``direct``, ``starttls`` ou ``disabled``). Le mode ``disabled`` n'est
-    ``::1``). Dans tout autre cas, une erreur de validation est levée,
+    autorisé que sur un hôte de boucle locale (``localhost``, ``127.0.0.1``,
-    indépendamment de l'état du champ ``enabled``.
+    ``::1``) ; ``starttls`` et ``direct`` sont permis pour tous les hôtes.
+
+    Compatibilité : le champ historique ``use_tls`` (booléen) est un alias
+    obsolète ; ``use_tls=True`` mappe vers ``tls_mode="direct"`` et
+    ``use_tls=False`` vers ``tls_mode="starttls"``, avec un
+    :pyexc:`DeprecationWarning`. La valeur brute fournie reste lisible via
+    ``use_tls`` (``None`` si non fournie).
     """
 
     model_config = SettingsConfigDict(
@@ -163,33 +186,61 @@ class XmppSettings(BaseSettings):
     port: int = Field(default=5222, ge=1, le=65535)
     to: str | None = None
     resource: str = "pronote-sync"
-    use_tls: bool = True
+    tls_mode: Literal["direct", "starttls", "disabled"] = "starttls"
-    timeout: int = Field(default=30, gt=0)
+    use_tls: bool | None = Field(
+        default=None,
+        deprecated="Utiliser tls_mode à la place (XMPP_USE_TLS obsolète).",
+    )
+    timeout: float = Field(default=30, gt=0)
+    connect_timeout: float = Field(default=15, gt=0)
+    cleanup_timeout: float = Field(default=10, gt=0)
 
-    @field_validator("use_tls")
+    @model_validator(mode="before")
     @classmethod
-    def _validate_tls_policy(cls, v: bool, info: ValidationInfo) -> bool:
+    def _migrate_use_tls(cls, data: object) -> object:
-        """Refuse la désactivation de TLS hors des hôtes de boucle locale.
+        """Mappe l'alias obsolète ``use_tls`` vers le mode canonique ``tls_mode``.
 
-        La règle s'applique quel que soit l'état du champ ``enabled``. Le
+        ``use_tls=True`` devient ``tls_mode="direct"`` et ``use_tls=False``
-        message d'erreur ne contient aucune valeur sensible (``jid``,
+        devient ``tls_mode="starttls"`` ; un :pyexc:`DeprecationWarning` est
+        émis à chaque usage explicite de l'alias. ``tls_mode`` fourni
+        explicitement prend le pas sur l'alias.
+
+        :param data: Données d'entrée du modèle (dict ou autre).
+        :return: Données d'entrée avec ``tls_mode`` dérivé de ``use_tls``.
+        :rtype: object
+        """
+        if not isinstance(data, dict) or "use_tls" not in data:
+            return data
+        warnings.warn(
+            "XMPP_USE_TLS est obsolète : utiliser XMPP_TLS_MODE "
+            "('direct', 'starttls' ou 'disabled').",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        if data.get("tls_mode") is None:
+            data["tls_mode"] = "direct" if data["use_tls"] else "starttls"
+        return data
+
+    @model_validator(mode="after")
+    def _validate_tls_policy(self) -> XmppSettings:
+        """Refuse le mode ``disabled`` hors des hôtes de boucle locale.
+
+        La règle s'applique quel que soit l'état du champ ``enabled``. Les
+        modes ``starttls`` et ``direct`` sont autorisés pour tous les hôtes.
+        Le message d'erreur ne contient aucune valeur sensible (``jid``,
         ``password``, ``to``).
 
-        :param v: Valeur du champ ``use_tls`` à valider.
+        :return: L'instance validée inchangée.
-        :param info: Contexte de validation (accès aux autres champs).
+        :rtype: XmppSettings
-        :return: La valeur validée inchangée.
+        :raises ValueError: Si ``tls_mode`` est ``disabled`` et que ``host``
-        :rtype: bool
-        :raises ValueError: Si ``use_tls`` est ``False`` et que ``host``
             n'est pas un hôte de boucle locale.
         """
-        if v is False:
+        if self.tls_mode == "disabled" and self.host not in _XMPP_LOOPBACK_HOSTS:
-            host = info.data.get("host", "")
+            raise ValueError(
-            if host not in _XMPP_LOOPBACK_HOSTS:
+                "TLS désactivé n'est autorisé que sur les hôtes de loopback "
-                raise ValueError(
+                "(localhost, 127.0.0.1, ::1)."
-                    "TLS désactivé n'est autorisé que sur les hôtes de loopback "
+            ) from None
-                    "(localhost, 127.0.0.1, ::1)."
+        return self
-                ) from None
-        return v
 
 
 class AISettings(BaseSettings):
@@ -266,8 +317,9 @@ class Settings(BaseSettings):
         """Énumère tous les secrets configurés pour la rédaction.
 
         Collecte les valeurs :class:`pydantic.SecretStr` non vides présentes
-        dans les sous-configurations (Pronote, CalDAV, XMPP, IA). Les valeurs
+        dans les sous-configurations (URL iCal, mots de passe, code PIN QR et
-        vides ou ``None`` sont filtrées ; les doublons sont supprimés.
+        clé API IA). Les valeurs vides ou ``None`` sont filtrées ; les
+        doublons sont supprimés.
 
         :return: Tuple de secrets à masquer dans les messages d'erreur.
         :rtype: tuple[SecretStr, ...]
@@ -275,6 +327,7 @@ class Settings(BaseSettings):
         secrets = [
             self.pronote.ical_url,
             self.pronote.password,
+            self.pronote.qr_pin,
             self.caldav.url,
             self.caldav.password,
             self.xmpp.password,

pronote_sync/errors.py

@@ -21,6 +21,38 @@ class PronoteSyncError(Exception):
         self.message = message
 
 
+class PronoteAuthRotationError(PronoteSyncError):
+    """Erreur de rotation du token d'authentification pronotepy (QR code / token).
+
+    Levée quand le token persisté est invalide ou expiré et qu'un ré-enrôlement
+    manuel (suppression du fichier d'état + nouveau QR code) est nécessaire.
+
+    :ivar message: Message décrivant l'action à effectuer, sans secret.
+    """
+
+    def __init__(self, message: str) -> None:
+        """Initialise l'erreur de rotation.
+
+        :param message: Message actionnable sans secret (PIN, token, URL).
+        """
+        super().__init__(message)
+
+
+class PronoteAuthStateLockError(PronoteSyncError):
+    """Erreur levée lorsqu'un autre processus détient l'état d'authentification.
+
+    Cette erreur indique qu'une opération QR code / token concurrente est en
+    cours. Son message ne contient ni chemin local sensible ni credential.
+    """
+
+    def __init__(self, message: str) -> None:
+        """Initialise l'erreur de contention du verrou d'état.
+
+        :param message: Message actionnable expurgé décrivant la contention.
+        """
+        super().__init__(message)
+
+
 class ErrorSeverity(StrEnum):
     """Niveau de gravité d'une erreur produite par le pipeline."""
 

pronote_sync/models/agenda.py

@@ -52,6 +52,7 @@ class Lesson(BaseModel):
     teachers: tuple[str, ...] = Field(default=(), description="Liste des professeurs")
     rooms: tuple[str, ...] = Field(default=(), description="Liste des salles")
     group: str | None = Field(None, description="Groupe (ex: Classe entière)")
+    class_part: str | None = None
     status: LessonStatus = Field(default=LessonStatus.NORMAL, description="Statut du cours")
     content: str | None = Field(None, description="Contenu pédagogique")
     homework_blocks: tuple[HomeworkBlock, ...] = Field(

pronote_sync/pipeline/run.py

@@ -11,7 +11,12 @@ from typing import Protocol, runtime_checkable
 from pronote_sync.channels import get_channel
 from pronote_sync.channels.protocol import Channel
 from pronote_sync.config.settings import Settings
-from pronote_sync.errors import PipelineCriticalError, PipelineError, PipelineWarning
+from pronote_sync.errors import (
+    PipelineCriticalError,
+    PipelineError,
+    PipelineWarning,
+    PronoteAuthRotationError,
+)
 from pronote_sync.models.blog import ExternalInfo
 from pronote_sync.models.pronote import PronoteData
 from pronote_sync.models.sync import CalDAVSyncResult, CalDAVSyncStatus
@@ -26,6 +31,7 @@ from pronote_sync.pipeline.steps.send import send_step
 from pronote_sync.pipeline.steps.synthesis import synthesis_step
 from pronote_sync.sources.blog.rss import BlogRSSClient
 from pronote_sync.sources.blog.state import BlogRSSState
+from pronote_sync.sources.pronote.auth_state import PronoteAuthState
 from pronote_sync.sources.pronote.client import PronoteClient
 from pronote_sync.sources.pronote.fallback import PronoteFetcher, PronoteFetcherProtocol
 from pronote_sync.sources.theoretical import get_theoretical_provider
@@ -120,6 +126,9 @@ class PipelineRunner:
         :rtype: PipelineRunner
         """
         effective_dry_run = settings.app.dry_run if dry_run is None else dry_run
+        if effective_dry_run and settings.pronote.auth_mode == "qr_token":
+            raise ValueError("Le mode qr_token n'est pas compatible avec le dry-run.")
+        persistence_enabled = not effective_dry_run
         theoretical_provider = get_theoretical_provider(
             settings.app.theoretical_agenda_path,
             settings.app.school_holidays_path,
@@ -130,10 +139,22 @@ class PipelineRunner:
             AgendaComparator(theoretical_provider) if theoretical_provider is not None else None
         )
         blog_client = BlogRSSClient(settings.blog.rss_url) if settings.blog.enabled else None
-        blog_state = BlogRSSState() if settings.blog.enabled else None
+        blog_state = (
+            BlogRSSState(persistence_enabled=persistence_enabled) if settings.blog.enabled else None
+        )
         return cls(
             settings=settings,
-            pronote_fetcher=PronoteFetcher(settings, PronoteClient(settings.pronote)),
+            pronote_fetcher=PronoteFetcher(
+                settings,
+                PronoteClient(
+                    settings.pronote,
+                    auth_state=(
+                        PronoteAuthState(persistence_enabled=persistence_enabled)
+                        if settings.pronote.auth_mode == "qr_token"
+                        else None
+                    ),
+                ),
+            ),
             agenda_comparator=comparator,
             synthesis_provider=get_synthesis_provider(settings.ai),
             channel=get_channel(settings.xmpp, dry_run=effective_dry_run),
@@ -190,6 +211,11 @@ class PipelineRunner:
         des étapes facultatives sont converties en :class:`PipelineWarning` afin
         que les étapes suivantes, notamment XMPP, restent exécutées.
 
+        Une :class:`PronoteAuthRotationError` interrompt également l'exécution :
+        l'erreur est journalisée expurgée, une notification XMPP actionnable est
+        envoyée (sauf en dry-run ou sans canal), puis un résultat dégradé est
+        retourné.
+
         :return: Données Pronote normalisées ou ``None``, puis erreurs et avertissements.
         :rtype: tuple[PronoteData | None, list[PipelineError]]
         """
@@ -271,6 +297,28 @@ class PipelineRunner:
                     except Exception as exc:
                         self._warn("send", self._redact(exc))
                 return data, [*self._errors, *self._warnings]
+        except PronoteAuthRotationError as exc:
+            error = PipelineCriticalError(self._redact(exc), step="pronote")
+            logger.error("Erreur critique du pipeline : %s", error.message)
+            if self._channel is not None and not self._dry_run:
+                message = XmppMessage(
+                    target_date=now.date(),
+                    synthesis=(
+                        "⚠️ Rotation du token Pronote échouée. Le token d'authentification est "
+                        "expiré ou invalide. Action requise : supprimez le fichier "
+                        ".pronote_auth_state.json et relancez le pipeline avec un nouveau QR "
+                        "code (PRONOTE_QR_CODE_FILE + PRONOTE_QR_PIN)."
+                    ),
+                    external_info=None,
+                )
+                try:
+                    if not send_step(self._channel, message):
+                        self._warn("send", "Le canal XMPP a refusé l'envoi")
+                except Exception as send_exc:
+                    # L'envoi de la notification est un dernier avertissement : son échec
+                    # ne doit pas masquer l'erreur de rotation, déjà critique.
+                    self._warn("send", self._redact(send_exc))
+            self._errors.append(error)
         except PipelineCriticalError as exc:
             logger.error("Erreur critique du pipeline : %s", exc.message)
             self._errors.append(exc)

pronote_sync/pipeline/steps/fetch.py

@@ -2,16 +2,19 @@
 
 from __future__ import annotations
 
+import logging
 from dataclasses import dataclass
 from datetime import date
 
-from pronote_sync.errors import PipelineCriticalError, PipelineWarning
+from pronote_sync.errors import PipelineCriticalError, PipelineWarning, PronoteAuthRotationError
-from pronote_sync.models.agenda import Lesson, SchoolEvent
+from pronote_sync.models.agenda import Lesson, LessonStatus, SchoolEvent
 from pronote_sync.models.homework import Homework
 from pronote_sync.models.message import Message
 from pronote_sync.sources.pronote.fallback import PronoteFetcherProtocol
 from pronote_sync.utils.redaction import redact_exception
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass(frozen=True)
 class FetchedPronoteData:
@@ -36,27 +39,41 @@ def resolve_target_date(
 ) -> date:
     """Détermine la date cible du digest à partir de l'agenda disponible.
 
-    La règle privilégie J+1 lorsqu'il contient des cours. Si la journée en
+    La règle privilégie J+1 lorsqu'il contient un cours non annulé. Sinon,
-    cours contient des cours mais pas J+1, le prochain cours connu est choisi.
+    elle choisit le prochain jour possédant un cours effectif dans la fenêtre.
-    Sans cours correspondant, J+1 est conservé, y compris pendant les vacances.
+    Si aucune reprise n'est visible, la fin exclusive d'un événement scolaire
+    couvrant J+1 est utilisée ; à défaut, J+1 reste le meilleur choix connu.
 
     :param today: Date de référence de l'exécution.
     :param lessons: Cours récupérés pour la fenêtre de synchronisation.
-    :param school_events: Événements scolaires récupérés (réservés aux évolutions
+    :param school_events: Événements scolaires récupérés, avec borne de fin exclusive.
-        du libellé de jour sans cours).
     :return: Date cible du digest.
     :rtype: date
     """
-    del school_events
     tomorrow = date.fromordinal(today.toordinal() + 1)
-    lesson_dates = {lesson.start.date() for lesson in lessons}
+    effective_dates = {
-    if tomorrow in lesson_dates:
+        lesson.start.date()
-        return tomorrow
+        for lesson in lessons
-    if today in lesson_dates:
+        if lesson.status != LessonStatus.CANCELLED and lesson.start.date() > today
-        future_dates = sorted(day for day in lesson_dates if day > today)
+    }
-        if future_dates:
+    if tomorrow in effective_dates:
-            return future_dates[0]
+        reason = "cours effectif demain"
-    return tomorrow
+        target = tomorrow
+    elif effective_dates:
+        reason = "prochain cours effectif connu"
+        target = min(effective_dates)
+    else:
+        event_ends = [
+            event.to_date for event in school_events if event.from_date <= tomorrow < event.to_date
+        ]
+        if event_ends:
+            reason = "fin exclusive de l'événement couvrant demain"
+            target = max(event_ends)
+        else:
+            reason = "aucune reprise connue"
+            target = tomorrow
+    logger.info("Date cible %s : %s", target.isoformat(), reason)
+    return target
 
 
 def _fetch_optional_messages(
@@ -101,6 +118,8 @@ def fetch_step(
     :return: Données récupérées et avertissements non critiques.
     :rtype: tuple[FetchedPronoteData, list[PipelineWarning]]
     :raises PipelineCriticalError: Si l'agenda ou les devoirs ne sont pas disponibles.
+    :raises PronoteAuthRotationError: Si une rotation du token d'authentification
+        pronotepy est nécessaire : propagée telle quelle jusqu'au pipeline.
     """
     try:
         lessons, school_events = fetcher.fetch_agenda()
@@ -108,6 +127,8 @@ def fetch_step(
         homeworks = fetcher.fetch_homework(target_date)
     except PipelineCriticalError:
         raise
+    except PronoteAuthRotationError:
+        raise
     except Exception as exc:
         raise PipelineCriticalError(
             f"Récupération Pronote impossible : {redact_exception(exc)}", step="fetch"

pronote_sync/sources/blog/state.py

@@ -37,15 +37,24 @@ class BlogRSSState:
 
     :param state_file: Chemin du fichier d'état JSON (``str`` ou
         :class:`~pathlib.Path`). ``".blog_rss_state.json"`` par défaut.
+    :param persistence_enabled: Si ``False``, charge l'état existant mais ne
+        modifie jamais le fichier d'état. ``True`` par défaut.
     """
 
-    def __init__(self, state_file: Path | str = ".blog_rss_state.json") -> None:
+    def __init__(
+        self,
+        state_file: Path | str = ".blog_rss_state.json",
+        persistence_enabled: bool = True,
+    ) -> None:
         """Initialise le gestionnaire d'état depuis le fichier JSON.
 
         :param state_file: Chemin du fichier d'état JSON (``str`` ou
             :class:`~pathlib.Path`). ``".blog_rss_state.json"`` par défaut.
+        :param persistence_enabled: Si ``False``, charge l'état existant mais
+            désactive toutes les écritures sur disque. ``True`` par défaut.
         """
         self._state_file = Path(state_file)
+        self._persistence_enabled = persistence_enabled
         self._known_guids: set[str] = set()
         self._etag: str | None = None
         self._last_modified: str | None = None
@@ -98,6 +107,8 @@ class BlogRSSState:
         d'erreur d'écriture, une erreur est journalisée sans être
         propagée et le fichier temporaire est supprimé.
         """
+        if not self._persistence_enabled:
+            return
         payload = {
             "version": _STATE_VERSION,
             "known_guids": sorted(self._known_guids),

pronote_sync/sources/pronote/auth_state.py

@@ -0,0 +1,287 @@
+"""Persistance des credentials d'authentification par token pronotepy.
+
+Ce module fournit :class:`PronoteAuthState`, qui stocke et charge les credentials
+d'authentification par QR code / token entre les exécutions du pipeline. Le token
+pronotepy rotate à chaque session : le fichier d'état doit être mis à jour après
+chaque login réussi via :meth:`PronoteAuthState.save`.
+
+Le fichier d'état est créé avec des permissions ``0600`` car il contient un token
+d'authentification vivant. Son contenu n'est jamais journalisé.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from collections.abc import Generator
+from contextlib import contextmanager
+from fcntl import LOCK_EX, LOCK_NB, LOCK_UN, flock
+from pathlib import Path
+from typing import Any
+
+from pronote_sync.errors import PronoteAuthStateLockError, PronoteSyncError
+from pronote_sync.utils.redaction import redact_exception, redact_secrets
+
+logger = logging.getLogger(__name__)
+
+_STATE_VERSION = 1
+
+
+class PronoteAuthState:
+    """Persiste les credentials d'authentification par token pronotepy entre
+    les exécutions du pipeline.
+
+    Le fichier d'état contient un dict au format :
+    {"version": 1, "credentials": {"pronote_url": "...", "username": "...", "password": "<token>", "uuid": "..."}}
+
+    Les credentials sont le retour de pronotepy.Client.export_credentials(), utilisé tel quel
+    pour token_login(**credentials). Le token rotate à chaque session — le fichier doit être
+    mis à jour après chaque login réussi.
+
+    :param state_file: Chemin du fichier d'état JSON (``str`` ou
+        :class:`~pathlib.Path`). ``".pronote_auth_state.json"`` par défaut.
+    :param persistence_enabled: Si ``False``, charge l'état existant mais ne
+        modifie jamais le fichier d'état. ``True`` par défaut.
+    """
+
+    def __init__(
+        self,
+        state_file: Path | str = ".pronote_auth_state.json",
+        persistence_enabled: bool = True,
+    ) -> None:
+        """Initialise le gestionnaire d'état d'authentification Pronote.
+
+        Le fichier d'état n'est pas créé à l'initialisation : il n'est écrit
+        qu'à la première sauvegarde réussie via :meth:`save`.
+
+        :param state_file: Chemin du fichier d'état JSON (``str`` ou
+            :class:`~pathlib.Path`). ``".pronote_auth_state.json"`` par défaut.
+        :param persistence_enabled: Si ``False``, charge l'état existant mais
+            désactive toutes les écritures ou suppressions sur disque. ``True``
+            par défaut.
+        """
+        self._state_file = Path(state_file)
+        self._persistence_enabled = persistence_enabled
+        self._in_memory_credentials: dict[str, str] | None = None
+        self._in_memory_state_cleared = False
+
+    def load(self) -> dict[str, str] | None:
+        """Charge les credentials d'authentification depuis le fichier d'état.
+
+        Un fichier absent renvoie ``None`` (journalisé en debug). Un fichier
+        corrompu, une version absente ou non supportée, ou un champ
+        ``credentials`` invalide renvoient ``None`` avec un avertissement.
+        Le contenu des credentials n'est jamais journalisé.
+
+        :return: Dict des credentials (``pronote_url``, ``username``,
+            ``password``, ``uuid``) prêt pour
+            ``pronotepy.Client.token_login(**credentials)``, ou ``None`` si
+            aucun état valide n'est disponible.
+        :rtype: dict[str, str] | None
+        """
+        if self._in_memory_state_cleared:
+            return None
+        if self._in_memory_credentials is not None:
+            return self._in_memory_credentials.copy()
+        if not self._state_file.exists():
+            logger.debug(
+                "Fichier d'état d'authentification Pronote %s absent, aucun token à charger.",
+                redact_secrets(str(self._state_file)),
+            )
+            return None
+        try:
+            data: Any = json.loads(self._state_file.read_text(encoding="utf-8"))
+        except Exception as exc:
+            logger.warning(
+                "Impossible de charger le fichier d'état d'authentification Pronote %s : %s, "
+                "aucun token chargé.",
+                redact_secrets(str(self._state_file)),
+                redact_exception(exc),
+            )
+            return None
+        if not isinstance(data, dict) or data.get("version") != _STATE_VERSION:
+            logger.warning(
+                "Fichier d'état d'authentification Pronote %s : version absente ou non supportée, "
+                "aucun token chargé.",
+                redact_secrets(str(self._state_file)),
+            )
+            return None
+        credentials_data = data.get("credentials")
+        if not isinstance(credentials_data, dict):
+            logger.warning(
+                "Fichier d'état d'authentification Pronote %s : champ credentials absent ou invalide, "
+                "aucun token chargé.",
+                redact_secrets(str(self._state_file)),
+            )
+            return None
+        credentials: dict[str, str] = {}
+        for key, value in credentials_data.items():
+            if not isinstance(key, str) or not isinstance(value, str):
+                logger.warning(
+                    "Fichier d'état d'authentification Pronote %s : champ credentials invalide, "
+                    "aucun token chargé.",
+                    redact_secrets(str(self._state_file)),
+                )
+                return None
+            credentials[key] = value
+        return credentials
+
+    @contextmanager
+    def lock(self) -> Generator[None]:
+        """Protège une opération d'état par un verrou POSIX non bloquant.
+
+        Le verrou est conservé dans le fichier frère ``<state_file>.lock`` afin
+        de survivre à l'écriture atomique du fichier d'état. Le fichier de
+        verrou reste présent après libération et est créé en ``0600`` pour ne
+        pas élargir l'accès aux métadonnées de l'état sensible.
+
+        :return: Un gestionnaire de contexte qui tient le verrou exclusif.
+        :rtype: collections.abc.Generator[None, None, None]
+        :raises PronoteAuthStateLockError: Si un autre processus détient déjà
+            le verrou ou si son acquisition échoue.
+        """
+        lock_file = self._state_file.with_name(f"{self._state_file.name}.lock")
+        descriptor: int | None = None
+        try:
+            descriptor = os.open(
+                str(lock_file),
+                os.O_RDWR | os.O_CREAT | os.O_NOFOLLOW,
+                0o600,
+            )
+            os.fchmod(descriptor, 0o600)
+        except OSError:
+            logger.error("Impossible d'ouvrir le verrou d'état d'authentification Pronote.")
+            if descriptor is not None:
+                os.close(descriptor)
+
+        if descriptor is None:
+            raise PronoteAuthStateLockError(
+                "Impossible d'acquérir le verrou d'état d'authentification Pronote."
+            ) from None
+
+        is_contended = False
+        lock_acquisition_failed = False
+        try:
+            flock(descriptor, LOCK_EX | LOCK_NB)
+        except BlockingIOError:
+            is_contended = True
+        except OSError:
+            logger.error("Impossible d'acquérir le verrou d'état d'authentification Pronote.")
+            os.close(descriptor)
+            lock_acquisition_failed = True
+
+        if lock_acquisition_failed:
+            raise PronoteAuthStateLockError(
+                "Impossible d'acquérir le verrou d'état d'authentification Pronote."
+            ) from None
+
+        if is_contended:
+            os.close(descriptor)
+            raise PronoteAuthStateLockError(
+                "Une autre opération d'authentification Pronote est déjà en cours."
+            )
+
+        try:
+            yield
+        finally:
+            try:
+                flock(descriptor, LOCK_UN)
+            finally:
+                os.close(descriptor)
+
+    def save(self, credentials: dict[str, str]) -> None:
+        """Sauvegarde les credentials dans le fichier d'état, de manière atomique.
+
+        Le fichier contient ``{"version": 1, "credentials": ...}``. Le JSON est
+        d'abord écrit dans un fichier temporaire du même répertoire, créé avec
+        les permissions ``0600`` (lecture seule pour le propriétaire) dès son
+        ouverture via :func:`os.open` (avec ``O_EXCL`` et ``O_NOFOLLOW`` pour
+        résister aux attaques par lien symbolique), puis verrouillé via
+        :func:`os.fchmod` avant toute écriture ; le fichier temporaire remplace
+        ensuite atomiquement le fichier d'état via :func:`os.replace`. Un
+        éventuel fichier temporaire stale d'une exécution interrompue est
+        supprimé avant l'ouverture. Les credentials ne sont jamais journalisés.
+
+        :param credentials: Dict des credentials pronotepy, tel que retourné
+            par ``pronotepy.Client.export_credentials()``.
+        :raises PronoteSyncError: Si l'écriture ou le remplacement du fichier
+            échoue.
+        """
+        if not self._persistence_enabled:
+            self._in_memory_credentials = credentials.copy()
+            self._in_memory_state_cleared = False
+            return
+        payload: dict[str, Any] = {
+            "version": _STATE_VERSION,
+            "credentials": credentials,
+        }
+        tmp_file = self._state_file.with_suffix(".tmp")
+        fd: int | None = None
+        try:
+            # Nettoie un éventuel fichier temporaire stale laissé par une exécution interrompue.
+            if tmp_file.exists():
+                try:
+                    tmp_file.unlink()
+                except OSError:
+                    logger.debug(
+                        "Impossible de supprimer le fichier temporaire stale %s, "
+                        "l'ouverture en O_EXCL échouera.",
+                        redact_secrets(str(tmp_file)),
+                    )
+            # O_EXCL empêche de créer par-dessus un fichier existant (attaque par lien
+            # symbolique) et O_NOFOLLOW refuse de suivre un lien symbolique.
+            fd = os.open(
+                str(tmp_file),
+                os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW,
+                0o600,
+            )
+            # Verrouille les permissions en 0600 avant toute écriture, indépendamment de l'umask.
+            os.fchmod(fd, 0o600)
+            with os.fdopen(fd, "w", encoding="utf-8") as handle:
+                json.dump(payload, handle, indent=2)
+            os.replace(tmp_file, self._state_file)
+        except Exception as exc:
+            logger.error(
+                "Impossible d'écrire le fichier d'état d'authentification Pronote %s : %s.",
+                redact_secrets(str(self._state_file)),
+                redact_exception(exc),
+            )
+            if fd is not None:
+                try:
+                    os.close(fd)
+                except OSError:
+                    pass
+            try:
+                tmp_file.unlink(missing_ok=True)
+            except Exception as cleanup_exc:
+                logger.debug(
+                    "Nettoyage du fichier temporaire d'état d'authentification Pronote échoué : %s",
+                    redact_exception(cleanup_exc),
+                )
+            raise PronoteSyncError(
+                f"Impossible d'écrire le fichier d'état d'authentification Pronote "
+                f"{redact_secrets(str(self._state_file))}."
+            ) from None
+
+    def clear(self) -> None:
+        """Supprime le fichier d'état d'authentification.
+
+        Si le fichier n'existe pas, la méthode ne fait rien et aucune erreur
+        n'est levée. Lorsque la persistance est désactivée, elle efface
+        uniquement les credentials conservés en mémoire et ne modifie jamais
+        le fichier d'état.
+
+        :raises OSError: Si la suppression du fichier existant échoue.
+        """
+        self._in_memory_credentials = None
+        if not self._persistence_enabled:
+            self._in_memory_state_cleared = True
+            return
+        if not self._state_file.exists():
+            return
+        logger.debug(
+            "Suppression du fichier d'état d'authentification Pronote %s.",
+            redact_secrets(str(self._state_file)),
+        )
+        self._state_file.unlink()

pronote_sync/sources/pronote/client.py

@@ -10,19 +10,27 @@ des cours et des devoirs se propagent pour déclencher le repli iCal.
 
 from __future__ import annotations
 
+import json
 import logging
+from collections.abc import Generator
+from contextlib import contextmanager
 from datetime import date
+from pathlib import Path
 from typing import Any, Protocol
+from uuid import uuid4
 
 import pronotepy
 import pronotepy.ent as pronotepy_ent
 import requests
 
 from pronote_sync.config.settings import PronoteSettings
-from pronote_sync.models.agenda import Lesson, LessonStatus
+from pronote_sync.errors import PronoteAuthRotationError
+from pronote_sync.models.agenda import Lesson
 from pronote_sync.models.homework import Homework
 from pronote_sync.models.message import Message, MessageType
-from pronote_sync.utils.redaction import redact_exception
+from pronote_sync.sources.pronote.auth_state import PronoteAuthState
+from pronote_sync.sources.pronote.lessons import collapse_replaced_lessons, lesson_status
+from pronote_sync.utils.redaction import redact_exception, redact_secrets
 from pronote_sync.utils.uid import generate_deterministic_uid, normalize_pronote_uid
 
 logger = logging.getLogger(__name__)
@@ -91,6 +99,51 @@ def _resolve_ent(ent_name: str) -> Any:
     return resolver
 
 
+def _collect_auth_secrets(client: PronoteClient) -> list[str]:
+    """Collecte toutes les valeurs sensibles d'authentification pour la redaction.
+
+    Rassemble le mot de passe, le PIN QR, le contenu du fichier QR (jeton,
+    login, url) et les credentials persistés (token, username) afin de les
+    transmettre comme ``extra_secrets`` aux fonctions de masquage. Une valeur
+    vide ou ``None`` est ignorée.
+
+    :param client: Le client Pronote dont on collecte les secrets.
+    :return: Liste des valeurs sensibles à expurger des logs.
+    :rtype: list[str]
+    """
+    secrets: list[str] = []
+    settings = client._settings
+    # Mot de passe
+    if settings.password is not None:
+        secrets.append(settings.password.get_secret_value())
+    # PIN QR
+    if settings.qr_pin is not None:
+        secrets.append(settings.qr_pin.get_secret_value())
+    # Contenu du fichier QR (jeton, login, url)
+    if settings.qr_code_file is not None:
+        try:
+            qr_path = Path(settings.qr_code_file)
+            qr_data: Any = json.loads(qr_path.read_text(encoding="utf-8"))
+            for key in ("jeton", "login", "url"):
+                val = qr_data.get(key)
+                if isinstance(val, str):
+                    secrets.append(val)
+        except Exception as exc:
+            logger.debug(
+                "Impossible de lire le fichier QR %s : %s",
+                redact_secrets(settings.qr_code_file),
+                redact_exception(exc),
+            )
+    # Credentials persistés (token, username du fichier d'état)
+    if client._auth_state is not None:
+        creds = client._auth_state.load()
+        if creds is not None:
+            for val in creds.values():
+                if isinstance(val, str):
+                    secrets.append(val)
+    return [s for s in secrets if s]
+
+
 class PronoteClientProtocol(Protocol):
     """Interface du client Pronote consommée par la logique de repli."""
 
@@ -143,53 +196,249 @@ class PronoteClient:
     exceptions se propager pour déclencher le repli iCal.
     """
 
-    def __init__(self, settings: PronoteSettings) -> None:
+    def __init__(
+        self,
+        settings: PronoteSettings,
+        auth_state: PronoteAuthState | None = None,
+    ) -> None:
         """Initialise le client Pronote sans se connecter.
 
-        :param settings: Paramètres d'accès à Pronote (username, password, ent).
+        :param settings: Paramètres d'accès à Pronote (username, password, ent,
+            mode d'authentification, fichier QR et PIN).
+        :param auth_state: Gestionnaire de persistance du token
+            d'authentification (optionnel ; requis en mode ``qr_token`` pour
+            conserver le token entre les exécutions).
         """
         self._settings: PronoteSettings = settings
+        self._auth_state: PronoteAuthState | None = auth_state
         self._client: pronotepy.Client | None = None
 
     def _connect(self) -> pronotepy.Client:
         """Crée et connecte le client ``pronotepy`` (connexion paresseuse).
 
-        Le client est créé une seule fois puis réutilisé pour les appels
+        En mode ``password``, utilise l'authentification classique (URL,
-        suivants. Le nom d'ENT est résolu via :func:`_resolve_ent` et le
+        username, password, ENT). En mode ``qr_token``, utilise le token
-        type de compte (``student`` ou ``parent``) détermine la classe de
+        persisté via :class:`PronoteAuthState`, ou procède à l'enrôlement
-        client utilisée. L'erreur de connexion est relancée sans
+        initial par QR code si aucun token n'est présent.
-        journalisation, la méthode publique appelante étant responsable
-        de la journaliser.
 
         :return: Le client ``pronotepy`` connecté.
         :rtype: pronotepy.Client
-        :raises ValueError: Si ``pronote_url``, ``username``, ``password``
+        :raises ValueError: Si les credentials requis sont manquants.
-            ou ``ent`` est manquant, ou si l'ENT est inconnu.
+        :raises PronoteAuthRotationError: Si le token persisté est invalide
+            (rotation requise) ou si l'enrôlement QR échoue.
+        :raises pronotepy.PronoteAPIError: Si la connexion échoue.
+        """
+        if self._client is not None:
+            return self._client
+
+        if self._settings.auth_mode == "qr_token":
+            self._client = self._connect_qr_token()
+        else:
+            self._client = self._connect_password()
+        return self._client
+
+    def _persist_credentials(self) -> None:
+        """Persiste les credentials d'authentification après une opération réussie.
+
+        Le token pronotepy peut être rafraîchi (rotaté) par le serveur lors d'un
+        appel de données (agenda, devoirs, messages). Cette méthode persiste
+        systématiquement les credentials courantes pour garantir la disponibilité
+        du token valide au prochain run.
+
+        Ne fait rien si aucun :class:`PronoteAuthState` n'est configuré (mode
+        ``password``) ou si le client n'est pas connecté.
+        """
+        if self._auth_state is None or self._client is None:
+            return
+        try:
+            self._auth_state.save(self._client.export_credentials())
+        except Exception as exc:
+            logger.debug("Échec de la persistance des credentials : %s", redact_exception(exc))
+
+    @contextmanager
+    def _qr_token_operation_lock(self) -> Generator[None]:
+        """Verrouille un cycle d'authentification et de récupération QR/token.
+
+        Le verrou englobe le chargement du token, le login, l'opération de
+        données et la persistance qui suit. Il est volontairement absent du
+        mode ``password``, qui ne partage pas de fichier d'état de token.
+
+        :return: Un gestionnaire de contexte protégeant le cycle QR/token.
+        :rtype: collections.abc.Generator[None, None, None]
+        :raises PronoteAuthStateLockError: Si l'état QR/token est déjà utilisé
+            par une autre opération.
+        """
+        if self._settings.auth_mode != "qr_token" or self._auth_state is None:
+            yield
+            return
+
+        with self._auth_state.lock():
+            yield
+
+    def _connect_password(self) -> pronotepy.Client:
+        """Connecte le client ``pronotepy`` en mode ``password``.
+
+        Le nom d'ENT, s'il est configuré, est résolu via :func:`_resolve_ent` ;
+        en l'absence d'ENT, ``ent=None`` est transmis à ``pronotepy`` pour une
+        connexion directe. Le type de compte (``student`` ou ``parent``)
+        détermine la classe de client utilisée. L'erreur de connexion est
+        relancée sans journalisation, la méthode publique appelante étant
+        responsable de la journaliser.
+
+        :return: Le client ``pronotepy`` connecté.
+        :rtype: pronotepy.Client
+        :raises ValueError: Si ``url``, ``username`` ou ``password``
+            est manquant, ou si l'ENT fourni est inconnu.
         :raises pronotepy.PronoteAPIError: Si la connexion à Pronote échoue.
         """
-        if self._client is None:
+        url = self._settings.url
-            pronote_url = self._settings.pronote_url
+        username = self._settings.username
-            username = self._settings.username
+        password = self._settings.password
-            password = self._settings.password
+        ent = self._settings.ent
-            ent = self._settings.ent
+        if url is None or username is None or password is None:
-            if pronote_url is None or username is None or password is None or ent is None:
+            raise ValueError("url, username et password sont requis pour pronotepy")
-                raise ValueError(
+        resolver = _resolve_ent(ent) if ent is not None else None
-                    "pronote_url, username, password et ent sont requis pour pronotepy"
+        client_class: type[pronotepy.Client] = (
-                )
+            pronotepy.ParentClient if self._settings.account_type == "parent" else pronotepy.Client
-            resolver = _resolve_ent(ent)
+        )
-            client_class: type[pronotepy.Client] = (
+        self._client = client_class(
-                pronotepy.ParentClient
+            pronote_url=url,
-                if self._settings.account_type == "parent"
+            username=username,
-                else pronotepy.Client
+            password=password.get_secret_value(),
-            )
+            ent=resolver,
-            self._client = client_class(
+        )
-                pronote_url=pronote_url,
-                username=username,
-                password=password.get_secret_value(),
-                ent=resolver,
-            )
         return self._client
 
+    def _connect_qr_token(self) -> pronotepy.Client:
+        """Connecte via token persisté ou enrôlement par QR code.
+
+        En premier lieu, les credentials persistés (``pronote_url``, username,
+        ``password``/token, ``uuid``) sont rejoués via
+        ``pronotepy.Client.token_login`` si :class:`PronoteAuthState` est
+        disponible et fournit un état. En cas d'échec du login par token
+        (exception ou client non connecté), une :class:`PronoteAuthRotationError`
+        est levée immédiatement, sans repli vers l'enrôlement QR : la rotation
+        du token doit être déclenchée par l'opérateur. L'enrôlement par QR code
+        n'est tenté que lorsqu'aucun credential n'est persisté (premier login) ;
+        le nouveau token est ensuite persisté immédiatement.
+
+        :return: Le client ``pronotepy`` connecté.
+        :rtype: pronotepy.Client
+        :raises PronoteAuthRotationError: Si le token persisté est invalide
+            (expiré ou refusé par Pronote), ou si l'enrôlement QR échoue
+            (fichier QR ou PIN manquant, fichier QR invalide ou expiré).
+        """
+        client_class: type[pronotepy.Client] = (
+            pronotepy.ParentClient if self._settings.account_type == "parent" else pronotepy.Client
+        )
+
+        # Login par token avec les credentials persistés
+        if self._auth_state is not None:
+            creds = self._auth_state.load()
+            if creds is not None:
+                try:
+                    client = client_class.token_login(**creds)
+                    if client.logged_in:
+                        self._client = client
+                        self._persist_credentials()
+                        return client
+                    # logged_in est False — le token est invalide
+                    raise PronoteAuthRotationError(
+                        "Le token d'authentification Pronote est invalide (non connecté). "
+                        "Action requise : supprimez le fichier .pronote_auth_state.json "
+                        "et relancez avec un nouveau QR code."
+                    ) from None
+                except PronoteAuthRotationError:
+                    raise
+                except Exception as exc:
+                    logger.error(
+                        "Échec du login par token pronotepy : %s",
+                        redact_exception(exc, extra_secrets=_collect_auth_secrets(self)),
+                    )
+                    # Token expiré/invalide — pas de repli vers l'enrôlement QR
+                    raise PronoteAuthRotationError(
+                        "Le token d'authentification Pronote est expiré ou invalide. "
+                        "Action requise : supprimez le fichier .pronote_auth_state.json "
+                        "et relancez avec un nouveau QR code (PRONOTE_QR_CODE_FILE + "
+                        "PRONOTE_QR_PIN)."
+                    ) from None
+
+        # Enrôlement : premier login via QR code (aucun credential persisté)
+        client = self._enroll_qr_code(client_class)
+        # Persister le token rotaté immédiatement
+        self._client = client
+        self._persist_credentials()
+        return client
+
+    def _enroll_qr_code(self, client_class: type[pronotepy.Client]) -> pronotepy.Client:
+        """Procède à l'enrôlement initial via QR code pronotepy.
+
+        Le fichier QR JSON doit contenir les clés ``login``, ``jeton`` et
+        ``url``. Le PIN et le contenu du fichier ne sont jamais journalisés ;
+        les erreurs propagées sont expurgées.
+
+        :param client_class: Classe de client pronotepy à utiliser.
+        :return: Le client ``pronotepy`` connecté après enrôlement.
+        :rtype: pronotepy.Client
+        :raises PronoteAuthRotationError: Si le fichier QR ou le PIN est
+            manquant, si le fichier QR est illisible ou incomplet, ou si le
+            login par QR code échoue (PIN invalide ou QR code expiré).
+        """
+        qr_file = self._settings.qr_code_file
+        qr_pin = self._settings.qr_pin
+
+        if qr_file is None or qr_pin is None:
+            raise PronoteAuthRotationError(
+                "Enrôlement QR requis : PRONOTE_QR_CODE_FILE et PRONOTE_QR_PIN sont "
+                "nécessaires pour le premier login en mode qr_token. Supprimez le "
+                "fichier .pronote_auth_state.json si présent et relancez avec un "
+                "QR code frais."
+            ) from None
+
+        # Read and validate QR code JSON
+        try:
+            qr_path = Path(qr_file)
+            qr_data: Any = json.loads(qr_path.read_text(encoding="utf-8"))
+        except Exception as exc:
+            logger.error(
+                "Fichier QR invalide %s : %s",
+                redact_secrets(qr_file, extra_secrets=_collect_auth_secrets(self)),
+                redact_exception(exc, extra_secrets=_collect_auth_secrets(self)),
+            )
+            raise PronoteAuthRotationError(
+                "Impossible de lire le fichier QR code : "
+                f"{redact_secrets(qr_file, extra_secrets=_collect_auth_secrets(self))}"
+            ) from None
+
+        # Validate required keys
+        for key in ("login", "jeton", "url"):
+            if key not in qr_data:
+                raise PronoteAuthRotationError(
+                    f"Le fichier QR code ne contient pas la clé requise : {key}"
+                ) from None
+
+        pin_value = qr_pin.get_secret_value()
+        app_uuid = f"pronote-sync-{uuid4().hex}"
+
+        try:
+            client = client_class.qrcode_login(
+                qr_code=qr_data,
+                pin=pin_value,
+                uuid=app_uuid,
+            )
+        except Exception as exc:
+            logger.error(
+                "Échec de l'enrôlement QR : %s",
+                redact_exception(exc, extra_secrets=_collect_auth_secrets(self)),
+            )
+            raise PronoteAuthRotationError(
+                "Échec de l'enrôlement par QR code : PIN invalide ou QR code expiré. "
+                "Générez un nouveau QR code dans l'application Pronote et mettez à "
+                "jour PRONOTE_QR_CODE_FILE."
+            ) from None
+
+        return client
+
     def get_messages(self) -> list[Message]:
         """Récupère les messages des discussions Pronote.
 
@@ -200,35 +449,38 @@ class PronoteClient:
         :return: Liste des messages des professeurs ; vide en cas d'erreur.
         :rtype: list[Message]
         """
-        try:
+        with self._qr_token_operation_lock():
-            client = self._connect()
+            try:
-            messages: list[Message] = []
+                client = self._connect()
-            for discussion in client.discussions():
+                messages: list[Message] = []
-                for message in discussion.messages:
+                for discussion in client.discussions():
-                    messages.append(
+                    for message in discussion.messages:
-                        Message(
+                        messages.append(
-                            id=message.id,
+                            Message(
-                            type=MessageType.DISCUSSION,
+                                id=message.id,
-                            title=discussion.subject,
+                                type=MessageType.DISCUSSION,
-                            content=message.content,
+                                title=discussion.subject,
-                            author=message.author or "",
+                                content=message.content,
-                            date=message.created,
+                                author=message.author or "",
-                            read=message.seen,
+                                date=message.created,
+                                read=message.seen,
+                            )
                         )
-                    )
+                self._persist_credentials()
-            return messages
+                return messages
-        except (
+            except (
-            pronotepy.PronoteAPIError,
+                pronotepy.PronoteAPIError,
-            ValueError,
+                ValueError,
-            requests.RequestException,
+                requests.RequestException,
-            ConnectionError,
+                ConnectionError,
-            TimeoutError,
+                TimeoutError,
-        ) as exc:
+            ) as exc:
-            logger.error(
+                logger.error(
-                "Échec de la récupération des messages Pronote : %s",
+                    "Échec de la récupération des messages Pronote : %s",
-                redact_exception(exc),
+                    redact_exception(exc),
-            )
+                )
-            return []
+                self._persist_credentials()
+                return []
 
     def get_informations(self) -> list[Message]:
         """Récupère les informations et sondages Pronote.
@@ -239,34 +491,37 @@ class PronoteClient:
         :return: Liste des informations et sondages ; vide en cas d'erreur.
         :rtype: list[Message]
         """
-        try:
+        with self._qr_token_operation_lock():
-            client = self._connect()
+            try:
-            messages: list[Message] = []
+                client = self._connect()
-            for info in client.information_and_surveys():
+                messages: list[Message] = []
-                messages.append(
+                for info in client.information_and_surveys():
-                    Message(
+                    messages.append(
-                        id=info.id,
+                        Message(
-                        type=MessageType.SURVEY if info.survey else MessageType.INFORMATION,
+                            id=info.id,
-                        title=info.title or "",
+                            type=MessageType.SURVEY if info.survey else MessageType.INFORMATION,
-                        content=info.content(),
+                            title=info.title or "",
-                        author=info.author,
+                            content=info.content(),
-                        date=info.creation_date,
+                            author=info.author,
-                        read=info.read,
+                            date=info.creation_date,
+                            read=info.read,
+                        )
                     )
+                self._persist_credentials()
+                return messages
+            except (
+                pronotepy.PronoteAPIError,
+                ValueError,
+                requests.RequestException,
+                ConnectionError,
+                TimeoutError,
+            ) as exc:
+                logger.error(
+                    "Échec de la récupération des informations Pronote : %s",
+                    redact_exception(exc),
                 )
-            return messages
+                self._persist_credentials()
-        except (
+                return []
-            pronotepy.PronoteAPIError,
-            ValueError,
-            requests.RequestException,
-            ConnectionError,
-            TimeoutError,
-        ) as exc:
-            logger.error(
-                "Échec de la récupération des informations Pronote : %s",
-                redact_exception(exc),
-            )
-            return []
 
     def get_lessons(self, start: date, end: date) -> list[Lesson]:
         """Récupère les cours via ``pronotepy`` (repli iCal).
@@ -285,42 +540,46 @@ class PronoteClient:
         :param end: Date de fin de la fenêtre (incluse).
         :return: Liste des cours.
         :rtype: list[Lesson]
+        :raises PronoteAuthRotationError: Si le token persisté est invalide et
+            qu'aucun ré-enrôlement n'est possible (fichier QR ou PIN manquant).
         :raises pronotepy.PronoteAPIError: Si l'API Pronote échoue.
         :raises ValueError: Si la configuration ou l'ENT est invalide.
         :raises requests.RequestException: Si une requête réseau échoue.
         :raises ConnectionError: Si la connexion réseau échoue.
         :raises TimeoutError: Si la requête réseau expire.
         """
-        client = self._connect()
+        with self._qr_token_operation_lock():
-        lessons: list[Lesson] = []
+            client = self._connect()
-        for lesson in client.lessons(start, end):
+            lessons: list[Lesson] = []
-            content = lesson.content
+            for lesson in client.lessons(start, end):
-            raw_uid = lesson.id
+                content = lesson.content
-            if raw_uid:
+                raw_uid = lesson.id
-                uid = normalize_pronote_uid(raw_uid)
+                if raw_uid:
-            else:
+                    uid = normalize_pronote_uid(raw_uid)
-                uid = generate_deterministic_uid(
+                else:
-                    start=lesson.start,
+                    uid = generate_deterministic_uid(
-                    end=lesson.end,
+                        start=lesson.start,
-                    subject=lesson.subject.name if lesson.subject is not None else "",
+                        end=lesson.end,
-                    teachers=list(lesson.teacher_names or ()),
+                        subject=lesson.subject.name if lesson.subject is not None else "",
-                    rooms=list(lesson.classrooms or ()),
+                        teachers=list(lesson.teacher_names or ()),
-                    group=lesson.group_name,
+                        rooms=list(lesson.classrooms or ()),
+                        group=lesson.group_name,
+                    )
+                lessons.append(
+                    Lesson(
+                        id=uid,
+                        start=lesson.start,
+                        end=lesson.end,
+                        subject=lesson.subject.name if lesson.subject is not None else "",
+                        teachers=tuple(lesson.teacher_names or ()),
+                        rooms=tuple(lesson.classrooms or ()),
+                        group=lesson.group_name,
+                        status=lesson_status(getattr(lesson, "status", None), lesson.canceled),
+                        content=content.description if content is not None else None,
+                    )
                 )
-            lessons.append(
+            self._persist_credentials()
-                Lesson(
+            return collapse_replaced_lessons(lessons)
-                    id=uid,
-                    start=lesson.start,
-                    end=lesson.end,
-                    subject=lesson.subject.name if lesson.subject is not None else "",
-                    teachers=tuple(lesson.teacher_names or ()),
-                    rooms=tuple(lesson.classrooms or ()),
-                    group=lesson.group_name,
-                    status=(LessonStatus.CANCELLED if lesson.canceled else LessonStatus.NORMAL),
-                    content=content.description if content is not None else None,
-                )
-            )
-        return lessons
 
     def get_homeworks(self, start: date, end: date) -> list[Homework]:
         """Récupère les devoirs via ``pronotepy``.
@@ -335,24 +594,28 @@ class PronoteClient:
         :param end: Date de fin de la fenêtre (incluse).
         :return: Liste des devoirs.
         :rtype: list[Homework]
+        :raises PronoteAuthRotationError: Si le token persisté est invalide et
+            qu'aucun ré-enrôlement n'est possible (fichier QR ou PIN manquant).
         :raises pronotepy.PronoteAPIError: Si l'API Pronote échoue.
         :raises ValueError: Si la configuration ou l'ENT est invalide.
         :raises requests.RequestException: Si une requête réseau échoue.
         :raises ConnectionError: Si la connexion réseau échoue.
         :raises TimeoutError: Si la requête réseau expire.
         """
-        client = self._connect()
+        with self._qr_token_operation_lock():
-        homeworks: list[Homework] = []
+            client = self._connect()
-        for hw in client.homework(start, end):
+            homeworks: list[Homework] = []
-            homeworks.append(
+            for hw in client.homework(start, end):
-                Homework(
+                homeworks.append(
-                    id=hw.id,
+                    Homework(
-                    subject=hw.subject.name,
+                        id=hw.id,
-                    teachers=(),
+                        subject=hw.subject.name,
-                    assigned_on=None,
+                        teachers=(),
-                    due_on=hw.date,
+                        assigned_on=None,
-                    text=hw.description,
+                        due_on=hw.date,
-                    html=hw.description,
+                        text=hw.description,
+                        html=hw.description,
+                    )
                 )
-            )
+            self._persist_credentials()
-        return homeworks
+            return homeworks

pronote_sync/sources/pronote/fallback.py

@@ -23,7 +23,7 @@ from enum import StrEnum
 from typing import Literal, Protocol
 
 from pronote_sync.config.settings import Settings
-from pronote_sync.errors import PipelineCriticalError
+from pronote_sync.errors import PipelineCriticalError, PronoteAuthRotationError
 from pronote_sync.models.agenda import Lesson, SchoolEvent
 from pronote_sync.models.homework import Homework
 from pronote_sync.models.message import Message
@@ -147,18 +147,23 @@ class PronoteFetcher:
         return self._settings.pronote.ical_url is not None
 
     def _is_pronotepy_configured(self) -> bool:
-        """Vérifie que la source pronotepy est entièrement configurée.
+        """Vérifie si la source pronotepy est utilisable selon le mode d'authentification.
 
-        :return: ``True`` si ``pronote_url``, ``username``, ``password``
+        :return: ``True`` si pronotepy est configuré pour le mode
-            et ``ent`` sont tous définis, ``False`` sinon.
+            d'authentification actif, ``False`` sinon.
         :rtype: bool
         """
         pronote = self._settings.pronote
+        if pronote.auth_mode == "qr_token":
+            # En mode qr_token, seul PRONOTE_URL est requis.
+            # Le QR code et le PIN ne sont nécessaires que pour l'enrôlement initial.
+            # Les exécutions suivantes utilisent le token persisté.
+            return pronote.url is not None
+        # En mode password, URL + identifiant + mot de passe sont requis.
         return (
-            pronote.pronote_url is not None
+            pronote.url is not None
             and pronote.username is not None
             and pronote.password is not None
-            and pronote.ent is not None
         )
 
     def _fetch_agenda_ical(self) -> tuple[list[Lesson], list[SchoolEvent]]:
@@ -250,10 +255,14 @@ class PronoteFetcher:
         :return: Tuple ``(cours, événements scolaires)``.
         :rtype: tuple[list[Lesson], list[SchoolEvent]]
         :raises PipelineCriticalError: Si toutes les sources tentées échouent.
+        :raises PronoteAuthRotationError: Si une rotation du token d'authentification
+            pronotepy est nécessaire : propagée telle quelle, sans repli.
         """
         primary, fallback = self._agenda_sources()
         try:
             return self._fetch_agenda_source(primary)
+        except PronoteAuthRotationError:
+            raise
         except Exception as exc:
             logger.error(
                 "Échec de la récupération %s pour l'agenda : %s",
@@ -267,6 +276,8 @@ class PronoteFetcher:
             logger.info("Repli sur %s pour l'agenda.", fallback)
             try:
                 lessons, school_events = self._fetch_agenda_source(fallback)
+            except PronoteAuthRotationError:
+                raise
             except Exception as exc:
                 logger.error(
                     "Échec de la récupération %s pour l'agenda : %s",
@@ -371,10 +382,14 @@ class PronoteFetcher:
         :return: Liste des devoirs.
         :rtype: list[Homework]
         :raises PipelineCriticalError: Si toutes les sources tentées échouent.
+        :raises PronoteAuthRotationError: Si une rotation du token d'authentification
+            pronotepy est nécessaire : propagée telle quelle, sans repli.
         """
         primary, fallback = self._homework_sources()
         try:
             return self._fetch_homework_source(primary, target_date)
+        except PronoteAuthRotationError:
+            raise
         except Exception as exc:
             logger.error(
                 "Échec de la récupération %s pour les devoirs : %s",
@@ -388,6 +403,8 @@ class PronoteFetcher:
             logger.info("Repli sur %s pour les devoirs.", fallback)
             try:
                 homeworks = self._fetch_homework_source(fallback, target_date)
+            except PronoteAuthRotationError:
+                raise
             except Exception as exc:
                 logger.error(
                     "Échec de la récupération %s pour les devoirs : %s",

pronote_sync/sources/pronote/ical.py

@@ -14,13 +14,15 @@ from __future__ import annotations
 
 import hashlib
 import re
+import unicodedata
 import urllib.parse
 from datetime import date, datetime
 from html import unescape
 from pathlib import Path
-from typing import TypedDict
+from typing import NamedTuple, TypedDict
 
 import requests
+from bs4 import BeautifulSoup
 from icalendar import Calendar
 
 from ...models.agenda import (
@@ -33,22 +35,15 @@ from ...models.agenda import (
 from ...models.homework import Homework
 from ...utils.redaction import redact_exception, redact_url
 from ...utils.uid import generate_deterministic_uid, normalize_pronote_uid
+from .lessons import collapse_replaced_lessons
 
-_HEADER_LABEL_PATTERN = re.compile(r"\b(Matière|Professeurs?|Salles?|Groupe)\s*:\s*")
+_HEADER_LABEL_PATTERN = re.compile(
+    r"(?P<label>Mati(?:ère|ere)|Professeur(?:s|\(s\))?|Salle(?:s|\(s\))?"
+    r"|Groupe|Partie(?:s|\(s\))?\s+de\s+classe)\s*:\s*",
+    re.IGNORECASE,
+)
 _CALNAME_PATTERN = re.compile(r"^X-WR-CALNAME(?:;[^:]*)?:([^\r\n]*)", re.MULTILINE)
-_TAG_PATTERN = re.compile(r"<[^>]+>")
+_STRONG_PATTERN = re.compile(r"<strong\b[^>]*>(?P<label>.*?)</strong>", re.IGNORECASE | re.DOTALL)
-_CONTENT_PATTERN = re.compile(
-    r"<strong>Contenu pédagogique\s*:\s*</strong>(.*?)(?=<strong>|</div>\s*$|\Z)",
-    re.DOTALL,
-)
-_DUE_PATTERN = re.compile(
-    r"<strong>Pour le (\d{2}/\d{2}/\d{4})\s*:\s*</strong>(.*?)(?=<strong>|</div>\s*$|\Z)",
-    re.DOTALL,
-)
-_ASSIGNED_PATTERN = re.compile(
-    r"<strong>Donné le (\d{2}/\d{2}/\d{4})\s*:\s*</strong>(.*?)(?=<strong>|</div>\s*$|\Z)",
-    re.DOTALL,
-)
 
 _HEADERS = {
     "accept": "text/calendar",
@@ -63,6 +58,15 @@ class HeaderInfo(TypedDict):
     teachers: list[str]
     rooms: list[str]
     group: str | None
+    class_part: str | None
+
+
+class ParsedHomeworkBlock(NamedTuple):
+    """Bloc de devoir parsé avec son texte nettoyé et son HTML sûr."""
+
+    date: date
+    text: str
+    html: str
 
 
 def fetch_ical(url: str, timeout: int = 20) -> str:
@@ -156,11 +160,11 @@ def split_header_and_body(description: str) -> tuple[str, str]:
     :return: Tuple ``(en-tête, corps)`` ; le corps est vide si aucun ``<strong>``.
     :rtype: tuple[str, str]
     """
-    strong_start = description.find("<strong>")
+    strong_match = _STRONG_PATTERN.search(description)
-    if strong_start == -1:
+    if strong_match is None:
         return description.strip(), ""
-    header = description[:strong_start].strip()
+    header = description[: strong_match.start()].strip()
-    body = description[strong_start:]
+    body = description[strong_match.start() :]
     return header, body
 
 
@@ -168,7 +172,7 @@ def parse_header(header: str) -> HeaderInfo:
     """Parse l'en-tête texte pour extraire les métadonnées du cours.
 
     Les labels reconnus sont : ``Matière :``, ``Professeur(s) :``,
-    ``Salle(s) :`` et ``Groupe :``. La recherche se fait par position
+    ``Salle(s) :``, ``Groupe :`` et ``Partie(s) de classe :``. La recherche se fait par position
     des labels, ce qui supporte aussi bien un en-tête multi-lignes
     qu'un en-tête dont les lignes sont jointes sur une seule ligne.
 
@@ -176,14 +180,21 @@ def parse_header(header: str) -> HeaderInfo:
     :return: Dictionnaire typé avec les champs subject, teachers, rooms, group.
     :rtype: HeaderInfo
     """
-    info: HeaderInfo = {"subject": "", "teachers": [], "rooms": [], "group": None}
+    info: HeaderInfo = {
-    matches = list(_HEADER_LABEL_PATTERN.finditer(header))
+        "subject": "",
+        "teachers": [],
+        "rooms": [],
+        "group": None,
+        "class_part": None,
+    }
+    header_text = _strip_html(header)
+    matches = list(_HEADER_LABEL_PATTERN.finditer(header_text))
     for index, match in enumerate(matches):
         value_start = match.end()
-        value_end = matches[index + 1].start() if index + 1 < len(matches) else len(header)
+        value_end = matches[index + 1].start() if index + 1 < len(matches) else len(header_text)
-        value = unescape(header[value_start:value_end].strip())
+        value = unescape(header_text[value_start:value_end].strip())
-        label = match.group(1).lower()
+        label = _normalize_label(match.group("label")).replace("(s)", "s")
-        if label == "matière":
+        if label == "matiere":
             info["subject"] = value
         elif label in ("professeur", "professeurs"):
             info["teachers"] = [part.strip() for part in value.split(",") if part.strip()]
@@ -191,9 +202,44 @@ def parse_header(header: str) -> HeaderInfo:
             info["rooms"] = [part.strip() for part in value.split(",") if part.strip()]
         elif label == "groupe":
             info["group"] = value
+        elif label in ("partie de classe", "parties de classe"):
+            info["class_part"] = value
     return info
 
 
+def _normalize_label(value: str) -> str:
+    """Normalise un libellé iCal pour comparer des variantes contrôlées.
+
+    :param value: Libellé à normaliser.
+    :return: Libellé minuscule sans accents et avec des espaces unifiés.
+    :rtype: str
+    """
+    decomposed = unicodedata.normalize("NFKD", value)
+    without_accents = "".join(char for char in decomposed if not unicodedata.combining(char))
+    return re.sub(r"\s+", " ", without_accents).strip().lower()
+
+
+def _sanitize_html(fragment: str) -> str:
+    """Nettoie un fragment HTML de description sans exécuter de contenu.
+
+    :param fragment: Fragment HTML extrait d'une section de devoir.
+    :return: HTML conservé sans scripts, styles ni attributs exécutables.
+    :rtype: str
+    """
+    soup = BeautifulSoup(fragment, "html.parser")
+    for tag in soup.find_all(("script", "style")):
+        tag.decompose()
+    for tag in soup.find_all(True):
+        for attribute in list(tag.attrs):
+            lowered = attribute.lower()
+            value = tag.attrs[attribute]
+            if lowered.startswith("on") or (
+                lowered in ("href", "src") and str(value).lower().strip().startswith("javascript:")
+            ):
+                del tag.attrs[attribute]
+    return soup.decode_contents().strip()
+
+
 def _strip_html(text: str) -> str:
     """Retire les balises HTML d'un texte et nettoie les espaces.
 
@@ -201,8 +247,10 @@ def _strip_html(text: str) -> str:
     :return: Texte brut sans balises, entités HTML décodées.
     :rtype: str
     """
-    cleaned = _TAG_PATTERN.sub("", text)
+    soup = BeautifulSoup(text, "html.parser")
-    return unescape(cleaned).strip()
+    for tag in soup.find_all(("script", "style")):
+        tag.decompose()
+    return " ".join(unescape(soup.get_text(" ", strip=True)).split())
 
 
 def _parse_french_date(value: str) -> date | None:
@@ -218,44 +266,57 @@ def _parse_french_date(value: str) -> date | None:
         return None
 
 
-def parse_body(body: str) -> tuple[str | None, list[tuple[date, str]], list[tuple[date, str]]]:
+def parse_body(
+    body: str,
+) -> tuple[str | None, list[ParsedHomeworkBlock], list[ParsedHomeworkBlock]]:
     """Parse le corps HTML pour extraire contenu pédagogique et devoirs.
 
     Le contenu est extrait de la section ``<strong>Contenu pédagogique :</strong>``.
     Les devoirs à faire sont extraits des sections ``<strong>Pour le JJ/MM/AAAA :</strong>``
-    (liste de tuples ``(date, texte)`` dans l'ordre du flux) et les devoirs donnés
+    et les devoirs donnés des sections ``<strong>Donné le JJ/MM/AAAA :</strong>``.
-    des sections ``<strong>Donné le JJ/MM/AAAA :</strong>`` (liste de tuples
+    Les listes préservent tous les blocs, même lorsque plusieurs sections partagent
-    ``(date, texte)``). Les listes préservent tous les blocs, même lorsque plusieurs
+    la même date, avec le texte nettoyé et le HTML sûr de chaque bloc.
-    sections partagent la même date.
 
     :param body: Corps HTML (à partir du premier ``<strong>``).
     :return: Tuple ``(contenu pédagogique, devoirs dus, devoirs donnés)``.
-    :rtype: tuple[str | None, list[tuple[date, str]], list[tuple[date, str]]]
+    :rtype: tuple[str | None, list[ParsedHomeworkBlock], list[ParsedHomeworkBlock]]
     """
     content: str | None = None
-    due_blocks: list[tuple[date, str]] = []
+    due_blocks: list[ParsedHomeworkBlock] = []
-    assigned_blocks: list[tuple[date, str]] = []
+    assigned_blocks: list[ParsedHomeworkBlock] = []
 
-    content_match = _CONTENT_PATTERN.search(body)
+    matches = list(_STRONG_PATTERN.finditer(body))
-    if content_match is not None:
+    for index, match in enumerate(matches):
-        content = _strip_html(content_match.group(1))
+        next_start = matches[index + 1].start() if index + 1 < len(matches) else len(body)
+        heading = _strip_html(match.group("label")).rstrip(":").strip()
+        fragment = body[match.end() : next_start]
+        safe_html = _sanitize_html(fragment)
+        text = _strip_html(fragment)
 
-    for match in _DUE_PATTERN.finditer(body):
+        normalized_heading = _normalize_label(heading)
-        due_date = _parse_french_date(match.group(1))
+        if normalized_heading == "contenu pedagogique":
-        if due_date is not None:
+            content = text
-            due_blocks.append((due_date, _strip_html(match.group(2))))
+            continue
 
-    for match in _ASSIGNED_PATTERN.finditer(body):
+        due_match = re.fullmatch(r"Pour\s+le\s+(\d{2}/\d{2}/\d{4})", heading, re.IGNORECASE)
-        assigned_date = _parse_french_date(match.group(1))
+        assigned_match = re.fullmatch(
-        if assigned_date is not None:
+            r"Donne\s+le\s+(\d{2}/\d{2}/\d{4})", normalized_heading, re.IGNORECASE
-            assigned_blocks.append((assigned_date, _strip_html(match.group(2))))
+        )
+        if due_match is not None:
+            due_date = _parse_french_date(due_match.group(1))
+            if due_date is not None:
+                due_blocks.append(ParsedHomeworkBlock(due_date, text, safe_html))
+        elif assigned_match is not None:
+            assigned_date = _parse_french_date(assigned_match.group(1))
+            if assigned_date is not None:
+                assigned_blocks.append(ParsedHomeworkBlock(assigned_date, text, safe_html))
 
     return content, due_blocks, assigned_blocks
 
 
 def parse_homework_blocks(
-    due_blocks: list[tuple[date, str]],
+    due_blocks: list[ParsedHomeworkBlock],
-    assigned_blocks: list[tuple[date, str]],
+    assigned_blocks: list[ParsedHomeworkBlock],
 ) -> tuple[HomeworkBlock, ...]:
     """Construit les :class:`HomeworkBlock` depuis les listes de devoirs.
 
@@ -269,10 +330,12 @@ def parse_homework_blocks(
     :rtype: tuple[HomeworkBlock, ...]
     """
     blocks: list[HomeworkBlock] = []
-    for due_date, text in due_blocks:
+    for block in due_blocks:
-        blocks.append(HomeworkBlock(kind="due", date=due_date, text=text, html=text))
+        blocks.append(HomeworkBlock(kind="due", date=block.date, text=block.text, html=block.html))
-    for assigned_date, text in assigned_blocks:
+    for block in assigned_blocks:
-        blocks.append(HomeworkBlock(kind="assigned", date=assigned_date, text=text, html=text))
+        blocks.append(
+            HomeworkBlock(kind="assigned", date=block.date, text=block.text, html=block.html)
+        )
     return tuple(blocks)
 
 
@@ -286,24 +349,32 @@ def normalize_homework_text(text: str) -> str:
     :return: Texte normalisé.
     :rtype: str
     """
-    normalized = re.sub(r"\s+", " ", text)
+    return _strip_html(text).casefold()
-    normalized = _TAG_PATTERN.sub("", normalized)
-    return normalized.strip().lower()
 
 
-def generate_homework_id(due_on: date, normalized_text: str) -> str:
+def generate_homework_id(
+    due_on: date,
+    normalized_text: str,
+    subject: str = "",
+    teachers: tuple[str, ...] = (),
+) -> str:
     """Génère un ID stable pour un devoir.
 
-    L'ID est la clé ``AAAA-MM-JJ|texte_normalisé`` hachée en SHA-1 dont
+    L'ID est la clé ``AAAA-MM-JJ|matière|enseignants|texte_normalisé`` hachée en SHA-1 dont
     on garde les 12 premiers caractères hexadécimaux. Le hachage n'est
     pas utilisé à des fins de sécurité (``usedforsecurity=False``).
 
     :param due_on: Date d'échéance du devoir.
     :param normalized_text: Texte normalisé du devoir.
+    :param subject: Matière du devoir, utile pour distinguer les homonymes.
+    :param teachers: Enseignants du devoir, triés pour garantir la stabilité.
     :return: ID stable (12 caractères hexadécimaux).
     :rtype: str
     """
-    payload = f"{due_on.isoformat()}|{normalized_text}".encode()
+    payload = (
+        f"{due_on.isoformat()}|{subject.casefold()}|"
+        f"{','.join(sorted(teacher.casefold() for teacher in teachers))}|{normalized_text}".encode()
+    )
     return hashlib.sha1(payload, usedforsecurity=False).hexdigest()[:12]
 
 
@@ -313,7 +384,7 @@ def collect_homeworks(lessons: list[Lesson], target_date: date) -> list[Homework
     Passe 1 : les blocs ``due`` (devoirs à faire pour ``target_date``)
     de tous les cours. Passe 2 : les blocs ``assigned`` (devoirs donnés
     le jour cible) des cours du jour ``target_date``. La déduplication
-    se fait par texte normalisé (premier venu, premier servi) et le
+    se fait par texte, matière et enseignants normalisés (premier venu, premier servi) et le
     résultat est trié par matière puis texte.
 
     :param lessons: Liste de tous les cours (VEVENT) parsés.
@@ -321,15 +392,22 @@ def collect_homeworks(lessons: list[Lesson], target_date: date) -> list[Homework
     :return: Liste unique de devoirs, triée par matière puis texte.
     :rtype: list[Homework]
     """
-    by_text: dict[str, Homework] = {}
+    by_context: dict[tuple[str, tuple[str, ...], str], Homework] = {}
 
     for lesson in lessons:
         for block in lesson.homework_blocks:
             if block.kind == "due" and block.date == target_date:
-                key = normalize_homework_text(block.text)
+                normalized_text = normalize_homework_text(block.text)
-                if key not in by_text:
+                key = (
-                    by_text[key] = Homework(
+                    lesson.subject.casefold(),
-                        id=generate_homework_id(target_date, key),
+                    tuple(sorted(teacher.casefold() for teacher in lesson.teachers)),
+                    normalized_text,
+                )
+                if key not in by_context:
+                    by_context[key] = Homework(
+                        id=generate_homework_id(
+                            target_date, normalized_text, lesson.subject, lesson.teachers
+                        ),
                         subject=lesson.subject,
                         teachers=lesson.teachers,
                         assigned_on=lesson.start.date(),
@@ -343,10 +421,17 @@ def collect_homeworks(lessons: list[Lesson], target_date: date) -> list[Homework
             continue
         for block in lesson.homework_blocks:
             if block.kind == "assigned":
-                key = normalize_homework_text(block.text)
+                normalized_text = normalize_homework_text(block.text)
-                if key not in by_text:
+                key = (
-                    by_text[key] = Homework(
+                    lesson.subject.casefold(),
-                        id=generate_homework_id(target_date, key),
+                    tuple(sorted(teacher.casefold() for teacher in lesson.teachers)),
+                    normalized_text,
+                )
+                if key not in by_context:
+                    by_context[key] = Homework(
+                        id=generate_homework_id(
+                            target_date, normalized_text, lesson.subject, lesson.teachers
+                        ),
                         subject=lesson.subject,
                         teachers=lesson.teachers,
                         assigned_on=block.date,
@@ -355,7 +440,7 @@ def collect_homeworks(lessons: list[Lesson], target_date: date) -> list[Homework
                         html=block.html,
                     )
 
-    return sorted(by_text.values(), key=lambda hw: (hw.subject.lower(), hw.text.lower()))
+    return sorted(by_context.values(), key=lambda hw: (hw.subject.lower(), hw.text.lower()))
 
 
 def parse_ical(raw_ical: str) -> tuple[list[Lesson], list[Homework], list[SchoolEvent]]:
@@ -399,15 +484,28 @@ def parse_ical(raw_ical: str) -> tuple[list[Lesson], list[Homework], list[School
         else:
             categories = [str(category) for category in categories_obj.cats]
 
-        # Événements de type vacances/congés (tout le jour).
+        normalized_categories = [_normalize_label(category) for category in categories]
-        if any(cat in ("Congés", "Vacances") for cat in categories):
+        holiday_kind: SchoolEventKind | None = None
+        if any(
+            category in ("conges", "vacances", "vacances scolaires")
+            for category in normalized_categories
+        ):
+            holiday_kind = SchoolEventKind.HOLIDAY
+        elif any(
+            category in ("jour ferie", "jours feries", "ferie", "feries")
+            for category in normalized_categories
+        ):
+            holiday_kind = SchoolEventKind.PUBLIC_HOLIDAY
+
+        # Événements de type vacances/congés/jours fériés (tout le jour).
+        if holiday_kind is not None:
             from_date = start.date() if isinstance(start, datetime) else start
             to_date = end.date() if isinstance(end, datetime) else end
             summary = component.get("summary")
             label = str(summary) if summary is not None else ""
             school_events.append(
                 SchoolEvent(
-                    kind=SchoolEventKind.HOLIDAY,
+                    kind=holiday_kind,
                     label=label,
                     from_date=from_date,
                     to_date=to_date,
@@ -422,9 +520,15 @@ def parse_ical(raw_ical: str) -> tuple[list[Lesson], list[Homework], list[School
 
         status_obj = component.get("status")
         status_value = str(status_obj).strip().upper() if status_obj is not None else ""
-        if status_value == "CANCELLED" or "Cours - Cours annulé" in categories:
+        normalized_status_categories = set(normalized_categories)
+        if status_value == "CANCELLED" or any(
+            "annul" in category for category in normalized_status_categories
+        ):
             status = LessonStatus.CANCELLED
-        elif "Cours - Cours déplacé" in categories:
+        elif any(
+            any(token in category for token in ("deplac", "changement de salle", "modifi"))
+            for category in normalized_status_categories
+        ):
             status = LessonStatus.MOVED
         else:
             status = LessonStatus.NORMAL
@@ -458,10 +562,11 @@ def parse_ical(raw_ical: str) -> tuple[list[Lesson], list[Homework], list[School
                 teachers=tuple(lesson_data["teachers"]),
                 rooms=tuple(lesson_data["rooms"]),
                 group=lesson_data["group"],
+                class_part=lesson_data["class_part"],
                 status=status,
                 content=content,
                 homework_blocks=homework_blocks,
             )
         )
 
-    return lessons, homeworks, school_events
+    return collapse_replaced_lessons(lessons), homeworks, school_events

pronote_sync/sources/pronote/lessons.py

@@ -0,0 +1,72 @@
+"""Règles communes de statut et de consolidation des cours Pronote."""
+
+from __future__ import annotations
+
+import unicodedata
+from collections import defaultdict
+
+from ...models.agenda import Lesson, LessonStatus
+
+
+def _normalize_status(value: str) -> str:
+    """Normalise un statut Pronote pour une comparaison tolérante.
+
+    :param value: Statut brut fourni par Pronote.
+    :return: Statut minuscule sans accents.
+    :rtype: str
+    """
+    decomposed = unicodedata.normalize("NFKD", value)
+    without_accents = "".join(char for char in decomposed if not unicodedata.combining(char))
+    return " ".join(without_accents.casefold().split())
+
+
+def lesson_status(raw_status: object, canceled: bool = False) -> LessonStatus:
+    """Convertit le statut Pronote en statut métier canonique.
+
+    L'indicateur d'annulation et les libellés annulé sont prioritaires sur un
+    éventuel libellé de déplacement. Les libellés inconnus restent normaux.
+
+    :param raw_status: Valeur du champ ``Lesson.status`` de pronotepy.
+    :param canceled: Indicateur ``Lesson.canceled`` de pronotepy.
+    :return: Statut métier canonique.
+    :rtype: LessonStatus
+    """
+    status = _normalize_status(raw_status) if isinstance(raw_status, str) else ""
+    if canceled or "annul" in status:
+        return LessonStatus.CANCELLED
+    if any(token in status for token in ("deplac", "changement de salle", "modifi")):
+        return LessonStatus.MOVED
+    return LessonStatus.NORMAL
+
+
+def collapse_replaced_lessons(lessons: list[Lesson]) -> list[Lesson]:
+    """Supprime l'ancien exemplaire annulé lorsqu'un cours déplacé est présent.
+
+    Deux cours sont considérés comme les exemplaires d'une même modification
+    lorsqu'ils partagent les dates, la matière, les enseignants et le groupe,
+    et qu'une seule annulation et un seul déplacement se distinguent par leur
+    salle. Une annulation isolée ou ambiguë est toujours conservée.
+
+    :param lessons: Cours issus d'une source Pronote.
+    :return: Cours consolidés dans leur ordre d'origine.
+    :rtype: list[Lesson]
+    """
+    grouped: dict[tuple[object, ...], list[tuple[int, Lesson]]] = defaultdict(list)
+    for index, lesson in enumerate(lessons):
+        key = (
+            lesson.start,
+            lesson.end,
+            lesson.subject.casefold(),
+            tuple(teacher.casefold() for teacher in lesson.teachers),
+            (lesson.group or "").casefold(),
+        )
+        grouped[key].append((index, lesson))
+
+    replaced_indexes: set[int] = set()
+    for siblings in grouped.values():
+        cancelled = [item for item in siblings if item[1].status == LessonStatus.CANCELLED]
+        moved = [item for item in siblings if item[1].status == LessonStatus.MOVED]
+        if len(cancelled) == 1 and len(moved) == 1 and cancelled[0][1].rooms != moved[0][1].rooms:
+            replaced_indexes.add(cancelled[0][0])
+
+    return [lesson for index, lesson in enumerate(lessons) if index not in replaced_indexes]

pronote_sync/sync/serialization.py

@@ -61,6 +61,10 @@ def lesson_to_vevent(lesson: Lesson) -> Event:
         parts.append(f"Professeur(s): {', '.join(lesson.teachers)}")
     if lesson.rooms:
         parts.append(f"Salle(s): {', '.join(lesson.rooms)}")
+    if lesson.group:
+        parts.append(f"Groupe: {lesson.group}")
+    if lesson.class_part:
+        parts.append(f"Partie(s) de classe: {lesson.class_part}")
     if lesson.content:
         parts.append(f"Contenu: {lesson.content}")
     event.add("description", "\n".join(parts))

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pronote-sync"
-version = "0.1.0"
+version = "0.1.2"
 description = "Synchronisation Pronote → CalDAV + XMPP"
 license = {text = "MIT"}
 requires-python = ">=3.13.5"

scripts/check_secrets.py

@@ -0,0 +1,245 @@
+#!/usr/bin/env python3
+"""Vérifie l'absence de secrets littéraux avant un déploiement.
+
+Le script inspecte le contenu textuel du dépôt, ou uniquement les fichiers
+ajoutés/modifiés dans l'index avec ``--staged``. Il ne transmet jamais la
+valeur détectée : les résultats ne contiennent que le chemin, le numéro de
+ligne et le type de motif. Les fichiers d'environnement et les répertoires
+générés sont exclus, car ils ne doivent pas être versionnés ni déployés.
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import subprocess  # nosec B404
+from collections.abc import Callable, Iterable, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+
+_EXCLUDED_PARTS = frozenset({".git", ".venv", ".worktrees", "__pycache__", ".."})
+_EXCLUDED_NAMES = frozenset({".env", ".secrets.baseline", "GUIDE_DEV_PYTHON.md"})
+_EXCLUDED_TOP_LEVEL = frozenset({"tests"})
+_ALLOWLIST_MARKER = "secret-check: allow"
+_UNQUOTED_CONFIG_SUFFIXES = frozenset({".conf", ".ini", ".toml", ".yaml", ".yml"})
+_TEXT_SUFFIXES = frozenset(
+    {".conf", ".ini", ".json", ".md", ".py", ".service", ".timer", ".toml", ".txt", ".yaml", ".yml"}
+)
+_LITERAL_SECRET_RE = re.compile(
+    r"(?ix)\b[a-z0-9_]*(?:api[_-]?key|access[_-]?token|auth(?:orization)?|icalsecurise|password|secret|token)"
+    r"\s*[:=]\s*['\"][^'\"\r\n]{3,}['\"]"
+)
+_UNQUOTED_SECRET_RE = re.compile(
+    r"(?ix)\b[a-z0-9_]*(?:api[_-]?key|access[_-]?token|auth(?:orization)?|icalsecurise|password|secret|token)"
+    r"\s*[:=]\s*[a-z0-9][a-z0-9._~+/-]{2,}"
+)
+_URL_SECRET_RE = re.compile(
+    r"(?ix)[?&](?:api[_-]?key|access[_-]?token|auth(?:orization)?|icalsecurise|password|secret|token)"
+    r"=([^&#\s]{3,})"
+)
+_EXTRA_NAMES = frozenset({"pronote_sync"})
+
+
+@dataclass(frozen=True)
+class SecretFinding:
+    """Représente un motif sensible détecté sans exposer sa valeur.
+
+    :ivar path: Chemin relatif du fichier concerné.
+    :ivar line: Numéro de ligne du motif.
+    :ivar rule: Règle ayant détecté le motif.
+    """
+
+    path: Path
+    line: int
+    rule: str
+
+
+CommandRunner = Callable[..., subprocess.CompletedProcess[str]]
+#: Fournisseur de contenu pour un chemin relatif ; retourne ``None`` pour ignorer.
+ContentProvider = Callable[[Path], str | None]
+
+
+def _is_candidate(path: Path) -> bool:
+    """Indique si un chemin peut être analysé comme fichier texte.
+
+    Les fichiers de déploiement sans extension, nommés explicitement dans
+    ``_EXTRA_NAMES``, sont également retenus.
+
+    :param path: Chemin relatif au dépôt.
+    :return: ``True`` lorsque le fichier est textuel et non exclu.
+    :rtype: bool
+    """
+    return (
+        not path.is_absolute()
+        and path.name not in _EXCLUDED_NAMES
+        and path.parts[0] not in _EXCLUDED_TOP_LEVEL
+        and not any(part in _EXCLUDED_PARTS for part in path.parts)
+        and (path.suffix in _TEXT_SUFFIXES or path.name in _EXTRA_NAMES)
+    )
+
+
+def _repository_files(root: Path) -> list[Path]:
+    """Liste les fichiers textuels présents dans le dépôt de travail.
+
+    Les tests et la spécification historique ne font pas partie de l'artefact
+    déployé : leurs sentinelles et exemples intentionnels ne doivent donc pas
+    bloquer le déploiement.
+
+    :param root: Racine du dépôt à analyser.
+    :return: Chemins relatifs triés des fichiers analysables.
+    :rtype: list[Path]
+    """
+    return sorted(
+        path.relative_to(root)
+        for path in root.rglob("*")
+        if path.is_file() and _is_candidate(path.relative_to(root))
+    )
+
+
+def _staged_files(root: Path, runner: CommandRunner) -> list[Path]:
+    """Retourne les fichiers ajoutés ou modifiés actuellement indexés.
+
+    :param root: Racine du dépôt Git.
+    :param runner: Exécuteur de sous-processus injectable pour les tests.
+    :return: Chemins relatifs triés des fichiers indexés analysables.
+    :rtype: list[Path]
+    :raises RuntimeError: Si Git ne peut pas fournir les fichiers indexés.
+    """
+    result = runner(
+        ["git", "diff", "--cached", "--name-only", "-z", "--diff-filter=ACMR"],
+        cwd=root,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if result.returncode != 0:
+        raise RuntimeError("Impossible de lister les fichiers Git indexés") from None
+    paths = [Path(value) for value in result.stdout.split("\0") if value]
+    return sorted(path for path in paths if _is_candidate(path))
+
+
+def _staged_content_provider(root: Path, runner: CommandRunner) -> ContentProvider:
+    """Retourne un lecteur de contenu depuis l'index Git.
+
+    Lit le blob indexé via ``git show :<chemin>`` afin de ne pas dépendre de
+    l'état du working tree, dont la copie de travail peut différer de l'index.
+
+    :param root: Racine du dépôt Git.
+    :param runner: Exécuteur de sous-processus injectable pour les tests.
+    :return: Fonction de lecture du contenu indexé ; ``None`` si indisponible.
+    :rtype: ContentProvider
+    """
+
+    def provider(relative_path: Path) -> str | None:
+        result = runner(
+            ["git", "show", f":{relative_path}"],
+            cwd=root,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode != 0:
+            return None
+        return result.stdout
+
+    return provider
+
+
+def find_secrets(
+    root: Path,
+    files: Iterable[Path],
+    content_provider: ContentProvider | None = None,
+) -> list[SecretFinding]:
+    """Détecte les motifs de secrets littéraux dans les fichiers désignés.
+
+    Les lignes explicitement marquées ``secret-check: allow`` sont exclues :
+    cette échappatoire doit rester locale à une fixture ou un exemple contrôlé.
+
+    :param root: Racine du dépôt analysé.
+    :param files: Chemins relatifs à inspecter.
+    :param content_provider: Lecteur optionnel du contenu d'un fichier ; par
+        défaut le contenu est lu depuis le working tree via ``read_text``.
+        Si le lecteur retourne ``None`` ou lève une erreur d'encodage, le
+        fichier est ignoré.
+    :return: Résultats triés par chemin, ligne et règle.
+    :rtype: list[SecretFinding]
+    """
+    findings: list[SecretFinding] = []
+    for relative_path in files:
+        path = root / relative_path
+        try:
+            if content_provider is not None:
+                content = content_provider(relative_path)
+            else:
+                content = path.read_text(encoding="utf-8")
+            if content is None:
+                continue
+        except (OSError, UnicodeDecodeError):
+            continue
+        for number, line in enumerate(content.splitlines(), start=1):
+            if _ALLOWLIST_MARKER in line:
+                continue
+            is_literal_secret = _LITERAL_SECRET_RE.search(line) or (
+                relative_path.suffix in _UNQUOTED_CONFIG_SUFFIXES
+                and _UNQUOTED_SECRET_RE.search(line)
+            )
+            if is_literal_secret:
+                findings.append(SecretFinding(relative_path, number, "affectation-litterale"))
+            if _URL_SECRET_RE.search(line):
+                findings.append(SecretFinding(relative_path, number, "parametre-url"))
+    return sorted(findings, key=lambda finding: (str(finding.path), finding.line, finding.rule))
+
+
+def _parse_arguments(arguments: Sequence[str] | None = None) -> argparse.Namespace:
+    """Analyse les options de vérification.
+
+    :param arguments: Arguments explicites, ou ``None`` pour ceux du processus.
+    :return: Options validées.
+    :rtype: argparse.Namespace
+    """
+    parser = argparse.ArgumentParser(description="Vérifie les secrets avant déploiement.")
+    parser.add_argument(
+        "--staged",
+        action="store_true",
+        help="Analyse uniquement les fichiers ajoutés ou modifiés dans l'index Git.",
+    )
+    return parser.parse_args(arguments)
+
+
+def main(
+    arguments: Sequence[str] | None = None,
+    *,
+    root: Path | None = None,
+    runner: CommandRunner = subprocess.run,
+) -> int:
+    """Exécute la vérification de secrets et retourne un code de sortie.
+
+    :param arguments: Arguments de ligne de commande.
+    :param root: Racine à analyser ; le dépôt du script par défaut.
+    :param runner: Exécuteur Git injectable pour les tests.
+    :return: ``0`` sans motif, ``1`` si un motif est trouvé, ``2`` si le contrôle échoue.
+    :rtype: int
+    """
+    parsed_arguments = _parse_arguments(arguments)
+    repository_root = root or Path(__file__).resolve().parents[1]
+    try:
+        if parsed_arguments.staged:
+            files = _staged_files(repository_root, runner)
+            content_provider = _staged_content_provider(repository_root, runner)
+        else:
+            files = _repository_files(repository_root)
+            content_provider = None
+    except RuntimeError as error:
+        print(f"ERREUR: {error}")
+        return 2
+    findings = find_secrets(repository_root, files, content_provider=content_provider)
+    if not findings:
+        print("OK: aucun secret littéral détecté.")
+        return 0
+    for finding in findings:
+        print(f"ECHEC: {finding.path}:{finding.line} ({finding.rule})")
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

tests/e2e/test_cli.py

@@ -11,6 +11,23 @@ from pronote_sync.errors import PipelineCriticalError, PipelineWarning
 from pronote_sync.models.pronote import PronoteData
 
 
+def test_help_documents_strict_dry_run_contract(capsys: pytest.CaptureFixture[str]) -> None:
+    """L'aide CLI expose le contrat strict et l'incompatibilité QR/token.
+
+    :param capsys: Capture des sorties standard de pytest.
+    :return: None
+    """
+    from pronote_sync.cli.main import main
+
+    with pytest.raises(SystemExit) as exc_info:
+        main(["--help"])
+
+    output = " ".join(capsys.readouterr().out.split())
+    assert exc_info.value.code == 0
+    assert "sans sortie distante ni état local persistant" in output
+    assert "PRONOTE_AUTH_MODE=qr_token" in output
+
+
 def test_main_runs_composition_root_in_dry_run_with_requested_log_level(
     mocker: MockerFixture,
 ) -> None:

tests/fixtures/pronote-variants.ics

@@ -0,0 +1,53 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//pronote-sync tests//FR
+X-WR-CALNAME:Fixture anonymisée
+BEGIN:VEVENT
+UID:variant-normal
+DTSTART:20260910T080000Z
+DTEND:20260910T090000Z
+SUMMARY:Mathématiques
+CATEGORIES:Cours
+DESCRIPTION:<div>Matière : Mathématiques Professeur(s) : Enseignant A Salle(s) : 101 Groupe : Classe entière Partie(s) de classe : Groupe 1 <strong data-section="content">Contenu pédagogique :</strong><p>Leçon &amp; exemple</p><strong>Pour le 15/09/2026 :</strong><p>Lire le chapitre</p><strong>Donné le 10/09/2026 :</strong><p>Lire le chapitre</p></div>
+END:VEVENT
+BEGIN:VEVENT
+UID:variant-duplicate
+DTSTART:20260910T100000Z
+DTEND:20260910T110000Z
+SUMMARY:Mathématiques
+CATEGORIES:Cours
+DESCRIPTION:<div>Matière : Mathématiques Professeur(s) : Enseignant A Salle(s) : 102 <strong>Pour le 15/09/2026 :</strong><p>Lire le chapitre</p></div>
+END:VEVENT
+BEGIN:VEVENT
+UID:variant-same-text-other-context
+DTSTART:20260910T120000Z
+DTEND:20260910T130000Z
+SUMMARY:Sciences
+CATEGORIES:Cours
+DESCRIPTION:<div>Matière : Sciences Professeur(s) : Enseignant B Salle(s) : 103 <strong>Pour le 15/09/2026 :</strong><p>Lire le chapitre</p></div>
+END:VEVENT
+BEGIN:VEVENT
+UID:variant-moved
+DTSTART:20260911T080000Z
+DTEND:20260911T090000Z
+SUMMARY:Mathématiques
+CATEGORIES:Cours - Cours modifié
+DESCRIPTION:<div>Matière : Mathématiques Professeur : Enseignant A Salle : 204</div>
+END:VEVENT
+BEGIN:VEVENT
+UID:variant-public-holiday
+DTSTART;VALUE=DATE:20260914
+DTEND;VALUE=DATE:20260915
+SUMMARY:Journée fériée anonymisée
+CATEGORIES:Jours fériés
+DESCRIPTION:Journée sans cours.
+END:VEVENT
+BEGIN:VEVENT
+UID:variant-holiday
+DTSTART;VALUE=DATE:20261020
+DTEND;VALUE=DATE:20261022
+SUMMARY:Vacances anonymisées
+CATEGORIES:Congés
+DESCRIPTION:Période de vacances.
+END:VEVENT
+END:VCALENDAR

tests/fixtures/pronote-variants.manifest.json

@@ -0,0 +1,19 @@
+{
+  "version": "fixture-1",
+  "source": "ical",
+  "pronote_version": "2026-unknown",
+  "anonymized": true,
+  "scenarios": {
+    "normal_and_headers": "variant-normal",
+    "duplicate_homework_same_context": ["variant-normal", "variant-duplicate"],
+    "same_text_distinct_context": "variant-same-text-other-context",
+    "moved_lesson": "variant-moved",
+    "public_holiday": "variant-public-holiday",
+    "holiday_exclusive_end": "variant-holiday"
+  },
+  "invariants": [
+    "Aucune valeur d'authentification ou identité réelle n'est présente.",
+    "Les bornes de date d'un événement scolaire sont début inclusif et fin exclusive.",
+    "Les devoirs sont vérifiés après parsing dans les modèles métier finaux."
+  ]
+}

tests/integration/test_pipeline_runner.py

@@ -8,18 +8,26 @@ from typing import Any, cast
 import pytest
 from pydantic import SecretStr
 
-from pronote_sync.config.settings import AISettings, AppSettings, PronoteSettings, Settings
+from pronote_sync.config.settings import (
-from pronote_sync.errors import PipelineCriticalError, PipelineWarning
+    AISettings,
+    AppSettings,
+    BlogSettings,
+    PronoteSettings,
+    Settings,
+)
+from pronote_sync.errors import PipelineCriticalError, PipelineWarning, PronoteAuthRotationError
 from pronote_sync.models.agenda import Lesson, LessonStatus, SchoolEvent
 from pronote_sync.models.blog import BlogArticle
 from pronote_sync.models.diff import AgendaDiff
 from pronote_sync.models.homework import Homework
 from pronote_sync.models.message import Message
 from pronote_sync.models.sync import CalDAVSyncResult, CalDAVSyncStatus
+from pronote_sync.models.xmpp import XmppMessage
 from pronote_sync.pipeline.run import PipelineRunner
 from pronote_sync.sources.blog.result import BlogRSSFetchResult
 from pronote_sync.sources.blog.rss import BlogRSSClient
 from pronote_sync.sources.blog.state import BlogRSSState
+from pronote_sync.sources.pronote.auth_state import PronoteAuthState
 from pronote_sync.sources.pronote.fallback import PronoteFetcher
 from pronote_sync.sync.diff import AgendaComparator
 
@@ -393,6 +401,145 @@ def test_from_settings_with_theoretical_agenda_instantiates_comparator(
     assert isinstance(runner._agenda_comparator, RecordingComparator)
 
 
+def test_from_settings_password_mode_passes_auth_state_none(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Password mode (default) constructs PronoteClient with auth_state=None."""
+    import pronote_sync.pipeline.run as run_module
+
+    constructed: list[tuple[object, object]] = []
+
+    class RecordingClient:
+        """PronoteClient constructor recording the supplied auth_state."""
+
+        def __init__(self, settings: PronoteSettings, *, auth_state: object) -> None:
+            """Record the constructor arguments used by the composition root.
+
+            :param settings: Pronote settings supplied by the composition root.
+            :param auth_state: Auth state handler supplied by the composition root.
+            """
+            constructed.append((settings, auth_state))
+
+    monkeypatch.setattr(run_module, "PronoteClient", RecordingClient)
+
+    PipelineRunner.from_settings(Settings())
+
+    assert len(constructed) == 1
+    assert constructed[0][1] is None
+
+
+def test_from_settings_rejects_qr_token_dry_run_before_constructing_pronote_client(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """QR-token dry-run fails before authentication or data dependencies are created."""
+    import pronote_sync.pipeline.run as run_module
+
+    qr_pin_sentinel = "qr-pin-must-not-appear"
+    constructed: list[object] = []
+
+    class FailingClient:
+        """Pronote client sentinel that makes unexpected construction explicit."""
+
+        def __init__(self, settings: PronoteSettings, *, auth_state: object) -> None:
+            """Record and reject any unexpected client construction.
+
+            :param settings: Pronote settings supplied by the composition root.
+            :param auth_state: Authentication state supplied by the composition root.
+            """
+            del settings, auth_state
+            constructed.append(object())
+            raise AssertionError("PronoteClient must not be constructed for QR-token dry-run")
+
+    monkeypatch.setattr(run_module, "PronoteClient", FailingClient)
+
+    with pytest.raises(ValueError) as exc_info:
+        PipelineRunner.from_settings(
+            Settings(
+                app=AppSettings(dry_run=True),
+                pronote=PronoteSettings(
+                    auth_mode="qr_token",
+                    qr_pin=SecretStr(qr_pin_sentinel),
+                ),
+            )
+        )
+
+    assert "qr_token" in str(exc_info.value)
+    assert "dry-run" in str(exc_info.value)
+    assert qr_pin_sentinel not in str(exc_info.value)
+    assert constructed == []
+
+
+def test_from_settings_qr_token_mode_passes_auth_state_instance(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """QR-token mode constructs PronoteClient with a PronoteAuthState instance."""
+    import pronote_sync.pipeline.run as run_module
+
+    constructed: list[tuple[object, object]] = []
+
+    class RecordingClient:
+        """PronoteClient constructor recording the supplied auth_state."""
+
+        def __init__(self, settings: PronoteSettings, *, auth_state: object) -> None:
+            """Record the constructor arguments used by the composition root.
+
+            :param settings: Pronote settings supplied by the composition root.
+            :param auth_state: Auth state handler supplied by the composition root.
+            """
+            constructed.append((settings, auth_state))
+
+    monkeypatch.setattr(run_module, "PronoteClient", RecordingClient)
+
+    PipelineRunner.from_settings(Settings(pronote=PronoteSettings(auth_mode="qr_token")))
+
+    assert len(constructed) == 1
+    assert isinstance(constructed[0][1], PronoteAuthState)
+
+
+@pytest.mark.parametrize("dry_run", [False, True])
+def test_from_settings_configures_source_state_persistence_for_dry_run(
+    monkeypatch: pytest.MonkeyPatch,
+    dry_run: bool,
+) -> None:
+    """Composition disables source-state persistence only in dry-run mode."""
+    import pronote_sync.pipeline.run as run_module
+
+    blog_persistence: list[bool] = []
+
+    class RecordingBlogState:
+        """Blog state factory recording its persistence configuration."""
+
+        def __init__(self, *, persistence_enabled: bool = True) -> None:
+            """Record the requested persistence setting.
+
+            :param persistence_enabled: Whether disk writes are enabled.
+            """
+            blog_persistence.append(persistence_enabled)
+
+    class RecordingClient:
+        """Pronote client constructor accepting the injected auth state."""
+
+        def __init__(self, settings: PronoteSettings, *, auth_state: object) -> None:
+            """Accept the composition-root dependencies.
+
+            :param settings: Pronote settings.
+            :param auth_state: Injected authentication state.
+            """
+            del settings, auth_state
+
+    monkeypatch.setattr(run_module, "BlogRSSState", RecordingBlogState)
+    monkeypatch.setattr(run_module, "PronoteClient", RecordingClient)
+
+    PipelineRunner.from_settings(
+        Settings(
+            app=AppSettings(dry_run=dry_run),
+            blog=BlogSettings(enabled=True),
+        )
+    )
+
+    assert blog_persistence == [not dry_run]
+
+
 def test_runner_reuses_ical_download_and_parse_within_one_run(
     monkeypatch: pytest.MonkeyPatch,
     pipeline_inputs: tuple[Lesson, Homework],
@@ -1063,3 +1210,338 @@ def test_runner_ical_cache_cleanup_on_second_run(
         "https://pronote.example.test/calendar.ics",
         "https://pronote.example.test/calendar.ics",
     ]
+
+
+def test_rotation_error_sends_xmpp_notification() -> None:
+    """Une PronoteAuthRotationError envoie une notification XMPP puis retourne un résultat dégradé.
+
+    Ce test vérifie que l'erreur de rotation se propage à travers le pipeline réel
+    (PronoteFetcher → fetch_step → PipelineRunner.run) et déclenche une notification XMPP
+    avec un message actionnable.
+    """
+    calls: list[str] = []
+    channel = StubChannel(calls)
+
+    # Créer un client Pronote qui lève PronoteAuthRotationError
+    class RotatingPronoteClient:
+        """Client Pronote qui simule une erreur de rotation de token."""
+
+        def get_lessons(self, start: date, end: date) -> list[Lesson]:
+            """Lève l'erreur de rotation lors de la récupération des cours.
+
+            :param start: Début de la fenêtre (ignoré).
+            :param end: Fin de la fenêtre (ignoré).
+            :return: Ne retourne jamais.
+            :raises PronoteAuthRotationError: Toujours.
+            """
+            del start, end
+            raise PronoteAuthRotationError("Token persisté expiré : ré-enrôlement requis")
+
+        def get_homeworks(self, start: date, end: date) -> list[Homework]:
+            """Ne devrait pas être appelé si fetch_agenda échoue.
+
+            :param start: Début de la fenêtre (ignoré).
+            :param end: Fin de la fenêtre (ignoré).
+            :return: Liste vide.
+            :rtype: list[Homework]
+            """
+            del start, end
+            return []
+
+        def get_messages(self) -> list[Message]:
+            """Ne devrait pas être appelé si fetch_agenda échoue.
+
+            :return: Liste vide.
+            :rtype: list[Message]
+            """
+            return []
+
+        def get_informations(self) -> list[Message]:
+            """Ne devrait pas être appelé si fetch_agenda échoue.
+
+            :return: Liste vide.
+            :rtype: list[Message]
+            """
+            return []
+
+    settings = Settings(
+        pronote=PronoteSettings(
+            url="https://pronote.example.com",
+            username="test",
+            password=SecretStr("test_password"),
+            ent="bordeaux",
+            account_type="parent",
+            agenda_source="pronotepy",
+            homework_source="pronotepy",
+        )
+    )
+
+    runner = PipelineRunner(
+        settings=settings,
+        pronote_fetcher=PronoteFetcher(settings, RotatingPronoteClient()),
+        channel=channel,
+        now_provider=lambda: datetime(2026, 9, 8, 7, 0),
+    )
+
+    data, errors = runner.run()
+
+    assert data is None
+    assert len(errors) == 1
+    assert isinstance(errors[0], PipelineCriticalError)
+    assert len(channel.messages) == 1
+    message = channel.messages[0]
+    assert isinstance(message, XmppMessage)
+    assert message.target_date == date(2026, 9, 8)
+    assert message.synthesis is not None
+    assert "Rotation" in message.synthesis
+    assert "token" in message.synthesis
+    assert "QR code" in message.synthesis
+
+
+def test_rotation_error_no_channel_no_xmpp_send() -> None:
+    """Sans canal XMPP, l'erreur de rotation ne tente aucun envoi.
+
+    Ce test vérifie que même sans canal XMPP configuré, l'erreur de rotation
+    est correctement capturée et retournée dans la liste des erreurs.
+    """
+
+    class RotatingPronoteClient:
+        """Client Pronote qui simule une erreur de rotation de token."""
+
+        def get_lessons(self, start: date, end: date) -> list[Lesson]:
+            """Lève l'erreur de rotation lors de la récupération des cours.
+
+            :param start: Début de la fenêtre (ignoré).
+            :param end: Fin de la fenêtre (ignoré).
+            :return: Ne retourne jamais.
+            :raises PronoteAuthRotationError: Toujours.
+            """
+            del start, end
+            raise PronoteAuthRotationError("Token persisté expiré : ré-enrôlement requis")
+
+        def get_homeworks(self, start: date, end: date) -> list[Homework]:
+            """Ne devrait pas être appelé.
+
+            :param start: Début de la fenêtre (ignoré).
+            :param end: Fin de la fenêtre (ignoré).
+            :return: Liste vide.
+            :rtype: list[Homework]
+            """
+            del start, end
+            return []
+
+        def get_messages(self) -> list[Message]:
+            """Ne devrait pas être appelé.
+
+            :return: Liste vide.
+            :rtype: list[Message]
+            """
+            return []
+
+        def get_informations(self) -> list[Message]:
+            """Ne devrait pas être appelé.
+
+            :return: Liste vide.
+            :rtype: list[Message]
+            """
+            return []
+
+    settings = Settings(
+        pronote=PronoteSettings(
+            url="https://pronote.example.com",
+            username="test",
+            password=SecretStr("test_password"),
+            ent="bordeaux",
+            account_type="parent",
+            agenda_source="pronotepy",
+            homework_source="pronotepy",
+        )
+    )
+
+    runner = PipelineRunner(
+        settings=settings,
+        pronote_fetcher=PronoteFetcher(settings, RotatingPronoteClient()),
+        channel=None,
+        now_provider=lambda: datetime(2026, 9, 8, 7, 0),
+    )
+
+    data, errors = runner.run()
+
+    assert data is None
+    assert len(errors) == 1
+    assert isinstance(errors[0], PipelineCriticalError)
+
+
+def test_rotation_error_dry_run_no_xmpp_send() -> None:
+    """En dry-run, l'erreur de rotation n'envoie aucune notification XMPP.
+
+    Ce test vérifie que même en mode dry-run, l'erreur de rotation est correctement
+    capturée et retournée, mais aucune notification XMPP n'est envoyée.
+    """
+
+    class RotatingPronoteClient:
+        """Client Pronote qui simule une erreur de rotation de token."""
+
+        def get_lessons(self, start: date, end: date) -> list[Lesson]:
+            """Lève l'erreur de rotation lors de la récupération des cours.
+
+            :param start: Début de la fenêtre (ignoré).
+            :param end: Fin de la fenêtre (ignoré).
+            :return: Ne retourne jamais.
+            :raises PronoteAuthRotationError: Toujours.
+            """
+            del start, end
+            raise PronoteAuthRotationError("Token persisté expiré : ré-enrôlement requis")
+
+        def get_homeworks(self, start: date, end: date) -> list[Homework]:
+            """Ne devrait pas être appelé.
+
+            :param start: Début de la fenêtre (ignoré).
+            :param end: Fin de la fenêtre (ignoré).
+            :return: Liste vide.
+            :rtype: list[Homework]
+            """
+            del start, end
+            return []
+
+        def get_messages(self) -> list[Message]:
+            """Ne devrait pas être appelé.
+
+            :return: Liste vide.
+            :rtype: list[Message]
+            """
+            return []
+
+        def get_informations(self) -> list[Message]:
+            """Ne devrait pas être appelé.
+
+            :return: Liste vide.
+            :rtype: list[Message]
+            """
+            return []
+
+    calls: list[str] = []
+    channel = StubChannel(calls)
+
+    settings = Settings(
+        pronote=PronoteSettings(
+            url="https://pronote.example.com",
+            username="test",
+            password=SecretStr("test_password"),
+            ent="bordeaux",
+            account_type="parent",
+            agenda_source="pronotepy",
+            homework_source="pronotepy",
+            messages_source="pronotepy",
+            auth_mode="password",
+            qr_code_file=None,
+            qr_pin=None,
+            ical_url=None,
+        )
+    )
+
+    runner = PipelineRunner(
+        settings=settings,
+        pronote_fetcher=PronoteFetcher(settings, RotatingPronoteClient()),
+        channel=channel,
+        dry_run=True,
+        now_provider=lambda: datetime(2026, 9, 8, 7, 0),
+    )
+
+    data, errors = runner.run()
+
+    assert data is None
+    assert len(errors) == 1
+    assert isinstance(errors[0], PipelineCriticalError)
+    assert channel.messages == []
+    assert "send" not in calls
+
+
+def test_no_secrets_in_xmpp_message() -> None:
+    """La synthèse XMPP de rotation ne contient aucun secret (token, PIN, URL).
+
+    Ce test vérifie que le message XMPP généré pour une erreur de rotation
+    ne contient aucun secret sensible, même si l'erreur originale en contenait.
+    """
+
+    class RotatingPronoteClient:
+        """Client Pronote qui simule une erreur de rotation avec secrets dans message."""
+
+        def get_lessons(self, start: date, end: date) -> list[Lesson]:
+            """Lève l'erreur de rotation avec message contenant des secrets.
+
+            :param start: Début de la fenêtre (ignoré).
+            :param end: Fin de la fenêtre (ignoré).
+            :return: Ne retourne jamais.
+            :raises PronoteAuthRotationError: Toujours, avec des secrets dans le message.
+            """
+            del start, end
+            raise PronoteAuthRotationError(
+                "Token sk-sentinel-token-987654 invalide et PIN 000000 pour "
+                "https://pronote.sentinel.example/icalsecurise"
+            )
+
+        def get_homeworks(self, start: date, end: date) -> list[Homework]:
+            """Ne devrait pas être appelé.
+
+            :param start: Début de la fenêtre (ignoré).
+            :param end: Fin de la fenêtre (ignoré).
+            :return: Liste vide.
+            :rtype: list[Homework]
+            """
+            del start, end
+            return []
+
+        def get_messages(self) -> list[Message]:
+            """Ne devrait pas être appelé.
+
+            :return: Liste vide.
+            :rtype: list[Message]
+            """
+            return []
+
+        def get_informations(self) -> list[Message]:
+            """Ne devrait pas être appelé.
+
+            :return: Liste vide.
+            :rtype: list[Message]
+            """
+            return []
+
+    channel = StubChannel([])
+
+    settings = Settings(
+        pronote=PronoteSettings(
+            url="https://pronote.example.com",
+            username="test",
+            password=SecretStr("test_password"),
+            ent="bordeaux",
+            account_type="parent",
+            agenda_source="pronotepy",
+            homework_source="pronotepy",
+        )
+    )
+
+    runner = PipelineRunner(
+        settings=settings,
+        pronote_fetcher=PronoteFetcher(settings, RotatingPronoteClient()),
+        channel=channel,
+        now_provider=lambda: datetime(2026, 9, 8, 7, 0),
+    )
+
+    data, errors = runner.run()
+
+    assert data is None
+    assert len(errors) == 1
+    assert len(channel.messages) == 1
+    message = channel.messages[0]
+    assert isinstance(message, XmppMessage)
+    assert message.synthesis is not None
+    # Vérifier que les secrets ne sont pas dans le message final
+    assert "sk-sentinel-token-987654" not in message.synthesis
+    assert "000000" not in message.synthesis
+    assert "pronote.sentinel.example" not in message.synthesis
+    # Vérifier que le message contient les instructions actionnables
+    assert ".pronote_auth_state.json" in message.synthesis
+    assert "PRONOTE_QR_CODE_FILE" in message.synthesis
+    assert "PRONOTE_QR_PIN" in message.synthesis

tests/integration/test_xmpp_integration.py

@@ -67,7 +67,7 @@ class FakeClientXMPP:
         :param handler: Fonction gestionnaire.
         :raises: AssertionError si l'événement n'est pas supporté.
         """
-        if name not in ("session_start", "failed_auth", "disconnected"):
+        if name not in ("session_start", "failed_auth", "connection_failed", "disconnected"):
             raise AssertionError(f"Unsupported event: {name}")
         self.handlers.setdefault(name, []).append(handler)
 

tests/unit/test_blog_state.py

@@ -35,6 +35,49 @@ def test_state_file_absent_empty_state(tmp_path: Path) -> None:
     assert state.get_cache_headers() == (None, None)
 
 
+def test_disabled_persistence_keeps_updates_in_memory_without_creating_file(tmp_path: Path) -> None:
+    """Vérifie que la persistance désactivée conserve l'état uniquement en mémoire.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state_file = tmp_path / "state.json"
+    state = BlogRSSState(state_file, persistence_enabled=False)
+
+    state.add_guids(["guid-1"])
+    state.update_cache_headers("etag-123", "Wed, 01 Sep 2026 GMT")
+
+    assert state.get_known_guids() == frozenset({"guid-1"})
+    assert state.get_cache_headers() == ("etag-123", "Wed, 01 Sep 2026 GMT")
+    assert not state_file.exists()
+
+
+def test_disabled_persistence_preserves_existing_file(tmp_path: Path) -> None:
+    """Vérifie que la persistance désactivée ne modifie pas l'état déjà stocké.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state_file = tmp_path / "state.json"
+    original_content = json.dumps(
+        {
+            "version": 1,
+            "known_guids": ["existing-guid"],
+            "etag": "old-etag",
+            "last_modified": "Tue, 31 Aug 2026 GMT",
+        }
+    )
+    state_file.write_text(original_content, encoding="utf-8")
+    state = BlogRSSState(state_file, persistence_enabled=False)
+
+    state.add_guids(["new-guid"])
+    state.update_cache_headers("new-etag", "Wed, 01 Sep 2026 GMT")
+
+    assert state.get_known_guids() == frozenset({"existing-guid", "new-guid"})
+    assert state.get_cache_headers() == ("new-etag", "Wed, 01 Sep 2026 GMT")
+    assert state_file.read_text(encoding="utf-8") == original_content
+
+
 def test_add_guids_persists(tmp_path: Path) -> None:
     """Vérifie que l'ajout de GUID persiste dans le fichier JSON.
 

tests/unit/test_check_secrets.py

@@ -0,0 +1,249 @@
+"""Tests unitaires du contrôle de secrets de déploiement."""
+
+from __future__ import annotations
+
+import importlib.util
+import subprocess
+import sys
+from pathlib import Path
+from types import ModuleType
+from typing import TYPE_CHECKING
+
+import pytest
+
+if TYPE_CHECKING:
+    from _pytest.capture import CaptureFixture
+
+
+@pytest.fixture
+def secret_checker() -> ModuleType:
+    """Charge le script de vérification sans l'exécuter comme programme.
+
+    :return: Module du script de contrôle de secrets.
+    :rtype: ModuleType
+    """
+    script_path = Path(__file__).parents[2] / "scripts" / "check_secrets.py"
+    specification = importlib.util.spec_from_file_location("check_secrets", script_path)
+    assert specification is not None
+    assert specification.loader is not None
+    module = importlib.util.module_from_spec(specification)
+    sys.modules[specification.name] = module
+    try:
+        specification.loader.exec_module(module)
+    finally:
+        del sys.modules[specification.name]
+    return module
+
+
+def test_main_accepts_clean_files_and_ignores_environment_file(
+    secret_checker: ModuleType, tmp_path: Path, capsys: CaptureFixture[str]
+) -> None:
+    """Vérifie qu'un dépôt propre réussit sans analyser le fichier d'environnement.
+
+    :param secret_checker: Module du script sous test.
+    :param tmp_path: Répertoire temporaire représentant un dépôt.
+    :param capsys: Fixture de capture de sortie.
+    :return: None
+    """
+    (tmp_path / "application.py").write_text("value = 'safe'\n", encoding="utf-8")
+    ignored_environment_secret = 'password = "private-value"\n'  # pragma: allowlist secret
+    (tmp_path / ".env").write_text(
+        ignored_environment_secret, encoding="utf-8"
+    )  # secret-check: allow
+
+    assert secret_checker.main([], root=tmp_path) == 0
+    assert "OK:" in capsys.readouterr().out
+
+
+def test_main_reports_a_literal_secret_without_disclosing_its_value(
+    secret_checker: ModuleType, tmp_path: Path, capsys: CaptureFixture[str]
+) -> None:
+    """Vérifie qu'un secret littéral échoue sans fuite de sa valeur.
+
+    :param secret_checker: Module du script sous test.
+    :param tmp_path: Répertoire temporaire représentant un dépôt.
+    :param capsys: Fixture de capture de sortie.
+    :return: None
+    """
+    sentinel = "m14-literal-sentinel"
+    (tmp_path / "settings.py").write_text(
+        f'password = "{sentinel}"\n', encoding="utf-8"
+    )  # secret-check: allow
+
+    assert secret_checker.main([], root=tmp_path) == 1
+    output = capsys.readouterr().out
+    assert "settings.py:1 (affectation-litterale)" in output
+    assert sentinel not in output
+
+
+def test_main_reports_an_unquoted_configuration_secret_without_disclosing_its_value(
+    secret_checker: ModuleType, tmp_path: Path, capsys: CaptureFixture[str]
+) -> None:
+    """Vérifie qu'un secret de configuration non cité échoue sans fuite de sa valeur.
+
+    :param secret_checker: Module du script sous test.
+    :param tmp_path: Répertoire temporaire représentant un dépôt.
+    :param capsys: Fixture de capture de sortie.
+    :return: None
+    """
+    sentinel = "m14-unquoted-sentinel"
+    (tmp_path / "settings.yaml").write_text(
+        f"password: {sentinel}\n", encoding="utf-8"
+    )  # secret-check: allow
+
+    assert secret_checker.main([], root=tmp_path) == 1
+    output = capsys.readouterr().out
+    assert "settings.yaml:1 (affectation-litterale)" in output
+    assert sentinel not in output
+
+
+def test_main_detects_sensitive_url_parameter(
+    secret_checker: ModuleType, tmp_path: Path, capsys: CaptureFixture[str]
+) -> None:
+    """Vérifie qu'un paramètre URL sensible déclenche un échec.
+
+    :param secret_checker: Module du script sous test.
+    :param tmp_path: Répertoire temporaire représentant un dépôt.
+    :param capsys: Fixture de capture de sortie.
+    :return: None
+    """
+    sentinel = "m14-url-sentinel"
+    (tmp_path / "settings.yaml").write_text(
+        f"url: https://example.invalid/calendar?icalsecurise={sentinel}\n", encoding="utf-8"
+    )  # secret-check: allow
+
+    assert secret_checker.main([], root=tmp_path) == 1
+    output = capsys.readouterr().out
+    assert "settings.yaml:1 (parametre-url)" in output
+    assert sentinel not in output
+
+
+def test_staged_mode_inspects_only_paths_provided_by_git(
+    secret_checker: ModuleType, tmp_path: Path, capsys: CaptureFixture[str]
+) -> None:
+    """Vérifie que l'option staged ignore les fichiers non indexés.
+
+    :param secret_checker: Module du script sous test.
+    :param tmp_path: Répertoire temporaire représentant un dépôt.
+    :param capsys: Fixture de capture de sortie.
+    :return: None
+    """
+    (tmp_path / "indexed.py").write_text("answer = 42\n", encoding="utf-8")
+    untracked_secret = 'api_key = "m14-untracked-sentinel"\n'  # pragma: allowlist secret
+    (tmp_path / "untracked.py").write_text(
+        untracked_secret, encoding="utf-8"
+    )  # secret-check: allow
+
+    def runner(*_args: object, **_kwargs: object) -> subprocess.CompletedProcess[str]:
+        """Simule Git avec un seul fichier indexé.
+
+        :return: Résultat Git simulé.
+        :rtype: subprocess.CompletedProcess[str]
+        """
+        return subprocess.CompletedProcess([], 0, stdout="indexed.py\0", stderr="")
+
+    assert secret_checker.main(["--staged"], root=tmp_path, runner=runner) == 0
+    assert "OK:" in capsys.readouterr().out
+
+
+def test_main_detects_prefixed_secret_assignment(
+    secret_checker: ModuleType, tmp_path: Path, capsys: CaptureFixture[str]
+) -> None:
+    """Vérifie qu'une variable préfixée (PRONOTE_PASSWORD) est détectée.
+
+    :param secret_checker: Module du script sous test.
+    :param tmp_path: Répertoire temporaire représentant un dépôt.
+    :param capsys: Fixture de capture de sortie.
+    :return: None
+    """
+    sentinel = "m14-prefixed-secret"
+    (tmp_path / "config.py").write_text(
+        f'PRONOTE_PASSWORD = "{sentinel}"\n', encoding="utf-8"
+    )  # secret-check: allow
+
+    assert secret_checker.main([], root=tmp_path) == 1
+    output = capsys.readouterr().out
+    assert "config.py:1" in output
+    assert sentinel not in output
+
+
+def test_main_detects_short_secret_assignment(
+    secret_checker: ModuleType, tmp_path: Path, capsys: CaptureFixture[str]
+) -> None:
+    """Vérifie qu'un secret court (< 8 caractères) est détecté.
+
+    :param secret_checker: Module du script sous test.
+    :param tmp_path: Répertoire temporaire représentant un dépôt.
+    :param capsys: Fixture de capture de sortie.
+    :return: None
+    """
+    sentinel = "s3cr3t"
+    (tmp_path / "config.py").write_text(
+        f'password = "{sentinel}"\n', encoding="utf-8"
+    )  # secret-check: allow
+
+    assert secret_checker.main([], root=tmp_path) == 1
+    output = capsys.readouterr().out
+    assert "config.py:1" in output
+    assert sentinel not in output
+
+
+def test_staged_mode_reads_index_content_not_working_tree(
+    secret_checker: ModuleType, tmp_path: Path, capsys: CaptureFixture[str]
+) -> None:
+    """Vérifie que --staged lit le contenu indexé, pas le working tree.
+
+    :param secret_checker: Module du script sous test.
+    :param tmp_path: Répertoire temporaire représentant un dépôt.
+    :param capsys: Fixture de capture de sortie.
+    :return: None
+    """
+    indexed_secret = "m14-indexed-only-secret"  # pragma: allowlist secret
+    (tmp_path / "staged.py").write_text(
+        f'password = "{indexed_secret}"\n', encoding="utf-8"
+    )  # secret-check: allow
+    (tmp_path / "staged.py").write_text('value = "safe"\n', encoding="utf-8")
+
+    def runner(*args: object, **_kwargs: object) -> subprocess.CompletedProcess[str]:
+        """Simule Git en renvoyant le contenu indexé pour le blob demandé.
+
+        :return: Résultat Git simulé.
+        :rtype: subprocess.CompletedProcess[str]
+        """
+        first_argument = args[0] if args else []
+        command = (
+            [str(argument) for argument in first_argument]
+            if isinstance(first_argument, list)
+            else []
+        )
+        if "show" in command:
+            return subprocess.CompletedProcess(
+                command, 0, stdout=f'password = "{indexed_secret}"\n', stderr=""
+            )
+        return subprocess.CompletedProcess(command, 0, stdout="staged.py\0", stderr="")
+
+    assert secret_checker.main(["--staged"], root=tmp_path, runner=runner) == 1
+    output = capsys.readouterr().out
+    assert "staged.py:1" in output
+    assert indexed_secret not in output
+
+
+def test_main_scans_extensionless_deployment_file(
+    secret_checker: ModuleType, tmp_path: Path, capsys: CaptureFixture[str]
+) -> None:
+    """Vérifie qu'un fichier de déploiement sans extension est scanné.
+
+    :param secret_checker: Module du script sous test.
+    :param tmp_path: Répertoire temporaire représentant un dépôt.
+    :param capsys: Fixture de capture de sortie.
+    :return: None
+    """
+    sentinel = "m14-logrotate-secret"
+    (tmp_path / "pronote_sync").write_text(
+        f'password = "{sentinel}"\n', encoding="utf-8"
+    )  # secret-check: allow
+
+    assert secret_checker.main([], root=tmp_path) == 1
+    output = capsys.readouterr().out
+    assert "pronote_sync:1" in output
+    assert sentinel not in output

tests/unit/test_config.py

@@ -116,4 +116,95 @@ def test_no_singleton_import() -> None:
         )
 
 
+def test_url_from_pronote_url_env_var(monkeypatch: MonkeyPatch) -> None:
+    """Vérifie que PRONOTE_URL mappe au champ url via le préfixe PRONOTE_.
+
+    Ce test couvre la régression où PRONOTE_URL n'était pas mappé vers le
+    champ du modèle à cause du double préfixe PRONOTE_.
+
+    :param monkeypatch: Fixture pytest pour modifier temporairement l'environnement.
+    :return: None
+    """
+    test_url = "https://example.index-education.net/pronote/parent.html"
+    monkeypatch.setenv("PRONOTE_URL", test_url)
+    settings = load_settings()
+    assert settings.pronote.url == test_url
+
+
+def test_auth_mode_default_password() -> None:
+    """Vérifie que ``auth_mode`` vaut ``"password"`` par défaut.
+
+    :return: None
+    """
+    settings = PronoteSettings()
+    assert settings.auth_mode == "password"
+
+
+def test_auth_mode_env_qr_token(monkeypatch: MonkeyPatch) -> None:
+    """Vérifie que ``PRONOTE_AUTH_MODE=qr_token`` est chargé correctement.
+
+    :param monkeypatch: Fixture pytest pour modifier temporairement l'environnement.
+    :return: None
+    """
+    monkeypatch.setenv("PRONOTE_AUTH_MODE", "qr_token")
+    settings = load_settings()
+    assert settings.pronote.auth_mode == "qr_token"
+
+
+def test_qr_pin_loaded_as_secretstr_and_masked(monkeypatch: MonkeyPatch) -> None:
+    """Vérifie que ``PRONOTE_QR_PIN`` est chargé en ``SecretStr`` et masqué.
+
+    Le PIN ne doit apparaître nulle part dans les représentations textuelles
+    (str, repr, JSON) : seul le masque ``**********`` est visible.
+
+    :param monkeypatch: Fixture pytest pour modifier temporairement l'environnement.
+    :return: None
+    """
+    monkeypatch.setenv("PRONOTE_QR_PIN", "123456")
+    settings = load_settings()
+    assert isinstance(settings.pronote.qr_pin, SecretStr)
+    assert settings.pronote.qr_pin.get_secret_value() == "123456"
+
+    str_repr = str(settings)
+    assert "123456" not in str_repr
+    assert "**********" in str_repr
+
+    repr_repr = repr(settings)
+    assert "123456" not in repr_repr
+    assert "**********" in repr_repr
+
+    json_str = settings.model_dump_json()
+    assert "123456" not in json_str
+    assert "**********" in json_str
+
+
+def test_qr_code_file_loaded_as_plain_string(monkeypatch: MonkeyPatch) -> None:
+    """Vérifie que ``PRONOTE_QR_CODE_FILE`` est chargé comme chaîne simple.
+
+    :param monkeypatch: Fixture pytest pour modifier temporairement l'environnement.
+    :return: None
+    """
+    monkeypatch.setenv("PRONOTE_QR_CODE_FILE", "/data/qr_code.png")
+    settings = load_settings()
+    assert isinstance(settings.pronote.qr_code_file, str)
+    assert settings.pronote.qr_code_file == "/data/qr_code.png"
+
+
+def test_qr_pin_in_redaction_secrets(monkeypatch: MonkeyPatch) -> None:
+    """Vérifie que le PIN QR est collecté pour la rédaction des secrets.
+
+    Le ``SecretStr`` du PIN doit figurer dans ``redaction_secrets()`` et sa
+    représentation textuelle doit rester masquée.
+
+    :param monkeypatch: Fixture pytest pour modifier temporairement l'environnement.
+    :return: None
+    """
+    monkeypatch.setenv("PRONOTE_QR_PIN", "654321")
+    settings = load_settings()
+    secrets = settings.redaction_secrets()
+    assert settings.pronote.qr_pin in secrets
+    assert "654321" not in repr(settings.pronote.qr_pin)
+    assert "**********" in repr(settings.pronote.qr_pin)
+
+
 # Ensure trailing newline

tests/unit/test_fallback.py

@@ -53,7 +53,7 @@ def fixture_mock_settings() -> Settings:
     """
     return Settings(
         pronote=PronoteSettings(
-            pronote_url="https://pronote.example.com",
+            url="https://pronote.example.com",
             ical_url=SecretStr("file:///fake/ical.ics"),
             agenda_source="auto",
             homework_source="auto",
@@ -251,7 +251,7 @@ def test_fetch_agenda_auto_both_fail(mock_fetcher: PronoteFetcher) -> None:
     :rtype: None
     """
     # Disable pronotepy so fallback is None
-    mock_fetcher._settings.pronote.pronote_url = None
+    mock_fetcher._settings.pronote.url = None
 
     with (
         patch("pronote_sync.sources.pronote.fallback.fetch_ical") as m_fetch_ical,
@@ -280,7 +280,7 @@ def test_fetch_agenda_ical_mode_failure(mock_fetcher: PronoteFetcher) -> None:
     """
     # Override settings to use ical mode explicitly and disable fallback
     mock_fetcher._settings.pronote.agenda_source = "ical"
-    mock_fetcher._settings.pronote.pronote_url = None
+    mock_fetcher._settings.pronote.url = None
 
     with (
         patch("pronote_sync.sources.pronote.fallback.fetch_ical") as m_fetch_ical,
@@ -438,7 +438,7 @@ def test_fetch_homework_auto_both_fail(mock_fetcher: PronoteFetcher) -> None:
     target_date = date(2025, 9, 10)
 
     # Disable pronotepy so fallback is None
-    mock_fetcher._settings.pronote.pronote_url = None
+    mock_fetcher._settings.pronote.url = None
 
     with (
         patch("pronote_sync.sources.pronote.fallback.fetch_ical") as m_fetch_ical,
@@ -531,7 +531,7 @@ def test_no_secrets_in_error_messages(
     :rtype: None
     """
     # Disable pronotepy so fallback is None to trigger PipelineCriticalError
-    mock_fetcher._settings.pronote.pronote_url = None
+    mock_fetcher._settings.pronote.url = None
 
     with (
         patch("pronote_sync.sources.pronote.fallback.fetch_ical") as m_fetch_ical,
@@ -629,7 +629,7 @@ def test_fetch_agenda_no_source_configured_raises(mock_fetcher: PronoteFetcher)
     """
     # Disable both sources
     mock_fetcher._settings.pronote.ical_url = None
-    mock_fetcher._settings.pronote.pronote_url = None
+    mock_fetcher._settings.pronote.url = None
 
     with pytest.raises(PipelineCriticalError) as exc_info:
         mock_fetcher.fetch_agenda()
@@ -1020,7 +1020,7 @@ def test_homework_sources_explicit_ical_mode_strict(mock_fetcher: PronoteFetcher
     assert fallback is None
 
     # Without pronotepy configured
-    mock_fetcher._settings.pronote.pronote_url = None
+    mock_fetcher._settings.pronote.url = None
     primary, fallback = mock_fetcher._homework_sources()
     assert primary == "ical"
     assert fallback is None
@@ -1080,7 +1080,7 @@ def test_homework_sources_auto_no_source_configured_raises(mock_fetcher: Pronote
     """
     mock_fetcher._settings.pronote.homework_source = "auto"
     mock_fetcher._settings.pronote.ical_url = None
-    mock_fetcher._settings.pronote.pronote_url = None
+    mock_fetcher._settings.pronote.url = None
 
     with pytest.raises(PipelineCriticalError) as exc_info:
         mock_fetcher._homework_sources()
@@ -1088,6 +1088,102 @@ def test_homework_sources_auto_no_source_configured_raises(mock_fetcher: Pronote
     assert "ni la source iCal ni pronotepy n'est configurée" in str(exc_info.value)
 
 
+def test_fetch_agenda_auto_ical_configured_fails_fallback_to_pronotepy_without_ent(
+    mock_fetcher: PronoteFetcher,
+) -> None:
+    """Test le mode auto : iCal configuré mais échoue, repli sur pronotepy sans ent.
+
+    On mock iCal pour échouer, pronotepy configuré sans ent. On vérifie que pronotepy est appelé
+    et que le résultat provient de pronotepy, pas une erreur.
+
+    :param mock_fetcher: Fetcher de test.
+    :return: None
+    :rtype: None
+    """
+    start_dt = datetime(2025, 9, 1, 8, 0)
+    end_dt = datetime(2025, 9, 1, 9, 30)
+    lessons = [
+        Lesson(
+            id="l1",
+            start=start_dt,
+            end=end_dt,
+            subject="Maths",
+            teachers=("Dupont",),
+            rooms=("S1",),
+            group="2ndeA",
+            status=LessonStatus.NORMAL,
+            content=None,
+        )
+    ]
+
+    # Override settings to use auto mode with ical_url configured but ent=None
+    mock_fetcher._settings.pronote.agenda_source = "auto"
+    mock_fetcher._settings.pronote.ent = None  # Explicitly None
+
+    with (
+        patch("pronote_sync.sources.pronote.fallback.fetch_ical") as m_fetch_ical,
+        patch("pronote_sync.sources.pronote.fallback.parse_ical") as m_parse_ical,
+    ):
+        m_fetch_ical.side_effect = OSError("iCal unreachable")
+        m_parse_ical.side_effect = OSError("iCal parse error")
+        client = MagicMock()
+        client.get_lessons.return_value = lessons
+        mock_fetcher._pronote_client = client
+
+        result_lessons, result_events = mock_fetcher.fetch_agenda()
+
+        assert result_lessons == lessons
+        assert result_events == []
+        client.get_lessons.assert_called_once()
+
+
+def test_fetch_homework_auto_ical_configured_fails_fallback_to_pronotepy_without_ent(
+    mock_fetcher: PronoteFetcher,
+) -> None:
+    """Test le mode auto des devoirs : iCal configuré mais échoue, repli sur pronotepy sans ent.
+
+    On mock iCal pour échouer, pronotepy configuré sans ent. On vérifie que pronotepy est appelé
+    et que le résultat provient de pronotepy, pas une erreur.
+
+    :param mock_fetcher: Fetcher de test.
+    :return: None
+    :rtype: None
+    """
+    target_date = date(2025, 9, 10)
+    homeworks = [
+        Homework(
+            id="hw1",
+            subject="Physique",
+            teachers=(),
+            assigned_on=None,
+            due_on=target_date,
+            text="TP à préparer",
+            html="TP à préparer",
+        )
+    ]
+
+    # Override settings to use auto mode with ical_url configured but ent=None
+    mock_fetcher._settings.pronote.homework_source = "auto"
+    mock_fetcher._settings.pronote.ent = None  # Explicitly None
+
+    with (
+        patch("pronote_sync.sources.pronote.fallback.fetch_ical") as m_fetch_ical,
+        patch("pronote_sync.sources.pronote.fallback.parse_ical") as m_parse_ical,
+        patch("pronote_sync.sources.pronote.fallback.collect_homeworks") as m_collect,
+    ):
+        m_fetch_ical.side_effect = OSError("iCal unreachable")
+        m_parse_ical.side_effect = OSError("iCal parse error")
+        client = MagicMock()
+        client.get_homeworks.return_value = homeworks
+        mock_fetcher._pronote_client = client
+        m_collect.return_value = homeworks
+
+        result = mock_fetcher.fetch_homework(target_date)
+
+        assert result == homeworks
+        client.get_homeworks.assert_called_once()
+
+
 def test_fetch_homework_fallback_both_fail_raises_pipeline_critical_error(
     mock_fetcher: PronoteFetcher,
 ) -> None:
@@ -1127,7 +1223,7 @@ def test_fetch_homework_fallback_both_fail_raises_pipeline_critical_error(
 def test_fetch_homework_auto_fallback_returns_empty_logs_warning(
     mock_fetcher: PronoteFetcher, caplog: pytest.LogCaptureFixture
 ) -> None:
-    """Test que fetch_homework retourne [] et journalise un avertissement si le repli retourne vide.
+    """Test que fetch_homework retourne [] et journalise un avertissement si le repli est vide.
 
     On mock ICAL pour échouer, pronotepy configuré et retourne vide. On vérifie le retour et le log.
     Ce test utilise le mode AUTO pour tester le comportement de repli.
@@ -1186,4 +1282,203 @@ def test_fetch_informations_logs_and_re_raises_secret(
     )
 
 
+def test_is_pronotepy_configured_without_ent_returns_true() -> None:
+    """Test _is_pronotepy_configured() retourne True quand ent est None.
+
+    Les autres champs de la configuration pronotepy sont présents, donc la
+    fonction renvoie True.
+
+    Ce test valide que PRONOTE_ENT est optionnel pour pronotepy.
+
+    :return: None
+    """
+    from pronote_sync.config.settings import PronoteSettings, Settings
+    from pronote_sync.sources.pronote.fallback import PronoteFetcher
+
+    # Créer des settings avec pronotepy configuré mais sans ent
+    settings = Settings(
+        pronote=PronoteSettings(
+            url="https://pronote.example.com",
+            username="testuser",
+            password=SecretStr("testpass"),
+            ent=None,  # Explicitement None
+            agenda_source="pronotepy",
+            homework_source="pronotepy",
+        ),
+        app=Settings().app,
+    )
+
+    client: _MockPronoteClientProtocol = MagicMock()
+    fetcher = PronoteFetcher(settings=settings, pronote_client=client)
+
+    # Should return True even without ent
+    assert fetcher._is_pronotepy_configured() is True
+
+
+def test_is_pronotepy_configured_password_mode_all_set() -> None:
+    """Test _is_pronotepy_configured() en mode password avec tous les champs définis.
+
+    URL, identifiant et mot de passe sont présents : la fonction retourne True.
+
+    :return: None
+    :rtype: None
+    """
+    settings = Settings(
+        pronote=PronoteSettings(
+            url="https://pronote.example.com",
+            username="testuser",
+            password=SecretStr("testpass"),
+            agenda_source="pronotepy",
+            homework_source="pronotepy",
+        ),
+        app=Settings().app,
+    )
+
+    client: _MockPronoteClientProtocol = MagicMock()
+    fetcher = PronoteFetcher(settings=settings, pronote_client=client)
+
+    assert fetcher._is_pronotepy_configured() is True
+
+
+def test_is_pronotepy_configured_password_mode_missing_password() -> None:
+    """Test _is_pronotepy_configured() en mode password sans mot de passe.
+
+    Le mot de passe est None : la fonction retourne False.
+
+    :return: None
+    :rtype: None
+    """
+    settings = Settings(
+        pronote=PronoteSettings(
+            url="https://pronote.example.com",
+            username="testuser",
+            password=None,
+            agenda_source="pronotepy",
+            homework_source="pronotepy",
+        ),
+        app=Settings().app,
+    )
+
+    client: _MockPronoteClientProtocol = MagicMock()
+    fetcher = PronoteFetcher(settings=settings, pronote_client=client)
+
+    assert fetcher._is_pronotepy_configured() is False
+
+
+def test_is_pronotepy_configured_qr_token_mode_url_only() -> None:
+    """Test _is_pronotepy_configured() en mode qr_token avec URL uniquement.
+
+    En mode qr_token, seul l'URL est requis : l'identifiant et le mot de
+    passe peuvent être absents, la fonction retourne True.
+
+    :return: None
+    :rtype: None
+    """
+    settings = Settings(
+        pronote=PronoteSettings(
+            url="https://pronote.example.com",
+            username=None,
+            password=None,
+            auth_mode="qr_token",
+            agenda_source="pronotepy",
+            homework_source="pronotepy",
+        ),
+        app=Settings().app,
+    )
+
+    client: _MockPronoteClientProtocol = MagicMock()
+    fetcher = PronoteFetcher(settings=settings, pronote_client=client)
+
+    assert fetcher._is_pronotepy_configured() is True
+
+
+def test_is_pronotepy_configured_qr_token_mode_no_url() -> None:
+    """Test _is_pronotepy_configured() en mode qr_token sans URL.
+
+    L'URL est None : la fonction retourne False, même si le mode qr_token
+    ne requiert que PRONOTE_URL.
+
+    :return: None
+    :rtype: None
+    """
+    settings = Settings(
+        pronote=PronoteSettings(
+            url=None,
+            username=None,
+            password=None,
+            auth_mode="qr_token",
+            agenda_source="pronotepy",
+            homework_source="pronotepy",
+        ),
+        app=Settings().app,
+    )
+
+    client: _MockPronoteClientProtocol = MagicMock()
+    fetcher = PronoteFetcher(settings=settings, pronote_client=client)
+
+    assert fetcher._is_pronotepy_configured() is False
+
+
+def test_agenda_sources_auto_without_ical_and_without_ent_returns_pronotepy() -> None:
+    """Test _agenda_sources() en mode AUTO sans iCal URL et sans ent retourne pronotepy.
+
+    Ce test valide que le mode auto peut utiliser pronotepy même sans ent configuré.
+
+    :return: None
+    """
+    from pronote_sync.config.settings import PronoteSettings, Settings
+    from pronote_sync.sources.pronote.fallback import PronoteFetcher
+
+    settings = Settings(
+        pronote=PronoteSettings(
+            url="https://pronote.example.com",
+            username="testuser",
+            password=SecretStr("testpass"),
+            ent=None,  # Explicitement None
+            ical_url=None,  # Pas de iCal URL
+            agenda_source="auto",
+        ),
+        app=Settings().app,
+    )
+
+    client: _MockPronoteClientProtocol = MagicMock()
+    fetcher = PronoteFetcher(settings=settings, pronote_client=client)
+
+    primary, fallback = fetcher._agenda_sources()
+
+    assert primary == "pronotepy"
+    assert fallback is None
+
+
+def test_homework_sources_auto_without_ical_and_without_ent_returns_pronotepy() -> None:
+    """Test _homework_sources() en mode AUTO sans iCal URL et sans ent retourne pronotepy.
+
+    Ce test valide que le mode auto peut utiliser pronotepy pour les devoirs même sans ent configuré.
+
+    :return: None
+    """
+    from pronote_sync.config.settings import PronoteSettings, Settings
+    from pronote_sync.sources.pronote.fallback import PronoteFetcher
+
+    settings = Settings(
+        pronote=PronoteSettings(
+            url="https://pronote.example.com",
+            username="testuser",
+            password=SecretStr("testpass"),
+            ent=None,  # Explicitement None
+            ical_url=None,  # Pas de iCal URL
+            homework_source="auto",
+        ),
+        app=Settings().app,
+    )
+
+    client: _MockPronoteClientProtocol = MagicMock()
+    fetcher = PronoteFetcher(settings=settings, pronote_client=client)
+
+    primary, fallback = fetcher._homework_sources()
+
+    assert primary == "pronotepy"
+    assert fallback is None
+
+
 # Ensure trailing newline

tests/unit/test_fetch_target_date.py

@@ -0,0 +1,86 @@
+"""Tests de sélection de la date cible du digest Pronote."""
+
+from __future__ import annotations
+
+from datetime import date, datetime
+
+from pronote_sync.models.agenda import Lesson, LessonStatus, SchoolEvent, SchoolEventKind
+from pronote_sync.pipeline.steps.fetch import resolve_target_date
+
+
+def _lesson(day: date, status: LessonStatus = LessonStatus.NORMAL) -> Lesson:
+    """Construit un cours minimal à une date donnée.
+
+    :param day: Date du cours.
+    :param status: Statut du cours.
+    :return: Cours de test.
+    :rtype: Lesson
+    """
+    return Lesson(
+        id=day.isoformat(),
+        start=datetime.combine(day, datetime.min.time()),
+        end=datetime.combine(day, datetime.min.time().replace(hour=1)),
+        subject="Mathématiques",
+        group=None,
+        status=status,
+        content=None,
+    )
+
+
+def _event(from_date: date, to_date: date) -> SchoolEvent:
+    """Construit un événement scolaire à borne de fin exclusive.
+
+    :param from_date: Début inclusif.
+    :param to_date: Fin exclusive.
+    :return: Événement de vacances de test.
+    :rtype: SchoolEvent
+    """
+    return SchoolEvent(
+        kind=SchoolEventKind.HOLIDAY,
+        label="Vacances anonymisées",
+        from_date=from_date,
+        to_date=to_date,
+    )
+
+
+def test_target_date_prefers_tomorrow_effective_lesson() -> None:
+    """Un cours effectif demain est prioritaire.
+
+    :return: None
+    """
+    today = date(2026, 9, 11)
+
+    assert resolve_target_date(today, [_lesson(date(2026, 9, 12))], []) == date(2026, 9, 12)
+
+
+def test_target_date_skips_empty_days_and_cancelled_lessons() -> None:
+    """Le prochain cours effectif remplace un lendemain vide ou annulé.
+
+    :return: None
+    """
+    today = date(2026, 9, 11)
+    lessons = [
+        _lesson(date(2026, 9, 12), LessonStatus.CANCELLED),
+        _lesson(date(2026, 9, 14)),
+    ]
+
+    assert resolve_target_date(today, lessons, []) == date(2026, 9, 14)
+
+
+def test_target_date_uses_exclusive_holiday_end_when_no_reprise_is_visible() -> None:
+    """La fin exclusive d'une période couvrant demain devient la reprise connue.
+
+    :return: None
+    """
+    today = date(2026, 10, 19)
+    holiday = _event(date(2026, 10, 20), date(2026, 11, 2))
+
+    assert resolve_target_date(today, [], [holiday]) == date(2026, 11, 2)
+
+
+def test_target_date_falls_back_to_tomorrow_without_data() -> None:
+    """Une liste vide valide sans événement conserve J+1 explicitement.
+
+    :return: None
+    """
+    assert resolve_target_date(date(2026, 9, 11), [], []) == date(2026, 9, 12)

tests/unit/test_ical.py

@@ -294,8 +294,8 @@ def test_collect_homeworks_dedup() -> None:
         id="lesson2",
         start=datetime(2026, 9, 10, 10, 0),
         end=datetime(2026, 9, 10, 11, 0),
-        subject="Physique",
+        subject="Math",
-        teachers=("M. Martin",),
+        teachers=("M. Dupont",),
         rooms=("205",),
         group=None,
         status=LessonStatus.NORMAL,
@@ -343,8 +343,8 @@ def test_collect_homeworks_id_stability() -> None:
         id="lesson2",
         start=datetime(2026, 9, 10, 10, 0),
         end=datetime(2026, 9, 10, 11, 0),
-        subject="Physique",
+        subject="Math",
-        teachers=("M. Martin",),
+        teachers=("M. Dupont",),
         rooms=("205",),
         group=None,
         status=LessonStatus.NORMAL,
@@ -361,7 +361,150 @@ def test_collect_homeworks_id_stability() -> None:
 
     homeworks = collect_homeworks([lesson1, lesson2], target_date=date(2026, 9, 10))
     assert len(homeworks) == 1
-    assert homeworks[0].id == generate_homework_id(date(2026, 9, 10), "devoir commun")
+    assert homeworks[0].id == generate_homework_id(
+        date(2026, 9, 10), "devoir commun", "Math", ("M. Dupont",)
+    )
+
+
+def test_collect_homeworks_keeps_distinct_subjects() -> None:
+    """Deux matières différentes conservent deux devoirs homonymes.
+
+    :return: None
+    """
+    lesson = Lesson(
+        id="lesson1",
+        start=datetime(2026, 9, 10, 8, 0),
+        end=datetime(2026, 9, 10, 9, 0),
+        subject="Math",
+        teachers=("M. Dupont",),
+        group=None,
+        content=None,
+        homework_blocks=(
+            HomeworkBlock(
+                kind="due",
+                date=date(2026, 9, 10),
+                text="Devoir commun",
+                html="<p>Devoir commun</p>",
+            ),
+        ),
+    )
+    other_lesson = lesson.model_copy(
+        update={"id": "lesson2", "subject": "Physique", "teachers": ("M. Martin",)}
+    )
+
+    homeworks = collect_homeworks([lesson, other_lesson], target_date=date(2026, 9, 10))
+
+    assert len(homeworks) == 2
+    assert {homework.subject for homework in homeworks} == {"Math", "Physique"}
+
+
+def test_collect_homeworks_deduplicates_teacher_order_variants() -> None:
+    """Deux ordres d'enseignants équivalents ne créent pas de doublon.
+
+    :return: None
+    """
+    homework_block = HomeworkBlock(
+        kind="due",
+        date=date(2026, 9, 10),
+        text="Devoir commun",
+        html="<p>Devoir commun</p>",
+    )
+    lesson = Lesson(
+        id="lesson1",
+        start=datetime(2026, 9, 10, 8, 0),
+        end=datetime(2026, 9, 10, 9, 0),
+        subject="Math",
+        teachers=("M. Martin", "M. Dupont"),
+        group=None,
+        content=None,
+        homework_blocks=(homework_block,),
+    )
+    other_lesson = lesson.model_copy(
+        update={"id": "lesson2", "teachers": ("M. Dupont", "M. Martin")}
+    )
+
+    homeworks = collect_homeworks([lesson, other_lesson], target_date=date(2026, 9, 10))
+
+    assert len(homeworks) == 1
+
+
+def test_parse_body_accepts_html_variants_and_sanitizes() -> None:
+    """Les attributs HTML, les espaces et le contenu actif sont traités correctement.
+
+    :return: None
+    """
+    body = (
+        '<strong class="label"> Contenu pédagogique : </strong><p>Leçon &amp; exemple</p>'
+        '<strong data-kind="homework"> Pour le 10/09/2026 : </strong>'
+        '<p onclick="evil()">Lire <em>le chapitre</em></p><script>alert(1)</script>'
+        "<strong> Donné le 05/09/2026 : </strong><p>Noter &amp; relire</p>"
+    )
+
+    content, due_blocks, assigned_blocks = parse_body(body)
+
+    assert content == "Leçon & exemple"
+    assert due_blocks[0].date == date(2026, 9, 10)
+    assert due_blocks[0].text == "Lire le chapitre"
+    assert "<em>le chapitre</em>" in due_blocks[0].html
+    assert "onclick" not in due_blocks[0].html
+    assert "script" not in due_blocks[0].html.lower()
+    assert assigned_blocks[0].date == date(2026, 9, 5)
+
+
+def test_parse_anonymized_variants_fixture() -> None:
+    """Vérifie le corpus iCal anonymisé sur les statuts et le contexte des devoirs.
+
+    :return: None
+    """
+    fixture_path = Path(__file__).parent.parent / "fixtures" / "pronote-variants.ics"
+    lessons, _, school_events = parse_ical(fixture_path.read_text(encoding="utf-8"))
+
+    assert lessons[0].class_part == "Groupe 1"
+    assert lessons[0].homework_blocks[0].html == "<p>Lire le chapitre</p>"
+    assert any(lesson.status == LessonStatus.MOVED for lesson in lessons)
+    assert any(event.kind.value == "public_holiday" for event in school_events)
+    assert any(
+        event.from_date == date(2026, 10, 20) and event.to_date == date(2026, 10, 22)
+        for event in school_events
+    )
+
+    homeworks = collect_homeworks(lessons, target_date=date(2026, 9, 15))
+
+    assert len(homeworks) == 2
+    assert {homework.subject for homework in homeworks} == {"Mathématiques", "Sciences"}
+
+
+def test_parse_ical_removes_old_replaced_lesson() -> None:
+    """Un ancien cours annulé est retiré lorsqu'un cours déplacé le remplace.
+
+    :return: None
+    """
+    raw_ical = """BEGIN:VCALENDAR
+VERSION:2.0
+BEGIN:VEVENT
+UID:old
+DTSTART:20260911T080000Z
+DTEND:20260911T090000Z
+SUMMARY:Mathématiques
+CATEGORIES:Cours - Cours annulé
+STATUS:CANCELLED
+DESCRIPTION:<div>Matière : Mathématiques Professeur : Enseignant A Salle : 101</div>
+END:VEVENT
+BEGIN:VEVENT
+UID:new
+DTSTART:20260911T080000Z
+DTEND:20260911T090000Z
+SUMMARY:Mathématiques
+CATEGORIES:Cours - Changement de salle
+DESCRIPTION:<div>Matière : Mathématiques Professeur : Enseignant A Salle : 204</div>
+END:VEVENT
+END:VCALENDAR"""
+
+    lessons, _, _ = parse_ical(raw_ical)
+
+    assert len(lessons) == 1
+    assert lessons[0].status == LessonStatus.MOVED
+    assert lessons[0].rooms == ("204",)
 
 
 def test_collect_homeworks_sorted() -> None:

tests/unit/test_pronote_auth_state.py

@@ -0,0 +1,367 @@
+"""Tests unitaires pour le gestionnaire d'état d'authentification Pronote.
+
+Ce module valide le comportement de :class:`PronoteAuthState` dans
+:mod:`pronote_sync.sources.pronote.auth_state`. Les tests couvrent :
+
+- Le chargement des credentials (absent, corrompu, version invalide),
+- La persistance et le rechargement des credentials,
+- Les permissions ``0600`` du fichier d'état,
+- La suppression via :meth:`clear`,
+- L'absence de fuite des credentials dans les journaux.
+
+Tous les tests utilisent des fichiers temporaires via la fixture ``tmp_path``.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from fcntl import LOCK_EX, LOCK_NB, LOCK_UN, flock
+from pathlib import Path
+
+import pytest
+
+from pronote_sync.errors import PronoteAuthStateLockError
+from pronote_sync.sources.pronote.auth_state import PronoteAuthState
+
+
+def test_load_no_file_returns_none(tmp_path: Path) -> None:
+    """Vérifie qu'un fichier d'état absent renvoie ``None``.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state = PronoteAuthState(tmp_path / "missing.json")
+
+    assert state.load() is None
+
+
+def test_disabled_persistence_keeps_credentials_in_memory_without_creating_file(
+    tmp_path: Path,
+) -> None:
+    """Vérifie que la persistance désactivée conserve les credentials en mémoire.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state_file = tmp_path / "auth.json"
+    credentials = {
+        "pronote_url": "https://example.com/pronote",
+        "username": "parent-1",
+        "password": "token-123",  # pragma: allowlist secret
+        "uuid": "uuid-456",
+    }
+    state = PronoteAuthState(state_file, persistence_enabled=False)
+
+    state.save(credentials)
+
+    assert state.load() == credentials
+    assert not state_file.exists()
+
+
+def test_disabled_persistence_preserves_existing_file(tmp_path: Path) -> None:
+    """Vérifie que la persistance désactivée garde les nouveaux credentials en mémoire.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state_file = tmp_path / "auth.json"
+    original_credentials = {
+        "pronote_url": "https://example.com/pronote",
+        "username": "parent-1",
+        "password": "old-token",  # pragma: allowlist secret
+        "uuid": "old-uuid",
+    }
+    original_content = json.dumps({"version": 1, "credentials": original_credentials}).encode()
+    new_credentials = {
+        "pronote_url": "https://example.com/pronote",
+        "username": "parent-1",
+        "password": "new-token",  # pragma: allowlist secret
+        "uuid": "new-uuid",
+    }
+    state_file.write_bytes(original_content)
+    state = PronoteAuthState(state_file, persistence_enabled=False)
+
+    assert state.load() == original_credentials
+
+    state.save(new_credentials)
+
+    assert state.load() == new_credentials
+    assert state_file.read_bytes() == original_content
+
+
+def test_disabled_persistence_clear_discards_in_memory_credentials_only(tmp_path: Path) -> None:
+    """Vérifie que clear oublie l'état en mémoire sans modifier le fichier existant.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state_file = tmp_path / "auth.json"
+    original_credentials = {
+        "pronote_url": "https://example.com/pronote",
+        "username": "parent-1",
+        "password": "old-token",  # pragma: allowlist secret
+        "uuid": "old-uuid",
+    }
+    original_content = json.dumps({"version": 1, "credentials": original_credentials}).encode()
+    credentials = {
+        "pronote_url": "https://example.com/pronote",
+        "username": "parent-1",
+        "password": "new-token",  # pragma: allowlist secret
+        "uuid": "new-uuid",
+    }
+    state_file.write_bytes(original_content)
+    state = PronoteAuthState(state_file, persistence_enabled=False)
+
+    state.save(credentials)
+    state.clear()
+
+    assert state.load() is None
+    assert state_file.read_bytes() == original_content
+
+
+def test_save_then_load_roundtrip(tmp_path: Path) -> None:
+    """Vérifie que des credentials sauvegardés sont rechargés à l'identique.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state_file = tmp_path / "auth.json"
+    credentials = {
+        "pronote_url": "https://example.com/pronote",
+        "username": "parent-1",
+        "password": "token-123",  # pragma: allowlist secret
+        "uuid": "uuid-456",
+    }
+
+    state = PronoteAuthState(state_file)
+    state.save(credentials)
+    loaded = PronoteAuthState(state_file).load()
+
+    assert loaded == credentials
+
+
+def test_load_corrupted_json_returns_none(tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None:
+    """Vérifie qu'un fichier JSON corrompu renvoie ``None`` et journalise un avertissement.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :param caplog: Fixture pytest pour capturer les logs.
+    :return: None
+    """
+    state_file = tmp_path / "corrupt.json"
+    state_file.write_text("not json{", encoding="utf-8")
+
+    with caplog.at_level("WARNING"):
+        result = PronoteAuthState(state_file).load()
+
+    assert result is None
+    assert "Impossible de charger le fichier d'état d'authentification Pronote" in caplog.text
+
+
+def test_load_wrong_version_returns_none(tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None:
+    """Vérifie qu'une version non supportée renvoie ``None`` et journalise un avertissement.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :param caplog: Fixture pytest pour capturer les logs.
+    :return: None
+    """
+    state_file = tmp_path / "wrong_version.json"
+    state_file.write_text(
+        json.dumps(
+            {
+                "version": 2,
+                "credentials": {
+                    "pronote_url": "https://example.com",
+                    "username": "u",
+                    "password": "t",
+                    "uuid": "i",
+                },
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    with caplog.at_level("WARNING"):
+        result = PronoteAuthState(state_file).load()
+
+    assert result is None
+    assert "version absente ou non supportée" in caplog.text
+
+
+def test_load_missing_version_returns_none(
+    tmp_path: Path, caplog: pytest.LogCaptureFixture
+) -> None:
+    """Vérifie qu'un fichier sans champ version renvoie ``None``.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :param caplog: Fixture pytest pour capturer les logs.
+    :return: None
+    """
+    state_file = tmp_path / "missing_version.json"
+    state_file.write_text(
+        json.dumps(
+            {
+                "credentials": {
+                    "pronote_url": "https://example.com",
+                    "username": "u",
+                    "password": "t",
+                    "uuid": "i",
+                }
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    with caplog.at_level("WARNING"):
+        result = PronoteAuthState(state_file).load()
+
+    assert result is None
+
+
+def test_clear_removes_file(tmp_path: Path) -> None:
+    """Vérifie que clear supprime le fichier d'état existant.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state_file = tmp_path / "auth.json"
+    state = PronoteAuthState(state_file)
+    state.save({"pronote_url": "u", "username": "u", "password": "t", "uuid": "i"})
+
+    assert state_file.exists()
+    state.clear()
+
+    assert not state_file.exists()
+
+
+def test_clear_no_file_noop(tmp_path: Path) -> None:
+    """Vérifie que clear ne fait rien quand le fichier n'existe pas.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state = PronoteAuthState(tmp_path / "missing.json")
+
+    state.clear()
+
+
+def test_save_creates_file_with_0600_permissions(tmp_path: Path) -> None:
+    """Vérifie que le fichier d'état est créé avec les permissions ``0600``.
+
+    Le fichier contient un token vivant : il doit être lisible uniquement
+    par le propriétaire.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state_file = tmp_path / "auth.json"
+    state = PronoteAuthState(state_file)
+    state.save({"pronote_url": "u", "username": "u", "password": "t", "uuid": "i"})
+
+    assert os.stat(state_file).st_mode & 0o777 == 0o600
+
+
+def test_no_credentials_in_logs(tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None:
+    """Vérifie qu'aucun contenu des credentials n'apparaît dans les journaux.
+
+    Des sentinelles distinctes sont utilisées pour ``pronote_url``,
+    ``username``, ``password`` et ``uuid`` ; aucun de ces marqueurs ne doit
+    apparaître dans les messages journalisés lors d'une sauvegarde, d'un
+    chargement et d'une suppression.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :param caplog: Fixture pytest pour capturer les logs.
+    :return: None
+    """
+    state_file = tmp_path / "auth.json"
+    credentials = {
+        "pronote_url": "https://SENTINEL_URL_ZZZ.example/pronote",
+        "username": "SENTINEL_USER_ZZZ",
+        "password": "SENTINEL_PASSWORD_ZZZ",  # pragma: allowlist secret
+        "uuid": "SENTINEL_UUID_ZZZ",
+    }
+
+    state = PronoteAuthState(state_file)
+    with caplog.at_level(logging.DEBUG):
+        state.save(credentials)
+        state.load()
+        state.clear()
+
+    assert "SENTINEL_URL_ZZZ" not in caplog.text
+    assert "SENTINEL_USER_ZZZ" not in caplog.text
+    assert "SENTINEL_PASSWORD_ZZZ" not in caplog.text
+    assert "SENTINEL_UUID_ZZZ" not in caplog.text
+
+
+def test_lock_rejects_concurrent_access_with_a_redacted_dedicated_error(tmp_path: Path) -> None:
+    """Vérifie qu'un verrou concurrent échoue immédiatement sans fuite interne.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state_file = tmp_path / ".pronote_auth_state.json"
+    state = PronoteAuthState(state_file)
+    competing_state = PronoteAuthState(state_file)
+
+    with state.lock():
+        assert state_file.with_name(f"{state_file.name}.lock").exists()
+        with pytest.raises(PronoteAuthStateLockError) as exc_info:
+            with competing_state.lock():
+                pass
+
+    assert "BlockingIOError" not in str(exc_info.value)
+    assert exc_info.value.__cause__ is None
+    assert exc_info.value.__context__ is None
+
+
+def test_lock_open_failure_does_not_log_sensitive_lock_path(
+    tmp_path: Path, caplog: pytest.LogCaptureFixture, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Vérifie qu'un échec d'ouverture du verrou ne divulgue pas son chemin.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :param caplog: Fixture pytest pour capturer les logs.
+    :param monkeypatch: Fixture pytest pour remplacer l'ouverture du verrou.
+    :return: None
+    """
+    sentinel_path = "/SENTINEL_LOCK_PATH_ZZZ/.pronote_auth_state.json.lock"
+
+    def raise_lock_open_error(*args: object, **kwargs: object) -> int:
+        """Simule un refus d'ouverture portant un chemin sensible."""
+        del args, kwargs
+        raise OSError(13, "Permission denied", sentinel_path)
+
+    monkeypatch.setattr(os, "open", raise_lock_open_error)
+
+    with caplog.at_level(logging.ERROR):
+        with pytest.raises(PronoteAuthStateLockError) as exc_info:
+            with PronoteAuthState(tmp_path / ".pronote_auth_state.json").lock():
+                pass
+
+    assert "Impossible d'ouvrir le verrou d'état d'authentification Pronote" in caplog.text
+    assert "SENTINEL_LOCK_PATH_ZZZ" not in caplog.text
+    assert exc_info.value.__cause__ is None
+    assert exc_info.value.__context__ is None
+
+
+def test_lock_is_released_when_the_protected_operation_raises(tmp_path: Path) -> None:
+    """Vérifie que le verrou est libéré même si le bloc protégé échoue.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state_file = tmp_path / ".pronote_auth_state.json"
+    lock_file = state_file.with_name(f"{state_file.name}.lock")
+    state = PronoteAuthState(state_file)
+
+    with pytest.raises(RuntimeError, match="échec simulé"):
+        with state.lock():
+            raise RuntimeError("échec simulé")
+
+    descriptor = os.open(lock_file, os.O_RDWR)
+    try:
+        flock(descriptor, LOCK_EX | LOCK_NB)
+        flock(descriptor, LOCK_UN)
+    finally:
+        os.close(descriptor)

tests/unit/test_pronote_lessons.py

@@ -0,0 +1,91 @@
+"""Tests des règles communes de statut et de consolidation des cours."""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+import pytest
+
+from pronote_sync.models.agenda import Lesson, LessonStatus
+from pronote_sync.sources.pronote.lessons import collapse_replaced_lessons, lesson_status
+
+
+def _lesson(status: LessonStatus, room: str) -> Lesson:
+    """Construit un cours minimal pour les tests de consolidation.
+
+    :param status: Statut métier du cours.
+    :param room: Salle du cours.
+    :return: Cours de test.
+    :rtype: Lesson
+    """
+    return Lesson(
+        id=f"lesson-{room}",
+        start=datetime(2026, 9, 11, 8, 0),
+        end=datetime(2026, 9, 11, 9, 0),
+        subject="Mathématiques",
+        teachers=("Enseignant A",),
+        rooms=(room,),
+        group="Classe entière",
+        status=status,
+        content=None,
+    )
+
+
+@pytest.mark.parametrize(
+    ("raw_status", "canceled", "expected"),
+    [
+        ("Changement de salle", False, LessonStatus.MOVED),
+        ("Cours déplacé", False, LessonStatus.MOVED),
+        ("Cours annulé", False, LessonStatus.CANCELLED),
+        (None, True, LessonStatus.CANCELLED),
+        ("Statut inconnu", False, LessonStatus.NORMAL),
+    ],
+)
+def test_lesson_status_maps_pronotepy_variants(
+    raw_status: object, canceled: bool, expected: LessonStatus
+) -> None:
+    """Convertit les statuts Pronote connus sans interpréter les inconnus.
+
+    :param raw_status: Statut brut simulé.
+    :param canceled: Indicateur d'annulation simulé.
+    :param expected: Statut métier attendu.
+    :return: None
+    """
+    assert lesson_status(raw_status, canceled) == expected
+
+
+def test_collapse_replaced_lessons_keeps_effective_lesson() -> None:
+    """Retire l'ancien exemplaire annulé d'un changement de salle.
+
+    :return: None
+    """
+    cancelled = _lesson(LessonStatus.CANCELLED, "101")
+    moved = _lesson(LessonStatus.MOVED, "204")
+
+    result = collapse_replaced_lessons([cancelled, moved])
+
+    assert result == [moved]
+
+
+def test_collapse_replaced_lessons_keeps_real_cancellation() -> None:
+    """Conserve une annulation lorsqu'aucun cours déplacé ne la remplace.
+
+    :return: None
+    """
+    cancelled = _lesson(LessonStatus.CANCELLED, "101")
+
+    assert collapse_replaced_lessons([cancelled]) == [cancelled]
+
+
+def test_collapse_replaced_lessons_keeps_ambiguous_cancellations() -> None:
+    """Conserve les annulations lorsqu'une paire de remplacement est ambiguë.
+
+    :return: None
+    """
+    cancelled_old = _lesson(LessonStatus.CANCELLED, "101")
+    cancelled_real = _lesson(LessonStatus.CANCELLED, "305")
+    moved = _lesson(LessonStatus.MOVED, "204")
+
+    result = collapse_replaced_lessons([cancelled_old, cancelled_real, moved])
+
+    assert result == [cancelled_old, cancelled_real, moved]

tests/unit/test_rotation_propagation.py

@@ -0,0 +1,180 @@
+"""Unit tests for PronoteAuthRotationError propagation through each layer.
+
+These tests verify that the rotation error propagates correctly through the
+real call chain without being wrapped in PipelineCriticalError at any layer.
+"""
+
+from __future__ import annotations
+
+from datetime import date
+
+import pytest
+from pydantic import SecretStr
+
+from pronote_sync.config.settings import PronoteSettings, Settings
+from pronote_sync.errors import PipelineCriticalError, PronoteAuthRotationError
+from pronote_sync.models.agenda import Lesson, SchoolEvent
+from pronote_sync.models.homework import Homework
+from pronote_sync.models.message import Message
+from pronote_sync.pipeline.steps.fetch import fetch_step
+from pronote_sync.sources.pronote.fallback import PronoteFetcher
+
+
+class StubPronoteClientWithRotationError:
+    """Stub PronoteClient that raises PronoteAuthRotationError from its methods."""
+
+    def get_lessons(self, start: date, end: date) -> list[Lesson]:
+        """Raise rotation error when fetching lessons.
+
+        :param start: Start date (unused).
+        :param end: End date (unused).
+        :return: Never returns.
+        :raises PronoteAuthRotationError: Always.
+        """
+        del start, end
+        raise PronoteAuthRotationError("Token persisté expiré : ré-enrôlement requis")
+
+    def get_homeworks(self, start: date, end: date) -> list[Homework]:
+        """Raise rotation error when fetching homeworks.
+
+        :param start: Start date (unused).
+        :param end: End date (unused).
+        :return: Never returns.
+        :raises PronoteAuthRotationError: Always.
+        """
+        del start, end
+        raise PronoteAuthRotationError("Token persisté expiré : ré-enrôlement requis")
+
+    def get_messages(self) -> list[Message]:
+        """Return empty messages list.
+
+        :return: Empty list.
+        :rtype: list[Message]
+        """
+        return []
+
+    def get_informations(self) -> list[Message]:
+        """Return empty information messages list.
+
+        :return: Empty list.
+        :rtype: list[Message]
+        """
+        return []
+
+
+class StubSettings:
+    """Minimal settings stub for PronoteFetcher."""
+
+    def __init__(self) -> None:
+        """Initialize with minimal configuration."""
+        self.pronote = PronoteSettings(
+            url="https://pronote.example.com",
+            username="test",
+            password=SecretStr("test_password"),
+            ent="bordeaux",
+            account_type="parent",
+            agenda_source="pronotepy",
+            homework_source="pronotepy",
+            messages_source="pronotepy",
+            auth_mode="password",
+            qr_code_file=None,
+            qr_pin=None,
+            ical_url=None,
+        )
+        self.app = type("AppSettings", (), {"sync_past_days": 7, "sync_future_days": 7})()
+
+
+class StubFetcherWithRotationError:
+    """Stub PronoteFetcher that raises PronoteAuthRotationError from its methods."""
+
+    def __init__(self) -> None:
+        """Initialize the stub fetcher."""
+        self._settings = StubSettings()
+        self._client = StubPronoteClientWithRotationError()
+
+    def fetch_agenda(self) -> tuple[list[Lesson], list[SchoolEvent]]:
+        """Raise rotation error when fetching agenda.
+
+        :return: Never returns.
+        :rtype: tuple[list[Lesson], list[SchoolEvent]]
+        :raises PronoteAuthRotationError: Always.
+        """
+        raise PronoteAuthRotationError("Token persisté expiré : ré-enrôlement requis")
+
+    def fetch_homework(self, target_date: date) -> list[Homework]:
+        """Raise rotation error when fetching homework.
+
+        :param target_date: Target date (unused).
+        :return: Never returns.
+        :rtype: list[Homework]
+        :raises PronoteAuthRotationError: Always.
+        """
+        del target_date
+        raise PronoteAuthRotationError("Token persisté expiré : ré-enrôlement requis")
+
+    def fetch_messages(self) -> list[Message]:
+        """Return empty messages list.
+
+        :return: Empty list.
+        :rtype: list[Message]
+        """
+        return []
+
+    def fetch_informations(self) -> list[Message]:
+        """Return empty information messages list.
+
+        :return: Empty list.
+        :rtype: list[Message]
+        """
+        return []
+
+
+def test_pronote_fetcher_fetch_agenda_propagates_rotation_error() -> None:
+    """PronoteFetcher.fetch_agenda() propagates PronoteAuthRotationError without wrapping.
+
+    This test verifies that when the underlying PronoteClient raises
+    PronoteAuthRotationError, the fetcher propagates it directly without
+    converting it to PipelineCriticalError.
+    """
+    settings = Settings(pronote=StubSettings().pronote)
+    fetcher = PronoteFetcher(settings, StubPronoteClientWithRotationError())
+
+    with pytest.raises(PronoteAuthRotationError) as exc_info:
+        fetcher.fetch_agenda()
+
+    assert "Token persisté expiré" in str(exc_info.value)
+    assert not isinstance(exc_info.value, PipelineCriticalError)
+
+
+def test_pronote_fetcher_fetch_homework_propagates_rotation_error() -> None:
+    """PronoteFetcher.fetch_homework() propagates PronoteAuthRotationError without wrapping.
+
+    This test verifies that when the underlying PronoteClient raises
+    PronoteAuthRotationError, the fetcher propagates it directly without
+    converting it to PipelineCriticalError.
+    """
+    settings = Settings(pronote=StubSettings().pronote)
+    fetcher = PronoteFetcher(settings, StubPronoteClientWithRotationError())
+    target_date = date(2026, 9, 9)
+
+    with pytest.raises(PronoteAuthRotationError) as exc_info:
+        fetcher.fetch_homework(target_date)
+
+    assert "Token persisté expiré" in str(exc_info.value)
+    assert not isinstance(exc_info.value, PipelineCriticalError)
+
+
+def test_fetch_step_propagates_rotation_error() -> None:
+    """fetch_step() propagates PronoteAuthRotationError without wrapping.
+
+    This test verifies that the pipeline step fetch_step() propagates
+    PronoteAuthRotationError directly from the fetcher without converting
+    it to PipelineCriticalError.
+    """
+    fetcher = StubFetcherWithRotationError()
+
+    with pytest.raises(PronoteAuthRotationError) as exc_info:
+        fetch_step(fetcher, today=date(2026, 9, 8))
+
+    assert "Token persisté expiré" in str(exc_info.value)
+    assert not isinstance(exc_info.value, PipelineCriticalError)

tests/unit/test_xmpp_channel.py

@@ -17,7 +17,7 @@ from unittest.mock import patch
 import pytest
 from pydantic import SecretStr
 
-from pronote_sync.channels.xmpp import XmppChannel, XmppMessage
+from pronote_sync.channels.xmpp import SyncXmppChannel, XmppChannel, XmppMessage
 from pronote_sync.config.settings import XmppSettings
 from pronote_sync.models.agenda import Lesson, TheoreticalLesson
 from pronote_sync.models.blog import BlogArticle, ExternalInfo
@@ -48,11 +48,15 @@ class FakeClientXMPP:
         self._should_disconnect_early = False
         self._host_used: str | None = None
         self._port_used: int | None = None
+        # New modes for realistic failure simulation
+        self._connect_mode: str = "ok"  # "ok", "pending", "connection_failed"
+        self._disconnect_mode: str = "ok"  # "ok", "pending"
+        self._fire_connection_failed: bool = False
 
     def add_event_handler(
         self, name: str, pointer: Callable[..., object], disposable: bool = False
     ) -> None:
-        if name not in ("session_start", "failed_auth", "disconnected"):
+        if name not in ("session_start", "failed_auth", "connection_failed", "disconnected"):
             raise AssertionError(f"Unsupported event: {name}")
         self.handlers.setdefault(name, []).append(pointer)
 
@@ -63,10 +67,24 @@ class FakeClientXMPP:
         self.connected = True
         self._host_used = host
         self._port_used = port
-        # Schedule event handlers to fire after connect returns
+
-        loop.call_soon(self._fire_events)
+        if self._connect_mode == "pending":
-        future.set_result(True)
+            # Never resolves - simulates connection timeout
-        return future
+            return future
+        elif self._connect_mode == "connection_failed":
+            # Resolves connect future but fires connection_failed event
+            loop.call_soon(self._fire_connection_failed_event)
+            future.set_result(True)
+            return future
+        else:
+            # Schedule event handlers to fire after connect returns
+            loop.call_soon(self._fire_events)
+            future.set_result(True)
+            return future
+
+    def _fire_connection_failed_event(self) -> None:
+        """Fire connection_failed event for testing."""
+        self._fire("connection_failed")
 
     def _fire_events(self) -> None:
         if self._should_disconnect_early:
@@ -86,8 +104,13 @@ class FakeClientXMPP:
         loop = asyncio.get_event_loop()
         future: asyncio.Future[bool] = loop.create_future()
         self.disconnected = True
-        future.set_result(True)
+
-        return future
+        if self._disconnect_mode == "pending":
+            # Never resolves - simulates cleanup timeout
+            return future
+        else:
+            future.set_result(True)
+            return future
 
     def send_message(
         self, mto: object, mbody: str | None = None, mtype: str | None = None, **kwargs: object
@@ -681,6 +704,339 @@ class TestXmppChannelSend:
             jid_arg = call_args.args[0]
             assert jid_arg == "bot@example.com/myresource"
 
+    @patch("pronote_sync.channels.xmpp.ClientXMPP", new=FakeClientXMPP)
+    @pytest.mark.asyncio
+    async def test_connect_timeout_returns_false(self, caplog: pytest.LogCaptureFixture) -> None:
+        """Test que connect_timeout retourne False quand connect() ne résout pas.
+
+        :param caplog: Fixture pytest pour capturer les logs.
+        """
+        settings = XmppSettings(
+            enabled=True,
+            jid="bot@example.com",
+            password=SecretStr("secret123"),
+            host="xmpp.example.com",
+            port=5222,
+            to="parent@example.com",
+            resource="pronote-sync",
+            tls_mode="starttls",
+            connect_timeout=0.05,
+            timeout=30,
+            cleanup_timeout=0.01,
+        )
+
+        class PendingConnectClient(FakeClientXMPP):
+            def __init__(self, jid: str, password: str) -> None:
+                super().__init__(jid, password)
+                self._connect_mode = "pending"
+
+        with patch("pronote_sync.channels.xmpp.ClientXMPP", new=PendingConnectClient):
+            channel = XmppChannel(settings, dry_run=False)
+            msg = XmppMessage(target_date=date(2025, 9, 7), synthesis=None, external_info=None)
+            result = await channel.send_async(msg)
+            assert result is False
+            # Vérifier que le log contient "connexion"
+            logs = caplog.text
+            assert "connexion" in logs.lower()
+
+    @pytest.mark.asyncio
+    async def test_cancelled_error_cancels_pending_tasks(self) -> None:
+        """Test que l'annulation de send_async annule les tâches encore en attente.
+
+        Un ``connect()`` qui ne résout jamais et une annulation de la tâche
+        appelante doivent entraîner la cancellation de la future de connexion
+        (idempotence de ``_cancel_pending`` sur les chemins d'exception).
+        """
+        settings = XmppSettings(
+            enabled=True,
+            jid="bot@example.com",
+            password=SecretStr("secret123"),
+            host="xmpp.example.com",
+            port=5222,
+            to="parent@example.com",
+            resource="pronote-sync",
+            tls_mode="starttls",
+            connect_timeout=15,
+            timeout=30,
+            cleanup_timeout=0.01,
+        )
+
+        class PendingConnectClient(FakeClientXMPP):
+            """Client dont ``connect()`` retourne une future jamais résolue."""
+
+            def __init__(self, jid: str, password: str) -> None:
+                super().__init__(jid, password)
+                self._connect_mode = "pending"
+                self.connect_future: asyncio.Future[bool] | None = None
+
+            def connect(
+                self, host: str | None = None, port: int | None = None
+            ) -> asyncio.Future[bool]:
+                future = super().connect(host, port)
+                self.connect_future = future
+                return future
+
+        with patch("pronote_sync.channels.xmpp.ClientXMPP", new=PendingConnectClient):
+            channel = XmppChannel(settings, dry_run=False)
+            msg = XmppMessage(target_date=date(2025, 9, 7), synthesis=None, external_info=None)
+            client = PendingConnectClient("bot@example.com", "secret123")
+            with patch("pronote_sync.channels.xmpp.ClientXMPP", new=lambda j, p: client):
+                task = asyncio.ensure_future(channel.send_async(msg))
+                # Laisse asyncio.wait démarrer et la future de connexion rester en attente
+                await asyncio.sleep(0.05)
+                task.cancel()
+                result = await task
+                assert result is False
+                assert client.connect_future is not None
+                assert client.connect_future.cancelled()
+
+    @patch("pronote_sync.channels.xmpp.ClientXMPP", new=FakeClientXMPP)
+    @pytest.mark.asyncio
+    async def test_connection_failed_event_returns_false(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """Test que connection_failed event retourne False rapidement.
+
+        :param caplog: Fixture pytest pour capturer les logs.
+        """
+        settings = XmppSettings(
+            enabled=True,
+            jid="bot@example.com",
+            password=SecretStr("secret123"),
+            host="xmpp.example.com",
+            port=5222,
+            to="parent@example.com",
+            resource="pronote-sync",
+            tls_mode="starttls",
+            connect_timeout=15,
+            timeout=30,
+            cleanup_timeout=0.01,
+        )
+
+        class ConnectionFailedClient(FakeClientXMPP):
+            def __init__(self, jid: str, password: str) -> None:
+                super().__init__(jid, password)
+                self._connect_mode = "connection_failed"
+
+        with patch("pronote_sync.channels.xmpp.ClientXMPP", new=ConnectionFailedClient):
+            channel = XmppChannel(settings, dry_run=False)
+            msg = XmppMessage(target_date=date(2025, 9, 7), synthesis=None, external_info=None)
+            result = await channel.send_async(msg)
+            assert result is False
+            # Vérifier que le log contient une mention d'échec réseau
+            logs = caplog.text
+            assert "réseau" in logs.lower() or "connexion" in logs.lower()
+
+    @patch("pronote_sync.channels.xmpp.ClientXMPP", new=FakeClientXMPP)
+    @pytest.mark.asyncio
+    async def test_cleanup_timeout_does_not_hang(self, caplog: pytest.LogCaptureFixture) -> None:
+        """Test que cleanup_timeout ne bloque pas quand disconnect() ne résout pas.
+
+        :param caplog: Fixture pytest pour capturer les logs.
+        """
+        import logging
+
+        caplog.set_level(logging.DEBUG)
+
+        settings = XmppSettings(
+            enabled=True,
+            jid="bot@example.com",
+            password=SecretStr("secret123"),
+            host="xmpp.example.com",
+            port=5222,
+            to="parent@example.com",
+            resource="pronote-sync",
+            tls_mode="starttls",
+            connect_timeout=0.05,
+            timeout=30,
+            cleanup_timeout=0.01,
+        )
+
+        class HangingDisconnectClient(FakeClientXMPP):
+            def __init__(self, jid: str, password: str) -> None:
+                super().__init__(jid, password)
+                self._disconnect_mode = "pending"
+
+        with patch("pronote_sync.channels.xmpp.ClientXMPP", new=HangingDisconnectClient):
+            channel = XmppChannel(settings, dry_run=False)
+            msg = XmppMessage(target_date=date(2025, 9, 7), synthesis=None, external_info=None)
+            # Should complete quickly despite hanging disconnect
+            result = await asyncio.wait_for(channel.send_async(msg), timeout=0.5)
+            assert result is True
+            # Vérifier que le log contient une mention de timeout de nettoyage
+            logs = caplog.text
+            assert "déconnexion" in logs.lower()
+
+    @patch("pronote_sync.channels.xmpp.ClientXMPP", new=FakeClientXMPP)
+    @pytest.mark.asyncio
+    async def test_tls_mode_direct_config(self) -> None:
+        """Test que tls_mode='direct' configure enable_direct_tls=True et enable_starttls=False.
+
+        :return: None
+        """
+        settings = XmppSettings(
+            enabled=True,
+            jid="bot@example.com",
+            password=SecretStr("secret123"),
+            host="xmpp.example.com",
+            port=5222,
+            to="parent@example.com",
+            resource="pronote-sync",
+            tls_mode="direct",
+            timeout=30,
+        )
+
+        class InspectClient(FakeClientXMPP):
+            def __init__(self, jid: str, password: str) -> None:
+                super().__init__(jid, password)
+
+        with patch("pronote_sync.channels.xmpp.ClientXMPP") as mock_cls:
+            mock_cls.return_value = InspectClient("bot@example.com", "secret123")
+            channel = XmppChannel(settings, dry_run=False)
+            msg = XmppMessage(target_date=date(2025, 9, 7), synthesis=None, external_info=None)
+            await channel.send_async(msg)
+            client_instance = mock_cls.return_value
+            assert client_instance.enable_direct_tls is True
+            assert client_instance.enable_starttls is False
+
+    @patch("pronote_sync.channels.xmpp.ClientXMPP", new=FakeClientXMPP)
+    @pytest.mark.asyncio
+    async def test_tls_mode_starttls_config(self) -> None:
+        """Test que tls_mode='starttls' configure enable_starttls=True et enable_direct_tls=False.
+
+        :return: None
+        """
+        settings = XmppSettings(
+            enabled=True,
+            jid="bot@example.com",
+            password=SecretStr("secret123"),
+            host="xmpp.example.com",
+            port=5222,
+            to="parent@example.com",
+            resource="pronote-sync",
+            tls_mode="starttls",
+            timeout=30,
+        )
+
+        class InspectClient(FakeClientXMPP):
+            def __init__(self, jid: str, password: str) -> None:
+                super().__init__(jid, password)
+
+        with patch("pronote_sync.channels.xmpp.ClientXMPP") as mock_cls:
+            mock_cls.return_value = InspectClient("bot@example.com", "secret123")
+            channel = XmppChannel(settings, dry_run=False)
+            msg = XmppMessage(target_date=date(2025, 9, 7), synthesis=None, external_info=None)
+            await channel.send_async(msg)
+            client_instance = mock_cls.return_value
+            assert client_instance.enable_starttls is True
+            assert client_instance.enable_direct_tls is False
+
+    @patch("pronote_sync.channels.xmpp.ClientXMPP", new=FakeClientXMPP)
+    @pytest.mark.asyncio
+    async def test_tls_mode_disabled_config(self) -> None:
+        """Test que tls_mode='disabled' avec host='127.0.0.1' configure TLS désactivé.
+
+        :return: None
+        """
+        settings = XmppSettings(
+            enabled=True,
+            jid="bot@example.com",
+            password=SecretStr("secret123"),
+            host="127.0.0.1",
+            port=5222,
+            to="parent@example.com",
+            resource="pronote-sync",
+            tls_mode="disabled",
+            timeout=30,
+        )
+
+        class InspectClient(FakeClientXMPP):
+            def __init__(self, jid: str, password: str) -> None:
+                super().__init__(jid, password)
+
+        with patch("pronote_sync.channels.xmpp.ClientXMPP") as mock_cls:
+            mock_cls.return_value = InspectClient("bot@example.com", "secret123")
+            channel = XmppChannel(settings, dry_run=False)
+            msg = XmppMessage(target_date=date(2025, 9, 7), synthesis=None, external_info=None)
+            await channel.send_async(msg)
+            client_instance = mock_cls.return_value
+            assert client_instance.enable_direct_tls is False
+            assert client_instance.enable_starttls is False
+
+    @patch("pronote_sync.channels.xmpp.ClientXMPP", new=FakeClientXMPP)
+    @pytest.mark.asyncio
+    async def test_no_secret_leak_in_connection_failure_log(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """Test qu'aucun secret ne fuit dans les logs en cas d'échec de connexion.
+
+        :param caplog: Fixture pytest pour capturer les logs.
+        """
+        sentinel_password = "SECRET_PASSWORD_XMPP_12345"  # pragma: allowlist secret
+        settings = XmppSettings(
+            enabled=True,
+            jid="bot@example.com",
+            password=SecretStr(sentinel_password),
+            host="xmpp.example.com",
+            port=5222,
+            to="parent@example.com",
+            resource="pronote-sync",
+            tls_mode="starttls",
+            timeout=30,
+        )
+
+        class ConnectionFailedClient(FakeClientXMPP):
+            def __init__(self, jid: str, password: str) -> None:
+                super().__init__(jid, password)
+                self._connect_mode = "connection_failed"
+
+        with patch("pronote_sync.channels.xmpp.ClientXMPP", new=ConnectionFailedClient):
+            channel = XmppChannel(settings, dry_run=False)
+            msg = XmppMessage(target_date=date(2025, 9, 7), synthesis=None, external_info=None)
+            await channel.send_async(msg)
+
+        # Vérifier que le mot de passe sentinelle n'apparaît pas dans les logs
+        logs = caplog.text
+        assert sentinel_password not in logs
+
+    @patch("pronote_sync.channels.xmpp.ClientXMPP", new=FakeClientXMPP)
+    @pytest.mark.asyncio
+    async def test_no_secret_leak_in_connect_timeout_log(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """Test qu'aucun secret ne fuit dans les logs en cas de timeout de connexion.
+
+        :param caplog: Fixture pytest pour capturer les logs.
+        """
+        sentinel_password = "SECRET_PASSWORD_XMPP_12345"
+        settings = XmppSettings(
+            enabled=True,
+            jid="bot@example.com",
+            password=SecretStr(sentinel_password),
+            host="xmpp.example.com",
+            port=5222,
+            to="parent@example.com",
+            resource="pronote-sync",
+            tls_mode="starttls",
+            connect_timeout=0.05,
+            timeout=30,
+            cleanup_timeout=0.01,
+        )
+
+        class PendingConnectClient(FakeClientXMPP):
+            def __init__(self, jid: str, password: str) -> None:
+                super().__init__(jid, password)
+                self._connect_mode = "pending"
+
+        with patch("pronote_sync.channels.xmpp.ClientXMPP", new=PendingConnectClient):
+            channel = XmppChannel(settings, dry_run=False)
+            msg = XmppMessage(target_date=date(2025, 9, 7), synthesis=None, external_info=None)
+            await channel.send_async(msg)
+
+        # Vérifier que le mot de passe sentinelle n'apparaît pas dans les logs
+        logs = caplog.text
+        assert sentinel_password not in logs
+
     @patch("pronote_sync.channels.xmpp.ClientXMPP", new=FakeClientXMPP)
     @pytest.mark.asyncio
     async def test_send_async_tls_direct_config(self) -> None:
@@ -816,6 +1172,328 @@ class TestXmppChannelSend:
             result = await channel.send_async(msg)
             assert result is True
 
+    @patch("pronote_sync.channels.xmpp.ClientXMPP", new=FakeClientXMPP)
+    @pytest.mark.asyncio
+    async def test_send_async_connect_raises_exception_returns_false(self) -> None:
+        """Test que connect() levant une exception retourne False.
+
+        :return: None
+        """
+        settings = XmppSettings(
+            enabled=True,
+            jid="bot@example.com",
+            password=SecretStr("secret123"),
+            host="xmpp.example.com",
+            port=5222,
+            to="parent@example.com",
+            resource="pronote-sync",
+            tls_mode="starttls",
+            timeout=30,
+        )
+
+        class ConnectExceptionClient(FakeClientXMPP):
+            def connect(
+                self, host: str | None = None, port: int | None = None
+            ) -> asyncio.Future[bool]:
+                raise ConnectionError("Network unreachable")
+
+        with patch("pronote_sync.channels.xmpp.ClientXMPP", new=ConnectExceptionClient):
+            channel = XmppChannel(settings, dry_run=False)
+            msg = XmppMessage(target_date=date(2025, 9, 7), synthesis=None, external_info=None)
+            result = await channel.send_async(msg)
+            assert result is False
+
+    @patch("pronote_sync.channels.xmpp.ClientXMPP", new=FakeClientXMPP)
+    @pytest.mark.asyncio
+    async def test_send_async_connect_future_error_returns_false(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """Test que la future de connect() résolue avec une exception retourne False.
+
+        Le message d'erreur doit être expurgé et ne pas contenir les secrets.
+
+        :param caplog: Fixture pytest pour capturer les logs.
+        """
+        sentinel_password = "SECRET_PASSWORD_XMPP_CONNECT_FUT"  # pragma: allowlist secret
+        settings = XmppSettings(
+            enabled=True,
+            jid="bot@example.com",
+            password=SecretStr(sentinel_password),
+            host="xmpp.example.com",
+            port=5222,
+            to="parent@example.com",
+            resource="pronote-sync",
+            tls_mode="starttls",
+            timeout=30,
+        )
+
+        class ConnectFutureErrorClient(FakeClientXMPP):
+            def connect(
+                self, host: str | None = None, port: int | None = None
+            ) -> asyncio.Future[bool]:
+                loop = asyncio.get_event_loop()
+                future: asyncio.Future[bool] = loop.create_future()
+                future.set_exception(ConnectionError("Network unreachable"))
+                return future
+
+        with patch("pronote_sync.channels.xmpp.ClientXMPP", new=ConnectFutureErrorClient):
+            channel = XmppChannel(settings, dry_run=False)
+            msg = XmppMessage(target_date=date(2025, 9, 7), synthesis=None, external_info=None)
+            result = await channel.send_async(msg)
+            assert result is False
+            assert "Échec de connexion XMPP" in caplog.text
+            assert sentinel_password not in caplog.text
+
+    @patch("pronote_sync.channels.xmpp.ClientXMPP", new=FakeClientXMPP)
+    @pytest.mark.asyncio
+    async def test_send_async_session_failure_after_connect_returns_false(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """Test qu'un échec de session après connexion résolue retourne False.
+
+        Le connect future est résolu avec succès, puis l'événement
+        ``failed_auth`` arrive pendant l'attente de session.
+
+        :param caplog: Fixture pytest pour capturer les logs.
+        """
+        settings = XmppSettings(
+            enabled=True,
+            jid="bot@example.com",
+            password=SecretStr("secret123"),
+            host="xmpp.example.com",
+            port=5222,
+            to="parent@example.com",
+            resource="pronote-sync",
+            tls_mode="starttls",
+            timeout=5,
+            cleanup_timeout=0.01,
+        )
+
+        class LateAuthFailClient(FakeClientXMPP):
+            def connect(
+                self, host: str | None = None, port: int | None = None
+            ) -> asyncio.Future[bool]:
+                loop = asyncio.get_event_loop()
+                future: asyncio.Future[bool] = loop.create_future()
+                self.connected = True
+                self._host_used = host
+                self._port_used = port
+                loop.call_later(0.01, lambda: self._fire("failed_auth"))
+                future.set_result(True)
+                return future
+
+        with patch("pronote_sync.channels.xmpp.ClientXMPP", new=LateAuthFailClient):
+            channel = XmppChannel(settings, dry_run=False)
+            msg = XmppMessage(target_date=date(2025, 9, 7), synthesis=None, external_info=None)
+            result = await channel.send_async(msg)
+            assert result is False
+            assert "authentification" in caplog.text.lower()
+
+    @patch("pronote_sync.channels.xmpp.ClientXMPP", new=FakeClientXMPP)
+    @pytest.mark.asyncio
+    async def test_send_async_cancelled_returns_false(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """Test que l'annulation de la tâche retourne False sans lever.
+
+        Le contrat du canal impose un retour booléen : ``CancelledError`` doit
+        être interceptée et convertie en ``False``.
+
+        :param caplog: Fixture pytest pour capturer les logs.
+        """
+        import logging
+
+        caplog.set_level(logging.DEBUG)
+        settings = XmppSettings(
+            enabled=True,
+            jid="bot@example.com",
+            password=SecretStr("secret123"),
+            host="xmpp.example.com",
+            port=5222,
+            to="parent@example.com",
+            resource="pronote-sync",
+            tls_mode="starttls",
+            connect_timeout=15,
+            timeout=30,
+            cleanup_timeout=0.01,
+        )
+
+        class PendingConnectClient(FakeClientXMPP):
+            def __init__(self, jid: str, password: str) -> None:
+                super().__init__(jid, password)
+                self._connect_mode = "pending"
+
+        with patch("pronote_sync.channels.xmpp.ClientXMPP", new=PendingConnectClient):
+            channel = XmppChannel(settings, dry_run=False)
+            msg = XmppMessage(target_date=date(2025, 9, 7), synthesis=None, external_info=None)
+            task = asyncio.ensure_future(channel.send_async(msg))
+            await asyncio.sleep(0.001)
+            task.cancel()
+            result = await asyncio.wait_for(task, timeout=1.0)
+            assert result is False
+            assert "annulé" in caplog.text.lower()
+
+
+class TestSecretValues:
+    """Tests pour la fonction _secret_values."""
+
+    def test_secret_values_with_all_secrets(self) -> None:
+        """Test que _secret_values retourne tous les secrets.
+
+        :return: None
+        """
+        from pronote_sync.channels.xmpp import _secret_values
+
+        settings = XmppSettings(
+            jid="bot@example.com",
+            password=SecretStr("secret123"),
+            to="parent@example.com",
+        )
+        secrets = _secret_values(settings)
+        assert len(secrets) == 3
+        assert "bot@example.com" in secrets
+        assert settings.password in secrets
+        assert "parent@example.com" in secrets
+
+    def test_secret_values_with_none_values(self) -> None:
+        """Test que _secret_values filtre les valeurs None.
+
+        :return: None
+        """
+        from pronote_sync.channels.xmpp import _secret_values
+
+        settings = XmppSettings(
+            jid=None,
+            password=None,
+            to=None,
+        )
+        secrets = _secret_values(settings)
+        assert len(secrets) == 0
+
+    def test_secret_values_with_some_none(self) -> None:
+        """Test que _secret_values gère les valeurs partiellement None.
+
+        :return: None
+        """
+        from pronote_sync.channels.xmpp import _secret_values
+
+        settings = XmppSettings(
+            jid="bot@example.com",
+            password=None,
+            to="parent@example.com",
+        )
+        secrets = _secret_values(settings)
+        assert len(secrets) == 2
+        assert "bot@example.com" in secrets
+        assert "parent@example.com" in secrets
+
+
+class TestSyncXmppChannel:
+    """Tests unitaires pour la classe SyncXmppChannel."""
+
+    @patch("pronote_sync.channels.xmpp.ClientXMPP", new=FakeClientXMPP)
+    def test_sync_send_dry_run_returns_true(self) -> None:
+        """Test que SyncXmppChannel en dry_run retourne True.
+
+        :return: None
+        """
+        settings = XmppSettings(
+            enabled=True,
+            jid="bot@example.com",
+            password=SecretStr("secret123"),
+            host="xmpp.example.com",
+            port=5222,
+            to="parent@example.com",
+            resource="pronote-sync",
+            use_tls=True,
+            timeout=30,
+        )
+        channel = SyncXmppChannel(settings, dry_run=True)
+        msg = XmppMessage(target_date=date(2025, 9, 7), synthesis=None, external_info=None)
+        result = channel.send(msg)
+        assert result is True
+
+    @patch("pronote_sync.channels.xmpp.ClientXMPP", new=FakeClientXMPP)
+    def test_sync_send_success_returns_true(self) -> None:
+        """Test que SyncXmppChannel.send retourne True en cas de succès.
+
+        :return: None
+        """
+        settings = XmppSettings(
+            enabled=True,
+            jid="bot@example.com",
+            password=SecretStr("secret123"),
+            host="xmpp.example.com",
+            port=5222,
+            to="parent@example.com",
+            resource="pronote-sync",
+            use_tls=True,
+            timeout=30,
+        )
+        channel = SyncXmppChannel(settings, dry_run=False)
+        msg = XmppMessage(target_date=date(2025, 9, 7), synthesis=None, external_info=None)
+        result = channel.send(msg)
+        assert result is True
+
+    @patch("pronote_sync.channels.xmpp.ClientXMPP", new=FakeClientXMPP)
+    def test_sync_send_exception_returns_false(self) -> None:
+        """Test que SyncXmppChannel.send retourne False en cas d'exception.
+
+        :return: None
+        """
+        settings = XmppSettings(
+            enabled=True,
+            jid="bot@example.com",
+            password=SecretStr("secret123"),
+            host="xmpp.example.com",
+            port=5222,
+            to="parent@example.com",
+            resource="pronote-sync",
+            use_tls=True,
+            timeout=30,
+        )
+
+        class ErrorClient(FakeClientXMPP):
+            def connect(
+                self, host: str | None = None, port: int | None = None
+            ) -> asyncio.Future[bool]:
+                raise RuntimeError("Connection failed")
+
+        with patch("pronote_sync.channels.xmpp.ClientXMPP", new=ErrorClient):
+            channel = SyncXmppChannel(settings, dry_run=False)
+            msg = XmppMessage(target_date=date(2025, 9, 7), synthesis=None, external_info=None)
+            result = channel.send(msg)
+            assert result is False
+
+    @patch("pronote_sync.channels.xmpp.ClientXMPP", new=FakeClientXMPP)
+    def test_sync_send_asyncio_run_error_returns_false(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """Test que send retourne False si asyncio.run lève une exception.
+
+        :param caplog: Fixture pytest pour capturer les logs.
+        """
+        settings = XmppSettings(
+            enabled=True,
+            jid="bot@example.com",
+            password=SecretStr("secret123"),
+            host="xmpp.example.com",
+            port=5222,
+            to="parent@example.com",
+            resource="pronote-sync",
+            use_tls=True,
+            timeout=30,
+        )
+        channel = SyncXmppChannel(settings, dry_run=False)
+        msg = XmppMessage(target_date=date(2025, 9, 7), synthesis=None, external_info=None)
+        with patch(
+            "pronote_sync.channels.xmpp.asyncio.run",
+            side_effect=RuntimeError("Boucle événementielle indisponible"),
+        ):
+            result = channel.send(msg)
+        assert result is False
+        assert "erreur" in caplog.text.lower()
+
 
 class TestXmppChannelSecurity:
     """Tests de sécurité pour XmppChannel (non-fuite de secrets).

tests/unit/test_xmpp_settings.py

@@ -99,19 +99,52 @@ class TestTimeoutConstraints:
 class TestTlsPolicy:
     """Tests de la politique TLS pour le champ use_tls."""
 
-    def test_use_tls_false_with_remote_host_rejected(self) -> None:
+    def test_tls_disabled_with_remote_host_rejected(self) -> None:
-        """Vérifie que use_tls=False avec un hôte distant est rejeté.
+        """Vérifie que tls_mode="disabled" avec un hôte distant est rejeté.
 
-        :raises ValidationError: Si use_tls=False et host n'est pas une boucle locale.
+        :raises ValidationError: Si tls_mode="disabled" et host n'est pas une boucle locale.
         """
         with pytest.raises(ValidationError) as exc_info:
-            XmppSettings(use_tls=False, host="talk.example.com")
+            XmppSettings(tls_mode="disabled", host="talk.example.com")
-        assert "use_tls" in str(exc_info.value).lower() or "tls" in str(exc_info.value).lower()
+        assert "tls" in str(exc_info.value).lower()
 
-    def test_use_tls_false_with_remote_host_rejected_when_enabled(self) -> None:
+    def test_tls_disabled_with_remote_host_rejected_when_enabled(self) -> None:
         """Vérifie que la politique TLS s'applique même quand le canal est activé."""
         with pytest.raises(ValidationError):
-            XmppSettings(enabled=True, use_tls=False, host="talk.example.com")
+            XmppSettings(enabled=True, tls_mode="disabled", host="talk.example.com")
+
+    def test_use_tls_false_maps_to_starttls(self) -> None:
+        """Vérifie que l'alias obsolète use_tls=False mappe vers tls_mode='starttls'.
+
+        :return: Vérifie le mapping et l'émission d'un DeprecationWarning.
+        :rtype: None
+        """
+        with pytest.warns(DeprecationWarning):
+            settings = XmppSettings(use_tls=False, host="talk.example.com")
+        assert settings.tls_mode == "starttls"
+        assert settings.host == "talk.example.com"
+
+    def test_use_tls_true_maps_to_direct(self) -> None:
+        """Vérifie que l'alias obsolète use_tls=True mappe vers tls_mode='direct'.
+
+        :return: Vérifie le mapping et l'émission d'un DeprecationWarning.
+        :rtype: None
+        """
+        with pytest.warns(DeprecationWarning):
+            settings = XmppSettings(use_tls=True, host="talk.example.com")
+        assert settings.tls_mode == "direct"
+        assert settings.host == "talk.example.com"
+
+    def test_default_tls_mode_is_starttls(self) -> None:
+        """Vérifie que tls_mode vaut 'starttls' par défaut avec les timeouts par défaut.
+
+        :return: Vérifie tls_mode='starttls', connect_timeout=15, cleanup_timeout=10.
+        :rtype: None
+        """
+        settings = XmppSettings()
+        assert settings.tls_mode == "starttls"
+        assert settings.connect_timeout == 15
+        assert settings.cleanup_timeout == 10
 
     def test_use_tls_false_with_localhost_allowed(self) -> None:
         """Vérifie que use_tls=False avec localhost est autorisé.
@@ -120,7 +153,7 @@ class TestTlsPolicy:
         :rtype: None
         """
         settings = XmppSettings(use_tls=False, host="localhost")
-        assert settings.use_tls is False
+        assert settings.tls_mode == "starttls"
         assert settings.host == "localhost"
 
     def test_use_tls_false_with_127_allowed(self) -> None:
@@ -130,7 +163,7 @@ class TestTlsPolicy:
         :rtype: None
         """
         settings = XmppSettings(use_tls=False, host="127.0.0.1")
-        assert settings.use_tls is False
+        assert settings.tls_mode == "starttls"
         assert settings.host == "127.0.0.1"
 
     def test_use_tls_false_with_ipv6_loopback_allowed(self) -> None:
@@ -140,7 +173,7 @@ class TestTlsPolicy:
         :rtype: None
         """
         settings = XmppSettings(use_tls=False, host="::1")
-        assert settings.use_tls is False
+        assert settings.tls_mode == "starttls"
         assert settings.host == "::1"
 
     def test_use_tls_true_with_remote_host_allowed(self) -> None:
@@ -150,7 +183,7 @@ class TestTlsPolicy:
         :rtype: None
         """
         settings = XmppSettings(use_tls=True, host="talk.example.com")
-        assert settings.use_tls is True
+        assert settings.tls_mode == "direct"
         assert settings.host == "talk.example.com"
 
     def test_use_tls_true_with_empty_host_allowed(self) -> None:
@@ -160,7 +193,7 @@ class TestTlsPolicy:
         :rtype: None
         """
         settings = XmppSettings(use_tls=True, host="")
-        assert settings.use_tls is True
+        assert settings.tls_mode == "direct"
         assert settings.host == ""
 
 
@@ -173,7 +206,7 @@ class TestNoSecretInErrorMessages:
         Crée une instance avec des valeurs sensibles et vérifie que l'erreur de validation
         ne contient pas ces valeurs dans son message.
 
-        :raises ValidationError: Si use_tls=False avec un hôte non-local.
+        :raises ValidationError: Si tls_mode="disabled" avec un hôte non-local.
         :return: Vérifie que le message d'erreur ne contient pas les secrets.
         :rtype: None
         """
@@ -184,7 +217,7 @@ class TestNoSecretInErrorMessages:
 
         with pytest.raises(ValidationError) as exc_info:
             XmppSettings(
-                use_tls=False,
+                tls_mode="disabled",
                 host="talk.example.com",
                 jid=sentinel_jid,
                 password=sentinel_password,
@@ -197,3 +230,72 @@ class TestNoSecretInErrorMessages:
         assert "test_password_123" not in error_message
         assert "test_to@example.com" not in error_message
         assert "secret" not in error_message
+
+
+class TestXmppSettingsTlsMode:
+    """Tests supplémentaires pour les validateurs de XmppSettings."""
+
+    def test_use_tls_true_maps_to_direct_with_warning(self) -> None:
+        """Vérifie que use_tls=True mappe vers tls_mode='direct' avec DeprecationWarning.
+
+        :return: Vérifie le mapping et l'émission d'un DeprecationWarning.
+        :rtype: None
+        """
+        with pytest.warns(DeprecationWarning):
+            settings = XmppSettings(use_tls=True, host="talk.example.com")
+        assert settings.tls_mode == "direct"
+
+    def test_use_tls_false_maps_to_starttls_with_warning(self) -> None:
+        """Vérifie que use_tls=False mappe vers tls_mode='starttls' avec DeprecationWarning.
+
+        :return: Vérifie le mapping et l'émission d'un DeprecationWarning.
+        :rtype: None
+        """
+        with pytest.warns(DeprecationWarning):
+            settings = XmppSettings(use_tls=False, host="talk.example.com")
+        assert settings.tls_mode == "starttls"
+
+    def test_tls_mode_disabled_rejected_for_remote(self) -> None:
+        """Vérifie que tls_mode='disabled' avec un hôte distant est rejeté.
+
+        :raises ValidationError: Si tls_mode="disabled" et host n'est pas une boucle locale.
+        """
+        with pytest.raises(ValidationError) as exc_info:
+            XmppSettings(tls_mode="disabled", host="example.com")
+        assert "tls" in str(exc_info.value).lower()
+
+    def test_tls_mode_disabled_allowed_for_loopback(self) -> None:
+        """Vérifie que tls_mode='disabled' avec host='127.0.0.1' est valide.
+
+        :return: Vérifie que XmppSettings(tls_mode='disabled', host='127.0.0.1') est valide.
+        :rtype: None
+        """
+        settings = XmppSettings(tls_mode="disabled", host="127.0.0.1")
+        assert settings.tls_mode == "disabled"
+        assert settings.host == "127.0.0.1"
+
+    def test_connect_timeout_must_be_positive(self) -> None:
+        """Vérifie que connect_timeout doit être strictement positif.
+
+        :raises ValidationError: Si connect_timeout <= 0.
+        """
+        with pytest.raises(ValidationError) as exc_info:
+            XmppSettings(connect_timeout=0)
+        assert "connect_timeout" in str(exc_info.value).lower()
+
+        with pytest.raises(ValidationError) as exc_info:
+            XmppSettings(connect_timeout=-1)
+        assert "connect_timeout" in str(exc_info.value).lower()
+
+    def test_cleanup_timeout_must_be_positive(self) -> None:
+        """Vérifie que cleanup_timeout doit être strictement positif.
+
+        :raises ValidationError: Si cleanup_timeout <= 0.
+        """
+        with pytest.raises(ValidationError) as exc_info:
+            XmppSettings(cleanup_timeout=0)
+        assert "cleanup_timeout" in str(exc_info.value).lower()
+
+        with pytest.raises(ValidationError) as exc_info:
+            XmppSettings(cleanup_timeout=-1)
+        assert "cleanup_timeout" in str(exc_info.value).lower()