Configurer les rôles et leurs capacités

Critère d'acceptation de WP-01 resté sans écran : « un rôle personnalisé créé
par un client modifie effectivement l'accès, sans changement de code ». Le
catalogue de capacités existait, l'autorisation s'y adossait déjà, mais seul le
semis pouvait attribuer quoi que ce soit.

Deux dangers opposés, et il faut se protéger des deux. L'escalade d'abord : on
ne peut accorder qu'une capacité qu'on détient soi-même, sans quoi la première
personne autorisée à éditer un rôle s'accorde l'accès aux rémunérations en
trois clics et le catalogue ne sert plus à rien. Le retrait, lui, reste permis
même sur une capacité qu'on n'a pas — réduire un droit n'a jamais élargi le
sien, et l'interdire empêcherait de corriger un rôle trop large.

Le verrouillage ensuite : au moins un rôle doit conserver la gestion des
droits. La condition se juge sur l'ensemble des rôles après coup, non sur celui
qu'on édite — ce qui compte n'est pas que ce rôle-ci garde la capacité, mais
qu'un rôle la garde. Sans cela une organisation se fermerait dehors, et le seul
recours serait une intervention en base.

Un rôle naît sans aucune capacité : en hériter de celles de son créateur
distribuerait des droits que personne n'a demandés. Le niveau propriétaire se
délègue à part. Un rôle système ne se supprime pas, un rôle attribué non plus —
ses membres se retrouveraient dehors sans que personne l'ait décidé pour eux.

Le test va jusqu'au bout : créer le rôle, l'attribuer, se connecter, constater
qu'un écran s'ouvre et qu'un autre reste fermé. S'arrêter à « la case est
cochée » n'aurait rien dit du critère.

Trois défauts d'isolation des tests corrigés au passage, tous du même genre —
un état qui s'accumule d'une exécution à l'autre :

- la file des congés désignait « la première ligne de ce salarié » pour son
  nettoyage, et tombait sur une ligne laissée par un passage antérieur ;
- l'écran de conservation tronquait à quarante pièces triées par ancienneté,
  faisant disparaître les pièces échues derrière celles dont il n'y a rien à
  dire — corrigé dans le produit, pas seulement dans le test ;
- le test de verrouillage de période consommait un mois par exécution sans
  jamais le rendre.

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

src/app/(app)/reglages/conservation/page.tsx

