diff --git a/backend/config/services.yaml b/backend/config/services.yaml
index 8dd1307..2666f12 100644
--- a/backend/config/services.yaml
+++ b/backend/config/services.yaml
@@ -179,6 +179,9 @@ services:
     App\Scolarite\Domain\Repository\ScheduleSlotRepository:
         alias: App\Scolarite\Infrastructure\Persistence\Doctrine\DoctrineScheduleSlotRepository
 
+    App\Scolarite\Domain\Repository\ScheduleExceptionRepository:
+        alias: App\Scolarite\Infrastructure\Persistence\Doctrine\DoctrineScheduleExceptionRepository
+
     App\Scolarite\Domain\Service\ScheduleConflictDetector:
         autowire: true
 
diff --git a/backend/migrations/Version20260304103700.php b/backend/migrations/Version20260304103700.php
new file mode 100644
index 0000000..feb8d72
--- /dev/null
+++ b/backend/migrations/Version20260304103700.php
@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DoctrineMigrations;
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+final class Version20260304103700 extends AbstractMigration
+{
+    public function getDescription(): string
+    {
+        return 'Story 4.2 : Récurrences hebdomadaires — ajout bornes récurrence et table exceptions';
+    }
+
+    public function up(Schema $schema): void
+    {
+        // Ajout des bornes de récurrence sur schedule_slots
+        $this->addSql('ALTER TABLE schedule_slots ADD COLUMN recurrence_start DATE');
+        $this->addSql('ALTER TABLE schedule_slots ADD COLUMN recurrence_end DATE');
+
+        // Table des exceptions (modifications/annulations ponctuelles)
+        $this->addSql('
+            CREATE TABLE schedule_exceptions (
+                id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+                tenant_id UUID NOT NULL,
+                slot_id UUID NOT NULL REFERENCES schedule_slots(id) ON DELETE CASCADE,
+                exception_date DATE NOT NULL,
+                exception_type VARCHAR(20) NOT NULL,
+                new_start_time VARCHAR(5),
+                new_end_time VARCHAR(5),
+                new_room VARCHAR(50),
+                new_teacher_id UUID REFERENCES users(id),
+                reason TEXT,
+                created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+                created_by UUID NOT NULL REFERENCES users(id),
+                UNIQUE (slot_id, exception_date)
+            )
+        ');
+
+        $this->addSql('CREATE INDEX idx_exceptions_slot ON schedule_exceptions(slot_id)');
+        $this->addSql('CREATE INDEX idx_exceptions_date ON schedule_exceptions(exception_date)');
+        $this->addSql('CREATE INDEX idx_exceptions_tenant ON schedule_exceptions(tenant_id)');
+    }
+
+    public function down(Schema $schema): void
+    {
+        $this->addSql('DROP TABLE IF EXISTS schedule_exceptions');
+        $this->addSql('ALTER TABLE schedule_slots DROP COLUMN IF EXISTS recurrence_start');
+        $this->addSql('ALTER TABLE schedule_slots DROP COLUMN IF EXISTS recurrence_end');
+    }
+}
diff --git a/backend/src/Scolarite/Application/Command/CreateScheduleException/CreateScheduleExceptionCommand.php b/backend/src/Scolarite/Application/Command/CreateScheduleException/CreateScheduleExceptionCommand.php
new file mode 100644
index 0000000..e3e2b89
--- /dev/null
+++ b/backend/src/Scolarite/Application/Command/CreateScheduleException/CreateScheduleExceptionCommand.php
@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Scolarite\Application\Command\CreateScheduleException;
+
+final readonly class CreateScheduleExceptionCommand
+{
+    public function __construct(
+        public string $tenantId,
+        public string $slotId,
+        public string $exceptionDate,
+        public string $type,
+        public string $createdBy,
+        public ?string $newStartTime = null,
+        public ?string $newEndTime = null,
+        public ?string $newRoom = null,
+        public ?string $newTeacherId = null,
+        public ?string $reason = null,
+    ) {
+    }
+}
diff --git a/backend/src/Scolarite/Application/Command/CreateScheduleException/CreateScheduleExceptionHandler.php b/backend/src/Scolarite/Application/Command/CreateScheduleException/CreateScheduleExceptionHandler.php
new file mode 100644
index 0000000..6ab32cd
--- /dev/null
+++ b/backend/src/Scolarite/Application/Command/CreateScheduleException/CreateScheduleExceptionHandler.php
@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Scolarite\Application\Command\CreateScheduleException;
+
+use App\Administration\Domain\Model\User\UserId;
+use App\Scolarite\Domain\Exception\DateExceptionInvalideException;
+use App\Scolarite\Domain\Model\Schedule\ScheduleException;
+use App\Scolarite\Domain\Model\Schedule\ScheduleExceptionType;
+use App\Scolarite\Domain\Model\Schedule\ScheduleSlotId;
+use App\Scolarite\Domain\Model\Schedule\TimeSlot;
+use App\Scolarite\Domain\Repository\ScheduleExceptionRepository;
+use App\Scolarite\Domain\Repository\ScheduleSlotRepository;
+use App\Shared\Domain\Clock;
+use App\Shared\Domain\Tenant\TenantId;
+use DateTimeImmutable;
+use Symfony\Component\Messenger\Attribute\AsMessageHandler;
+
+#[AsMessageHandler(bus: 'command.bus')]
+final readonly class CreateScheduleExceptionHandler
+{
+    public function __construct(
+        private ScheduleSlotRepository $slotRepository,
+        private ScheduleExceptionRepository $exceptionRepository,
+        private Clock $clock,
+    ) {
+    }
+
+    public function __invoke(CreateScheduleExceptionCommand $command): ScheduleException
+    {
+        $tenantId = TenantId::fromString($command->tenantId);
+        $slotId = ScheduleSlotId::fromString($command->slotId);
+
+        $slot = $this->slotRepository->get($slotId, $tenantId);
+
+        $type = ScheduleExceptionType::from($command->type);
+        $exceptionDate = new DateTimeImmutable($command->exceptionDate);
+
+        if (!$slot->isActiveOnDate($exceptionDate)) {
+            throw DateExceptionInvalideException::pourSlotEtDate($slotId, $exceptionDate);
+        }
+        $createdBy = UserId::fromString($command->createdBy);
+
+        $exception = match ($type) {
+            ScheduleExceptionType::CANCELLED => ScheduleException::annuler(
+                tenantId: $tenantId,
+                slotId: $slotId,
+                exceptionDate: $exceptionDate,
+                reason: $command->reason,
+                createdBy: $createdBy,
+                now: $this->clock->now(),
+            ),
+            ScheduleExceptionType::MODIFIED => ScheduleException::modifier(
+                tenantId: $tenantId,
+                slotId: $slotId,
+                exceptionDate: $exceptionDate,
+                newTimeSlot: $command->newStartTime !== null && $command->newEndTime !== null
+                    ? new TimeSlot($command->newStartTime, $command->newEndTime)
+                    : null,
+                newRoom: $command->newRoom,
+                newTeacherId: $command->newTeacherId !== null
+                    ? UserId::fromString($command->newTeacherId)
+                    : null,
+                reason: $command->reason,
+                createdBy: $createdBy,
+                now: $this->clock->now(),
+            ),
+        };
+
+        $this->exceptionRepository->save($exception);
+
+        return $exception;
+    }
+}
diff --git a/backend/src/Scolarite/Application/Command/TruncateSlotRecurrence/TruncateSlotRecurrenceCommand.php b/backend/src/Scolarite/Application/Command/TruncateSlotRecurrence/TruncateSlotRecurrenceCommand.php
new file mode 100644
index 0000000..816e99f
--- /dev/null
+++ b/backend/src/Scolarite/Application/Command/TruncateSlotRecurrence/TruncateSlotRecurrenceCommand.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Scolarite\Application\Command\TruncateSlotRecurrence;
+
+final readonly class TruncateSlotRecurrenceCommand
+{
+    public function __construct(
+        public string $tenantId,
+        public string $slotId,
+        public string $fromDate,
+        public string $updatedBy,
+    ) {
+    }
+}
diff --git a/backend/src/Scolarite/Application/Command/TruncateSlotRecurrence/TruncateSlotRecurrenceHandler.php b/backend/src/Scolarite/Application/Command/TruncateSlotRecurrence/TruncateSlotRecurrenceHandler.php
new file mode 100644
index 0000000..259efc4
--- /dev/null
+++ b/backend/src/Scolarite/Application/Command/TruncateSlotRecurrence/TruncateSlotRecurrenceHandler.php
@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Scolarite\Application\Command\TruncateSlotRecurrence;
+
+use App\Scolarite\Domain\Exception\DateExceptionInvalideException;
+use App\Scolarite\Domain\Model\Schedule\ScheduleSlotId;
+use App\Scolarite\Domain\Repository\ScheduleSlotRepository;
+use App\Shared\Domain\Clock;
+use App\Shared\Domain\Tenant\TenantId;
+use DateTimeImmutable;
+
+final readonly class TruncateSlotRecurrenceHandler
+{
+    public function __construct(
+        private ScheduleSlotRepository $slotRepository,
+        private Clock $clock,
+    ) {
+    }
+
+    public function __invoke(TruncateSlotRecurrenceCommand $command): void
+    {
+        $tenantId = TenantId::fromString($command->tenantId);
+        $slotId = ScheduleSlotId::fromString($command->slotId);
+        $slot = $this->slotRepository->get($slotId, $tenantId);
+        $fromDate = new DateTimeImmutable($command->fromDate);
+
+        if (!$slot->isActiveOnDate($fromDate)) {
+            throw DateExceptionInvalideException::pourSlotEtDate($slotId, $fromDate);
+        }
+
+        $now = $this->clock->now();
+        $dayBefore = $fromDate->modify('-1 day');
+        $slot->terminerRecurrenceLe($dayBefore, $now);
+        $this->slotRepository->save($slot);
+    }
+}
diff --git a/backend/src/Scolarite/Application/Command/UpdateRecurringSlot/UpdateRecurringSlotCommand.php b/backend/src/Scolarite/Application/Command/UpdateRecurringSlot/UpdateRecurringSlotCommand.php
new file mode 100644
index 0000000..20bf55f
--- /dev/null
+++ b/backend/src/Scolarite/Application/Command/UpdateRecurringSlot/UpdateRecurringSlotCommand.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Scolarite\Application\Command\UpdateRecurringSlot;
+
+final readonly class UpdateRecurringSlotCommand
+{
+    /**
+     * @param string $scope 'this_occurrence' | 'all_future'
+     */
+    public function __construct(
+        public string $tenantId,
+        public string $slotId,
+        public string $occurrenceDate,
+        public string $scope,
+        public string $classId,
+        public string $subjectId,
+        public string $teacherId,
+        public int $dayOfWeek,
+        public string $startTime,
+        public string $endTime,
+        public ?string $room,
+        public string $updatedBy,
+    ) {
+    }
+}
diff --git a/backend/src/Scolarite/Application/Command/UpdateRecurringSlot/UpdateRecurringSlotHandler.php b/backend/src/Scolarite/Application/Command/UpdateRecurringSlot/UpdateRecurringSlotHandler.php
new file mode 100644
index 0000000..8af3366
--- /dev/null
+++ b/backend/src/Scolarite/Application/Command/UpdateRecurringSlot/UpdateRecurringSlotHandler.php
@@ -0,0 +1,139 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Scolarite\Application\Command\UpdateRecurringSlot;
+
+use App\Administration\Domain\Model\SchoolClass\ClassId;
+use App\Administration\Domain\Model\Subject\SubjectId;
+use App\Administration\Domain\Model\User\UserId;
+use App\Scolarite\Domain\Exception\DateExceptionInvalideException;
+use App\Scolarite\Domain\Model\Schedule\DayOfWeek;
+use App\Scolarite\Domain\Model\Schedule\ScheduleException;
+use App\Scolarite\Domain\Model\Schedule\ScheduleSlot;
+use App\Scolarite\Domain\Model\Schedule\ScheduleSlotId;
+use App\Scolarite\Domain\Model\Schedule\TimeSlot;
+use App\Scolarite\Domain\Repository\ScheduleExceptionRepository;
+use App\Scolarite\Domain\Repository\ScheduleSlotRepository;
+use App\Shared\Domain\Clock;
+use App\Shared\Domain\Tenant\TenantId;
+use DateTimeImmutable;
+use Symfony\Component\Messenger\Attribute\AsMessageHandler;
+
+#[AsMessageHandler(bus: 'command.bus')]
+final readonly class UpdateRecurringSlotHandler
+{
+    public function __construct(
+        private ScheduleSlotRepository $slotRepository,
+        private ScheduleExceptionRepository $exceptionRepository,
+        private Clock $clock,
+    ) {
+    }
+
+    /**
+     * @return array{exception: ?ScheduleException, newSlot: ?ScheduleSlot}
+     */
+    public function __invoke(UpdateRecurringSlotCommand $command): array
+    {
+        $tenantId = TenantId::fromString($command->tenantId);
+        $slotId = ScheduleSlotId::fromString($command->slotId);
+        $slot = $this->slotRepository->get($slotId, $tenantId);
+        $now = $this->clock->now();
+        $occurrenceDate = new DateTimeImmutable($command->occurrenceDate);
+        $newTimeSlot = new TimeSlot($command->startTime, $command->endTime);
+
+        if (!$slot->isActiveOnDate($occurrenceDate)) {
+            throw DateExceptionInvalideException::pourSlotEtDate($slotId, $occurrenceDate);
+        }
+
+        if ($command->scope === 'this_occurrence') {
+            return $this->handleThisOccurrence(
+                $tenantId,
+                $slotId,
+                $occurrenceDate,
+                $newTimeSlot,
+                $command->room,
+                UserId::fromString($command->teacherId),
+                UserId::fromString($command->updatedBy),
+                $now,
+            );
+        }
+
+        // all_future: end current recurrence, create new slot
+        return $this->handleAllFuture(
+            $slot,
+            $tenantId,
+            $occurrenceDate,
+            $command,
+            $now,
+        );
+    }
+
+    /**
+     * @return array{exception: ScheduleException, newSlot: null}
+     */
+    private function handleThisOccurrence(
+        TenantId $tenantId,
+        ScheduleSlotId $slotId,
+        DateTimeImmutable $occurrenceDate,
+        TimeSlot $newTimeSlot,
+        ?string $newRoom,
+        UserId $newTeacherId,
+        UserId $createdBy,
+        DateTimeImmutable $now,
+    ): array {
+        $exception = ScheduleException::modifier(
+            tenantId: $tenantId,
+            slotId: $slotId,
+            exceptionDate: $occurrenceDate,
+            newTimeSlot: $newTimeSlot,
+            newRoom: $newRoom,
+            newTeacherId: $newTeacherId,
+            reason: null,
+            createdBy: $createdBy,
+            now: $now,
+        );
+
+        $this->exceptionRepository->save($exception);
+
+        return ['exception' => $exception, 'newSlot' => null];
+    }
+
+    /**
+     * @return array{exception: null, newSlot: ScheduleSlot}
+     */
+    private function handleAllFuture(
+        ScheduleSlot $slot,
+        TenantId $tenantId,
+        DateTimeImmutable $occurrenceDate,
+        UpdateRecurringSlotCommand $command,
+        DateTimeImmutable $now,
+    ): array {
+        // Save original end date before modifying
+        $originalRecurrenceEnd = $slot->recurrenceEnd;
+
+        // End original slot one day before the change
+        $dayBefore = $occurrenceDate->modify('-1 day');
+        $slot->terminerRecurrenceLe($dayBefore, $now);
+        $this->slotRepository->save($slot);
+
+        // Create new slot starting from the occurrence date
+        $newSlot = ScheduleSlot::creer(
+            tenantId: $tenantId,
+            classId: ClassId::fromString($command->classId),
+            subjectId: SubjectId::fromString($command->subjectId),
+            teacherId: UserId::fromString($command->teacherId),
+            dayOfWeek: DayOfWeek::from($command->dayOfWeek),
+            timeSlot: new TimeSlot($command->startTime, $command->endTime),
+            room: $command->room,
+            isRecurring: true,
+            now: $now,
+            recurrenceStart: $occurrenceDate,
+            recurrenceEnd: $originalRecurrenceEnd,
+        );
+
+        $this->slotRepository->save($newSlot);
+
+        return ['exception' => null, 'newSlot' => $newSlot];
+    }
+}
diff --git a/backend/src/Scolarite/Application/Service/ScheduleResolver.php b/backend/src/Scolarite/Application/Service/ScheduleResolver.php
new file mode 100644
index 0000000..2f48e15
--- /dev/null
+++ b/backend/src/Scolarite/Application/Service/ScheduleResolver.php
@@ -0,0 +1,92 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Scolarite\Application\Service;
+
+use App\Administration\Domain\Model\SchoolCalendar\SchoolCalendar;
+use App\Administration\Domain\Model\SchoolClass\ClassId;
+use App\Scolarite\Domain\Model\Schedule\ResolvedScheduleSlot;
+use App\Scolarite\Domain\Model\Schedule\ScheduleException;
+use App\Scolarite\Domain\Repository\ScheduleExceptionRepository;
+use App\Scolarite\Domain\Repository\ScheduleSlotRepository;
+use App\Shared\Domain\Tenant\TenantId;
+use DateTimeImmutable;
+
+/**
+ * Résout l'emploi du temps réel d'une classe pour une semaine donnée.
+ *
+ * Combine les créneaux récurrents (semaine type), les exceptions ponctuelles,
+ * et le calendrier scolaire pour produire la liste des cours effectifs.
+ */
+final readonly class ScheduleResolver
+{
+    public function __construct(
+        private ScheduleSlotRepository $slotRepository,
+        private ScheduleExceptionRepository $exceptionRepository,
+    ) {
+    }
+
+    /**
+     * @return array<ResolvedScheduleSlot>
+     */
+    public function resolveForWeek(
+        ClassId $classId,
+        DateTimeImmutable $weekStart,
+        TenantId $tenantId,
+        SchoolCalendar $calendar,
+    ): array {
+        $slots = $this->slotRepository->findRecurringByClass($classId, $tenantId);
+        $weekEnd = $weekStart->modify('+6 days');
+
+        $exceptionsIndex = $this->indexExceptions(
+            $this->exceptionRepository->findForDateRange($tenantId, $weekStart, $weekEnd),
+        );
+
+        $resolved = [];
+
+        for ($day = 0; $day < 7; ++$day) {
+            $date = $weekStart->modify("+{$day} days");
+
+            if (!$calendar->estJourOuvre($date)) {
+                continue;
+            }
+
+            foreach ($slots as $slot) {
+                if (!$slot->isActiveOnDate($date)) {
+                    continue;
+                }
+
+                $key = (string) $slot->id . '_' . $date->format('Y-m-d');
+                $exception = $exceptionsIndex[$key] ?? null;
+
+                if ($exception?->isCancelled()) {
+                    continue;
+                }
+
+                $resolved[] = $exception !== null
+                    ? ResolvedScheduleSlot::fromSlotWithException($slot, $exception)
+                    : ResolvedScheduleSlot::fromSlot($slot, $date);
+            }
+        }
+
+        return $resolved;
+    }
+
+    /**
+     * @param array<ScheduleException> $exceptions
+     *
+     * @return array<string, ScheduleException>
+     */
+    private function indexExceptions(array $exceptions): array
+    {
+        $index = [];
+
+        foreach ($exceptions as $exception) {
+            $key = (string) $exception->slotId . '_' . $exception->exceptionDate->format('Y-m-d');
+            $index[$key] = $exception;
+        }
+
+        return $index;
+    }
+}
diff --git a/backend/src/Scolarite/Domain/Exception/DateExceptionInvalideException.php b/backend/src/Scolarite/Domain/Exception/DateExceptionInvalideException.php
new file mode 100644
index 0000000..a8cac64
--- /dev/null
+++ b/backend/src/Scolarite/Domain/Exception/DateExceptionInvalideException.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Scolarite\Domain\Exception;
+
+use App\Scolarite\Domain\Model\Schedule\ScheduleSlotId;
+use DateTimeImmutable;
+use RuntimeException;
+
+final class DateExceptionInvalideException extends RuntimeException
+{
+    public static function pourSlotEtDate(ScheduleSlotId $slotId, DateTimeImmutable $date): self
+    {
+        return new self(
+            "La date {$date->format('Y-m-d')} n'est pas valide pour le créneau $slotId "
+            . '(mauvais jour de la semaine ou hors bornes de récurrence).',
+        );
+    }
+}
diff --git a/backend/src/Scolarite/Domain/Model/Schedule/ResolvedScheduleSlot.php b/backend/src/Scolarite/Domain/Model/Schedule/ResolvedScheduleSlot.php
new file mode 100644
index 0000000..fc184ec
--- /dev/null
+++ b/backend/src/Scolarite/Domain/Model/Schedule/ResolvedScheduleSlot.php
@@ -0,0 +1,77 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Scolarite\Domain\Model\Schedule;
+
+use App\Administration\Domain\Model\SchoolClass\ClassId;
+use App\Administration\Domain\Model\Subject\SubjectId;
+use App\Administration\Domain\Model\User\UserId;
+use App\Shared\Domain\Tenant\TenantId;
+use DateTimeImmutable;
+
+/**
+ * Représentation résolue d'un créneau pour une date donnée.
+ *
+ * Combine le créneau template (récurrent) avec ses éventuelles exceptions
+ * pour donner l'état réel du cours à une date précise.
+ */
+final readonly class ResolvedScheduleSlot
+{
+    public function __construct(
+        public ScheduleSlotId $slotId,
+        public TenantId $tenantId,
+        public ClassId $classId,
+        public SubjectId $subjectId,
+        public UserId $teacherId,
+        public DayOfWeek $dayOfWeek,
+        public TimeSlot $timeSlot,
+        public ?string $room,
+        public DateTimeImmutable $date,
+        public bool $isModified,
+        public ?ScheduleExceptionId $exceptionId,
+    ) {
+    }
+
+    /**
+     * Crée un créneau résolu à partir du template (pas d'exception).
+     */
+    public static function fromSlot(ScheduleSlot $slot, DateTimeImmutable $date): self
+    {
+        return new self(
+            slotId: $slot->id,
+            tenantId: $slot->tenantId,
+            classId: $slot->classId,
+            subjectId: $slot->subjectId,
+            teacherId: $slot->teacherId,
+            dayOfWeek: $slot->dayOfWeek,
+            timeSlot: $slot->timeSlot,
+            room: $slot->room,
+            date: $date,
+            isModified: false,
+            exceptionId: null,
+        );
+    }
+
+    /**
+     * Crée un créneau résolu avec une exception (modification ponctuelle).
+     */
+    public static function fromSlotWithException(
+        ScheduleSlot $slot,
+        ScheduleException $exception,
+    ): self {
+        return new self(
+            slotId: $slot->id,
+            tenantId: $slot->tenantId,
+            classId: $slot->classId,
+            subjectId: $slot->subjectId,
+            teacherId: $exception->newTeacherId ?? $slot->teacherId,
+            dayOfWeek: $slot->dayOfWeek,
+            timeSlot: $exception->newTimeSlot ?? $slot->timeSlot,
+            room: $exception->newRoom ?? $slot->room,
+            date: $exception->exceptionDate,
+            isModified: true,
+            exceptionId: $exception->id,
+        );
+    }
+}
diff --git a/backend/src/Scolarite/Domain/Model/Schedule/ScheduleException.php b/backend/src/Scolarite/Domain/Model/Schedule/ScheduleException.php
new file mode 100644
index 0000000..39e544c
--- /dev/null
+++ b/backend/src/Scolarite/Domain/Model/Schedule/ScheduleException.php
@@ -0,0 +1,134 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Scolarite\Domain\Model\Schedule;
+
+use App\Administration\Domain\Model\User\UserId;
+use App\Shared\Domain\Tenant\TenantId;
+use DateTimeImmutable;
+
+/**
+ * Représente une exception ponctuelle sur un créneau récurrent.
+ *
+ * Une exception peut être une annulation (cancelled) ou une modification
+ * (modified) pour une date précise. Cela permet de gérer les changements
+ * ponctuels sans altérer la semaine type.
+ *
+ * @see FR27: Définir une semaine type qui se répète automatiquement
+ */
+final class ScheduleException
+{
+    private function __construct(
+        public private(set) ScheduleExceptionId $id,
+        public private(set) TenantId $tenantId,
+        public private(set) ScheduleSlotId $slotId,
+        public private(set) DateTimeImmutable $exceptionDate,
+        public private(set) ScheduleExceptionType $type,
+        public private(set) ?TimeSlot $newTimeSlot,
+        public private(set) ?string $newRoom,
+        public private(set) ?UserId $newTeacherId,
+        public private(set) ?string $reason,
+        public private(set) UserId $createdBy,
+        public private(set) DateTimeImmutable $createdAt,
+    ) {
+    }
+
+    /**
+     * Annule un cours récurrent pour une date donnée.
+     */
+    public static function annuler(
+        TenantId $tenantId,
+        ScheduleSlotId $slotId,
+        DateTimeImmutable $exceptionDate,
+        ?string $reason,
+        UserId $createdBy,
+        DateTimeImmutable $now,
+    ): self {
+        return new self(
+            id: ScheduleExceptionId::generate(),
+            tenantId: $tenantId,
+            slotId: $slotId,
+            exceptionDate: $exceptionDate,
+            type: ScheduleExceptionType::CANCELLED,
+            newTimeSlot: null,
+            newRoom: null,
+            newTeacherId: null,
+            reason: $reason,
+            createdBy: $createdBy,
+            createdAt: $now,
+        );
+    }
+
+    /**
+     * Modifie un cours récurrent pour une date donnée.
+     *
+     * Les champs null signifient "pas de changement par rapport au créneau original".
+     */
+    public static function modifier(
+        TenantId $tenantId,
+        ScheduleSlotId $slotId,
+        DateTimeImmutable $exceptionDate,
+        ?TimeSlot $newTimeSlot,
+        ?string $newRoom,
+        ?UserId $newTeacherId,
+        ?string $reason,
+        UserId $createdBy,
+        DateTimeImmutable $now,
+    ): self {
+        return new self(
+            id: ScheduleExceptionId::generate(),
+            tenantId: $tenantId,
+            slotId: $slotId,
+            exceptionDate: $exceptionDate,
+            type: ScheduleExceptionType::MODIFIED,
+            newTimeSlot: $newTimeSlot,
+            newRoom: $newRoom,
+            newTeacherId: $newTeacherId,
+            reason: $reason,
+            createdBy: $createdBy,
+            createdAt: $now,
+        );
+    }
+
+    public function isCancelled(): bool
+    {
+        return $this->type === ScheduleExceptionType::CANCELLED;
+    }
+
+    public function isModified(): bool
+    {
+        return $this->type === ScheduleExceptionType::MODIFIED;
+    }
+
+    /**
+     * @internal Pour usage Infrastructure uniquement
+     */
+    public static function reconstitute(
+        ScheduleExceptionId $id,
+        TenantId $tenantId,
+        ScheduleSlotId $slotId,
+        DateTimeImmutable $exceptionDate,
+        ScheduleExceptionType $type,
+        ?TimeSlot $newTimeSlot,
+        ?string $newRoom,
+        ?UserId $newTeacherId,
+        ?string $reason,
+        UserId $createdBy,
+        DateTimeImmutable $createdAt,
+    ): self {
+        return new self(
+            id: $id,
+            tenantId: $tenantId,
+            slotId: $slotId,
+            exceptionDate: $exceptionDate,
+            type: $type,
+            newTimeSlot: $newTimeSlot,
+            newRoom: $newRoom,
+            newTeacherId: $newTeacherId,
+            reason: $reason,
+            createdBy: $createdBy,
+            createdAt: $createdAt,
+        );
+    }
+}
diff --git a/backend/src/Scolarite/Domain/Model/Schedule/ScheduleExceptionId.php b/backend/src/Scolarite/Domain/Model/Schedule/ScheduleExceptionId.php
new file mode 100644
index 0000000..0338612
--- /dev/null
+++ b/backend/src/Scolarite/Domain/Model/Schedule/ScheduleExceptionId.php
@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Scolarite\Domain\Model\Schedule;
+
+use App\Shared\Domain\EntityId;
+
+final readonly class ScheduleExceptionId extends EntityId
+{
+}
diff --git a/backend/src/Scolarite/Domain/Model/Schedule/ScheduleExceptionType.php b/backend/src/Scolarite/Domain/Model/Schedule/ScheduleExceptionType.php
new file mode 100644
index 0000000..eaa86f8
--- /dev/null
+++ b/backend/src/Scolarite/Domain/Model/Schedule/ScheduleExceptionType.php
@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Scolarite\Domain\Model\Schedule;
+
+enum ScheduleExceptionType: string
+{
+    case MODIFIED = 'modified';
+    case CANCELLED = 'cancelled';
+}
diff --git a/backend/src/Scolarite/Domain/Model/Schedule/ScheduleSlot.php b/backend/src/Scolarite/Domain/Model/Schedule/ScheduleSlot.php
index 602a13b..1fec957 100644
--- a/backend/src/Scolarite/Domain/Model/Schedule/ScheduleSlot.php
+++ b/backend/src/Scolarite/Domain/Model/Schedule/ScheduleSlot.php
@@ -37,6 +37,8 @@ final class ScheduleSlot extends AggregateRoot
         public private(set) ?string $room,
         public private(set) bool $isRecurring,
         public private(set) DateTimeImmutable $createdAt,
+        public private(set) ?DateTimeImmutable $recurrenceStart = null,
+        public private(set) ?DateTimeImmutable $recurrenceEnd = null,
     ) {
         $this->updatedAt = $createdAt;
     }
