Poser le contrat au moment de l'embauche

Créer un salarié demandait quatre champs et produisait un dossier vide :
sans contrat il n'apparaît sur aucune grille et ne se déclare pas, sans
équipe il ne s'ordonne nulle part — et jusqu'ici aucun écran ne permettait
de rattraper l'un ni l'autre.

Le contrat est proposé coché, et reste décochable : un remplaçant se
saisit parfois avant que son établissement soit tranché.

Dossier, contrat et rattachement entrent dans la même transaction. Créés
séparément, un incident au milieu laisserait exactement le dossier
incomplet que ce changement vise à supprimer.

Ouvrir un contrat reste une capacité distincte de celle de créer un
dossier : un gestionnaire d'annuaire n'engage pas l'entreprise. Le refus
le dit, et propose de créer le salarié sans contrat.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

src/app/(app)/equipe/AddEmployeeForm.tsx

@@ -1,25 +1,64 @@
 'use client';
 
-import { useActionState } from 'react';
+import { useActionState, useState } from 'react';
 
+import { Button } from '@/components/ui/Button';
 import { Field, FormError, SubmitButton } from '@/components/ui/Form';
 import { PersistentForm } from '@/components/ui/PersistentForm';
 import {
   createEmployeeAction,
   type ActionState,
 } from '@/server/employees/actions';
+import type { ContractLocation } from '@/server/employees/queries';
 
