@imenam/mcp-messenger 1.0.17 → 1.0.18

package/README.md

@@ -377,7 +377,7 @@ configuration partagent alors la même boîte. Utile pour un service unique et s
 
 ## Console web
 
-`http://127.0.0.1:3600/ui/` affiche, en lecture seule, **tous les échanges** de la flotte,
+`http://127.0.0.1:3600/ui/` affiche **tous les échanges** de la flotte,
 organisés autour du fil — l'unité d'une correspondance, celle qui porte le sujet, les deux
 correspondants et l'état de lecture :
 
@@ -386,7 +386,8 @@ correspondants et l'état de lecture :
   chevron sur ses boîtes ; une boîte que son agent n'a pas nommée s'affiche à son adresse,
   la seule chose qui la distingue alors de ses sœurs. Cliquer l'agent filtre les fils sur
   **toutes ses sessions**, cliquer une boîte sur **cette seule session**. La colonne se
-  replie sur les seuls avatars d'agents quand la place manque.
+  replie sur les seuls avatars d'agents quand la place manque, son bouton de repli restant
+  en place : c'est lui qui la rouvre.
 
   **Le classement se fait en deux temps : d'abord ce qui a servi, ensuite ce qui est
   vide ; puis, dans chacun des deux, la dernière activité, la plus récente en tête.** Une
@@ -439,7 +440,31 @@ navigateur de l'administrateur. Les routes `/admin` acceptent toujours le jeton
 `Authorization: Bearer` pour les scripts. Le formulaire est limité à 10 tentatives par
 quart d'heure et par IP.
 
-La console n'écrit jamais : elle ne peut ni envoyer, ni supprimer, ni modifier.
+La console n'envoie ni ne modifie aucun message. Elle ne commande qu'une seule écriture,
+et c'est une suppression : la **purge des boîtes inactives**, derrière l'icône de corbeille
+de la barre du haut.
+
+Une boîte est inactive quand plus rien ne l'a touchée depuis la date choisie : ni
+connexion, ni message reçu ou envoyé. **Une boîte créée après cette date est épargnée,
+même vide** — une session qui vient de démarrer et n'a pas encore parlé n'est pas une
+boîte à l'abandon.
+
+La purge se fait en deux temps, parce qu'elle ne se rattrape pas :
+
+1. **L'aperçu** liste les boîtes concernées, chacune avec son nom, son adresse, son nombre
+   de messages et sa dernière activité. Chaque ligne se décoche.
+2. **La confirmation** demande deux clics, et n'envoie que les adresses affichées. Le
+   serveur, lui, reconfronte chacune à la date avant de supprimer : une boîte redevenue
+   active entre l'aperçu et la confirmation fait échouer la purge entière, nommément.
+   Changer la date ou décocher une ligne annule une confirmation déjà donnée.
+
+**Ce qui disparaît.** Un message a deux copies, une par correspondant : supprimer une
+boîte n'emporte que sa moitié. Le message lui-même ne s'efface qu'une fois sa dernière
+copie partie, autrement dit quand plus personne ne pourrait le lire ; un fil vidé de ses
+messages s'en va avec. Ce que l'autre côté a reçu reste intact, expéditeur compris.
+
+Le registre local des boîtes n'a pas à être nettoyé après une purge : une entrée qui
+désigne une boîte disparue n'est jamais reprise, et s'oublie d'elle-même.
 
 ---
 
@@ -506,6 +531,8 @@ la console (cookie), qui elle n'ouvre rien d'autre.
 | `GET` | `/admin/overview` · `/admin/messages[/:id]` | Supervision, lecture seule |
 | `GET` | `/admin/threads` | Fils du serveur entier (`agent` — une ou plusieurs adresses séparées par des virgules —, `search`, `unread_only`, `priority`, `limit`, `offset`) |
 | `GET` | `/admin/threads/:id` | Fil complet, corps inclus |