@@ -54,6 +56,8 @@ final class ScheduleSlot extends AggregateRoot
         ?string $room,
         bool $isRecurring,
         DateTimeImmutable $now,
+        ?DateTimeImmutable $recurrenceStart = null,
+        ?DateTimeImmutable $recurrenceEnd = null,
     ): self {
         $room = $room !== '' ? $room : null;
 
@@ -68,6 +72,8 @@ final class ScheduleSlot extends AggregateRoot
             room: $room,
             isRecurring: $isRecurring,
             createdAt: $now,
+            recurrenceStart: $recurrenceStart,
+            recurrenceEnd: $recurrenceEnd,
         );
 
         $slot->recordEvent(new CoursCree(
@@ -133,6 +139,44 @@ final class ScheduleSlot extends AggregateRoot
         ));
     }
 
+    /**
+     * Termine la récurrence à une date donnée (pour le scénario "modifier toutes les futures").
+     */
+    public function terminerRecurrenceLe(DateTimeImmutable $date, DateTimeImmutable $at): void
+    {
+        $this->recurrenceEnd = $date;
+        $this->updatedAt = $at;
+    }
+
+    /**
+     * Vérifie si ce créneau récurrent est actif à une date donnée.
+     *
+     * Un créneau est actif si : récurrent, même jour de la semaine,
+     * et la date est dans les bornes de récurrence.
+     */
+    public function isActiveOnDate(DateTimeImmutable $date): bool
+    {
+        if (!$this->isRecurring) {
+            return false;
+        }
+
+        if (DayOfWeek::from((int) $date->format('N')) !== $this->dayOfWeek) {
+            return false;
+        }
+
+        $dateOnly = $date->format('Y-m-d');
+
+        if ($this->recurrenceStart !== null && $dateOnly < $this->recurrenceStart->format('Y-m-d')) {
+            return false;
+        }
+
+        if ($this->recurrenceEnd !== null && $dateOnly > $this->recurrenceEnd->format('Y-m-d')) {
+            return false;
+        }
+
+        return true;
+    }
+
     /**
      * Vérifie si ce créneau entre en conflit temporel avec un autre sur le même jour.
      */
@@ -159,6 +203,8 @@ final class ScheduleSlot extends AggregateRoot
         bool $isRecurring,
         DateTimeImmutable $createdAt,
         DateTimeImmutable $updatedAt,
