@imenam/mcp-messenger 1.0.16 → 1.0.18

package/dist/src/mcp/start.js

@@ -7,6 +7,8 @@ import { removeOwnHandoffs } from "../cli/watch-handoff.js";
 import { newId } from "../core/ids.js";
 import { logger } from "../logger.js";
 import { APP_VERSION } from "../version.js";
+import { HEARTBEAT_MS, claim, heartbeat, orphanEntries, projectFingerprint, purge, releaseOwn, sessionKeyDigest, } from "./mailbox-registry.js";
+import { setResumeState } from "./resume-state.js";
 import { TOOLS, callTool } from "./tools.js";
 /**
  * Ce que l'hôte reçoit à la poignée de main, avant le moindre appel d'outil.
@@ -29,6 +31,11 @@ Who you are, and who the others are — read this before writing to anyone:
 - One of those groups may carry the same agent name as yours. Recognising your own agent name there does not mean you are looking at yourself — those are other sessions of the same project, each a different agent with its own mailbox. Compare addresses, never names.
 - Your own mailbox is never listed in \`list_agents\`: every address you see there belongs to someone else.
 
+Resuming earlier work:
+- A resumed session usually keeps the mailbox it had: the address, the threads and the unread messages come back on their own. \`whoami\` says so when it happens.
+- When it cannot be decided automatically, \`whoami\` lists the mailboxes left by a stopped session of this project. If you are continuing that work, call \`attach_to_mailbox\` with the right address.
+- If a \`box_…\` address appears earlier in your own context, from a previous part of this conversation, that is your mailbox from before: attach to it rather than writing from a fresh one, so your correspondents keep reaching you at the address they know.
+
 Writing:
 - One message goes to exactly one mailbox, and never to your own. To reach several correspondents, send each one its own message.
 - Never write a mailbox address in the body of a message. The server attaches the sender and the recipient to every message, and the reader sees them: an address copied by hand adds nothing and misleads as soon as it is stale or mistaken.
@@ -55,17 +62,61 @@ export function createMcpServer(client) {
 /**
  * Donne son adresse à la session.
  *
- * Avec `MESSENGER_AGENT_ID`, l'adresse est fixe et partagée par toutes les sessions qui
- * utilisent cette configuration. Sans elle — le cas normal — une boîte neuve est allouée
- * pour cette session : deux agents lancés dans le même projet ne se marchent pas dessus.
- * L'identifiant est opaque : c'est une adresse à transmettre, pas un rôle à deviner.
+ * Trois chemins, du plus certain au plus approximatif :
+ *
+ * 1. `MESSENGER_AGENT_ID` fixe l'adresse, partagée par toutes les sessions de cette
+ *    configuration. Rien à chercher.
+ * 2. Le registre local rend à une session reprise la boîte qu'elle tenait : identique si
+ *    l'hôte a redonné le même identifiant de session, sinon la seule boîte du projet
+ *    qu'aucune session vivante ne tient plus et qui a réellement servi.
+ * 3. À défaut, une boîte neuve, comme avant. Les boîtes orphelines non reprises sont
+ *    gardées de côté : `whoami` les propose, l'agent en rattache une s'il reconnaît la
+ *    sienne dans son contexte.
+ *
+ * Une boîte tenue par une session vivante n'est jamais reprise : c'est ce qui distingue
+ * ce mécanisme d'une adresse partagée, et ce qui protège deux sessions ouvertes en
+ * parallèle sur le même projet.
  */
