diff --git a/docs/superpowers/plans/2026-05-19-mail-phase1-foundations.md b/docs/superpowers/plans/2026-05-19-mail-phase1-foundations.md
new file mode 100644
index 0000000..42f1cbf
--- /dev/null
+++ b/docs/superpowers/plans/2026-05-19-mail-phase1-foundations.md
@@ -0,0 +1,1632 @@
+# Mail Integration — Phase 1 : Backend Foundations
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Créer les fondations BDD + interfaces de l'intégration mail OVH IMAP (4 entités, 4 repositories, 1 migration, 4 DTOs, 1 interface, 1 exception, 1 fixture, tests). Aucune logique métier.
+
+**Architecture:** Singleton `MailConfiguration` (calqué sur `ZimbraConfiguration`), `MailFolder` (cache arbre IMAP), `MailMessage` (cache headers + snippet), `TaskMailLink` (join). Interface `MailProviderInterface` définit le contrat — implémentation en Phase 2.
+
+**Tech Stack:** PHP 8.4, Symfony 8.0, Doctrine ORM avec attributs PHP 8, PostgreSQL 16, PHPUnit + DAMA DoctrineTestBundle.
+
+**Branche cible :** `feat/mail-integration` (créer si elle n'existe pas).
+
+**Fichiers créés/modifiés par le codeur :**
+
+| Fichier | Action |
+|---|---|
+| `src/Entity/MailConfiguration.php` | Créer |
+| `src/Entity/MailFolder.php` | Créer |
+| `src/Entity/MailMessage.php` | Créer |
+| `src/Entity/TaskMailLink.php` | Créer |
+| `src/Repository/MailConfigurationRepository.php` | Créer |
+| `src/Repository/MailFolderRepository.php` | Créer |
+| `src/Repository/MailMessageRepository.php` | Créer |
+| `src/Repository/TaskMailLinkRepository.php` | Créer |
+| `src/Mail/MailProviderInterface.php` | Créer |
+| `src/Mail/Exception/MailProviderException.php` | Créer |
+| `src/Mail/Dto/MailFolderDto.php` | Créer |
+| `src/Mail/Dto/MailMessageHeaderDto.php` | Créer |
+| `src/Mail/Dto/MailAttachmentDto.php` | Créer |
+| `src/Mail/Dto/MailMessageDetailDto.php` | Créer |
+| `migrations/Version<timestamp>.php` | Créer |
+| `src/DataFixtures/AppFixtures.php` | Modifier |
+| `tests/Unit/Repository/MailConfigurationRepositoryTest.php` | Créer |
+
+---
+
+### Task 1 : Préparation — branche + dossiers
+
+- [ ] **Step 1 : Vérifier / créer la branche**
+
+  ```bash
+  git checkout feat/mail-integration 2>/dev/null || git checkout -b feat/mail-integration
+  ```
+
+- [ ] **Step 2 : Créer les dossiers namespace**
+
+  ```bash
+  mkdir -p src/Mail/Dto src/Mail/Exception
+  mkdir -p tests/Unit/Repository
+  ```
+
+- [ ] **Step 3 : Vérifier que les dossiers sont dans l'autoloader Composer**
+
+  Ouvrir `composer.json` et confirmer que `"App\\": "src/"` est présent dans `autoload.psr-4`. Si oui, rien à faire (les sous-dossiers `src/Mail/` sont automatiquement couverts).
+
+---
+
+### Task 2 : Entité `MailConfiguration` + Repository + test singleton
+
+#### Step 1 : Écrire le test (TDD — il doit échouer)
+
+Créer `tests/Unit/Repository/MailConfigurationRepositoryTest.php` :
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\Repository;
+
+use App\Entity\MailConfiguration;
+use App\Repository\MailConfigurationRepository;
+use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
+
+class MailConfigurationRepositoryTest extends KernelTestCase
+{
+    private MailConfigurationRepository $repository;
+
+    protected function setUp(): void
+    {
+        self::bootKernel();
+        $container = static::getContainer();
+        $this->repository = $container->get(MailConfigurationRepository::class);
+    }
+
+    public function testFindSingletonReturnsNullWhenEmpty(): void
+    {
+        $result = $this->repository->findSingleton();
+
+        self::assertNull($result);
+    }
+
+    public function testFindSingletonReturnsFirstRecord(): void
+    {
+        $container = static::getContainer();
+        $em = $container->get('doctrine.orm.entity_manager');
+
+        $config = new MailConfiguration();
+        $config->setImapHost('ssl0.ovh.net');
+        $config->setEnabled(false);
+        $em->persist($config);
+        $em->flush();
+
+        $result = $this->repository->findSingleton();
+
+        self::assertInstanceOf(MailConfiguration::class, $result);
+        self::assertSame('ssl0.ovh.net', $result->getImapHost());
+        self::assertFalse($result->isEnabled());
+    }
+}
+```
+
+- [ ] **Step 2 : Lancer le test pour vérifier qu'il échoue**
+
+  ```bash
+  docker exec php-lesstime-fpm php bin/phpunit tests/Unit/Repository/MailConfigurationRepositoryTest.php 2>&1 | tail -20
+  ```
+
+  Attendu : erreur de classe manquante (`App\Entity\MailConfiguration`).
+
+- [ ] **Step 3 : Créer l'entité `MailConfiguration`**
+
+  Créer `src/Entity/MailConfiguration.php` :
+
+  ```php
+  <?php
+
+  declare(strict_types=1);
+
+  namespace App\Entity;
+
+  use App\Repository\MailConfigurationRepository;
+  use Doctrine\ORM\Mapping as ORM;
+
+  #[ORM\Entity(repositoryClass: MailConfigurationRepository::class)]
+  #[ORM\Table(name: 'mail_configuration')]
+  class MailConfiguration
+  {
+      #[ORM\Id]
+      #[ORM\GeneratedValue]
+      #[ORM\Column]
+      private ?int $id = null;
+
+      #[ORM\Column(length: 10)]
+      private string $protocol = 'imap';
+
+      #[ORM\Column(length: 255, nullable: true)]
+      private ?string $imapHost = null;
+
+      #[ORM\Column]
+      private int $imapPort = 993;
+
+      #[ORM\Column(length: 10)]
+      private string $imapEncryption = 'ssl';
+
+      #[ORM\Column(length: 255, nullable: true)]
+      private ?string $smtpHost = null;
+
+      #[ORM\Column]
+      private int $smtpPort = 465;
+
+      #[ORM\Column(length: 10)]
+      private string $smtpEncryption = 'ssl';
+
+      #[ORM\Column(length: 255, nullable: true)]
+      private ?string $username = null;
+
+      #[ORM\Column(type: 'text', nullable: true)]
+      private ?string $encryptedPassword = null;
+
+      #[ORM\Column(length: 255)]
+      private string $sentFolderPath = 'Sent';
+
+      #[ORM\Column(type: 'boolean')]
+      private bool $enabled = false;
+
+      public function getId(): ?int
+      {
+          return $this->id;
+      }
+
+      public function getProtocol(): string
+      {
+          return $this->protocol;
+      }
+
+      public function setProtocol(string $protocol): static
+      {
+          $this->protocol = $protocol;
+
+          return $this;
+      }
+
+      public function getImapHost(): ?string
+      {
+          return $this->imapHost;
+      }
+
+      public function setImapHost(?string $imapHost): static
+      {
+          $this->imapHost = $imapHost;
+
+          return $this;
+      }
+
+      public function getImapPort(): int
+      {
+          return $this->imapPort;
+      }
+
+      public function setImapPort(int $imapPort): static
+      {
+          $this->imapPort = $imapPort;
+
+          return $this;
+      }
+
+      public function getImapEncryption(): string
+      {
+          return $this->imapEncryption;
+      }
+
+      public function setImapEncryption(string $imapEncryption): static
+      {
+          $this->imapEncryption = $imapEncryption;
+
+          return $this;
+      }
+
+      public function getSmtpHost(): ?string
+      {
+          return $this->smtpHost;
+      }
+
+      public function setSmtpHost(?string $smtpHost): static
+      {
+          $this->smtpHost = $smtpHost;
+
+          return $this;
+      }
+
+      public function getSmtpPort(): int
+      {
+          return $this->smtpPort;
+      }
+
+      public function setSmtpPort(int $smtpPort): static
+      {
+          $this->smtpPort = $smtpPort;
+
+          return $this;
+      }
+
+      public function getSmtpEncryption(): string
+      {
+          return $this->smtpEncryption;
+      }
+
+      public function setSmtpEncryption(string $smtpEncryption): static
+      {
+          $this->smtpEncryption = $smtpEncryption;
+
+          return $this;
+      }
+
+      public function getUsername(): ?string
+      {
+          return $this->username;
+      }
+
+      public function setUsername(?string $username): static
+      {
+          $this->username = $username;
+
+          return $this;
+      }
+
+      public function getEncryptedPassword(): ?string
+      {
+          return $this->encryptedPassword;
+      }
+
+      public function setEncryptedPassword(?string $encryptedPassword): static
+      {
+          $this->encryptedPassword = $encryptedPassword;
+
+          return $this;
+      }
+
+      public function getSentFolderPath(): string
+      {
+          return $this->sentFolderPath;
+      }
+
+      public function setSentFolderPath(string $sentFolderPath): static
+      {
+          $this->sentFolderPath = $sentFolderPath;
+
+          return $this;
+      }
+
+      public function isEnabled(): bool
+      {
+          return $this->enabled;
+      }
+
+      public function setEnabled(bool $enabled): static
+      {
+          $this->enabled = $enabled;
+
+          return $this;
+      }
+
+      public function hasPassword(): bool
+      {
+          return null !== $this->encryptedPassword;
+      }
+  }
+  ```
+
+- [ ] **Step 4 : Créer le repository `MailConfigurationRepository`**
+
+  Créer `src/Repository/MailConfigurationRepository.php` :
+
+  ```php
+  <?php
+
+  declare(strict_types=1);
+
+  namespace App\Repository;
+
+  use App\Entity\MailConfiguration;
+  use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
+  use Doctrine\Persistence\ManagerRegistry;
+
+  class MailConfigurationRepository extends ServiceEntityRepository
+  {
+      public function __construct(ManagerRegistry $registry)
+      {
+          parent::__construct($registry, MailConfiguration::class);
+      }
+
+      public function findSingleton(): ?MailConfiguration
+      {
+          return $this->createQueryBuilder('m')
+              ->setMaxResults(1)
+              ->getQuery()
+              ->getOneOrNullResult()
+          ;
+      }
+  }
+  ```
+
+- [ ] **Step 5 : Lancer le test pour vérifier qu'il passe**
+
+  ```bash
+  docker exec php-lesstime-fpm php bin/phpunit tests/Unit/Repository/MailConfigurationRepositoryTest.php 2>&1 | tail -20
+  ```
+
+  Attendu : `OK (2 tests, 2 assertions)`.
+
+  > Note : si le test `testFindSingletonReturnsNullWhenEmpty` échoue car des données persistent entre tests, vérifier que `DAMA\DoctrineTestBundle\Doctrine\DBAL\StaticDriver` est bien configuré dans `config/packages/test/dama_doctrine_test_bundle.yaml`. Si non configuré, ajouter le `@runInSeparateProcess` en dernier recours — mais normalement le projet utilise déjà DAMA.
+
+- [ ] **Step 6 : Commit**
+
+  ```bash
+  make php-cs-fixer-allow-risky
+  git add src/Entity/MailConfiguration.php src/Repository/MailConfigurationRepository.php tests/Unit/Repository/MailConfigurationRepositoryTest.php
+  git commit -m "feat(mail) : MailConfiguration entity + repository + singleton test"
+  ```
+
+---
+
+### Task 3 : Entité `MailFolder` + Repository
+
+- [ ] **Step 1 : Créer l'entité `MailFolder`**
+
+  Créer `src/Entity/MailFolder.php` :
+
+  ```php
+  <?php
+
+  declare(strict_types=1);
+
+  namespace App\Entity;
+
+  use App\Repository\MailFolderRepository;
+  use DateTimeImmutable;
+  use Doctrine\ORM\Mapping as ORM;
+
+  #[ORM\Entity(repositoryClass: MailFolderRepository::class)]
+  #[ORM\Table(name: 'mail_folder')]
+  #[ORM\Index(columns: ['parent_path'], name: 'idx_mail_folder_parent_path')]
+  class MailFolder
+  {
+      #[ORM\Id]
+      #[ORM\GeneratedValue]
+      #[ORM\Column]
+      private ?int $id = null;
+
+      #[ORM\Column(length: 500, unique: true)]
+      private string $path;
+
+      #[ORM\Column(length: 255)]
+      private string $displayName;
+
+      #[ORM\Column(length: 500, nullable: true)]
+      private ?string $parentPath = null;
+
+      #[ORM\Column]
+      private int $unreadCount = 0;
+
+      #[ORM\Column]
+      private int $totalCount = 0;
+
+      #[ORM\Column(type: 'datetimetz_immutable', nullable: true)]
+      private ?DateTimeImmutable $lastSyncedAt = null;
+
+      public function getId(): ?int
+      {
+          return $this->id;
+      }
+
+      public function getPath(): string
+      {
+          return $this->path;
+      }
+
+      public function setPath(string $path): static
+      {
+          $this->path = $path;
+
+          return $this;
+      }
+
+      public function getDisplayName(): string
+      {
+          return $this->displayName;
+      }
+
+      public function setDisplayName(string $displayName): static
+      {
+          $this->displayName = $displayName;
+
+          return $this;
+      }
+
+      public function getParentPath(): ?string
+      {
+          return $this->parentPath;
+      }
+
+      public function setParentPath(?string $parentPath): static
+      {
+          $this->parentPath = $parentPath;
+
+          return $this;
+      }
+
+      public function getUnreadCount(): int
+      {
+          return $this->unreadCount;
+      }
+
+      public function setUnreadCount(int $unreadCount): static
+      {
+          $this->unreadCount = $unreadCount;
+
+          return $this;
+      }
+
+      public function getTotalCount(): int
+      {
+          return $this->totalCount;
+      }
+
+      public function setTotalCount(int $totalCount): static
+      {
+          $this->totalCount = $totalCount;
+
+          return $this;
+      }
+
+      public function getLastSyncedAt(): ?DateTimeImmutable
+      {
+          return $this->lastSyncedAt;
+      }
+
+      public function setLastSyncedAt(?DateTimeImmutable $lastSyncedAt): static
+      {
+          $this->lastSyncedAt = $lastSyncedAt;
+
+          return $this;
+      }
+  }
+  ```
+
+- [ ] **Step 2 : Créer le repository `MailFolderRepository`**
+
+  Créer `src/Repository/MailFolderRepository.php` :
+
+  ```php
+  <?php
+
+  declare(strict_types=1);
+
+  namespace App\Repository;
+
+  use App\Entity\MailFolder;
+  use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
+  use Doctrine\Persistence\ManagerRegistry;
+
+  class MailFolderRepository extends ServiceEntityRepository
+  {
+      public function __construct(ManagerRegistry $registry)
+      {
+          parent::__construct($registry, MailFolder::class);
+      }
+
+      /**
+       * @return list<MailFolder>
+       */
+      public function findAllOrderedByPath(): array
+      {
+          return $this->createQueryBuilder('f')
+              ->orderBy('f.path', 'ASC')
+              ->getQuery()
+              ->getResult()
+          ;
+      }
+
+      public function findByPath(string $path): ?MailFolder
+      {
+          return $this->findOneBy(['path' => $path]);
+      }
+  }
+  ```
+
+- [ ] **Step 3 : Vérifier la syntaxe PHP**
+
+  ```bash
+  docker exec php-lesstime-fpm php -l src/Entity/MailFolder.php
+  docker exec php-lesstime-fpm php -l src/Repository/MailFolderRepository.php
+  ```
+
+  Attendu : `No syntax errors detected`.
+
+- [ ] **Step 4 : Commit**
+
+  ```bash
+  make php-cs-fixer-allow-risky
+  git add src/Entity/MailFolder.php src/Repository/MailFolderRepository.php
+  git commit -m "feat(mail) : MailFolder entity + repository"
+  ```
+
+---
+
+### Task 4 : Entité `MailMessage` + Repository
+
+- [ ] **Step 1 : Créer l'entité `MailMessage`**
+
+  Créer `src/Entity/MailMessage.php` :
+
+  ```php
+  <?php
+
+  declare(strict_types=1);
+
+  namespace App\Entity;
+
+  use App\Repository\MailMessageRepository;
+  use DateTimeImmutable;
+  use Doctrine\ORM\Mapping as ORM;
+
+  #[ORM\Entity(repositoryClass: MailMessageRepository::class)]
+  #[ORM\Table(name: 'mail_message')]
+  #[ORM\UniqueConstraint(name: 'uq_mail_message_folder_uid', columns: ['folder_id', 'uid'])]
+  #[ORM\Index(columns: ['sent_at'], name: 'idx_mail_message_sent_at')]
+  #[ORM\Index(columns: ['is_read'], name: 'idx_mail_message_is_read')]
+  class MailMessage
+  {
+      #[ORM\Id]
+      #[ORM\GeneratedValue]
+      #[ORM\Column]
+      private ?int $id = null;
+
+      #[ORM\Column(length: 500, unique: true)]
+      private string $messageId;
+
+      #[ORM\ManyToOne(targetEntity: MailFolder::class)]
+      #[ORM\JoinColumn(name: 'folder_id', referencedColumnName: 'id', nullable: false, onDelete: 'CASCADE')]
+      private MailFolder $folder;
+
+      #[ORM\Column]
+      private int $uid;
+
+      #[ORM\Column(length: 500, nullable: true)]
+      private ?string $subject = null;
+
+      #[ORM\Column(length: 255)]
+      private string $fromAddress;
+
+      #[ORM\Column(length: 255, nullable: true)]
+      private ?string $fromName = null;
+
+      #[ORM\Column(type: 'json')]
+      private array $toAddresses = [];
+
+      #[ORM\Column(type: 'json', nullable: true)]
+      private ?array $ccAddresses = null;
+
+      #[ORM\Column(type: 'datetimetz_immutable')]
+      private DateTimeImmutable $sentAt;
+
+      #[ORM\Column(type: 'boolean')]
+      private bool $isRead = false;
+
+      #[ORM\Column(type: 'boolean')]
+      private bool $isFlagged = false;
+
+      #[ORM\Column(type: 'boolean')]
+      private bool $hasAttachments = false;
+
+      #[ORM\Column(type: 'text', nullable: true)]
+      private ?string $snippet = null;
+
+      #[ORM\Column(type: 'datetimetz_immutable')]
+      private DateTimeImmutable $syncedAt;
+
+      public function getId(): ?int
+      {
+          return $this->id;
+      }
+
+      public function getMessageId(): string
+      {
+          return $this->messageId;
+      }
+
+      public function setMessageId(string $messageId): static
+      {
+          $this->messageId = $messageId;
+
+          return $this;
+      }
+
+      public function getFolder(): MailFolder
+      {
+          return $this->folder;
+      }
+
+      public function setFolder(MailFolder $folder): static
+      {
+          $this->folder = $folder;
+
+          return $this;
+      }
+
+      public function getUid(): int
+      {
+          return $this->uid;
+      }
+
+      public function setUid(int $uid): static
+      {
+          $this->uid = $uid;
+
+          return $this;
+      }
+
+      public function getSubject(): ?string
+      {
+          return $this->subject;
+      }
+
+      public function setSubject(?string $subject): static
+      {
+          $this->subject = $subject;
+
+          return $this;
+      }
+
+      public function getFromAddress(): string
+      {
+          return $this->fromAddress;
+      }
+
+      public function setFromAddress(string $fromAddress): static
+      {
+          $this->fromAddress = $fromAddress;
+
+          return $this;
+      }
+
+      public function getFromName(): ?string
+      {
+          return $this->fromName;
+      }
+
+      public function setFromName(?string $fromName): static
+      {
+          $this->fromName = $fromName;
+
+          return $this;
+      }
+
+      public function getToAddresses(): array
+      {
+          return $this->toAddresses;
+      }
+
+      public function setToAddresses(array $toAddresses): static
+      {
+          $this->toAddresses = $toAddresses;
+
+          return $this;
+      }
+
+      public function getCcAddresses(): ?array
+      {
+          return $this->ccAddresses;
+      }
+
+      public function setCcAddresses(?array $ccAddresses): static
+      {
+          $this->ccAddresses = $ccAddresses;
+
+          return $this;
+      }
+
+      public function getSentAt(): DateTimeImmutable
+      {
+          return $this->sentAt;
+      }
+
+      public function setSentAt(DateTimeImmutable $sentAt): static
+      {
+          $this->sentAt = $sentAt;
+
+          return $this;
+      }
+
+      public function isRead(): bool
+      {
+          return $this->isRead;
+      }
+
+      public function setIsRead(bool $isRead): static
+      {
+          $this->isRead = $isRead;
+
+          return $this;
+      }
+
+      public function isFlagged(): bool
+      {
+          return $this->isFlagged;
+      }
+
+      public function setIsFlagged(bool $isFlagged): static
+      {
+          $this->isFlagged = $isFlagged;
+
+          return $this;
+      }
+
+      public function hasAttachments(): bool
+      {
+          return $this->hasAttachments;
+      }
+
+      public function setHasAttachments(bool $hasAttachments): static
+      {
+          $this->hasAttachments = $hasAttachments;
+
+          return $this;
+      }
+
+      public function getSnippet(): ?string
+      {
+          return $this->snippet;
+      }
+
+      public function setSnippet(?string $snippet): static
+      {
+          $this->snippet = $snippet;
+
+          return $this;
+      }
+
+      public function getSyncedAt(): DateTimeImmutable
+      {
+          return $this->syncedAt;
+      }
+
+      public function setSyncedAt(DateTimeImmutable $syncedAt): static
+      {
+          $this->syncedAt = $syncedAt;
+
+          return $this;
+      }
+  }
+  ```
+
+- [ ] **Step 2 : Créer le repository `MailMessageRepository`**
+
+  Créer `src/Repository/MailMessageRepository.php` :
+
+  ```php
+  <?php
+
+  declare(strict_types=1);
+
+  namespace App\Repository;
+
+  use App\Entity\MailFolder;
+  use App\Entity\MailMessage;
+  use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
+  use Doctrine\Persistence\ManagerRegistry;
+
+  class MailMessageRepository extends ServiceEntityRepository
+  {
+      public function __construct(ManagerRegistry $registry)
+      {
+          parent::__construct($registry, MailMessage::class);
+      }
+
+      public function findByMessageId(string $messageId): ?MailMessage
+      {
+          return $this->findOneBy(['messageId' => $messageId]);
+      }
+
+      public function findByFolderAndUid(MailFolder $folder, int $uid): ?MailMessage
+      {
+          return $this->findOneBy(['folder' => $folder, 'uid' => $uid]);
+      }
+
+      /**
+       * @return list<MailMessage>
+       */
+      public function findByFolderPaginated(MailFolder $folder, int $limit, int $offset): array
+      {
+          return $this->createQueryBuilder('m')
+              ->andWhere('m.folder = :folder')
+              ->setParameter('folder', $folder)
+              ->orderBy('m.sentAt', 'DESC')
+              ->addOrderBy('m.id', 'DESC')
+              ->setMaxResults($limit)
+              ->setFirstResult($offset)
+              ->getQuery()
+              ->getResult()
+          ;
+      }
+
+      public function countUnreadByFolder(MailFolder $folder): int
+      {
+          return (int) $this->createQueryBuilder('m')
+              ->select('COUNT(m.id)')
+              ->andWhere('m.folder = :folder')
+              ->andWhere('m.isRead = false')
+              ->setParameter('folder', $folder)
+              ->getQuery()
+              ->getSingleScalarResult()
+          ;
+      }
+  }
+  ```
+
+- [ ] **Step 3 : Vérifier la syntaxe PHP**
+
+  ```bash
+  docker exec php-lesstime-fpm php -l src/Entity/MailMessage.php
+  docker exec php-lesstime-fpm php -l src/Repository/MailMessageRepository.php
+  ```
+
+  Attendu : `No syntax errors detected`.
+
+- [ ] **Step 4 : Commit**
+
+  ```bash
+  make php-cs-fixer-allow-risky
+  git add src/Entity/MailMessage.php src/Repository/MailMessageRepository.php
+  git commit -m "feat(mail) : MailMessage entity + repository"
+  ```
+
+---
+
+### Task 5 : Entité `TaskMailLink` + Repository
+
+- [ ] **Step 1 : Créer l'entité `TaskMailLink`**
+
+  Créer `src/Entity/TaskMailLink.php` :
+
+  ```php
+  <?php
+
+  declare(strict_types=1);
+
+  namespace App\Entity;
+
+  use App\Repository\TaskMailLinkRepository;
+  use DateTimeImmutable;
+  use Doctrine\ORM\Mapping as ORM;
+
+  #[ORM\Entity(repositoryClass: TaskMailLinkRepository::class)]
+  #[ORM\Table(name: 'task_mail_link')]
+  #[ORM\UniqueConstraint(name: 'uq_task_mail_link', columns: ['task_id', 'mail_message_id'])]
+  class TaskMailLink
+  {
+      #[ORM\Id]
+      #[ORM\GeneratedValue]
+      #[ORM\Column]
+      private ?int $id = null;
+
+      #[ORM\ManyToOne(targetEntity: Task::class)]
+      #[ORM\JoinColumn(name: 'task_id', referencedColumnName: 'id', nullable: false, onDelete: 'CASCADE')]
+      private Task $task;
+
+      #[ORM\ManyToOne(targetEntity: MailMessage::class)]
+      #[ORM\JoinColumn(name: 'mail_message_id', referencedColumnName: 'id', nullable: false, onDelete: 'CASCADE')]
+      private MailMessage $mailMessage;
+
+      #[ORM\Column(type: 'datetimetz_immutable')]
+      private DateTimeImmutable $linkedAt;
+
+      #[ORM\ManyToOne(targetEntity: User::class)]
+      #[ORM\JoinColumn(name: 'linked_by_id', referencedColumnName: 'id', nullable: true, onDelete: 'SET NULL')]
+      private ?User $linkedBy = null;
+
+      public function getId(): ?int
+      {
+          return $this->id;
+      }
+
+      public function getTask(): Task
+      {
+          return $this->task;
+      }
+
+      public function setTask(Task $task): static
+      {
+          $this->task = $task;
+
+          return $this;
+      }
+
+      public function getMailMessage(): MailMessage
+      {
+          return $this->mailMessage;
+      }
+
+      public function setMailMessage(MailMessage $mailMessage): static
+      {
+          $this->mailMessage = $mailMessage;
+
+          return $this;
+      }
+
+      public function getLinkedAt(): DateTimeImmutable
+      {
+          return $this->linkedAt;
+      }
+
+      public function setLinkedAt(DateTimeImmutable $linkedAt): static
+      {
+          $this->linkedAt = $linkedAt;
+
+          return $this;
+      }
+
+      public function getLinkedBy(): ?User
+      {
+          return $this->linkedBy;
+      }
+
+      public function setLinkedBy(?User $linkedBy): static
+      {
+          $this->linkedBy = $linkedBy;
+
+          return $this;
+      }
+  }
+  ```
+
+- [ ] **Step 2 : Créer le repository `TaskMailLinkRepository`**
+
+  Créer `src/Repository/TaskMailLinkRepository.php` :
+
+  ```php
+  <?php
+
+  declare(strict_types=1);
+
+  namespace App\Repository;
+
+  use App\Entity\MailMessage;
+  use App\Entity\Task;
+  use App\Entity\TaskMailLink;
+  use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
+  use Doctrine\Persistence\ManagerRegistry;
+
+  class TaskMailLinkRepository extends ServiceEntityRepository
+  {
+      public function __construct(ManagerRegistry $registry)
+      {
+          parent::__construct($registry, TaskMailLink::class);
+      }
+
+      /**
+       * @return list<TaskMailLink>
+       */
+      public function findByTask(Task $task): array
+      {
+          return $this->createQueryBuilder('l')
+              ->andWhere('l.task = :task')
+              ->setParameter('task', $task)
+              ->orderBy('l.linkedAt', 'DESC')
+              ->getQuery()
+              ->getResult()
+          ;
+      }
+
+      public function findByTaskAndMessage(Task $task, MailMessage $message): ?TaskMailLink
+      {
+          return $this->findOneBy(['task' => $task, 'mailMessage' => $message]);
+      }
+
+      /**
+       * @return list<TaskMailLink>
+       */
+      public function findByMessage(MailMessage $message): array
+      {
+          return $this->findBy(['mailMessage' => $message]);
+      }
+  }
+  ```
+
+- [ ] **Step 3 : Vérifier la syntaxe PHP**
+
+  ```bash
+  docker exec php-lesstime-fpm php -l src/Entity/TaskMailLink.php
+  docker exec php-lesstime-fpm php -l src/Repository/TaskMailLinkRepository.php
+  ```
+
+  Attendu : `No syntax errors detected`.
+
+- [ ] **Step 4 : Commit**
+
+  ```bash
+  make php-cs-fixer-allow-risky
+  git add src/Entity/TaskMailLink.php src/Repository/TaskMailLinkRepository.php
+  git commit -m "feat(mail) : TaskMailLink entity + repository"
+  ```
+
+---
+
+### Task 6 : Migration Doctrine unique (raw SQL, 4 tables + FK + index)
+
+- [ ] **Step 1 : Générer le squelette de migration vide**
+
+  ```bash
+  docker exec php-lesstime-fpm php bin/console doctrine:migrations:generate
+  ```
+
+  Cela crée `migrations/Version<timestamp>.php`. Relever le nom exact du fichier créé (ex. `Version20260519120000.php`).
+
+- [ ] **Step 2 : Écrire le SQL UP complet dans la migration générée**
+
+  Ouvrir le fichier `migrations/Version<timestamp>.php` et remplacer les méthodes `up()` et `down()` par :
+
+  ```php
+  public function getDescription(): string
+  {
+      return 'Mail integration: create mail_configuration, mail_folder, mail_message, task_mail_link tables';
+  }
+
+  public function up(Schema $schema): void
+  {
+      $this->addSql(<<<'SQL'
+          CREATE TABLE mail_configuration (
+              id SERIAL NOT NULL,
+              protocol VARCHAR(10) NOT NULL DEFAULT 'imap',
+              imap_host VARCHAR(255) DEFAULT NULL,
+              imap_port INT NOT NULL DEFAULT 993,
+              imap_encryption VARCHAR(10) NOT NULL DEFAULT 'ssl',
+              smtp_host VARCHAR(255) DEFAULT NULL,
+              smtp_port INT NOT NULL DEFAULT 465,
+              smtp_encryption VARCHAR(10) NOT NULL DEFAULT 'ssl',
+              username VARCHAR(255) DEFAULT NULL,
+              encrypted_password TEXT DEFAULT NULL,
+              sent_folder_path VARCHAR(255) NOT NULL DEFAULT 'Sent',
+              enabled BOOLEAN NOT NULL DEFAULT false,
+              PRIMARY KEY (id)
+          )
+      SQL);
+
+      $this->addSql(<<<'SQL'
+          CREATE TABLE mail_folder (
+              id SERIAL NOT NULL,
+              path VARCHAR(500) NOT NULL,
+              display_name VARCHAR(255) NOT NULL,
+              parent_path VARCHAR(500) DEFAULT NULL,
+              unread_count INT NOT NULL DEFAULT 0,
+              total_count INT NOT NULL DEFAULT 0,
+              last_synced_at TIMESTAMPTZ DEFAULT NULL,
+              PRIMARY KEY (id)
+          )
+      SQL);
+
+      $this->addSql('CREATE UNIQUE INDEX uq_mail_folder_path ON mail_folder (path)');
+      $this->addSql('CREATE INDEX idx_mail_folder_parent_path ON mail_folder (parent_path)');
+
+      $this->addSql(<<<'SQL'
+          CREATE TABLE mail_message (
+              id SERIAL NOT NULL,
+              message_id VARCHAR(500) NOT NULL,
+              folder_id INT NOT NULL,
+              uid INT NOT NULL,
+              subject VARCHAR(500) DEFAULT NULL,
+              from_address VARCHAR(255) NOT NULL,
+              from_name VARCHAR(255) DEFAULT NULL,
+              to_addresses JSONB NOT NULL,
+              cc_addresses JSONB DEFAULT NULL,
+              sent_at TIMESTAMPTZ NOT NULL,
+              is_read BOOLEAN NOT NULL DEFAULT false,
+              is_flagged BOOLEAN NOT NULL DEFAULT false,
+              has_attachments BOOLEAN NOT NULL DEFAULT false,
+              snippet TEXT DEFAULT NULL,
+              synced_at TIMESTAMPTZ NOT NULL,
+              PRIMARY KEY (id)
+          )
+      SQL);
+
+      $this->addSql('CREATE UNIQUE INDEX uq_mail_message_message_id ON mail_message (message_id)');
+      $this->addSql('CREATE UNIQUE INDEX uq_mail_message_folder_uid ON mail_message (folder_id, uid)');
+      $this->addSql('CREATE INDEX idx_mail_message_sent_at ON mail_message (sent_at)');
+      $this->addSql('CREATE INDEX idx_mail_message_is_read ON mail_message (is_read)');
+      $this->addSql('ALTER TABLE mail_message ADD CONSTRAINT fk_mail_message_folder FOREIGN KEY (folder_id) REFERENCES mail_folder (id) ON DELETE CASCADE NOT DEFERRABLE INITIALLY IMMEDIATE');
+
+      $this->addSql(<<<'SQL'
+          CREATE TABLE task_mail_link (
+              id SERIAL NOT NULL,
+              task_id INT NOT NULL,
+              mail_message_id INT NOT NULL,
+              linked_at TIMESTAMPTZ NOT NULL,
+              linked_by_id INT DEFAULT NULL,
+              PRIMARY KEY (id)
+          )
+      SQL);
+
+      $this->addSql('CREATE UNIQUE INDEX uq_task_mail_link ON task_mail_link (task_id, mail_message_id)');
+      $this->addSql('CREATE INDEX idx_task_mail_link_task ON task_mail_link (task_id)');
+      $this->addSql('CREATE INDEX idx_task_mail_link_message ON task_mail_link (mail_message_id)');
+      $this->addSql('ALTER TABLE task_mail_link ADD CONSTRAINT fk_task_mail_link_task FOREIGN KEY (task_id) REFERENCES task (id) ON DELETE CASCADE NOT DEFERRABLE INITIALLY IMMEDIATE');
+      $this->addSql('ALTER TABLE task_mail_link ADD CONSTRAINT fk_task_mail_link_message FOREIGN KEY (mail_message_id) REFERENCES mail_message (id) ON DELETE CASCADE NOT DEFERRABLE INITIALLY IMMEDIATE');
+      $this->addSql('ALTER TABLE task_mail_link ADD CONSTRAINT fk_task_mail_link_user FOREIGN KEY (linked_by_id) REFERENCES "user" (id) ON DELETE SET NULL NOT DEFERRABLE INITIALLY IMMEDIATE');
+  }
+
+  public function down(Schema $schema): void
+  {
+      $this->addSql('ALTER TABLE task_mail_link DROP CONSTRAINT fk_task_mail_link_task');
+      $this->addSql('ALTER TABLE task_mail_link DROP CONSTRAINT fk_task_mail_link_message');
+      $this->addSql('ALTER TABLE task_mail_link DROP CONSTRAINT fk_task_mail_link_user');
+      $this->addSql('DROP TABLE task_mail_link');
+
+      $this->addSql('ALTER TABLE mail_message DROP CONSTRAINT fk_mail_message_folder');
+      $this->addSql('DROP TABLE mail_message');
+
+      $this->addSql('DROP TABLE mail_folder');
+
+      $this->addSql('DROP TABLE mail_configuration');
+  }
+  ```
+
+  > Attention : `declare(strict_types=1);` doit être présent en tête du fichier (il est présent dans le squelette généré par Doctrine).
+
+- [ ] **Step 3 : Lancer la migration**
+
+  ```bash
+  make migration-migrate
+  ```
+
+  Attendu : migration exécutée sans erreur SQL.
+
+- [ ] **Step 4 : Valider le schéma Doctrine**
+
+  ```bash
+  docker exec php-lesstime-fpm php bin/console doctrine:schema:validate
+  ```
+
+  Attendu : `[Mapping]  OK - The mapping files are correct.` et `[Database] OK - The database schema is in sync with the mapping files.`
+
+  > Si des différences sont signalées (ex. type `json` vs `jsonb`), ajuster l'attribut `#[ORM\Column(type: 'json')]` en `#[ORM\Column(type: 'jsonb')]` dans `MailMessage.php` si le mapping Doctrine du projet est configuré pour `jsonb`. Dans le doute, `json` est le type Doctrine standard et PostgreSQL accepte les deux.
+
+- [ ] **Step 5 : Commit**
+
+  ```bash
+  make php-cs-fixer-allow-risky
+  git add migrations/
+  git commit -m "feat(mail) : migration — 4 tables mail_configuration, mail_folder, mail_message, task_mail_link"
+  ```
+
+---
+
+### Task 7 : DTOs (4 fichiers sous `src/Mail/Dto/`)
+
+- [ ] **Step 1 : Créer `MailFolderDto`**
+
+  Créer `src/Mail/Dto/MailFolderDto.php` :
+
+  ```php
+  <?php
+
+  declare(strict_types=1);
+
+  namespace App\Mail\Dto;
+
+  final readonly class MailFolderDto
+  {
+      public function __construct(
+          public string $path,
+          public string $displayName,
+          public ?string $parentPath,
+          public int $unreadCount,
+          public int $totalCount,
+      ) {}
+  }
+  ```
+
+- [ ] **Step 2 : Créer `MailMessageHeaderDto`**
+
+  Créer `src/Mail/Dto/MailMessageHeaderDto.php` :
+
+  ```php
+  <?php
+
+  declare(strict_types=1);
+
+  namespace App\Mail\Dto;
+
+  use DateTimeImmutable;
+
+  final readonly class MailMessageHeaderDto
+  {
+      public function __construct(
+          public int $uid,
+          public string $messageId,
+          public ?string $subject,
+          public string $fromAddress,
+          public ?string $fromName,
+          public array $toAddresses,
+          public ?array $ccAddresses,
+          public DateTimeImmutable $sentAt,
+          public bool $isRead,
+          public bool $isFlagged,
+          public bool $hasAttachments,
+          public ?string $snippet,
+      ) {}
+  }
+  ```
+
+- [ ] **Step 3 : Créer `MailAttachmentDto`**
+
+  Créer `src/Mail/Dto/MailAttachmentDto.php` :
+
+  ```php
+  <?php
+
+  declare(strict_types=1);
+
+  namespace App\Mail\Dto;
+
+  final readonly class MailAttachmentDto
+  {
+      public function __construct(
+          public string $partNumber,
+          public string $filename,
+          public string $mimeType,
+          public int $size,
+      ) {}
+  }
+  ```
+
+- [ ] **Step 4 : Créer `MailMessageDetailDto`**
+
+  Créer `src/Mail/Dto/MailMessageDetailDto.php` :
+
+  ```php
+  <?php
+
+  declare(strict_types=1);
+
+  namespace App\Mail\Dto;
+
+  final readonly class MailMessageDetailDto
+  {
+      /**
+       * @param list<MailAttachmentDto> $attachments
+       */
+      public function __construct(
+          public MailMessageHeaderDto $header,
+          public ?string $bodyHtml,
+          public ?string $bodyText,
+          public array $attachments,
+      ) {}
+  }
+  ```
+
+- [ ] **Step 5 : Vérifier la syntaxe des 4 DTOs**
+
+  ```bash
+  docker exec php-lesstime-fpm php -l src/Mail/Dto/MailFolderDto.php
+  docker exec php-lesstime-fpm php -l src/Mail/Dto/MailMessageHeaderDto.php
+  docker exec php-lesstime-fpm php -l src/Mail/Dto/MailAttachmentDto.php
+  docker exec php-lesstime-fpm php -l src/Mail/Dto/MailMessageDetailDto.php
+  ```
+
+  Attendu : `No syntax errors detected` pour chacun.
+
+- [ ] **Step 6 : Commit**
+
+  ```bash
+  make php-cs-fixer-allow-risky
+  git add src/Mail/Dto/
+  git commit -m "feat(mail) : DTOs — MailFolderDto, MailMessageHeaderDto, MailAttachmentDto, MailMessageDetailDto"
+  ```
+
+---
+
+### Task 8 : Interface `MailProviderInterface` + Exception `MailProviderException`
+
+- [ ] **Step 1 : Créer `MailProviderException`**
+
+  Créer `src/Mail/Exception/MailProviderException.php` :
+
+  ```php
+  <?php
+
+  declare(strict_types=1);
+
+  namespace App\Mail\Exception;
+
+  use RuntimeException;
+
+  final class MailProviderException extends RuntimeException
+  {
+      public static function connectionFailed(string $reason): self
+      {
+          return new self(sprintf('Mail provider connection failed: %s', $reason));
+      }
+
+      public static function operationFailed(string $operation, string $reason): self
+      {
+          return new self(sprintf('Mail provider operation "%s" failed: %s', $operation, $reason));
+      }
+  }
+  ```
+
+- [ ] **Step 2 : Créer `MailProviderInterface`**
+
+  Créer `src/Mail/MailProviderInterface.php` :
+
+  ```php
+  <?php
+
+  declare(strict_types=1);
+
+  namespace App\Mail;
+
+  use App\Mail\Dto\MailAttachmentDto;
+  use App\Mail\Dto\MailFolderDto;
+  use App\Mail\Dto\MailMessageDetailDto;
+  use App\Mail\Dto\MailMessageHeaderDto;
+  use App\Mail\Exception\MailProviderException;
+
+  interface MailProviderInterface
+  {
+      /**
+       * Returns the full folder tree of the configured mailbox.
+       *
+       * @return list<MailFolderDto>
+       *
+       * @throws MailProviderException
+       */
+      public function listFolders(): array;
+
+      /**
+       * Returns a paginated list of message headers for the given folder.
+       *
+       * @return list<MailMessageHeaderDto>
+       *
+       * @throws MailProviderException
+       */
+      public function listMessages(string $folderPath, int $limit, int $offset): array;
+
+      /**
+       * Fetches the full message (headers + body + attachments list) by UID.
+       *
+       * @throws MailProviderException
+       */
+      public function fetchMessage(string $folderPath, int $uid): MailMessageDetailDto;
+
+      /**
+       * Marks a message as read or unread on the IMAP server.
+       *
+       * @throws MailProviderException
+       */
+      public function markRead(string $folderPath, int $uid, bool $read): void;
+
+      /**
+       * Marks a message as flagged (starred) or unflagged on the IMAP server.
+       *
+       * @throws MailProviderException
+       */
+      public function markFlagged(string $folderPath, int $uid, bool $flagged): void;
+
+      /**
+       * Moves a message from one folder to another on the IMAP server.
+       *
+       * @throws MailProviderException
+       */
+      public function moveMessage(string $folderPath, int $uid, string $targetFolder): void;
+
+      /**
+       * Fetches the raw binary content of an attachment by its MIME part number.
+       *
+       * @throws MailProviderException
+       */
+      public function fetchAttachment(string $folderPath, int $uid, string $partNumber): string;
+  }
+  ```
+
+- [ ] **Step 3 : Vérifier la syntaxe**
+
+  ```bash
+  docker exec php-lesstime-fpm php -l src/Mail/Exception/MailProviderException.php
+  docker exec php-lesstime-fpm php -l src/Mail/MailProviderInterface.php
+  ```
+
+  Attendu : `No syntax errors detected`.
+
+- [ ] **Step 4 : Commit**
+
+  ```bash
+  make php-cs-fixer-allow-risky
+  git add src/Mail/MailProviderInterface.php src/Mail/Exception/MailProviderException.php
+  git commit -m "feat(mail) : MailProviderInterface + MailProviderException"
+  ```
+
+---
+
+### Task 9 : Fixture `MailConfiguration` désactivée (OVH defaults)
+
+- [ ] **Step 1 : Modifier `AppFixtures.php`**
+
+  Ouvrir `src/DataFixtures/AppFixtures.php`.
+
+  Ajouter l'import en tête du bloc `use` (après `use App\Entity\ZimbraConfiguration;`) :
+
+  ```php
+  use App\Entity\MailConfiguration;
+  ```
+
+  Puis ajouter le bloc fixture juste **avant** `$manager->flush();` (après le bloc TaskRecurrence existant) :
+
+  ```php
+  // =============================================
+  // Mail Configuration
+  // =============================================
+  $mailConfig = new MailConfiguration();
+  $mailConfig->setImapHost('ssl0.ovh.net');
+  $mailConfig->setImapPort(993);
+  $mailConfig->setImapEncryption('ssl');
+  $mailConfig->setSmtpHost('ssl0.ovh.net');
+  $mailConfig->setSmtpPort(465);
+  $mailConfig->setSmtpEncryption('ssl');
+  $mailConfig->setUsername('lesstime@ovh.fr');
+  $mailConfig->setSentFolderPath('Sent');
+  $mailConfig->setEnabled(false);
+  $manager->persist($mailConfig);
+  ```
+
+- [ ] **Step 2 : Vérifier la syntaxe**
+
+  ```bash
+  docker exec php-lesstime-fpm php -l src/DataFixtures/AppFixtures.php
+  ```
+
+  Attendu : `No syntax errors detected`.
+
+- [ ] **Step 3 : Charger les fixtures pour valider**
+
+  ```bash
+  make fixtures
+  ```
+
+  Attendu : pas d'erreur. Vérifier en BDD :
+
+  ```bash
+  docker exec php-lesstime-fpm php bin/console dbal:run-sql "SELECT id, imap_host, smtp_host, enabled FROM mail_configuration"
+  ```
+
+  Attendu : une ligne avec `ssl0.ovh.net`, `ssl0.ovh.net`, `f`.
+
+- [ ] **Step 4 : Commit**
+
+  ```bash
+  make php-cs-fixer-allow-risky
+  git add src/DataFixtures/AppFixtures.php
+  git commit -m "feat(mail) : fixture MailConfiguration OVH defaults (disabled)"
+  ```
+
+---
+
+### Task 10 : Validation finale
+
+- [ ] **Step 1 : Valider le mapping Doctrine**
+
+  ```bash
+  docker exec php-lesstime-fpm php bin/console doctrine:schema:validate
+  ```
+
+  Attendu :
+  ```
+  [Mapping]  OK - The mapping files are correct.
+  [Database] OK - The database schema is in sync with the mapping files.
+  ```
+
+  Si des erreurs apparaissent, les corriger (type mismatch `json` vs `jsonb`, colonnes manquantes, etc.) avant de continuer.
+
+- [ ] **Step 2 : Lancer la suite de tests complète**
+
+  ```bash
+  make test
+  ```
+
+  Attendu : tous les tests passent (au minimum les 2 tests `MailConfigurationRepositoryTest`).
+
+- [ ] **Step 3 : PHP CS Fixer sur l'ensemble des fichiers modifiés**
+
+  ```bash
+  make php-cs-fixer-allow-risky
+  ```
+
+  Si des fichiers sont modifiés par le fixer, les re-stageer et committer :
+
+  ```bash
+  git add -p
+  git commit -m "style(mail) : php-cs-fixer pass"
+  ```
+
+- [ ] **Step 4 : Vider le cache Symfony**
+
+  ```bash
+  make cache-clear
+  ```
+
+  Attendu : pas d'erreur de configuration ou de service manquant.
+
+- [ ] **Step 5 : Vérification rapide du conteneur de services**
+
+  ```bash
+  docker exec php-lesstime-fpm php bin/console debug:autowiring MailConfiguration 2>&1 | head -20
+  ```
+
+  Attendu : `App\Repository\MailConfigurationRepository` apparaît dans la liste des services autowirables.
+
+- [ ] **Step 6 : Résumé des commits de la phase**
+
+  Vérifier l'historique :
+
+  ```bash
+  git log --oneline feat/mail-integration ^develop | head -20
+  ```
+
+  Les commits attendus (dans l'ordre chronologique) :
+  1. `feat(mail) : MailConfiguration entity + repository + singleton test`
+  2. `feat(mail) : MailFolder entity + repository`
+  3. `feat(mail) : MailMessage entity + repository`
+  4. `feat(mail) : TaskMailLink entity + repository`
+  5. `feat(mail) : migration — 4 tables mail_configuration, mail_folder, mail_message, task_mail_link`
+  6. `feat(mail) : DTOs — MailFolderDto, MailMessageHeaderDto, MailAttachmentDto, MailMessageDetailDto`
+  7. `feat(mail) : MailProviderInterface + MailProviderException`
+  8. `feat(mail) : fixture MailConfiguration OVH defaults (disabled)`
+
+---
+
+### Self-Review
+
+#### Cohérence des noms
+
+| Concept | Classe PHP | Table SQL | Repository |
+|---|---|---|---|
+| Configuration singleton | `MailConfiguration` | `mail_configuration` | `MailConfigurationRepository` |
+| Cache dossiers IMAP | `MailFolder` | `mail_folder` | `MailFolderRepository` |
+| Cache messages IMAP | `MailMessage` | `mail_message` | `MailMessageRepository` |
+| Lien tâche ↔ mail | `TaskMailLink` | `task_mail_link` | `TaskMailLinkRepository` |
+| DTO dossier | `MailFolderDto` | — | — |
+| DTO header message | `MailMessageHeaderDto` | — | — |
+| DTO pièce jointe | `MailAttachmentDto` | — | — |
+| DTO message complet | `MailMessageDetailDto` | — | — |
+| Interface provider | `MailProviderInterface` | — | — |
+| Exception provider | `MailProviderException` | — | — |
+
+#### Checklist finale avant de valider Phase 1
+
+- [ ] `declare(strict_types=1);` présent en tête de chaque fichier PHP créé
+- [ ] Toutes les FK définies avec `ON DELETE CASCADE` (sauf `task_mail_link.linked_by_id` → `ON DELETE SET NULL`)
+- [ ] `UNIQUE INDEX` sur `mail_folder.path`, `mail_message.message_id`, `(mail_message.folder_id, mail_message.uid)`, `(task_mail_link.task_id, task_mail_link.mail_message_id)`
+- [ ] `INDEX` sur `mail_folder.parent_path`, `mail_message.sent_at`, `mail_message.is_read`
+- [ ] Table `"user"` entre guillemets dans le SQL de la migration (réservé PostgreSQL)
+- [ ] `MailConfiguration.encryptedPassword` est `null` par défaut en fixture (pas de mot de passe en clair)
+- [ ] DTOs déclarés `final readonly class` (PHP 8.2+)
+- [ ] `MailProviderInterface` contient exactement 7 méthodes : `listFolders`, `listMessages`, `fetchMessage`, `markRead`, `markFlagged`, `moveMessage`, `fetchAttachment`
+- [ ] `make test` vert (2 tests minimum)
+- [ ] `doctrine:schema:validate` OK
+- [ ] Aucune logique métier IMAP implémentée (Phase 2)
+- [ ] `feat/mail-integration` est la branche de travail (pas `develop`)
+
+#### Remise à la review humaine
+
+Une fois tous les steps cochés, pousser la branche et notifier le user :
+
+```bash
+git push -u origin feat/mail-integration
+```
+
+Indiquer au user :
+- Nombre de fichiers créés : 17
+- Tables créées : 4 (`mail_configuration`, `mail_folder`, `mail_message`, `task_mail_link`)
+- Tests : 2 (MailConfigurationRepositoryTest)
+- Prêt pour Phase 2 : IMAP provider + MailSyncService