+        ?DateTimeImmutable $recurrenceStart = null,
+        ?DateTimeImmutable $recurrenceEnd = null,
     ): self {
         $slot = new self(
             id: $id,
@@ -171,6 +217,8 @@ final class ScheduleSlot extends AggregateRoot
             room: $room,
             isRecurring: $isRecurring,
             createdAt: $createdAt,
+            recurrenceStart: $recurrenceStart,
+            recurrenceEnd: $recurrenceEnd,
         );
 
         $slot->updatedAt = $updatedAt;
diff --git a/backend/src/Scolarite/Domain/Repository/ScheduleExceptionRepository.php b/backend/src/Scolarite/Domain/Repository/ScheduleExceptionRepository.php
new file mode 100644
index 0000000..71c814e
--- /dev/null
+++ b/backend/src/Scolarite/Domain/Repository/ScheduleExceptionRepository.php
@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Scolarite\Domain\Repository;
+
+use App\Scolarite\Domain\Model\Schedule\ScheduleException;
+use App\Scolarite\Domain\Model\Schedule\ScheduleExceptionId;
+use App\Scolarite\Domain\Model\Schedule\ScheduleSlotId;
+use App\Shared\Domain\Tenant\TenantId;
+use DateTimeImmutable;
+
+interface ScheduleExceptionRepository
+{
+    public function save(ScheduleException $exception): void;
+
+    public function findById(ScheduleExceptionId $id, TenantId $tenantId): ?ScheduleException;
+
+    public function findForSlotAndDate(
+        ScheduleSlotId $slotId,
+        DateTimeImmutable $date,
+        TenantId $tenantId,
+    ): ?ScheduleException;
+
+    /**
+     * @return array<ScheduleException>
+     */
+    public function findForSlotBetweenDates(
+        ScheduleSlotId $slotId,
+        DateTimeImmutable $startDate,
+        DateTimeImmutable $endDate,
+        TenantId $tenantId,
+    ): array;
+
+    /**
+     * @return array<ScheduleException>
+     */
+    public function findForDateRange(
+        TenantId $tenantId,
+        DateTimeImmutable $startDate,
+        DateTimeImmutable $endDate,
+    ): array;
+
+    public function delete(ScheduleExceptionId $id, TenantId $tenantId): void;
+}
diff --git a/backend/src/Scolarite/Domain/Repository/ScheduleSlotRepository.php b/backend/src/Scolarite/Domain/Repository/ScheduleSlotRepository.php
index 20c2683..1550fc8 100644
--- a/backend/src/Scolarite/Domain/Repository/ScheduleSlotRepository.php
+++ b/backend/src/Scolarite/Domain/Repository/ScheduleSlotRepository.php
@@ -26,6 +26,9 @@ interface ScheduleSlotRepository
     /** @return array<ScheduleSlot> */
     public function findByClass(ClassId $classId, TenantId $tenantId): array;
 
+    /** @return array<ScheduleSlot> */
+    public function findRecurringByClass(ClassId $classId, TenantId $tenantId): array;
+
     /** @return array<ScheduleSlot> */
     public function findByTeacher(UserId $teacherId, TenantId $tenantId): array;
 
diff --git a/backend/src/Scolarite/Infrastructure/Api/Processor/CancelOccurrenceProcessor.php b/backend/src/Scolarite/Infrastructure/Api/Processor/CancelOccurrenceProcessor.php
new file mode 100644
index 0000000..0091ae1
--- /dev/null
+++ b/backend/src/Scolarite/Infrastructure/Api/Processor/CancelOccurrenceProcessor.php
@@ -0,0 +1,104 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Scolarite\Infrastructure\Api\Processor;
+
+use ApiPlatform\Metadata\Operation;
+use ApiPlatform\State\ProcessorInterface;
+use App\Administration\Infrastructure\Security\SecurityUser;
+use App\Scolarite\Application\Command\CreateScheduleException\CreateScheduleExceptionCommand;
+use App\Scolarite\Application\Command\CreateScheduleException\CreateScheduleExceptionHandler;
+use App\Scolarite\Application\Command\TruncateSlotRecurrence\TruncateSlotRecurrenceCommand;
+use App\Scolarite\Application\Command\TruncateSlotRecurrence\TruncateSlotRecurrenceHandler;
+use App\Scolarite\Domain\Exception\DateExceptionInvalideException;
+use App\Scolarite\Domain\Exception\ScheduleSlotNotFoundException;
+use App\Scolarite\Infrastructure\Api\Resource\ScheduleOccurrenceResource;
+use App\Scolarite\Infrastructure\Security\ScheduleSlotVoter;
+use App\Shared\Infrastructure\Tenant\TenantContext;
+use Override;
+use Symfony\Component\HttpFoundation\RequestStack;
+use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
+use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
+use Symfony\Component\HttpKernel\Exception\UnauthorizedHttpException;
+use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
+use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
+
+/**
+ * @implements ProcessorInterface<ScheduleOccurrenceResource, ScheduleOccurrenceResource>
+ */
+final readonly class CancelOccurrenceProcessor implements ProcessorInterface
+{
+    public function __construct(
+        private CreateScheduleExceptionHandler $cancelHandler,
+        private TruncateSlotRecurrenceHandler $truncateHandler,
+        private TenantContext $tenantContext,
+        private AuthorizationCheckerInterface $authorizationChecker,
+        private TokenStorageInterface $tokenStorage,
+        private RequestStack $requestStack,
+    ) {
+    }
+
+    /**
+     * @param ScheduleOccurrenceResource|null $data
+     */
+    #[Override]
+    public function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = []): ScheduleOccurrenceResource
+    {
+        if (!$this->authorizationChecker->isGranted(ScheduleSlotVoter::DELETE)) {
+            throw new AccessDeniedHttpException("Vous n'êtes pas autorisé à modifier l'emploi du temps.");
+        }
+
+        if (!$this->tenantContext->hasTenant()) {
+            throw new UnauthorizedHttpException('Bearer', 'Tenant non défini.');
+        }
+
+        /** @var string $slotId */
+        $slotId = $uriVariables['id'] ?? '';
+        /** @var string $date */
+        $date = $uriVariables['date'] ?? '';
+
+        $user = $this->tokenStorage->getToken()?->getUser();
+        $userId = $user instanceof SecurityUser ? $user->userId() : '';
+        $tenantId = (string) $this->tenantContext->getCurrentTenantId();
+
+        $scope = $this->requestStack->getCurrentRequest()?->query->getString('scope', 'this_occurrence');
+
+        try {
+            if ($scope === 'all_future') {
+                ($this->truncateHandler)(new TruncateSlotRecurrenceCommand(
+                    tenantId: $tenantId,
+                    slotId: $slotId,
+                    fromDate: $date,
+                    updatedBy: $userId,
+                ));
+
+                $type = 'truncated';
+            } else {
+                ($this->cancelHandler)(new CreateScheduleExceptionCommand(
+                    tenantId: $tenantId,
+                    slotId: $slotId,
+                    exceptionDate: $date,
+                    type: 'cancelled',
+                    createdBy: $userId,
+                    reason: $data?->reason,
+                ));
+
+                $type = 'cancelled';
+            }
+
+            $resource = new ScheduleOccurrenceResource();
+            $resource->id = $slotId . '_' . $date;
+            $resource->slotId = $slotId;
+            $resource->date = $date;
+            $resource->type = $type;
+
+            return $resource;
+        } catch (ScheduleSlotNotFoundException $e) {
+            throw new NotFoundHttpException($e->getMessage());
+        } catch (DateExceptionInvalideException $e) {
+            throw new BadRequestHttpException($e->getMessage());
+        }
+    }
+}
diff --git a/backend/src/Scolarite/Infrastructure/Api/Processor/ModifyOccurrenceProcessor.php b/backend/src/Scolarite/Infrastructure/Api/Processor/ModifyOccurrenceProcessor.php
new file mode 100644
index 0000000..6ea5e56
--- /dev/null
+++ b/backend/src/Scolarite/Infrastructure/Api/Processor/ModifyOccurrenceProcessor.php
@@ -0,0 +1,93 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Scolarite\Infrastructure\Api\Processor;
+
+use ApiPlatform\Metadata\Operation;
+use ApiPlatform\State\ProcessorInterface;
+use App\Administration\Infrastructure\Security\SecurityUser;
+use App\Scolarite\Application\Command\UpdateRecurringSlot\UpdateRecurringSlotCommand;
+use App\Scolarite\Application\Command\UpdateRecurringSlot\UpdateRecurringSlotHandler;
+use App\Scolarite\Domain\Exception\DateExceptionInvalideException;
+use App\Scolarite\Domain\Exception\ScheduleSlotNotFoundException;
+use App\Scolarite\Infrastructure\Api\Resource\ScheduleOccurrenceResource;
+use App\Scolarite\Infrastructure\Security\ScheduleSlotVoter;
+use App\Shared\Infrastructure\Tenant\TenantContext;
+use Override;
+use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
+use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
+use Symfony\Component\HttpKernel\Exception\UnauthorizedHttpException;
+use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
+use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
+use ValueError;
+
+/**
+ * @implements ProcessorInterface<ScheduleOccurrenceResource, ScheduleOccurrenceResource>
+ */
+final readonly class ModifyOccurrenceProcessor implements ProcessorInterface
+{
+    public function __construct(
+        private UpdateRecurringSlotHandler $handler,
+        private TenantContext $tenantContext,
+        private AuthorizationCheckerInterface $authorizationChecker,
+        private TokenStorageInterface $tokenStorage,
+    ) {
+    }
+
+    /**
+     * @param ScheduleOccurrenceResource $data
+     */
+    #[Override]
+    public function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = []): ScheduleOccurrenceResource
+    {
+        if (!$this->authorizationChecker->isGranted(ScheduleSlotVoter::EDIT)) {
+            throw new AccessDeniedHttpException("Vous n'êtes pas autorisé à modifier l'emploi du temps.");
+        }
+
+        if (!$this->tenantContext->hasTenant()) {
+            throw new UnauthorizedHttpException('Bearer', 'Tenant non défini.');
+        }
+
+        /** @var string $slotId */
+        $slotId = $uriVariables['id'] ?? '';
+        /** @var string $date */
+        $date = $uriVariables['date'] ?? '';
+
+        $user = $this->tokenStorage->getToken()?->getUser();
+        $userId = $user instanceof SecurityUser ? $user->userId() : '';
+
+        try {
+            $command = new UpdateRecurringSlotCommand(
+                tenantId: (string) $this->tenantContext->getCurrentTenantId(),
+                slotId: $slotId,
+                occurrenceDate: $date,
+                scope: $data->scope ?? 'this_occurrence',
+                classId: $data->classId ?? '',
+                subjectId: $data->subjectId ?? '',
+                teacherId: $data->teacherId ?? '',
+                dayOfWeek: $data->dayOfWeek ?? 1,
+                startTime: $data->startTime ?? '',
+                endTime: $data->endTime ?? '',
+                room: $data->room,
+                updatedBy: $userId,
+            );
+
+            $result = ($this->handler)($command);
+
+            $resource = new ScheduleOccurrenceResource();
+            $resource->id = $slotId . '_' . $date;
+            $resource->slotId = $slotId;
+            $resource->date = $date;
+            $resource->scope = $data->scope;
+            $resource->type = $result['exception'] !== null ? 'modified' : 'recurring_updated';
+
+            return $resource;
+        } catch (ScheduleSlotNotFoundException $e) {
+            throw new NotFoundHttpException($e->getMessage());
+        } catch (DateExceptionInvalideException|ValueError $e) {
+            throw new BadRequestHttpException($e->getMessage());
+        }
+    }
+}
diff --git a/backend/src/Scolarite/Infrastructure/Api/Provider/ResolvedScheduleWeekProvider.php b/backend/src/Scolarite/Infrastructure/Api/Provider/ResolvedScheduleWeekProvider.php
new file mode 100644
index 0000000..70d2e18
--- /dev/null
+++ b/backend/src/Scolarite/Infrastructure/Api/Provider/ResolvedScheduleWeekProvider.php
@@ -0,0 +1,99 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Scolarite\Infrastructure\Api\Provider;
+
+use ApiPlatform\Metadata\Operation;
+use ApiPlatform\State\ProviderInterface;
+use App\Administration\Domain\Model\SchoolCalendar\SchoolCalendar;
+use App\Administration\Domain\Model\SchoolCalendar\SchoolCalendarRepository;
+use App\Administration\Domain\Model\SchoolClass\AcademicYearId;
+use App\Administration\Domain\Model\SchoolClass\ClassId;
+use App\Administration\Infrastructure\Service\CurrentAcademicYearResolver;
+use App\Scolarite\Application\Service\ScheduleResolver;
+use App\Scolarite\Infrastructure\Api\Resource\ResolvedScheduleSlotResource;
+use App\Scolarite\Infrastructure\Security\ScheduleSlotVoter;
+use App\Shared\Domain\Tenant\TenantId;
+use App\Shared\Infrastructure\Tenant\TenantContext;
+
+use function array_map;
+
+use DateTimeImmutable;
+use Override;
+use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
+use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
+use Symfony\Component\HttpKernel\Exception\UnauthorizedHttpException;
+use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
+
+/**
+ * Provider pour l'emploi du temps résolu d'une semaine.
+ *
+ * @implements ProviderInterface<ResolvedScheduleSlotResource>
+ */
+final readonly class ResolvedScheduleWeekProvider implements ProviderInterface
+{
+    public function __construct(
+        private ScheduleResolver $scheduleResolver,
+        private SchoolCalendarRepository $calendarRepository,
+        private TenantContext $tenantContext,
+        private AuthorizationCheckerInterface $authorizationChecker,
+        private CurrentAcademicYearResolver $academicYearResolver,
+    ) {
+    }
+
+    /** @return array<ResolvedScheduleSlotResource> */
+    #[Override]
+    public function provide(Operation $operation, array $uriVariables = [], array $context = []): array
+    {
+        if (!$this->authorizationChecker->isGranted(ScheduleSlotVoter::VIEW)) {
+            throw new AccessDeniedHttpException("Vous n'êtes pas autorisé à consulter l'emploi du temps.");
+        }
+
+        if (!$this->tenantContext->hasTenant()) {
+            throw new UnauthorizedHttpException('Bearer', 'Tenant non défini.');
+        }
+
+        /** @var array<string, string> $filters */
+        $filters = $context['filters'] ?? [];
+
+        if (!isset($filters['classId'])) {
+            throw new BadRequestHttpException('Le paramètre classId est requis.');
+        }
+
+        /** @var string $dateParam */
+        $dateParam = $uriVariables['date'] ?? '';
+        $weekStart = new DateTimeImmutable($dateParam);
+
+        $tenantId = TenantId::fromString((string) $this->tenantContext->getCurrentTenantId());
+        $classId = ClassId::fromString((string) $filters['classId']);
+
+        $calendar = $this->loadCalendar($tenantId);
+
+        // TODO: cache-aside par classId+weekStart si la perf le nécessite
+        $resolved = $this->scheduleResolver->resolveForWeek(
+            $classId,
+            $weekStart,
+            $tenantId,
+            $calendar,
+        );
+
+        return array_map(ResolvedScheduleSlotResource::fromDomain(...), $resolved);
+    }
+
+    private function loadCalendar(TenantId $tenantId): SchoolCalendar
+    {
+        $academicYearId = $this->academicYearResolver->resolve('current');
+
+        if ($academicYearId === null) {
+            return SchoolCalendar::initialiser($tenantId, AcademicYearId::generate());
+        }
+
+        $calendar = $this->calendarRepository->findByTenantAndYear(
+            $tenantId,
+            AcademicYearId::fromString($academicYearId),
+        );
+
+        return $calendar ?? SchoolCalendar::initialiser($tenantId, AcademicYearId::generate());
+    }
+}
diff --git a/backend/src/Scolarite/Infrastructure/Api/Resource/ResolvedScheduleSlotResource.php b/backend/src/Scolarite/Infrastructure/Api/Resource/ResolvedScheduleSlotResource.php
new file mode 100644
index 0000000..0864400
--- /dev/null
+++ b/backend/src/Scolarite/Infrastructure/Api/Resource/ResolvedScheduleSlotResource.php
@@ -0,0 +1,81 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Scolarite\Infrastructure\Api\Resource;
+
+use ApiPlatform\Metadata\ApiProperty;
+use ApiPlatform\Metadata\ApiResource;
+use ApiPlatform\Metadata\GetCollection;
+use ApiPlatform\Metadata\Link;
+use App\Scolarite\Domain\Model\Schedule\ResolvedScheduleSlot;
+use App\Scolarite\Infrastructure\Api\Provider\ResolvedScheduleWeekProvider;
+
+/**
+ * API Resource pour l'emploi du temps résolu (récurrences + exceptions + calendrier).
+ *
+ * @see Story 4.2 - Récurrences Hebdomadaires
+ * @see FR27 - Définir une semaine type qui se répète automatiquement
+ */
+#[ApiResource(
+    shortName: 'ResolvedScheduleSlot',
+    operations: [
+        new GetCollection(
+            uriTemplate: '/schedule/week/{date}',
+            uriVariables: [
+                'date' => new Link(
+                    fromClass: self::class,
+                    identifiers: ['date'],
+                ),
+            ],
+            provider: ResolvedScheduleWeekProvider::class,
+            name: 'get_resolved_schedule_week',
+        ),
+    ],
+)]
+final class ResolvedScheduleSlotResource
+{
+    #[ApiProperty(identifier: true)]
+    public ?string $id = null;
+
+    public ?string $slotId = null;
+
+    public ?string $classId = null;
+
+    public ?string $subjectId = null;
+
+    public ?string $teacherId = null;
+
+    public ?int $dayOfWeek = null;
+
+    public ?string $startTime = null;
+
+    public ?string $endTime = null;
+
+    public ?string $room = null;
+
+    public ?string $date = null;
+
+    public ?bool $isModified = null;
+
+    public ?string $exceptionId = null;
+
+    public static function fromDomain(ResolvedScheduleSlot $resolved): self
+    {
+        $resource = new self();
+        $resource->id = (string) $resolved->slotId . '_' . $resolved->date->format('Y-m-d');
+        $resource->slotId = (string) $resolved->slotId;
+        $resource->classId = (string) $resolved->classId;
+        $resource->subjectId = (string) $resolved->subjectId;
+        $resource->teacherId = (string) $resolved->teacherId;
+        $resource->dayOfWeek = $resolved->dayOfWeek->value;
+        $resource->startTime = $resolved->timeSlot->startTime;
+        $resource->endTime = $resolved->timeSlot->endTime;
+        $resource->room = $resolved->room;
+        $resource->date = $resolved->date->format('Y-m-d');
+        $resource->isModified = $resolved->isModified;
+        $resource->exceptionId = $resolved->exceptionId !== null ? (string) $resolved->exceptionId : null;
+
+        return $resource;
+    }
+}
diff --git a/backend/src/Scolarite/Infrastructure/Api/Resource/ScheduleOccurrenceResource.php b/backend/src/Scolarite/Infrastructure/Api/Resource/ScheduleOccurrenceResource.php
new file mode 100644
index 0000000..4db8315
--- /dev/null
+++ b/backend/src/Scolarite/Infrastructure/Api/Resource/ScheduleOccurrenceResource.php
@@ -0,0 +1,71 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Scolarite\Infrastructure\Api\Resource;
+
+use ApiPlatform\Metadata\ApiProperty;
+use ApiPlatform\Metadata\ApiResource;
+use ApiPlatform\Metadata\Delete;
+use ApiPlatform\Metadata\Put;
+use App\Scolarite\Infrastructure\Api\Processor\CancelOccurrenceProcessor;
+use App\Scolarite\Infrastructure\Api\Processor\ModifyOccurrenceProcessor;
+use Symfony\Component\Validator\Constraints as Assert;
+
+/**
+ * API Resource pour les modifications ponctuelles d'occurrences de cours récurrents.
+ *
+ * @see Story 4.2 - Récurrences Hebdomadaires (AC3, AC5)
+ */
+#[ApiResource(
+    shortName: 'ScheduleOccurrence',
+    operations: [
+        new Put(
+            uriTemplate: '/schedule/slots/{id}/occurrence/{date}',
+            read: false,
+            processor: ModifyOccurrenceProcessor::class,
+            name: 'modify_schedule_occurrence',
+        ),
+        new Delete(
+            uriTemplate: '/schedule/slots/{id}/occurrence/{date}',
+            read: false,
+            processor: CancelOccurrenceProcessor::class,
+            name: 'cancel_schedule_occurrence',
+        ),
+    ],
+)]
+final class ScheduleOccurrenceResource
+{
+    #[ApiProperty(identifier: true)]
+    public ?string $id = null;
+
+    /**
+     * 'this_occurrence' (modifier uniquement cette date) ou 'all_future' (toutes les futures).
+     */
+    #[Assert\Choice(choices: ['this_occurrence', 'all_future'], message: 'Le scope doit être "this_occurrence" ou "all_future".')]
+    public ?string $scope = 'this_occurrence';
+
+    public ?string $classId = null;
+
+    public ?string $subjectId = null;
+
+    public ?string $teacherId = null;
+
+    public ?int $dayOfWeek = null;
+
+    #[Assert\Regex(pattern: '/^([01]\d|2[0-3]):[0-5]\d$/', message: "L'heure doit être au format HH:MM.")]
+    public ?string $startTime = null;
+
+    #[Assert\Regex(pattern: '/^([01]\d|2[0-3]):[0-5]\d$/', message: "L'heure doit être au format HH:MM.")]
+    public ?string $endTime = null;
+
+    public ?string $room = null;
+
+    public ?string $reason = null;
+
+    public ?string $type = null;
+
+    public ?string $date = null;
+
+    public ?string $slotId = null;
+}
diff --git a/backend/src/Scolarite/Infrastructure/Persistence/Doctrine/DoctrineScheduleExceptionRepository.php b/backend/src/Scolarite/Infrastructure/Persistence/Doctrine/DoctrineScheduleExceptionRepository.php
new file mode 100644
index 0000000..9c40812
--- /dev/null
+++ b/backend/src/Scolarite/Infrastructure/Persistence/Doctrine/DoctrineScheduleExceptionRepository.php
@@ -0,0 +1,199 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Scolarite\Infrastructure\Persistence\Doctrine;
+
+use App\Administration\Domain\Model\User\UserId;
+use App\Scolarite\Domain\Model\Schedule\ScheduleException;
+use App\Scolarite\Domain\Model\Schedule\ScheduleExceptionId;
+use App\Scolarite\Domain\Model\Schedule\ScheduleExceptionType;
+use App\Scolarite\Domain\Model\Schedule\ScheduleSlotId;
+use App\Scolarite\Domain\Model\Schedule\TimeSlot;
+use App\Scolarite\Domain\Repository\ScheduleExceptionRepository;
+use App\Shared\Domain\Tenant\TenantId;
+
+use function array_map;
+
+use DateTimeImmutable;
+use Doctrine\DBAL\Connection;
+use Override;
+
+final readonly class DoctrineScheduleExceptionRepository implements ScheduleExceptionRepository
+{
+    public function __construct(
+        private Connection $connection,
+    ) {
+    }
+
+    #[Override]
+    public function save(ScheduleException $exception): void
+    {
+        $this->connection->executeStatement(
+            'INSERT INTO schedule_exceptions (id, tenant_id, slot_id, exception_date, exception_type, new_start_time, new_end_time, new_room, new_teacher_id, reason, created_at, created_by)
+             VALUES (:id, :tenant_id, :slot_id, :exception_date, :exception_type, :new_start_time, :new_end_time, :new_room, :new_teacher_id, :reason, :created_at, :created_by)
+             ON CONFLICT (slot_id, exception_date) DO UPDATE SET
+                 exception_type = EXCLUDED.exception_type,
+                 new_start_time = EXCLUDED.new_start_time,
+                 new_end_time = EXCLUDED.new_end_time,
+                 new_room = EXCLUDED.new_room,
+                 new_teacher_id = EXCLUDED.new_teacher_id,
+                 reason = EXCLUDED.reason',
+            [
+                'id' => (string) $exception->id,
+                'tenant_id' => (string) $exception->tenantId,
+                'slot_id' => (string) $exception->slotId,
+                'exception_date' => $exception->exceptionDate->format('Y-m-d'),
+                'exception_type' => $exception->type->value,
+                'new_start_time' => $exception->newTimeSlot?->startTime,
+                'new_end_time' => $exception->newTimeSlot?->endTime,
+                'new_room' => $exception->newRoom,
+                'new_teacher_id' => $exception->newTeacherId !== null ? (string) $exception->newTeacherId : null,
+                'reason' => $exception->reason,
+                'created_at' => $exception->createdAt->format(DateTimeImmutable::ATOM),
+                'created_by' => (string) $exception->createdBy,
+            ],
+        );
+    }
+
+    #[Override]
+    public function findById(ScheduleExceptionId $id, TenantId $tenantId): ?ScheduleException
+    {
+        $row = $this->connection->fetchAssociative(
+            'SELECT * FROM schedule_exceptions WHERE id = :id AND tenant_id = :tenant_id',
+            ['id' => (string) $id, 'tenant_id' => (string) $tenantId],
+        );
+
+        if ($row === false) {
+            return null;
+        }
+
+        return $this->hydrate($row);
+    }
+
+    #[Override]
+    public function findForSlotAndDate(
+        ScheduleSlotId $slotId,
+        DateTimeImmutable $date,
+        TenantId $tenantId,
+    ): ?ScheduleException {
+        $row = $this->connection->fetchAssociative(
+            'SELECT * FROM schedule_exceptions
+             WHERE slot_id = :slot_id AND exception_date = :exception_date AND tenant_id = :tenant_id',
+            [
+                'slot_id' => (string) $slotId,
+                'exception_date' => $date->format('Y-m-d'),
+                'tenant_id' => (string) $tenantId,
+            ],
+        );
+
+        if ($row === false) {
+            return null;
+        }
+
+        return $this->hydrate($row);
+    }
+
+    #[Override]
+    public function findForSlotBetweenDates(
+        ScheduleSlotId $slotId,
+        DateTimeImmutable $startDate,
+        DateTimeImmutable $endDate,
+        TenantId $tenantId,
+    ): array {
+        $rows = $this->connection->fetchAllAssociative(
+            'SELECT * FROM schedule_exceptions
+             WHERE slot_id = :slot_id
+             AND exception_date >= :start_date
+             AND exception_date <= :end_date
+             AND tenant_id = :tenant_id
+             ORDER BY exception_date',
+            [
+                'slot_id' => (string) $slotId,
+                'start_date' => $startDate->format('Y-m-d'),
+                'end_date' => $endDate->format('Y-m-d'),
+                'tenant_id' => (string) $tenantId,
+            ],
+        );
+
+        return array_map($this->hydrate(...), $rows);
+    }
+
+    #[Override]
+    public function findForDateRange(
+        TenantId $tenantId,
+        DateTimeImmutable $startDate,
+        DateTimeImmutable $endDate,
+    ): array {
+        $rows = $this->connection->fetchAllAssociative(
+            'SELECT * FROM schedule_exceptions
+             WHERE tenant_id = :tenant_id
+             AND exception_date >= :start_date
+             AND exception_date <= :end_date
+             ORDER BY exception_date',
+            [
+                'tenant_id' => (string) $tenantId,
+                'start_date' => $startDate->format('Y-m-d'),
+                'end_date' => $endDate->format('Y-m-d'),
+            ],
+        );
+
+        return array_map($this->hydrate(...), $rows);
+    }
+
+    #[Override]
+    public function delete(ScheduleExceptionId $id, TenantId $tenantId): void
+    {
+        $this->connection->executeStatement(
+            'DELETE FROM schedule_exceptions WHERE id = :id AND tenant_id = :tenant_id',
+            ['id' => (string) $id, 'tenant_id' => (string) $tenantId],
+        );
+    }
+
+    /**
+     * @param array<string, mixed> $row
+     */
+    private function hydrate(array $row): ScheduleException
+    {
+        /** @var string $id */
+        $id = $row['id'];
+        /** @var string $tenantId */
+        $tenantId = $row['tenant_id'];
+        /** @var string $slotId */
+        $slotId = $row['slot_id'];
+        /** @var string $exceptionDate */
+        $exceptionDate = $row['exception_date'];
+        /** @var string $exceptionType */
+        $exceptionType = $row['exception_type'];
+        /** @var string|null $newStartTime */
+        $newStartTime = $row['new_start_time'] ?? null;
+        /** @var string|null $newEndTime */
+        $newEndTime = $row['new_end_time'] ?? null;
+        /** @var string|null $newRoom */
+        $newRoom = $row['new_room'] ?? null;
+        /** @var string|null $newTeacherId */
+        $newTeacherId = $row['new_teacher_id'] ?? null;
+        /** @var string|null $reason */
+        $reason = $row['reason'] ?? null;
+        /** @var string $createdBy */
+        $createdBy = $row['created_by'];
+        /** @var string $createdAt */
+        $createdAt = $row['created_at'];
+
+        return ScheduleException::reconstitute(
+            id: ScheduleExceptionId::fromString($id),
+            tenantId: TenantId::fromString($tenantId),
+            slotId: ScheduleSlotId::fromString($slotId),
+            exceptionDate: new DateTimeImmutable($exceptionDate),
+            type: ScheduleExceptionType::from($exceptionType),
+            newTimeSlot: $newStartTime !== null && $newEndTime !== null
+                ? new TimeSlot($newStartTime, $newEndTime)
+                : null,
+            newRoom: $newRoom,
+            newTeacherId: $newTeacherId !== null ? UserId::fromString($newTeacherId) : null,
+            reason: $reason,
+            createdBy: UserId::fromString($createdBy),
+            createdAt: new DateTimeImmutable($createdAt),
+        );
+    }
+}
diff --git a/backend/src/Scolarite/Infrastructure/Persistence/Doctrine/DoctrineScheduleSlotRepository.php b/backend/src/Scolarite/Infrastructure/Persistence/Doctrine/DoctrineScheduleSlotRepository.php
index 7aa2e3b..3b41f77 100644
--- a/backend/src/Scolarite/Infrastructure/Persistence/Doctrine/DoctrineScheduleSlotRepository.php
+++ b/backend/src/Scolarite/Infrastructure/Persistence/Doctrine/DoctrineScheduleSlotRepository.php
@@ -32,8 +32,8 @@ final readonly class DoctrineScheduleSlotRepository implements ScheduleSlotRepos
     public function save(ScheduleSlot $slot): void
     {
         $this->connection->executeStatement(
-            'INSERT INTO schedule_slots (id, tenant_id, class_id, subject_id, teacher_id, day_of_week, start_time, end_time, room, is_recurring, created_at, updated_at)
-             VALUES (:id, :tenant_id, :class_id, :subject_id, :teacher_id, :day_of_week, :start_time, :end_time, :room, :is_recurring, :created_at, :updated_at)
+            'INSERT INTO schedule_slots (id, tenant_id, class_id, subject_id, teacher_id, day_of_week, start_time, end_time, room, is_recurring, recurrence_start, recurrence_end, created_at, updated_at)
+             VALUES (:id, :tenant_id, :class_id, :subject_id, :teacher_id, :day_of_week, :start_time, :end_time, :room, :is_recurring, :recurrence_start, :recurrence_end, :created_at, :updated_at)
              ON CONFLICT (id) DO UPDATE SET
                  class_id = EXCLUDED.class_id,
                  subject_id = EXCLUDED.subject_id,
@@ -42,6 +42,8 @@ final readonly class DoctrineScheduleSlotRepository implements ScheduleSlotRepos
                  start_time = EXCLUDED.start_time,
                  end_time = EXCLUDED.end_time,
                  room = EXCLUDED.room,
+                 recurrence_start = EXCLUDED.recurrence_start,
+                 recurrence_end = EXCLUDED.recurrence_end,
                  updated_at = EXCLUDED.updated_at',
             [
                 'id' => (string) $slot->id,
@@ -54,6 +56,8 @@ final readonly class DoctrineScheduleSlotRepository implements ScheduleSlotRepos
                 'end_time' => $slot->timeSlot->endTime,
                 'room' => $slot->room,
                 'is_recurring' => $slot->isRecurring ? 'true' : 'false',
+                'recurrence_start' => $slot->recurrenceStart?->format('Y-m-d'),
+                'recurrence_end' => $slot->recurrenceEnd?->format('Y-m-d'),
                 'created_at' => $slot->createdAt->format(DateTimeImmutable::ATOM),
                 'updated_at' => $slot->updatedAt->format(DateTimeImmutable::ATOM),
             ],
@@ -109,6 +113,19 @@ final readonly class DoctrineScheduleSlotRepository implements ScheduleSlotRepos
         return $this->hydrateMany($rows);
     }
 
+    #[Override]
+    public function findRecurringByClass(ClassId $classId, TenantId $tenantId): array
+    {
+        $rows = $this->connection->fetchAllAssociative(
+            'SELECT * FROM schedule_slots
+             WHERE class_id = :class_id AND tenant_id = :tenant_id AND is_recurring = true
+             ORDER BY day_of_week, start_time',
+            ['class_id' => (string) $classId, 'tenant_id' => (string) $tenantId],
+        );
+
+        return $this->hydrateMany($rows);
+    }
+
     #[Override]
     public function findByTeacher(UserId $teacherId, TenantId $tenantId): array
     {
@@ -256,6 +273,10 @@ final readonly class DoctrineScheduleSlotRepository implements ScheduleSlotRepos
         $room = $row['room'];
         /** @var bool $isRecurring */
         $isRecurring = $row['is_recurring'];
+        /** @var string|null $recurrenceStart */
+        $recurrenceStart = $row['recurrence_start'] ?? null;
+        /** @var string|null $recurrenceEnd */
+        $recurrenceEnd = $row['recurrence_end'] ?? null;
         /** @var string $createdAt */
         $createdAt = $row['created_at'];
         /** @var string $updatedAt */
@@ -273,6 +294,8 @@ final readonly class DoctrineScheduleSlotRepository implements ScheduleSlotRepos
             isRecurring: (bool) $isRecurring,
             createdAt: new DateTimeImmutable($createdAt),
             updatedAt: new DateTimeImmutable($updatedAt),
+            recurrenceStart: $recurrenceStart !== null ? new DateTimeImmutable($recurrenceStart) : null,
+            recurrenceEnd: $recurrenceEnd !== null ? new DateTimeImmutable($recurrenceEnd) : null,
         );
     }
 }