+| `GET` | `/admin/mailboxes/stale` | Boîtes sans activité depuis `before`, avec ce que chacune contient |
+| `POST` | `/admin/mailboxes/purge` | Supprime les boîtes nommées (`before`, `mailboxes`) — refusé si l'une d'elles est redevenue active |
 | `POST` | `/ui/login` · `/ui/logout` | Session de la console (`{ "token": … }` → cookie `HttpOnly`) |
 
 ---
@@ -525,8 +552,12 @@ la console (cookie), qui elle n'ouvre rien d'autre.
   dans les logs).
 - **Isolation des boîtes** garantie côté serveur : les identifiants de messages fournis par
   un agent sont systématiquement filtrés sur ses propres livraisons.
-- La console web n'insère jamais de HTML fourni par un agent (`textContent` uniquement) et
-  la CSP interdit tout script tiers.
+- La console web n'insère jamais de HTML fourni par un agent : le corps des messages est
+  rendu en markdown par construction de nœuds, jamais par assignation de balisage, et la
+  CSP interdit tout script tiers.
+- La console ne peut ni écrire ni modifier un message. Sa seule commande destructrice est
+  la purge des boîtes inactives, réservée au jeton d'administration, confirmée deux fois et
+  revérifiée par le serveur avant exécution.
 - Derrière un reverse proxy TLS, exposer le serveur en `https://` et donner cette URL aux
   agents via `MESSENGER_SERVER_URL`.
 
@@ -567,7 +598,8 @@ test/                   # store, config, API HTTP, outils MCP, binaire réel
 
 ### Tests
 
-207 tests couvrant : la reprise de la boîte d'une session interrompue (clé de session de
+231 tests couvrant : la purge des boîtes inactives commandée depuis la console (aperçu,
+double confirmation, refus nominatif d'une boîte redevenue active), la reprise de la boîte d'une session interrompue (clé de session de
 l'hôte, boîte orpheline, boîte d'une session vivante jamais reprise), le rendu markdown des messages et l'aplatissement des aperçus (dont
 l'innocuité du rendu : ni HTML interprété, ni lien vers un autre schéma qu'`http`, `https`
 ou `mailto`), le stockage et l'isolation des boîtes, la validation de configuration,

package/dist/src/core/store.d.ts