-export async function resolveIdentity(client, config) {
+export async function resolveIdentity(client, config, options = {}) {
+    const keySource = config.sessionKey ? config.sessionKeySource : null;
     if (config.agentId) {
         client.setAgentId(config.agentId, { own: true });
         await client.register();
-        return config.agentId;
+        const identity = { mailbox: config.agentId, resumed: null, candidates: [] };
+        setResumeState(client, { resumed: null, candidates: [], keySource });
+        return identity;
+    }
+    const fingerprint = projectFingerprint({
+        cwd: options.cwd ?? process.cwd(),
+        agentName: config.agentName,
+        serverUrl: config.serverUrl,
+    });
+    const sessionKey = config.sessionKey ? sessionKeyDigest(config.sessionKey) : null;
+    purge();
+    const found = config.resume === "off" ? [] : await inspectOrphans(config, orphanEntries(fingerprint));
+    const exact = sessionKey ? found.find((c) => c.entry.session_key === sessionKey) : undefined;
+    // Une seule boîte laissée par une session arrêtée, et elle a servi : l'ambiguïté
+    // n'existe pas. Plusieurs, ou une boîte vide, et c'est à l'agent de choisir.
+    const sole = found.length === 1 && found[0].candidate.messages > 0 ? found[0] : undefined;
+    const taken = config.resume === "auto" ? (exact ?? sole) : exact;
+    if (taken) {
+        client.setAgentId(taken.candidate.mailbox, { own: true });
+        await client.register();
+        claim({ mailbox: taken.candidate.mailbox, fingerprint, sessionKey });
+        const resumed = taken === exact ? "session-key" : "orphan";
+        const candidates = found.filter((c) => c !== taken).map((c) => c.candidate);
+        setResumeState(client, { resumed, candidates, keySource });
+        return { mailbox: taken.candidate.mailbox, resumed, candidates };
     }
+    const mailbox = await allocateMailbox(client);
+    claim({ mailbox, fingerprint, sessionKey });
+    // Une boîte vide n'apprend rien à personne : seules celles qui ont du courrier valent
+    // la peine d'être proposées.
+    const candidates = found.map((c) => c.candidate).filter((c) => c.messages > 0);
+    setResumeState(client, { resumed: null, candidates, keySource });
+    return { mailbox, resumed: null, candidates };
+}
+async function allocateMailbox(client) {
     // `fresh` fait échouer l'enregistrement si l'adresse existe déjà : la collision, même
     // improbable sur 64 bits d'aléa, ne peut pas faire atterrir deux sessions au même endroit.
     for (let attempt = 0; attempt < 5; attempt += 1) {
@@ -83,6 +134,57 @@ export async function resolveIdentity(client, config) {
     }
     throw new Error("could not allocate a mailbox: too many id collisions");
 }
+/**
+ * Ce que le journal dit du démarrage.
+ *
+ * C'est le seul endroit d'où l'on peut vérifier que l'hôte transmet bien un identifiant
+ * de session, et lequel : sans cette ligne, une reprise qui n'a pas lieu ne s'explique pas.
+ */
+function describeIdentity(identity, config) {
+    const key = config.sessionKeySource ? `session key from ${config.sessionKeySource}` : "no host session key";
+    const how = identity.resumed === "session-key"
+        ? "resumed from the previous session (same host session id)"
+        : identity.resumed === "orphan"
+            ? "resumed the only mailbox left by a stopped session of this project"
+            : "new mailbox";
+    const waiting = identity.candidates.length > 0 ? `, ${identity.candidates.length} resumable mailbox(es)` : "";
+    return ` — ${how} (${key})${waiting}`;
+}
+/** Nombre de boîtes orphelines examinées : au-delà, le démarrage coûterait plus qu'il ne rend. */
+const MAX_CANDIDATES = 5;
+/**
+ * Confronte les entrées du registre au serveur : une boîte peut avoir disparu (base
+ * réinitialisée), et une boîte vide n'a rien à reprendre. Un serveur injoignable ne fait
+ * pas échouer le démarrage, il rend simplement la reprise impossible pour cette fois.
+ */
+async function inspectOrphans(config, entries) {
+    // Client jetable : la session n'a pas encore d'adresse, et celle-ci ne doit pas bouger
+    // au gré de l'inspection.
+    const probe = new MessengerClient(config);
+    const found = [];
+    for (const entry of entries.slice(0, MAX_CANDIDATES)) {
+        probe.setAgentId(entry.mailbox);
+        try {
+            const agent = await probe.getAgent(entry.mailbox);
+            const stats = await probe.stats();
+            found.push({
+                entry,
+                candidate: {
+                    mailbox: entry.mailbox,
+                    agent_name: agent.agent_name,
+                    mailbox_name: agent.display_name,
+                    messages: stats.folders.reduce((total, folder) => total + folder.total, 0),
+                    unread: stats.unread_total,
+                    last_activity: agent.last_seen_at,
+                },
+            });
+        }
+        catch (error) {
+            logger.info(`mailbox ${entry.mailbox} cannot be resumed: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    return found;
+}
 /** Point d'entrée du mode MCP (mode par défaut, sans argument). */
 export async function runMcpMode() {
     const config = loadAgentConfig();
@@ -90,18 +192,27 @@ export async function runMcpMode() {
     // Un serveur momentanément injoignable ne doit pas empêcher la session MCP de démarrer :
     // l'agent verra l'erreur au premier outil appelé, et pourra réessayer.
     try {
-        const agentId = await resolveIdentity(client, config);
-        logger.info(`mailbox \`${agentId}\` ready on ${config.serverUrl}`);
+        const identity = await resolveIdentity(client, config);
+        logger.info(`mailbox \`${identity.mailbox}\` ready on ${config.serverUrl}${describeIdentity(identity, config)}`);
     }
     catch (error) {
         logger.warn(`could not reach ${config.serverUrl}: ${error instanceof Error ? error.message : String(error)}`);
     }
+    // Tant que ce battement continue, la boîte de cette session n'est reprise par personne.
+    // `unref` : c'est une trace, pas une raison de garder le processus en vie.
+    setInterval(heartbeat, HEARTBEAT_MS).unref();
     // Le relais vers le veilleur porte le jeton de la session : il ne survit pas à la
     // session. Un arrêt brutal le laisse en place, la purge par ancienneté le rattrape.
-    process.on("exit", removeOwnHandoffs);
+    // L'entrée du registre suit le même sort, à ceci près qu'elle est close et non effacée :
+    // c'est elle qui rendra sa boîte à la session suivante.
+    process.on("exit", () => {
+        removeOwnHandoffs();
+        releaseOwn();
+    });
     for (const signal of ["SIGINT", "SIGTERM"]) {
         process.on(signal, () => {
             removeOwnHandoffs();
+            releaseOwn();
             process.exit(0);
         });
     }

package/dist/src/mcp/tools.js

@@ -1,6 +1,8 @@
 import { z } from "zod";
 import { writeHandoff } from "../cli/watch-handoff.js";
 import { PRIORITIES, SYSTEM_FOLDERS } from "../core/types.js";
+import { rebind } from "./mailbox-registry.js";
+import { forgetCandidate, getResumeState } from "./resume-state.js";
 /** Nom publié : l'agent recopie la commande, il n'a pas à connaître de chemin local. */
 const PACKAGE_NAME = "@imenam/mcp-messenger";
 const FOLDER_HINT = `Folder name. System folders: ${SYSTEM_FOLDERS.join(", ")}. Custom folders come from list_folders.`;
@@ -335,6 +337,7 @@ export async function callTool(client, name, rawArgs) {
             if (client.isAttachedElsewhere) {
                 lines.push(`Attached to another mailbox. This session's own mailbox is ${client.sessionAgentId}.`);
             }
+            lines.push(...resumeLines(client));
             lines.push(`Mailbox server: ${client.serverUrl}${health ? ` (v${health.version}, ${health.agents} mailbox(es))` : " (unreachable health endpoint)"}`, 
             // Sans veilleur, un message arrive en boîte sans que personne n'en soit averti.
             // Le dire ici est le seul moyen pour l'agent de s'en apercevoir.
@@ -350,12 +353,17 @@ export async function callTool(client, name, rawArgs) {
                 if (!own)
                     throw new Error("this session has no mailbox of its own to return to");
                 client.setAgentId(own);
+                rebind(own);
                 return `Back to this session's own mailbox: ${own}`;
             }
             // Vérifie que la boîte existe avant de basculer : une faute de frappe créerait
             // silencieusement une boîte vide, et l'agent croirait avoir repris le travail.
             const target = await client.getAgent(input.mailbox_id);
             client.setAgentId(target.id);
+            // La session travaille désormais cette boîte : c'est elle que sa prochaine reprise
+            // doit retrouver, et elle n'a plus à être proposée.
+            rebind(target.id);
+            forgetCandidate(client, target.id);
             const attachedStats = await client.stats();
             return [
                 `Attached to mailbox ${target.id}${formatAgentNames(target) ? ` (${formatAgentNames(target)})` : ""}.`,
@@ -678,6 +686,35 @@ async function renameThread(client, threadId, name, description) {
         .filter(Boolean)
         .join("\n");
 }
+/**
+ * Ce que `whoami` dit des sessions précédentes.
+ *
+ * Deux choses, et seulement quand elles ont eu lieu : que cette boîte vient d'une session
+ * arrêtée — l'agent doit savoir d'où sortent des fils qu'il n'a pas ouverts — et quelles
+ * boîtes du projet attendent encore quelqu'un.
+ */
+function resumeLines(client) {
+    const state = getResumeState(client);
+    if (!state)
+        return [];
+    const lines = [];
+    if (state.resumed === "session-key") {
+        lines.push("Resumed: this is the mailbox of the session you are continuing (matched on the host session id).");
+    }
+    else if (state.resumed === "orphan") {
+        lines.push("Resumed: this mailbox was left by a stopped session of this project, and no live session held it.", "  ↳ its threads and unread messages are not yours from this conversation; read before you answer.");
+    }
+    if (state.candidates.length > 0) {
+        lines.push("Mailboxes left by a stopped session of this project:");
+        for (const candidate of state.candidates) {
+            const name = candidate.mailbox_name ?? "unnamed mailbox";
+            const seen = candidate.last_activity ? ` · last activity ${candidate.last_activity}` : "";
+            lines.push(`  ${candidate.mailbox} — ${name} · ${candidate.messages} message(s), ${candidate.unread} unread${seen}`);
+        }
+        lines.push("  ↳ if you are resuming that work, call attach_to_mailbox with its address.");
+    }
+    return lines;
+}
 /** `titre (id)`, ou l'id seul tant que le fil n'a pas été nommé. */
 function formatThreadRef(title, threadId) {
     return title ? `${title} (${threadId})` : threadId;

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" />