diff --git a/backend/src/Scolarite/Infrastructure/Persistence/InMemory/InMemoryScheduleExceptionRepository.php b/backend/src/Scolarite/Infrastructure/Persistence/InMemory/InMemoryScheduleExceptionRepository.php
new file mode 100644
index 0000000..c097b96
--- /dev/null
+++ b/backend/src/Scolarite/Infrastructure/Persistence/InMemory/InMemoryScheduleExceptionRepository.php
@@ -0,0 +1,107 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Scolarite\Infrastructure\Persistence\InMemory;
+
+use App\Scolarite\Domain\Model\Schedule\ScheduleException;
+use App\Scolarite\Domain\Model\Schedule\ScheduleExceptionId;
+use App\Scolarite\Domain\Model\Schedule\ScheduleSlotId;
+use App\Scolarite\Domain\Repository\ScheduleExceptionRepository;
+use App\Shared\Domain\Tenant\TenantId;
+
+use function array_filter;
+use function array_values;
+
+use DateTimeImmutable;
+use Override;
+
+final class InMemoryScheduleExceptionRepository implements ScheduleExceptionRepository
+{
+    /** @var array<string, ScheduleException> */
+    private array $byId = [];
+
+    #[Override]
+    public function save(ScheduleException $exception): void
+    {
+        $this->byId[(string) $exception->id] = $exception;
+    }
+
+    #[Override]
+    public function findById(ScheduleExceptionId $id, TenantId $tenantId): ?ScheduleException
+    {
+        $exception = $this->byId[(string) $id] ?? null;
+
+        if ($exception !== null && !$exception->tenantId->equals($tenantId)) {
+            return null;
+        }
+
+        return $exception;
+    }
+
+    #[Override]
+    public function findForSlotAndDate(
+        ScheduleSlotId $slotId,
+        DateTimeImmutable $date,
+        TenantId $tenantId,
+    ): ?ScheduleException {
+        $dateStr = $date->format('Y-m-d');
+
+        foreach ($this->byId as $exception) {
+            if ($exception->tenantId->equals($tenantId)
+                && $exception->slotId->equals($slotId)
+                && $exception->exceptionDate->format('Y-m-d') === $dateStr
+            ) {
+                return $exception;
+            }
+        }
+
+        return null;
+    }
+
+    #[Override]
+    public function findForSlotBetweenDates(
+        ScheduleSlotId $slotId,
+        DateTimeImmutable $startDate,
+        DateTimeImmutable $endDate,
+        TenantId $tenantId,
+    ): array {
+        $start = $startDate->format('Y-m-d');
+        $end = $endDate->format('Y-m-d');
+
+        return array_values(array_filter(
+            $this->byId,
+            static fn (ScheduleException $e): bool => $e->tenantId->equals($tenantId)
+                && $e->slotId->equals($slotId)
+                && $e->exceptionDate->format('Y-m-d') >= $start
+                && $e->exceptionDate->format('Y-m-d') <= $end,
+        ));
+    }
+
+    #[Override]
+    public function findForDateRange(
+        TenantId $tenantId,
+        DateTimeImmutable $startDate,
+        DateTimeImmutable $endDate,
+    ): array {
+        $start = $startDate->format('Y-m-d');
+        $end = $endDate->format('Y-m-d');
+
+        return array_values(array_filter(
+            $this->byId,
+            static fn (ScheduleException $e): bool => $e->tenantId->equals($tenantId)
+                && $e->exceptionDate->format('Y-m-d') >= $start
+                && $e->exceptionDate->format('Y-m-d') <= $end,
+        ));
+    }
+
+    #[Override]
+    public function delete(ScheduleExceptionId $id, TenantId $tenantId): void
+    {
+        $exception = $this->findById($id, $tenantId);
+
+        if ($exception !== null) {
+            unset($this->byId[(string) $id]);
+        }
+    }
+}
diff --git a/backend/src/Scolarite/Infrastructure/Persistence/InMemory/InMemoryScheduleSlotRepository.php b/backend/src/Scolarite/Infrastructure/Persistence/InMemory/InMemoryScheduleSlotRepository.php
index b5bc5b8..8bd23c0 100644
--- a/backend/src/Scolarite/Infrastructure/Persistence/InMemory/InMemoryScheduleSlotRepository.php
+++ b/backend/src/Scolarite/Infrastructure/Persistence/InMemory/InMemoryScheduleSlotRepository.php
@@ -74,6 +74,17 @@ final class InMemoryScheduleSlotRepository implements ScheduleSlotRepository
         ));
     }
 