@@ -87,6 +87,31 @@ export declare class MessageStore extends EventEmitter<StoreEvents> {
     stats(agentId: string): MailboxStats;
     /** Purge les livraisons restées en corbeille au-delà de `days`. Renvoie le nombre supprimé. */
     purgeTrash(days: number): number;
+    /**
+     * Boîtes dont plus rien ne bouge depuis `before`, avec ce que leur suppression coûterait.
+     *
+     * L'inactivité se mesure au plus récent de trois moments : la dernière connexion, la
+     * dernière livraison, et la création. Le dernier compte autant que les autres — une
+     * boîte allouée il y a une minute et qui n'a rien fait n'est pas une boîte à l'abandon,
+     * c'est une session qui n'a pas encore parlé.
+     */
+    staleMailboxes(before: string): (AgentDirectoryEntry & {
+        messages: number;
+    })[];
+    /**
+     * Supprime ces boîtes et tout ce qui n'appartenait qu'à elles.
+     *
+     * Un message a deux copies, une par correspondant : effacer une boîte n'efface donc que
+     * sa moitié. Le message lui-même ne disparaît qu'une fois sa dernière copie partie —
+     * autrement dit quand plus personne ne peut le lire. Ce que l'autre côté a reçu reste
+     * intact, avec l'adresse de l'expéditeur telle qu'elle a été livrée.
+     */
+    deleteMailboxes(ids: string[]): {
+        mailboxes: number;
+        deliveries: number;
+        messages: number;
+        threads: number;
+    };
     /** Vue globale : tous les messages du serveur, indépendamment des boîtes. */
     listAllMessages(opts?: {
         search?: string;

package/dist/src/core/store.js

@@ -581,7 +581,64 @@ export class MessageStore extends EventEmitter {
         this.dropOrphanMessages();
         return removed;
     }
-    // --- Supervision (interface web, lecture seule) --------------------------
+    /**
+     * Boîtes dont plus rien ne bouge depuis `before`, avec ce que leur suppression coûterait.
+     *
+     * L'inactivité se mesure au plus récent de trois moments : la dernière connexion, la
+     * dernière livraison, et la création. Le dernier compte autant que les autres — une
+     * boîte allouée il y a une minute et qui n'a rien fait n'est pas une boîte à l'abandon,
+     * c'est une session qui n'a pas encore parlé.
+     */
+    staleMailboxes(before) {
+        const rows = this.db
+            .prepare(`SELECT a.*, ${LAST_ACTIVITY} AS last_activity_at,
+                (SELECT COUNT(*) FROM deliveries d WHERE d.agent_id = a.id) AS messages
+           FROM agents a
+          WHERE MAX(${LAST_ACTIVITY}, a.created_at) < ?
+          ORDER BY MAX(${LAST_ACTIVITY}, a.created_at) ASC`)
+            .all(before);
+        return rows.map((row) => ({
+            ...row,
+            registered: Boolean(row.registered),
+            last_activity_at: row.last_activity_at || null,
+        }));
+    }
+    /**
+     * Supprime ces boîtes et tout ce qui n'appartenait qu'à elles.
+     *
+     * Un message a deux copies, une par correspondant : effacer une boîte n'efface donc que
+     * sa moitié. Le message lui-même ne disparaît qu'une fois sa dernière copie partie —
+     * autrement dit quand plus personne ne peut le lire. Ce que l'autre côté a reçu reste
+     * intact, avec l'adresse de l'expéditeur telle qu'elle a été livrée.
+     */
+    deleteMailboxes(ids) {
+        if (ids.length === 0)
+            return { mailboxes: 0, deliveries: 0, messages: 0, threads: 0 };
+        return this.db.transaction(() => {
+            const messagesBefore = this.db.prepare("SELECT COUNT(*) AS n FROM messages").get().n;
+            const threadsBefore = this.db.prepare("SELECT COUNT(*) AS n FROM threads").get().n;
+            let mailboxes = 0;
+            let deliveries = 0;
+            const dropDeliveries = this.db.prepare("DELETE FROM deliveries WHERE agent_id = ?");
+            const dropFolders = this.db.prepare("DELETE FROM folders WHERE agent_id = ?");
+            const dropAgent = this.db.prepare("DELETE FROM agents WHERE id = ?");
+            for (const id of ids) {
+                deliveries += dropDeliveries.run(id).changes;
+                dropFolders.run(id);
+                mailboxes += dropAgent.run(id).changes;
+            }
+            this.dropOrphanMessages();
+            const messagesAfter = this.db.prepare("SELECT COUNT(*) AS n FROM messages").get().n;
+            const threadsAfter = this.db.prepare("SELECT COUNT(*) AS n FROM threads").get().n;
+            return {
+                mailboxes,
+                deliveries,
+                messages: messagesBefore - messagesAfter,
+                threads: threadsBefore - threadsAfter,
+            };
+        })();
+    }
+    // --- Supervision (interface web, lecture seule sauf purge) ---------------
     /** Vue globale : tous les messages du serveur, indépendamment des boîtes. */
     listAllMessages(opts = {}) {
         const limit = clamp(opts.limit ?? 50, 1, MAX_LIMIT);

package/dist/src/server/app.js

@@ -89,6 +89,24 @@ const adminThreadsSchema = z.object({
     limit: z.coerce.number().int().min(1).max(100).optional(),
     offset: z.coerce.number().int().min(0).optional(),
 });
+/**
+ * Date de coupure d'une purge.
+ *
+ * Un jour (`2026-08-01`) autant qu'un instant (`2026-08-01T09:00:00.000Z`) : la console
+ * envoie ce que le champ de date du navigateur produit, un jour nu, qui est déjà un
+ * horodatage ISO valide et se compare tel quel aux dates stockées.
+ */
+const isoDate = z
+    .string()
+    .trim()
+    .regex(/^\d{4}-\d{2}-\d{2}(T[\d:.]+Z?)?$/, "expected a date such as 2026-08-01")
+    .refine((value) => !Number.isNaN(Date.parse(value)), "not a real date");
+const staleSchema = z.object({ before: isoDate });
+const purgeSchema = z.object({
+    before: isoDate,
+    /** Les adresses vues dans l'aperçu : on ne supprime jamais autre chose que ce qui a été montré. */
+    mailboxes: z.array(z.string().trim().min(1)).min(1).max(500),
+});
 const adminListSchema = z.object({
     search: z.string().trim().min(1).optional(),
     agent: z.string().trim().min(1).optional(),
@@ -157,7 +175,7 @@ export function createApp({ store, config }) {
     app.get("/", (_req, res) => {
         res.redirect("/ui/");
     });
-    // --- Supervision (lecture seule) -----------------------------------------
+    // --- Supervision (lecture, sauf la purge des boîtes inactives) -----------
     // Montée avant la porte d'entrée : son contrôle est au moins aussi strict (session de
     // console ou jeton admin), et la session par cookie n'est reconnue nulle part ailleurs.
     const admin = express.Router();
@@ -197,6 +215,35 @@ export function createApp({ store, config }) {
             throw new MessengerError(`thread not found: ${threadId}`, 404);
         res.json({ thread_id: threadId, thread: store.getThreadInfo(threadId), messages });
     });
+    /**
+     * Boîtes sans activité depuis une date : ce que la purge emporterait.
+     *
+     * Toujours consultée avant de supprimer — la console montre la liste, et c'est sur cette
+     * liste que porte la suppression. Une purge ne se décide pas sur un compte.
+     */
+    admin.get("/mailboxes/stale", (req, res) => {
+        const { before } = staleSchema.parse(req.query);
+        res.json({ before, mailboxes: store.staleMailboxes(before) });
+    });
+    /**
+     * La seule route de la console qui écrit, et elle détruit.
+     *
+     * Deux garde-fous, parce qu'une purge ne se rattrape pas : la date est redemandée avec
+     * les adresses, et le serveur refuse toute adresse qui ne serait pas, au moment où il
+     * répond, sans activité depuis cette date. Une boîte redevenue vivante entre l'aperçu
+     * et la confirmation est donc épargnée, et le refus est nominatif.
+     */
+    admin.post("/mailboxes/purge", (req, res) => {
+        const input = purgeSchema.parse(req.body ?? {});
+        const stale = new Set(store.staleMailboxes(input.before).map((mailbox) => mailbox.id));
+        const active = input.mailboxes.filter((id) => !stale.has(id));
+        if (active.length > 0) {
+            throw new MessengerError(`these mailboxes are no longer inactive since ${input.before}, nothing was deleted: ${active.join(", ")}`, 409);
+        }
+        const removed = store.deleteMailboxes(input.mailboxes);
+        logger.warn(`admin purge: ${removed.mailboxes} mailbox(es) deleted, inactive since ${input.before}`);
+        res.json({ before: input.before, ...removed });
+    });
     app.use("/admin", admin);
     // Porte d'entrée de tout le reste : aucune requête n'est servie sans jeton valide. Le
     // contrôle par route (identité de l'agent) vient ensuite.

package/dist/src/server/ui/app.js

@@ -1,4 +1,7 @@
-// Console de supervision : lecture seule sur les routes /admin du serveur.
+// Console de supervision : les routes /admin du serveur, en lecture — à une exception
+// près, la purge des boîtes inactives, seule commande de cette page qui écrit, et qui
+// détruit. Elle est donc tenue à part : un aperçu, puis une confirmation, et rien ne part
+// que le serveur n'ait redemandé sa date.
 //
 // Tout le contenu affiché provient d'agents : il est inséré via textContent uniquement,
 // jamais par innerHTML. Les seuls fragments de balisage construits ici sont les icônes,
@@ -77,6 +80,14 @@ const el = {
   threads: document.getElementById("threads"),
   reader: document.getElementById("reader"),
   sheet: document.getElementById("sheet"),
+  purge: document.getElementById("purge"),
+  purgeOpen: document.getElementById("purge-open"),
+  purgeClose: document.getElementById("purge-close"),
+  purgeCancel: document.getElementById("purge-cancel"),
+  purgeBefore: document.getElementById("purge-before"),
+  purgePreview: document.getElementById("purge-preview"),
+  purgeResult: document.getElementById("purge-result"),
+  purgeConfirm: document.getElementById("purge-confirm"),
 };
 
 // --- Fabrique de noeuds ----------------------------------------------------
@@ -235,6 +246,12 @@ function formatShort(iso) {
   return date.toLocaleDateString([], { day: "2-digit", month: "2-digit" });
 }
 
+/** Jour seul, sans heure : une purge se raisonne en jours, pas en minutes. */
+function formatDay(iso) {
+  const date = new Date(iso);
+  return Number.isNaN(date.getTime()) ? String(iso) : date.toLocaleDateString();
+}
+
 function plural(count, singular, pluralForm) {
   return `${count} ${count > 1 ? pluralForm || `${singular}s` : singular}`;
 }
@@ -258,6 +275,23 @@ async function api(path, params) {
   return response.json();
 }
 
+/** Envoi d'une action à la console. La seule qui existe supprime : elle passe par ici. */
+async function post(path, body) {
+  const response = await fetch(path, {
+    method: "POST",
+    headers: { "content-type": "application/json", accept: "application/json" },
+    credentials: "same-origin",
+    body: JSON.stringify(body),
+  });
+  if (response.status === 401) {
+    setLoggedIn(false);
+    throw new Error("unauthorized");
+  }
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok) throw new Error(payload.error || response.statusText);
+  return payload;
+}
+
 function setLoggedIn(loggedIn) {
   el.login.hidden = loggedIn;
   el.console.hidden = !loggedIn;
@@ -906,14 +940,160 @@ async function refresh(options) {
   }
 }
 
+// --- Purge des boîtes inactives --------------------------------------------
+
+/**
+ * Ce que la fenêtre de purge a sous la main : la date de l'aperçu, les boîtes que le
+ * serveur a désignées, celles qui restent cochées, et si la suppression a déjà été
+ * demandée une fois. Le second clic est ce qui la déclenche.
+ */
+const purge = { before: null, mailboxes: [], selected: new Set(), armed: false };
+
+function openPurge() {
+  const month = new Date(Date.now() - 30 * 86_400_000);
+  el.purgeBefore.value = month.toISOString().slice(0, 10);
+  el.purgeBefore.max = new Date().toISOString().slice(0, 10);
+  resetPurge();
+  el.purge.showModal();
+}
+
+/** Toute modification remet la confirmation à zéro : on ne supprime que ce qu'on vient de voir. */
+function resetPurge() {
+  purge.before = null;
+  purge.mailboxes = [];
+  purge.selected = new Set();
+  purge.armed = false;
+  el.purgeResult.replaceChildren();
+  el.purgeConfirm.disabled = true;
+  el.purgeConfirm.textContent = "Supprimer";
+}
+
+async function previewPurge() {
+  const before = el.purgeBefore.value;
+  if (!before) return;
+  resetPurge();
+  try {
+    const { mailboxes } = await api("/admin/mailboxes/stale", { before });
+    purge.before = before;
+    purge.mailboxes = mailboxes;
+    purge.selected = new Set(mailboxes.map((mailbox) => mailbox.id));
+    renderPurgePreview();
+  } catch (error) {
+    el.purgeResult.replaceChildren(node("p", "purge-error", `Erreur : ${error.message}`));
+  }
+}
+
+function renderPurgePreview() {
+  const container = document.createDocumentFragment();
+
+  if (purge.mailboxes.length === 0) {
+    container.appendChild(node("p", "purge-empty", `Aucune boîte sans activité depuis le ${formatDay(purge.before)}.`));
+    el.purgeResult.replaceChildren(container);
+    return;
+  }
+
+  container.appendChild(
+    node("p", "purge-count", `${plural(purge.mailboxes.length, "boîte")} sans activité depuis le ${formatDay(purge.before)}.`)
+  );
+
+  const list = node("ul", "purge-list");
+  for (const mailbox of purge.mailboxes) {
+    const item = node("li", "purge-item");
+    const label = node("label", "purge-line");
+
+    const box = document.createElement("input");
+    box.type = "checkbox";
+    box.checked = true;
+    box.addEventListener("change", () => {
+      if (box.checked) purge.selected.add(mailbox.id);
+      else purge.selected.delete(mailbox.id);
+      // Décocher change ce qui sera supprimé : la confirmation déjà armée ne vaut plus.
+      purge.armed = false;
+      updatePurgeButton();
+    });
+    label.appendChild(box);
+
+    const text = node("span", "purge-text");
+    text.appendChild(node("span", "purge-name", mailbox.display_name || mailbox.agent_name || "boîte sans nom"));
+    text.appendChild(node("span", "mono muted", mailbox.id));
+    const activity = mailbox.last_activity_at ? `dernière activité ${formatDay(mailbox.last_activity_at)}` : "jamais utilisée";
+    text.appendChild(node("span", "purge-meta", `${plural(mailbox.messages, "message")} · ${activity}`));
+    label.appendChild(text);
+
+    item.appendChild(label);
+    list.appendChild(item);
+  }
+  container.appendChild(list);
+
+  el.purgeResult.replaceChildren(container);
+  updatePurgeButton();
+}
+
+function updatePurgeButton() {
+  const count = purge.selected.size;
+  el.purgeConfirm.disabled = count === 0;
+  el.purgeConfirm.textContent = purge.armed
+    ? `Confirmer : supprimer ${plural(count, "boîte")}`
+    : `Supprimer ${plural(count, "boîte")}`;
+}
+
+async function confirmPurge() {
+  if (purge.selected.size === 0 || !purge.before) return;
+
+  // Premier clic : la suppression est armée, pas faite. Rien ne part sans un second clic.
+  if (!purge.armed) {
+    purge.armed = true;
+    updatePurgeButton();
+    return;
+  }
+
+  el.purgeConfirm.disabled = true;
+  try {
+    const removed = await post("/admin/mailboxes/purge", {
+      before: purge.before,
+      mailboxes: [...purge.selected],
+    });
+    resetPurge();
+    el.purgeResult.replaceChildren(
+      node(
+        "p",
+        "purge-done",
+        `${plural(removed.mailboxes, "boîte")} supprimée(s), ${plural(removed.messages, "message")} et ${plural(removed.threads, "fil")} avec.`
+      )
+    );
+    // La console montre encore ce qui n'existe plus : elle se relit entièrement.
+    state.threadId = null;
+    state.messageId = null;
+    el.sheet.hidden = true;
+    el.console.classList.remove("has-sheet");
+    await refresh();
+  } catch (error) {
+    purge.armed = false;
+    updatePurgeButton();
+    el.purgeResult.appendChild(node("p", "purge-error", `Erreur : ${error.message}`));
+  }
+}
+
 // --- Écouteurs -------------------------------------------------------------
 
+el.purgeOpen.addEventListener("click", openPurge);
+el.purgeClose.addEventListener("click", () => el.purge.close());
+el.purgeCancel.addEventListener("click", () => el.purge.close());
+el.purgeBefore.addEventListener("change", resetPurge);
+el.purgePreview.addEventListener("click", previewPurge);
+el.purgeConfirm.addEventListener("click", confirmPurge);
+
 el.refresh.addEventListener("click", () => refresh({ keepThread: true }));
 
+// Le bouton reste en place une fois la colonne repliée : il est le seul moyen de la
+// rouvrir. Seul ce qu'il annonce change.
 el.collapse.addEventListener("click", () => {
   state.collapsed = !state.collapsed;
   el.console.classList.toggle("is-collapsed", state.collapsed);
+  const label = state.collapsed ? "Déplier la liste des agents" : "Replier la liste des agents";
   el.collapse.title = state.collapsed ? "Déplier" : "Replier";
+  el.collapse.setAttribute("aria-label", label);
+  el.collapse.setAttribute("aria-expanded", String(!state.collapsed));
 });
 
 el.chips.addEventListener("click", (event) => {

package/dist/src/server/ui/index.html

@@ -42,10 +42,57 @@
             <path d="M3 21v-5h5" />
           </svg>
         </button>
+        <button type="button" id="purge-open" class="btn btn--icon" title="Purger les boîtes inactives" aria-label="Purger les boîtes inactives">
+          <svg class="icon" viewBox="0 0 24 24" aria-hidden="true">
+            <path d="M3 6h18" />
+            <path d="M8 6V4a1 1 0 0 1 1-1h6a1 1 0 0 1 1 1v2" />
+            <path d="M19 6l-1 14a2 2 0 0 1-2 2H8a2 2 0 0 1-2-2L5 6" />
+          </svg>
+        </button>
         <button type="button" id="logout" class="btn btn--link">Se déconnecter</button>
       </div>
     </header>
 
+    <!--
+      Purge des boîtes inactives : la seule action de la console qui écrit, et elle
+      détruit. Elle se fait donc en deux temps, l'aperçu puis la confirmation, et ne porte
+      jamais que sur les boîtes affichées.
+    -->
+    <dialog class="modal" id="purge">
+      <div class="modal-card">
+        <div class="modal-head">
+          <h2>Purger les boîtes inactives</h2>
+          <button type="button" class="btn btn--icon btn--ghost" id="purge-close" aria-label="Fermer">
+            <svg class="icon" viewBox="0 0 24 24" aria-hidden="true">
+              <path d="M18 6 6 18" />
+              <path d="m6 6 12 12" />
+            </svg>
+          </button>
+        </div>
+        <p class="modal-sub">
+          Une boîte est inactive quand plus rien ne l'a touchée depuis la date choisie : ni connexion, ni message reçu
+          ou envoyé. Une boîte créée après cette date est laissée tranquille, même vide. La suppression est définitive
+          et emporte les messages que plus personne ne pourrait lire ; ce que le correspondant a reçu de son côté reste
+          intact.
+        </p>
+
+        <div class="purge-controls">
+          <label class="field">
+            <span class="field-label">Sans activité depuis le</span>
+            <span class="field-input"><input type="date" id="purge-before" /></span>
+          </label>
+          <button type="button" class="btn" id="purge-preview">Prévisualiser</button>
+        </div>
+
+        <div class="purge-result" id="purge-result"></div>
+
+        <div class="modal-foot">
+          <button type="button" class="btn btn--link" id="purge-cancel">Fermer</button>
+          <button type="button" class="btn btn--danger" id="purge-confirm" disabled>Supprimer</button>
+        </div>
+      </div>
+    </dialog>
+
     <!-- Écran de connexion : une carte seule, sans les panneaux vides derrière elle. -->
     <main class="login" id="login" hidden>
       <form class="card" id="login-form">
@@ -85,7 +132,7 @@
       <aside class="agents" id="agents-pane">
         <div class="agents-head">
           <span class="section-label">Agents</span>
-          <button type="button" class="btn btn--icon btn--ghost" id="collapse" title="Replier" aria-label="Replier la liste des agents">
+          <button type="button" class="btn btn--icon btn--ghost" id="collapse" title="Replier" aria-label="Replier la liste des agents" aria-expanded="true">
             <svg class="icon" viewBox="0 0 24 24" aria-hidden="true">
               <rect x="3" y="3" width="18" height="18" rx="2" />
               <path d="M9 3v18" />