diff --git a/.secrets.baseline b/.secrets.baseline
index dfc147d..0ed8438 100644
--- a/.secrets.baseline
+++ b/.secrets.baseline
@@ -140,7 +140,7 @@
         "filename": "GUIDE_DEV_PYTHON.md",
         "hashed_secret": "90bd1b48e958257948487b90bee080ba5ed00caa",
         "is_verified": false,
-        "line_number": 5117
+        "line_number": 5125
       }
     ],
     "tests/unit/test_caldav_gateway.py": [
@@ -185,5 +185,5 @@
       }
     ]
   },
-  "generated_at": "2026-09-12T11:33:28Z"
+  "generated_at": "2026-09-12T12:04:07Z"
 }
diff --git a/GUIDE_DEV_PYTHON.md b/GUIDE_DEV_PYTHON.md
index 5ffb434..96f2116 100644
--- a/GUIDE_DEV_PYTHON.md
+++ b/GUIDE_DEV_PYTHON.md
@@ -1532,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
@@ -2158,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,
-    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.
+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`).
+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)
 
diff --git a/pronote_sync/pipeline/steps/fetch.py b/pronote_sync/pipeline/steps/fetch.py
index 8c0f270..b6d7eac 100644
--- a/pronote_sync/pipeline/steps/fetch.py
+++ b/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, 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
-    cours contient des cours mais pas J+1, le prochain cours connu est choisi.
-    Sans cours correspondant, J+1 est conservé, y compris pendant les vacances.
+    La règle privilégie J+1 lorsqu'il contient un cours non annulé. Sinon,
+    elle choisit le prochain jour possédant un cours effectif dans la fenêtre.
+    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
-        du libellé de jour sans cours).
+    :param school_events: Événements scolaires récupérés, avec borne de fin exclusive.
     :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}
-    if tomorrow in lesson_dates:
-        return tomorrow
-    if today in lesson_dates:
-        future_dates = sorted(day for day in lesson_dates if day > today)
-        if future_dates:
-            return future_dates[0]
-    return tomorrow
+    effective_dates = {
+        lesson.start.date()
+        for lesson in lessons
+        if lesson.status != LessonStatus.CANCELLED and lesson.start.date() > today
+    }
+    if tomorrow in effective_dates:
+        reason = "cours effectif demain"
+        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(
diff --git a/pronote_sync/sources/pronote/client.py b/pronote_sync/sources/pronote/client.py
index 7f5c2ab..48670b1 100644
--- a/pronote_sync/sources/pronote/client.py
+++ b/pronote_sync/sources/pronote/client.py
@@ -25,10 +25,11 @@ import requests
 
 from pronote_sync.config.settings import PronoteSettings
 from pronote_sync.errors import PronoteAuthRotationError
-from pronote_sync.models.agenda import Lesson, LessonStatus
+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.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
 
@@ -573,12 +574,12 @@ class PronoteClient:
                         teachers=tuple(lesson.teacher_names or ()),
                         rooms=tuple(lesson.classrooms or ()),
                         group=lesson.group_name,
-                        status=(LessonStatus.CANCELLED if lesson.canceled else LessonStatus.NORMAL),
+                        status=lesson_status(getattr(lesson, "status", None), lesson.canceled),
                         content=content.description if content is not None else None,
                     )
                 )
             self._persist_credentials()
-            return lessons
+            return collapse_replaced_lessons(lessons)
 
     def get_homeworks(self, start: date, end: date) -> list[Homework]:
         """Récupère les devoirs via ``pronotepy``.
diff --git a/pronote_sync/sources/pronote/ical.py b/pronote_sync/sources/pronote/ical.py
index 0bf16e7..f03183f 100644
--- a/pronote_sync/sources/pronote/ical.py
+++ b/pronote_sync/sources/pronote/ical.py
@@ -35,6 +35,7 @@ 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"(?P<label>Mati(?:ère|ere)|Professeur(?:s|\(s\))?|Salle(?:s|\(s\))?"
@@ -186,11 +187,12 @@ def parse_header(header: str) -> HeaderInfo:
         "group": None,
         "class_part": None,
     }
-    matches = list(_HEADER_LABEL_PATTERN.finditer(header))
+    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 = unescape(header[value_start:value_end].strip())
+        value_end = matches[index + 1].start() if index + 1 < len(matches) else len(header_text)
+        value = unescape(header_text[value_start:value_end].strip())
         label = _normalize_label(match.group("label")).replace("(s)", "s")
         if label == "matiere":
             info["subject"] = value
@@ -567,4 +569,4 @@ def parse_ical(raw_ical: str) -> tuple[list[Lesson], list[Homework], list[School
             )
         )
 
-    return lessons, homeworks, school_events
+    return collapse_replaced_lessons(lessons), homeworks, school_events
diff --git a/pronote_sync/sources/pronote/lessons.py b/pronote_sync/sources/pronote/lessons.py
new file mode 100644
index 0000000..4e1b945
--- /dev/null
+++ b/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]
diff --git a/tests/unit/test_fetch_target_date.py b/tests/unit/test_fetch_target_date.py
new file mode 100644
index 0000000..5c8139c
--- /dev/null
+++ b/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)
diff --git a/tests/unit/test_ical.py b/tests/unit/test_ical.py
index 4f62c53..2b0eb53 100644
--- a/tests/unit/test_ical.py
+++ b/tests/unit/test_ical.py
@@ -474,6 +474,39 @@ def test_parse_anonymized_variants_fixture() -> None:
     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:
     """Les résultats sont triés par (subject.lower(), text.lower()).
 
diff --git a/tests/unit/test_pronote_client.py b/tests/unit/test_pronote_client.py
index 74d2701..cdfa312 100644
--- a/tests/unit/test_pronote_client.py
+++ b/tests/unit/test_pronote_client.py
@@ -233,6 +233,24 @@ def test_get_lessons_success(
     assert lesson.content == "Lesson content"
 
 
+def test_get_lessons_maps_moved_status(
+    mocker: pytest_mock.MockerFixture, pronote_settings: PronoteSettings
+) -> None:
+    """Mappe le statut ``Changement de salle`` de pronotepy vers ``MOVED``.
+
+    :param mocker: Fixture pytest-mock pour le mocking.
+    :param pronote_settings: Paramètres Pronote valides.
+    :return: None
+    """
+    mock_client = _make_lessons_mock_client(mocker)
+    mock_client.lessons.return_value[0].status = "Changement de salle"
+    mocker.patch.object(PronoteClient, "_connect", return_value=mock_client)
+
+    lessons = PronoteClient(pronote_settings).get_lessons(date(2024, 9, 1), date(2024, 9, 30))
+
+    assert lessons[0].status == LessonStatus.MOVED
+
+
 def test_get_homeworks_success(
     mocker: pytest_mock.MockerFixture, pronote_settings: PronoteSettings
 ) -> None:
diff --git a/tests/unit/test_pronote_lessons.py b/tests/unit/test_pronote_lessons.py
new file mode 100644
index 0000000..794d2a1
--- /dev/null
+++ b/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]