-export function AddEmployeeForm() {
+/**
+ * Embauche.
+ *
+ * Un salarié créé sans contrat ni équipe est un dossier que rien ne rattache :
+ * il n'apparaît sur aucune grille et ne se déclare pas. Le contrat est donc
+ * proposé d'emblée — et reste décochable, parce qu'un remplaçant se saisit
+ * parfois avant que son établissement soit tranché.
+ */
+
+const empty: ActionState = {};
+
+const CONTRACT_TYPES = [
+  ['CDI', 'CDI'],
+  ['CDD', 'CDD'],
+  ['APPRENTISSAGE', 'Apprentissage'],
+  ['STAGIAIRE', 'Stagiaire'],
+  ['SAISONNIER', 'Saisonnier'],
+  ['EXTRA', 'Extra'],
+  ['INTERIM', 'Intérim'],
+  ['DIRIGEANT_ASSIMILE_SALARIE', 'Dirigeant assimilé salarié'],
+  ['DIRIGEANT_NON_SALARIE', 'Dirigeant non salarié'],
+] as const;
+
+const selectClass =
+  'h-9 min-w-0 rounded-2 border border-line-2 bg-surface px-2 text-sm text-ink-1 outline-none focus-visible:border-focus';
+
+export function AddEmployeeForm({
+  locations,
+}: {
+  /** Vide quand la capacité d'ouvrir un contrat manque : la section disparaît. */
+  locations: ContractLocation[];
+}) {
   const [state, formAction] = useActionState<ActionState, FormData>(
     createEmployeeAction,
-    {},
+    empty,
   );
+  const [withContract, setWithContract] = useState(locations.length > 0);
+  const [locationId, setLocationId] = useState(locations[0]?.id ?? '');
+  const [forfait, setForfait] = useState(false);
+
+  const teams =
+    locations.find((location) => location.id === locationId)?.teams ?? [];
 
   return (
     <PersistentForm
       action={formAction}
       resetAfter={state.ok ? state : null}
-      className="flex flex-col gap-3"
+      className="flex flex-col gap-4"
     >
       <div className="flex flex-wrap gap-3">
         <Field label="Prénom" name="firstName" required />
@@ -27,12 +66,147 @@ export function AddEmployeeForm() {
         <Field label="Matricule" name="employeeNumber" required />
       </div>
 
-      <Field
-        label="Adresse électronique"
-        name="email"
-        type="email"
-        hint="Facultative. Un salarié sans adresse reste plannifiable et déclarable ; il n'aura simplement pas d'accès à l'application."
-      />
+      <div className="flex flex-wrap gap-3">
+        <Field
+          label="Adresse électronique"
+          name="email"
+          type="email"
+          hint="Facultative. Sans adresse, le salarié reste planifiable et déclarable ; il n’aura simplement pas d’accès à l’application."
+        />
+        <Field label="Téléphone mobile" name="phone" type="tel" />
+      </div>
+
+      {locations.length > 0 ? (
+        <>
+          <label className="flex items-center gap-2 text-sm font-medium">
+            <input
+              type="checkbox"
+              name="withContract"
+              checked={withContract}
+              onChange={(event) => setWithContract(event.target.checked)}
+              className="size-4 accent-[var(--accent)]"
+            />
+            Ouvrir un contrat maintenant
+          </label>
+
+          {withContract ? (
+            <div className="flex flex-col gap-3 rounded-3 border border-line-1 bg-surface-2 p-4">
+              <div className="flex flex-wrap gap-3">
+                <label className="flex min-w-0 flex-1 flex-col gap-1.5">
+                  <span className="text-sm font-medium">Établissement</span>
+                  <select
+                    name="locationId"
+                    className={selectClass}
+                    value={locationId}
+                    onChange={(event) => setLocationId(event.target.value)}
+                  >
+                    {locations.map((location) => (
+                      <option key={location.id} value={location.id}>
+                        {location.name}
+                      </option>
+                    ))}
+                  </select>
+                </label>
+
+                <label className="flex min-w-0 flex-1 flex-col gap-1.5">
+                  <span className="text-sm font-medium">Équipe</span>
+                  <select name="teamId" className={selectClass}>
+                    <option value="">Aucune pour l’instant</option>
+                    {teams.map((team) => (
+                      <option key={team.id} value={team.id}>
+                        {team.name}
+                      </option>
+                    ))}
+                  </select>
+                </label>
+
+                <label className="flex min-w-0 flex-1 flex-col gap-1.5">
+                  <span className="text-sm font-medium">Type de contrat</span>
+                  <select name="contractType" className={selectClass}>
+                    {CONTRACT_TYPES.map(([value, label]) => (
+                      <option key={value} value={value}>
+                        {label}
+                      </option>
+                    ))}
+                  </select>
+                </label>
+              </div>
+
+              <div className="flex flex-wrap gap-3">
+                <Field
+                  label="Début du contrat"
+                  name="startDate"
+                  type="date"
+                  required={withContract}
+                />
+                <Field
+                  label="Fin du contrat"
+                  name="endDate"
+                  type="date"
+                  hint="Vide pour un contrat sans terme."
+                />
+              </div>
+
+              <div className="flex flex-wrap gap-3">
+                <label className="flex min-w-0 flex-1 flex-col gap-1.5">
+                  <span className="text-sm font-medium">
+                    Organisation du temps
+                  </span>
+                  <select
+                    name="workTimeArrangement"
+                    className={selectClass}
+                    onChange={(event) =>
+                      setForfait(event.target.value === 'FORFAIT_JOURS')
+                    }
+                  >
+                    <option value="HOURLY">Décompte horaire</option>
+                    <option value="FORFAIT_JOURS">Forfait jours</option>
+                  </select>
+                </label>
+
+                {forfait ? (
+                  <Field
+                    label="Jours par an"
+                    name="forfaitDaysPerYear"
+                    type="number"
+                    step="0.5"
+                    min="0"
+                    max="218"
+                    defaultValue="218"
+                  />
+                ) : (
+                  <Field
+                    label="Durée hebdomadaire"
+                    name="weeklyHours"
+                    type="number"
+                    step="0.5"
+                    min="0"
+                    max="60"
+                    defaultValue="35"
+                  />
+                )}
+              </div>
+
+              {forfait ? (
+                <div className="flex flex-wrap gap-3">
+                  <Field
+                    label="Référence de la convention de forfait"
+                    name="forfaitAgreementRef"
+                    required
+                    hint="Sans convention individuelle écrite, le forfait est inopposable."
+                  />
+                  <Field
+                    label="Date d’accord du salarié"
+                    name="forfaitAgreedAt"
+                    type="date"
+                    required
+                  />
+                </div>
+              ) : null}
+            </div>
+          ) : null}
+        </>
+      ) : null}
 
       <FormError>{state.error}</FormError>
 
@@ -41,6 +215,16 @@ export function AddEmployeeForm() {
         {state.ok ? (
           <span className="text-xs text-ok-soft-ink">Salarié ajouté.</span>
         ) : null}
+        {withContract ? null : (
+          <Button
+            type="button"
+            variant="ghost"
+            onClick={() => setWithContract(true)}
+            disabled={locations.length === 0}
+          >
+            Ajouter un contrat
+          </Button>
+        )}
       </div>
     </PersistentForm>
   );

src/app/(app)/equipe/page.tsx

@@ -6,7 +6,10 @@ import { DirectoryFilters } from '@/app/(app)/equipe/DirectoryFilters';
 import { PageBody, PageHeader } from '@/components/shell/PageHeader';
 import { Badge, type Tone } from '@/components/ui/Badge';
 import { Card, CardHeader, EmptyState } from '@/components/ui/Card';
-import { listEmployees } from '@/server/employees/queries';
+import {
+  listContractLocations,
+  listEmployees,
+} from '@/server/employees/queries';
 
 export const metadata = { title: 'Équipe · PlanFlow' };
 export const dynamic = 'force-dynamic';
@@ -46,6 +49,10 @@ export default async function EquipePage({
     ...(one(params.tri) === 'number' ? { sort: 'number' as const } : {}),
   });
 
+  // Sans la capacité d'ouvrir un contrat, la liste revient vide et le
+  // formulaire s'en tient à l'identité.
+  const hiringLocations = await listContractLocations().catch(() => []);
+
   const filtered = directory.rows.length !== directory.total;
 
   return (
@@ -185,7 +192,7 @@ export default async function EquipePage({
       <Card>
         <CardHeader title="Ajouter un collaborateur" />
         <div className="p-4">
-          <AddEmployeeForm />
+          <AddEmployeeForm locations={hiringLocations} />
         </div>
       </Card>
     </PageBody>

src/server/employees/actions.ts

@@ -3,7 +3,7 @@
 import { revalidatePath } from 'next/cache';
 import { z } from 'zod';
 
-import { AuthorizationError } from '@/domain/access/authorize';
+import { AuthorizationError, can } from '@/domain/access/authorize';
 import { findOverlaps, validateContract } from '@/domain/contracts/rules';
 import { recordAudit } from '@/server/audit';
 import { mutate } from '@/server/context';
@@ -31,14 +31,39 @@ const employeeInput = z.object({
   employeeNumber: z.string().trim().min(1, 'Matricule requis').max(40),
   /** Vide = salarié géré sans accès applicatif. */
   email: z.string().trim().email('Adresse invalide').or(z.literal('')),
+  phone: z.string().trim().max(30),
 });
 
 /**
- * Crée un salarié.
+ * Contrat posé au moment de l'embauche.
+ *
+ * Facultatif dans le formulaire, mais tout ou rien une fois entamé : un
+ * établissement sans date de début produirait un contrat qu'aucune règle ne
+ * sait valider.
+ */
+const hiringContractInput = z.object({
+  locationId: z.string().min(1, 'Établissement requis'),
+  teamId: z.string().trim(),
+  contractType: z.enum(CONTRACT_TYPES),
+  startDate: z.coerce.date(),
+  endDate: z.string().trim(),
+  workTimeArrangement: z.enum(['HOURLY', 'FORFAIT_JOURS']),
+  weeklyHours: z.coerce.number().min(0).max(60),
+  forfaitDaysPerYear: z.coerce.number().min(0).max(400).optional(),
+  forfaitAgreementRef: z.string().trim(),
+  forfaitAgreedAt: z.string().trim(),
+});
+
+/**
+ * Crée un salarié, et l'embauche s'il y a lieu.
  *
  * Un salarié **sans compte utilisateur** doit rester créable : la plupart des
  * équipes de vente ne se connectent jamais à l'outil, et exiger une adresse
  * électronique les rendrait impossibles à planifier ou à déclarer.
+ *
+ * Le contrat et l'équipe sont posés dans la **même transaction** que le
+ * dossier. Créés séparément, un incident au milieu laisserait un salarié sans
+ * contrat — c'est-à-dire un dossier qu'aucun écran ne permettait de rattraper.
  */
 export async function createEmployeeAction(
   _previous: ActionState,
@@ -49,14 +74,71 @@ export async function createEmployeeAction(
     lastName: formData.get('lastName'),
     employeeNumber: formData.get('employeeNumber'),
     email: formData.get('email') ?? '',
+    phone: formData.get('phone') ?? '',
   });
 
   if (!parsed.success) {
     return { error: parsed.error.issues[0]?.message ?? 'Formulaire invalide' };
   }
 
+  // Le contrat n'est tenté que si le formulaire l'a ouvert : créer un salarié
+  // sans contrat reste légitime — un remplaçant se saisit avant que son
+  // établissement soit tranché.
+  const wantsContract = formData.get('withContract') === 'on';
+  let contract: z.infer<typeof hiringContractInput> | null = null;
+  let contractEnd: Date | null = null;
+  let forfaitAgreedAt: Date | null = null;
+
+  if (wantsContract) {
+    const parsedContract = hiringContractInput.safeParse({
+      locationId: formData.get('locationId') ?? '',
+      teamId: formData.get('teamId') ?? '',
+      contractType: formData.get('contractType') ?? 'CDI',
+      startDate: formData.get('startDate'),
+      endDate: formData.get('endDate') ?? '',
+      workTimeArrangement: formData.get('workTimeArrangement') ?? 'HOURLY',
+      weeklyHours: formData.get('weeklyHours') || 35,
+      forfaitDaysPerYear: formData.get('forfaitDaysPerYear') || undefined,
+      forfaitAgreementRef: formData.get('forfaitAgreementRef') ?? '',
+      forfaitAgreedAt: formData.get('forfaitAgreedAt') ?? '',
+    });
+
+    if (!parsedContract.success) {
+      return {
+        error:
+          parsedContract.error.issues[0]?.message ?? 'Contrat invalide',
+      };
+    }
+
+    contract = parsedContract.data;
+    contractEnd = contract.endDate ? new Date(contract.endDate) : null;
+    forfaitAgreedAt = contract.forfaitAgreedAt
+      ? new Date(contract.forfaitAgreedAt)
+      : null;
+
+    const issues = validateContract({
+      startDate: contract.startDate,
+      endDate: contractEnd,
+      workTimeArrangement: contract.workTimeArrangement,
+      weeklyHours: contract.weeklyHours,
+      forfaitDaysPerYear: contract.forfaitDaysPerYear ?? null,
+      forfaitAgreementRef: contract.forfaitAgreementRef || null,
+      forfaitAgreedAt,
+    });
+
+    if (issues.length > 0) {
+      return { error: issues[0]?.message ?? 'Contrat invalide' };
+    }
+  }
+
   try {
     await mutate('members.create', async (db, actor) => {
+      // Poser un contrat est une capacité distincte de celle de créer un
+      // dossier : un gestionnaire d'annuaire n'engage pas l'entreprise.
+      if (contract && !can(actor, 'members.contract.create')) {
+        throw new AuthorizationError('members.contract.create');
+      }
+
       const role = await db.role.findFirst({ where: { key: 'employee' } });
       if (!role) throw new Error('Rôle « employee » introuvable.');
 
@@ -81,9 +163,64 @@ export async function createEmployeeAction(
           firstName: parsed.data.firstName,
           lastName: parsed.data.lastName,
           personalEmail: parsed.data.email || null,
+          phone: parsed.data.phone || null,
         } as never,
       });
 
+      if (contract) {
+        const location = await db.location.findUnique({
+          where: { id: contract.locationId },
+        });
+        if (!location) {
+          throw new ValidationError('Établissement introuvable.');
+        }
+
+        const openedContract = await db.userContract.create({
+          data: {
+            membershipId: created.id,
+            locationId: location.id,
+            contractType: contract.contractType,
+            startDate: contract.startDate,
+            endDate: contractEnd,
+            workTimeArrangement: contract.workTimeArrangement,
+            weeklyHours: contract.weeklyHours,
+            forfaitDaysPerYear: contract.forfaitDaysPerYear ?? null,
+            forfaitAgreementRef: contract.forfaitAgreementRef || null,
+            forfaitAgreedAt,
+          } as never,
+        });
+
+        // Sans équipe, le salarié n'apparaît sur aucune grille : le planning
+        // s'ordonne par équipe, et un rattachement omis se paie à la première
+        // semaine à couvrir.
+        if (contract.teamId) {
+          const team = await db.team.findUnique({
+            where: { id: contract.teamId },
+            select: { id: true, locationId: true },
+          });
+          if (!team || team.locationId !== location.id) {
+            throw new ValidationError(
+              'Cette équipe n’appartient pas à l’établissement choisi.',
+            );
+          }
+          await db.teamMember.create({
+            data: { teamId: team.id, membershipId: created.id } as never,
+          });
+        }
+
+        await recordAudit(db, {
+          actorMembershipId: actor.membershipId,
+          action: 'contract.create',
+          entityType: 'UserContract',
+          entityId: openedContract.id,
+          after: {
+            contractType: openedContract.contractType,
+            startDate: openedContract.startDate.toISOString(),
+            workTimeArrangement: openedContract.workTimeArrangement,
+          },
+        });
+      }
+
       await recordAudit(db, {
         actorMembershipId: actor.membershipId,
         action: 'membership.create',
@@ -92,13 +229,19 @@ export async function createEmployeeAction(
         after: {
           employeeNumber: created.employeeNumber,
           hasAccount: Boolean(parsed.data.email),
+          withContract: Boolean(contract),
         },
       });
     });
   } catch (error) {
     if (error instanceof ValidationError) return { error: error.message };
     if (error instanceof AuthorizationError) {
-      return { error: "Vous n'avez pas le droit de créer un salarié." };
+      return {
+        error:
+          error.permission === 'members.contract.create'
+            ? "Vous n'avez pas le droit d'ouvrir un contrat. Créez le salarié sans contrat, ou faites-le poser."
+            : "Vous n'avez pas le droit de créer un salarié.",
+      };
     }
     throw error;
   }

src/server/employees/queries.ts

@@ -535,14 +535,26 @@ export const getEmployee = cache(async function getEmployee(
  * d'administrer les établissements, et emprunter `settings.access` fermerait
  * la création à un gestionnaire de paie qui n'a rien à y administrer.
  */
+export interface ContractLocation {
+  id: string;
+  name: string;
+  teams: Array<{ id: string; name: string }>;
+}
+
 export const listContractLocations = cache(
-  async function listContractLocations(): Promise<
-    Array<{ id: string; name: string }>
-  > {
+  async function listContractLocations(): Promise<ContractLocation[]> {
     return query('members.contract.create', async (db) =>
       db.location.findMany({
         where: { archivedAt: null },
-        select: { id: true, name: true },
+        select: {
+          id: true,
+          name: true,
+          teams: {
+            where: { archivedAt: null },
+            select: { id: true, name: true },
+            orderBy: { position: 'asc' },
+          },
+        },
         orderBy: { name: 'asc' },
       }),
     );

tests/e2e/conservation.spec.ts

@@ -117,6 +117,9 @@ test('une pièce sans politique n’est jamais purgée', async ({ page }) => {
   await create.getByLabel('Prénom').fill('Garde');
   await create.getByLabel('Nom', { exact: true }).fill(`Garde${suffix}`);
   await create.getByLabel('Matricule').fill(`RET${suffix}`);
+  // Le formulaire propose d’ouvrir un contrat d’emblée : ce parcours n’en veut
+  // pas, et un salarié sans contrat doit rester créable.
+  await create.getByLabel('Ouvrir un contrat maintenant').uncheck();
   await create.getByRole('button', { name: 'Ajouter' }).click();
   await expect(page.getByText('Salarié ajouté.')).toBeVisible();
 
@@ -168,6 +171,9 @@ test('une pièce échue est effectivement effacée', async ({ page }) => {
   await create.getByLabel('Prénom').fill('Purge');
   await create.getByLabel('Nom', { exact: true }).fill(`Purge${suffix}`);
   await create.getByLabel('Matricule').fill(`PUR${suffix}`);
+  // Le formulaire propose d’ouvrir un contrat d’emblée : ce parcours n’en veut
+  // pas, et un salarié sans contrat doit rester créable.
+  await create.getByLabel('Ouvrir un contrat maintenant').uncheck();
   await create.getByRole('button', { name: 'Ajouter' }).click();
   await expect(page.getByText('Salarié ajouté.')).toBeVisible();
 

tests/e2e/documents.spec.ts

@@ -31,6 +31,9 @@ async function createEmployee(page: Page, tag: string) {
   await form.getByLabel('Prénom').fill('Inès');
   await form.getByLabel('Nom', { exact: true }).fill(lastName);
   await form.getByLabel('Matricule').fill(`DOC${suffix}`);
+  // Le formulaire propose d’ouvrir un contrat d’emblée : ce parcours n’en veut
+  // pas, et un salarié sans contrat doit rester créable.
+  await form.getByLabel('Ouvrir un contrat maintenant').uncheck();
   await form.getByRole('button', { name: 'Ajouter' }).click();
   await expect(page.getByText('Salarié ajouté.')).toBeVisible();
 

tests/e2e/fiche.spec.ts

@@ -18,6 +18,9 @@ async function createEmployee(page: Page) {
   await form.getByLabel('Prénom').fill('Awa');
   await form.getByLabel('Nom', { exact: true }).fill(lastName);
   await form.getByLabel('Matricule').fill(`FIC${suffix}`);
+  // Le formulaire propose d’ouvrir un contrat d’emblée : ce parcours n’en veut
+  // pas, et un salarié sans contrat doit rester créable.
+  await form.getByLabel('Ouvrir un contrat maintenant').uncheck();
   await form.getByRole('button', { name: 'Ajouter' }).click();
   await expect(page.getByText('Salarié ajouté.')).toBeVisible();
 
@@ -88,3 +91,37 @@ test('une date de naissance à venir est refusée', async ({ page }) => {
 
   await expect(page.getByText('Date de naissance invalide.')).toBeVisible();
 });
+
+test('une embauche pose le contrat en même temps que le dossier', async ({
+  page,
+}) => {
+  const suffix = `${Date.now()}-embauche`;
+  const lastName = `Embauche${suffix}`;
+
+  await page.goto('/equipe');
+  const form = page.locator('form').filter({ hasText: 'Ajouter' });
+  await form.getByLabel('Prénom').fill('Sofia');
+  await form.getByLabel('Nom', { exact: true }).fill(lastName);
+  await form.getByLabel('Matricule').fill(`EMB${suffix}`);
+
+  // Le contrat est proposé coché : un dossier créé sans lui n'apparaît sur
+  // aucune grille et ne se déclare pas.
+  await expect(
+    form.getByLabel('Ouvrir un contrat maintenant'),
+  ).toBeChecked();
+  await form.getByLabel('Début du contrat').fill('2026-01-05');
+  await form.getByRole('button', { name: 'Ajouter' }).click();
+  await expect(page.getByText('Salarié ajouté.')).toBeVisible();
+
+  // Le contrat est visible depuis l'annuaire, sans passer par la fiche.
+  await expect(page.getByRole('row', { name: new RegExp(lastName) })).toContainText(
+    'CDI',
+  );
+
+  await page.getByRole('link', { name: new RegExp(lastName) }).click();
+  // Le bandeau porte le contrat : c'est ce qui distingue un dossier embauché
+  // d'un dossier ouvert.
+  await expect(page.getByText('Type de contrat')).toBeVisible();
+  await page.getByRole('link', { name: 'Contrats', exact: true }).click();
+  await expect(page.getByText('35 heures hebdomadaires')).toBeVisible();
+});

tests/e2e/invitation.spec.ts

@@ -26,6 +26,9 @@ async function createEmployee(page: Page, tag: string) {
   await form.getByLabel('Nom', { exact: true }).fill(lastName);
   await form.getByLabel('Matricule').fill(`E2E${suffix}`);
   await form.getByLabel('Adresse électronique').fill(email);
+  // Le formulaire propose d’ouvrir un contrat d’emblée : ce parcours n’en veut
+  // pas, et un salarié sans contrat doit rester créable.
+  await form.getByLabel('Ouvrir un contrat maintenant').uncheck();
   await form.getByRole('button', { name: 'Ajouter' }).click();
   await expect(page.getByText('Salarié ajouté.')).toBeVisible();
 

tests/e2e/registre.spec.ts

@@ -59,6 +59,9 @@ test('un salarié sans compte applicatif est créable', async ({ page }) => {
   await form.locator('input[name="firstName"]').fill('Sans');
   await form.locator('input[name="lastName"]').fill(nom);
   await form.locator('input[name="employeeNumber"]').fill(matricule);
+  // Le formulaire propose d’ouvrir un contrat d’emblée : ce parcours n’en veut
+  // pas, et un salarié sans contrat doit rester créable.
+  await form.getByLabel('Ouvrir un contrat maintenant').uncheck();
   await page.getByRole('button', { name: 'Ajouter' }).click();
   await expect(page.getByText('Salarié ajouté.')).toBeVisible();
 

tests/e2e/roles.spec.ts

@@ -163,6 +163,9 @@ async function inviteWithRole(page: Page, roleLabel: string) {
   await create.getByLabel('Nom', { exact: true }).fill(lastName);
   await create.getByLabel('Matricule').fill(`ROL${suffix}`);
   await create.getByLabel('Adresse électronique').fill(email);
+  // Le formulaire propose d’ouvrir un contrat d’emblée : ce parcours n’en veut
+  // pas, et un salarié sans contrat doit rester créable.
+  await create.getByLabel('Ouvrir un contrat maintenant').uncheck();
   await create.getByRole('button', { name: 'Ajouter' }).click();
   await expect(page.getByText('Salarié ajouté.')).toBeVisible();
 

tests/e2e/securite.spec.ts

@@ -156,6 +156,9 @@ async function createAccessibleEmployee(page: Page) {
   await form.getByLabel('Nom', { exact: true }).fill(lastName);
   await form.getByLabel('Matricule').fill(`MFA${suffix}`);
   await form.getByLabel('Adresse électronique').fill(email);
+  // Le formulaire propose d’ouvrir un contrat d’emblée : ce parcours n’en veut
+  // pas, et un salarié sans contrat doit rester créable.
+  await form.getByLabel('Ouvrir un contrat maintenant').uncheck();
   await form.getByRole('button', { name: 'Ajouter' }).click();
   await expect(page.getByText('Salarié ajouté.')).toBeVisible();