diff --git a/docs/superpowers/plans/2026-03-12-contract-suspension.md b/docs/superpowers/plans/2026-03-12-contract-suspension.md
new file mode 100644
index 0000000..81bfeab
--- /dev/null
+++ b/docs/superpowers/plans/2026-03-12-contract-suspension.md
@@ -0,0 +1,1550 @@
+# Contract Suspension Implementation Plan
+
+> **For agentic workers:** REQUIRED: Use superpowers:subagent-driven-development (if subagents available) or superpowers:executing-plans to implement this plan. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Allow suspending employee contracts, with multiple suspensions per contract period. Suspensions reduce accruing leave days (CDI/CDD non forfait) and acquired days (forfait 218) prorata.
+
+**Architecture:** New `ContractSuspension` entity (OneToMany from `EmployeeContractPeriod`). Dedicated API endpoint for CRUD. Leave calculation modified in both `EmployeeLeaveSummaryProvider` (live display) and `LeaveBalanceComputationService` (rollover). Frontend drawer gets tabbed UI with Clôturer/Suspendre.
+
+**Tech Stack:** Symfony + API Platform + Doctrine (backend), Nuxt 4 + Vue 3 + TypeScript (frontend)
+
+**Spec:** `docs/superpowers/specs/2026-03-12-contract-suspension-design.md`
+
+**No commits, no pushes — user handles git.**
+
+---
+
+## File Structure
+
+| File | Action | Responsibility |
+|------|--------|----------------|
+| `src/Entity/ContractSuspension.php` | Create | New entity with startDate, endDate, comment |
+| `src/Repository/ContractSuspensionRepository.php` | Create | Repository for ContractSuspension |
+| `src/Entity/EmployeeContractPeriod.php` | Modify | Add OneToMany relation to suspensions |
+| `migrations/Version20260312140000.php` | Create | Create contract_suspensions table |
+| `src/State/ContractSuspensionWriteProcessor.php` | Create | Custom processor: validation + persistence |
+| `tests/State/ContractSuspensionWriteProcessorTest.php` | Create | Tests for suspension processor |
+| `src/Dto/Employees/ContractHistoryItem.php` | Modify | Add periodId + suspensions array |
+| `src/Entity/Employee.php` | Modify | Add getContractPeriods(), getCurrentSuspensions() |
+| `src/Service/Leave/SuspensionDaysCalculator.php` | Create | Extract suspension day counting logic (shared) |
+| `tests/Service/Leave/SuspensionDaysCalculatorTest.php` | Create | Tests for suspension calculator |
+| `src/State/EmployeeLeaveSummaryProvider.php` | Modify | Use SuspensionDaysCalculator in accrual + forfait |
+| `src/Service/Leave/LeaveBalanceComputationService.php` | Modify | Use SuspensionDaysCalculator in accrual + forfait |
+| `tests/State/EmployeeLeaveSummaryProviderTest.php` | Modify | Test suspension impact on leave |
+| `frontend/services/dto/employee.ts` | Modify | Add ContractSuspension type and fields |
+| `frontend/services/contractSuspensions.ts` | Create | API service for suspension CRUD |
+| `frontend/components/employees/ContractTab.vue` | Modify | Tabbed drawer (Clôturer/Suspendre) |
+| `frontend/composables/useEmployeeDetailPage.ts` | Modify | Suspension form state + submit logic |
+
+---
+
+## Chunk 1: Entity, Migration, Repository
+
+### Task 1: ContractSuspension Entity
+
+**Files:**
+- Create: `src/Entity/ContractSuspension.php`
+- Create: `src/Repository/ContractSuspensionRepository.php`
+
+- [ ] **Step 1: Create the repository**
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Repository;
+
+use App\Entity\ContractSuspension;
+use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
+use Doctrine\Persistence\ManagerRegistry;
+
+/**
+ * @extends ServiceEntityRepository<ContractSuspension>
+ */
+class ContractSuspensionRepository extends ServiceEntityRepository
+{
+    public function __construct(ManagerRegistry $registry)
+    {
+        parent::__construct($registry, ContractSuspension::class);
+    }
+}
+```
+
+- [ ] **Step 2: Create the entity**
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Entity;
+
+use ApiPlatform\Metadata\ApiResource;
+use ApiPlatform\Metadata\GetCollection;
+use ApiPlatform\Metadata\Patch;
+use ApiPlatform\Metadata\Post;
+use App\Repository\ContractSuspensionRepository;
+use App\State\ContractSuspensionWriteProcessor;
+use DateTimeImmutable;
+use Doctrine\ORM\Mapping as ORM;
+use Symfony\Component\Serializer\Attribute\Context;
+use Symfony\Component\Serializer\Attribute\Groups;
+use Symfony\Component\Serializer\Normalizer\DateTimeNormalizer;
+
+#[ApiResource(
+    operations: [
+        new GetCollection(),
+        new Post(processor: ContractSuspensionWriteProcessor::class),
+        new Patch(processor: ContractSuspensionWriteProcessor::class),
+    ],
+    normalizationContext: ['groups' => ['suspension:read']],
+    denormalizationContext: ['groups' => ['suspension:write']],
+    paginationEnabled: false,
+    security: "is_granted('ROLE_ADMIN')",
+)]
+#[ORM\Entity(repositoryClass: ContractSuspensionRepository::class)]
+#[ORM\Table(name: 'contract_suspensions')]
+#[ORM\Index(columns: ['contract_period_id', 'start_date'], name: 'idx_suspension_period_start')]
+class ContractSuspension
+{
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    #[ORM\Column(type: 'integer')]
+    #[Groups(['suspension:read', 'employee:read'])]
+    private ?int $id = null;
+
+    #[ORM\ManyToOne(targetEntity: EmployeeContractPeriod::class, inversedBy: 'suspensions')]
+    #[ORM\JoinColumn(nullable: false, onDelete: 'CASCADE')]
+    #[Groups(['suspension:write'])]
+    private ?EmployeeContractPeriod $contractPeriod = null;
+
+    #[ORM\Column(type: 'date_immutable')]
+    #[Groups(['suspension:read', 'suspension:write', 'employee:read'])]
+    #[Context([DateTimeNormalizer::FORMAT_KEY => 'Y-m-d'])]
+    private DateTimeImmutable $startDate;
+
+    #[ORM\Column(type: 'date_immutable', nullable: true)]
+    #[Groups(['suspension:read', 'suspension:write', 'employee:read'])]
+    #[Context([DateTimeNormalizer::FORMAT_KEY => 'Y-m-d'])]
+    private ?DateTimeImmutable $endDate = null;
+
+    #[ORM\Column(type: 'text', nullable: true)]
+    #[Groups(['suspension:read', 'suspension:write', 'employee:read'])]
+    private ?string $comment = null;
+
+    #[ORM\Column(type: 'datetime_immutable')]
+    private DateTimeImmutable $createdAt;
+
+    public function __construct()
+    {
+        $this->createdAt  = new DateTimeImmutable();
+        $this->startDate  = new DateTimeImmutable('today');
+    }
+
+    public function getId(): ?int
+    {
+        return $this->id;
+    }
+
+    public function getContractPeriod(): ?EmployeeContractPeriod
+    {
+        return $this->contractPeriod;
+    }
+
+    public function setContractPeriod(?EmployeeContractPeriod $contractPeriod): self
+    {
+        $this->contractPeriod = $contractPeriod;
+
+        return $this;
+    }
+
+    public function getStartDate(): DateTimeImmutable
+    {
+        return $this->startDate;
+    }
+
+    public function setStartDate(DateTimeImmutable $startDate): self
+    {
+        $this->startDate = $startDate;
+
+        return $this;
+    }
+
+    public function getEndDate(): ?DateTimeImmutable
+    {
+        return $this->endDate;
+    }
+
+    public function setEndDate(?DateTimeImmutable $endDate): self
+    {
+        $this->endDate = $endDate;
+
+        return $this;
+    }
+
+    public function getComment(): ?string
+    {
+        return $this->comment;
+    }
+
+    public function setComment(?string $comment): self
+    {
+        $this->comment = $comment;
+
+        return $this;
+    }
+
+    public function getCreatedAt(): DateTimeImmutable
+    {
+        return $this->createdAt;
+    }
+}
+```
+
+- [ ] **Step 3: Verify entity is syntactically correct**
+
+Run: `docker exec php-sirh-fpm php -l src/Entity/ContractSuspension.php`
+Expected: No syntax errors
+
+---
+
+### Task 2: Add OneToMany relation on EmployeeContractPeriod
+
+**Files:**
+- Modify: `src/Entity/EmployeeContractPeriod.php`
+
+- [ ] **Step 1: Add the suspensions collection**
+
+Add import at top of file (after existing `use` statements):
+
+```php
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\Common\Collections\Collection;
+```
+
+Add property after `$comment` (after line 44):
+
+```php
+/**
+ * @var Collection<int, ContractSuspension>
+ */
+#[ORM\OneToMany(mappedBy: 'contractPeriod', targetEntity: ContractSuspension::class, cascade: ['persist', 'remove'])]
+private Collection $suspensions;
+```
+
+In the constructor (line 49-53), add after `$this->startDate = ...`:
+
+```php
+$this->suspensions = new ArrayCollection();
+```
+
+Add getter after `setComment()` method (after line 153):
+
+```php
+/**
+ * @return Collection<int, ContractSuspension>
+ */
+public function getSuspensions(): Collection
+{
+    return $this->suspensions;
+}
+```
+
+---
+
+### Task 3: Migration
+
+**Files:**
+- Create: `migrations/Version20260312140000.php`
+
+- [ ] **Step 1: Create the migration file**
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace DoctrineMigrations;
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+final class Version20260312140000 extends AbstractMigration
+{
+    public function getDescription(): string
+    {
+        return 'Create contract_suspensions table';
+    }
+
+    public function up(Schema $schema): void
+    {
+        $this->addSql('CREATE TABLE contract_suspensions (
+            id SERIAL PRIMARY KEY,
+            contract_period_id INT NOT NULL REFERENCES employee_contract_periods(id) ON DELETE CASCADE,
+            start_date DATE NOT NULL,
+            end_date DATE DEFAULT NULL,
+            comment TEXT DEFAULT NULL,
+            created_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL
+        )');
+        $this->addSql('CREATE INDEX idx_suspension_period_start ON contract_suspensions (contract_period_id, start_date)');
+    }
+
+    public function down(Schema $schema): void
+    {
+        $this->addSql('DROP TABLE contract_suspensions');
+    }
+}
+```
+
+- [ ] **Step 2: Run migration**
+
+Run: `docker exec php-sirh-fpm php bin/console doctrine:migrations:migrate --no-interaction`
+Expected: Migration applied successfully
+
+- [ ] **Step 3: Verify schema is in sync**
+
+Run: `docker exec php-sirh-fpm php bin/console doctrine:schema:validate`
+Expected: OK (or only pre-existing warnings)
+
+---
+
+### Task 4: Expose suspensions in Employee read API
+
+**Files:**
+- Modify: `src/Dto/Employees/ContractHistoryItem.php`
+- Modify: `src/Entity/Employee.php`
+
+- [ ] **Step 1: Add periodId and suspensions to ContractHistoryItem DTO**
+
+In `src/Dto/Employees/ContractHistoryItem.php`, add two new constructor parameters after `$comment` (line 25):
+
+```php
+        #[Groups(['employee:read'])]
+        public ?string $comment = null,
+        #[Groups(['employee:read'])]
+        public ?int $periodId = null,
+        #[Groups(['employee:read'])]
+        public array $suspensions = [],
+```
+
+- [ ] **Step 2: Update Employee::getContractHistory() to include suspensions**
+
+In `src/Entity/Employee.php`, find the `getContractHistory()` method (around line 253). In the `array_map` callback, update the `ContractHistoryItem` construction to pass suspensions:
+
+Replace the current `return new ContractHistoryItem(...)` block with:
+
+```php
+                $suspensionData = array_map(
+                    static fn (ContractSuspension $s): array => [
+                        'id' => $s->getId(),
+                        'startDate' => $s->getStartDate()->format('Y-m-d'),
+                        'endDate' => $s->getEndDate()?->format('Y-m-d'),
+                        'comment' => $s->getComment(),
+                    ],
+                    $period->getSuspensions()->toArray()
+                );
+
+                return new ContractHistoryItem(
+                    contractId: $contract?->getId(),
+                    contractName: $contract?->getName(),
+                    weeklyHours: $contract?->getWeeklyHours(),
+                    contractNature: $period->getContractNatureEnum()->value,
+                    startDate: $period->getStartDate()->format('Y-m-d'),
+                    endDate: $period->getEndDate()?->format('Y-m-d'),
+                    comment: $period->getComment(),
+                    periodId: $period->getId(),
+                    suspensions: $suspensionData,
+                );
+```
+
+Add `use App\Entity\ContractSuspension;` at the top of `Employee.php` if not already present.
+
+- [ ] **Step 3: Add getContractPeriods() getter to Employee**
+
+In `src/Entity/Employee.php`, add a public getter for the `$contractPeriods` collection (needed by leave calculation to access suspensions):
+
+```php
+/**
+ * @return Collection<int, EmployeeContractPeriod>
+ */
+public function getContractPeriods(): Collection
+{
+    return $this->contractPeriods;
+}
+```
+
+- [ ] **Step 4: Add getCurrentSuspensions() to Employee**
+
+In `src/Entity/Employee.php`, add a new method after `getCurrentContractEndDate()` (around line 247):
+
+```php
+/**
+ * @return list<array{id: int|null, startDate: string, endDate: string|null, comment: string|null}>
+ */
+#[Groups(['employee:read'])]
+public function getCurrentSuspensions(): array
+{
+    $currentPeriod = $this->resolveCurrentContractPeriod();
+    if (null === $currentPeriod) {
+        return [];
+    }
+
+    return array_values(array_map(
+        static fn (ContractSuspension $s): array => [
+            'id' => $s->getId(),
+            'startDate' => $s->getStartDate()->format('Y-m-d'),
+            'endDate' => $s->getEndDate()?->format('Y-m-d'),
+            'comment' => $s->getComment(),
+        ],
+        $currentPeriod->getSuspensions()->toArray()
+    ));
+}
+```
+
+- [ ] **Step 5: Verify no syntax errors**
+
+Run: `docker exec php-sirh-fpm php -l src/Entity/Employee.php && docker exec php-sirh-fpm php -l src/Dto/Employees/ContractHistoryItem.php`
+Expected: No syntax errors
+
+---
+
+## Chunk 2: Suspension API Processor
+
+### Task 5: ContractSuspensionWriteProcessor
+
+**Files:**
+- Create: `src/State/ContractSuspensionWriteProcessor.php`
+- Create: `tests/State/ContractSuspensionWriteProcessorTest.php`
+
+- [ ] **Step 1: Write the test — valid suspension creation**
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\State;
+
+use ApiPlatform\Metadata\Post;
+use ApiPlatform\State\ProcessorInterface;
+use App\Entity\Contract;
+use App\Entity\ContractSuspension;
+use App\Entity\Employee;
+use App\Entity\EmployeeContractPeriod;
+use App\Enum\ContractNature;
+use App\State\ContractSuspensionWriteProcessor;
+use DateTimeImmutable;
+use Doctrine\ORM\EntityManagerInterface;
+use PHPUnit\Framework\TestCase;
+use ReflectionProperty;
+
+/**
+ * @internal
+ */
+final class ContractSuspensionWriteProcessorTest extends TestCase
+{
+    public function testPersistsValidSuspension(): void
+    {
+        $period = $this->buildPeriodWithId(1, '2026-01-01', null);
+        $suspension = new ContractSuspension();
+        $suspension->setContractPeriod($period);
+        $suspension->setStartDate(new DateTimeImmutable('2026-03-01'));
+        $suspension->setEndDate(new DateTimeImmutable('2026-04-30'));
+        $suspension->setComment('Congé sans solde');
+
+        $persistProcessor = $this->createMock(ProcessorInterface::class);
+        $persistProcessor->expects(self::once())->method('process')->willReturn($suspension);
+
+        $entityManager = $this->createStub(EntityManagerInterface::class);
+
+        $processor = new ContractSuspensionWriteProcessor($persistProcessor, $entityManager);
+        $result = $processor->process($suspension, new Post());
+
+        self::assertSame($suspension, $result);
+    }
+
+    public function testRejectsEndDateBeforeStartDate(): void
+    {
+        $period = $this->buildPeriodWithId(1, '2026-01-01', null);
+        $suspension = new ContractSuspension();
+        $suspension->setContractPeriod($period);
+        $suspension->setStartDate(new DateTimeImmutable('2026-05-01'));
+        $suspension->setEndDate(new DateTimeImmutable('2026-03-01'));
+
+        $persistProcessor = $this->createStub(ProcessorInterface::class);
+        $entityManager = $this->createStub(EntityManagerInterface::class);
+
+        $processor = new ContractSuspensionWriteProcessor($persistProcessor, $entityManager);
+
+        $this->expectException(\Symfony\Component\HttpKernel\Exception\UnprocessableEntityHttpException::class);
+        $processor->process($suspension, new Post());
+    }
+
+    public function testRejectsStartDateBeforePeriodStart(): void
+    {
+        $period = $this->buildPeriodWithId(1, '2026-06-01', null);
+        $suspension = new ContractSuspension();
+        $suspension->setContractPeriod($period);
+        $suspension->setStartDate(new DateTimeImmutable('2026-01-01'));
+
+        $persistProcessor = $this->createStub(ProcessorInterface::class);
+        $entityManager = $this->createStub(EntityManagerInterface::class);
+
+        $processor = new ContractSuspensionWriteProcessor($persistProcessor, $entityManager);
+
+        $this->expectException(\Symfony\Component\HttpKernel\Exception\UnprocessableEntityHttpException::class);
+        $processor->process($suspension, new Post());
+    }
+
+    public function testRejectsOverlappingSuspension(): void
+    {
+        $period = $this->buildPeriodWithId(1, '2026-01-01', null);
+
+        $existing = new ContractSuspension();
+        $existing->setContractPeriod($period);
+        $existing->setStartDate(new DateTimeImmutable('2026-03-01'));
+        $existing->setEndDate(new DateTimeImmutable('2026-04-30'));
+        $period->getSuspensions()->add($existing);
+
+        $suspension = new ContractSuspension();
+        $suspension->setContractPeriod($period);
+        $suspension->setStartDate(new DateTimeImmutable('2026-04-01'));
+        $suspension->setEndDate(new DateTimeImmutable('2026-05-31'));
+
+        $persistProcessor = $this->createStub(ProcessorInterface::class);
+        $entityManager = $this->createStub(EntityManagerInterface::class);
+
+        $processor = new ContractSuspensionWriteProcessor($persistProcessor, $entityManager);
+
+        $this->expectException(\Symfony\Component\HttpKernel\Exception\UnprocessableEntityHttpException::class);
+        $processor->process($suspension, new Post());
+    }
+
+    public function testRejectsClosedPeriod(): void
+    {
+        $period = $this->buildPeriodWithId(1, '2025-01-01', '2025-12-31');
+        $suspension = new ContractSuspension();
+        $suspension->setContractPeriod($period);
+        $suspension->setStartDate(new DateTimeImmutable('2025-06-01'));
+        $suspension->setEndDate(new DateTimeImmutable('2025-07-31'));
+
+        $persistProcessor = $this->createStub(ProcessorInterface::class);
+        $entityManager = $this->createStub(EntityManagerInterface::class);
+
+        $processor = new ContractSuspensionWriteProcessor($persistProcessor, $entityManager);
+
+        $this->expectException(\Symfony\Component\HttpKernel\Exception\UnprocessableEntityHttpException::class);
+        $processor->process($suspension, new Post());
+    }
+
+    private function buildPeriodWithId(int $id, string $start, ?string $end): EmployeeContractPeriod
+    {
+        $period = new EmployeeContractPeriod();
+        $period->setStartDate(new DateTimeImmutable($start));
+        if (null !== $end) {
+            $period->setEndDate(new DateTimeImmutable($end));
+        }
+        $period->setContractNature(ContractNature::CDI);
+
+        $ref = new ReflectionProperty($period, 'id');
+        $ref->setValue($period, $id);
+
+        return $period;
+    }
+}
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `docker exec php-sirh-fpm php bin/phpunit tests/State/ContractSuspensionWriteProcessorTest.php`
+Expected: FAIL — class ContractSuspensionWriteProcessor not found
+
+- [ ] **Step 3: Implement the processor**
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\State;
+
+use ApiPlatform\Metadata\Operation;
+use ApiPlatform\State\ProcessorInterface;
+use App\Entity\ContractSuspension;
+use App\Entity\EmployeeContractPeriod;
+use DateTimeImmutable;
+use Doctrine\ORM\EntityManagerInterface;
+use Symfony\Component\DependencyInjection\Attribute\Autowire;
+use Symfony\Component\HttpKernel\Exception\UnprocessableEntityHttpException;
+
+final readonly class ContractSuspensionWriteProcessor implements ProcessorInterface
+{
+    public function __construct(
+        #[Autowire(service: 'api_platform.doctrine.orm.state.persist_processor')]
+        private ProcessorInterface $persistProcessor,
+        private EntityManagerInterface $entityManager,
+    ) {}
+
+    public function process(
+        mixed $data,
+        Operation $operation,
+        array $uriVariables = [],
+        array $context = []
+    ): mixed {
+        if (!$data instanceof ContractSuspension) {
+            return $this->persistProcessor->process($data, $operation, $uriVariables, $context);
+        }
+
+        $period = $data->getContractPeriod();
+        if (!$period instanceof EmployeeContractPeriod) {
+            throw new UnprocessableEntityHttpException('contractPeriod is required.');
+        }
+
+        $this->validate($data, $period);
+
+        return $this->persistProcessor->process($data, $operation, $uriVariables, $context);
+    }
+
+    private function validate(ContractSuspension $suspension, EmployeeContractPeriod $period): void
+    {
+        $startDate = $suspension->getStartDate();
+        $endDate   = $suspension->getEndDate();
+
+        $periodEnd = $period->getEndDate();
+        if ($periodEnd instanceof DateTimeImmutable && $periodEnd < new DateTimeImmutable('today')) {
+            throw new UnprocessableEntityHttpException('Impossible de suspendre une période de contrat clôturée.');
+        }
+
+        if ($endDate instanceof DateTimeImmutable && $endDate < $startDate) {
+            throw new UnprocessableEntityHttpException('La date de fin doit être postérieure à la date de début.');
+        }
+
+        if ($startDate < $period->getStartDate()) {
+            throw new UnprocessableEntityHttpException('La suspension ne peut pas commencer avant le début du contrat.');
+        }
+
+        $periodEnd = $period->getEndDate();
+        if ($periodEnd instanceof DateTimeImmutable) {
+            if ($startDate > $periodEnd) {
+                throw new UnprocessableEntityHttpException('La suspension ne peut pas commencer après la fin du contrat.');
+            }
+            if ($endDate instanceof DateTimeImmutable && $endDate > $periodEnd) {
+                throw new UnprocessableEntityHttpException('La suspension ne peut pas se terminer après la fin du contrat.');
+            }
+        }
+
+        $this->validateNoOverlap($suspension, $period);
+    }
+
+    private function validateNoOverlap(ContractSuspension $suspension, EmployeeContractPeriod $period): void
+    {
+        $start = $suspension->getStartDate();
+        $end   = $suspension->getEndDate();
+
+        foreach ($period->getSuspensions() as $existing) {
+            if ($existing->getId() === $suspension->getId() && null !== $suspension->getId()) {
+                continue;
+            }
+
+            $existingStart = $existing->getStartDate();
+            $existingEnd   = $existing->getEndDate();
+
+            if (null === $end && null === $existingEnd) {
+                throw new UnprocessableEntityHttpException('Les suspensions ne peuvent pas se chevaucher.');
+            }
+
+            if (null === $end) {
+                if ($start <= $existingEnd) {
+                    throw new UnprocessableEntityHttpException('Les suspensions ne peuvent pas se chevaucher.');
+                }
+                continue;
+            }
+
+            if (null === $existingEnd) {
+                if ($existingStart <= $end) {
+                    throw new UnprocessableEntityHttpException('Les suspensions ne peuvent pas se chevaucher.');
+                }
+                continue;
+            }
+
+            if ($start <= $existingEnd && $end >= $existingStart) {
+                throw new UnprocessableEntityHttpException('Les suspensions ne peuvent pas se chevaucher.');
+            }
+        }
+    }
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `docker exec php-sirh-fpm php bin/phpunit tests/State/ContractSuspensionWriteProcessorTest.php`
+Expected: All 5 tests PASS
+
+---
+
+## Chunk 3: Leave Calculation — SuspensionDaysCalculator
+
+### Task 6: SuspensionDaysCalculator (shared logic)
+
+Both `EmployeeLeaveSummaryProvider` and `LeaveBalanceComputationService` need the same logic to subtract suspended days from a month. Extract this into a small dedicated service.
+
+**Files:**
+- Create: `src/Service/Leave/SuspensionDaysCalculator.php`
+- Create: `tests/Service/Leave/SuspensionDaysCalculatorTest.php`
+
+- [ ] **Step 1: Write the test**
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Service\Leave;
+
+use App\Entity\ContractSuspension;
+use App\Entity\EmployeeContractPeriod;
+use App\Service\Leave\SuspensionDaysCalculator;
+use DateTimeImmutable;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @internal
+ */
+final class SuspensionDaysCalculatorTest extends TestCase
+{
+    public function testNoSuspensionsReturnsZero(): void
+    {
+        $calc = new SuspensionDaysCalculator();
+        $result = $calc->countSuspendedDaysInMonth(
+            new DateTimeImmutable('2026-03-01'),
+            new DateTimeImmutable('2026-03-31'),
+            []
+        );
+
+        self::assertSame(0, $result);
+    }
+
+    public function testFullMonthSuspension(): void
+    {
+        $calc = new SuspensionDaysCalculator();
+        $suspension = $this->buildSuspension('2026-03-01', '2026-03-31');
+
+        $result = $calc->countSuspendedDaysInMonth(
+            new DateTimeImmutable('2026-03-01'),
+            new DateTimeImmutable('2026-03-31'),
+            [$suspension]
+        );
+
+        self::assertSame(31, $result);
+    }
+
+    public function testPartialMonthSuspension(): void
+    {
+        $calc = new SuspensionDaysCalculator();
+        $suspension = $this->buildSuspension('2026-03-10', '2026-03-20');
+
+        $result = $calc->countSuspendedDaysInMonth(
+            new DateTimeImmutable('2026-03-01'),
+            new DateTimeImmutable('2026-03-31'),
+            [$suspension]
+        );
+
+        self::assertSame(11, $result);
+    }
+
+    public function testSuspensionSpanningMultipleMonths(): void
+    {
+        $calc = new SuspensionDaysCalculator();
+        $suspension = $this->buildSuspension('2026-02-15', '2026-04-10');
+
+        // March fully covered
+        $result = $calc->countSuspendedDaysInMonth(
+            new DateTimeImmutable('2026-03-01'),
+            new DateTimeImmutable('2026-03-31'),
+            [$suspension]
+        );
+
+        self::assertSame(31, $result);
+    }
+
+    public function testSuspensionWithoutEndDate(): void
+    {
+        $calc = new SuspensionDaysCalculator();
+        $suspension = $this->buildSuspension('2026-03-15', null);
+
+        $result = $calc->countSuspendedDaysInMonth(
+            new DateTimeImmutable('2026-03-01'),
+            new DateTimeImmutable('2026-03-31'),
+            [$suspension]
+        );
+
+        self::assertSame(17, $result);
+    }
+
+    public function testMultipleSuspensionsInSameMonth(): void
+    {
+        $calc = new SuspensionDaysCalculator();
+        $s1 = $this->buildSuspension('2026-03-01', '2026-03-10');
+        $s2 = $this->buildSuspension('2026-03-20', '2026-03-25');
+
+        $result = $calc->countSuspendedDaysInMonth(
+            new DateTimeImmutable('2026-03-01'),
+            new DateTimeImmutable('2026-03-31'),
+            [$s1, $s2]
+        );
+
+        self::assertSame(16, $result);
+    }
+
+    public function testSuspensionOutsideMonthReturnsZero(): void
+    {
+        $calc = new SuspensionDaysCalculator();
+        $suspension = $this->buildSuspension('2026-01-01', '2026-01-31');
+
+        $result = $calc->countSuspendedDaysInMonth(
+            new DateTimeImmutable('2026-03-01'),
+            new DateTimeImmutable('2026-03-31'),
+            [$suspension]
+        );
+
+        self::assertSame(0, $result);
+    }
+
+    public function testCountSuspendedBusinessDays(): void
+    {
+        $calc = new SuspensionDaysCalculator();
+        // March 2-6, 2026 = Mon-Fri = 5 business days
+        $suspension = $this->buildSuspension('2026-03-02', '2026-03-06');
+
+        $result = $calc->countSuspendedBusinessDays(
+            new DateTimeImmutable('2026-01-01'),
+            new DateTimeImmutable('2026-12-31'),
+            [$suspension],
+            []
+        );
+
+        self::assertSame(5, $result);
+    }
+
+    private function buildSuspension(string $start, ?string $end): ContractSuspension
+    {
+        $s = new ContractSuspension();
+        $s->setStartDate(new DateTimeImmutable($start));
+        if (null !== $end) {
+            $s->setEndDate(new DateTimeImmutable($end));
+        }
+
+        return $s;
+    }
+}
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `docker exec php-sirh-fpm php bin/phpunit tests/Service/Leave/SuspensionDaysCalculatorTest.php`
+Expected: FAIL — class not found
+
+- [ ] **Step 3: Implement SuspensionDaysCalculator**
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service\Leave;
+
+use App\Entity\ContractSuspension;
+use DateTimeImmutable;
+
+final class SuspensionDaysCalculator
+{
+    /**
+     * Count calendar days suspended within a month window [monthStart, monthEnd].
+     *
+     * @param list<ContractSuspension> $suspensions
+     */
+    public function countSuspendedDaysInMonth(
+        DateTimeImmutable $monthStart,
+        DateTimeImmutable $monthEnd,
+        array $suspensions
+    ): int {
+        $total = 0;
+
+        foreach ($suspensions as $suspension) {
+            $sStart = $suspension->getStartDate();
+            $sEnd   = $suspension->getEndDate() ?? $monthEnd;
+
+            $overlapStart = $sStart > $monthStart ? $sStart : $monthStart;
+            $overlapEnd   = $sEnd < $monthEnd ? $sEnd : $monthEnd;
+
+            if ($overlapStart > $overlapEnd) {
+                continue;
+            }
+
+            $total += ((int) $overlapEnd->diff($overlapStart)->format('%a')) + 1;
+        }
+
+        return $total;
+    }
+
+    /**
+     * Count business days (Mon-Fri, excl. public holidays) suspended within a period.
+     *
+     * @param list<ContractSuspension> $suspensions
+     * @param array<string, string>    $publicHolidays  map of Y-m-d => label
+     */
+    public function countSuspendedBusinessDays(
+        DateTimeImmutable $periodStart,
+        DateTimeImmutable $periodEnd,
+        array $suspensions,
+        array $publicHolidays
+    ): int {
+        $total = 0;
+
+        foreach ($suspensions as $suspension) {
+            $sStart = $suspension->getStartDate();
+            $sEnd   = $suspension->getEndDate() ?? $periodEnd;
+
+            $overlapStart = $sStart > $periodStart ? $sStart : $periodStart;
+            $overlapEnd   = $sEnd < $periodEnd ? $sEnd : $periodEnd;
+
+            if ($overlapStart > $overlapEnd) {
+                continue;
+            }
+
+            for ($cursor = $overlapStart; $cursor <= $overlapEnd; $cursor = $cursor->modify('+1 day')) {
+                $weekDay = (int) $cursor->format('N');
+                $dayKey  = $cursor->format('Y-m-d');
+                if ($weekDay <= 5 && !isset($publicHolidays[$dayKey])) {
+                    ++$total;
+                }
+            }
+        }
+
+        return $total;
+    }
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `docker exec php-sirh-fpm php bin/phpunit tests/Service/Leave/SuspensionDaysCalculatorTest.php`
+Expected: All 8 tests PASS
+
+---
+
+## Chunk 4: Integrate suspension into leave calculation
+
+### Task 7: Modify EmployeeLeaveSummaryProvider
+
+**Files:**
+- Modify: `src/State/EmployeeLeaveSummaryProvider.php`
+
+- [ ] **Step 1: Inject SuspensionDaysCalculator**
+
+Add `use App\Service\Leave\SuspensionDaysCalculator;` to imports.
+
+Add to constructor: `private SuspensionDaysCalculator $suspensionDaysCalculator`
+
+- [ ] **Step 2: Modify computeAccruedDaysFromStart signature**
+
+Change method signature at line 333 to add suspensions parameter:
+
+```php
+private function computeAccruedDaysFromStart(
+    float $acquiredDays,
+    float $accrualPerMonth,
+    DateTimeImmutable $periodStart,
+    ?DateTimeImmutable $periodEnd,
+    array $suspensions = []
+): float {
+```
+
+- [ ] **Step 3: Add suspension subtraction in the month loop**
+
+Inside the while loop (after line 358 `$coveredDays = ...`), add:
+
+```php
+            $suspendedDays = $this->suspensionDaysCalculator->countSuspendedDaysInMonth($monthStart, $monthEnd, $suspensions);
+            $coveredDays   = max(0, $coveredDays - $suspendedDays);
+```
+
+- [ ] **Step 4: Resolve suspensions and pass to computeAccruedDaysFromStart calls**
+
+Find where `computeAccruedDaysFromStart` is called (around lines 173-187). Before those calls, resolve the suspensions for the current period:
+
+```php
+$suspensions = $this->resolveSuspensionsForPeriod($employee, $effectiveFrom, $to);
+```
+
+Then pass `$suspensions` as the 5th argument to both calls:
+
+```php
+$generatedDays = $leavePolicy['accrualPerMonth'] > 0.0
+    ? $this->computeAccruedDaysFromStart(
+        $leavePolicy['acquiredDays'],
+        $leavePolicy['accrualPerMonth'],
+        $effectiveFrom,
+        $accrualCalculationEnd,
+        $suspensions
+    )
+    : 0.0;
+$generatedSaturdays = $leavePolicy['saturdayAccrualPerMonth'] > 0.0
+    ? $this->computeAccruedDaysFromStart(
+        $leavePolicy['acquiredSaturdays'],
+        $leavePolicy['saturdayAccrualPerMonth'],
+        $effectiveFrom,
+        $accrualCalculationEnd,
+        $suspensions
+    )
+    : 0.0;
+```
+
+- [ ] **Step 5: Modify the forfait branch to subtract suspended business days**
+
+In the forfait branch (around line 225-234), replace `$acquiredDays = $carryDays + $leavePolicy['acquiredDays'];` (line 227) with:
+
+```php
+$acquiredDays = $carryDays + $leavePolicy['acquiredDays'];
+$suspensions = $this->resolveSuspensionsForPeriod($employee, $from, $to);
+if ([] !== $suspensions) {
+    $publicHolidays = $this->buildPublicHolidayMap($from, $to);
+    $suspendedBusinessDays = $this->suspensionDaysCalculator->countSuspendedBusinessDays($from, $to, $suspensions, $publicHolidays);
+    $totalBusinessDays = $this->countBusinessDays($from, $to);
+    if ($totalBusinessDays > 0) {
+        $effectiveBusinessDays = $totalBusinessDays - $suspendedBusinessDays;
+        $acquiredDays = $carryDays + (float) max(0, $effectiveBusinessDays - self::FORFAIT_TARGET_WORKED_DAYS);
+    }
+}
+```
+
+- [ ] **Step 6: Add resolveSuspensionsForPeriod helper method**
+
+Add at the end of the class:
+
+```php
+/**
+ * @return list<ContractSuspension>
+ */
+private function resolveSuspensionsForPeriod(Employee $employee, DateTimeImmutable $from, DateTimeImmutable $to): array
+{
+    $suspensions = [];
+    foreach ($employee->getContractPeriods() as $period) {
+        $periodStart = $period->getStartDate();
+        $periodEnd   = $period->getEndDate();
+
+        if ($periodStart > $to) {
+            continue;
+        }
+        if ($periodEnd instanceof DateTimeImmutable && $periodEnd < $from) {
+            continue;
+        }
+
+        foreach ($period->getSuspensions() as $suspension) {
+            $suspensions[] = $suspension;
+        }
+    }
+
+    return $suspensions;
+}
+```
+
+Note: `Employee::getContractPeriods()` was already added in Task 4 Step 3.
+
+Add `use App\Entity\ContractSuspension;` import in `EmployeeLeaveSummaryProvider.php`.
+
+- [ ] **Step 7: Run existing leave tests**
+
+Run: `docker exec php-sirh-fpm php bin/phpunit tests/State/EmployeeLeaveSummaryProviderTest.php`
+Expected: All existing tests still pass (no regression — employees without suspensions should behave identically)
+
+---
+
+### Task 8: Modify LeaveBalanceComputationService
+
+**Files:**
+- Modify: `src/Service/Leave/LeaveBalanceComputationService.php`
+
+- [ ] **Step 1: Inject SuspensionDaysCalculator**
+
+Add `use App\Entity\ContractSuspension;` and `use App\Service\Leave\SuspensionDaysCalculator;` to imports.
+
+Add to constructor: `private SuspensionDaysCalculator $suspensionDaysCalculator`
+
+- [ ] **Step 2: Modify computeAccruedDays signature**
+
+Change method signature at line 261 to add suspensions:
+
+```php
+private function computeAccruedDays(
+    float $annualCap,
+    float $accrualPerMonth,
+    DateTimeImmutable $periodStart,
+    DateTimeImmutable $periodEnd,
+    array $suspensions = []
+): float {
+```
+
+- [ ] **Step 3: Add suspension subtraction in the month loop**
+
+Inside the while loop (after line 282 `$coveredDays = ...`), add:
+
+```php
+            $suspendedDays = $this->suspensionDaysCalculator->countSuspendedDaysInMonth($monthStart, $monthEnd, $suspensions);
+            $coveredDays   = max(0, $coveredDays - $suspendedDays);
+```
+
+- [ ] **Step 4: Resolve suspensions in computeDynamicClosingForYear and pass to calls**
+
+In `computeDynamicClosingForYear()`, before the calls to `computeAccruedDays` (around lines 79-90), add:
+
+```php
+$suspensions = $this->resolveSuspensionsForEmployeePeriod($employee, $from, $to);
+```
+
+Pass `$suspensions` as 5th argument to both `computeAccruedDays` calls:
+
+```php
+$generatedDays = $this->computeAccruedDays(
+    $this->resolveAnnualDays($employee),
+    $this->resolveDaysAccrualPerMonth($employee),
+    $effectiveFrom,
+    $to,
+    $suspensions
+);
+$generatedSaturdays = $this->computeAccruedDays(
+    $this->resolveAnnualSaturdays($employee),
+    $this->resolveSaturdayAccrualPerMonth($employee),
+    $effectiveFrom,
+    $to,
+    $suspensions
+);
+```
+
+- [ ] **Step 5: Modify the forfait branch**
+
+In the forfait section (around line 69-76), after `$acquiredDays = $carryDays + (float) max(0, $this->countBusinessDays($from, $to) - self::FORFAIT_TARGET_WORKED_DAYS) + $fractionedDays;`, replace with:
+
+```php
+$totalBusinessDays = $this->countBusinessDays($from, $to);
+$suspensions = $this->resolveSuspensionsForEmployeePeriod($employee, $from, $to);
+$suspendedBusinessDays = 0;
+if ([] !== $suspensions) {
+    $publicHolidays = $this->buildPublicHolidayMap($from, $to);
+    $suspendedBusinessDays = $this->suspensionDaysCalculator->countSuspendedBusinessDays($from, $to, $suspensions, $publicHolidays);
+}
+$effectiveBusinessDays = $totalBusinessDays - $suspendedBusinessDays;
+$acquiredDays = $carryDays + (float) max(0, $effectiveBusinessDays - self::FORFAIT_TARGET_WORKED_DAYS) + $fractionedDays;
+```
+
+- [ ] **Step 6: Add resolveSuspensionsForEmployeePeriod helper**
+
+```php
+/**
+ * @return list<ContractSuspension>
+ */
+private function resolveSuspensionsForEmployeePeriod(Employee $employee, DateTimeImmutable $from, DateTimeImmutable $to): array
+{
+    $suspensions = [];
+    foreach ($employee->getContractPeriods() as $period) {
+        $periodStart = $period->getStartDate();
+        $periodEnd   = $period->getEndDate();
+
+        if ($periodStart > $to) {
+            continue;
+        }
+        if ($periodEnd instanceof DateTimeImmutable && $periodEnd < $from) {
+            continue;
+        }
+
+        foreach ($period->getSuspensions() as $suspension) {
+            $suspensions[] = $suspension;
+        }
+    }
+
+    return $suspensions;
+}
+```
+
+- [ ] **Step 7: Run all tests**
+
+Run: `docker exec php-sirh-fpm php bin/phpunit`
+Expected: All tests pass
+
+---
+
+## Chunk 5: Frontend — DTO, Service, Drawer UI
+
+### Task 9: Frontend types and API service
+
+**Files:**
+- Modify: `frontend/services/dto/employee.ts`
+- Create: `frontend/services/contractSuspensions.ts`
+
+- [ ] **Step 1: Add ContractSuspension type and update Employee DTO**
+
+In `frontend/services/dto/employee.ts`, add the type and update Employee:
+
+```typescript
+export type ContractSuspension = {
+  id: number
+  startDate: string
+  endDate?: string | null
+  comment?: string | null
+}
+```
+
+Add to `Employee` type:
+```typescript
+  currentSuspensions?: ContractSuspension[]
+```
+
+Add to `ContractHistoryItem` type:
+```typescript
+  suspensions?: ContractSuspension[]
+```
+
+- [ ] **Step 2: Create suspension API service**
+
+```typescript
+import type { ContractSuspension } from './dto/employee'
+
+export const createSuspension = async (payload: {
+  contractPeriodId: number
+  startDate: string
+  endDate?: string | null
+  comment?: string | null
+}) => {
+  const api = useApi()
+  return api.post<ContractSuspension>('/contract_suspensions', {
+    contractPeriod: `/api/employee_contract_periods/${payload.contractPeriodId}`,
+    startDate: payload.startDate,
+    endDate: payload.endDate ?? null,
+    comment: payload.comment ?? null
+  }, {
+    toastSuccessKey: 'success.suspension.create',
+    toastErrorKey: 'errors.suspension.create'
+  })
+}
+
+export const updateSuspension = async (
+  id: number,
+  payload: {
+    startDate: string
+    endDate?: string | null
+    comment?: string | null
+  }
+) => {
+  const api = useApi()
+  return api.patch<ContractSuspension>(`/contract_suspensions/${id}`, {
+    startDate: payload.startDate,
+    endDate: payload.endDate ?? null,
+    comment: payload.comment ?? null
+  }, {
+    toastSuccessKey: 'success.suspension.update',
+    toastErrorKey: 'errors.suspension.update'
+  })
+}
+```
+
+---
+
+### Task 10: Modify ContractTab.vue — tabbed drawer
+
+**Files:**
+- Modify: `frontend/components/employees/ContractTab.vue`
+- Modify: `frontend/composables/useEmployeeDetailPage.ts`
+
+- [ ] **Step 1: Add suspension props to ContractTab.vue**
+
+In the `defineProps` section of `ContractTab.vue`, add new props using the TypeScript generics syntax (matching the existing codebase pattern):
+
+```typescript
+type SuspensionForm = {
+  id: number | null
+  startDate: string
+  endDate: string
+  comment: string
+}
+```
+
+Add to the existing `defineProps` (which uses TypeScript generics):
+
+```typescript
+// Add these to the existing defineProps<{ ... }>()
+suspensionForms: SuspensionForm[]
+isSuspensionSubmitting: boolean
+onSubmitSuspension: (index: number) => void
+onAddSuspensionForm: () => void
+currentContractPeriodId?: number | null
+```
+
+- [ ] **Step 2: Change button label from "Clôturer" to "Modifier"**
+
+In the template, find the "Clôturer" button (around lines 28-35). Change the button text:
+
+From: `Clôturer`
+To: `Modifier`
+
+- [ ] **Step 3: Change drawer title and add tabs**
+
+Replace the drawer title from `"Clôturer le contrat"` to `"Modifier le contrat"`.
+
+Inside the `AppDrawer`, wrap the existing close-contract form content in a tab structure. Add at the start of the drawer content:
+
+```vue
+<div class="mb-4 flex border-b border-neutral-200">
+    <button
+        class="pb-2 px-4 border-b-2 font-semibold"
+        :class="drawerTab === 'close'
+            ? 'border-primary-500 text-primary-500'
+            : 'border-transparent text-neutral-400 hover:text-neutral-600'"
+        @click="drawerTab = 'close'"
+    >
+        Clôturer
+    </button>
+    <button
+        class="pb-2 px-4 border-b-2 font-semibold"
+        :class="drawerTab === 'suspend'
+            ? 'border-primary-500 text-primary-500'
+            : 'border-transparent text-neutral-400 hover:text-neutral-600'"
+        @click="drawerTab = 'suspend'"
+    >
+        Suspendre
+    </button>
+</div>
+```
+
+Add a `ref` in the script:
+
+```typescript
+const drawerTab = ref<'close' | 'suspend'>('close')
+```
+
+Wrap the existing close-contract form content in `<div v-if="drawerTab === 'close'">...</div>`.
+
+- [ ] **Step 4: Add Suspendre tab content**
+
+After the close tab div, add:
+
+```vue
+<div v-if="drawerTab === 'suspend'" class="space-y-6">
+    <div
+        v-for="(form, index) in suspensionForms"
+        :key="form.id ?? `new-${index}`"
+        class="space-y-4 rounded-lg border border-neutral-200 p-4"
+    >
+        <div>
+            <label class="text-md font-semibold text-neutral-700">
+                Date de début <span class="text-red-600">*</span>
+            </label>
+            <input
+                v-model="form.startDate"
+                type="date"
+                class="mt-2 w-full rounded-md border border-neutral-300 bg-white px-3 py-2 text-base text-neutral-900 focus:border-primary-500 focus:outline-none focus:ring-2 focus:ring-secondary-500/20"
+            />
+        </div>
+        <div>
+            <label class="text-md font-semibold text-neutral-700">
+                Date de fin
+            </label>
+            <input
+                v-model="form.endDate"
+                type="date"
+                class="mt-2 w-full rounded-md border border-neutral-300 bg-white px-3 py-2 text-base text-neutral-900 focus:border-primary-500 focus:outline-none focus:ring-2 focus:ring-secondary-500/20"
+            />
+        </div>
+        <div>
+            <label class="text-md font-semibold text-neutral-700">
+                Commentaire
+            </label>
+            <textarea
+                v-model="form.comment"
+                rows="3"
+                class="mt-2 w-full rounded-md border border-neutral-300 bg-white px-3 py-2 text-base text-neutral-900 focus:border-primary-500 focus:outline-none focus:ring-2 focus:ring-secondary-500/20"
+            />
+        </div>
+        <button
+            type="button"
+            class="w-full rounded-md bg-primary-500 px-4 py-2 text-base font-semibold text-white transition hover:bg-secondary-500 disabled:cursor-not-allowed disabled:opacity-60"
+            :disabled="!form.startDate || isSuspensionSubmitting"
+            @click="onSubmitSuspension(index)"
+        >
+            {{ form.id ? 'Modifier' : '+ Ajouter' }}
+        </button>
+    </div>
+
+    <button
+        type="button"
+        class="w-full rounded-md border-2 border-dashed border-neutral-300 px-4 py-3 text-base font-semibold text-neutral-500 transition hover:border-primary-500 hover:text-primary-500"
+        @click="onAddSuspensionForm"
+    >
+        + Ajouter une suspension
+    </button>
+</div>
+```
+
+---
+
+### Task 11: Suspension form logic in composable
+
+**Files:**
+- Modify: `frontend/composables/useEmployeeDetailPage.ts`
+
+- [ ] **Step 1: Add suspension imports and state**
+
+Add imports:
+```typescript
+import { createSuspension, updateSuspension } from '~/services/contractSuspensions'
+```
+
+Add reactive state alongside the existing contract form state:
+
+```typescript
+type SuspensionForm = {
+  id: number | null
+  startDate: string
+  endDate: string
+  comment: string
+}
+
+const suspensionForms = ref<SuspensionForm[]>([])
+const isSuspensionSubmitting = ref(false)
+```
+
+- [ ] **Step 2: Add hydration logic**
+
+Add a function to populate suspension forms from current employee data:
+
+```typescript
+const hydrateSuspensionForms = () => {
+    const current = employee.value?.currentSuspensions ?? []
+    suspensionForms.value = current.map(s => ({
+        id: s.id,
+        startDate: s.startDate,
+        endDate: s.endDate ?? '',
+        comment: s.comment ?? ''
+    }))
+}
+```
+
+Call `hydrateSuspensionForms()` inside `openCloseContractDrawer()` (which becomes `openModifyContractDrawer()`).
+
+- [ ] **Step 3: Add submit function**
+
+```typescript
+const submitSuspension = async (index: number) => {
+    const form = suspensionForms.value[index]
+    if (!form || !form.startDate) return
+
+    const periodId = currentActiveContractPeriodId.value
+    if (!periodId) return
+
+    isSuspensionSubmitting.value = true
+    try {
+        if (form.id) {
+            await updateSuspension(form.id, {
+                startDate: form.startDate,
+                endDate: form.endDate || null,
+                comment: form.comment || null
+            })
+        } else {
+            await createSuspension({
+                contractPeriodId: periodId,
+                startDate: form.startDate,
+                endDate: form.endDate || null,
+                comment: form.comment || null
+            })
+        }
+        await loadEmployee()
+        hydrateSuspensionForms()
+    } finally {
+        isSuspensionSubmitting.value = false
+    }
+}
+```
+
+- [ ] **Step 4: Add addSuspensionForm function**
+
+```typescript
+const addSuspensionForm = () => {
+    suspensionForms.value.push({
+        id: null,
+        startDate: '',
+        endDate: '',
+        comment: ''
+    })
+}
+```
+
+- [ ] **Step 5: Resolve currentActiveContractPeriodId**
+
+Add a computed that extracts the period ID from the already-existing `currentActiveContractPeriod` computed (the `periodId` field was already added to `ContractHistoryItem` in Task 4 and Task 9):
+
+```typescript
+const currentActiveContractPeriodId = computed<number | null>(() => {
+    const period = currentActiveContractPeriod.value
+    return period?.periodId ?? null
+})
+```
+
+Where `currentActiveContractPeriod` already exists in the composable (around line 80).
+
+- [ ] **Step 6: Export new values from composable**
+
+Add to the return object:
+
+```typescript
+suspensionForms,
+isSuspensionSubmitting,
+submitSuspension,
+addSuspensionForm,
+currentActiveContractPeriodId,
+```
+
+- [ ] **Step 7: Pass new props from [id].vue to ContractTab**
+
+In `frontend/pages/employees/[id].vue`, destructure the new values from the composable and pass them as props to `<EmployeesContractTab>`:
+
+```vue
+:suspension-forms="suspensionForms"
+:is-suspension-submitting="isSuspensionSubmitting"
+:on-submit-suspension="submitSuspension"
+:on-add-suspension-form="addSuspensionForm"
+:current-contract-period-id="currentActiveContractPeriodId"
+```
+
+- [ ] **Step 8: Verify in browser**
+
+1. Open an employee detail page
+2. Click "Modifier" button — drawer should open with 2 tabs
+3. Click "Suspendre" tab — should show "+ Ajouter une suspension" button
+4. Click it, fill in dates, submit — suspension should be created
+5. Reopen drawer — suspension should be pre-filled
+6. Check leave tab — accruing days should be reduced
+
+---
+
+## Chunk 6: Add i18n toast keys
+
+### Task 12: Add toast translation keys
+
+**Files:**
+- Find and modify the i18n file(s) for success/error messages
+
+- [ ] **Step 1: Locate i18n files**
+
+Search for existing toast keys like `success.employee.create` to find the translation file.
+
+- [ ] **Step 2: Add suspension keys**
+
+Add:
+```
+success.suspension.create: "Suspension créée"
+success.suspension.update: "Suspension modifiée"
+errors.suspension.create: "Erreur lors de la création de la suspension"
+errors.suspension.update: "Erreur lors de la modification de la suspension"
+```
+
+**Note:** If the project uses the toast key as a fallback label when no translation file is found, adding these keys to the translation file is optional — the key string itself will be displayed. Check the `useApi` composable behavior to confirm.
diff --git a/docs/superpowers/specs/2026-03-12-contract-suspension-design.md b/docs/superpowers/specs/2026-03-12-contract-suspension-design.md
new file mode 100644
index 0000000..1cca876
--- /dev/null
+++ b/docs/superpowers/specs/2026-03-12-contract-suspension-design.md
@@ -0,0 +1,187 @@
+# Suspension de contrat — Design Spec
+
+## Objectif
+
+Permettre de suspendre un contrat employé. Une suspension empêche l'acquisition de congés durant la période concernée (prorata). S'applique aux CDI/CDD non forfait et aux forfaits 218.
+
+## Contraintes
+
+- Plusieurs suspensions possibles par période de contrat
+- Pas de suppression de suspension (hors scope)
+- Règle de calcul : on exclut les jours de suspension jusqu'au dernier mois complet terminé (cohérent avec la règle existante)
+- Suspension sans date de fin = suspension en cours indéfiniment (exclut les mois jusqu'au dernier mois terminé)
+- Les suspensions ne doivent pas se chevaucher sur une même période de contrat
+
+## Modèle de données
+
+### Nouvelle entité `ContractSuspension`
+
+Nouvelle table `contract_suspensions` :
+
+| Colonne | Type | Nullable | Description |
+|---------|------|----------|-------------|
+| `id` | SERIAL | non | PK |
+| `contract_period_id` | INT | non | FK vers `employee_contract_periods`, CASCADE delete |
+| `start_date` | DATE | non | Début de suspension |
+| `end_date` | DATE | oui | Fin de suspension (null = en cours) |
+| `comment` | TEXT | oui | Commentaire libre |
+| `created_at` | TIMESTAMP | non | Date de création technique |
+
+Index : `(contract_period_id, start_date)`.
+
+Relation : `EmployeeContractPeriod` ← OneToMany → `ContractSuspension`.
+
+## Backend — API
+
+### Endpoint dédié
+
+Les suspensions sont gérées via un endpoint dédié plutôt que via les champs transients Employee. Cela évite de complexifier le `EmployeeWriteProcessor` et permet de gérer N suspensions proprement.
+
+**Nouvel ApiResource `ContractSuspension` :**
+- `POST /api/contract_suspensions` — créer une suspension (body : `contractPeriod` IRI, `startDate`, `endDate`, `comment`)
+- `PATCH /api/contract_suspensions/{id}` — modifier une suspension existante
+- Security : `ROLE_ADMIN`
+- Pagination désactivée
+
+**Processor custom `ContractSuspensionWriteProcessor` :**
+- Résout la période de contrat depuis l'IRI
+- Validation :
+  - `startDate` requis
+  - `endDate >= startDate` si renseigné
+  - `startDate >= period.startDate`
+  - Pour les CDD/contrats avec date de fin : `startDate` et `endDate` dans les bornes de la période
+  - Pas de chevauchement avec les autres suspensions de la même période
+  - Rejet si la période de contrat est déjà clôturée (date de fin dans le passé)
+
+### Lecture
+
+Exposer les suspensions dans la sérialisation de l'Employee :
+
+- `Employee::getCurrentSuspensions(): array` — retourne les suspensions de la période de contrat courante, groupe `employee:read`
+- Ajouter les suspensions au `ContractHistoryItem` via `EmployeeContractPeriod::getSuspensions()`
+
+## Backend — Calcul des congés
+
+### Deux points d'impact
+
+Le calcul d'acquisition existe à **deux endroits** qui doivent tous les deux prendre en compte les suspensions :
+
+1. **`EmployeeLeaveSummaryProvider::computeAccruedDaysFromStart()`** — affichage live des congés en cours d'acquisition
+2. **`LeaveBalanceComputationService::computeAccruedDays()`** — utilisé par le rollover (`LeaveRolloverCommand`) pour calculer le solde de report
+
+Les deux méthodes ont la même structure (boucle mois par mois) et doivent être modifiées de la même manière.
+
+### Modification des méthodes de calcul
+
+Pour les deux méthodes, ajouter un paramètre optionnel : `array $suspensions = []` (tableau de `{start: DateTimeImmutable, end: ?DateTimeImmutable}`).
+
+Dans la boucle mois par mois, pour chaque mois :
+1. Calculer les jours couverts par la période de contrat (existant)
+2. Pour chaque suspension, calculer le nombre de jours suspendus qui tombent dans ce mois
+3. Soustraire le total des jours suspendus
+4. Le ratio du mois = max(0, jours couverts - jours suspendus) / jours dans le mois
+
+Cela gère automatiquement les suspensions qui commencent/finissent en milieu de mois (prorata).
+
+Une suspension sans date de fin utilise la date de fin de calcul comme borne (dernier jour du mois précédent, cohérent avec la règle existante).
+
+**Note :** chaque méthode est appelée deux fois — une pour les jours, une pour les samedis. La soustraction de suspension s'applique aux deux appels.
+
+### Impact sur les forfaits 218
+
+Pour les forfaits, les jours acquis en début d'exercice (ex: 34 jours pour 2026) sont réduits au prorata des jours de suspension.
+
+Calcul : `jours acquis = base × (jours ouvrés effectifs / jours ouvrés totaux de l'exercice)`
+
+Où `jours ouvrés effectifs = jours ouvrés totaux - jours ouvrés suspendus`.
+
+Cela impacte `EmployeeLeaveSummaryProvider` dans la branche forfait et `LeaveBalanceComputationService` dans le calcul forfait de `computeDynamicClosingForYear()`.
+
+### Passage des données de suspension aux méthodes
+
+- **`EmployeeLeaveSummaryProvider`** : le provider a accès aux périodes de contrat via l'Employee. Il doit résoudre les suspensions de la période couvrant l'exercice et les passer aux méthodes de calcul.
+- **`LeaveBalanceComputationService`** : le service utilise `$employee->getContractHistory()`. Il doit trouver les suspensions de la période couvrant l'exercice. L'accès au repository `EmployeeContractPeriodRepository` est déjà injecté — ajouter l'accès au repository `ContractSuspensionRepository` ou passer par la relation Doctrine.
+
+### Impact sur la bascule d'exercice (rollover au 01/06)
+
+Le rollover (`LeaveRolloverCommand`) appelle `LeaveBalanceComputationService::computeDynamicClosingForYear()` qui appelle `computeAccruedDays()`. En modifiant `computeAccruedDays()` pour accepter et traiter les suspensions, le rollover prendra automatiquement en compte les suspensions. Les jours acquis au rollover reflèteront la déduction.
+
+**Exemple CDI :** exercice 2027 (juin 2026 - mai 2027), 2 suspensions totalisant 3 mois → au lieu de 25j acquis, l'employé bascule avec ~18.75j (9 mois effectifs × 2.083j/mois).
+
+### Règles non impactées
+
+- INTERIM : pas de congés gérés
+
+## Frontend — UI
+
+### Bouton et drawer
+
+Le bouton "Clôturer" devient **"Modifier"**. Il ouvre le drawer existant avec le titre **"Modifier le contrat"**. Le bouton **"+ Ajouter"** (création de nouveau contrat) reste inchangé.
+
+Le drawer contient 2 onglets :
+
+**Onglet "Clôturer"** — contenu identique à l'actuel (type contrat, temps de travail, début contrat en readonly, date fin, commentaire, checkbox solde de tout compte).
+
+**Onglet "Suspendre"** — formulaires empilés :
+- Pour chaque suspension existante : un formulaire pré-rempli avec les 3 champs (date début, date fin, commentaire) et un bouton **"Modifier"**
+- En bas : un bouton **"+ Ajouter"** qui ajoute un nouveau formulaire vide avec les 3 champs et un bouton **"Ajouter"**
+- Chaque formulaire est indépendant (soumission individuelle)
+
+### Champs par formulaire de suspension
+
+- Date de début (required, input date)
+- Date de fin (optionnel, input date)
+- Commentaire (optionnel, textarea)
+
+### Données nécessaires côté frontend
+
+Nouveau type `ContractSuspension` (DTO) :
+```typescript
+type ContractSuspension = {
+  id: number
+  startDate: string
+  endDate?: string | null
+  comment?: string | null
+}
+```
+
+Ajouter au type `Employee` (DTO) :
+- `currentSuspensions?: ContractSuspension[]`
+
+Ajouter au type `ContractHistoryItem` :
+- `suspensions?: ContractSuspension[]`
+
+Nouveau service `frontend/services/contractSuspensions.ts` :
+- `createSuspension(payload)` — POST
+- `updateSuspension(id, payload)` — PATCH
+
+## Exemples de calcul
+
+### CDI/CDD non forfait
+
+Contrat CDI démarré le 01/06/2026, exercice 2027 (juin 2026 - mai 2027).
+Accrual : 25j / 12 mois = 2.083j/mois.
+
+Sans suspension au 12/03/2027 (9 mois complets : juin-février) :
+- En cours d'acquisition = 9 × 2.083 = 18.75j
+
+Avec 2 suspensions (01/01 au 31/01 + 01/03 au 31/03 = 2 mois) au 12/04/2027 (10 mois complets - 2 suspendus = 8 mois effectifs) :
+- En cours d'acquisition = 8 × 2.083 = 16.67j
+
+Samedis (5/12 par mois) :
+- Sans suspension : 9 × 0.417 = 3.75j
+- Avec 2 suspensions : 8 × 0.417 = 3.33j
+
+### Forfait 218
+
+Exercice 2026 (année civile), 34 jours acquis, 252 jours ouvrés dans l'année.
+Suspension de 2 mois (44 jours ouvrés).
+
+- Jours ouvrés effectifs = 252 - 44 = 208
+- Jours acquis = 34 × (208 / 252) = 28.06j
+
+## Hors scope
+
+- Suppression d'une suspension
+- Affichage de la suspension dans l'historique des contrats (les données sont sérialisées mais pas de rendu spécifique dans le tableau historique)
+- Auto-fermeture des suspensions lors de la clôture du contrat
diff --git a/frontend/components/AppDrawer.vue b/frontend/components/AppDrawer.vue
index 302fb95..a28f4a3 100644
--- a/frontend/components/AppDrawer.vue
+++ b/frontend/components/AppDrawer.vue
@@ -17,7 +17,7 @@
             ✕
           </button>
         </div>
-        <div class="p-6">
+        <div class="overflow-y-auto p-6" style="max-height: calc(100% - 65px)">
           <slot />
         </div>
       </div>
diff --git a/frontend/components/employees/ContractTab.vue b/frontend/components/employees/ContractTab.vue
index d81107c..bd55a7b 100644
--- a/frontend/components/employees/ContractTab.vue
+++ b/frontend/components/employees/ContractTab.vue
@@ -31,7 +31,7 @@
         :disabled="isContractSubmitting || !canCloseCurrentContract"
         @click="onOpenCloseContractDrawer"
       >
-        Clôturer
+        Modifier
       </button>
       <button
         type="button"
@@ -43,7 +43,30 @@
       </button>
     </div>
 
-    <AppDrawer :model-value="isContractDrawerOpen" title="Clôturer le contrat" @update:model-value="onUpdateContractDrawerOpen">
+    <AppDrawer :model-value="isContractDrawerOpen" title="Modifier le contrat" @update:model-value="onUpdateContractDrawerOpen">
+      <div class="mb-4 flex border-b border-neutral-200">
+          <button
+              type="button"
+              class="pb-2 px-4 border-b-2 font-semibold"
+              :class="drawerTab === 'close'
+                  ? 'border-primary-500 text-primary-500'
+                  : 'border-transparent text-neutral-400 hover:text-neutral-600'"
+              @click="drawerTab = 'close'"
+          >
+              Clôturer
+          </button>
+          <button
+              type="button"
+              class="pb-2 px-4 border-b-2 font-semibold"
+              :class="drawerTab === 'suspend'
+                  ? 'border-primary-500 text-primary-500'
+                  : 'border-transparent text-neutral-400 hover:text-neutral-600'"
+              @click="drawerTab = 'suspend'"
+          >
+              Suspendre
+          </button>
+      </div>
+      <div v-if="drawerTab === 'close'">
       <form class="space-y-4" @submit.prevent="onSubmitCloseContract">
         <div>
           <label class="text-md font-semibold text-neutral-700" for="contract-nature">
@@ -128,6 +151,62 @@
           </button>
         </div>
       </form>
+      </div>
+
+      <div v-if="drawerTab === 'suspend'" class="space-y-6">
+          <div
+              v-for="(form, index) in suspensionForms"
+              :key="form.id ?? `new-${index}`"
+              class="space-y-4 rounded-lg border border-neutral-200 p-4"
+          >
+              <div>
+                  <label class="text-md font-semibold text-neutral-700">
+                      Date de début <span class="text-red-600">*</span>
+                  </label>
+                  <input
+                      v-model="form.startDate"
+                      type="date"
+                      class="mt-2 w-full rounded-md border border-neutral-300 bg-white px-3 py-2 text-base text-neutral-900 focus:border-primary-500 focus:outline-none focus:ring-2 focus:ring-secondary-500/20"
+                  />
+              </div>
+              <div>
+                  <label class="text-md font-semibold text-neutral-700">
+                      Date de fin
+                  </label>
+                  <input
+                      v-model="form.endDate"
+                      type="date"
+                      class="mt-2 w-full rounded-md border border-neutral-300 bg-white px-3 py-2 text-base text-neutral-900 focus:border-primary-500 focus:outline-none focus:ring-2 focus:ring-secondary-500/20"
+                  />
+              </div>
+              <div>
+                  <label class="text-md font-semibold text-neutral-700">
+                      Commentaire
+                  </label>
+                  <textarea
+                      v-model="form.comment"
+                      rows="3"
+                      class="mt-2 w-full rounded-md border border-neutral-300 bg-white px-3 py-2 text-base text-neutral-900 focus:border-primary-500 focus:outline-none focus:ring-2 focus:ring-secondary-500/20"
+                  />
+              </div>
+              <button
+                  type="button"
+                  class="w-full rounded-md bg-primary-500 px-4 py-2 text-base font-semibold text-white transition hover:bg-secondary-500 disabled:cursor-not-allowed disabled:opacity-60"
+                  :disabled="!form.startDate || isSuspensionSubmitting"
+                  @click="onSubmitSuspension(index)"
+              >
+                  {{ form.id ? 'Modifier' : 'Ajouter' }}
+              </button>
+          </div>
+
+          <button
+              type="button"
+              class="w-full rounded-md border-2 border-dashed border-neutral-300 px-4 py-3 text-base font-semibold text-neutral-500 transition hover:border-primary-500 hover:text-primary-500"
+              @click="onAddSuspensionForm"
+          >
+              + Ajouter une suspension
+          </button>
+      </div>
     </AppDrawer>
 
     <AppDrawer :model-value="isCreateContractDrawerOpen" title="Ajouter un contrat" @update:model-value="onUpdateCreateContractDrawerOpen">
@@ -195,6 +274,13 @@
 import type { Contract } from '~/services/dto/contract'
 import type { ContractHistoryItem } from '~/services/dto/employee'
 
+type SuspensionForm = {
+  id: number | null
+  startDate: string
+  endDate: string
+  comment: string
+}
+
 type ContractForm = {
   contractId: number | ''
   contractName: string
@@ -213,7 +299,7 @@ type CreateContractForm = {
   endDate: string
 }
 
-defineProps<{
+const props = defineProps<{
   contractHistory: ContractHistoryItem[]
   contractNatureLabel: (value?: 'CDI' | 'CDD' | 'INTERIM') => string
   contractHistoryLabel: (item: ContractHistoryItem) => string
@@ -245,5 +331,16 @@ defineProps<{
   onUpdateCreateContractDrawerOpen: (open: boolean) => void
   onSubmitCloseContract: () => void
   onSubmitCreateContract: () => void
+  suspensionForms: SuspensionForm[]
+  isSuspensionSubmitting: boolean
+  onSubmitSuspension: (index: number) => void
+  onAddSuspensionForm: () => void
+  currentContractPeriodId?: number | null
 }>()
+
+const drawerTab = ref<'close' | 'suspend'>('close')
+
+watch(() => props.isContractDrawerOpen, (open) => {
+  if (open) drawerTab.value = 'close'
+})
 </script>
diff --git a/frontend/components/employees/LeaveTab.vue b/frontend/components/employees/LeaveTab.vue
index e85108e..a9d3350 100644
--- a/frontend/components/employees/LeaveTab.vue
+++ b/frontend/components/employees/LeaveTab.vue
@@ -29,7 +29,7 @@
         </div>
         <div class="mt-8 min-h-0 flex-1 overflow-y-auto pr-2">
             <div class="grid grid-cols-4 gap-10">
-                <div v-for="month in months" :key="month.label" class="rounded-md bg-tertiary-500 text-primary-500">
+                <div v-for="month in months" :key="month.label" class="rounded-md bg-tertiary-500 text-primary-500 flex flex-col justify-between">
                     <div class="flex justify-center rounded-t-md bg-primary-500 py-1 font-bold uppercase text-white">
                         {{ month.label }}
                     </div>
@@ -54,6 +54,7 @@
                             </div>
                         </template>
                     </div>
+                    <div class="px-2 py-2 text-center border-t border-primary-500">Jours de présence : {{ summary?.presenceDaysByMonth?.[month.monthKey] ?? 0 }}</div>
                 </div>
             </div>
         </div>
@@ -259,9 +260,12 @@ const months = computed(() => {
             cells.push(null)
         }
 
+        const monthKey = `${monthYear}-${String(monthIndex + 1).padStart(2, '0')}`
+
         return {
             label,
-            cells
+            cells,
+            monthKey
         }
     })
 })
diff --git a/frontend/composables/useEmployeeDetailPage.ts b/frontend/composables/useEmployeeDetailPage.ts
index 5c807d4..b02fb54 100644
--- a/frontend/composables/useEmployeeDetailPage.ts
+++ b/frontend/composables/useEmployeeDetailPage.ts
@@ -12,6 +12,7 @@ import { getEmployee, updateEmployee } from '~/services/employees'
 import { listPublicHolidays } from '~/services/public-holidays'
 import { formatNullableYmdToFr, getTodayYmd, shiftYmd } from '~/utils/date'
 import { contractNatureLabel, isContractNature, requiresContractEndDate, showsContractEndDate } from '~/utils/contract'
+import { createSuspension, updateSuspension } from '~/services/contractSuspensions'
 
 export const useEmployeeDetailPage = () => {
   const route = useRoute()
@@ -29,6 +30,16 @@ export const useEmployeeDetailPage = () => {
   const isCreateContractDrawerOpen = ref(false)
   const isCreateContractSubmitting = ref(false)
 
+  type SuspensionForm = {
+    id: number | null
+    startDate: string
+    endDate: string
+    comment: string
+  }
+
+  const suspensionForms = ref<SuspensionForm[]>([])
+  const isSuspensionSubmitting = ref(false)
+
   const contractForm = reactive({
     contractId: '' as number | '',
     contractName: '',
@@ -83,6 +94,11 @@ export const useEmployeeDetailPage = () => {
     return history.find((item) => item.startDate <= today && (!item.endDate || item.endDate >= today)) ?? null
   })
 
+  const currentActiveContractPeriodId = computed<number | null>(() => {
+    const period = currentActiveContractPeriod.value
+    return period?.periodId ?? null
+  })
+
   const canCloseCurrentContract = computed(() => {
     const active = currentActiveContractPeriod.value
     if (!active) return false
@@ -130,6 +146,16 @@ export const useEmployeeDetailPage = () => {
     validationTouched.endDate = false
   }
 
+  const hydrateSuspensionForms = () => {
+    const current = employee.value?.currentSuspensions ?? []
+    suspensionForms.value = current.map(s => ({
+      id: s.id,
+      startDate: s.startDate,
+      endDate: s.endDate ?? '',
+      comment: s.comment ?? ''
+    }))
+  }
+
   const hydrateContractFormFromCurrent = () => {
     const current = employee.value
     const active = currentActiveContractPeriod.value
@@ -149,6 +175,7 @@ export const useEmployeeDetailPage = () => {
     if (!employee.value || !canCloseCurrentContract.value) return
     hydrateContractFormFromCurrent()
     resetContractValidation()
+    hydrateSuspensionForms()
     isContractDrawerOpen.value = true
   }
 
@@ -301,6 +328,45 @@ export const useEmployeeDetailPage = () => {
     }
   }
 
+  const submitSuspension = async (index: number) => {
+    const form = suspensionForms.value[index]
+    if (!form || !form.startDate) return
+
+    const periodId = currentActiveContractPeriodId.value
+    if (!periodId) return
+
+    isSuspensionSubmitting.value = true
+    try {
+      if (form.id) {
+        await updateSuspension(form.id, {
+          startDate: form.startDate,
+          endDate: form.endDate || null,
+          comment: form.comment || null
+        })
+      } else {
+        await createSuspension({
+          contractPeriodId: periodId,
+          startDate: form.startDate,
+          endDate: form.endDate || null,
+          comment: form.comment || null
+        })
+      }
+      await loadEmployee()
+      hydrateSuspensionForms()
+    } finally {
+      isSuspensionSubmitting.value = false
+    }
+  }
+
+  const addSuspensionForm = () => {
+    suspensionForms.value.push({
+      id: null,
+      startDate: '',
+      endDate: '',
+      comment: ''
+    })
+  }
+
   const submitFractionedDays = async (days: number) => {
     if (!employee.value) return
     const year = leaveSummary.value?.year ?? undefined
@@ -368,6 +434,11 @@ export const useEmployeeDetailPage = () => {
     submitContractUpdate,
     submitCreateContract,
     submitFractionedDays,
-    submitRttPayment
+    submitRttPayment,
+    suspensionForms,
+    isSuspensionSubmitting,
+    submitSuspension,
+    addSuspensionForm,
+    currentActiveContractPeriodId
   }
 }
diff --git a/frontend/pages/employees/[id].vue b/frontend/pages/employees/[id].vue
index 7061be9..91dc74a 100644
--- a/frontend/pages/employees/[id].vue
+++ b/frontend/pages/employees/[id].vue
@@ -91,6 +91,11 @@
                     :on-update-create-contract-drawer-open="setCreateContractDrawerOpen"
                     :on-submit-close-contract="submitContractUpdate"
                     :on-submit-create-contract="submitCreateContract"
+                    :suspension-forms="suspensionForms"
+                    :is-suspension-submitting="isSuspensionSubmitting"
+                    :on-submit-suspension="submitSuspension"
+                    :on-add-suspension-form="addSuspensionForm"
+                    :current-contract-period-id="currentActiveContractPeriodId"
                 />
                 <EmployeesLeaveTab
                     v-else-if="showLeaveTab && activeTab === 'leave'"
@@ -149,7 +154,12 @@ const {
     submitContractUpdate,
     submitCreateContract,
     submitFractionedDays,
-    submitRttPayment
+    submitRttPayment,
+    suspensionForms,
+    isSuspensionSubmitting,
+    submitSuspension,
+    addSuspensionForm,
+    currentActiveContractPeriodId
 } = useEmployeeDetailPage()
 
 useHead(() => ({
diff --git a/frontend/services/contractSuspensions.ts b/frontend/services/contractSuspensions.ts
new file mode 100644
index 0000000..ec74ea6
--- /dev/null
+++ b/frontend/services/contractSuspensions.ts
@@ -0,0 +1,38 @@
+import type { ContractSuspension } from './dto/employee'
+
+export const createSuspension = async (payload: {
+  contractPeriodId: number
+  startDate: string
+  endDate?: string | null
+  comment?: string | null
+}) => {
+  const api = useApi()
+  return api.post<ContractSuspension>('/contract_suspensions', {
+    contractPeriodId: payload.contractPeriodId,
+    startDate: payload.startDate,
+    endDate: payload.endDate ?? null,
+    comment: payload.comment ?? null
+  }, {
+    toastSuccessKey: 'Suspension créée',
+    toastErrorKey: 'Erreur lors de la création de la suspension'
+  })
+}
+
+export const updateSuspension = async (
+  id: number,
+  payload: {
+    startDate: string
+    endDate?: string | null
+    comment?: string | null
+  }
+) => {
+  const api = useApi()
+  return api.patch<ContractSuspension>(`/contract_suspensions/${id}`, {
+    startDate: payload.startDate,
+    endDate: payload.endDate ?? null,
+    comment: payload.comment ?? null
+  }, {
+    toastSuccessKey: 'Suspension modifiée',
+    toastErrorKey: 'Erreur lors de la modification de la suspension'
+  })
+}
diff --git a/frontend/services/dto/employee-leave-summary.ts b/frontend/services/dto/employee-leave-summary.ts
index 723373f..a36cdd2 100644
--- a/frontend/services/dto/employee-leave-summary.ts
+++ b/frontend/services/dto/employee-leave-summary.ts
@@ -10,5 +10,6 @@ export type EmployeeLeaveSummary = {
   takenSaturdays: number
   fractionedDays: number
   accruingDays: number
+  presenceDaysByMonth: Record<string, number>
 }
 
diff --git a/frontend/services/dto/employee.ts b/frontend/services/dto/employee.ts
index c22472e..7f000c1 100644
--- a/frontend/services/dto/employee.ts
+++ b/frontend/services/dto/employee.ts
@@ -1,6 +1,13 @@
 import type { Site } from './site'
 import type { Contract } from './contract'
 
+export type ContractSuspension = {
+  id: number
+  startDate: string
+  endDate?: string | null
+  comment?: string | null
+}
+
 export type ContractHistoryItem = {
   contractId?: number | null
   contractName?: string | null
@@ -9,6 +16,8 @@ export type ContractHistoryItem = {
   startDate: string
   endDate?: string | null
   comment?: string | null
+  periodId?: number | null
+  suspensions?: ContractSuspension[]
 }
 
 export type Employee = {
@@ -23,4 +32,5 @@ export type Employee = {
   contractHistory?: ContractHistoryItem[]
   displayOrder?: number
   entryDate?: string | null
+  currentSuspensions?: ContractSuspension[]
 }
diff --git a/migrations/Version20260312140000.php b/migrations/Version20260312140000.php
new file mode 100644
index 0000000..4ffe70b
--- /dev/null
+++ b/migrations/Version20260312140000.php
@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DoctrineMigrations;
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+final class Version20260312140000 extends AbstractMigration
+{
+    public function getDescription(): string
+    {
+        return 'Create contract_suspensions table';
+    }
+
+    public function up(Schema $schema): void
+    {
+        $this->addSql('CREATE TABLE contract_suspensions (
+            id SERIAL PRIMARY KEY,
+            contract_period_id INT NOT NULL REFERENCES employee_contract_periods(id) ON DELETE CASCADE,
+            start_date DATE NOT NULL,
+            end_date DATE DEFAULT NULL,
+            comment TEXT DEFAULT NULL,
+            created_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL
+        )');
+        $this->addSql('CREATE INDEX idx_suspension_period_start ON contract_suspensions (contract_period_id, start_date)');
+    }
+
+    public function down(Schema $schema): void
+    {
+        $this->addSql('DROP TABLE contract_suspensions');
+    }
+}
diff --git a/src/ApiResource/EmployeeLeaveSummary.php b/src/ApiResource/EmployeeLeaveSummary.php
index 66b1587..95a4173 100644
--- a/src/ApiResource/EmployeeLeaveSummary.php
+++ b/src/ApiResource/EmployeeLeaveSummary.php
@@ -31,4 +31,7 @@ final class EmployeeLeaveSummary
     public float $takenSaturdays     = 0.0;
     public float $fractionedDays     = 0.0;
     public float $accruingDays       = 0.0;
+
+    /** @var array<string, float> YYYY-MM => count (0.5 for half-days) */
+    public array $presenceDaysByMonth = [];
 }
diff --git a/src/Dto/Employees/ContractHistoryItem.php b/src/Dto/Employees/ContractHistoryItem.php
index d6fc7ff..2dce07e 100644
--- a/src/Dto/Employees/ContractHistoryItem.php
+++ b/src/Dto/Employees/ContractHistoryItem.php
@@ -23,5 +23,9 @@ final class ContractHistoryItem
         public ?string $endDate,
         #[Groups(['employee:read'])]
         public ?string $comment = null,
+        #[Groups(['employee:read'])]
+        public ?int $periodId = null,
+        #[Groups(['employee:read'])]
+        public array $suspensions = [],
     ) {}
 }
diff --git a/src/Entity/ContractSuspension.php b/src/Entity/ContractSuspension.php
new file mode 100644
index 0000000..0e12860
--- /dev/null
+++ b/src/Entity/ContractSuspension.php
@@ -0,0 +1,140 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Entity;
+
+use ApiPlatform\Metadata\ApiResource;
+use ApiPlatform\Metadata\GetCollection;
+use ApiPlatform\Metadata\Patch;
+use ApiPlatform\Metadata\Post;
+use App\Repository\ContractSuspensionRepository;
+use App\State\ContractSuspensionWriteProcessor;
+use DateTimeImmutable;
+use Doctrine\ORM\Mapping as ORM;
+use Symfony\Component\Serializer\Attribute\Context;
+use Symfony\Component\Serializer\Attribute\Groups;
+use Symfony\Component\Serializer\Normalizer\DateTimeNormalizer;
+
+#[ApiResource(
+    operations: [
+        new GetCollection(),
+        new Post(processor: ContractSuspensionWriteProcessor::class),
+        new Patch(processor: ContractSuspensionWriteProcessor::class),
+    ],
+    normalizationContext: ['groups' => ['suspension:read']],
+    denormalizationContext: ['groups' => ['suspension:write']],
+    paginationEnabled: false,
+    security: "is_granted('ROLE_ADMIN')",
+)]
+#[ORM\Entity(repositoryClass: ContractSuspensionRepository::class)]
+#[ORM\Table(name: 'contract_suspensions')]
+#[ORM\Index(columns: ['contract_period_id', 'start_date'], name: 'idx_suspension_period_start')]
+class ContractSuspension
+{
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    #[ORM\Column(type: 'integer')]
+    #[Groups(['suspension:read', 'employee:read'])]
+    private ?int $id = null;
+
+    #[ORM\ManyToOne(targetEntity: EmployeeContractPeriod::class, inversedBy: 'suspensions')]
+    #[ORM\JoinColumn(nullable: false, onDelete: 'CASCADE')]
+    private ?EmployeeContractPeriod $contractPeriod = null;
+
+    #[Groups(['suspension:write'])]
+    private ?int $contractPeriodId = null;
+
+    #[ORM\Column(type: 'date_immutable')]
+    #[Groups(['suspension:read', 'suspension:write', 'employee:read'])]
+    #[Context([DateTimeNormalizer::FORMAT_KEY => 'Y-m-d'])]
+    private DateTimeImmutable $startDate;
+
+    #[ORM\Column(type: 'date_immutable', nullable: true)]
+    #[Groups(['suspension:read', 'suspension:write', 'employee:read'])]
+    #[Context([DateTimeNormalizer::FORMAT_KEY => 'Y-m-d'])]
+    private ?DateTimeImmutable $endDate = null;
+
+    #[ORM\Column(type: 'text', nullable: true)]
+    #[Groups(['suspension:read', 'suspension:write', 'employee:read'])]
+    private ?string $comment = null;
+
+    #[ORM\Column(type: 'datetime_immutable')]
+    private DateTimeImmutable $createdAt;
+
+    public function __construct()
+    {
+        $this->createdAt = new DateTimeImmutable();
+        $this->startDate = new DateTimeImmutable('today');
+    }
+
+    public function getContractPeriodId(): ?int
+    {
+        return $this->contractPeriodId;
+    }
+
+    public function setContractPeriodId(?int $contractPeriodId): self
+    {
+        $this->contractPeriodId = $contractPeriodId;
+
+        return $this;
+    }
+
+    public function getId(): ?int
+    {
+        return $this->id;
+    }
+
+    public function getContractPeriod(): ?EmployeeContractPeriod
+    {
+        return $this->contractPeriod;
+    }
+
+    public function setContractPeriod(?EmployeeContractPeriod $contractPeriod): self
+    {
+        $this->contractPeriod = $contractPeriod;
+
+        return $this;
+    }
+
+    public function getStartDate(): DateTimeImmutable
+    {
+        return $this->startDate;
+    }
+
+    public function setStartDate(DateTimeImmutable $startDate): self
+    {
+        $this->startDate = $startDate;
+
+        return $this;
+    }
+
+    public function getEndDate(): ?DateTimeImmutable
+    {
+        return $this->endDate;
+    }
+
+    public function setEndDate(?DateTimeImmutable $endDate): self
+    {
+        $this->endDate = $endDate;
+
+        return $this;
+    }
+
+    public function getComment(): ?string
+    {
+        return $this->comment;
+    }
+
+    public function setComment(?string $comment): self
+    {
+        $this->comment = $comment;
+
+        return $this;
+    }
+
+    public function getCreatedAt(): DateTimeImmutable
+    {
+        return $this->createdAt;
+    }
+}
diff --git a/src/Entity/Employee.php b/src/Entity/Employee.php
index bb1d88f..c3aac91 100644
--- a/src/Entity/Employee.php
+++ b/src/Entity/Employee.php
@@ -263,6 +263,36 @@ class Employee
         return $this->resolveCurrentContractPeriod()?->getEndDate()?->format('Y-m-d');
     }
 
+    /**
+     * @return list<array{id: null|int, startDate: string, endDate: null|string, comment: null|string}>
+     */
+    #[Groups(['employee:read'])]
+    public function getCurrentSuspensions(): array
+    {
+        $currentPeriod = $this->resolveCurrentContractPeriod();
+        if (null === $currentPeriod) {
+            return [];
+        }
+
+        return array_values(array_map(
+            static fn (ContractSuspension $s): array => [
+                'id'        => $s->getId(),
+                'startDate' => $s->getStartDate()->format('Y-m-d'),
+                'endDate'   => $s->getEndDate()?->format('Y-m-d'),
+                'comment'   => $s->getComment(),
+            ],
+            $currentPeriod->getSuspensions()->toArray()
+        ));
+    }
+
+    /**
+     * @return Collection<int, EmployeeContractPeriod>
+     */
+    public function getContractPeriods(): Collection
+    {
+        return $this->contractPeriods;
+    }
+
     /**
      * @return list<ContractHistoryItem>
      */
@@ -279,6 +309,16 @@ class Employee
             static function (EmployeeContractPeriod $period): ContractHistoryItem {
                 $contract = $period->getContract();
 
+                $suspensionData = array_map(
+                    static fn (ContractSuspension $s): array => [
+                        'id'        => $s->getId(),
+                        'startDate' => $s->getStartDate()->format('Y-m-d'),
+                        'endDate'   => $s->getEndDate()?->format('Y-m-d'),
+                        'comment'   => $s->getComment(),
+                    ],
+                    $period->getSuspensions()->toArray()
+                );
+
                 return new ContractHistoryItem(
                     contractId: $contract?->getId(),
                     contractName: $contract?->getName(),
@@ -287,6 +327,8 @@ class Employee
                     startDate: $period->getStartDate()->format('Y-m-d'),
                     endDate: $period->getEndDate()?->format('Y-m-d'),
                     comment: $period->getComment(),
+                    periodId: $period->getId(),
+                    suspensions: $suspensionData,
                 );
             },
             $periods
diff --git a/src/Entity/EmployeeContractPeriod.php b/src/Entity/EmployeeContractPeriod.php
index a01f63a..e87ab49 100644
--- a/src/Entity/EmployeeContractPeriod.php
+++ b/src/Entity/EmployeeContractPeriod.php
@@ -7,6 +7,8 @@ namespace App\Entity;
 use App\Enum\ContractNature;
 use App\Repository\EmployeeContractPeriodRepository;
 use DateTimeImmutable;
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
 
 #[ORM\Entity(repositoryClass: EmployeeContractPeriodRepository::class)]
@@ -43,13 +45,20 @@ class EmployeeContractPeriod
     #[ORM\Column(type: 'text', nullable: true)]
     private ?string $comment = null;
 
+    /**
+     * @var Collection<int, ContractSuspension>
+     */
+    #[ORM\OneToMany(mappedBy: 'contractPeriod', targetEntity: ContractSuspension::class, cascade: ['persist', 'remove'])]
+    private Collection $suspensions;
+
     #[ORM\Column(type: 'datetime_immutable')]
     private DateTimeImmutable $createdAt;
 
     public function __construct()
     {
-        $this->createdAt = new DateTimeImmutable();
-        $this->startDate = new DateTimeImmutable('today');
+        $this->createdAt   = new DateTimeImmutable();
+        $this->startDate   = new DateTimeImmutable('today');
+        $this->suspensions = new ArrayCollection();
     }
 
     public function getId(): ?int
@@ -151,4 +160,12 @@ class EmployeeContractPeriod
 
         return $this;
     }
+
+    /**
+     * @return Collection<int, ContractSuspension>
+     */
+    public function getSuspensions(): Collection
+    {
+        return $this->suspensions;
+    }
 }
diff --git a/src/Repository/ContractSuspensionRepository.php b/src/Repository/ContractSuspensionRepository.php
new file mode 100644
index 0000000..5c44e4c
--- /dev/null
+++ b/src/Repository/ContractSuspensionRepository.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Repository;
+
+use App\Entity\ContractSuspension;
+use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
+use Doctrine\Persistence\ManagerRegistry;
+
+/**
+ * @extends ServiceEntityRepository<ContractSuspension>
+ */
+class ContractSuspensionRepository extends ServiceEntityRepository
+{
+    public function __construct(ManagerRegistry $registry)
+    {
+        parent::__construct($registry, ContractSuspension::class);
+    }
+}
diff --git a/src/Repository/WorkHourRepository.php b/src/Repository/WorkHourRepository.php
index 21eeb4e..5c054ae 100644
--- a/src/Repository/WorkHourRepository.php
+++ b/src/Repository/WorkHourRepository.php
@@ -138,6 +138,48 @@ final class WorkHourRepository extends ServiceEntityRepository implements WorkHo
         return $qb->getQuery()->getOneOrNullResult();
     }
 
+    /**
+     * @return array<string, float> YYYY-MM => presence day count (0.5 for half-days)
+     */
+    public function countPresenceDaysByMonth(Employee $employee, DateTimeImmutable $from, DateTimeImmutable $to): array
+    {
+        $sql = <<<'SQL'
+            SELECT TO_CHAR(work_date, 'YYYY-MM') AS month,
+                   SUM(
+                       CASE
+                           WHEN (morning_from IS NOT NULL OR is_present_morning = true)
+                                AND (afternoon_from IS NOT NULL OR is_present_afternoon = true)
+                           THEN 1.0
+                           WHEN (morning_from IS NOT NULL OR is_present_morning = true)
+                                OR (afternoon_from IS NOT NULL OR is_present_afternoon = true)
+                           THEN 0.5
+                           ELSE 0
+                       END
+                   ) AS cnt
+            FROM work_hours
+            WHERE employee_id = :employee
+              AND work_date >= :from
+              AND work_date <= :to
+              AND (morning_from IS NOT NULL OR is_present_morning = true
+                   OR afternoon_from IS NOT NULL OR is_present_afternoon = true)
+            GROUP BY month
+            SQL;
+
+        $conn = $this->getEntityManager()->getConnection();
+        $rows = $conn->fetchAllAssociative($sql, [
+            'employee' => $employee->getId(),
+            'from'     => $from->format('Y-m-d'),
+            'to'       => $to->format('Y-m-d'),
+        ]);
+
+        $result = [];
+        foreach ($rows as $row) {
+            $result[(string) $row['month']] = (float) $row['cnt'];
+        }
+
+        return $result;
+    }
+
     public function hasPendingSiteValidationForSiteAndDate(int $siteId, DateTimeInterface $date): bool
     {
         $workDate = DateTimeImmutable::createFromInterface($date);
diff --git a/src/Service/Leave/LeaveBalanceComputationService.php b/src/Service/Leave/LeaveBalanceComputationService.php
index 3af9fb2..55b0ad7 100644
--- a/src/Service/Leave/LeaveBalanceComputationService.php
+++ b/src/Service/Leave/LeaveBalanceComputationService.php
@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace App\Service\Leave;
 
 use App\Entity\Absence;
+use App\Entity\ContractSuspension;
 use App\Entity\Employee;
 use App\Enum\LeaveRuleCode;
 use App\Repository\AbsenceRepository;
@@ -29,6 +30,7 @@ final readonly class LeaveBalanceComputationService
         private EmployeeContractPeriodRepository $periodRepository,
         private EmployeeLeaveBalanceRepository $leaveBalanceRepository,
         private PublicHolidayServiceInterface $publicHolidayService,
+        private SuspensionDaysCalculator $suspensionDaysCalculator,
     ) {}
 
     /**
@@ -67,7 +69,18 @@ final readonly class LeaveBalanceComputationService
             $fractionedDays = $this->resolveFractionedDays($employee, $ruleCode, $year);
 
             if (LeaveRuleCode::FORFAIT_218 === $ruleCode) {
-                $acquiredDays               = $carryDays + (float) max(0, $this->countBusinessDays($from, $to) - self::FORFAIT_TARGET_WORKED_DAYS) + $fractionedDays;
+                $totalBusinessDays = $this->countBusinessDays($from, $to);
+                $baseAcquiredDays  = (float) max(0, $totalBusinessDays - self::FORFAIT_TARGET_WORKED_DAYS);
+                $suspensions       = $this->resolveSuspensionsForEmployeePeriod($employee, $from, $to);
+                $acquiredDays      = $carryDays + $baseAcquiredDays + $fractionedDays;
+                if ([] !== $suspensions) {
+                    $totalMonths     = $this->countFractionalMonths($from, $to);
+                    $suspendedMonths = $this->countSuspendedFractionalMonths($from, $to, $suspensions);
+                    if ($totalMonths > 0) {
+                        $ratio        = max(0.0, ($totalMonths - $suspendedMonths) / $totalMonths);
+                        $acquiredDays = $carryDays + $baseAcquiredDays * $ratio + $fractionedDays;
+                    }
+                }
                 $absences                   = $this->absenceRepository->findByEmployeeAndOverlappingDateRange($employee, $effectiveFrom, $to);
                 [$takenDays]                = $this->computeTakenAbsences($absences, $effectiveFrom, $to, false, false);
                 $previousRemainingDays      = max(0.0, $acquiredDays - $takenDays);
@@ -76,17 +89,20 @@ final readonly class LeaveBalanceComputationService
                 continue;
             }
 
+            $suspensions   = $this->resolveSuspensionsForEmployeePeriod($employee, $from, $to);
             $generatedDays = $this->computeAccruedDays(
                 $this->resolveAnnualDays($employee),
                 $this->resolveDaysAccrualPerMonth($employee),
                 $effectiveFrom,
-                $to
+                $to,
+                $suspensions
             );
             $generatedSaturdays = $this->computeAccruedDays(
                 $this->resolveAnnualSaturdays($employee),
                 $this->resolveSaturdayAccrualPerMonth($employee),
                 $effectiveFrom,
-                $to
+                $to,
+                $suspensions
             );
 
             $absences                     = $this->absenceRepository->findByEmployeeAndOverlappingDateRange($employee, $effectiveFrom, $to);
@@ -262,7 +278,8 @@ final readonly class LeaveBalanceComputationService
         float $annualCap,
         float $accrualPerMonth,
         DateTimeImmutable $periodStart,
-        DateTimeImmutable $periodEnd
+        DateTimeImmutable $periodEnd,
+        array $suspensions = []
     ): float {
         if ($accrualPerMonth <= 0.0 || $periodEnd < $periodStart) {
             return 0.0;
@@ -280,6 +297,10 @@ final readonly class LeaveBalanceComputationService
             }
 
             $coveredDays = ((int) $monthEnd->diff($monthStart)->format('%a')) + 1;
+            if ([] !== $suspensions) {
+                $suspendedDays = $this->suspensionDaysCalculator->countSuspendedDaysInMonth($monthStart, $monthEnd, $suspensions);
+                $coveredDays   = max(0, $coveredDays - $suspendedDays);
+            }
             $daysInMonth = (int) $cursor->format('t');
             $coveredMonths += $coveredDays / $daysInMonth;
 
@@ -404,6 +425,80 @@ final readonly class LeaveBalanceComputationService
         return [$takenDays, $takenSaturdays];
     }
 
+    private function countFractionalMonths(DateTimeImmutable $from, DateTimeImmutable $to): float
+    {
+        $from   = $this->normalizeDate($from);
+        $to     = $this->normalizeDate($to);
+        $months = 0.0;
+        $cursor = $from->modify('first day of this month')->setTime(0, 0);
+
+        while ($cursor <= $to) {
+            $monthStart = $cursor > $from ? $cursor : $from;
+            $monthEnd   = $cursor->modify('last day of this month')->setTime(0, 0);
+            if ($monthEnd > $to) {
+                $monthEnd = $to;
+            }
+            $coveredDays = ((int) $monthEnd->diff($monthStart)->format('%a')) + 1;
+            $daysInMonth = (int) $cursor->format('t');
+            $months += $coveredDays / $daysInMonth;
+
+            $cursor = $cursor->modify('first day of next month');
+        }
+
+        return $months;
+    }
+
+    /**
+     * @param list<ContractSuspension> $suspensions
+     */
+    private function countSuspendedFractionalMonths(DateTimeImmutable $from, DateTimeImmutable $to, array $suspensions): float
+    {
+        $from   = $this->normalizeDate($from);
+        $to     = $this->normalizeDate($to);
+        $months = 0.0;
+        $cursor = $from->modify('first day of this month')->setTime(0, 0);
+
+        while ($cursor <= $to) {
+            $monthStart = $cursor > $from ? $cursor : $from;
+            $monthEnd   = $cursor->modify('last day of this month')->setTime(0, 0);
+            if ($monthEnd > $to) {
+                $monthEnd = $to;
+            }
+            $daysInMonth   = (int) $cursor->format('t');
+            $suspendedDays = $this->suspensionDaysCalculator->countSuspendedDaysInMonth($monthStart, $monthEnd, $suspensions);
+            $months += $suspendedDays / $daysInMonth;
+
+            $cursor = $cursor->modify('first day of next month');
+        }
+
+        return $months;
+    }
+
+    /**
+     * @return list<ContractSuspension>
+     */
+    private function resolveSuspensionsForEmployeePeriod(Employee $employee, DateTimeImmutable $from, DateTimeImmutable $to): array
+    {
+        $suspensions = [];
+        foreach ($employee->getContractPeriods() as $period) {
+            $periodStart = $period->getStartDate();
+            $periodEnd   = $period->getEndDate();
+
+            if ($periodStart > $to) {
+                continue;
+            }
+            if ($periodEnd instanceof DateTimeImmutable && $periodEnd < $from) {
+                continue;
+            }
+
+            foreach ($period->getSuspensions() as $suspension) {
+                $suspensions[] = $suspension;
+            }
+        }
+
+        return $suspensions;
+    }
+
     /**
      * @return array{bool, bool}
      */
diff --git a/src/Service/Leave/SuspensionDaysCalculator.php b/src/Service/Leave/SuspensionDaysCalculator.php
new file mode 100644
index 0000000..ff52825
--- /dev/null
+++ b/src/Service/Leave/SuspensionDaysCalculator.php
@@ -0,0 +1,77 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service\Leave;
+
+use App\Entity\ContractSuspension;
+use DateTimeImmutable;
+
+final class SuspensionDaysCalculator
+{
+    /**
+     * Count calendar days suspended within a month window [monthStart, monthEnd].
+     *
+     * @param list<ContractSuspension> $suspensions
+     */
+    public function countSuspendedDaysInMonth(
+        DateTimeImmutable $monthStart,
+        DateTimeImmutable $monthEnd,
+        array $suspensions
+    ): int {
+        $total = 0;
+
+        foreach ($suspensions as $suspension) {
+            $sStart = $suspension->getStartDate();
+            $sEnd   = $suspension->getEndDate() ?? $monthEnd;
+
+            $overlapStart = $sStart > $monthStart ? $sStart : $monthStart;
+            $overlapEnd   = $sEnd < $monthEnd ? $sEnd : $monthEnd;
+
+            if ($overlapStart > $overlapEnd) {
+                continue;
+            }
+
+            $total += ((int) $overlapEnd->diff($overlapStart)->format('%a')) + 1;
+        }
+
+        return $total;
+    }
+
+    /**
+     * Count business days (Mon-Fri, excl. public holidays) suspended within a period.
+     *
+     * @param list<ContractSuspension> $suspensions
+     * @param array<string, string>    $publicHolidays map of Y-m-d => label
+     */
+    public function countSuspendedBusinessDays(
+        DateTimeImmutable $periodStart,
+        DateTimeImmutable $periodEnd,
+        array $suspensions,
+        array $publicHolidays
+    ): int {
+        $total = 0;
+
+        foreach ($suspensions as $suspension) {
+            $sStart = $suspension->getStartDate();
+            $sEnd   = $suspension->getEndDate() ?? $periodEnd;
+
+            $overlapStart = $sStart > $periodStart ? $sStart : $periodStart;
+            $overlapEnd   = $sEnd < $periodEnd ? $sEnd : $periodEnd;
+
+            if ($overlapStart > $overlapEnd) {
+                continue;
+            }
+
+            for ($cursor = $overlapStart; $cursor <= $overlapEnd; $cursor = $cursor->modify('+1 day')) {
+                $weekDay = (int) $cursor->format('N');
+                $dayKey  = $cursor->format('Y-m-d');
+                if ($weekDay <= 5 && !isset($publicHolidays[$dayKey])) {
+                    ++$total;
+                }
+            }
+        }
+
+        return $total;
+    }
+}
diff --git a/src/State/ContractSuspensionWriteProcessor.php b/src/State/ContractSuspensionWriteProcessor.php
new file mode 100644
index 0000000..eb8db67
--- /dev/null
+++ b/src/State/ContractSuspensionWriteProcessor.php
@@ -0,0 +1,122 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\State;
+
+use ApiPlatform\Metadata\Operation;
+use ApiPlatform\State\ProcessorInterface;
+use App\Entity\ContractSuspension;
+use App\Entity\EmployeeContractPeriod;
+use DateTimeImmutable;
+use Doctrine\ORM\EntityManagerInterface;
+use Symfony\Component\DependencyInjection\Attribute\Autowire;
+use Symfony\Component\HttpKernel\Exception\UnprocessableEntityHttpException;
+
+final readonly class ContractSuspensionWriteProcessor implements ProcessorInterface
+{
+    public function __construct(
+        #[Autowire(service: 'api_platform.doctrine.orm.state.persist_processor')]
+        private ProcessorInterface $persistProcessor,
+        private EntityManagerInterface $entityManager,
+    ) {}
+
+    public function process(
+        mixed $data,
+        Operation $operation,
+        array $uriVariables = [],
+        array $context = []
+    ): mixed {
+        if (!$data instanceof ContractSuspension) {
+            return $this->persistProcessor->process($data, $operation, $uriVariables, $context);
+        }
+
+        $period = $data->getContractPeriod();
+
+        if (!$period instanceof EmployeeContractPeriod && null !== $data->getContractPeriodId()) {
+            $period = $this->entityManager->find(EmployeeContractPeriod::class, $data->getContractPeriodId());
+            if ($period instanceof EmployeeContractPeriod) {
+                $data->setContractPeriod($period);
+            }
+        }
+
+        if (!$period instanceof EmployeeContractPeriod) {
+            throw new UnprocessableEntityHttpException('contractPeriodId is required.');
+        }
+
+        $this->validate($data, $period);
+
+        return $this->persistProcessor->process($data, $operation, $uriVariables, $context);
+    }
+
+    private function validate(ContractSuspension $suspension, EmployeeContractPeriod $period): void
+    {
+        // Compare as Y-m-d strings to avoid timezone issues between Doctrine and API Platform DateTimeImmutable
+        $startDate   = $suspension->getStartDate()->format('Y-m-d');
+        $endDate     = $suspension->getEndDate()?->format('Y-m-d');
+        $periodStart = $period->getStartDate()->format('Y-m-d');
+        $periodEnd   = $period->getEndDate()?->format('Y-m-d');
+
+        if (null !== $periodEnd && $periodEnd < new DateTimeImmutable('today')->format('Y-m-d')) {
+            throw new UnprocessableEntityHttpException('Impossible de suspendre une période de contrat clôturée.');
+        }
+
+        if (null !== $endDate && $endDate < $startDate) {
+            throw new UnprocessableEntityHttpException('La date de fin doit être postérieure à la date de début.');
+        }
+
+        if ($startDate < $periodStart) {
+            throw new UnprocessableEntityHttpException('La suspension ne peut pas commencer avant le début du contrat.');
+        }
+
+        if (null !== $periodEnd) {
+            if ($startDate > $periodEnd) {
+                throw new UnprocessableEntityHttpException('La suspension ne peut pas commencer après la fin du contrat.');
+            }
+            if (null !== $endDate && $endDate > $periodEnd) {
+                throw new UnprocessableEntityHttpException('La suspension ne peut pas se terminer après la fin du contrat.');
+            }
+        }
+
+        $this->validateNoOverlap($suspension, $period);
+    }
+
+    private function validateNoOverlap(ContractSuspension $suspension, EmployeeContractPeriod $period): void
+    {
+        $start = $suspension->getStartDate()->format('Y-m-d');
+        $end   = $suspension->getEndDate()?->format('Y-m-d');
+
+        foreach ($period->getSuspensions() as $existing) {
+            if ($existing->getId() === $suspension->getId() && null !== $suspension->getId()) {
+                continue;
+            }
+
+            $existingStart = $existing->getStartDate()->format('Y-m-d');
+            $existingEnd   = $existing->getEndDate()?->format('Y-m-d');
+
+            if (null === $end && null === $existingEnd) {
+                throw new UnprocessableEntityHttpException('Les suspensions ne peuvent pas se chevaucher.');
+            }
+
+            if (null === $end) {
+                if ($start <= $existingEnd) {
+                    throw new UnprocessableEntityHttpException('Les suspensions ne peuvent pas se chevaucher.');
+                }
+
+                continue;
+            }
+
+            if (null === $existingEnd) {
+                if ($existingStart <= $end) {
+                    throw new UnprocessableEntityHttpException('Les suspensions ne peuvent pas se chevaucher.');
+                }
+
+                continue;
+            }
+
+            if ($start <= $existingEnd && $end >= $existingStart) {
+                throw new UnprocessableEntityHttpException('Les suspensions ne peuvent pas se chevaucher.');
+            }
+        }
+    }
+}
diff --git a/src/State/EmployeeLeaveSummaryProvider.php b/src/State/EmployeeLeaveSummaryProvider.php
index fbecb82..9cd5216 100644
--- a/src/State/EmployeeLeaveSummaryProvider.php
+++ b/src/State/EmployeeLeaveSummaryProvider.php
@@ -8,6 +8,7 @@ use ApiPlatform\Metadata\Operation;
 use ApiPlatform\State\ProviderInterface;
 use App\ApiResource\EmployeeLeaveSummary;
 use App\Entity\Absence;
+use App\Entity\ContractSuspension;
 use App\Entity\Employee;
 use App\Entity\User;
 use App\Enum\ContractNature;
@@ -17,8 +18,10 @@ use App\Repository\AbsenceRepository;
 use App\Repository\EmployeeContractPeriodRepository;
 use App\Repository\EmployeeLeaveBalanceRepository;
 use App\Repository\EmployeeRepository;
+use App\Repository\WorkHourRepository;
 use App\Security\EmployeeScopeService;
 use App\Service\Leave\LeaveBalanceComputationService;
+use App\Service\Leave\SuspensionDaysCalculator;
 use App\Service\PublicHolidayServiceInterface;
 use DateTimeImmutable;
 use Symfony\Bundle\SecurityBundle\Security;
@@ -50,6 +53,8 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
         private EmployeeLeaveBalanceRepository $leaveBalanceRepository,
         private LeaveBalanceComputationService $leaveBalanceComputationService,
         private PublicHolidayServiceInterface $publicHolidayService,
+        private SuspensionDaysCalculator $suspensionDaysCalculator,
+        private WorkHourRepository $workHourRepository,
     ) {}
 
     public function provide(Operation $operation, array $uriVariables = [], array $context = []): EmployeeLeaveSummary
@@ -97,6 +102,9 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
         $summary->remainingDays      = $yearSummary['remainingDays'] + $fractionedDays;
         $summary->remainingSaturdays = $yearSummary['remainingSaturdays'];
 
+        [$periodFrom, $periodTo]      = $this->resolvePeriodBounds($employee, $year);
+        $summary->presenceDaysByMonth = $this->workHourRepository->countPresenceDaysByMonth($employee, $periodFrom, $periodTo);
+
         return $summary;
     }
 
@@ -170,12 +178,14 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
 
             $accrualCalculationEnd = $this->resolveAccrualCalculationEndDate($leavePolicy['ruleCode'], $year, $to, $employee);
             $takenCalculationEnd   = $this->resolveTakenCalculationEndDate($to, $employee);
+            $suspensions           = $this->resolveSuspensionsForPeriod($employee, $effectiveFrom, $to);
             $generatedDays         = $leavePolicy['accrualPerMonth'] > 0.0
                 ? $this->computeAccruedDaysFromStart(
                     $leavePolicy['acquiredDays'],
                     $leavePolicy['accrualPerMonth'],
                     $effectiveFrom,
-                    $accrualCalculationEnd
+                    $accrualCalculationEnd,
+                    $suspensions
                 )
                 : 0.0;
             $generatedSaturdays = $leavePolicy['saturdayAccrualPerMonth'] > 0.0
@@ -183,7 +193,8 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
                     $leavePolicy['acquiredSaturdays'],
                     $leavePolicy['saturdayAccrualPerMonth'],
                     $effectiveFrom,
-                    $accrualCalculationEnd
+                    $accrualCalculationEnd,
+                    $suspensions
                 )
                 : 0.0;
             $absences                     = $this->absenceRepository->findByEmployeeAndOverlappingDateRange($employee, $from, $to);
@@ -224,7 +235,16 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
                 $previousRemainingSaturdays = $remainingAcquiredSaturdays + $remainingGeneratedSaturdays;
             } else {
                 // Forfait: no "en cours d'acquisition" counter, all rights are in acquired.
-                $acquiredDays       = $carryDays + $leavePolicy['acquiredDays'];
+                $acquiredDays = $carryDays + $leavePolicy['acquiredDays'];
+                $suspensions  = $this->resolveSuspensionsForPeriod($employee, $from, $to);
+                if ([] !== $suspensions) {
+                    $totalMonths     = $this->countFractionalMonths($from, $to);
+                    $suspendedMonths = $this->countSuspendedFractionalMonths($from, $to, $suspensions);
+                    if ($totalMonths > 0) {
+                        $ratio        = max(0.0, ($totalMonths - $suspendedMonths) / $totalMonths);
+                        $acquiredDays = $carryDays + $leavePolicy['acquiredDays'] * $ratio;
+                    }
+                }
                 $accruingDays       = 0.0;
                 $remainingDays      = max(0.0, $acquiredDays - $takenDays);
                 $acquiredSaturdays  = 0.0;
@@ -334,7 +354,8 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
         float $acquiredDays,
         float $accrualPerMonth,
         DateTimeImmutable $periodStart,
-        ?DateTimeImmutable $periodEnd
+        ?DateTimeImmutable $periodEnd,
+        array $suspensions = []
     ): float {
         if ($accrualPerMonth <= 0.0) {
             return $acquiredDays;
@@ -356,6 +377,10 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
             }
 
             $coveredDays = ((int) $monthEnd->diff($monthStart)->format('%a')) + 1;
+            if ([] !== $suspensions) {
+                $suspendedDays = $this->suspensionDaysCalculator->countSuspendedDaysInMonth($monthStart, $monthEnd, $suspensions);
+                $coveredDays   = max(0, $coveredDays - $suspendedDays);
+            }
             $daysInMonth = (int) $cursor->format('t');
             $coveredMonths += $coveredDays / $daysInMonth;
 
@@ -706,6 +731,80 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
         return [$takenDays, $takenSaturdays];
     }
 