+    #[Override]
+    public function findRecurringByClass(ClassId $classId, TenantId $tenantId): array
+    {
+        return array_values(array_filter(
+            $this->byId,
+            static fn (ScheduleSlot $s) => $s->tenantId->equals($tenantId)
+                && $s->classId->equals($classId)
+                && $s->isRecurring,
+        ));
+    }
+
     #[Override]
     public function findByTeacher(UserId $teacherId, TenantId $tenantId): array
     {
diff --git a/backend/tests/Unit/Scolarite/Application/Command/CreateScheduleException/CreateScheduleExceptionHandlerTest.php b/backend/tests/Unit/Scolarite/Application/Command/CreateScheduleException/CreateScheduleExceptionHandlerTest.php
new file mode 100644
index 0000000..2321b8d
--- /dev/null
+++ b/backend/tests/Unit/Scolarite/Application/Command/CreateScheduleException/CreateScheduleExceptionHandlerTest.php
@@ -0,0 +1,212 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\Scolarite\Application\Command\CreateScheduleException;
+
+use App\Administration\Domain\Model\SchoolClass\ClassId;
+use App\Administration\Domain\Model\Subject\SubjectId;
+use App\Administration\Domain\Model\User\UserId;
+use App\Scolarite\Application\Command\CreateScheduleException\CreateScheduleExceptionCommand;
+use App\Scolarite\Application\Command\CreateScheduleException\CreateScheduleExceptionHandler;
+use App\Scolarite\Domain\Exception\DateExceptionInvalideException;
+use App\Scolarite\Domain\Model\Schedule\DayOfWeek;
+use App\Scolarite\Domain\Model\Schedule\ScheduleExceptionType;
+use App\Scolarite\Domain\Model\Schedule\ScheduleSlot;
+use App\Scolarite\Domain\Model\Schedule\TimeSlot;
+use App\Scolarite\Infrastructure\Persistence\InMemory\InMemoryScheduleExceptionRepository;
+use App\Scolarite\Infrastructure\Persistence\InMemory\InMemoryScheduleSlotRepository;
+use App\Shared\Domain\Clock;
+use App\Shared\Domain\Tenant\TenantId;
+use DateTimeImmutable;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+
+final class CreateScheduleExceptionHandlerTest extends TestCase
+{
+    private const string TENANT_ID = '550e8400-e29b-41d4-a716-446655440001';
+    private const string CLASS_ID = '550e8400-e29b-41d4-a716-446655440020';
+    private const string SUBJECT_ID = '550e8400-e29b-41d4-a716-446655440030';
+    private const string TEACHER_ID = '550e8400-e29b-41d4-a716-446655440010';
+    private const string CREATOR_ID = '550e8400-e29b-41d4-a716-446655440099';
+
+    private InMemoryScheduleSlotRepository $slotRepository;
+    private InMemoryScheduleExceptionRepository $exceptionRepository;
+    private CreateScheduleExceptionHandler $handler;
+
+    protected function setUp(): void
+    {
+        $this->slotRepository = new InMemoryScheduleSlotRepository();
+        $this->exceptionRepository = new InMemoryScheduleExceptionRepository();
+
+        $clock = new class implements Clock {
+            public function now(): DateTimeImmutable
+            {
+                return new DateTimeImmutable('2026-10-01 10:00:00');
+            }
+        };
+
+        $this->handler = new CreateScheduleExceptionHandler(
+            $this->slotRepository,
+            $this->exceptionRepository,
+            $clock,
+        );
+    }
+
+    #[Test]
+    public function cancelOccurrenceCreatesACancelledException(): void
+    {
+        $slot = $this->createAndSaveSlot();
+
+        $command = new CreateScheduleExceptionCommand(
+            tenantId: self::TENANT_ID,
+            slotId: (string) $slot->id,
+            exceptionDate: '2026-10-05',
+            type: 'cancelled',
+            reason: 'Grève',
+            createdBy: self::CREATOR_ID,
+        );
+
+        $exception = ($this->handler)($command);
+
+        self::assertSame(ScheduleExceptionType::CANCELLED, $exception->type);
+        self::assertSame('2026-10-05', $exception->exceptionDate->format('Y-m-d'));
+        self::assertSame('Grève', $exception->reason);
+        self::assertNull($exception->newTimeSlot);
+    }
+
+    #[Test]
+    public function modifyOccurrenceCreatesAModifiedException(): void
+    {
+        $slot = $this->createAndSaveSlot();
+        $newTeacherId = '550e8400-e29b-41d4-a716-446655440011';
+
+        $command = new CreateScheduleExceptionCommand(
+            tenantId: self::TENANT_ID,
+            slotId: (string) $slot->id,
+            exceptionDate: '2026-10-05',
+            type: 'modified',
+            newStartTime: '10:00',
+            newEndTime: '11:00',
+            newRoom: 'Salle 301',
+            newTeacherId: $newTeacherId,
+            reason: 'Changement de salle',
+            createdBy: self::CREATOR_ID,
+        );
+
+        $exception = ($this->handler)($command);
+
+        self::assertSame(ScheduleExceptionType::MODIFIED, $exception->type);
+        self::assertNotNull($exception->newTimeSlot);
+        self::assertSame('10:00', $exception->newTimeSlot->startTime);
+        self::assertSame('11:00', $exception->newTimeSlot->endTime);
+        self::assertSame('Salle 301', $exception->newRoom);
+        self::assertTrue($exception->newTeacherId->equals(UserId::fromString($newTeacherId)));
+    }
+
+    #[Test]
+    public function exceptionIsSavedToRepository(): void
+    {
+        $slot = $this->createAndSaveSlot();
+
+        $command = new CreateScheduleExceptionCommand(
+            tenantId: self::TENANT_ID,
+            slotId: (string) $slot->id,
+            exceptionDate: '2026-10-05',
+            type: 'cancelled',
+            createdBy: self::CREATOR_ID,
+        );
+
+        $exception = ($this->handler)($command);
+        $tenantId = TenantId::fromString(self::TENANT_ID);
+
+        $found = $this->exceptionRepository->findById($exception->id, $tenantId);
+        self::assertNotNull($found);
+    }
+
+    #[Test]
+    public function throwsWhenSlotNotFound(): void
+    {
+        $this->expectException(\App\Scolarite\Domain\Exception\ScheduleSlotNotFoundException::class);
+
+        $command = new CreateScheduleExceptionCommand(
+            tenantId: self::TENANT_ID,
+            slotId: '550e8400-e29b-41d4-a716-446655440099',
+            exceptionDate: '2026-10-05',
+            type: 'cancelled',
+            createdBy: self::CREATOR_ID,
+        );
+
+        ($this->handler)($command);
+    }
+
+    #[Test]
+    public function throwsWhenDateIsWrongDayOfWeek(): void
+    {
+        $slot = $this->createAndSaveSlot();
+
+        $this->expectException(DateExceptionInvalideException::class);
+
+        // Slot is MONDAY, but 2026-10-06 is a Tuesday
+        $command = new CreateScheduleExceptionCommand(
+            tenantId: self::TENANT_ID,
+            slotId: (string) $slot->id,
+            exceptionDate: '2026-10-06',
+            type: 'cancelled',
+            createdBy: self::CREATOR_ID,
+        );
+
+        ($this->handler)($command);
+    }
+
+    #[Test]
+    public function throwsWhenDateIsOutsideRecurrenceBounds(): void
+    {
+        $slot = ScheduleSlot::creer(
+            tenantId: TenantId::fromString(self::TENANT_ID),
+            classId: ClassId::fromString(self::CLASS_ID),
+            subjectId: SubjectId::fromString(self::SUBJECT_ID),
+            teacherId: UserId::fromString(self::TEACHER_ID),
+            dayOfWeek: DayOfWeek::MONDAY,
+            timeSlot: new TimeSlot('08:00', '09:00'),
+            room: null,
+            isRecurring: true,
+            now: new DateTimeImmutable('2026-09-01 10:00:00'),
+            recurrenceStart: new DateTimeImmutable('2026-09-07'),
+            recurrenceEnd: new DateTimeImmutable('2026-09-28'),
+        );
+        $this->slotRepository->save($slot);
+
+        $this->expectException(DateExceptionInvalideException::class);
+
+        // 2026-10-05 is a Monday but after recurrenceEnd (2026-09-28)
+        $command = new CreateScheduleExceptionCommand(
+            tenantId: self::TENANT_ID,
+            slotId: (string) $slot->id,
+            exceptionDate: '2026-10-05',
+            type: 'cancelled',
+            createdBy: self::CREATOR_ID,
+        );
+
+        ($this->handler)($command);
+    }
+
+    private function createAndSaveSlot(): ScheduleSlot
+    {
+        $slot = ScheduleSlot::creer(
+            tenantId: TenantId::fromString(self::TENANT_ID),
+            classId: ClassId::fromString(self::CLASS_ID),
+            subjectId: SubjectId::fromString(self::SUBJECT_ID),
+            teacherId: UserId::fromString(self::TEACHER_ID),
+            dayOfWeek: DayOfWeek::MONDAY,
+            timeSlot: new TimeSlot('08:00', '09:00'),
+            room: null,
+            isRecurring: true,
+            now: new DateTimeImmutable('2026-09-01 10:00:00'),
+        );
+
+        $this->slotRepository->save($slot);
+
+        return $slot;
+    }
+}
diff --git a/backend/tests/Unit/Scolarite/Application/Command/TruncateSlotRecurrence/TruncateSlotRecurrenceHandlerTest.php b/backend/tests/Unit/Scolarite/Application/Command/TruncateSlotRecurrence/TruncateSlotRecurrenceHandlerTest.php
new file mode 100644
index 0000000..9aa2ca3
--- /dev/null
+++ b/backend/tests/Unit/Scolarite/Application/Command/TruncateSlotRecurrence/TruncateSlotRecurrenceHandlerTest.php
@@ -0,0 +1,114 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\Scolarite\Application\Command\TruncateSlotRecurrence;
+
+use App\Administration\Domain\Model\SchoolClass\ClassId;
+use App\Administration\Domain\Model\Subject\SubjectId;
+use App\Administration\Domain\Model\User\UserId;
+use App\Scolarite\Application\Command\TruncateSlotRecurrence\TruncateSlotRecurrenceCommand;
+use App\Scolarite\Application\Command\TruncateSlotRecurrence\TruncateSlotRecurrenceHandler;
+use App\Scolarite\Domain\Exception\DateExceptionInvalideException;
+use App\Scolarite\Domain\Model\Schedule\DayOfWeek;
+use App\Scolarite\Domain\Model\Schedule\ScheduleSlot;
+use App\Scolarite\Domain\Model\Schedule\TimeSlot;
+use App\Scolarite\Infrastructure\Persistence\InMemory\InMemoryScheduleSlotRepository;
+use App\Shared\Domain\Clock;
+use App\Shared\Domain\Tenant\TenantId;
+use DateTimeImmutable;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+
+final class TruncateSlotRecurrenceHandlerTest extends TestCase
+{
+    private const string TENANT_ID = '550e8400-e29b-41d4-a716-446655440001';
+    private const string CLASS_ID = '550e8400-e29b-41d4-a716-446655440020';
+    private const string SUBJECT_ID = '550e8400-e29b-41d4-a716-446655440030';
+    private const string TEACHER_ID = '550e8400-e29b-41d4-a716-446655440010';
+    private const string UPDATER_ID = '550e8400-e29b-41d4-a716-446655440099';
+
+    private InMemoryScheduleSlotRepository $slotRepository;
+    private TruncateSlotRecurrenceHandler $handler;
+
+    protected function setUp(): void
+    {
+        $this->slotRepository = new InMemoryScheduleSlotRepository();
+
+        $clock = new class implements Clock {
+            public function now(): DateTimeImmutable
+            {
+                return new DateTimeImmutable('2026-10-01 10:00:00');
+            }
+        };
+
+        $this->handler = new TruncateSlotRecurrenceHandler(
+            $this->slotRepository,
+            $clock,
+        );
+    }
+
+    #[Test]
+    public function truncatesRecurrenceOneDayBeforeGivenDate(): void
+    {
+        $slot = $this->createAndSaveSlot(
+            recurrenceStart: new DateTimeImmutable('2026-09-01'),
+            recurrenceEnd: new DateTimeImmutable('2027-07-04'),
+        );
+
+        $command = new TruncateSlotRecurrenceCommand(
+            tenantId: self::TENANT_ID,
+            slotId: (string) $slot->id,
+            fromDate: '2026-10-05',
+            updatedBy: self::UPDATER_ID,
+        );
+
+        ($this->handler)($command);
+
+        $tenantId = TenantId::fromString(self::TENANT_ID);
+        $updated = $this->slotRepository->get($slot->id, $tenantId);
+        self::assertSame('2026-10-04', $updated->recurrenceEnd->format('Y-m-d'));
+    }
+
+    #[Test]
+    public function throwsWhenDateIsNotActiveForSlot(): void
+    {
+        $slot = $this->createAndSaveSlot(
+            recurrenceStart: new DateTimeImmutable('2026-09-01'),
+            recurrenceEnd: new DateTimeImmutable('2026-09-28'),
+        );
+
+        $command = new TruncateSlotRecurrenceCommand(
+            tenantId: self::TENANT_ID,
+            slotId: (string) $slot->id,
+            fromDate: '2026-10-05',
+            updatedBy: self::UPDATER_ID,
+        );
+
+        $this->expectException(DateExceptionInvalideException::class);
+        ($this->handler)($command);
+    }
+
+    private function createAndSaveSlot(
+        ?DateTimeImmutable $recurrenceStart = null,
+        ?DateTimeImmutable $recurrenceEnd = null,
+    ): ScheduleSlot {
+        $slot = ScheduleSlot::creer(
+            tenantId: TenantId::fromString(self::TENANT_ID),
+            classId: ClassId::fromString(self::CLASS_ID),
+            subjectId: SubjectId::fromString(self::SUBJECT_ID),
+            teacherId: UserId::fromString(self::TEACHER_ID),
+            dayOfWeek: DayOfWeek::MONDAY,
+            timeSlot: new TimeSlot('08:00', '09:00'),
+            room: null,
+            isRecurring: true,
+            now: new DateTimeImmutable('2026-09-01 10:00:00'),
+            recurrenceStart: $recurrenceStart,
+            recurrenceEnd: $recurrenceEnd,
+        );
+
+        $this->slotRepository->save($slot);
+
+        return $slot;
+    }
+}
diff --git a/backend/tests/Unit/Scolarite/Application/Command/UpdateRecurringSlot/UpdateRecurringSlotHandlerTest.php b/backend/tests/Unit/Scolarite/Application/Command/UpdateRecurringSlot/UpdateRecurringSlotHandlerTest.php
new file mode 100644
index 0000000..45d6a91
--- /dev/null
+++ b/backend/tests/Unit/Scolarite/Application/Command/UpdateRecurringSlot/UpdateRecurringSlotHandlerTest.php
@@ -0,0 +1,173 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\Scolarite\Application\Command\UpdateRecurringSlot;
+
+use App\Administration\Domain\Model\SchoolClass\ClassId;
+use App\Administration\Domain\Model\Subject\SubjectId;
+use App\Administration\Domain\Model\User\UserId;
+use App\Scolarite\Application\Command\UpdateRecurringSlot\UpdateRecurringSlotCommand;
+use App\Scolarite\Application\Command\UpdateRecurringSlot\UpdateRecurringSlotHandler;
+use App\Scolarite\Domain\Model\Schedule\DayOfWeek;
+use App\Scolarite\Domain\Model\Schedule\ScheduleExceptionType;
+use App\Scolarite\Domain\Model\Schedule\ScheduleSlot;
+use App\Scolarite\Domain\Model\Schedule\TimeSlot;
+use App\Scolarite\Infrastructure\Persistence\InMemory\InMemoryScheduleExceptionRepository;
+use App\Scolarite\Infrastructure\Persistence\InMemory\InMemoryScheduleSlotRepository;
+use App\Shared\Domain\Clock;
+use App\Shared\Domain\Tenant\TenantId;
+use DateTimeImmutable;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+
+final class UpdateRecurringSlotHandlerTest extends TestCase
+{
+    private const string TENANT_ID = '550e8400-e29b-41d4-a716-446655440001';
+    private const string CLASS_ID = '550e8400-e29b-41d4-a716-446655440020';
+    private const string SUBJECT_ID = '550e8400-e29b-41d4-a716-446655440030';
+    private const string TEACHER_ID = '550e8400-e29b-41d4-a716-446655440010';
+    private const string NEW_TEACHER_ID = '550e8400-e29b-41d4-a716-446655440011';
+    private const string UPDATER_ID = '550e8400-e29b-41d4-a716-446655440099';
+
+    private InMemoryScheduleSlotRepository $slotRepository;
+    private InMemoryScheduleExceptionRepository $exceptionRepository;
+    private UpdateRecurringSlotHandler $handler;
+
+    protected function setUp(): void
+    {
+        $this->slotRepository = new InMemoryScheduleSlotRepository();
+        $this->exceptionRepository = new InMemoryScheduleExceptionRepository();
+
+        $clock = new class implements Clock {
+            public function now(): DateTimeImmutable
+            {
+                return new DateTimeImmutable('2026-10-01 10:00:00');
+            }
+        };
+
+        $this->handler = new UpdateRecurringSlotHandler(
+            $this->slotRepository,
+            $this->exceptionRepository,
+            $clock,
+        );
+    }
+
+    #[Test]
+    public function thisOccurrenceCreatesAnException(): void
+    {
+        $slot = $this->createAndSaveSlot();
+
+        $command = new UpdateRecurringSlotCommand(
+            tenantId: self::TENANT_ID,
+            slotId: (string) $slot->id,
+            occurrenceDate: '2026-10-05',
+            scope: 'this_occurrence',
+            classId: self::CLASS_ID,
+            subjectId: self::SUBJECT_ID,
+            teacherId: self::NEW_TEACHER_ID,
+            dayOfWeek: DayOfWeek::MONDAY->value,
+            startTime: '10:00',
+            endTime: '11:00',
+            room: 'Salle 301',
+            updatedBy: self::UPDATER_ID,
+        );
+
+        $result = ($this->handler)($command);
+
+        self::assertNotNull($result['exception']);
+        self::assertSame(ScheduleExceptionType::MODIFIED, $result['exception']->type);
+        self::assertSame('10:00', $result['exception']->newTimeSlot->startTime);
+        self::assertSame('Salle 301', $result['exception']->newRoom);
+    }
+
+    #[Test]
+    public function allFutureEndCurrentRecurrenceAndCreatesNewSlot(): void
+    {
+        $slot = $this->createAndSaveSlot(
+            recurrenceStart: new DateTimeImmutable('2026-09-01'),
+            recurrenceEnd: new DateTimeImmutable('2027-07-04'),
+        );
+
+        $command = new UpdateRecurringSlotCommand(
+            tenantId: self::TENANT_ID,
+            slotId: (string) $slot->id,
+            occurrenceDate: '2026-10-12',
+            scope: 'all_future',
+            classId: self::CLASS_ID,
+            subjectId: self::SUBJECT_ID,
+            teacherId: self::NEW_TEACHER_ID,
+            dayOfWeek: DayOfWeek::MONDAY->value,
+            startTime: '10:00',
+            endTime: '11:00',
+            room: 'Salle 301',
+            updatedBy: self::UPDATER_ID,
+        );
+
+        $result = ($this->handler)($command);
+
+        // Original slot's recurrence ends before the change date
+        $tenantId = TenantId::fromString(self::TENANT_ID);
+        $updatedOriginal = $this->slotRepository->get($slot->id, $tenantId);
+        self::assertSame('2026-10-11', $updatedOriginal->recurrenceEnd->format('Y-m-d'));
+
+        // New slot starts from the change date
+        self::assertNotNull($result['newSlot']);
+        self::assertSame('2026-10-12', $result['newSlot']->recurrenceStart->format('Y-m-d'));
+        self::assertSame('2027-07-04', $result['newSlot']->recurrenceEnd->format('Y-m-d'));
+        self::assertSame('10:00', $result['newSlot']->timeSlot->startTime);
+        self::assertTrue($result['newSlot']->teacherId->equals(UserId::fromString(self::NEW_TEACHER_ID)));
+    }
+
+    #[Test]
+    public function allFutureWithNoOriginalEndUsesNullForNewSlotEnd(): void
+    {
+        $slot = $this->createAndSaveSlot(
+            recurrenceStart: new DateTimeImmutable('2026-09-01'),
+            recurrenceEnd: null,
+        );
+
+        $command = new UpdateRecurringSlotCommand(
+            tenantId: self::TENANT_ID,
+            slotId: (string) $slot->id,
+            occurrenceDate: '2026-10-12',
+            scope: 'all_future',
+            classId: self::CLASS_ID,
+            subjectId: self::SUBJECT_ID,
+            teacherId: self::TEACHER_ID,
+            dayOfWeek: DayOfWeek::MONDAY->value,
+            startTime: '10:00',
+            endTime: '11:00',
+            room: null,
+            updatedBy: self::UPDATER_ID,
+        );
+
+        $result = ($this->handler)($command);
+
+        self::assertNotNull($result['newSlot']);
+        self::assertNull($result['newSlot']->recurrenceEnd);
+    }
+
+    private function createAndSaveSlot(
+        ?DateTimeImmutable $recurrenceStart = null,
+        ?DateTimeImmutable $recurrenceEnd = null,
+    ): ScheduleSlot {
+        $slot = ScheduleSlot::creer(
+            tenantId: TenantId::fromString(self::TENANT_ID),
+            classId: ClassId::fromString(self::CLASS_ID),
+            subjectId: SubjectId::fromString(self::SUBJECT_ID),
+            teacherId: UserId::fromString(self::TEACHER_ID),
+            dayOfWeek: DayOfWeek::MONDAY,
+            timeSlot: new TimeSlot('08:00', '09:00'),
+            room: null,
+            isRecurring: true,
+            now: new DateTimeImmutable('2026-09-01 10:00:00'),
+            recurrenceStart: $recurrenceStart,
+            recurrenceEnd: $recurrenceEnd,
+        );
+
+        $this->slotRepository->save($slot);
+
+        return $slot;
+    }
+}
diff --git a/backend/tests/Unit/Scolarite/Application/Service/ScheduleResolverTest.php b/backend/tests/Unit/Scolarite/Application/Service/ScheduleResolverTest.php
new file mode 100644
index 0000000..3823f2f
--- /dev/null
+++ b/backend/tests/Unit/Scolarite/Application/Service/ScheduleResolverTest.php
@@ -0,0 +1,375 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\Scolarite\Application\Service;
+
+use App\Administration\Domain\Model\SchoolCalendar\CalendarEntry;
+use App\Administration\Domain\Model\SchoolCalendar\CalendarEntryId;
+use App\Administration\Domain\Model\SchoolCalendar\CalendarEntryType;
+use App\Administration\Domain\Model\SchoolCalendar\SchoolCalendar;
+use App\Administration\Domain\Model\SchoolClass\AcademicYearId;
+use App\Administration\Domain\Model\SchoolClass\ClassId;
+use App\Administration\Domain\Model\Subject\SubjectId;
+use App\Administration\Domain\Model\User\UserId;
+use App\Scolarite\Application\Service\ScheduleResolver;
+use App\Scolarite\Domain\Model\Schedule\DayOfWeek;
+use App\Scolarite\Domain\Model\Schedule\ScheduleException;
+use App\Scolarite\Domain\Model\Schedule\ScheduleSlot;
+use App\Scolarite\Domain\Model\Schedule\TimeSlot;
+use App\Scolarite\Infrastructure\Persistence\InMemory\InMemoryScheduleExceptionRepository;
+use App\Scolarite\Infrastructure\Persistence\InMemory\InMemoryScheduleSlotRepository;
+use App\Shared\Domain\Tenant\TenantId;
+use DateTimeImmutable;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+
+final class ScheduleResolverTest extends TestCase
+{
+    private const string TENANT_ID = '550e8400-e29b-41d4-a716-446655440001';
+    private const string CLASS_ID = '550e8400-e29b-41d4-a716-446655440020';
+    private const string SUBJECT_ID = '550e8400-e29b-41d4-a716-446655440030';
+    private const string TEACHER_ID = '550e8400-e29b-41d4-a716-446655440010';
+    private const string CREATOR_ID = '550e8400-e29b-41d4-a716-446655440099';
+
+    private InMemoryScheduleSlotRepository $slotRepository;
+    private InMemoryScheduleExceptionRepository $exceptionRepository;
+    private ScheduleResolver $resolver;
+
+    protected function setUp(): void
+    {
+        $this->slotRepository = new InMemoryScheduleSlotRepository();
+        $this->exceptionRepository = new InMemoryScheduleExceptionRepository();
+        $this->resolver = new ScheduleResolver(
+            $this->slotRepository,
+            $this->exceptionRepository,
+        );
+    }
+
+    #[Test]
+    public function resolveForWeekReturnsRecurringSlotsForSchoolDays(): void
+    {
+        $slot = $this->createAndSaveSlot(DayOfWeek::MONDAY, '08:00', '09:00');
+
+        $calendar = $this->createCalendar();
+        // 2026-09-07 is a Monday
+        $weekStart = new DateTimeImmutable('2026-09-07');
+
+        $resolved = $this->resolver->resolveForWeek(
+            ClassId::fromString(self::CLASS_ID),
+            $weekStart,
+            TenantId::fromString(self::TENANT_ID),
+            $calendar,
+        );
+
+        self::assertCount(1, $resolved);
+        self::assertTrue($resolved[0]->slotId->equals($slot->id));
+        self::assertSame('2026-09-07', $resolved[0]->date->format('Y-m-d'));
+        self::assertFalse($resolved[0]->isModified);
+    }
+
+    #[Test]
+    public function resolveForWeekReturnsMultipleSlotsOnDifferentDays(): void
+    {
+        $this->createAndSaveSlot(DayOfWeek::MONDAY, '08:00', '09:00');
+        $this->createAndSaveSlot(DayOfWeek::WEDNESDAY, '10:00', '11:00');
+        $this->createAndSaveSlot(DayOfWeek::FRIDAY, '14:00', '15:00');
+
+        $calendar = $this->createCalendar();
+        $weekStart = new DateTimeImmutable('2026-09-07');
+
+        $resolved = $this->resolver->resolveForWeek(
+            ClassId::fromString(self::CLASS_ID),
+            $weekStart,
+            TenantId::fromString(self::TENANT_ID),
+            $calendar,
+        );
+
+        self::assertCount(3, $resolved);
+    }
+
+    #[Test]
+    public function resolveForWeekSkipsCancelledOccurrences(): void
+    {
+        $slot = $this->createAndSaveSlot(DayOfWeek::MONDAY, '08:00', '09:00');
+
+        $exception = ScheduleException::annuler(
+            tenantId: TenantId::fromString(self::TENANT_ID),
+            slotId: $slot->id,
+            exceptionDate: new DateTimeImmutable('2026-09-07'),
+            reason: 'Grève',
+            createdBy: UserId::fromString(self::CREATOR_ID),
+            now: new DateTimeImmutable('2026-09-01 10:00:00'),
+        );
+        $this->exceptionRepository->save($exception);
+
+        $calendar = $this->createCalendar();
+        $weekStart = new DateTimeImmutable('2026-09-07');
+
+        $resolved = $this->resolver->resolveForWeek(
+            ClassId::fromString(self::CLASS_ID),
+            $weekStart,
+            TenantId::fromString(self::TENANT_ID),
+            $calendar,
+        );
+
+        self::assertCount(0, $resolved);
+    }
+
+    #[Test]
+    public function resolveForWeekAppliesModifiedExceptionOverrides(): void
+    {
+        $slot = $this->createAndSaveSlot(DayOfWeek::MONDAY, '08:00', '09:00');
+
+        $newTimeSlot = new TimeSlot('10:00', '11:00');
+        $newTeacherId = UserId::fromString('550e8400-e29b-41d4-a716-446655440011');
+        $exception = ScheduleException::modifier(
+            tenantId: TenantId::fromString(self::TENANT_ID),
+            slotId: $slot->id,
+            exceptionDate: new DateTimeImmutable('2026-09-07'),
+            newTimeSlot: $newTimeSlot,
+            newRoom: 'Salle 301',
+            newTeacherId: $newTeacherId,
+            reason: 'Changement de salle',
+            createdBy: UserId::fromString(self::CREATOR_ID),
+            now: new DateTimeImmutable('2026-09-01 10:00:00'),
+        );
+        $this->exceptionRepository->save($exception);
+
+        $calendar = $this->createCalendar();
+        $weekStart = new DateTimeImmutable('2026-09-07');
+
+        $resolved = $this->resolver->resolveForWeek(
+            ClassId::fromString(self::CLASS_ID),
+            $weekStart,
+            TenantId::fromString(self::TENANT_ID),
+            $calendar,
+        );
+
+        self::assertCount(1, $resolved);
+        self::assertTrue($resolved[0]->isModified);
+        self::assertSame('10:00', $resolved[0]->timeSlot->startTime);
+        self::assertSame('11:00', $resolved[0]->timeSlot->endTime);
+        self::assertSame('Salle 301', $resolved[0]->room);
+        self::assertTrue($resolved[0]->teacherId->equals($newTeacherId));
+    }
+
+    #[Test]
+    public function resolveForWeekSkipsNonSchoolDays(): void
+    {
+        // Saturday slot — should not appear (weekend)
+        $this->createAndSaveSlot(DayOfWeek::SATURDAY, '08:00', '09:00');
+
+        $calendar = $this->createCalendar();
+        $weekStart = new DateTimeImmutable('2026-09-07');
+
+        $resolved = $this->resolver->resolveForWeek(
+            ClassId::fromString(self::CLASS_ID),
+            $weekStart,
+            TenantId::fromString(self::TENANT_ID),
+            $calendar,
+        );
+
+        self::assertCount(0, $resolved);
+    }
+
+    #[Test]
+    public function resolveForWeekSkipsVacationDays(): void
+    {
+        // Monday slot, but this Monday is during vacation
+        $this->createAndSaveSlot(DayOfWeek::MONDAY, '08:00', '09:00');
+
+        $calendar = $this->createCalendarWithVacation(
+            new DateTimeImmutable('2026-10-19'),
+            new DateTimeImmutable('2026-11-01'),
+        );
+
+        // Week starting Monday Oct 19 (during vacation)
+        $weekStart = new DateTimeImmutable('2026-10-19');
+
+        $resolved = $this->resolver->resolveForWeek(
+            ClassId::fromString(self::CLASS_ID),
+            $weekStart,
+            TenantId::fromString(self::TENANT_ID),
+            $calendar,
+        );
+
+        self::assertCount(0, $resolved);
+    }
+
+    #[Test]
+    public function resolveForWeekSkipsHolidays(): void
+    {
+        // Monday slot
+        $this->createAndSaveSlot(DayOfWeek::MONDAY, '08:00', '09:00');
+        // Wednesday slot
+        $this->createAndSaveSlot(DayOfWeek::WEDNESDAY, '10:00', '11:00');
+
+        // Nov 11 2026 is a Wednesday (holiday: Armistice)
+        $calendar = $this->createCalendarWithHoliday(new DateTimeImmutable('2026-11-11'));
+
+        // Week of Nov 9 2026 (Monday)
+        $weekStart = new DateTimeImmutable('2026-11-09');
+
+        $resolved = $this->resolver->resolveForWeek(
+            ClassId::fromString(self::CLASS_ID),
+            $weekStart,
+            TenantId::fromString(self::TENANT_ID),
+            $calendar,
+        );
+
+        // Monday should appear, Wednesday (holiday) should not
+        self::assertCount(1, $resolved);
+        self::assertSame('2026-11-09', $resolved[0]->date->format('Y-m-d'));
+    }
+
+    #[Test]
+    public function resolveForWeekRespectsRecurrenceBounds(): void
+    {
+        // Slot with recurrence starting Sep 15
+        $tenantId = TenantId::fromString(self::TENANT_ID);
+        $slot = ScheduleSlot::creer(
+            tenantId: $tenantId,
+            classId: ClassId::fromString(self::CLASS_ID),
+            subjectId: SubjectId::fromString(self::SUBJECT_ID),
+            teacherId: UserId::fromString(self::TEACHER_ID),
+            dayOfWeek: DayOfWeek::MONDAY,
+            timeSlot: new TimeSlot('08:00', '09:00'),
+            room: null,
+            isRecurring: true,
+            now: new DateTimeImmutable('2026-09-01 10:00:00'),
+            recurrenceStart: new DateTimeImmutable('2026-09-15'),
+            recurrenceEnd: new DateTimeImmutable('2027-07-04'),
+        );
+        $this->slotRepository->save($slot);
+
+        $calendar = $this->createCalendar();
+
+        // Week of Sep 7 — before recurrence start
+        $resolved = $this->resolver->resolveForWeek(
+            ClassId::fromString(self::CLASS_ID),
+            new DateTimeImmutable('2026-09-07'),
+            $tenantId,
+            $calendar,
+        );
+        self::assertCount(0, $resolved);
+
+        // Week of Sep 15 — within recurrence bounds
+        $resolved = $this->resolver->resolveForWeek(
+            ClassId::fromString(self::CLASS_ID),
+            new DateTimeImmutable('2026-09-15'),
+            $tenantId,
+            $calendar,
+        );
+        self::assertCount(1, $resolved);
+    }
+
+    #[Test]
+    public function resolveForWeekIgnoresNonRecurringSlots(): void
+    {
+        $tenantId = TenantId::fromString(self::TENANT_ID);
+        $slot = ScheduleSlot::creer(
+            tenantId: $tenantId,
+            classId: ClassId::fromString(self::CLASS_ID),
+            subjectId: SubjectId::fromString(self::SUBJECT_ID),
+            teacherId: UserId::fromString(self::TEACHER_ID),
+            dayOfWeek: DayOfWeek::MONDAY,
+            timeSlot: new TimeSlot('08:00', '09:00'),
+            room: null,
+            isRecurring: false,
+            now: new DateTimeImmutable('2026-09-01 10:00:00'),
+        );
+        $this->slotRepository->save($slot);
+
+        $calendar = $this->createCalendar();
+        $weekStart = new DateTimeImmutable('2026-09-07');
+
+        $resolved = $this->resolver->resolveForWeek(
+            ClassId::fromString(self::CLASS_ID),
+            $weekStart,
+            $tenantId,
+            $calendar,
+        );
+
+        self::assertCount(0, $resolved);
+    }
+
+    #[Test]
+    public function resolveForWeekReturnsEmptyForClassWithNoSlots(): void
+    {
+        $calendar = $this->createCalendar();
+        $weekStart = new DateTimeImmutable('2026-09-07');
+
+        $resolved = $this->resolver->resolveForWeek(
+            ClassId::fromString(self::CLASS_ID),
+            $weekStart,
+            TenantId::fromString(self::TENANT_ID),
+            $calendar,
+        );
+
+        self::assertCount(0, $resolved);
+    }
+
+    private function createAndSaveSlot(
+        DayOfWeek $dayOfWeek,
+        string $startTime,
+        string $endTime,
+        ?string $room = null,
+    ): ScheduleSlot {
+        $slot = ScheduleSlot::creer(
+            tenantId: TenantId::fromString(self::TENANT_ID),
+            classId: ClassId::fromString(self::CLASS_ID),
+            subjectId: SubjectId::fromString(self::SUBJECT_ID),
+            teacherId: UserId::fromString(self::TEACHER_ID),
+            dayOfWeek: $dayOfWeek,
+            timeSlot: new TimeSlot($startTime, $endTime),
+            room: $room,
+            isRecurring: true,
+            now: new DateTimeImmutable('2026-09-01 10:00:00'),
+        );
+
+        $this->slotRepository->save($slot);
+
+        return $slot;
+    }
+
+    private function createCalendar(): SchoolCalendar
+    {
+        return SchoolCalendar::reconstitute(
+            tenantId: TenantId::fromString(self::TENANT_ID),
+            academicYearId: AcademicYearId::fromString('550e8400-e29b-41d4-a716-446655440090'),
+            zone: null,
+            entries: [],
+        );
+    }
+
+    private function createCalendarWithVacation(
+        DateTimeImmutable $start,
+        DateTimeImmutable $end,
+    ): SchoolCalendar {
+        $calendar = $this->createCalendar();
+        $calendar->ajouterEntree(new CalendarEntry(
+            id: CalendarEntryId::generate(),
+            type: CalendarEntryType::VACATION,
+            startDate: $start,
+            endDate: $end,
+            label: 'Vacances de la Toussaint',
+        ));
+
+        return $calendar;
+    }
+
+    private function createCalendarWithHoliday(DateTimeImmutable $date): SchoolCalendar
+    {
+        $calendar = $this->createCalendar();
+        $calendar->ajouterEntree(new CalendarEntry(
+            id: CalendarEntryId::generate(),
+            type: CalendarEntryType::HOLIDAY,
+            startDate: $date,
+            endDate: $date,
+            label: 'Armistice',
+        ));
+
+        return $calendar;
+    }
+}
diff --git a/backend/tests/Unit/Scolarite/Domain/Model/Schedule/ScheduleExceptionTest.php b/backend/tests/Unit/Scolarite/Domain/Model/Schedule/ScheduleExceptionTest.php
new file mode 100644
index 0000000..2becafb
--- /dev/null
+++ b/backend/tests/Unit/Scolarite/Domain/Model/Schedule/ScheduleExceptionTest.php
@@ -0,0 +1,168 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\Scolarite\Domain\Model\Schedule;
+
+use App\Administration\Domain\Model\User\UserId;
+use App\Scolarite\Domain\Model\Schedule\ScheduleException;
+use App\Scolarite\Domain\Model\Schedule\ScheduleExceptionId;
+use App\Scolarite\Domain\Model\Schedule\ScheduleExceptionType;
+use App\Scolarite\Domain\Model\Schedule\ScheduleSlotId;
+use App\Scolarite\Domain\Model\Schedule\TimeSlot;
+use App\Shared\Domain\Tenant\TenantId;
+use DateTimeImmutable;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+
+final class ScheduleExceptionTest extends TestCase
+{
+    private const string TENANT_ID = '550e8400-e29b-41d4-a716-446655440001';
+    private const string SLOT_ID = '550e8400-e29b-41d4-a716-446655440050';
+    private const string TEACHER_ID = '550e8400-e29b-41d4-a716-446655440010';
+    private const string CREATOR_ID = '550e8400-e29b-41d4-a716-446655440099';
+
+    #[Test]
+    public function annulerCreatesACancelledExceptionWithCorrectProperties(): void
+    {
+        $exception = ScheduleException::annuler(
+            tenantId: TenantId::fromString(self::TENANT_ID),
+            slotId: ScheduleSlotId::fromString(self::SLOT_ID),
+            exceptionDate: new DateTimeImmutable('2026-10-05'),
+            reason: 'Grève',
+            createdBy: UserId::fromString(self::CREATOR_ID),
+            now: new DateTimeImmutable('2026-10-01 10:00:00'),
+        );
+
+        self::assertTrue($exception->tenantId->equals(TenantId::fromString(self::TENANT_ID)));
+        self::assertTrue($exception->slotId->equals(ScheduleSlotId::fromString(self::SLOT_ID)));
+        self::assertSame('2026-10-05', $exception->exceptionDate->format('Y-m-d'));
+        self::assertSame(ScheduleExceptionType::CANCELLED, $exception->type);
+        self::assertSame('Grève', $exception->reason);
+        self::assertNull($exception->newTimeSlot);
+        self::assertNull($exception->newRoom);
+        self::assertNull($exception->newTeacherId);
+        self::assertTrue($exception->createdBy->equals(UserId::fromString(self::CREATOR_ID)));
+    }
+
+    #[Test]
+    public function modifierCreatesAModifiedExceptionWithNewValues(): void
+    {
+        $newTimeSlot = new TimeSlot('10:00', '11:00');
+        $newTeacherId = UserId::fromString(self::TEACHER_ID);
+
+        $exception = ScheduleException::modifier(
+            tenantId: TenantId::fromString(self::TENANT_ID),
+            slotId: ScheduleSlotId::fromString(self::SLOT_ID),
+            exceptionDate: new DateTimeImmutable('2026-10-05'),
+            newTimeSlot: $newTimeSlot,
+            newRoom: 'Salle 301',
+            newTeacherId: $newTeacherId,
+            reason: 'Changement de salle',
+            createdBy: UserId::fromString(self::CREATOR_ID),
+            now: new DateTimeImmutable('2026-10-01 10:00:00'),
+        );
+
+        self::assertSame(ScheduleExceptionType::MODIFIED, $exception->type);
+        self::assertNotNull($exception->newTimeSlot);
+        self::assertSame('10:00', $exception->newTimeSlot->startTime);
+        self::assertSame('11:00', $exception->newTimeSlot->endTime);
+        self::assertSame('Salle 301', $exception->newRoom);
+        self::assertTrue($exception->newTeacherId->equals($newTeacherId));
+    }
+
+    #[Test]
+    public function modifierWithPartialOverridesKeepsNullsForUnchangedFields(): void
+    {
+        $exception = ScheduleException::modifier(
+            tenantId: TenantId::fromString(self::TENANT_ID),
+            slotId: ScheduleSlotId::fromString(self::SLOT_ID),
+            exceptionDate: new DateTimeImmutable('2026-10-05'),
+            newTimeSlot: null,
+            newRoom: 'Salle 302',
+            newTeacherId: null,
+            reason: null,
+            createdBy: UserId::fromString(self::CREATOR_ID),
+            now: new DateTimeImmutable('2026-10-01 10:00:00'),
+        );
+
+        self::assertSame(ScheduleExceptionType::MODIFIED, $exception->type);
+        self::assertNull($exception->newTimeSlot);
+        self::assertSame('Salle 302', $exception->newRoom);
+        self::assertNull($exception->newTeacherId);
+        self::assertNull($exception->reason);
+    }
+
+    #[Test]
+    public function isCancelledReturnsTrueForCancelledType(): void
+    {
+        $exception = ScheduleException::annuler(
+            tenantId: TenantId::fromString(self::TENANT_ID),
+            slotId: ScheduleSlotId::fromString(self::SLOT_ID),
+            exceptionDate: new DateTimeImmutable('2026-10-05'),
+            reason: null,
+            createdBy: UserId::fromString(self::CREATOR_ID),
+            now: new DateTimeImmutable('2026-10-01 10:00:00'),
+        );
+
+        self::assertTrue($exception->isCancelled());
+        self::assertFalse($exception->isModified());
+    }
+
+    #[Test]
+    public function isModifiedReturnsTrueForModifiedType(): void
+    {
+        $exception = ScheduleException::modifier(
+            tenantId: TenantId::fromString(self::TENANT_ID),
+            slotId: ScheduleSlotId::fromString(self::SLOT_ID),
+            exceptionDate: new DateTimeImmutable('2026-10-05'),
+            newTimeSlot: new TimeSlot('14:00', '15:00'),
+            newRoom: null,
+            newTeacherId: null,
+            reason: null,
+            createdBy: UserId::fromString(self::CREATOR_ID),
+            now: new DateTimeImmutable('2026-10-01 10:00:00'),
+        );
+
+        self::assertTrue($exception->isModified());
+        self::assertFalse($exception->isCancelled());
+    }
+
+    #[Test]
+    public function reconstituteRestoresAllPropertiesWithoutEvents(): void
+    {
+        $id = ScheduleExceptionId::generate();
+        $tenantId = TenantId::fromString(self::TENANT_ID);
+        $slotId = ScheduleSlotId::fromString(self::SLOT_ID);
+        $newTimeSlot = new TimeSlot('11:00', '12:00');
+        $newTeacherId = UserId::fromString(self::TEACHER_ID);
+        $createdBy = UserId::fromString(self::CREATOR_ID);
+        $createdAt = new DateTimeImmutable('2026-10-01 10:00:00');
+
+        $exception = ScheduleException::reconstitute(
+            id: $id,
+            tenantId: $tenantId,
+            slotId: $slotId,
+            exceptionDate: new DateTimeImmutable('2026-10-05'),
+            type: ScheduleExceptionType::MODIFIED,
+            newTimeSlot: $newTimeSlot,
+            newRoom: 'Salle 303',
+            newTeacherId: $newTeacherId,
+            reason: 'Interversion',
+            createdBy: $createdBy,
+            createdAt: $createdAt,
+        );
+
+        self::assertTrue($exception->id->equals($id));
+        self::assertTrue($exception->tenantId->equals($tenantId));
+        self::assertTrue($exception->slotId->equals($slotId));
+        self::assertSame('2026-10-05', $exception->exceptionDate->format('Y-m-d'));
+        self::assertSame(ScheduleExceptionType::MODIFIED, $exception->type);
+        self::assertSame('11:00', $exception->newTimeSlot->startTime);
+        self::assertSame('Salle 303', $exception->newRoom);
+        self::assertTrue($exception->newTeacherId->equals($newTeacherId));
+        self::assertSame('Interversion', $exception->reason);
+        self::assertTrue($exception->createdBy->equals($createdBy));
+        self::assertEquals($createdAt, $exception->createdAt);
+    }
+}
diff --git a/backend/tests/Unit/Scolarite/Domain/Model/Schedule/ScheduleSlotTest.php b/backend/tests/Unit/Scolarite/Domain/Model/Schedule/ScheduleSlotTest.php
index bf70954..6251a99 100644
--- a/backend/tests/Unit/Scolarite/Domain/Model/Schedule/ScheduleSlotTest.php
+++ b/backend/tests/Unit/Scolarite/Domain/Model/Schedule/ScheduleSlotTest.php
@@ -176,6 +176,161 @@ final class ScheduleSlotTest extends TestCase
         self::assertEmpty($slot->pullDomainEvents());
     }
 