@@ -34,6 +34,18 @@ export default async function RetentionPage() {
   const due = candidates.filter((entry) => entry.verdict === 'DUE');
   const unpolicied = candidates.filter((entry) => entry.verdict === 'NO_POLICY');
 
+  // Ce qui appelle une décision d'abord. Trier par date de dépôt puis tronquer
+  // ferait disparaître les pièces échues derrière les plus anciennes, qui sont
+  // justement celles dont il n'y a rien à dire.
+  const PRIORITY: Record<string, number> = { DUE: 0, HELD: 1, NOT_COMPUTABLE: 2 };
+  const shown = [...candidates]
+    .sort(
+      (a, b) =>
+        (PRIORITY[a.verdict] ?? 3) - (PRIORITY[b.verdict] ?? 3) ||
+        b.uploadedAt.getTime() - a.uploadedAt.getTime(),
+    )
+    .slice(0, 40);
+
   return (
     <PageBody>
       <PageHeader
@@ -130,7 +142,7 @@ export default async function RetentionPage() {
             <p className="text-sm text-ink-3">Aucune pièce déposée.</p>
           ) : (
             <ul className="flex flex-col gap-1 text-sm">
-              {candidates.slice(0, 40).map((candidate) => (
+              {shown.map((candidate) => (
                 <li key={candidate.id} className="flex flex-wrap items-center gap-2">
                   <Badge
                     tone={
@@ -155,6 +167,13 @@ export default async function RetentionPage() {
             </ul>
           )}
 
+          {candidates.length > shown.length ? (
+            <p className="text-micro text-ink-3">
+              {candidates.length - shown.length} pièce(s) de plus, non affichées.
+              Les pièces échues et suspendues figurent toujours en tête.
+            </p>
+          ) : null}
+
           {unpolicied.length > 0 ? (
             <p className="text-micro text-ink-3">
               {unpolicied.length} pièce(s) sans politique déclarée : elles ne

src/app/(app)/reglages/roles/page.tsx

@@ -0,0 +1,104 @@
+import {
+  CreateRoleForm,
+  DeleteRoleForm,
+  RolePermissionsForm,
+  type CapabilityView,
+  type RoleView,
+} from '@/components/settings/RoleEditor';
+import { PageBody, PageHeader } from '@/components/shell/PageHeader';
+import { Badge } from '@/components/ui/Badge';
+import { Card, CardHeader } from '@/components/ui/Card';
+import { query } from '@/server/context';
+
+export const metadata = { title: 'Rôles et permissions · PlanFlow' };
+export const dynamic = 'force-dynamic';
+
+/**
+ * Rôles et capacités.
+ *
+ * Critère d'acceptation de WP-01 : un rôle personnalisé créé par un client doit
+ * modifier effectivement l'accès, sans changement de code. Le code ne teste
+ * jamais un nom de rôle, seulement des capacités — c'est ce qui rend cet écran
+ * possible.
+ */
+export default async function RolesPage() {
+  const { roles, capabilities } = await query(
+    'settings.roles.manage',
+    async (db, actor) => {
+      const [rows, permissions] = await Promise.all([
+        db.role.findMany({
+          orderBy: [{ isSystem: 'desc' }, { name: 'asc' }],
+          include: {
+            permissions: { include: { permission: true } },
+            _count: { select: { memberships: true } },
+          },
+        }),
+        db.permission.findMany({ orderBy: [{ category: 'asc' }, { code: 'asc' }] }),
+      ]);
+
+      return {
+        roles: rows.map(
+          (role): RoleView => ({
+            id: role.id,
+            key: role.key,
+            name: role.name,
+            isSystem: role.isSystem,
+            memberCount: role._count.memberships,
+            granted: role.permissions.map((entry) => entry.permission.code),
+          }),
+        ),
+        capabilities: permissions.map(
+          (permission): CapabilityView => ({
+            code: permission.code,
+            category: permission.category,
+            label: permission.label,
+            // Calculé côté serveur depuis l'acteur : le client n'a pas à
+            // décider ce qu'il a le droit d'accorder.
+            grantable: actor.permissions.has(permission.code),
+          }),
+        ),
+      };
+    },
+  );
+
+  return (
+    <PageBody>
+      <PageHeader
+        title="Rôles et permissions"
+        subtitle="Le code teste des capacités, jamais un nom de rôle : renommer « Manager » ou en créer un cinquième ne casse rien."
+        actions={<Badge tone="neutral">{roles.length} rôles</Badge>}
+      />
+
+      <section className="rounded-3 border border-line-1 bg-surface-2 p-4 text-sm text-ink-2">
+        <p>
+          Vous ne pouvez accorder que les capacités que vous détenez vous-même —
+          sinon cet écran suffirait à s’octroyer l’accès aux rémunérations.
+          Retirer reste possible : réduire un droit n’a jamais élargi le sien.
+        </p>
+        <p className="mt-2">
+          Au moins un rôle doit conserver « Gérer les rôles », faute de quoi
+          l’organisation se fermerait dehors et le seul recours serait une
+          intervention en base.
+        </p>
+      </section>
+
+      <Card>
+        <CardHeader title="Créer un rôle" />
+        <div className="p-4">
+          <CreateRoleForm />
+        </div>
+      </Card>
+
+      {roles.map((role) => (
+        <Card key={role.id}>
+          <CardHeader
+            title={role.name}
+            badge={<Badge tone="neutral">{role.granted.length}</Badge>}
+          />
+          <RolePermissionsForm role={role} capabilities={capabilities} />
+          <DeleteRoleForm role={role} />
+        </Card>
+      ))}
+    </PageBody>
+  );
+}

src/components/settings/RoleEditor.tsx

@@ -0,0 +1,210 @@
+'use client';
+
+import { useActionState } from 'react';
+
+import { Badge } from '@/components/ui/Badge';
+import { Button } from '@/components/ui/Button';
+import {
+  OWNER_LEVEL_CAPABILITY,
+  ROLE_ADMIN_CAPABILITY,
+} from '@/domain/access/role-editing';
+import {
+  createRoleAction,
+  deleteRoleAction,
+  saveRolePermissionsAction,
+  type RoleState,
+} from '@/server/roles/actions';
+
+const empty: RoleState = {};
+
+export interface CapabilityView {
+  code: string;
+  category: string;
+  label: string;
+  /** L'acteur courant la détient : il peut donc l'accorder. */
+  grantable: boolean;
+}
+
+export interface RoleView {
+  id: string;
+  key: string;
+  name: string;
+  isSystem: boolean;
+  memberCount: number;
+  granted: string[];
+}
+
+export function CreateRoleForm() {
+  const [state, action, pending] = useActionState(createRoleAction, empty);
+
+  return (
+    <form action={action} className="flex flex-wrap items-end gap-3">
+      <label className="flex flex-col gap-1">
+        <span className="text-micro font-medium tracking-[0.04em] text-ink-3 uppercase">
+          Nom du rôle
+        </span>
+        <input
+          name="name"
+          required
+          minLength={2}
+          placeholder="Responsable de secteur"
+          className="h-8 w-64 rounded-2 border border-line-2 bg-surface px-2 text-sm text-ink-1"
+        />
+        <span className="text-micro text-ink-3">
+          Créé sans aucune capacité : un rôle neuf qui hériterait des vôtres
+          distribuerait des droits que personne n’a demandés.
+        </span>
+      </label>
+      <Button type="submit" variant="primary" disabled={pending}>
+        Créer
+      </Button>
+      <Messages state={state} />
+    </form>
+  );
+}
+
+/**
+ * Capacités d'un rôle.
+ *
+ * Les cases qu'on ne détient pas soi-même sont désactivées et le disent : on ne
+ * peut accorder que ce qu'on a. Retirer reste possible — réduire un droit n'a
+ * jamais élargi le sien.
+ */
+export function RolePermissionsForm({
+  role,
+  capabilities,
+}: {
+  role: RoleView;
+  capabilities: CapabilityView[];
+}) {
+  const [state, action, pending] = useActionState(
+    saveRolePermissionsAction,
+    empty,
+  );
+  const granted = new Set(role.granted);
+
+  const categories = [...new Set(capabilities.map((c) => c.category))];
+
+  return (
+    <form
+      action={action}
+      // Repère stable : les libellés de capacités contiennent les mots des
+      // rôles (« niveau propriétaire »), et une recherche par texte désigne
+      // alors plusieurs cartes à la fois.
+      data-testid={`role-${role.key}`}
+      className="flex flex-col gap-4 p-4"
+    >
+      <input type="hidden" name="roleId" value={role.id} />
+
+      <div className="flex flex-wrap items-center gap-2 text-sm">
+        <span className="font-medium text-ink-1">{role.name}</span>
+        <Badge tone="neutral">{role.key}</Badge>
+        {role.isSystem ? <Badge tone="info">Rôle système</Badge> : null}
+        <span className="text-micro text-ink-3">
+          {role.memberCount} membre{role.memberCount > 1 ? 's' : ''} ·{' '}
+          {role.granted.length} capacité{role.granted.length > 1 ? 's' : ''}
+        </span>
+      </div>
+
+      <div className="grid gap-4 [grid-template-columns:repeat(auto-fit,minmax(260px,1fr))]">
+        {categories.map((category) => (
+          <fieldset key={category} className="flex flex-col gap-1">
+            <legend className="text-micro font-semibold tracking-[0.06em] text-ink-3 uppercase">
+              {category}
+            </legend>
+            {capabilities
+              .filter((capability) => capability.category === category)
+              .map((capability) => {
+                const isGranted = granted.has(capability.code);
+                // Interdire de décocher ce qu'on ne peut pas re-cocher éviterait
+                // un retrait qu'on ne saurait pas défaire — mais empêcherait
+                // aussi de réduire un rôle trop large. Le retrait reste permis.
+                const locked = !capability.grantable && !isGranted;
+
+                return (
+                  <label
+                    key={capability.code}
+                    className="flex items-start gap-2 text-sm text-ink-2"
+                  >
+                    <input
+                      type="checkbox"
+                      name="permission"
+                      value={capability.code}
+                      defaultChecked={isGranted}
+                      disabled={locked}
+                      className="mt-0.5 size-4"
+                    />
+                    <span className={locked ? 'text-ink-3' : undefined}>
+                      {capability.label}
+                      {capability.code === ROLE_ADMIN_CAPABILITY ? (
+                        <span className="block text-micro text-ink-3">
+                          Au moins un rôle doit la conserver.
+                        </span>
+                      ) : null}
+                      {capability.code === OWNER_LEVEL_CAPABILITY ? (
+                        <span className="block text-micro text-ink-3">
+                          Ne se délègue que par un propriétaire.
+                        </span>
+                      ) : null}
+                      {locked ? (
+                        <span className="block text-micro text-ink-3">
+                          Vous ne la détenez pas.
+                        </span>
+                      ) : null}
+                    </span>
+                  </label>
+                );
+              })}
+          </fieldset>
+        ))}
+      </div>
+
+      <div className="flex flex-wrap items-center gap-3">
+        <Button type="submit" variant="primary" disabled={pending}>
+          Enregistrer
+        </Button>
+        <Messages state={state} />
+      </div>
+    </form>
+  );
+}
+
+export function DeleteRoleForm({ role }: { role: RoleView }) {
+  const [state, action, pending] = useActionState(deleteRoleAction, empty);
+
+  if (role.isSystem) return null;
+
+  return (
+    <form
+      action={action}
+      data-testid={`role-delete-${role.key}`}
+      className="flex items-center gap-3 px-4 pb-4"
+    >
+      <input type="hidden" name="roleId" value={role.id} />
+      <Button type="submit" disabled={pending || role.memberCount > 0}>
+        Supprimer ce rôle
+      </Button>
+      {role.memberCount > 0 ? (
+        <span className="text-micro text-ink-3">
+          Réaffectez ses {role.memberCount} membre(s) d’abord.
+        </span>
+      ) : null}
+      <Messages state={state} />
+    </form>
+  );
+}
+
+function Messages({ state }: { state: RoleState }) {
+  return (
+    <>
+      {state.error ? (
+        <span role="alert" className="text-xs text-danger">
+          {state.error}
+        </span>
+      ) : null}
+      {state.message ? (
+        <span className="text-xs text-ok-soft-ink">{state.message}</span>
+      ) : null}
+    </>
+  );
+}

src/components/shell/navigation.ts

@@ -92,7 +92,7 @@ export const NAVIGATION: NavSection[] = [
       },
       { id: 'convention', label: 'Convention collective' },
       { id: 'postes', label: 'Postes et étiquettes' },
-      { id: 'roles', label: 'Rôles et permissions' },
+      { id: 'roles', label: 'Rôles et permissions', href: '/reglages/roles' },
     ],
   },
 ];

src/domain/access/role-editing.ts

@@ -0,0 +1,110 @@
+import type { Actor } from '@/domain/access/authorize';
+
+/**
+ * Garde-fous de l'édition des rôles — PLAN.md §5.
+ *
+ * Un écran qui distribue les droits est celui par lequel on prend le contrôle
+ * d'une application. Deux dangers, opposés, et il faut se protéger des deux :
+ *
+ * - **l'escalade** — s'accorder une capacité qu'on n'a pas ;
+ * - **le verrouillage** — retirer la dernière capacité qui permettait encore de
+ *   revenir en arrière, et fermer les réglages à tout le monde.
+ */
+
+/** Capacité sans laquelle plus personne ne peut redistribuer les droits. */
+export const ROLE_ADMIN_CAPABILITY = 'settings.roles.manage';
+
+/** Capacité qui confère le niveau propriétaire, et se délègue à part. */
+export const OWNER_LEVEL_CAPABILITY = 'role_config.assign_owner_level';
+
+export type EditRefusal =
+  | 'ESCALATION'
+  | 'OWNER_LEVEL'
+  | 'LAST_ADMIN'
+  | 'SYSTEM_ROLE'
+  | 'DUPLICATE_KEY'
+  | 'ROLE_IN_USE'
+  | 'NOT_FOUND';
+
+export const REFUSAL_MESSAGES: Record<EditRefusal, string> = {
+  ESCALATION:
+    'Vous ne pouvez pas accorder une capacité que vous ne détenez pas vous-même.',
+  OWNER_LEVEL:
+    'Le niveau propriétaire ne se délègue que par un propriétaire.',
+  LAST_ADMIN:
+    'Ce retrait fermerait la gestion des droits à tout le monde : au moins un rôle doit conserver « Gérer les rôles ».',
+  SYSTEM_ROLE:
+    'Un rôle système ne se supprime pas : le code et le semis y font référence par sa clé.',
+  DUPLICATE_KEY: 'Un rôle porte déjà ce nom.',
+  ROLE_IN_USE:
+    'Ce rôle est encore attribué. Réaffectez ses membres avant de le supprimer.',
+  NOT_FOUND: 'Rôle introuvable.',
+};
+
+export interface GrantContext {
+  actor: Actor;
+  /** Capacités que le rôle portera après enregistrement. */
+  next: ReadonlySet<string>;
+  /** Capacités qu'il portait avant. */
+  previous: ReadonlySet<string>;
+}
+
+/**
+ * Refus d'escalade.
+ *
+ * On ne peut accorder que ce qu'on détient. Sans cette règle, la première
+ * personne autorisée à éditer un rôle s'accorderait l'accès aux rémunérations
+ * en trois clics — et le catalogue de capacités ne servirait plus à rien.
+ *
+ * Retirer reste permis même sur une capacité qu'on n'a pas : réduire un droit
+ * n'a jamais élargi le sien.
+ */
+export function escalationRefusal({
+  actor,
+  next,
+  previous,
+}: GrantContext): EditRefusal | null {
+  const added = [...next].filter((code) => !previous.has(code));
+
+  for (const code of added) {
+    if (code === OWNER_LEVEL_CAPABILITY && !actor.permissions.has(code)) {
+      return 'OWNER_LEVEL';
+    }
+    if (!actor.permissions.has(code)) return 'ESCALATION';
+  }
+
+  return null;
+}
+
+export interface LockoutContext {
+  /** Rôles du compte avec leurs capacités, **après** l'enregistrement envisagé. */
+  rolesAfter: ReadonlyArray<{ id: string; permissions: ReadonlySet<string> }>;
+}
+
+/**
+ * Refus de verrouillage.
+ *
+ * Compté après coup, sur l'ensemble des rôles : ce qui compte n'est pas que
+ * *ce* rôle garde la capacité, mais qu'au moins un la conserve. Sans cela, une
+ * organisation pourrait s'enfermer dehors, et le seul recours serait une
+ * intervention en base.
+ */
+export function lockoutRefusal({
+  rolesAfter,
+}: LockoutContext): EditRefusal | null {
+  const remaining = rolesAfter.filter((role) =>
+    role.permissions.has(ROLE_ADMIN_CAPABILITY),
+  );
+  return remaining.length === 0 ? 'LAST_ADMIN' : null;
+}
+
+/** Clé technique d'un rôle créé par le client. */
+export function slugifyRoleKey(name: string): string {
+  return name
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 40);
+}

src/server/roles/actions.ts

@@ -0,0 +1,219 @@
+'use server';
+
+import { revalidatePath } from 'next/cache';
+import { z } from 'zod';
+
+import { AuthorizationError } from '@/domain/access/authorize';
+import { PERMISSION_CODES } from '@/domain/access/permissions';
+import {
+  escalationRefusal,
+  lockoutRefusal,
+  REFUSAL_MESSAGES,
+  slugifyRoleKey,
+  type EditRefusal,
+} from '@/domain/access/role-editing';
+import { recordAudit } from '@/server/audit';
+import { mutate } from '@/server/context';
+
+/**
+ * Édition des rôles — PLAN.md §5.
+ *
+ * Critère d'acceptation de WP-01 : « un rôle personnalisé créé par un client
+ * modifie effectivement l'accès, sans changement de code ». C'est ce que cet
+ * écran rend possible — et c'est aussi celui par lequel on prendrait le
+ * contrôle de l'application, d'où les garde-fous.
+ */
+
+export interface RoleState {
+  error?: string;
+  ok?: boolean;
+  message?: string;
+}
+
+class Refused extends Error {
+  constructor(readonly refusal: EditRefusal) {
+    super(REFUSAL_MESSAGES[refusal]);
+  }
+}
+
+const createInput = z.object({
+  name: z.string().trim().min(2, 'Nom du rôle requis').max(60),
+});
+
+export async function createRoleAction(
+  _previous: RoleState,
+  formData: FormData,
+): Promise<RoleState> {
+  const parsed = createInput.safeParse({ name: formData.get('name') });
+  if (!parsed.success) {
+    return { error: parsed.error.issues[0]?.message ?? 'Formulaire invalide' };
+  }
+
+  const key = slugifyRoleKey(parsed.data.name);
+  if (!key) {
+    return { error: 'Ce nom ne produit aucune clé utilisable. Employez des lettres.' };
+  }
+
+  try {
+    await mutate('settings.roles.manage', async (db, actor) => {
+      const existing = await db.role.findFirst({ where: { key } });
+      if (existing) throw new Refused('DUPLICATE_KEY');
+
+      // Créé **sans aucune capacité**. Un rôle neuf qui hériterait de celles de
+      // son créateur distribuerait des droits que personne n'a demandés.
+      const role = await db.role.create({
+        data: { key, name: parsed.data.name, isSystem: false } as never,
+      });
+
+      await recordAudit(db, {
+        actorMembershipId: actor.membershipId,
+        action: 'role.create',
+        entityType: 'Role',
+        entityId: role.id,
+        after: { key, name: parsed.data.name },
+      });
+    });
+  } catch (error) {
+    return toState(error, "Vous n'avez pas le droit de gérer les rôles.");
+  }
+
+  revalidatePath('/reglages/roles');
+  return { ok: true, message: `Rôle « ${parsed.data.name} » créé, sans aucune capacité.` };
+}
+
+/**
+ * Enregistre les capacités d'un rôle.
+ *
+ * Les cases envoyées **remplacent** la liste : le formulaire porte l'état
+ * complet, ce qui évite d'avoir à distinguer ajout et retrait côté client — et
+ * ce qui rend les deux contrôles, escalade et verrouillage, calculables d'un
+ * seul coup.
+ */
+export async function saveRolePermissionsAction(
+  _previous: RoleState,
+  formData: FormData,
+): Promise<RoleState> {
+  const roleId = String(formData.get('roleId') ?? '');
+  if (!roleId) return { error: 'Rôle introuvable.' };
+
+  const requested = new Set(
+    formData
+      .getAll('permission')
+      .map(String)
+      .filter((code) => (PERMISSION_CODES as readonly string[]).includes(code)),
+  );
+
+  try {
+    await mutate('settings.roles.manage', async (db, actor) => {
+      const role = await db.role.findUnique({
+        where: { id: roleId },
+        include: { permissions: { include: { permission: true } } },
+      });
+      if (!role) throw new Refused('NOT_FOUND');
+
+      const previous = new Set(
+        role.permissions.map((entry) => entry.permission.code),
+      );
+
+      const escalation = escalationRefusal({
+        actor,
+        next: requested,
+        previous,
+      });
+      if (escalation) throw new Refused(escalation);
+
+      // Le verrouillage se juge sur l'ensemble des rôles après coup : ce qui
+      // compte n'est pas que *ce* rôle garde la capacité, mais qu'au moins un
+      // la conserve.
+      const allRoles = await db.role.findMany({
+        include: { permissions: { include: { permission: true } } },
+      });
+      const rolesAfter = allRoles.map((other) => ({
+        id: other.id,
+        permissions:
+          other.id === roleId
+            ? requested
+            : new Set(other.permissions.map((entry) => entry.permission.code)),
+      }));
+
+      const lockout = lockoutRefusal({ rolesAfter });
+      if (lockout) throw new Refused(lockout);
+
+      const permissions = await db.permission.findMany({
+        where: { code: { in: [...requested] } },
+        select: { id: true },
+      });
+
+      await db.rolePermission.deleteMany({ where: { roleId } });
+      if (permissions.length > 0) {
+        await db.rolePermission.createMany({
+          data: permissions.map((permission) => ({
+            roleId,
+            permissionId: permission.id,
+          })),
+        });
+      }
+
+      await recordAudit(db, {
+        actorMembershipId: actor.membershipId,
+        action: 'role.permissions.update',
+        entityType: 'Role',
+        entityId: roleId,
+        before: { count: previous.size, codes: [...previous].sort() },
+        after: { count: requested.size, codes: [...requested].sort() },
+      });
+    });
+  } catch (error) {
+    return toState(error, "Vous n'avez pas le droit de gérer les rôles.");
+  }
+
+  revalidatePath('/reglages/roles');
+  return { ok: true, message: 'Capacités enregistrées.' };
+}
+
+export async function deleteRoleAction(
+  _previous: RoleState,
+  formData: FormData,
+): Promise<RoleState> {
+  const roleId = String(formData.get('roleId') ?? '');
+  if (!roleId) return { error: 'Rôle introuvable.' };
+
+  try {
+    await mutate('settings.roles.manage', async (db, actor) => {
+      const role = await db.role.findUnique({
+        where: { id: roleId },
+        include: { memberships: { select: { id: true }, take: 1 } },
+      });
+      if (!role) throw new Refused('NOT_FOUND');
+
+      // Un rôle système est référencé par le code et par le semis : le
+      // supprimer casserait la création d'un salarié.
+      if (role.isSystem) throw new Refused('SYSTEM_ROLE');
+
+      // Supprimer un rôle attribué laisserait des salariés sans capacités, donc
+      // dehors, sans que personne ne l'ait décidé pour eux.
+      if (role.memberships.length > 0) throw new Refused('ROLE_IN_USE');
+
+      await db.role.delete({ where: { id: roleId } });
+
+      await recordAudit(db, {
+        actorMembershipId: actor.membershipId,
+        action: 'role.delete',
+        entityType: 'Role',
+        entityId: roleId,
+        before: { key: role.key, name: role.name },
+      });
+    });
+  } catch (error) {
+    return toState(error, "Vous n'avez pas le droit de gérer les rôles.");
+  }
+
+  revalidatePath('/reglages/roles');
+  return { ok: true, message: 'Rôle supprimé.' };
+}
+
+function toState(error: unknown, denied: string): RoleState {
+  if (error instanceof Refused) return { error: error.message };
+  if (error instanceof AuthorizationError) return { error: denied };
+  throw error;
+}