WP-05 : moteur de règles de convention, effectif-daté

Le planning cesse d'être un tableur : il est confronté aux durées légales et
conventionnelles à chaque écriture.

Domaine — dix-huit règles pures
- `src/domain/compliance/` : chaque règle est une fonction pure, testée à sa
  borne exacte. La valeur limite passe, un cran au-delà déclenche — c'est la
  seule forme de test qui protège d'une inégalité écrite à l'envers, et une
  inégalité à l'envers sur un repos quotidien est une infraction que personne
  ne verra.
- 58 tests de règles, 14 sur les tranches d'heures : 43 h donnent 8 h à +25 %,
  45 h donnent 8 h à +25 % et 2 h à +50 %.

Aucune valeur dans le code
- Les seuils vivent en base (`CollectiveAgreement.parameters`), validés par un
  schéma Zod qui refuse un jeu amputé : un seuil manquant lu comme `undefined`
  désactiverait silencieusement une règle de sécurité.
- Un test charge deux jeux différents et vérifie que les résultats diffèrent.
- `MAX_DAILY_AMPLITUDE` reste muette : l'IDCC 1517 ne fixe pas d'amplitude
  quotidienne. Inventer une borne ferait désactiver l'ensemble des alertes par
  le premier manager excédé.

Effectif-datage — exigence n° 1 de la matrice
- Les versions de convention coexistent ; un trigger PostgreSQL refuse de
  réécrire le contenu d'une version publiée, tout en laissant enregistrer une
  approbation postérieure.
- Chaque constat mémorise la version appliquée. Un test d'intégration pose deux
  versions et vérifie qu'une semaine de mars n'est pas jugée sur la règle
  publiée en juillet.

Dimanche — la double contrepartie
Le taux de 100 % ne vient pas de la convention : l'IDCC 1517 n'en fixe aucun, et
l'entreprise n'a pas d'accord. Il vient de l'article L3132-27, qui impose la
rémunération doublée **et** un repos compensateur d'égale durée. Le moteur
produit les deux ; un test échoue si l'un manque. Le quota des douze dimanches
du maire est opposable, avec la liste arrêtée par établissement.

Restitution
- Les bloquants — chevauchement, créneau pendant une absence — annulent la
  transaction : mieux vaut refuser une saisie que garder un planning dont les
  heures se comptent deux fois.
- Les avertissements se franchissent, avec un motif enregistré sur chaque
  constat et une entrée d'audit. Le constat acquitté reste affiché avec sa
  justification : le faire disparaître donnerait l'illusion qu'il a été résolu
  alors qu'il a été assumé.
- Une modification revalide la semaine **et ses voisines** : le repos entre
  dimanche soir et lundi matin appartient à deux semaines.

Règles de mineurs — non implémentées, volontairement
La matrice ne couvre que les majeurs et le dossier n'a aucune source primaire
sur les moins de 18 ans. Les codes sont réservés, les seuils absents. Les
inventer donnerait une fausse assurance sur la population que le droit protège
le plus.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cr9dkEHwbDgkWPnyGj1Rjv

tests/integration/compliance.test.ts

