@imenam/mcp-messenger 1.0.27 → 1.0.29

package/README.md

@@ -37,16 +37,20 @@ identifiée par une adresse opaque du type `box_9f2c4a01b3d7e5f8` — voir
 ### 1. Lancer la boîte aux lettres
 
 ```bash
-# Un jeton, à conserver : il sera demandé au serveur, aux agents et à la console.
-npx @imenam/mcp-messenger --generate-token
+# Deux jetons distincts : celui des agents, et celui de la console.
+npx @imenam/mcp-messenger --generate-token   # → jeton client
+npx @imenam/mcp-messenger --generate-token   # → jeton console
 
-MESSENGER_TOKEN=<le-jeton> npx @imenam/mcp-messenger --server
+MESSENGER_TOKEN=<jeton-client> MESSENGER_ADMIN_TOKEN=<jeton-console> \
+  npx @imenam/mcp-messenger --server
 # → listening on http://127.0.0.1:3600 (loopback only)
 # → auth: shared token — required on every request
+# → WARN shared token: no isolation between mailboxes — any holder can act as any address
+# → WARN set MESSENGER_AGENT_TOKENS (one token per agent) to compartmentalize
 # → web console: http://127.0.0.1:3600/ui/ (asks for MESSENGER_ADMIN_TOKEN once)
 ```
 
-Deux invariants, non négociables et vérifiés par les tests :
+Trois invariants, non négociables et vérifiés par les tests :
 
 1. **Le serveur écoute toujours sur `127.0.0.1`.** `MESSENGER_HOST` n'est pas un réglage :
    toute autre valeur fait échouer le démarrage. Pour joindre la boîte depuis une autre
@@ -55,6 +59,20 @@ Deux invariants, non négociables et vérifiés par les tests :
    et données de la console (`/admin`) comprises. Seule la page de la console, qui ne
    contient aucun secret, est servie librement. Sans `MESSENGER_TOKEN` ni
    `MESSENGER_AGENT_TOKENS`, le serveur refuse de démarrer.