+    #[Test]
+    public function creerWithRecurrenceBoundsSetsDates(): void
+    {
+        $recurrenceStart = new DateTimeImmutable('2026-09-01');
+        $recurrenceEnd = new DateTimeImmutable('2027-07-04');
+
+        $slot = ScheduleSlot::creer(
+            tenantId: TenantId::fromString(self::TENANT_ID),
+            classId: ClassId::fromString(self::CLASS_ID),
+            subjectId: SubjectId::fromString(self::SUBJECT_ID),
+            teacherId: UserId::fromString(self::TEACHER_ID),
+            dayOfWeek: DayOfWeek::MONDAY,
+            timeSlot: new TimeSlot('08:00', '09:00'),
+            room: null,
+            isRecurring: true,
+            now: new DateTimeImmutable('2026-09-01 10:00:00'),
+            recurrenceStart: $recurrenceStart,
+            recurrenceEnd: $recurrenceEnd,
+        );
+
+        self::assertEquals($recurrenceStart, $slot->recurrenceStart);
+        self::assertEquals($recurrenceEnd, $slot->recurrenceEnd);
+    }
+
+    #[Test]
+    public function creerWithoutRecurrenceBoundsDefaultsToNull(): void
+    {
+        $slot = $this->createSlot();
+
+        self::assertNull($slot->recurrenceStart);
+        self::assertNull($slot->recurrenceEnd);
+    }
+
+    #[Test]
+    public function isActiveOnDateReturnsTrueForMatchingDayWithinBounds(): void
+    {
+        $slot = $this->createRecurringSlot(
+            dayOfWeek: DayOfWeek::MONDAY,
+            recurrenceStart: new DateTimeImmutable('2026-09-01'),
+            recurrenceEnd: new DateTimeImmutable('2027-07-04'),
+        );
+
+        // 2026-09-07 is a Monday within bounds
+        self::assertTrue($slot->isActiveOnDate(new DateTimeImmutable('2026-09-07')));
+    }
+
+    #[Test]
+    public function isActiveOnDateReturnsFalseForWrongDayOfWeek(): void
+    {
+        $slot = $this->createRecurringSlot(
+            dayOfWeek: DayOfWeek::MONDAY,
+            recurrenceStart: new DateTimeImmutable('2026-09-01'),
+            recurrenceEnd: new DateTimeImmutable('2027-07-04'),
+        );
+
+        // 2026-09-08 is a Tuesday
+        self::assertFalse($slot->isActiveOnDate(new DateTimeImmutable('2026-09-08')));
+    }
+
+    #[Test]
+    public function isActiveOnDateReturnsFalseBeforeRecurrenceStart(): void
+    {
+        $slot = $this->createRecurringSlot(
+            dayOfWeek: DayOfWeek::MONDAY,
+            recurrenceStart: new DateTimeImmutable('2026-09-01'),
+            recurrenceEnd: new DateTimeImmutable('2027-07-04'),
+        );
+
+        // 2026-08-25 is a Monday but before start
+        self::assertFalse($slot->isActiveOnDate(new DateTimeImmutable('2026-08-25')));
+    }
+
+    #[Test]
+    public function isActiveOnDateReturnsFalseAfterRecurrenceEnd(): void
+    {
+        $slot = $this->createRecurringSlot(
+            dayOfWeek: DayOfWeek::MONDAY,
+            recurrenceStart: new DateTimeImmutable('2026-09-01'),
+            recurrenceEnd: new DateTimeImmutable('2027-07-04'),
+        );
+
+        // 2027-07-07 is a Monday but after end
+        self::assertFalse($slot->isActiveOnDate(new DateTimeImmutable('2027-07-07')));
+    }
+
+    #[Test]
+    public function isActiveOnDateReturnsTrueWithNoBounds(): void
+    {
+        $slot = $this->createRecurringSlot(
+            dayOfWeek: DayOfWeek::MONDAY,
+            recurrenceStart: null,
+            recurrenceEnd: null,
+        );
+
+        // Any Monday should work
+        self::assertTrue($slot->isActiveOnDate(new DateTimeImmutable('2026-09-07')));
+    }
+
+    #[Test]
+    public function isActiveOnDateReturnsFalseForNonRecurringSlot(): void
+    {
+        $slot = ScheduleSlot::creer(
+            tenantId: TenantId::fromString(self::TENANT_ID),
+            classId: ClassId::fromString(self::CLASS_ID),
+            subjectId: SubjectId::fromString(self::SUBJECT_ID),
+            teacherId: UserId::fromString(self::TEACHER_ID),
+            dayOfWeek: DayOfWeek::MONDAY,
+            timeSlot: new TimeSlot('08:00', '09:00'),
+            room: null,
+            isRecurring: false,
+            now: new DateTimeImmutable('2026-09-01 10:00:00'),
+        );
+
+        self::assertFalse($slot->isActiveOnDate(new DateTimeImmutable('2026-09-07')));
+    }
+
+    #[Test]
+    public function isActiveOnDateIncludesBoundaryDates(): void
+    {
+        $slot = $this->createRecurringSlot(
+            dayOfWeek: DayOfWeek::MONDAY,
+            recurrenceStart: new DateTimeImmutable('2026-09-07'),
+            recurrenceEnd: new DateTimeImmutable('2026-09-07'),
+        );
+
+        // Exact start = exact end date
+        self::assertTrue($slot->isActiveOnDate(new DateTimeImmutable('2026-09-07')));
+    }
+
+    #[Test]
+    public function reconstituteRestoresRecurrenceBounds(): void
+    {
+        $recurrenceStart = new DateTimeImmutable('2026-09-01');
+        $recurrenceEnd = new DateTimeImmutable('2027-07-04');
+
+        $slot = ScheduleSlot::reconstitute(
+            id: ScheduleSlotId::generate(),
+            tenantId: TenantId::fromString(self::TENANT_ID),
+            classId: ClassId::fromString(self::CLASS_ID),
+            subjectId: SubjectId::fromString(self::SUBJECT_ID),
+            teacherId: UserId::fromString(self::TEACHER_ID),
+            dayOfWeek: DayOfWeek::FRIDAY,
+            timeSlot: new TimeSlot('14:00', '15:30'),
+            room: null,
+            isRecurring: true,
+            createdAt: new DateTimeImmutable('2026-03-01 10:00:00'),
+            updatedAt: new DateTimeImmutable('2026-03-02 14:00:00'),
+            recurrenceStart: $recurrenceStart,
+            recurrenceEnd: $recurrenceEnd,
+        );
+
+        self::assertEquals($recurrenceStart, $slot->recurrenceStart);
+        self::assertEquals($recurrenceEnd, $slot->recurrenceEnd);
+    }
+
     private function createSlot(?string $room = null): ScheduleSlot
     {
         return ScheduleSlot::creer(
@@ -190,4 +345,24 @@ final class ScheduleSlotTest extends TestCase
             now: new DateTimeImmutable('2026-03-01 10:00:00'),
         );
     }
+
+    private function createRecurringSlot(
+        DayOfWeek $dayOfWeek,
+        ?DateTimeImmutable $recurrenceStart,
+        ?DateTimeImmutable $recurrenceEnd,
+    ): ScheduleSlot {
+        return ScheduleSlot::creer(
+            tenantId: TenantId::fromString(self::TENANT_ID),
+            classId: ClassId::fromString(self::CLASS_ID),
+            subjectId: SubjectId::fromString(self::SUBJECT_ID),
+            teacherId: UserId::fromString(self::TEACHER_ID),
+            dayOfWeek: $dayOfWeek,
+            timeSlot: new TimeSlot('08:00', '09:00'),
+            room: null,
+            isRecurring: true,
+            now: new DateTimeImmutable('2026-09-01 10:00:00'),
+            recurrenceStart: $recurrenceStart,
+            recurrenceEnd: $recurrenceEnd,
+        );
+    }
 }
diff --git a/frontend/e2e/schedule-advanced.spec.ts b/frontend/e2e/schedule-advanced.spec.ts
index 35c66ca..904b702 100644
--- a/frontend/e2e/schedule-advanced.spec.ts
+++ b/frontend/e2e/schedule-advanced.spec.ts
@@ -120,11 +120,18 @@ async function waitForScheduleReady(page: import('@playwright/test').Page) {
 		timeout: 15000
 	});
 	// Wait for either the grid or the empty state to appear