@@ -0,0 +1,232 @@
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+
+import { IDCC_1517_PARAMETERS } from '@/domain/compliance/idcc1517';
+import { zonedInstant } from '@/domain/planning/week';
+
+/**
+ * Le moteur branché sur la base — PLAN.md §12.2.
+ *
+ * Ce que ces tests vérifient, et que les tests de règles ne peuvent pas
+ * vérifier : qu'une semaine ancienne reste évaluée avec les paramètres qui
+ * s'appliquaient **alors**. C'est l'exigence n° 1 de la matrice — reproduire à
+ * l'identique une paie antérieure après un changement de règle — et elle ne se
+ * démontre qu'avec deux versions coexistantes en base.
+ */
+
+const enabled = (process.env.DATABASE_URL ?? '').length > 0;
+const describeIfDb = enabled ? describe : describe.skip;
+
+const TZ = 'Europe/Paris';
+const suffix = `cmp-${Date.now()}`;
+const accountId = `${suffix}-account`;
+const locationId = `${suffix}-loc`;
+const teamId = `${suffix}-team`;
+const membershipId = `${suffix}-member`;
+
+let agreementFor: typeof import('@/server/compliance/evaluate').agreementFor;
+let evaluateSchedule: typeof import('@/server/compliance/evaluate').evaluateSchedule;
+let withTenant: typeof import('@/server/tenant').withTenant;
+let unscoped: typeof import('@/server/tenant').unscoped;
+
+/** 10 h de travail : conforme à 10 h, non conforme à 8 h. */
+function tenHourShift(scheduleId: string, date: string) {
+  return {
+    accountId,
+    weeklyScheduleId: scheduleId,
+    membershipId,
+    localDate: new Date(`${date}T00:00:00Z`),
+    startAt: zonedInstant(date, '08:00', TZ),
+    endAt: zonedInstant(date, '18:00', TZ),
+    breakMinutes: 0,
+  };
+}
+
+describeIfDb('moteur de conformité en base', () => {
+  let marchSchedule = '';
+  let augustSchedule = '';
+
+  beforeAll(async () => {
+    process.env.ENCRYPTION_KEY ??= Buffer.alloc(32, 3).toString('base64');
+    ({ agreementFor, evaluateSchedule } = await import(
+      '@/server/compliance/evaluate'
+    ));
+    ({ withTenant, unscoped } = await import('@/server/tenant'));
+
+    const db = unscoped();
+
+    await db.account.create({
+      data: { id: accountId, name: `Compte ${suffix}` },
+    });
+    await db.location.create({
+      data: {
+        id: locationId,
+        accountId,
+        name: 'Établissement de test',
+        timezone: TZ,
+        employerContributionRate: 0,
+      },
+    });
+    await db.team.create({
+      data: { id: teamId, accountId, locationId, name: 'Vente' },
+    });
+
+    const role = await db.role.create({
+      data: { accountId, key: 'employee', name: 'Employé' },
+    });
+    await db.membership.create({
+      data: {
+        id: membershipId,
+        accountId,
+        roleId: role.id,
+        employeeNumber: 'T0001',
+        status: 'ACTIVE',
+      },
+    });
+    await db.employeeProfile.create({
+      data: { membershipId, accountId, firstName: 'Test', lastName: 'Salarié' },
+    });
+    await db.userContract.create({
+      data: {
+        accountId,
+        membershipId,
+        locationId,
+        contractType: 'CDI',
+        startDate: new Date('2024-01-01'),
+        workTimeArrangement: 'HOURLY',
+        weeklyHours: 35,
+      },
+    });
+    await db.teamMember.create({ data: { accountId, teamId, membershipId } });
+
+    // Deux versions coexistantes. La v2 durcit la durée quotidienne et ne
+    // prend effet qu'au 1er juillet.
+    await db.collectiveAgreement.create({
+      data: {
+        accountId,
+        idcc: '1517',
+        name: 'Version initiale',
+        parameters: IDCC_1517_PARAMETERS,
+        version: 1,
+        effectiveFrom: new Date('2026-01-01'),
+      },
+    });
+    await db.collectiveAgreement.create({
+      data: {
+        accountId,
+        idcc: '1517',
+        name: 'Version durcie',
+        parameters: { ...IDCC_1517_PARAMETERS, maxDailyWorkMinutes: 8 * 60 },
+        version: 2,
+        effectiveFrom: new Date('2026-07-01'),
+      },
+    });
+
+    // Semaine 11 de 2026 (9 mars) et semaine 33 (10 août) : mêmes créneaux.
+    const march = await db.weeklySchedule.create({
+      data: { accountId, teamId, locationId, isoYear: 2026, isoWeek: 11 },
+    });
+    const august = await db.weeklySchedule.create({
+      data: { accountId, teamId, locationId, isoYear: 2026, isoWeek: 33 },
+    });
+    marchSchedule = march.id;
+    augustSchedule = august.id;
+
+    await db.shift.create({ data: tenHourShift(march.id, '2026-03-09') });
+    await db.shift.create({ data: tenHourShift(august.id, '2026-08-10') });
+  });
+
+  afterAll(async () => {
+    if (!enabled) return;
+    await unscoped().account.delete({ where: { id: accountId } });
+  });
+
+  it('choisit la version en vigueur à la date, pas la plus récente', async () => {
+    await withTenant(accountId, async (db) => {
+      const inMarch = await agreementFor(db, new Date('2026-03-09'));
+      const inAugust = await agreementFor(db, new Date('2026-08-10'));
+
+      expect(inMarch?.version).toBe(1);
+      expect(inAugust?.version).toBe(2);
+    });
+  });
+
+  it('n’applique pas rétroactivement une règle plus dure', async () => {
+    // Le cœur de l'exigence : 10 h de travail passent en mars sous la v1 et
+    // déclenchent en août sous la v2, avec exactement les mêmes créneaux.
+    await withTenant(accountId, async (db) => {
+      const march = await evaluateSchedule(db, marchSchedule);
+      const august = await evaluateSchedule(db, augustSchedule);
+
+      expect(march.map((entry) => entry.ruleCode)).not.toContain(
+        'MAX_DAILY_WORK',
+      );
+      expect(august.map((entry) => entry.ruleCode)).toContain('MAX_DAILY_WORK');
+    });
+  });
+
+  it('mémorise la version appliquée sur chaque constat', async () => {
+    await withTenant(accountId, async (db) => {
+      const stored = await db.complianceViolation.findFirst({
+        where: { weeklyScheduleId: augustSchedule, ruleCode: 'MAX_DAILY_WORK' },
+      });
+      const agreement = await agreementFor(db, new Date('2026-08-10'));
+
+      // Sans elle, un constat ancien devient inexplicable dès que les
+      // paramètres changent.
+      expect(stored?.agreementId).toBe(agreement?.id);
+    });
+  });
+
+  it('conserve l’acquittement d’une réévaluation à l’autre', async () => {
+    await withTenant(accountId, async (db) => {
+      const before = await db.complianceViolation.findFirst({
+        where: { weeklyScheduleId: augustSchedule, ruleCode: 'MAX_DAILY_WORK' },
+      });
+      if (!before) throw new Error('Constat attendu introuvable.');
+      await db.complianceViolation.update({
+        where: { id: before.id },
+        data: {
+          acknowledgedBy: membershipId,
+          acknowledgedAt: new Date(),
+          acknowledgementReason: 'Inventaire annuel',
+        },
+      });
+
+      // Un manager qui a justifié une alerte ne doit pas la revoir surgir
+      // parce qu'un collègue a déplacé un créneau ailleurs dans la semaine.
+      await evaluateSchedule(db, augustSchedule);
+
+      const after = await db.complianceViolation.findFirst({
+        where: { weeklyScheduleId: augustSchedule, ruleCode: 'MAX_DAILY_WORK' },
+      });
+      expect(after?.acknowledgementReason).toBe('Inventaire annuel');
+      expect(after?.id).not.toBe(before.id);
+    });
+  });
+
+  it('refuse de réécrire le contenu d’une version de convention', async () => {
+    // Le figeage est en base, pas seulement dans l'application : une paie
+    // antérieure doit rester reproductible même si quelqu'un écrit
+    // directement en SQL.
+    const db = unscoped();
+    const agreement = await db.collectiveAgreement.findFirst({
+      where: { accountId, version: 1 },
+    });
+    if (!agreement) throw new Error('Convention de test introuvable.');
+
+    await expect(
+      db.collectiveAgreement.update({
+        where: { id: agreement.id },
+        data: { parameters: { altered: true } },
+      }),
+    ).rejects.toThrow(/figé/);
+
+    // L'approbation, elle, reste possible : c'est un acte postérieur légitime.
+    await expect(
+      db.collectiveAgreement.update({
+        where: { id: agreement.id },
+        data: { approvedBy: membershipId, approvedAt: new Date() },
+      }),
+    ).resolves.toBeTruthy();
+  });
+});