+3. **Le jeton de la console n'est jamais celui des agents.** `MESSENGER_ADMIN_TOKEN` est
+   exigé dans tous les cas, et le démarrage échoue s'il vaut `MESSENGER_TOKEN`. La console
+   voit toutes les boîtes de tous les projets et sait les supprimer, alors que le jeton
+   client est recopié dans le `.mcp.json` de chaque projet : les confondre donnerait ce
+   pouvoir à tout porteur de ce fichier.
+
+> **Le mode jeton partagé ne cloisonne pas les boîtes.** `MESSENGER_TOKEN` atteste
+> l'appartenance à la flotte, pas une adresse : l'en-tête `X-Agent-Id` qui accompagne chaque
+> appel n'est alors adossé à rien, et tout porteur du jeton peut lire, envoyer et supprimer
+> au nom de n'importe quelle boîte. C'est un mode « cercle de confiance », adapté aux
+> sessions d'une même personne sur une même machine — le serveur le rappelle au démarrage.
+> Dès que les agents ne se font pas mutuellement confiance, passer à
+> [`MESSENGER_AGENT_TOKENS`](#serveur), qui lie chaque adresse à son propre
+> jeton et rejette toute autre combinaison.
 
 ### 2. Déclarer le MCP côté agent
 
@@ -118,11 +136,10 @@ enable_notifications()      → retourne immédiatement, ne bloque rien
   Last step — call the Monitor tool now, with exactly these arguments:
     command:     npx -y @imenam/mcp-messenger --watch box_9f2c4a01b3d7e5f8
     description: Incoming messenger messages
-    persistent:  true
+    timeout_ms:  1800000
 ```
 
-L'agent recopie ces trois arguments dans l'outil `Monitor` de son hôte, et c'est fini pour la
-session. Le veilleur tourne en fond, tient une attente longue sur `/api/wait`, et écrit **une
+L'agent recopie ces trois arguments dans l'outil `Monitor` de son hôte. Le veilleur tourne en fond, tient une attente longue sur `/api/wait`, et écrit **une
 ligne par message** sur sa sortie standard :
 
 ```
@@ -131,6 +148,13 @@ ligne par message** sur sa sortie standard :
 
 Chaque ligne réveille l'agent, qui appelle `read_message` s'il décide de traiter le message.
 
+**Réarmer à l'expiration.** Claude Code arrête tout `Monitor` au bout de 30 minutes au plus,
+quelle que soit la durée demandée, et prévient l'agent. Ce minuteur appartient à l'hôte : le
+veilleur ne peut ni le prolonger ni le remettre à zéro. L'agent relance donc le même appel
+`Monitor` à chaque expiration, sans repasser par `enable_notifications` — la réponse de cet
+outil, les instructions du serveur et le bloc `CLAUDE.md` le lui disent. Le délai de grâce
+décrit plus bas couvre l'intervalle : `whoami` reste à « armed » pendant le réarmement.
+
 **Pourquoi deux appels et pas un.** Armer un réveil, c'est ouvrir un canal vers la boucle de
 la session hôte. Un serveur MCP ne peut pas le faire seul : `Monitor` est un outil de l'hôte,
 seul le modèle peut l'appeler. `enable_notifications` fait donc tout le reste — il connaît
@@ -474,7 +498,7 @@ navigateur de l'administrateur. Les routes `/admin` acceptent toujours le jeton
 quart d'heure et par IP.
 
 La console n'envoie ni ne modifie aucun message. Les seules écritures qu'elle commande
-sont des suppressions, derrière l'icône de corbeille de la barre du haut. **Deux
+sont des suppressions, derrière l'icône de corbeille de la barre du haut. **Trois
 nettoyages y cohabitent, avec chacun son bouton, parce qu'ils ne visent pas la même
 chose :**
 
@@ -485,12 +509,16 @@ chose :**
   boîte à regrouper ;
 - **les boîtes inactives depuis une date** : elles ont servi, mais plus rien ne les a
   touchées depuis. **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.
+  session qui vient de démarrer et n'a pas encore parlé n'est pas une boîte à l'abandon ;
+- **les boîtes créées avant une date** : le critère est l'âge de la boîte, et lui seul.
+  **Une boîte ouverte avant la coupure en fait partie même si elle a parlé ce matin** —
+  c'est l'exact inverse du nettoyage précédent, et c'est le geste à passer pour remettre
+  un serveur à une date donnée plutôt que pour y faire le tri.
 
 S'y ajoute la suppression d'**une boîte en particulier** : chaque ligne de la colonne de
 gauche porte une corbeille, révélée au survol ou au clavier. Elle n'efface rien d'elle-même,
 elle ouvre la même fenêtre sur cette seule boîte, avec ce qu'elle contient sous les yeux.
-C'est la seule des trois qui ne demande aucun critère : l'adresse vient d'être montrée du
+C'est la seule des quatre qui ne demande aucun critère : l'adresse vient d'être montrée du
 doigt, il n'y a rien à revérifier.
 
 Toutes se font en deux temps, parce qu'elles ne se rattrapent pas :
@@ -526,7 +554,8 @@ Toutes les variables sont documentées dans [`.env.example`](.env.example). L'es
 | `MESSENGER_DB_PATH` | `./data/messenger.db` | Fichier SQLite |
 | `MESSENGER_TOKEN` | — | **Obligatoire** (sauf si `MESSENGER_AGENT_TOKENS`) : jeton exigé sur toute requête. `--generate-token` en produit un |
 | `MESSENGER_AGENT_TOKENS` | — | Un jeton par agent : `planner:tok-a,coder:tok-b` |
-| `MESSENGER_ADMIN_TOKEN` | `MESSENGER_TOKEN` | Jeton de la console ; obligatoire si seul `MESSENGER_AGENT_TOKENS` est défini |
+| `MESSENGER_ADMIN_TOKEN` | — | **Obligatoire**, et toujours différent de `MESSENGER_TOKEN` : jeton de la console, qui voit et supprime toutes les boîtes |
+| `MESSENGER_TRUST_PROXY` | `1` | Proxys de confiance devant le serveur (nombre de sauts, `loopback`, ou `false`). Sans lui, toutes les requêtes venues du proxy se ressemblent : le quota devient un compteur unique et le cookie perd `Secure` |
 | `MESSENGER_RATE_LIMIT_MAX` | `600` | Requêtes par IP et par fenêtre |
 | `MESSENGER_RATE_LIMIT_WINDOW_MINUTES` | `15` | Durée de la fenêtre |
 | `MESSENGER_TRASH_RETENTION_DAYS` | `30` | Purge automatique de la corbeille (`0` = jamais) |
@@ -577,8 +606,9 @@ la console (cookie), qui elle n'ouvre rien d'autre.
 | `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 |
+| `GET` | `/admin/mailboxes/created-before` | Boîtes ouvertes avant `created_before`, quelle que soit leur activité |
 | `GET` | `/admin/mailboxes/empty` | Boîtes par lesquelles rien n'est jamais passé, sans critère de date |
-| `POST` | `/admin/mailboxes/purge` | Supprime les boîtes nommées (`mailboxes`, plus `before` **ou** `empty: true`) — refusé si l'une d'elles ne répond plus au critère |
+| `POST` | `/admin/mailboxes/purge` | Supprime les boîtes nommées (`mailboxes`, plus exactement un critère : `before`, `created_before` **ou** `empty: true`) — refusé si l'une d'elles ne répond plus au critère |
 | `DELETE` | `/admin/mailboxes/:id` | Supprime une boîte désignée, quel que soit son état — 404 si l'adresse est inconnue |
 | `POST` | `/ui/login` · `/ui/logout` | Session de la console (`{ "token": … }` → cookie `HttpOnly`) |
 
@@ -606,7 +636,13 @@ la console (cookie), qui elle n'ouvre rien d'autre.
   suppriment des boîtes : réservées au jeton d'administration, confirmées deux fois, et
   revérifiées par le serveur quand elles portent sur un lot.
 - Derrière un reverse proxy TLS, exposer le serveur en `https://` et donner cette URL aux
-  agents via `MESSENGER_SERVER_URL`.
+  agents via `MESSENGER_SERVER_URL`. Renseigner `MESSENGER_TRUST_PROXY` (défaut `1`) : c'est
+  lui qui rend au serveur l'adresse réelle de l'appelant, donc un quota par client plutôt
+  qu'un compteur unique, et le `Secure` du cookie de console.
+- **Le jeton posé dans le bloc `env` d'un `.mcp.json` survit à ce fichier.** L'hôte enregistre
+  la configuration du serveur MCP dans ses transcriptions de session — pour Claude Code,
+  `~/.claude/projects/*.jsonl`, en clair. Le retirer du `.mcp.json` ne l'en efface pas :
+  après une fuite, il faut faire tourner le jeton, pas seulement corriger le fichier.
 
 ---
 
@@ -645,8 +681,9 @@ test/                   # store, config, API HTTP, outils MCP, binaire réel
 
 ### Tests
 
-287 tests couvrant : les suppressions de boîtes commandées depuis la console — une boîte
-désignée à la main, les vides, celles sans activité depuis une date — avec leur aperçu,
+309 tests couvrant : les suppressions de boîtes commandées depuis la console — une boîte
+désignée à la main, les vides, celles sans activité depuis une date, celles créées avant
+une date — avec leur aperçu,
 leur double confirmation et le refus nominatif d'une boîte qui ne répond plus au critère, la reprise de la boîte d'une session interrompue (clé de session de
 l'hôte, boîte seulement proposée à défaut, 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`

package/dist/src/cli/setup-mcp.js

@@ -56,6 +56,10 @@ Au démarrage de la session, avant toute autre chose : appeler \`enable_notifica
 puis armer l'outil \`Monitor\` avec la commande exacte qu'il retourne. Sans cela, aucun
 message ne parviendra à l'agent — il ne l'apprendra qu'en appelant \`list_messages\`.
 
+L'hôte arrête le veilleur au bout de 30 minutes au plus. À chaque expiration signalée,
+le réarmer aussitôt avec le même appel \`Monitor\`, sans repasser par
+\`enable_notifications\`.
+
 Une fois le veilleur armé, ne rien attendre : les messages entrants interrompent l'agent
 d'eux-mêmes, y compris à l'arrêt. \`wait_for_message\` ne sert plus qu'à bloquer
 volontairement sur une réponse précise.
@@ -138,9 +142,15 @@ export function runSetupMcp({ cwd, force }) {
         console.log(`  ${name.padEnd(28)} ${description}`);
     }
     console.log("");
-    console.log("Le serveur boîte aux lettres doit tourner à part, avec le même jeton :");
-    console.log(`  MESSENGER_TOKEN=<votre-jeton> npx -y ${PACKAGE_NAME} --server`);
-    console.log(`  console web : ${DEFAULT_SERVER_URL}/ui/ (le jeton y est demandé une fois)`);
+    console.log("Le serveur boîte aux lettres doit tourner à part, avec le même jeton client");
+    console.log("et un second jeton, réservé à la console — les deux doivent différer :");
+    console.log(`  npx -y ${PACKAGE_NAME} --generate-token   (une fois par jeton)`);
+    console.log(`  MESSENGER_TOKEN=<jeton-client> MESSENGER_ADMIN_TOKEN=<jeton-console> \\`);
+    console.log(`    npx -y ${PACKAGE_NAME} --server`);
+    console.log(`  console web : ${DEFAULT_SERVER_URL}/ui/ (le jeton console y est demandé une fois)`);
+    console.log("");
+    console.log("Le jeton client va dans le .mcp.json ci-dessus ; le jeton console n'y va jamais.");
+    console.log("Il ouvre toutes les boîtes de tous les projets et permet de les supprimer.");
     console.log("");
     console.log("Chaque session d'agent reçoit sa propre boîte : demandez son adresse à l'agent");
     console.log("(outil whoami) pour la transmettre à un autre agent, ou pour la reprendre plus tard.");

package/dist/src/config.d.ts

@@ -12,8 +12,17 @@ export interface ServerConfig {
     token: string | null;
     /** Jeton dédié par agent : `agent_id -> token`. Prioritaire sur `token`. */
     agentTokens: Map<string, string>;
-    /** Jeton de l'interface de supervision. À défaut, `token` fait office. Jamais nul. */
+    /** Jeton de l'interface de supervision. Toujours distinct de `token`, et exigé. */
     adminToken: string;
+    /**
+     * Valeur passée à `trust proxy` d'Express. Le serveur n'écoute qu'en loopback et se
+     * déploie donc derrière un reverse proxy : sans ce réglage, `req.ip` vaut `127.0.0.1`
+     * pour tout le monde — le quota devient un compteur unique partagé par tous les clients,
+     * et `req.secure` reste faux même en HTTPS.
+     *
+     * `1` par défaut : un seul proxy devant, le cas documenté. `0` désactive.
+     */
+    trustProxy: number | string | boolean;
     rateLimit: {
         max: number;
         windowMs: number;

package/dist/src/config.js

@@ -53,9 +53,20 @@ export function loadServerConfig(env = process.env) {
     if (!token && agentTokens.size === 0) {
         throw new ConfigError("a token is required: set MESSENGER_TOKEN (shared) or MESSENGER_AGENT_TOKENS (one token per agent).");
     }
-    const adminToken = nonEmpty(env.MESSENGER_ADMIN_TOKEN) ?? token;
+    // Jamais de repli sur `token` : la console d'administration voit toutes les boîtes de
+    // tous les projets et sait les supprimer, alors que le jeton partagé est distribué à
+    // chaque client MCP. Les faire coïncider donnerait ce pouvoir à tout porteur du jeton —
+    // en silence, et précisément dans la configuration la plus courante.
+    const adminToken = nonEmpty(env.MESSENGER_ADMIN_TOKEN);
     if (!adminToken) {
-        throw new ConfigError("MESSENGER_ADMIN_TOKEN is required when only MESSENGER_AGENT_TOKENS is set: the web console needs its own token.");
+        throw new ConfigError("MESSENGER_ADMIN_TOKEN is required: the web console sees every mailbox and can delete them, " +
+            "so it never shares the token handed to MCP clients. " +
+            "Generate one with `npx @imenam/mcp-messenger --generate-token`.");
+    }
+    // Le poser à la même valeur à la main rouvrirait exactement la porte que l'on ferme.
+    if (token && adminToken === token) {
+        throw new ConfigError("MESSENGER_ADMIN_TOKEN must differ from MESSENGER_TOKEN: the shared token is distributed to " +
+            "every MCP client, and the admin token opens the whole console.");
     }
     return {
         port,
@@ -64,6 +75,7 @@ export function loadServerConfig(env = process.env) {
         token,
         agentTokens,
         adminToken,
+        trustProxy: parseTrustProxy(env.MESSENGER_TRUST_PROXY),
         rateLimit: {
             max: parseIntEnv(env.MESSENGER_RATE_LIMIT_MAX, 600, "MESSENGER_RATE_LIMIT_MAX"),
             windowMs: parseIntEnv(env.MESSENGER_RATE_LIMIT_WINDOW_MINUTES, 15, "MESSENGER_RATE_LIMIT_WINDOW_MINUTES") * 60_000,
@@ -121,6 +133,25 @@ function parseAgentTokens(raw) {
     }
     return map;
 }
+/**
+ * Nombre de proxys de confiance devant le serveur, ou une expression qu'Express comprend
+ * (`loopback`, une liste d'adresses...). Défaut `1` : le déploiement documenté met un
+ * reverse proxy devant, et c'est lui qui pose `X-Forwarded-For` / `X-Forwarded-Proto`.
+ */
+function parseTrustProxy(raw) {
+    const value = nonEmpty(raw);
+    if (value === null)
+        return 1;
+    if (value === "false")
+        return false;
+    if (value === "true")
+        return true;
+    // Un nombre est un nombre de sauts : Express ne retient alors que l'adresse posée par le
+    // proxy le plus proche, celle qu'un client ne peut pas forger.
+    if (/^\d+$/.test(value))
+        return Number(value);
+    return value;
+}
 function nonEmpty(value) {
     const trimmed = value?.trim();
     return trimmed ? trimmed : null;

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

@@ -98,6 +98,17 @@ export declare class MessageStore extends EventEmitter<StoreEvents> {
     staleMailboxes(before: string): (AgentDirectoryEntry & {
         messages: number;
     })[];
+    /**
+     * Boîtes ouvertes avant `before`, quoi qu'elles aient fait depuis.
+     *
+     * L'âge se lit ici sur la seule date de création : une boîte née avant la coupure en
+     * fait partie même si elle a parlé ce matin. C'est l'inverse de `staleMailboxes`, qui
+     * épargne tout ce qui bouge encore — les deux critères se ressemblent, et c'est la
+     * raison pour laquelle ils sont deux.
+     */
+    mailboxesCreatedBefore(before: string): (AgentDirectoryEntry & {
+        messages: number;
+    })[];
     /**
      * Boîtes par lesquelles rien n'est jamais passé, ni envoi ni réception.
      *

package/dist/src/core/store.js

@@ -603,6 +603,28 @@ export class MessageStore extends EventEmitter {
             last_activity_at: row.last_activity_at || null,
         }));
     }
+    /**
+     * Boîtes ouvertes avant `before`, quoi qu'elles aient fait depuis.
+     *
+     * L'âge se lit ici sur la seule date de création : une boîte née avant la coupure en
+     * fait partie même si elle a parlé ce matin. C'est l'inverse de `staleMailboxes`, qui
+     * épargne tout ce qui bouge encore — les deux critères se ressemblent, et c'est la
+     * raison pour laquelle ils sont deux.
+     */
+    mailboxesCreatedBefore(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 a.created_at < ?
+          ORDER BY a.created_at ASC`)
+            .all(before);
+        return rows.map((row) => ({
+            ...row,
+            registered: Boolean(row.registered),
+            last_activity_at: row.last_activity_at || null,
+        }));
+    }
     /**
      * Boîtes par lesquelles rien n'est jamais passé, ni envoi ni réception.
      *

package/dist/src/mcp/start.js

@@ -39,7 +39,8 @@ Resuming earlier work:
 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.
-- Call \`enable_notifications\` once at the start of the session and arm the watcher it hands you. Until then, no incoming message reaches you.`;
+- Call \`enable_notifications\` once at the start of the session and arm the watcher it hands you. Until then, no incoming message reaches you.
+- The host stops that watcher after 30 minutes at most. Each time it tells you the watcher expired, re-arm it at once with the same Monitor call; otherwise notifications stop for good.`;
 /** Serveur MCP prêt à être branché sur n'importe quel transport (stdio en production, mémoire en test). */
 export function createMcpServer(client) {
     const server = new Server({ name: "mcp-messenger", version: APP_VERSION }, { capabilities: { tools: {} }, instructions: INSTRUCTIONS });

package/dist/src/mcp/tools.js

@@ -5,6 +5,8 @@ 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";
+/** Durée maximale d'un `Monitor` côté hôte : au-delà, l'hôte la ramène à cette valeur. */
+const MONITOR_TIMEOUT_MS = 1_800_000;
 const FOLDER_HINT = `Folder name. System folders: ${SYSTEM_FOLDERS.join(", ")}. Custom folders come from list_folders.`;
 export const TOOLS = [
     {
@@ -217,7 +219,7 @@ export const TOOLS = [
     },
     {
         name: "enable_notifications",
-        description: "Get notified of incoming messages without waiting for them. Returns immediately: it blocks nothing and starts nothing on its own. It hands you the exact Monitor call to make right after — arming that watcher is what actually delivers notifications, and until you do it no message will reach you. Call this once at the start of a session, before any other work; then just keep working, incoming messages will interrupt you on their own.",
+        description: "Get notified of incoming messages without waiting for them. Returns immediately: it blocks nothing and starts nothing on its own. It hands you the exact Monitor call to make right after — arming that watcher is what actually delivers notifications, and until you do it no message will reach you. Call this once at the start of a session, before any other work; then just keep working, incoming messages will interrupt you on their own. The host stops the watcher after 30 minutes at most: re-arm it with the same Monitor call each time it expires.",
         inputSchema: { type: "object", properties: {}, additionalProperties: false },
     },
     {
@@ -522,6 +524,9 @@ export async function callTool(client, name, rawArgs) {
                     `Notifications are already live on mailbox \`${mailbox}\` (watcher armed since ${stats.watcher.since}).`,
                     "Nothing to do: keep working, incoming messages will interrupt you on their own.",
                     "Do not arm a second watcher — you would get every message twice.",
+                    "Only exception: if the host just told you your watcher expired or stopped, re-arm it",
+                    `with the same Monitor call (command \`npx -y ${PACKAGE_NAME} --watch ${mailbox}\`,`,
+                    `timeout_ms ${MONITOR_TIMEOUT_MS}).`,
                 ].join("\n");
             }
             const lines = [
@@ -530,11 +535,15 @@ export async function callTool(client, name, rawArgs) {
                 "Last step — call the Monitor tool now, with exactly these arguments:",
                 `  command:     npx -y ${PACKAGE_NAME} --watch ${mailbox}`,
                 "  description: Incoming messenger messages",
-                "  persistent:  true",
+                `  timeout_ms:  ${MONITOR_TIMEOUT_MS}`,
                 "",
                 "Until that watcher is armed, nothing will reach you: no message will be announced.",
                 "Once it is, keep working normally — each incoming message shows up on its own, even",
                 "while you are idle. One line per message; read it with read_message.",
+                "",
+                "The host stops every monitor after 30 minutes at most. Each time it tells you this",
+                "watcher expired, call Monitor again right away with the same arguments — do not call",
+                "enable_notifications again. Skip that and notifications stop for good.",
             ];
             if (client.isAttachedElsewhere) {
                 lines.push("", `Note: you are attached to \`${mailbox}\`, not to this session's own mailbox ` +

package/dist/src/server/app.js

@@ -102,21 +102,24 @@ const isoDate = z
     .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 createdBeforeSchema = z.object({ created_before: isoDate });
 /**
  * Une suppression désigne ses boîtes, et rappelle à quel titre elles sont supprimables :
- * `before`, elles n'ont plus d'activité depuis cette date ; `empty`, rien n'y est jamais
- * passé. Les deux critères s'excluent — le serveur revérifie celui qu'on lui donne, il
- * doit donc savoir lequel c'est.
+ * `before`, elles n'ont plus d'activité depuis cette date ; `created_before`, elles ont
+ * été ouvertes avant cette date ; `empty`, rien n'y est jamais passé. Les trois critères
+ * s'excluent — le serveur revérifie celui qu'on lui donne, il doit donc savoir lequel
+ * c'est, et les deux critères datés ne désignent pas les mêmes boîtes.
  */
 const purgeSchema = z
     .object({
     before: isoDate.optional(),
+    created_before: isoDate.optional(),
     empty: z.literal(true).optional(),
     /** 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),
 })
-    .refine((input) => (input.before === undefined) !== (input.empty === undefined), {
-    message: "provide either `before` (inactive since that date) or `empty: true`, not both",
+    .refine((input) => [input.before, input.created_before, input.empty].filter((value) => value !== undefined).length === 1, {
+    message: "provide exactly one of `before` (inactive since that date), `created_before` (created before that date) or `empty: true`",
 });
 const adminListSchema = z.object({
     search: z.string().trim().min(1).optional(),
@@ -130,7 +133,10 @@ export function createApp({ store, config }) {
     // Présence des veilleurs : état de connexion, donc en mémoire du processus.
     const watchers = new WatcherRegistry();
     app.disable("x-powered-by");
-    app.set("trust proxy", false);
+    // Le serveur n'écoute qu'en loopback : ce qui l'atteint de l'extérieur passe par un
+    // reverse proxy. Sans ce réglage, toutes les requêtes se présentent comme `127.0.0.1`
+    // et le quota par adresse n'en distingue aucune.
+    app.set("trust proxy", config.trustProxy);
     app.use(helmet({
         contentSecurityPolicy: {
             directives: {
@@ -160,7 +166,9 @@ export function createApp({ store, config }) {
     const cookieOptions = (req) => ({
         httpOnly: true,
         sameSite: "strict",
-        // `req.secure` n'est vrai derrière un proxy TLS que si `trust proxy` est configuré.
+        // Vrai dès que le proxy annonce `X-Forwarded-Proto: https`, ce que `trust proxy` (posé
+        // plus haut depuis la configuration) autorise Express à lire. Reste faux en clair sur
+        // la machine, où le cookie doit justement circuler.
         secure: req.secure,
         path: "/",
     });
@@ -236,6 +244,16 @@ export function createApp({ store, config }) {
         const { before } = staleSchema.parse(req.query);
         res.json({ before, mailboxes: store.staleMailboxes(before) });
     });
+    /**
+     * Boîtes ouvertes avant une date : ce que la purge par ancienneté emporterait.
+     *
+     * Même aperçu obligatoire que les autres nettoyages, mais un critère différent — ici
+     * l'activité ne protège rien, seule compte la date d'ouverture de la boîte.
+     */
+    admin.get("/mailboxes/created-before", (req, res) => {
+        const { created_before: createdBefore } = createdBeforeSchema.parse(req.query);
+        res.json({ created_before: createdBefore, mailboxes: store.mailboxesCreatedBefore(createdBefore) });
+    });
     /**
      * Boîtes par lesquelles rien n'est jamais passé. Sans date : une boîte vide l'est
      * indépendamment de son âge, et un agent dont toutes les boîtes sont vides disparaît
@@ -254,15 +272,29 @@ export function createApp({ store, config }) {
      */
     admin.post("/mailboxes/purge", (req, res) => {
         const input = purgeSchema.parse(req.body ?? {});
-        const reason = input.empty ? "empty" : `inactive since ${input.before}`;
-        const eligible = new Set((input.empty ? store.emptyMailboxes() : store.staleMailboxes(input.before)).map((mailbox) => mailbox.id));
+        const reason = input.empty
+            ? "empty"
+            : input.created_before
+                ? `older than ${input.created_before}`
+                : `inactive since ${input.before}`;
+        const candidates = input.empty
+            ? store.emptyMailboxes()
+            : input.created_before
+                ? store.mailboxesCreatedBefore(input.created_before)
+                : store.staleMailboxes(input.before);
+        const eligible = new Set(candidates.map((mailbox) => mailbox.id));
         const changed = input.mailboxes.filter((id) => !eligible.has(id));
         if (changed.length > 0) {
             throw new MessengerError(`these mailboxes are no longer ${reason}, nothing was deleted: ${changed.join(", ")}`, 409);
         }
         const removed = store.deleteMailboxes(input.mailboxes);
         logger.warn(`admin purge: ${removed.mailboxes} mailbox(es) deleted, ${reason}`);
-        res.json({ before: input.before ?? null, empty: input.empty ?? false, ...removed });
+        res.json({
+            before: input.before ?? null,
+            created_before: input.created_before ?? null,
+            empty: input.empty ?? false,
+            ...removed,
+        });
     });
     /**
      * Suppression d'une boîte désignée à la main, quel que soit son état.
@@ -502,6 +534,10 @@ function authenticateAgent(config) {
                 res.status(401).json({ error: "invalid or missing bearer token" });
                 return;
             }
+            // Le jeton partagé atteste l'appartenance à la flotte, pas une adresse : `X-Agent-Id`
+            // n'est adossé à rien ici, et rien ne cloisonne les boîtes entre elles. C'est le mode
+            // « cercle de confiance », annoncé comme tel au démarrage et dans le README ;
+            // MESSENGER_AGENT_TOKENS est ce qui lie une adresse à un jeton.
         }
         req.agentId = agentId;
         next();

package/dist/src/server/start.js

@@ -43,6 +43,13 @@ export async function runServerMode() {
     logger.info(`mcp-messenger v${APP_VERSION} listening on ${running.url} (loopback only)`);
     logger.info(`database: ${config.dbPath}`);
     logger.info(`auth: ${authMode} — required on every request`);
+    // Le jeton partagé prouve qu'on fait partie de la flotte, pas qu'on est telle boîte :
+    // `X-Agent-Id` n'est alors adossé à rien. Le dire ici, sinon la ligne au-dessus se lit
+    // comme une garantie de cloisonnement qu'elle ne donne pas.
+    if (config.agentTokens.size === 0) {
+        logger.warn("shared token: no isolation between mailboxes — any holder can act as any address");
+        logger.warn("set MESSENGER_AGENT_TOKENS (one token per agent) to compartmentalize");
+    }
     logger.info(`web console: ${running.url}/ui/ (asks for MESSENGER_ADMIN_TOKEN once)`);
     let shuttingDown = false;
     const shutdown = (signal) => {

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

@@ -101,7 +101,9 @@ const el = {
   purgeClose: document.getElementById("purge-close"),
   purgeCancel: document.getElementById("purge-cancel"),
   purgeBefore: document.getElementById("purge-before"),
+  purgeCreatedBefore: document.getElementById("purge-created-before"),
   purgePreview: document.getElementById("purge-preview"),
+  purgePreviewCreated: document.getElementById("purge-preview-created"),
   purgePreviewEmpty: document.getElementById("purge-preview-empty"),
   purgeResult: document.getElementById("purge-result"),
   purgeConfirm: document.getElementById("purge-confirm"),
@@ -1303,8 +1305,11 @@ const purge = { mode: null, before: null, mailboxes: [], selected: new Set(), ar
 
 function openPurge() {
   const month = new Date(Date.now() - 30 * 86_400_000);
+  const today = new Date().toISOString().slice(0, 10);
   el.purgeBefore.value = month.toISOString().slice(0, 10);
-  el.purgeBefore.max = new Date().toISOString().slice(0, 10);
+  el.purgeBefore.max = today;
+  el.purgeCreatedBefore.value = month.toISOString().slice(0, 10);
+  el.purgeCreatedBefore.max = today;
   resetPurge();
   el.purge.showModal();
 }
@@ -1356,6 +1361,13 @@ async function previewStale() {
   await previewPurge("stale", () => api("/admin/mailboxes/stale", { before }), before);
 }
 
+/** Boîtes ouvertes avant la date choisie, qu'elles servent encore ou non. */
+async function previewCreated() {
+  const before = el.purgeCreatedBefore.value;
+  if (!before) return;
+  await previewPurge("created", () => api("/admin/mailboxes/created-before", { created_before: before }), before);
+}
+
 async function previewPurge(mode, load, before = null) {
   resetPurge();
   try {
@@ -1373,10 +1385,15 @@ async function previewPurge(mode, load, before = null) {
 function renderPurgePreview() {
   const container = document.createDocumentFragment();
   const count = purge.mailboxes.length;
-  // Le critère est rappelé sous les yeux de qui va confirmer : les trois suppressions
-  // remplissent la même liste, et elles ne portent pas sur les mêmes boîtes.
-  const since = ` sans activité depuis le ${formatDay(purge.before)}`;
-  const criterion = purge.mode === "empty" ? "vide" : purge.mode === "one" ? "" : since;
+  // Le critère est rappelé sous les yeux de qui va confirmer : les quatre suppressions
+  // remplissent la même liste, et elles ne portent pas sur les mêmes boîtes. Les deux
+  // critères datés se distinguent par leur seule formulation : « depuis » regarde
+  // l'activité, « créée avant » regarde l'ouverture de la boîte.
+  const dated =
+    purge.mode === "created"
+      ? ` créée avant le ${formatDay(purge.before)}`
+      : ` sans activité depuis le ${formatDay(purge.before)}`;
+  const criterion = purge.mode === "empty" ? "vide" : purge.mode === "one" ? "" : dated;
 
   if (count === 0) {
     container.appendChild(node("p", "purge-empty", `Aucune boîte ${criterion.trim()}.`));
@@ -1392,7 +1409,9 @@ function renderPurgePreview() {
         ? "Cette boîte, et tout ce que personne d'autre ne pourrait plus lire :"
         : purge.mode === "empty"
           ? `${plural(count, "boîte vide", "boîtes vides")}.`
-          : `${plural(count, "boîte")}${since}.`
+          : purge.mode === "created"
+            ? `${plural(count, "boîte créée", "boîtes créées")} avant le ${formatDay(purge.before)}.`
+            : `${plural(count, "boîte")}${dated}.`
     )
   );
 
@@ -1457,7 +1476,11 @@ async function confirmPurge() {
         ? await remove(`/admin/mailboxes/${encodeURIComponent(deleted[0])}`)
         : await post("/admin/mailboxes/purge", {
             // Le critère repart avec les adresses : c'est lui que le serveur revérifie.
-            ...(purge.mode === "empty" ? { empty: true } : { before: purge.before }),
+            ...(purge.mode === "empty"
+              ? { empty: true }
+              : purge.mode === "created"
+                ? { created_before: purge.before }
+                : { before: purge.before }),
             mailboxes: deleted,
           });
     resetPurge();
@@ -1488,7 +1511,9 @@ 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.purgeCreatedBefore.addEventListener("change", resetPurge);
 el.purgePreview.addEventListener("click", previewStale);
+el.purgePreviewCreated.addEventListener("click", previewCreated);
 el.purgePreviewEmpty.addEventListener("click", previewEmpty);
 el.purgeConfirm.addEventListener("click", confirmPurge);
 

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

@@ -70,7 +70,7 @@
           </button>
         </div>
         <p class="modal-sub">
-          Deux nettoyages, deux critères. La suppression est définitive dans les deux cas, et emporte les messages que
+          Trois nettoyages, trois critères. La suppression est définitive dans tous les cas, et emporte les messages que
           plus personne ne pourrait lire ; ce que le correspondant a reçu de son côté reste intact. Un agent dont toutes
           les boîtes disparaissent quitte l'annuaire avec elles.
         </p>
@@ -94,6 +94,16 @@
           <button type="button" class="btn" id="purge-preview">Prévisualiser</button>
         </div>
 
+        <!-- Troisième critère : l'âge de la boîte, que son activité ne rachète pas. -->
+        <div class="purge-controls">
+          <label class="field">
+            <span class="field-label">Boîtes créées avant le</span>
+            <span class="field-input"><input type="date" id="purge-created-before" /></span>
+            <span class="purge-hint">Sur la seule date d'ouverture : une boîte encore active en fait partie.</span>
+          </label>
+          <button type="button" class="btn" id="purge-preview-created">Prévisualiser</button>
+        </div>
+
         <div class="purge-result" id="purge-result"></div>
 
         <div class="modal-foot">

package/dist/src/version.d.ts

@@ -1 +1 @@
-export declare const APP_VERSION = "1.0.27";
+export declare const APP_VERSION = "1.0.29";

package/dist/src/version.js

@@ -1,2 +1,2 @@
 // Généré par scripts/generate-version.js — ne pas modifier à la main.
-export const APP_VERSION = "1.0.27";
+export const APP_VERSION = "1.0.29";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imenam/mcp-messenger",
-  "version": "1.0.27",
+  "version": "1.0.29",
   "main": "dist/src/index.js",
   "scripts": {
     "test": "npm run build && vitest run",