-	await expect(page.locator('.schedule-grid, .empty-state, .alert-error')).toBeVisible({
+	await expect(page.locator('.schedule-grid, .empty-state')).toBeVisible({
 		timeout: 15000
 	});
 }
 
+async function chooseScopeAndEdit(page: import('@playwright/test').Page) {
+	// Scope modal appears - choose "this occurrence"
+	const scopeModal = page.getByRole('dialog');
+	await expect(scopeModal).toBeVisible({ timeout: 10000 });
+	await scopeModal.getByText('Cette occurrence uniquement').click();
+}
+
 async function fillSlotForm(
 	dialog: import('@playwright/test').Locator,
 	options: {
@@ -228,7 +235,7 @@ test.describe('Schedule Management - Modification & Conflicts & Calendar (Story
 	// AC3: Slot Modification & Deletion
 	// ==========================================================================
 	test.describe('AC3: Slot Modification & Deletion', () => {
-		test('clicking a slot opens edit modal', async ({ page }) => {
+		test('clicking a slot opens scope modal then edit modal', async ({ page }) => {
 			await loginAsAdmin(page);
 			await page.goto(`${ALPHA_URL}/admin/schedule`);
 
@@ -246,11 +253,13 @@ test.describe('Schedule Management - Modification & Conflicts & Calendar (Story
 			await dialog.getByRole('button', { name: /créer/i }).click();
 			await expect(dialog).not.toBeVisible({ timeout: 10000 });
 
-			// Click on the created slot
+			// Click on the created slot — scope modal should appear
 			const slotCard = page.locator('.slot-card').first();
 			await expect(slotCard).toBeVisible({ timeout: 10000 });
 			await slotCard.click();
 
+			await chooseScopeAndEdit(page);
+
 			// Edit modal should appear
 			const editDialog = page.getByRole('dialog');
 			await expect(editDialog).toBeVisible({ timeout: 10000 });
@@ -277,17 +286,24 @@ test.describe('Schedule Management - Modification & Conflicts & Calendar (Story
 			await dialog.getByRole('button', { name: /créer/i }).click();
 			await expect(dialog).not.toBeVisible({ timeout: 10000 });
 
-			// Click on the slot to edit
+			// Click on the slot — scope modal then edit modal
 			const slotCard = page.locator('.slot-card').first();
 			await expect(slotCard).toBeVisible({ timeout: 10000 });
 			await slotCard.click();
 
+			await chooseScopeAndEdit(page);
+
 			dialog = page.getByRole('dialog');
 			await expect(dialog).toBeVisible({ timeout: 10000 });
 
-			// Click delete button
+			// Click delete button — opens scope modal again for delete scope
 			await dialog.getByRole('button', { name: /supprimer/i }).click();
 
+			// Scope modal appears for delete action
+			const scopeModal = page.locator('.modal-scope');
+			await expect(scopeModal).toBeVisible({ timeout: 10000 });
+			await scopeModal.getByText('Cette occurrence uniquement').click();
+
 			// Confirmation modal should appear
 			const deleteModal = page.getByRole('alertdialog');
 			await expect(deleteModal).toBeVisible({ timeout: 10000 });
@@ -323,9 +339,11 @@ test.describe('Schedule Management - Modification & Conflicts & Calendar (Story
 			await expect(slotCard).toBeVisible({ timeout: 10000 });
 			await expect(slotCard.getByText('A101')).toBeVisible();
 
-			// Click to open edit modal
+			// Click to open scope modal then edit modal
 			await slotCard.click();
 
+			await chooseScopeAndEdit(page);
+
 			dialog = page.getByRole('dialog');
 			await expect(dialog).toBeVisible({ timeout: 10000 });
 			await expect(
@@ -520,5 +538,61 @@ test.describe('Schedule Management - Modification & Conflicts & Calendar (Story
 			const dialog = page.getByRole('dialog');
 			await expect(dialog).not.toBeVisible({ timeout: 3000 });
 		});
+
+		test('recurring slots do not appear on vacation days in next week (AC4)', async ({
+			page
+		}) => {
+			// Compute next week Thursday (use local format to avoid UTC shift)
+			const thisThursday = new Date(getWeekdayInCurrentWeek(4) + 'T00:00:00');
+			const nextThursday = new Date(thisThursday);
+			nextThursday.setDate(thisThursday.getDate() + 7);
+			const y = nextThursday.getFullYear();
+			const m = String(nextThursday.getMonth() + 1).padStart(2, '0');
+			const d = String(nextThursday.getDate()).padStart(2, '0');
+			const nextThursdayStr = `${y}-${m}-${d}`;
+
+			// Clean calendar entries and seed a vacation on next Thursday only
+			cleanupCalendarEntries();
+			seedBlockedDate(nextThursdayStr, 'Vacances AC4', 'vacation');
+			clearCache();
+
+			await loginAsAdmin(page);
+			await page.goto(`${ALPHA_URL}/admin/schedule`);
+			await waitForScheduleReady(page);
+
+			// Create a Thursday slot (if none exists) so we have a recurring slot on Thursday
+			const dayColumns = page.locator('.day-column');
+			// Check if Thursday column (index 3) already has a slot
+			const thursdaySlots = dayColumns.nth(3).locator('.slot-card');
+			const existingCount = await thursdaySlots.count();
+
+			if (existingCount === 0) {
+				// Create a slot on Thursday
+				const thursdayCell = dayColumns.nth(3).locator('.time-cell').first();
+				await thursdayCell.click();
+
+				const dialog = page.getByRole('dialog');
+				await expect(dialog).toBeVisible({ timeout: 10000 });
+				await fillSlotForm(dialog, { dayValue: '4', startTime: '09:00', endTime: '10:00' });
+				await dialog.getByRole('button', { name: /créer/i }).click();
+				await expect(dialog).not.toBeVisible({ timeout: 10000 });
+				await waitForScheduleReady(page);
+			}
+
+			// Verify slot is visible on current week's Thursday
+			await expect(dayColumns.nth(3).locator('.slot-card').first()).toBeVisible({
+				timeout: 10000
+			});
+
+			// Navigate to next week
+			await page.getByRole('button', { name: 'Semaine suivante' }).click();
+			await waitForScheduleReady(page);
+
+			// Next week Thursday should be blocked
+			await expect(dayColumns.nth(3)).toHaveClass(/day-blocked/, { timeout: 10000 });
+
+			// No slot card should appear on the blocked Thursday
+			await expect(dayColumns.nth(3).locator('.slot-card')).toHaveCount(0);
+		});
 	});
 });
diff --git a/frontend/e2e/schedule.spec.ts b/frontend/e2e/schedule.spec.ts
index f7ea8dd..3cbb8e0 100644
--- a/frontend/e2e/schedule.spec.ts
+++ b/frontend/e2e/schedule.spec.ts
@@ -94,7 +94,7 @@ async function waitForScheduleReady(page: import('@playwright/test').Page) {
 		timeout: 15000
 	});
 	// Wait for either the grid or the empty state to appear
-	await expect(page.locator('.schedule-grid, .empty-state, .alert-error')).toBeVisible({
+	await expect(page.locator('.schedule-grid, .empty-state')).toBeVisible({
 		timeout: 15000
 	});
 }
@@ -415,3 +415,244 @@ test.describe('Schedule Management - Navigation & Grid & Creation (Story 4.1)',
 		});
 	});
 });
+
+test.describe('Schedule Recurring - Week Navigation & Scope (Story 4.2)', () => {
+	test.describe.configure({ mode: 'serial' });
+
+	test.beforeAll(async () => {
+		// Create admin user
+		execSync(
+			`docker compose -f "${composeFile}" exec -T php php bin/console app:dev:create-test-user --tenant=ecole-alpha --email=${ADMIN_EMAIL} --password=${ADMIN_PASSWORD} --role=ROLE_ADMIN 2>&1`,
+			{ encoding: 'utf-8' }
+		);
+
+		// Create teacher user
+		execSync(
+			`docker compose -f "${composeFile}" exec -T php php bin/console app:dev:create-test-user --tenant=ecole-alpha --email=${TEACHER_EMAIL} --password=${TEACHER_PASSWORD} --role=ROLE_PROF 2>&1`,
+			{ encoding: 'utf-8' }
+		);
+
+		const { schoolId, academicYearId } = resolveDeterministicIds();
+
+		try {
+			runSql(
+				`INSERT INTO school_classes (id, tenant_id, school_id, academic_year_id, name, level, status, created_at, updated_at) VALUES (gen_random_uuid(), '${TENANT_ID}', '${schoolId}', '${academicYearId}', 'E2E-Schedule-6A', '6ème', 'active', NOW(), NOW()) ON CONFLICT DO NOTHING`
+			);
+		} catch {
+			// May already exist
+		}
+
+		try {
+			runSql(
+				`INSERT INTO subjects (id, tenant_id, school_id, name, code, color, status, created_at, updated_at) VALUES (gen_random_uuid(), '${TENANT_ID}', '${schoolId}', 'E2E-Schedule-Maths', 'E2ESCHEDMATH', '#3b82f6', 'active', NOW(), NOW()) ON CONFLICT DO NOTHING`
+			);
+		} catch {
+			// May already exist
+		}
+
+		cleanupScheduleData();
+		clearCache();
+	});
+
+	test.beforeEach(async () => {
+		cleanupScheduleData();
+		try {
+			runSql(`DELETE FROM schedule_exceptions WHERE tenant_id = '${TENANT_ID}'`);
+		} catch {
+			// Table may not exist
+		}
+		try {
+			runSql(`DELETE FROM teacher_assignments WHERE tenant_id = '${TENANT_ID}'`);
+		} catch {
+			// Table may not exist
+		}
+		seedTeacherAssignments();
+		clearCache();
+	});
+
+	// ==========================================================================
+	// AC2: Week Navigation
+	// ==========================================================================
+	test.describe('AC2: Week Navigation', () => {
+		test('displays week navigation controls', async ({ page }) => {
+			await loginAsAdmin(page);
+			await page.goto(`${ALPHA_URL}/admin/schedule`);
+			await waitForScheduleReady(page);
+
+			// Week navigation should be visible
+			const weekNav = page.locator('.week-nav');
+			await expect(weekNav).toBeVisible();
+
+			// Previous/next buttons
+			await expect(weekNav.getByLabel('Semaine précédente')).toBeVisible();
+			await expect(weekNav.getByLabel('Semaine suivante')).toBeVisible();
+
+			// Week label
+			await expect(weekNav.locator('.week-label')).toBeVisible();
+		});
+
+		test('can navigate to next and previous weeks', async ({ page }) => {
+			await loginAsAdmin(page);
+			await page.goto(`${ALPHA_URL}/admin/schedule`);
+			await waitForScheduleReady(page);
+
+			const weekLabel = page.locator('.week-label');
+			const initialLabel = await weekLabel.textContent();
+
+			// Navigate to next week
+			await page.getByLabel('Semaine suivante').click();
+			await expect(weekLabel).not.toHaveText(initialLabel!, { timeout: 5000 });
+			const nextLabel = await weekLabel.textContent();
+
+			// Navigate back
+			await page.getByLabel('Semaine précédente').click();
+			await expect(weekLabel).toHaveText(initialLabel!, { timeout: 5000 });
+
+			// Navigate to next again
+			await page.getByLabel('Semaine suivante').click();
+			await expect(weekLabel).toHaveText(nextLabel!, { timeout: 5000 });
+		});
+
+		test('today button appears when not on current week', async ({ page }) => {
+			await loginAsAdmin(page);
+			await page.goto(`${ALPHA_URL}/admin/schedule`);
+			await waitForScheduleReady(page);
+
+			// "Aujourd'hui" button should not be visible on current week
+			await expect(page.locator('.week-nav-today')).not.toBeVisible();
+
+			// Navigate away
+			await page.getByLabel('Semaine suivante').click();
+
+			// "Aujourd'hui" button should appear
+			await expect(page.locator('.week-nav-today')).toBeVisible({ timeout: 5000 });
+
+			// Click it to go back
+			await page.locator('.week-nav-today').click();
+
+			// Should disappear again
+			await expect(page.locator('.week-nav-today')).not.toBeVisible({ timeout: 5000 });
+		});
+	});
+
+	// ==========================================================================
+	// AC1/AC2: Recurring indicator
+	// ==========================================================================
+	test.describe('AC1: Recurring Indicator', () => {
+		test('recurring slots show recurring badge', async ({ page }) => {
+			await loginAsAdmin(page);
+			await page.goto(`${ALPHA_URL}/admin/schedule`);
+			await waitForScheduleReady(page);
+
+			// Create a slot first
+			const timeCell = page.locator('.time-cell').first();
+			await timeCell.click();
+
+			const dialog = page.getByRole('dialog');
+			await expect(dialog).toBeVisible({ timeout: 10000 });
+
+			await fillSlotForm(dialog, { room: 'B201' });
+			await dialog.getByRole('button', { name: /créer/i }).click();
+			await expect(dialog).not.toBeVisible({ timeout: 10000 });
+
+			// Slot card should have the recurring badge
+			const slotCard = page.locator('.slot-card');
+			await expect(slotCard).toBeVisible({ timeout: 10000 });
+			await expect(slotCard.locator('.slot-badge-recurring')).toBeVisible();
+		});
+	});
+
+	// ==========================================================================
+	// AC3: Scope Choice Modal
+	// ==========================================================================
+	test.describe('AC3: Scope Choice Modal', () => {
+		test('clicking a slot opens scope choice modal', async ({ page }) => {
+			await loginAsAdmin(page);
+			await page.goto(`${ALPHA_URL}/admin/schedule`);
+			await waitForScheduleReady(page);
+
+			// Create a slot
+			const timeCell = page.locator('.time-cell').first();
+			await timeCell.click();
+			const createDialog = page.getByRole('dialog');
+			await expect(createDialog).toBeVisible({ timeout: 10000 });
+
+			await fillSlotForm(createDialog, { room: 'C301' });
+			await createDialog.getByRole('button', { name: /créer/i }).click();
+			await expect(createDialog).not.toBeVisible({ timeout: 10000 });
+
+			// Click on the slot card
+			const slotCard = page.locator('.slot-card');
+			await expect(slotCard).toBeVisible({ timeout: 10000 });
+			await slotCard.click();
+
+			// Scope modal should appear
+			const scopeModal = page.locator('.modal-scope');
+			await expect(scopeModal).toBeVisible({ timeout: 10000 });
+			await expect(scopeModal.getByText('Cette occurrence uniquement')).toBeVisible();
+			await expect(scopeModal.getByText('Toutes les occurrences futures')).toBeVisible();
+		});
+
+		test('scope modal can be closed with Escape', async ({ page }) => {
+			await loginAsAdmin(page);
+			await page.goto(`${ALPHA_URL}/admin/schedule`);
+			await waitForScheduleReady(page);
+
+			// Create a slot
+			const timeCell = page.locator('.time-cell').first();
+			await timeCell.click();
+			const createDialog = page.getByRole('dialog');
+			await expect(createDialog).toBeVisible({ timeout: 10000 });
+
+			await fillSlotForm(createDialog);
+			await createDialog.getByRole('button', { name: /créer/i }).click();
+			await expect(createDialog).not.toBeVisible({ timeout: 10000 });
+
+			// Click on the slot card
+			const slotCard = page.locator('.slot-card');
+			await expect(slotCard).toBeVisible({ timeout: 10000 });
+			await slotCard.click();
+
+			// Scope modal appears
+			const scopeModal = page.locator('.modal-scope');
+			await expect(scopeModal).toBeVisible({ timeout: 10000 });
+
+			// Close with Escape
+			await page.keyboard.press('Escape');
+			await expect(scopeModal).not.toBeVisible({ timeout: 5000 });
+		});
+
+		test('choosing "this occurrence" opens edit form', async ({ page }) => {
+			await loginAsAdmin(page);
+			await page.goto(`${ALPHA_URL}/admin/schedule`);
+			await waitForScheduleReady(page);
+
+			// Create a slot
+			const timeCell = page.locator('.time-cell').first();
+			await timeCell.click();
+			const createDialog = page.getByRole('dialog');
+			await expect(createDialog).toBeVisible({ timeout: 10000 });
+
+			await fillSlotForm(createDialog, { room: 'D401' });
+			await createDialog.getByRole('button', { name: /créer/i }).click();
+			await expect(createDialog).not.toBeVisible({ timeout: 10000 });
+
+			// Click on the slot card
+			const slotCard = page.locator('.slot-card');
+			await expect(slotCard).toBeVisible({ timeout: 10000 });
+			await slotCard.click();
+
+			// Choose "this occurrence"
+			const scopeModal = page.locator('.modal-scope');
+			await expect(scopeModal).toBeVisible({ timeout: 10000 });
+			await scopeModal.getByText('Cette occurrence uniquement').click();
+
+			// Edit form should appear
+			const editDialog = page.getByRole('dialog');
+			await expect(editDialog).toBeVisible({ timeout: 10000 });
+			await expect(
+				editDialog.getByRole('heading', { name: /modifier le créneau/i })
+			).toBeVisible();
+		});
+	});
+});
diff --git a/frontend/src/routes/admin/schedule/+page.svelte b/frontend/src/routes/admin/schedule/+page.svelte
index f24ea98..43310ee 100644
--- a/frontend/src/routes/admin/schedule/+page.svelte
+++ b/frontend/src/routes/admin/schedule/+page.svelte
@@ -4,19 +4,6 @@
 	import { untrack } from 'svelte';
 
 	// Types
-	interface ScheduleSlot {
-		id: string;
-		classId: string;
-		subjectId: string;
-		teacherId: string;
-		dayOfWeek: number;
-		startTime: string;
-		endTime: string;
-		room: string | null;
-		isRecurring: boolean;
-		conflicts?: Array<{ type: string; description: string; slotId: string }>;
-	}
-
 	interface SchoolClass {
 		id: string;
 		name: string;
@@ -51,6 +38,21 @@
 		type: string;
 	}
 
+	interface ResolvedSlot {
+		id: string;
+		slotId: string;
+		classId: string;
+		subjectId: string;
+		teacherId: string;
+		dayOfWeek: number;
+		startTime: string;
+		endTime: string;
+		room: string | null;
+		date: string;
+		isModified: boolean;
+		exceptionId: string | null;
+	}
+
 	// Constants
 	const DAYS = [
 		{ value: 1, label: 'Lundi' },
@@ -68,8 +70,22 @@
 		TIME_SLOTS.push(`${String(h).padStart(2, '0')}:30`);
 	}
 
+	function formatLocalDate(d: Date): string {
+		const y = d.getFullYear();
+		const m = String(d.getMonth() + 1).padStart(2, '0');
+		const day = String(d.getDate()).padStart(2, '0');
+		return `${y}-${m}-${day}`;
+	}
+
+	function getInitialMonday(): string {
+		const now = new Date();
+		const d = new Date(now);
+		d.setDate(now.getDate() - ((now.getDay() + 6) % 7));
+		return formatLocalDate(d);
+	}
+
 	// State
-	let slots = $state<ScheduleSlot[]>([]);
+	let slots = $state<ResolvedSlot[]>([]);
 	let classes = $state<SchoolClass[]>([]);
 	let subjects = $state<Subject[]>([]);
 	let teachers = $state<User[]>([]);
@@ -84,9 +100,13 @@
 	let selectedClassId = $state('');
 	let selectedTeacherFilter = $state('');
 
+	// Week navigation
+	let currentWeekStart = $state(getInitialMonday());
+
 	// Create/Edit modal
 	let showSlotModal = $state(false);
-	let editingSlot = $state<ScheduleSlot | null>(null);
+	let editingSlot = $state<ResolvedSlot | null>(null);
+	let editScope = $state<'this_occurrence' | 'all_future'>('this_occurrence');
 	let formClassId = $state('');
 	let formSubjectId = $state('');
 	let formTeacherId = $state('');
@@ -100,11 +120,18 @@
 
 	// Delete modal
 	let showDeleteModal = $state(false);
-	let slotToDelete = $state<ScheduleSlot | null>(null);
+	let slotToDelete = $state<ResolvedSlot | null>(null);
 	let isDeleting = $state(false);
+	let deleteScope = $state<'this_occurrence' | 'all_future'>('this_occurrence');
+
+	// Scope choice modal
+	let showScopeModal = $state(false);
+	let scopeAction = $state<'edit' | 'delete' | 'move'>('edit');
+	let scopeSlot = $state<ResolvedSlot | null>(null);
 
 	// Drag state
-	let draggedSlot = $state<ScheduleSlot | null>(null);
+	let draggedSlot = $state<ResolvedSlot | null>(null);
+	let pendingDrop = $state<{ slot: ResolvedSlot; day: number; time: string } | null>(null);
 
 	// Mobile: selected day tab
 	let mobileSelectedDay = $state(1);
@@ -144,6 +171,16 @@
 	let subjectMap = $derived(new Map(subjects.map((s) => [s.id, s])));
 	let teacherMap = $derived(new Map(teachers.map((t) => [t.id, t])));
 
+	let weekLabel = $derived.by(() => {
+		const start = new Date(currentWeekStart + 'T00:00:00');
+		const end = new Date(start);
+		end.setDate(start.getDate() + 4);
+		const opts: Intl.DateTimeFormatOptions = { day: 'numeric', month: 'long' };
+		const optsY: Intl.DateTimeFormatOptions = { day: 'numeric', month: 'long', year: 'numeric' };
+		return `${start.toLocaleDateString('fr-FR', opts)} - ${end.toLocaleDateString('fr-FR', optsY)}`;
+	});
+
+	let isCurrentWeek = $derived(currentWeekStart === getInitialMonday());
 
 	// Load on mount
 	$effect(() => {
@@ -189,11 +226,15 @@
 		}
 	}
 
-	// Load slots whenever filter changes
+	// Load slots whenever filter or week changes
 	$effect(() => {
 		const classId = selectedClassId;
 		const teacherId = selectedTeacherFilter;
-		untrack(() => loadSlots(classId, teacherId));
+		const _week = currentWeekStart;
+		untrack(() => {
+			loadSlots(classId, teacherId);
+			loadBlockedDates();
+		});
 	});
 
 	// Load assignments when class filter or form class changes
@@ -219,20 +260,21 @@
 		try {
 			isSlotsLoading = true;
 			const apiUrl = getApiBaseUrl();
-			const params = new URLSearchParams();
-			if (classId) params.set('classId', classId);
-			if (teacherId) params.set('teacherId', teacherId);
 
-			const response = await authenticatedFetch(
-				`${apiUrl}/schedule/slots?${params.toString()}`,
-				{ signal: controller.signal }
-			);
+			const url = classId
+				? `${apiUrl}/schedule/week/${currentWeekStart}?classId=${classId}`
+				: `${apiUrl}/schedule/slots?teacherId=${teacherId}`;
+
+			const response = await authenticatedFetch(url, { signal: controller.signal });
 
 			if (controller.signal.aborted) return;
 			if (!response.ok) throw new Error('Erreur lors du chargement de l\u2019emploi du temps.');
 
 			const data = await response.json();
-			slots = data['hydra:member'] ?? data['member'] ?? (Array.isArray(data) ? data : []);
+			const items: ResolvedSlot[] = data['hydra:member'] ?? data['member'] ?? (Array.isArray(data) ? data : []);
+
+			// Apply teacher filter client-side when using resolved API
+			slots = teacherId ? items.filter((s) => s.teacherId === teacherId) : items;
 		} catch (e) {
 			if (e instanceof DOMException && e.name === 'AbortError') return;
 			error = e instanceof Error ? e.message : 'Erreur inconnue.';
@@ -265,14 +307,12 @@
 	}
 
 	function getCurrentWeekDates(): Map<number, string> {
-		const now = new Date();
-		const monday = new Date(now);
-		monday.setDate(now.getDate() - ((now.getDay() + 6) % 7));
+		const monday = new Date(currentWeekStart + 'T00:00:00');
 		const dates = new Map<number, string>();
 		for (let i = 0; i < 5; i++) {
 			const d = new Date(monday);
 			d.setDate(monday.getDate() + i);
-			dates.set(i + 1, d.toISOString().split('T')[0]!);
+			dates.set(i + 1, formatLocalDate(d));
 		}
 		return dates;
 	}
@@ -302,12 +342,29 @@
 		}
 	}
 
+	// Week navigation
+	function prevWeek() {
+		const d = new Date(currentWeekStart + 'T00:00:00');
+		d.setDate(d.getDate() - 7);
+		currentWeekStart = formatLocalDate(d);
+	}
+
+	function nextWeek() {
+		const d = new Date(currentWeekStart + 'T00:00:00');
+		d.setDate(d.getDate() + 7);
+		currentWeekStart = formatLocalDate(d);
+	}
+
+	function goToThisWeek() {
+		currentWeekStart = getInitialMonday();
+	}
+
 	// Grid helpers
-	function getSlotTop(slot: ScheduleSlot): number {
+	function getSlotTop(slot: ResolvedSlot): number {
 		return timeToMinutes(slot.startTime) - timeToMinutes(`${String(HOURS_START).padStart(2, '0')}:00`);
 	}
 
-	function getSlotHeight(slot: ScheduleSlot): number {
+	function getSlotHeight(slot: ResolvedSlot): number {
 		return timeToMinutes(slot.endTime) - timeToMinutes(slot.startTime);
 	}
 
@@ -338,7 +395,7 @@
 	}
 
 	// Unique slots for a day column (deduplicated by slot id)
-	function getSlotsForDay(day: number): ScheduleSlot[] {
+	function getSlotsForDay(day: number): ResolvedSlot[] {
 		return slots.filter((s) => s.dayOfWeek === day);
 	}
 
@@ -361,7 +418,34 @@
 		showSlotModal = true;
 	}
 
-	function openEditModal(slot: ScheduleSlot) {
+	function handleSlotClick(slot: ResolvedSlot) {
+		scopeSlot = slot;
+		scopeAction = 'edit';
+		showScopeModal = true;
+	}
+
+	function handleScopeChoice(scope: 'this_occurrence' | 'all_future') {
+		showScopeModal = false;
+		if (scopeAction === 'edit') {
+			editScope = scope;
+			openEditModal(scopeSlot!);
+		} else if (scopeAction === 'delete') {
+			deleteScope = scope;
+			openDeleteModal(scopeSlot!);
+		} else if (scopeAction === 'move' && pendingDrop) {
+			executeDrop(pendingDrop.slot, pendingDrop.day, pendingDrop.time, scope);
+			pendingDrop = null;
+		}
+		scopeSlot = null;
+	}
+
+	function closeScopeModal() {
+		showScopeModal = false;
+		scopeSlot = null;
+		pendingDrop = null;
+	}
+
+	function openEditModal(slot: ResolvedSlot) {
 		editingSlot = slot;
 		formClassId = slot.classId;
 		formSubjectId = slot.subjectId;
@@ -381,11 +465,19 @@
 		formConflicts = [];
 	}
 
-	function openDeleteModal(slot: ScheduleSlot) {
+	function openDeleteModal(slot: ResolvedSlot) {
 		slotToDelete = slot;
 		showDeleteModal = true;
 	}
 
+	function handleDeleteFromEdit() {
+		const slot = editingSlot!;
+		closeSlotModal();
+		scopeSlot = slot;
+		scopeAction = 'delete';
+		showScopeModal = true;
+	}
+
 	function closeDeleteModal() {
 		showDeleteModal = false;
 		slotToDelete = null;
@@ -413,11 +505,14 @@
 			};
 
 			const response = editingSlot
-				? await authenticatedFetch(`${apiUrl}/schedule/slots/${editingSlot.id}`, {
-						method: 'PATCH',
-						headers: { 'Content-Type': 'application/merge-patch+json' },
-						body: JSON.stringify(body)
-					})
+				? await authenticatedFetch(
+						`${apiUrl}/schedule/slots/${editingSlot.slotId}/occurrence/${editingSlot.date}`,
+						{
+							method: 'PUT',
+							headers: { 'Content-Type': 'application/json' },
+							body: JSON.stringify({ ...body, scope: editScope })
+						}
+					)
 				: await authenticatedFetch(`${apiUrl}/schedule/slots`, {
 						method: 'POST',
 						headers: { 'Content-Type': 'application/json' },
@@ -431,7 +526,7 @@
 				);
 			}
 
-			const result: ScheduleSlot = await response.json();
+			const result = await response.json();
 
 			// Conflits détectés et non forcés : garder la modale ouverte
 			if (result.conflicts && result.conflicts.length > 0 && !formForceConflicts) {
@@ -461,16 +556,23 @@
 			error = null;
 			const apiUrl = getApiBaseUrl();
 
-			const response = await authenticatedFetch(`${apiUrl}/schedule/slots/${slotToDelete.id}`, {
-				method: 'DELETE'
-			});
+			const occurrenceDate = slotToDelete.date;
+			if (!occurrenceDate) return;
+
+			const deleteUrl = deleteScope === 'all_future'
+				? `${apiUrl}/schedule/slots/${slotToDelete.slotId}/occurrence/${occurrenceDate}?scope=all_future`
+				: `${apiUrl}/schedule/slots/${slotToDelete.slotId}/occurrence/${occurrenceDate}`;
+
+			const response = await authenticatedFetch(deleteUrl, { method: 'DELETE' });
 
 			if (!response.ok) {
 				const data = await response.json().catch(() => null);
 				throw new Error(data?.message ?? data?.detail ?? 'Erreur lors de la suppression.');
 			}
 
-			successMessage = 'Créneau supprimé.';
+			successMessage = deleteScope === 'this_occurrence'
+				? 'Occurrence annulée.'
+				: 'Occurrences futures supprimées.';
 			closeDeleteModal();
 			await loadSlots(selectedClassId, selectedTeacherFilter);
 
@@ -485,11 +587,11 @@
 	}
 
 	// Drag & Drop
-	function handleDragStart(event: DragEvent, slot: ScheduleSlot) {
+	function handleDragStart(event: DragEvent, slot: ResolvedSlot) {
 		draggedSlot = slot;
 		if (event.dataTransfer) {
 			event.dataTransfer.effectAllowed = 'move';
-			event.dataTransfer.setData('text/plain', slot.id);
+			event.dataTransfer.setData('text/plain', slot.slotId);
 		}
 	}
 
@@ -501,14 +603,31 @@
 		}
 	}
 
-	async function handleDrop(event: DragEvent, day: number, time: string) {
+	function handleDrop(event: DragEvent, day: number, time: string) {
 		event.preventDefault();
 		if (!draggedSlot) return;
 
 		const slot = draggedSlot;
 		draggedSlot = null;
 
-		// Calculate new end time preserving duration
+		if (day !== slot.dayOfWeek) {
+			// Cross-day moves require splitting the recurrence — skip scope modal
+			executeDrop(slot, day, time, 'all_future');
+			return;
+		}
+
+		pendingDrop = { slot, day, time };
+		scopeSlot = slot;
+		scopeAction = 'move';
+		showScopeModal = true;
+	}
+
+	async function executeDrop(
+		slot: ResolvedSlot,
+		day: number,
+		time: string,
+		scope: 'this_occurrence' | 'all_future'
+	) {
 		const duration = timeToMinutes(slot.endTime) - timeToMinutes(slot.startTime);
 		const newEndMinutes = timeToMinutes(time) + duration;
 		const newEndH = Math.floor(newEndMinutes / 60);
@@ -519,16 +638,23 @@
 			error = null;
 			const apiUrl = getApiBaseUrl();
 
-			const response = await authenticatedFetch(`${apiUrl}/schedule/slots/${slot.id}`, {
-				method: 'PATCH',
-				headers: { 'Content-Type': 'application/merge-patch+json' },
-				body: JSON.stringify({
-					dayOfWeek: day,
-					startTime: time,
-					endTime: newEndTime,
-					forceConflicts: false
-				})
-			});
+			const response = await authenticatedFetch(
+				`${apiUrl}/schedule/slots/${slot.slotId}/occurrence/${slot.date}`,
+				{
+					method: 'PUT',
+					headers: { 'Content-Type': 'application/json' },
+					body: JSON.stringify({
+						classId: slot.classId,
+						subjectId: slot.subjectId,
+						teacherId: slot.teacherId,
+						dayOfWeek: day,
+						startTime: time,
+						endTime: newEndTime,
+						room: slot.room,
+						scope
+					})
+				}
+			);
 
 			if (!response.ok) {
 				const data = await response.json().catch(() => null);
@@ -537,7 +663,7 @@
 				);
 			}
 
-			const result: ScheduleSlot = await response.json();
+			const result: { conflicts?: Array<{ description: string }> } = await response.json();
 			if (result.conflicts && result.conflicts.length > 0) {
 				error = `Conflit détecté : ${result.conflicts.map((c) => c.description).join(', ')}`;
 			} else {
@@ -560,7 +686,8 @@
 
 <svelte:window onkeydown={(e) => {
 	if (e.key === 'Escape') {
-		if (showDeleteModal) closeDeleteModal();
+		if (showScopeModal) closeScopeModal();
+		else if (showDeleteModal) closeDeleteModal();
 		else if (showSlotModal) closeSlotModal();
 	}
 }} />
@@ -613,6 +740,16 @@
 		</div>
 	</div>
 
+	<!-- Week navigation -->
+	<div class="week-nav" aria-label="Navigation par semaine">
+		<button class="week-nav-btn" onclick={prevWeek} aria-label="Semaine précédente">&lt;</button>
+		<span class="week-label">{weekLabel}</span>
+		<button class="week-nav-btn" onclick={nextWeek} aria-label="Semaine suivante">&gt;</button>
+		{#if !isCurrentWeek}
+			<button class="week-nav-today" onclick={goToThisWeek}>Aujourd'hui</button>
+		{/if}
+	</div>
+
 	{#if isLoading}
 		<div class="loading-state" aria-live="polite" role="status">
 			<div class="spinner"></div>
@@ -690,6 +827,7 @@
 							<div
 								class="slot-card"
 								class:dragging={draggedSlot?.id === slot.id}
+								class:slot-modified={slot.isModified}
 								style="
 									top: {getSlotTop(slot)}px;
 									height: {getSlotHeight(slot)}px;
@@ -700,13 +838,20 @@
 								draggable="true"
 								ondragstart={(e) => handleDragStart(e, slot)}
 								ondragend={handleDragEnd}
-								onclick={(e) => { e.stopPropagation(); openEditModal(slot); }}
+								onclick={(e) => { e.stopPropagation(); handleSlotClick(slot); }}
 								role="button"
 								tabindex="0"
-								onkeydown={(e) => { if (e.key === 'Enter') openEditModal(slot); }}
+								onkeydown={(e) => { if (e.key === 'Enter') handleSlotClick(slot); }}
 								title="{getSubjectName(slot.subjectId)} - {getTeacherName(slot.teacherId)}"
 							>
-								<span class="slot-subject">{getSubjectName(slot.subjectId)}</span>
+								<div class="slot-header-row">
+									<span class="slot-subject">{getSubjectName(slot.subjectId)}</span>
+									{#if slot.isModified}
+										<span class="slot-badge slot-badge-modified" title="Occurrence modifiée">M</span>
+									{:else}
+										<span class="slot-badge slot-badge-recurring" title="Cours récurrent">↻</span>
+									{/if}
+								</div>
 								<span class="slot-teacher">{getTeacherName(slot.teacherId)}</span>
 								{#if slot.room}
 									<span class="slot-room">{slot.room}</span>
@@ -852,7 +997,7 @@
 						<button
 							type="button"
 							class="btn-danger"
-							onclick={() => { const slot = editingSlot!; closeSlotModal(); openDeleteModal(slot); }}
+							onclick={handleDeleteFromEdit}
 							disabled={isSubmitting}
 						>
 							Supprimer
@@ -884,18 +1029,31 @@
 			onclick={(e) => e.stopPropagation()}
 		>
 			<header class="modal-header modal-header-danger">
-				<h2 id="delete-title">Supprimer le créneau</h2>
+				<h2 id="delete-title">
+					{deleteScope === 'this_occurrence' ? 'Annuler cette occurrence' : 'Supprimer le créneau'}
+				</h2>
 				<button class="modal-close" onclick={closeDeleteModal} aria-label="Fermer">×</button>
 			</header>
 
 			<div class="modal-body">
 				<p id="delete-description">
-					Voulez-vous supprimer le créneau de
-					<strong>{getSubjectName(slotToDelete!.subjectId)}</strong>
-					({DAYS.find((d) => d.value === slotToDelete!.dayOfWeek)?.label}
-					{slotToDelete!.startTime} - {slotToDelete!.endTime}) ?
+					{#if deleteScope === 'this_occurrence'}
+						Voulez-vous annuler le cours de
+						<strong>{getSubjectName(slotToDelete!.subjectId)}</strong>
+						du {slotToDelete!.date} ({DAYS.find((d) => d.value === slotToDelete!.dayOfWeek)?.label}
+						{slotToDelete!.startTime} - {slotToDelete!.endTime}) ?
+					{:else}
+						Voulez-vous supprimer le créneau récurrent de
+						<strong>{getSubjectName(slotToDelete!.subjectId)}</strong>
+						({DAYS.find((d) => d.value === slotToDelete!.dayOfWeek)?.label}
+						{slotToDelete!.startTime} - {slotToDelete!.endTime}) ?
+					{/if}
+				</p>
+				<p class="delete-warning">
+					{deleteScope === 'this_occurrence'
+						? 'Le cours sera annulé uniquement pour cette date.'
+						: 'Cette action supprimera toutes les occurrences futures.'}
 				</p>
-				<p class="delete-warning">Cette action est irréversible.</p>
 			</div>
 
 			<div class="modal-actions">
@@ -924,6 +1082,59 @@
 	</div>
 {/if}
 
+<!-- Scope Choice Modal -->
+{#if showScopeModal && scopeSlot}
+	<!-- svelte-ignore a11y_no_static_element_interactions -->
+	<div class="modal-overlay" onclick={closeScopeModal} role="presentation">
+		<div
+			class="modal modal-scope"
+			role="dialog"
+			aria-modal="true"
+			aria-labelledby="scope-title"
+			onclick={(e) => e.stopPropagation()}
+		>
+			<header class="modal-header">
+				<h2 id="scope-title">
+					{scopeAction === 'edit' ? 'Modifier le cours' : 'Supprimer le cours'}
+				</h2>
+				<button class="modal-close" onclick={closeScopeModal} aria-label="Fermer">×</button>
+			</header>
+
+			<div class="modal-body">
+				<p class="scope-description">
+					Ce cours de <strong>{getSubjectName(scopeSlot.subjectId)}</strong> est récurrent.
+					Que souhaitez-vous {scopeAction === 'edit' ? 'modifier' : 'supprimer'} ?
+				</p>
+
+				<div class="scope-choices">
+					<button
+						class="scope-choice"
+						onclick={() => handleScopeChoice('this_occurrence')}
+					>
+						<span class="scope-choice-title">Cette occurrence uniquement</span>
+						<span class="scope-choice-desc">
+							{scopeAction === 'edit'
+								? 'Modifie uniquement le cours du ' + scopeSlot.date
+								: 'Annule uniquement le cours du ' + scopeSlot.date}
+						</span>
+					</button>
+					<button
+						class="scope-choice"
+						onclick={() => handleScopeChoice('all_future')}
+					>
+						<span class="scope-choice-title">Toutes les occurrences futures</span>
+						<span class="scope-choice-desc">
+							{scopeAction === 'edit'
+								? 'Modifie ce cours et toutes les semaines suivantes'
+								: 'Supprime ce cours et toutes les semaines suivantes'}
+						</span>
+					</button>
+				</div>
+			</div>
+		</div>
+	</div>
+{/if}
+
 <style>
 	.schedule-page {
 		padding: 1rem;
@@ -1451,6 +1662,130 @@
 		cursor: not-allowed;
 	}
 
+	/* Week navigation */
+	.week-nav {
+		display: flex;
+		align-items: center;
+		gap: 0.75rem;
+		margin-bottom: 1.5rem;
+	}
+
+	.week-nav-btn {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		width: 2rem;
+		height: 2rem;
+		border: 1px solid #e2e8f0;
+		border-radius: 0.375rem;
+		background: white;
+		cursor: pointer;
+		font-size: 0.875rem;
+		color: #374151;
+		transition: background-color 0.15s;
+	}
+
+	.week-nav-btn:hover {
+		background: #f8fafc;
+	}
+
+	.week-label {
+		font-size: 0.9375rem;
+		font-weight: 600;
+		color: #1f2937;
+	}
+
+	.week-nav-today {
+		padding: 0.375rem 0.75rem;
+		border: 1px solid #3b82f6;
+		border-radius: 0.375rem;
+		background: white;
+		color: #3b82f6;
+		font-size: 0.8125rem;
+		font-weight: 500;
+		cursor: pointer;
+		transition: background-color 0.15s;
+	}
+
+	.week-nav-today:hover {
+		background: #eff6ff;
+	}
+
+	/* Slot indicators */
+	.slot-header-row {
+		display: flex;
+		align-items: center;
+		gap: 3px;
+	}
+
+	.slot-badge {
+		flex-shrink: 0;
+		font-size: 0.55rem;
+		line-height: 1;
+		padding: 1px 3px;
+		border-radius: 2px;
+		font-weight: 700;
+	}
+
+	.slot-badge-recurring {
+		opacity: 0.5;
+	}
+
+	.slot-badge-modified {
+		background: rgba(255, 255, 255, 0.3);
+		opacity: 0.8;
+	}
+
+	.slot-modified {
+		border-left-style: dashed !important;
+	}
+
+	/* Scope modal */
+	.modal-scope {
+		max-width: 420px;
+	}
+
+	.scope-description {
+		margin: 0 0 1rem;
+		font-size: 0.875rem;
+		color: #374151;
+	}
+
+	.scope-choices {
+		display: flex;
+		flex-direction: column;
+		gap: 0.5rem;
+	}
+
+	.scope-choice {
+		display: flex;
+		flex-direction: column;
+		gap: 0.25rem;
+		padding: 0.75rem 1rem;
+		border: 1px solid #e2e8f0;
+		border-radius: 0.5rem;
+		background: white;
+		cursor: pointer;
+		text-align: left;
+		transition: border-color 0.15s, background-color 0.15s;
+	}
+
+	.scope-choice:hover {
+		border-color: #3b82f6;
+		background: #f0f9ff;
+	}
+
+	.scope-choice-title {
+		font-size: 0.875rem;
+		font-weight: 600;
+		color: #1f2937;
+	}
+
+	.scope-choice-desc {
+		font-size: 0.75rem;
+		color: #64748b;
+	}
+
 	/* Day tabs (mobile only) */
 	.day-tabs {
 		display: none;