+    private function countFractionalMonths(DateTimeImmutable $from, DateTimeImmutable $to): float
+    {
+        $from   = $this->normalizeDate($from);
+        $to     = $this->normalizeDate($to);
+        $months = 0.0;
+        $cursor = $from->modify('first day of this month')->setTime(0, 0);
+
+        while ($cursor <= $to) {
+            $monthStart = $cursor > $from ? $cursor : $from;
+            $monthEnd   = $cursor->modify('last day of this month')->setTime(0, 0);
+            if ($monthEnd > $to) {
+                $monthEnd = $to;
+            }
+            $coveredDays = ((int) $monthEnd->diff($monthStart)->format('%a')) + 1;
+            $daysInMonth = (int) $cursor->format('t');
+            $months += $coveredDays / $daysInMonth;
+
+            $cursor = $cursor->modify('first day of next month');
+        }
+
+        return $months;
+    }
+
+    /**
+     * @param list<ContractSuspension> $suspensions
+     */
+    private function countSuspendedFractionalMonths(DateTimeImmutable $from, DateTimeImmutable $to, array $suspensions): float
+    {
+        $from   = $this->normalizeDate($from);
+        $to     = $this->normalizeDate($to);
+        $months = 0.0;
+        $cursor = $from->modify('first day of this month')->setTime(0, 0);
+
+        while ($cursor <= $to) {
+            $monthStart = $cursor > $from ? $cursor : $from;
+            $monthEnd   = $cursor->modify('last day of this month')->setTime(0, 0);
+            if ($monthEnd > $to) {
+                $monthEnd = $to;
+            }
+            $daysInMonth   = (int) $cursor->format('t');
+            $suspendedDays = $this->suspensionDaysCalculator->countSuspendedDaysInMonth($monthStart, $monthEnd, $suspensions);
+            $months += $suspendedDays / $daysInMonth;
+
+            $cursor = $cursor->modify('first day of next month');
+        }
+
+        return $months;
+    }
+
+    /**
+     * @return list<ContractSuspension>
+     */
+    private function resolveSuspensionsForPeriod(Employee $employee, DateTimeImmutable $from, DateTimeImmutable $to): array
+    {
+        $suspensions = [];
+        foreach ($employee->getContractPeriods() as $period) {
+            $periodStart = $period->getStartDate();
+            $periodEnd   = $period->getEndDate();
+
+            if ($periodStart > $to) {
+                continue;
+            }
+            if ($periodEnd instanceof DateTimeImmutable && $periodEnd < $from) {
+                continue;
+            }
+
+            foreach ($period->getSuspensions() as $suspension) {
+                $suspensions[] = $suspension;
+            }
+        }
+
+        return $suspensions;
+    }
+
     /**
      * @return array{bool, bool}
      */
diff --git a/tests/Service/Leave/LeaveBalanceComputationServiceTest.php b/tests/Service/Leave/LeaveBalanceComputationServiceTest.php
index 714055c..2526361 100644
--- a/tests/Service/Leave/LeaveBalanceComputationServiceTest.php
+++ b/tests/Service/Leave/LeaveBalanceComputationServiceTest.php
@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace App\Tests\Service\Leave;
 
 use App\Service\Leave\LeaveBalanceComputationService;
+use App\Service\Leave\SuspensionDaysCalculator;
 use DateTimeImmutable;
 use PHPUnit\Framework\TestCase;
 use ReflectionClass;
@@ -16,7 +17,7 @@ final class LeaveBalanceComputationServiceTest extends TestCase
 {
     public function testComputeAccruedDaysProratesPartialFirstMonth(): void
     {
-        $service = new ReflectionClass(LeaveBalanceComputationService::class)->newInstanceWithoutConstructor();
+        $service = $this->createServiceWithoutConstructor();
         $method  = new ReflectionClass(LeaveBalanceComputationService::class)->getMethod('computeAccruedDays');
 
         $result = $method->invoke(
@@ -32,7 +33,7 @@ final class LeaveBalanceComputationServiceTest extends TestCase
 
     public function testComputeAccruedDaysTotalMatchesAlainCase(): void
     {
-        $service = new ReflectionClass(LeaveBalanceComputationService::class)->newInstanceWithoutConstructor();
+        $service = $this->createServiceWithoutConstructor();
         $method  = new ReflectionClass(LeaveBalanceComputationService::class)->getMethod('computeAccruedDays');
 
         $days = $method->invoke(
@@ -55,7 +56,7 @@ final class LeaveBalanceComputationServiceTest extends TestCase
 
     public function testComputeAccruedDaysIncludesLastDayOfMonthDespiteTimeComponents(): void
     {
-        $service = new ReflectionClass(LeaveBalanceComputationService::class)->newInstanceWithoutConstructor();
+        $service = $this->createServiceWithoutConstructor();
         $method  = new ReflectionClass(LeaveBalanceComputationService::class)->getMethod('computeAccruedDays');
 
         $result = $method->invoke(
@@ -68,4 +69,15 @@ final class LeaveBalanceComputationServiceTest extends TestCase
 
         self::assertEqualsWithDelta(25.0 / 12.0, $result, 0.0001);
     }
+
+    private function createServiceWithoutConstructor(): LeaveBalanceComputationService
+    {
+        $rc      = new ReflectionClass(LeaveBalanceComputationService::class);
+        $service = $rc->newInstanceWithoutConstructor();
+
+        $prop = $rc->getProperty('suspensionDaysCalculator');
+        $prop->setValue($service, new SuspensionDaysCalculator());
+
+        return $service;
+    }
 }
diff --git a/tests/Service/Leave/SuspensionDaysCalculatorTest.php b/tests/Service/Leave/SuspensionDaysCalculatorTest.php
new file mode 100644
index 0000000..f1181ed
--- /dev/null
+++ b/tests/Service/Leave/SuspensionDaysCalculatorTest.php
@@ -0,0 +1,141 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Service\Leave;
+
+use App\Entity\ContractSuspension;
+use App\Service\Leave\SuspensionDaysCalculator;
+use DateTimeImmutable;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @internal
+ */
+final class SuspensionDaysCalculatorTest extends TestCase
+{
+    public function testNoSuspensionsReturnsZero(): void
+    {
+        $calc   = new SuspensionDaysCalculator();
+        $result = $calc->countSuspendedDaysInMonth(
+            new DateTimeImmutable('2026-03-01'),
+            new DateTimeImmutable('2026-03-31'),
+            []
+        );
+
+        self::assertSame(0, $result);
+    }
+
+    public function testFullMonthSuspension(): void
+    {
+        $calc       = new SuspensionDaysCalculator();
+        $suspension = $this->buildSuspension('2026-03-01', '2026-03-31');
+
+        $result = $calc->countSuspendedDaysInMonth(
+            new DateTimeImmutable('2026-03-01'),
+            new DateTimeImmutable('2026-03-31'),
+            [$suspension]
+        );
+
+        self::assertSame(31, $result);
+    }
+
+    public function testPartialMonthSuspension(): void
+    {
+        $calc       = new SuspensionDaysCalculator();
+        $suspension = $this->buildSuspension('2026-03-10', '2026-03-20');
+
+        $result = $calc->countSuspendedDaysInMonth(
+            new DateTimeImmutable('2026-03-01'),
+            new DateTimeImmutable('2026-03-31'),
+            [$suspension]
+        );
+
+        self::assertSame(11, $result);
+    }
+
+    public function testSuspensionSpanningMultipleMonths(): void
+    {
+        $calc       = new SuspensionDaysCalculator();
+        $suspension = $this->buildSuspension('2026-02-15', '2026-04-10');
+
+        // March fully covered
+        $result = $calc->countSuspendedDaysInMonth(
+            new DateTimeImmutable('2026-03-01'),
+            new DateTimeImmutable('2026-03-31'),
+            [$suspension]
+        );
+
+        self::assertSame(31, $result);
+    }
+
+    public function testSuspensionWithoutEndDate(): void
+    {
+        $calc       = new SuspensionDaysCalculator();
+        $suspension = $this->buildSuspension('2026-03-15', null);
+
+        $result = $calc->countSuspendedDaysInMonth(
+            new DateTimeImmutable('2026-03-01'),
+            new DateTimeImmutable('2026-03-31'),
+            [$suspension]
+        );
+
+        self::assertSame(17, $result);
+    }
+
+    public function testMultipleSuspensionsInSameMonth(): void
+    {
+        $calc = new SuspensionDaysCalculator();
+        $s1   = $this->buildSuspension('2026-03-01', '2026-03-10');
+        $s2   = $this->buildSuspension('2026-03-20', '2026-03-25');
+
+        $result = $calc->countSuspendedDaysInMonth(
+            new DateTimeImmutable('2026-03-01'),
+            new DateTimeImmutable('2026-03-31'),
+            [$s1, $s2]
+        );
+
+        self::assertSame(16, $result);
+    }
+
+    public function testSuspensionOutsideMonthReturnsZero(): void
+    {
+        $calc       = new SuspensionDaysCalculator();
+        $suspension = $this->buildSuspension('2026-01-01', '2026-01-31');
+
+        $result = $calc->countSuspendedDaysInMonth(
+            new DateTimeImmutable('2026-03-01'),
+            new DateTimeImmutable('2026-03-31'),
+            [$suspension]
+        );
+
+        self::assertSame(0, $result);
+    }
+
+    public function testCountSuspendedBusinessDays(): void
+    {
+        $calc = new SuspensionDaysCalculator();
+        // March 2-6, 2026 = Mon-Fri = 5 business days
+        $suspension = $this->buildSuspension('2026-03-02', '2026-03-06');
+
+        $result = $calc->countSuspendedBusinessDays(
+            new DateTimeImmutable('2026-01-01'),
+            new DateTimeImmutable('2026-12-31'),
+            [$suspension],
+            []
+        );
+
+        self::assertSame(5, $result);
+    }
+
+    private function buildSuspension(string $start, ?string $end): ContractSuspension
+    {
+        $s = new ContractSuspension();
+        $s->setStartDate(new DateTimeImmutable($start));
+        if (null !== $end) {
+            $s->setEndDate(new DateTimeImmutable($end));
+        }
+
+        return $s;
+    }
+}
diff --git a/tests/State/ContractSuspensionWriteProcessorTest.php b/tests/State/ContractSuspensionWriteProcessorTest.php
new file mode 100644
index 0000000..7ee8256
--- /dev/null
+++ b/tests/State/ContractSuspensionWriteProcessorTest.php
@@ -0,0 +1,132 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\State;
+
+use ApiPlatform\Metadata\Post;
+use ApiPlatform\State\ProcessorInterface;
+use App\Entity\ContractSuspension;
+use App\Entity\EmployeeContractPeriod;
+use App\Enum\ContractNature;
+use App\State\ContractSuspensionWriteProcessor;
+use DateTimeImmutable;
+use Doctrine\ORM\EntityManagerInterface;
+use PHPUnit\Framework\TestCase;
+use ReflectionProperty;
+use Symfony\Component\HttpKernel\Exception\UnprocessableEntityHttpException;
+
+/**
+ * @internal
+ */
+final class ContractSuspensionWriteProcessorTest extends TestCase
+{
+    public function testPersistsValidSuspension(): void
+    {
+        $period     = $this->buildPeriodWithId(1, '2026-01-01', null);
+        $suspension = new ContractSuspension();
+        $suspension->setContractPeriod($period);
+        $suspension->setStartDate(new DateTimeImmutable('2026-03-01'));
+        $suspension->setEndDate(new DateTimeImmutable('2026-04-30'));
+        $suspension->setComment('Congé sans solde');
+
+        $persistProcessor = $this->createMock(ProcessorInterface::class);
+        $persistProcessor->expects(self::once())->method('process')->willReturn($suspension);
+
+        $entityManager = $this->createStub(EntityManagerInterface::class);
+
+        $processor = new ContractSuspensionWriteProcessor($persistProcessor, $entityManager);
+        $result    = $processor->process($suspension, new Post());
+
+        self::assertSame($suspension, $result);
+    }
+
+    public function testRejectsEndDateBeforeStartDate(): void
+    {
+        $period     = $this->buildPeriodWithId(1, '2026-01-01', null);
+        $suspension = new ContractSuspension();
+        $suspension->setContractPeriod($period);
+        $suspension->setStartDate(new DateTimeImmutable('2026-05-01'));
+        $suspension->setEndDate(new DateTimeImmutable('2026-03-01'));
+
+        $persistProcessor = $this->createStub(ProcessorInterface::class);
+        $entityManager    = $this->createStub(EntityManagerInterface::class);
+
+        $processor = new ContractSuspensionWriteProcessor($persistProcessor, $entityManager);
+
+        $this->expectException(UnprocessableEntityHttpException::class);
+        $processor->process($suspension, new Post());
+    }
+
+    public function testRejectsStartDateBeforePeriodStart(): void
+    {
+        $period     = $this->buildPeriodWithId(1, '2026-06-01', null);
+        $suspension = new ContractSuspension();
+        $suspension->setContractPeriod($period);
+        $suspension->setStartDate(new DateTimeImmutable('2026-01-01'));
+
+        $persistProcessor = $this->createStub(ProcessorInterface::class);
+        $entityManager    = $this->createStub(EntityManagerInterface::class);
+
+        $processor = new ContractSuspensionWriteProcessor($persistProcessor, $entityManager);
+
+        $this->expectException(UnprocessableEntityHttpException::class);
+        $processor->process($suspension, new Post());
+    }
+
+    public function testRejectsOverlappingSuspension(): void
+    {
+        $period = $this->buildPeriodWithId(1, '2026-01-01', null);
+
+        $existing = new ContractSuspension();
+        $existing->setContractPeriod($period);
+        $existing->setStartDate(new DateTimeImmutable('2026-03-01'));
+        $existing->setEndDate(new DateTimeImmutable('2026-04-30'));
+        $period->getSuspensions()->add($existing);
+
+        $suspension = new ContractSuspension();
+        $suspension->setContractPeriod($period);
+        $suspension->setStartDate(new DateTimeImmutable('2026-04-01'));
+        $suspension->setEndDate(new DateTimeImmutable('2026-05-31'));
+
+        $persistProcessor = $this->createStub(ProcessorInterface::class);
+        $entityManager    = $this->createStub(EntityManagerInterface::class);
+
+        $processor = new ContractSuspensionWriteProcessor($persistProcessor, $entityManager);
+
+        $this->expectException(UnprocessableEntityHttpException::class);
+        $processor->process($suspension, new Post());
+    }
+
+    public function testRejectsClosedPeriod(): void
+    {
+        $period     = $this->buildPeriodWithId(1, '2025-01-01', '2025-12-31');
+        $suspension = new ContractSuspension();
+        $suspension->setContractPeriod($period);
+        $suspension->setStartDate(new DateTimeImmutable('2025-06-01'));
+        $suspension->setEndDate(new DateTimeImmutable('2025-07-31'));
+
+        $persistProcessor = $this->createStub(ProcessorInterface::class);
+        $entityManager    = $this->createStub(EntityManagerInterface::class);
+
+        $processor = new ContractSuspensionWriteProcessor($persistProcessor, $entityManager);
+
+        $this->expectException(UnprocessableEntityHttpException::class);
+        $processor->process($suspension, new Post());
+    }
+
+    private function buildPeriodWithId(int $id, string $start, ?string $end): EmployeeContractPeriod
+    {
+        $period = new EmployeeContractPeriod();
+        $period->setStartDate(new DateTimeImmutable($start));
+        if (null !== $end) {
+            $period->setEndDate(new DateTimeImmutable($end));
+        }
+        $period->setContractNature(ContractNature::CDI);
+
+        $ref = new ReflectionProperty($period, 'id');
+        $ref->setValue($period, $id);
+
+        return $period;
+    }
+}