@imenam/mcp-messenger 1.0.4 → 1.0.5

package/README.md

@@ -96,6 +96,7 @@ la session MCP démarre quand même et l'enregistrement se fera au premier appel
 
 L'agent A appelle `send_message` avec `to: ["coder"]`, l'agent B voit le message via
 `list_messages` puis `read_message`, et répond avec `reply_to` pour rester dans le fil.
+Le fil se nomme au passage (`thread_title` sur `send_message`, ou `set_label` plus tard).
 `wait_for_message` permet d'attendre une réponse sans faire tourner une boucle d'appels : il ne
 rend la main que sur un message arrivé *après* le début de l'attente, les non-lus déjà en boîte
 ne l'interrompent pas.
@@ -175,9 +176,10 @@ superviseur capable de lire les lignes d'un processus peut la brancher. Sans rel
 |---|---|
 | `whoami` | Adresse de cette session, serveur connecté, veilleur armé ou non, compteurs par dossier |
 | `attach_to_mailbox` | Se brancher sur une autre boîte via son adresse ; sans argument, retour à la sienne |
-| `set_mailbox_label` | Nommer sa boîte, pour la reconnaître dans l'annuaire et la console |
-| `list_agents` | Annuaire : qui est joignable, avec quelle description |
-| `send_message` | Envoyer à un ou plusieurs agents (`to`, `cc`, `priority`, `reply_to`) |
+| `set_label` | Nommer sa boîte, ou un fil (`thread_id`), en langue naturelle |
+| `list_threads` | Carte des conversations : nom, participants, non-lus, dernière activité |
+| `list_agents` | Annuaire : qui est joignable, du plus récemment actif au plus ancien |
+| `send_message` | Envoyer à un ou plusieurs agents (`to`, `cc`, `priority`, `reply_to`, `thread_title`) |
 | `list_messages` | Lister la boîte (filtres : dossier, non lus, expéditeur, fil, texte libre) |
 | `read_message` | Lire un message en entier ; le marque lu par défaut |
 | `get_thread` | Relire toute une conversation, du plus ancien au plus récent |
@@ -189,6 +191,8 @@ superviseur capable de lire les lignes d'un processus peut la brancher. Sans rel
 | `enable_notifications` | Prépare la notification passive et rend la commande `Monitor` à armer ; ne bloque rien |
 | `wait_for_message` | Attente longue (jusqu'à 300 s) jusqu'à l'arrivée d'un message *postérieur* à l'appel |
 
+**Noms lisibles** — voir « Nommer les boîtes et les fils » ci-dessous.
+
 **Dossiers système** — toujours présents, non supprimables : `inbox`, `sent`, `archive`,
 `trash`. Les dossiers personnalisés sont propres à chaque boîte.
 
@@ -216,9 +220,35 @@ ont deux boîtes distinctes et ne se volent pas leur courrier.
 2. Transmets-la à l'agent B, qui l'utilise dans `send_message`.
 
 Comme les adresses sont opaques, demande aux agents de nommer leur boîte
-(`set_mailbox_label`) : le libellé apparaît dans `list_agents` et dans la console web, ce
+(`set_label`) : le libellé apparaît dans `list_agents` et dans la console web, ce
 qui permet de retrouver une adresse perdue.
 
+### Nommer les boîtes et les fils
+
+Les identifiants (`box_…`, `thr_…`) ne disent rien de ce qui se passe. Deux noms en langue
+naturelle viennent par-dessus, et un seul outil les pose :
+
+```
+set_label(label: "Développement des tests unitaires du parser")
+    → nomme la boîte de la session
+
+set_label(thread_id: "thr_…", label: "Le test échoue sur un bug applicatif")
+    → nomme le fil
+```
+
+Le plus simple reste de nommer un fil au moment où on l'ouvre, via `thread_title` sur
+`send_message` : l'agent qui écrit le premier message sait déjà de quoi il parle.
+
+Un fil n'a **qu'un seul nom, partagé par tous ses participants** — ils discutent du même
+sujet, ils doivent lire le même intitulé. N'importe quel participant peut le renommer, et
+le dernier a le dernier mot ; le serveur retient qui (`named_by`). Un agent extérieur au
+fil ne peut pas le renommer.
+
+Tant qu'un fil n'a pas été nommé, l'affichage retombe sur le sujet de son message
+d'ouverture : rien n'est jamais illisible, mais rien n'est aussi parlant qu'un nom choisi.
+Ces noms apparaissent dans `list_threads`, `list_messages`, `get_thread`, les
+notifications du veilleur et la console web.
+
 ### Reprendre le travail d'une session terminée
 
 Les boîtes survivent aux sessions. Après un redémarrage :
@@ -319,7 +349,9 @@ cet agent lorsque `MESSENGER_AGENT_TOKENS` est utilisé.
 | `POST` | `/api/messages/mark` | Marquer lu / suivi |
 | `POST` | `/api/messages/move` | Déplacer vers un dossier |
 | `POST` | `/api/messages/delete` | Corbeille ou suppression définitive |
-| `GET` | `/api/threads/:id` | Fil complet |
+| `GET` | `/api/threads` | Fils de la boîte (`unread_only`, `search`, `limit`, `offset`) |
+| `GET` | `/api/threads/:id` | Fil complet, avec son intitulé |
+| `PATCH` | `/api/threads/:id` | Nommer le fil (`title`, `description`) — participants uniquement |
 | `GET` `POST` `DELETE` | `/api/folders[/:name]` | Gérer les dossiers |
 | `GET` | `/api/wait` | Attente longue (`timeout_seconds`, `folder`, `watcher`) |
 | `GET` | `/admin/overview` · `/admin/messages[/:id]` · `/admin/threads/:id` | Supervision, lecture seule |

package/dist/src/cli/watch.js

@@ -54,7 +54,9 @@ export function resolveWatchConfig(mailbox, env = process.env) {
 export function formatEvent(message) {
     const subject = message.subject.replace(/\s+/g, " ").trim();
     const flag = message.priority === "high" ? "[high] " : "";
-    return `[messenger] ${flag}${message.from} — ${subject} (${message.message_id})`;
+    // Le nom du fil situe le message d'un coup d'œil : c'est tout ce que la notification montre.
+    const thread = message.thread_title ? ` · ${message.thread_title.replace(/\s+/g, " ").trim()}` : "";
+    return `[messenger] ${flag}${message.from} — ${subject}${thread} (${message.message_id})`;
 }
 export async function runWatchMode(mailbox) {
     const { config, mailbox: target, source } = resolveWatchConfig(mailbox);

package/dist/src/client/messenger-client.d.ts

@@ -1,5 +1,5 @@
 import type { AgentConfig } from "../config.js";
-import type { Agent, FolderInfo, ListMessagesOptions, MailboxStats, Message, MessageSummary, Priority, SendMessageResult } from "../core/types.js";
+import type { Agent, AgentDirectoryEntry, FolderInfo, ListMessagesOptions, MailboxStats, Message, MessageSummary, Priority, SendMessageResult, ThreadInfo, ThreadSummary } from "../core/types.js";
 /** Échec d'un appel au serveur boîte aux lettres (réseau, authentification ou métier). */
 export declare class MessengerClientError extends Error {
     readonly status?: number | undefined;
@@ -58,7 +58,7 @@ export declare class MessengerClient {
         description?: string | null;
     }): Promise<Agent>;
     getAgent(agentId: string): Promise<Agent>;
-    listAgents(): Promise<Agent[]>;
+    listAgents(): Promise<AgentDirectoryEntry[]>;
     stats(): Promise<MailboxStats>;
     sendMessage(input: {
         to: string[];
@@ -67,6 +67,8 @@ export declare class MessengerClient {
         body: string;
         priority?: Priority;
         reply_to?: string | null;
+        thread_title?: string | null;
+        thread_description?: string | null;
     }): Promise<SendMessageResult>;
     listMessages(options?: ListMessagesOptions): Promise<MessageSummary[]>;
     getMessage(messageId: string, markRead?: boolean): Promise<Message>;
@@ -76,7 +78,20 @@ export declare class MessengerClient {
     }): Promise<number>;
     moveMessages(messageIds: string[], folder: string): Promise<number>;
     deleteMessages(messageIds: string[], permanent?: boolean): Promise<number>;
-    getThread(threadId: string): Promise<Message[]>;
+    getThread(threadId: string): Promise<{
+        thread: ThreadInfo | null;
+        messages: Message[];
+    }>;
+    listThreads(options?: {
+        unread_only?: boolean;
+        search?: string;
+        limit?: number;
+    }): Promise<ThreadSummary[]>;
+    /** Renomme un fil. Le titre est partagé : il change pour tous ses participants. */
+    setThreadLabel(threadId: string, label: {
+        title?: string | null;
+        description?: string | null;
+    }): Promise<ThreadInfo>;
     listFolders(): Promise<FolderInfo[]>;
     createFolder(name: string): Promise<FolderInfo>;
     deleteFolder(name: string): Promise<number>;

package/dist/src/client/messenger-client.js

@@ -124,8 +124,16 @@ export class MessengerClient {
         return deleted;
     }
     async getThread(threadId) {
-        const { messages } = await this.request("GET", `/api/threads/${encodeURIComponent(threadId)}`);
-        return messages;
+        return this.request("GET", `/api/threads/${encodeURIComponent(threadId)}`);
+    }
+    async listThreads(options = {}) {
+        const { threads } = await this.request("GET", "/api/threads", { query: options });
+        return threads;
+    }
+    /** Renomme un fil. Le titre est partagé : il change pour tous ses participants. */
+    async setThreadLabel(threadId, label) {
+        const { thread } = await this.request("PATCH", `/api/threads/${encodeURIComponent(threadId)}`, { body: label });
+        return thread;
     }
     async listFolders() {
         const { folders } = await this.request("GET", "/api/folders");

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

@@ -1,5 +1,5 @@
 import { EventEmitter } from "node:events";
-import { type Agent, type DeliveryRole, type FolderInfo, type ListMessagesOptions, type MailboxStats, type Message, type MessageSummary, type SendMessageInput, type SendMessageResult } from "./types.js";
+import { type Agent, type AgentDirectoryEntry, type DeliveryRole, type FolderInfo, type ListMessagesOptions, type ListThreadsOptions, type MailboxStats, type Message, type MessageSummary, type SendMessageInput, type SendMessageResult, type ThreadInfo, type ThreadSummary } from "./types.js";
 /** Erreur métier : traduite en 4xx par la couche HTTP, en message d'outil côté MCP. */
 export declare class MessengerError extends Error {
     readonly status: number;
@@ -34,12 +34,31 @@ export declare class MessageStore extends EventEmitter<StoreEvents> {
     }): Agent;
     touchAgent(id: string): void;
     getAgent(id: string): Agent | null;
-    listAgents(): Agent[];
+    /** Annuaire classé par activité décroissante : ce qui bouge est en tête, l'id ne trie rien. */
+    listAgents(): AgentDirectoryEntry[];
     sendMessage(input: SendMessageInput): SendMessageResult;
     listMessages(agentId: string, opts?: ListMessagesOptions): MessageSummary[];
     getMessage(agentId: string, messageId: string, markRead?: boolean): Message;
     /** Tous les messages d'un fil visibles par l'agent, du plus ancien au plus récent. */
     getThread(agentId: string, threadId: string): Message[];
+    getThreadInfo(threadId: string): ThreadInfo | null;
+    /**
+     * Renomme un fil. Le titre est unique et partagé : les participants parlent du même
+     * sujet, ils lisent donc le même nom. Le dernier appelant a le dernier mot, et
+     * `named_by` retient qui c'était.
+     *
+     * Seul un participant peut renommer : le fil n'est pas nommable depuis l'extérieur.
+     */
+    setThreadLabel(agentId: string, threadId: string, label: {
+        title?: string | null;
+        description?: string | null;
+    }): ThreadInfo;
+    /** Fils visibles depuis cette boîte, le plus récemment actif en tête. */
+    listThreads(agentId: string, opts?: ListThreadsOptions): ThreadSummary[];
+    /** Écriture brute du nom : un champ absent (`null`) laisse l'ancienne valeur en place. */
+    private renameThreadRow;
+    private assertThreadVisible;
+    private participantsFor;
     markMessages(agentId: string, messageIds: string[], state: {
         read?: boolean;
         starred?: boolean;
@@ -74,7 +93,7 @@ export declare class MessageStore extends EventEmitter<StoreEvents> {
     overview(): {
         messages: number;
         threads: number;
-        agents: (Agent & {
+        agents: (AgentDirectoryEntry & {
             sent: number;
             received: number;
             unread: number;

package/dist/src/core/store.js

@@ -16,6 +16,19 @@ export class MessengerError extends Error {
 const PREVIEW_LENGTH = 160;
 const MAX_LIMIT = 100;
 const FOLDER_NAME_RE = /^[a-z0-9][a-z0-9 _-]{0,39}$/;
+const THREAD_TITLE_MAX = 200;
+const THREAD_DESCRIPTION_MAX = 2000;
+/**
+ * Dernière activité d'une boîte : sa dernière connexion, ou le dernier message qui l'a
+ * touchée. Une boîte qui ne fait que recevoir reste vivante, alors que `last_seen_at`
+ * seul la ferait paraître abandonnée.
+ */
+const LAST_ACTIVITY = `MAX(
+  COALESCE(a.last_seen_at, ''),
+  COALESCE((SELECT MAX(d.created_at) FROM deliveries d WHERE d.agent_id = a.id), '')
+)`;
+/** Colonnes du fil jointes à tout message : le titre voyage avec chaque livraison. */
+const THREAD_JOIN = "LEFT JOIN threads t ON t.id = m.thread_id";
 /**
  * Boîte aux lettres persistée en SQLite.
  *
@@ -70,6 +83,15 @@ export class MessageStore extends EventEmitter {
         UNIQUE (message_id, agent_id, role)
       );
 
+      CREATE TABLE IF NOT EXISTS threads (
+        id          TEXT PRIMARY KEY,
+        title       TEXT,
+        description TEXT,
+        named_by    TEXT,
+        created_at  TEXT NOT NULL,
+        updated_at  TEXT
+      );
+
       CREATE TABLE IF NOT EXISTS folders (
         agent_id   TEXT NOT NULL,
         name       TEXT NOT NULL,
@@ -80,6 +102,15 @@ export class MessageStore extends EventEmitter {
       CREATE INDEX IF NOT EXISTS idx_deliveries_mailbox ON deliveries (agent_id, folder, created_at DESC);
       CREATE INDEX IF NOT EXISTS idx_deliveries_message ON deliveries (message_id);
       CREATE INDEX IF NOT EXISTS idx_messages_thread ON messages (thread_id, created_at);
+    `);
+        // Bases antérieures aux fils nommés : chaque fil déjà présent reçoit sa ligne, sans
+        // titre. L'affichage retombe alors sur le sujet d'ouverture, comme avant.
+        this.db.exec(`
+      INSERT INTO threads (id, title, description, named_by, created_at, updated_at)
+      SELECT m.thread_id, NULL, NULL, NULL, MIN(m.created_at), NULL
+        FROM messages m
+       WHERE NOT EXISTS (SELECT 1 FROM threads t WHERE t.id = m.thread_id)
+       GROUP BY m.thread_id;
     `);
     }
     close() {
@@ -115,9 +146,18 @@ export class MessageStore extends EventEmitter {
         const row = this.db.prepare("SELECT * FROM agents WHERE id = ?").get(id);
         return row ? { ...row, registered: Boolean(row.registered) } : null;
     }
+    /** Annuaire classé par activité décroissante : ce qui bouge est en tête, l'id ne trie rien. */
     listAgents() {
-        const rows = this.db.prepare("SELECT * FROM agents ORDER BY id").all();
-        return rows.map((r) => ({ ...r, registered: Boolean(r.registered) }));
+        const rows = this.db
+            .prepare(`SELECT a.*, ${LAST_ACTIVITY} AS last_activity_at
+           FROM agents a
+          ORDER BY last_activity_at DESC, a.id`)
+            .all();
+        return rows.map((r) => ({
+            ...r,
+            registered: Boolean(r.registered),
+            last_activity_at: r.last_activity_at || null,
+        }));
     }
     // --- Envoi --------------------------------------------------------------
     sendMessage(input) {
@@ -134,6 +174,8 @@ export class MessageStore extends EventEmitter {
         const cc = dedupe((input.cc ?? []).map(normalizeAgentId).filter(Boolean)).filter((id) => !to.includes(id));
         if (to.length === 0)
             throw new MessengerError("at least one recipient is required in `to`");
+        const title = normalizeLabel(input.thread_title, THREAD_TITLE_MAX, "thread_title");
+        const threadDescription = normalizeLabel(input.thread_description, THREAD_DESCRIPTION_MAX, "thread_description");
         let threadId;
         let inReplyTo = null;
         if (input.reply_to) {
@@ -161,6 +203,16 @@ export class MessageStore extends EventEmitter {
             this.touchAgent(from);
             for (const id of [...to, ...cc])
                 this.ensureAgent(id);
+            // Le fil naît avec son premier message ; sur une réponse, la ligne existe déjà et
+            // n'est touchée que si l'expéditeur fournit un nouveau titre.
+            this.db
+                .prepare(`INSERT INTO threads (id, title, description, named_by, created_at, updated_at)
+           VALUES (?, NULL, NULL, NULL, ?, NULL)
+           ON CONFLICT (id) DO NOTHING`)
+                .run(threadId, now);
+            if (title !== null || threadDescription !== null) {
+                this.renameThreadRow(threadId, from, title, threadDescription, now);
+            }
             this.db
                 .prepare(`INSERT INTO messages (id, thread_id, sender_id, subject, body, priority, in_reply_to, created_at)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
@@ -177,6 +229,7 @@ export class MessageStore extends EventEmitter {
         return {
             message_id: messageId,
             thread_id: threadId,
+            thread_title: this.getThreadInfo(threadId)?.title ?? null,
             created_at: now,
             delivered_to: [...to, ...cc],
             unknown_recipients: unknownRecipients,
@@ -209,10 +262,11 @@ export class MessageStore extends EventEmitter {
             params.push(like, like);
         }
         const rows = this.db
-            .prepare(`SELECT m.id AS message_id, m.thread_id, m.sender_id, m.subject, m.body, m.priority,
-                m.in_reply_to, m.created_at, d.folder, d.role, d.read_at, d.starred
+            .prepare(`SELECT m.id AS message_id, m.thread_id, t.title AS thread_title, m.sender_id, m.subject, m.body,
+                m.priority, m.in_reply_to, m.created_at, d.folder, d.role, d.read_at, d.starred
            FROM deliveries d
            JOIN messages m ON m.id = d.message_id
+           ${THREAD_JOIN}
           WHERE ${where.join(" AND ")}
           ORDER BY m.created_at DESC, m.id DESC
           LIMIT ? OFFSET ?`)
@@ -222,10 +276,11 @@ export class MessageStore extends EventEmitter {
     }
     getMessage(agentId, messageId, markRead = false) {
         const row = this.db
-            .prepare(`SELECT m.id AS message_id, m.thread_id, m.sender_id, m.subject, m.body, m.priority,
-                m.in_reply_to, m.created_at, d.folder, d.role, d.read_at, d.starred
+            .prepare(`SELECT m.id AS message_id, m.thread_id, t.title AS thread_title, m.sender_id, m.subject, m.body,
+                m.priority, m.in_reply_to, m.created_at, d.folder, d.role, d.read_at, d.starred
            FROM deliveries d
            JOIN messages m ON m.id = d.message_id
+           ${THREAD_JOIN}
           WHERE d.agent_id = ? AND d.message_id = ?
           ORDER BY CASE d.role WHEN 'to' THEN 0 WHEN 'cc' THEN 1 ELSE 2 END
           LIMIT 1`)
@@ -245,11 +300,12 @@ export class MessageStore extends EventEmitter {
     /** Tous les messages d'un fil visibles par l'agent, du plus ancien au plus récent. */
     getThread(agentId, threadId) {
         const rows = this.db
-            .prepare(`SELECT m.id AS message_id, m.thread_id, m.sender_id, m.subject, m.body, m.priority,
-                m.in_reply_to, m.created_at,
+            .prepare(`SELECT m.id AS message_id, m.thread_id, t.title AS thread_title, m.sender_id, m.subject, m.body,
+                m.priority, m.in_reply_to, m.created_at,
                 MIN(d.folder) AS folder, MIN(d.role) AS role, MIN(d.read_at) AS read_at, MAX(d.starred) AS starred
            FROM deliveries d
            JOIN messages m ON m.id = d.message_id
+           ${THREAD_JOIN}
           WHERE d.agent_id = ? AND m.thread_id = ?
           GROUP BY m.id
           ORDER BY m.created_at ASC`)
@@ -259,6 +315,118 @@ export class MessageStore extends EventEmitter {
         const recipients = this.recipientsFor(rows.map((r) => r.message_id));
         return rows.map((row) => this.toMessage(row, recipients));
     }
+    // --- Fils ---------------------------------------------------------------
+    getThreadInfo(threadId) {
+        const row = this.db.prepare("SELECT * FROM threads WHERE id = ?").get(threadId);
+        if (!row)
+            return null;
+        const { id, ...rest } = row;
+        return { thread_id: id, ...rest };
+    }
+    /**
+     * Renomme un fil. Le titre est unique et partagé : les participants parlent du même
+     * sujet, ils lisent donc le même nom. Le dernier appelant a le dernier mot, et
+     * `named_by` retient qui c'était.
+     *
+     * Seul un participant peut renommer : le fil n'est pas nommable depuis l'extérieur.
+     */
+    setThreadLabel(agentId, threadId, label) {
+        const title = normalizeLabel(label.title, THREAD_TITLE_MAX, "title");
+        const description = normalizeLabel(label.description, THREAD_DESCRIPTION_MAX, "description");
+        if (title === null && description === null) {
+            throw new MessengerError("nothing to update: provide `title` and/or `description`");
+        }
+        this.assertThreadVisible(agentId, threadId);
+        this.renameThreadRow(threadId, agentId, title, description, new Date().toISOString());
+        return this.getThreadInfo(threadId);
+    }
+    /** Fils visibles depuis cette boîte, le plus récemment actif en tête. */
+    listThreads(agentId, opts = {}) {
+        const limit = clamp(opts.limit ?? 25, 1, MAX_LIMIT);
+        const offset = Math.max(0, opts.offset ?? 0);
+        const having = [];
+        const params = [agentId];
+        if (opts.unread_only)
+            having.push("unread > 0");
+        if (opts.search) {
+            // Le titre prime, mais un fil non nommé ne doit pas devenir introuvable :
+            // la recherche couvre aussi le sujet d'ouverture.
+            const matches = `LIKE ? ESCAPE '\\'`;
+            having.push(`(COALESCE(t.title, '') ${matches} OR COALESCE(t.description, '') ${matches} OR subject ${matches})`);
+            const like = `%${escapeLike(opts.search)}%`;
+            params.push(like, like, like);
+        }
+        const rows = this.db
+            .prepare(`SELECT m.thread_id,
+                t.title, t.description, t.named_by, t.created_at, t.updated_at,
+                (SELECT r.subject FROM messages r WHERE r.thread_id = m.thread_id
+                  ORDER BY r.created_at ASC, r.id ASC LIMIT 1) AS subject,
+                COUNT(DISTINCT m.id) AS messages,
+                COUNT(DISTINCT CASE WHEN d.read_at IS NULL AND d.role != 'sender' THEN m.id END) AS unread,
+                MAX(m.created_at) AS last_message_at
+           FROM deliveries d
+           JOIN messages m ON m.id = d.message_id
+           ${THREAD_JOIN}
+          WHERE d.agent_id = ? AND d.folder != 'trash'
+          GROUP BY m.thread_id
+          ${having.length ? `HAVING ${having.join(" AND ")}` : ""}
+          ORDER BY last_message_at DESC
+          LIMIT ? OFFSET ?`)
+            .all(...params, limit, offset);
+        const participants = this.participantsFor(rows.map((r) => r.thread_id));
+        return rows.map((row) => ({
+            thread_id: row.thread_id,
+            title: row.title,
+            description: row.description,
+            named_by: row.named_by,
+            // `created_at` du fil manque si la ligne n'a jamais été écrite : le premier
+            // message fait alors foi.
+            created_at: row.created_at ?? row.last_message_at,
+            updated_at: row.updated_at,
+            subject: row.subject,
+            messages: row.messages,
+            unread: row.unread,
+            participants: participants.get(row.thread_id) ?? [],
+            last_message_at: row.last_message_at,
+        }));
+    }
+    /** Écriture brute du nom : un champ absent (`null`) laisse l'ancienne valeur en place. */
+    renameThreadRow(threadId, agentId, title, description, now) {
+        this.db
+            .prepare(`INSERT INTO threads (id, title, description, named_by, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?)
+         ON CONFLICT (id) DO UPDATE SET
+           title       = COALESCE(excluded.title, threads.title),
+           description = COALESCE(excluded.description, threads.description),
+           named_by    = excluded.named_by,
+           updated_at  = excluded.updated_at`)
+            .run(threadId, title, description, agentId, now, now);
+    }
+    assertThreadVisible(agentId, threadId) {
+        const row = this.db
+            .prepare(`SELECT 1 FROM deliveries d JOIN messages m ON m.id = d.message_id
+          WHERE d.agent_id = ? AND m.thread_id = ? LIMIT 1`)
+            .get(agentId, threadId);
+        if (!row)
+            throw new MessengerError(`thread not found in this mailbox: ${threadId}`, 404);
+    }
+    participantsFor(threadIds) {
+        const map = new Map();
+        const ids = dedupe(threadIds);
+        if (ids.length === 0)
+            return map;
+        const placeholders = ids.map(() => "?").join(",");
+        const rows = this.db
+            .prepare(`SELECT DISTINCT m.thread_id, d.agent_id
+           FROM deliveries d JOIN messages m ON m.id = d.message_id
+          WHERE m.thread_id IN (${placeholders})
+          ORDER BY d.agent_id`)
+            .all(...ids);
+        for (const row of rows) {
+            map.set(row.thread_id, [...(map.get(row.thread_id) ?? []), row.agent_id]);
+        }
+        return map;
+    }
     // --- Organisation -------------------------------------------------------
     markMessages(agentId, messageIds, state) {
         if (state.read === undefined && state.starred === undefined) {
@@ -380,9 +548,10 @@ export class MessageStore extends EventEmitter {
             params.push(opts.thread_id);
         }
         const rows = this.db
-            .prepare(`SELECT m.id AS message_id, m.thread_id, m.sender_id, m.subject, m.body, m.priority,
-                m.in_reply_to, m.created_at, 'inbox' AS folder, 'to' AS role, NULL AS read_at, 0 AS starred
+            .prepare(`SELECT m.id AS message_id, m.thread_id, t.title AS thread_title, m.sender_id, m.subject, m.body,
+                m.priority, m.in_reply_to, m.created_at, 'inbox' AS folder, 'to' AS role, NULL AS read_at, 0 AS starred
            FROM messages m
+           ${THREAD_JOIN}
           WHERE ${where.join(" AND ")}
           ORDER BY m.created_at DESC, m.id DESC
           LIMIT ? OFFSET ?`)
@@ -393,9 +562,9 @@ export class MessageStore extends EventEmitter {
     /** Message complet vu du serveur, avec l'état de lecture de chaque destinataire. */
     getMessageAdmin(messageId) {
         const row = this.db
-            .prepare(`SELECT m.id AS message_id, m.thread_id, m.sender_id, m.subject, m.body, m.priority,
-                m.in_reply_to, m.created_at, 'inbox' AS folder, 'to' AS role, NULL AS read_at, 0 AS starred
-           FROM messages m WHERE m.id = ?`)
+            .prepare(`SELECT m.id AS message_id, m.thread_id, t.title AS thread_title, m.sender_id, m.subject, m.body,
+                m.priority, m.in_reply_to, m.created_at, 'inbox' AS folder, 'to' AS role, NULL AS read_at, 0 AS starred
+           FROM messages m ${THREAD_JOIN} WHERE m.id = ?`)
             .get(messageId);
         if (!row)
             throw new MessengerError(`message not found: ${messageId}`, 404);
@@ -485,6 +654,7 @@ export class MessageStore extends EventEmitter {
         return {
             message_id: row.message_id,
             thread_id: row.thread_id,
+            thread_title: row.thread_title,
             from: row.sender_id,
             to: rcpt.to,
             cc: rcpt.cc,
@@ -506,11 +676,29 @@ export class MessageStore extends EventEmitter {
     /** Un message sans aucune livraison n'est plus lisible par personne : on le supprime. */
     dropOrphanMessages() {
         this.db.exec("DELETE FROM messages WHERE NOT EXISTS (SELECT 1 FROM deliveries d WHERE d.message_id = messages.id)");
+        // Le nom d'un fil vidé de ses messages ne désigne plus rien.
+        this.db.exec("DELETE FROM threads WHERE NOT EXISTS (SELECT 1 FROM messages m WHERE m.thread_id = threads.id)");
     }
 }
 export function normalizeAgentId(id) {
     return String(id ?? "").trim();
 }
+/**
+ * Nettoie un intitulé fourni par un agent.
+ *
+ * `undefined` et `null` valent « ne touche pas » ; une chaîne vide est une erreur, car
+ * elle trahit plus souvent un bug d'appel qu'une volonté d'effacer le nom.
+ */
+function normalizeLabel(value, max, field) {
+    if (value === undefined || value === null)
+        return null;
+    const trimmed = String(value).trim();
+    if (!trimmed)
+        throw new MessengerError(`${field} cannot be empty`);
+    if (trimmed.length > max)
+        throw new MessengerError(`${field} must be at most ${max} characters`);
+    return trimmed;
+}
 function dedupe(values) {
     return [...new Set(values)];
 }

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

@@ -15,6 +15,15 @@ export interface Agent {
     /** false pour un agent créé implicitement parce qu'un message lui a été adressé. */
     registered: boolean;
 }
+/**
+ * Entrée d'annuaire : la fiche de l'agent, plus le moment où sa boîte a vécu pour la
+ * dernière fois. C'est ce moment qui classe l'annuaire, pas l'identifiant : une adresse
+ * opaque ne dit rien à qui lit la console.
+ */
+export interface AgentDirectoryEntry extends Agent {
+    /** Plus récent de la dernière connexion et de la dernière livraison ; null si aucune. */
+    last_activity_at: string | null;
+}
 export interface SendMessageInput {
     from: string;
     to: string[];
@@ -24,10 +33,39 @@ export interface SendMessageInput {
     priority?: Priority;
     /** Id d'un message existant : la réponse hérite de son fil de discussion. */
     reply_to?: string | null;
+    /** Nom lisible donné au fil. Sur une réponse, renomme le fil existant. */
+    thread_title?: string | null;
+    thread_description?: string | null;
+}
+/**
+ * Intitulé d'un fil de discussion.
+ *
+ * Le titre est unique et partagé : tous les participants parlent du même sujet, ils
+ * doivent donc lire le même nom. Le dernier qui renomme a le dernier mot ; `named_by`
+ * garde la trace de qui c'était.
+ */
+export interface ThreadInfo {
+    thread_id: string;
+    title: string | null;
+    description: string | null;
+    /** Agent ayant posé le nom courant, ou null tant que le fil n'a pas été nommé. */
+    named_by: string | null;
+    created_at: string;
+    updated_at: string | null;
+}
+export interface ThreadSummary extends ThreadInfo {
+    /** Sujet du message d'ouverture : intitulé de repli tant que le fil n'est pas nommé. */
+    subject: string;
+    messages: number;
+    unread: number;
+    participants: string[];
+    last_message_at: string;
 }
 export interface SendMessageResult {
     message_id: string;
     thread_id: string;
+    /** Titre du fil après envoi, null s'il n'a jamais été nommé. */
+    thread_title: string | null;
     created_at: string;
     delivered_to: string[];
     /** Destinataires jamais enregistrés sur ce serveur — le message les attend malgré tout. */
@@ -36,6 +74,8 @@ export interface SendMessageResult {
 export interface MessageSummary {
     message_id: string;
     thread_id: string;
+    /** Titre du fil, null tant que personne ne l'a nommé — le `subject` fait alors office. */
+    thread_title: string | null;
     from: string;
     to: string[];
     cc: string[];
@@ -58,6 +98,14 @@ export interface FolderInfo {
     total: number;
     unread: number;
 }
+export interface ListThreadsOptions {
+    /** Ne garder que les fils ayant au moins un message non lu. */
+    unread_only?: boolean;
+    /** Texte libre confronté au titre, à la description et au sujet d'ouverture. */
+    search?: string;
+    limit?: number;
+    offset?: number;
+}
 export interface ListMessagesOptions {
     folder?: string;
     unread_only?: boolean;

package/dist/src/mcp/tools.js

@@ -25,21 +25,37 @@ export const TOOLS = [
         },
     },
     {
-        name: "set_mailbox_label",
-        description: "Give this mailbox a human-readable label and description, so the user can recognise it in the directory and in the web console. Addresses are opaque: a label is what makes a mailbox findable later.",
+        name: "set_label",
+        description: "Give a plain-language name to this mailbox, or to a thread. Ids are opaque: a name is what makes a mailbox or a conversation recognisable later, both for the other agents and for the user reading the web console. Without thread_id it names this mailbox ('Développement des tests unitaires du parser'); with thread_id it names that thread ('Le test échoue sur un bug applicatif'). A thread has a single shared name: renaming it changes it for every participant, and the last caller wins.",
         inputSchema: {
             type: "object",
             properties: {
-                label: { type: "string", description: "Short name, e.g. 'Refactor du parser'." },
-                description: { type: "string", description: "What this session is working on." },
+                label: { type: "string", description: "Short name, one line. Say what the work is about, not who does it." },
+                description: { type: "string", description: "Optional longer explanation of the mailbox or the thread." },
+                thread_id: {
+                    type: "string",
+                    description: "Thread to name. Omit to name this mailbox instead. You must be a participant of the thread.",
+                },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "list_threads",
+        description: "List the conversations visible from this mailbox, most recently active first, with their name, participants and unread count. This is the readable map of the ongoing work: prefer it over list_messages when you want to know what is being discussed rather than what arrived last. A thread with no name falls back to the subject of its opening message — name it with set_label.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                unread_only: { type: "boolean", description: "Keep only threads with unread messages." },
+                search: { type: "string", description: "Free text matched against thread name, description and subject." },
+                limit: { type: "number", description: "1-100, defaults to 25." },
             },
-            required: ["label"],
             additionalProperties: false,
         },
     },
     {
         name: "list_agents",
-        description: "List the agents known to the mailbox server, with their description and last activity. Use it to find the address of the agent you want to write to.",
+        description: "List the agents known to the mailbox server, most recently active first, with their name and description. Use it to find the address of the agent you want to write to.",
         inputSchema: { type: "object", properties: {}, additionalProperties: false },
     },
     {
@@ -59,6 +75,11 @@ export const TOOLS = [
                 body: { type: "string", description: "Message body, plain text or markdown." },
                 priority: { type: "string", enum: [...PRIORITIES], description: "Defaults to normal." },
                 reply_to: { type: "string", description: "Id of the message being answered; the reply joins its thread." },
+                thread_title: {
+                    type: "string",
+                    description: "Plain-language name of the conversation, e.g. 'Résolution de l'échec du test de parsing'. Name the thread when you open it — you already know what it is about. On a reply it renames the thread for everyone, which is what you want when the discussion has drifted.",
+                },
+                thread_description: { type: "string", description: "Optional longer description of the thread." },
             },
             required: ["to", "subject", "body"],
             additionalProperties: false,
@@ -195,6 +216,8 @@ const schemas = {
         body: z.string().min(1),
         priority: z.enum(PRIORITIES).optional(),
         reply_to: z.string().optional(),
+        thread_title: z.string().trim().min(1).max(200).optional(),
+        thread_description: z.string().trim().min(1).max(2000).optional(),
     }),
     list_messages: z.object({
         folder: z.string().optional(),
@@ -215,7 +238,20 @@ const schemas = {
     move_messages: z.object({ message_ids: z.array(z.string().min(1)).min(1), folder: z.string().min(1) }),
     delete_messages: z.object({ message_ids: z.array(z.string().min(1)).min(1), permanent: z.boolean().optional() }),
     attach_to_mailbox: z.object({ mailbox_id: z.string().trim().min(1).optional() }),
-    set_mailbox_label: z.object({ label: z.string().trim().min(1).max(200), description: z.string().max(2000).optional() }),
+    set_label: z
+        .object({
+        label: z.string().trim().min(1).max(200).optional(),
+        description: z.string().trim().min(1).max(2000).optional(),
+        thread_id: z.string().trim().min(1).optional(),
+    })
+        .refine((v) => v.label !== undefined || v.description !== undefined, {
+        message: "provide `label` and/or `description`",
+    }),
+    list_threads: z.object({
+        unread_only: z.boolean().optional(),
+        search: z.string().trim().min(1).optional(),
+        limit: z.number().int().optional(),
+    }),
     create_folder: z.object({ name: z.string().min(1) }),
     delete_folder: z.object({ name: z.string().min(1) }),
     wait_for_message: z.object({ timeout_seconds: z.number().int().optional(), folder: z.string().optional() }),
@@ -233,9 +269,13 @@ export async function callTool(client, name, rawArgs) {
             const stats = await client.stats();
             const health = await client.health().catch(() => null);
             const folders = stats.folders.map((f) => `  ${f.name.padEnd(12)} ${f.total} message(s), ${f.unread} unread`);
+            const self = await client.getAgent(client.agentId).catch(() => null);
             const lines = [
                 `Mailbox address: ${client.agentId}`,
                 "  ↳ give this address to another agent so it can write to you.",
+                self?.display_name
+                    ? `Mailbox name: ${self.display_name}`
+                    : "Mailbox name: none — call set_label so the user can tell this session apart from the others.",
             ];
             if (client.isAttachedElsewhere) {
                 lines.push(`Attached to another mailbox. This session's own mailbox is ${client.sessionAgentId}.`);
@@ -273,10 +313,36 @@ export async function callTool(client, name, rawArgs) {
                 .filter(Boolean)
                 .join("\n");
         }
-        case "set_mailbox_label": {
-            const input = schemas.set_mailbox_label.parse(args);
-            const agent = await client.updateProfile({ display_name: input.label, description: input.description ?? null });
-            return `Mailbox ${agent.id} labelled "${agent.display_name}".`;
+        // `set_mailbox_label` n'est plus publié, mais reste accepté : une session en cours
+        // peut l'avoir appris avant la mise à jour du serveur.
+        case "set_mailbox_label":
+        case "set_label": {
+            const input = schemas.set_label.parse(args);
+            if (input.thread_id) {
+                const thread = await client.setThreadLabel(input.thread_id, {
+                    title: input.label ?? null,
+                    description: input.description ?? null,
+                });
+                return [
+                    `Thread ${thread.thread_id} is now named "${thread.title}".`,
+                    thread.description ? `Description: ${thread.description}` : null,
+                    "Every participant of the thread sees this name.",
+                ]
+                    .filter(Boolean)
+                    .join("\n");
+            }
+            const agent = await client.updateProfile({
+                display_name: input.label ?? null,
+                description: input.description ?? null,
+            });
+            return `Mailbox ${agent.id} named "${agent.display_name}".`;
+        }
+        case "list_threads": {
+            const input = schemas.list_threads.parse(args);
+            const threads = await client.listThreads(input);
+            if (threads.length === 0)
+                return "No thread in this mailbox matching these filters.";
+            return [`${threads.length} thread(s):`, "", ...threads.map(formatThread)].join("\n");
         }
         case "list_agents": {
             const agents = await client.listAgents();
@@ -288,7 +354,8 @@ export async function callTool(client, name, rawArgs) {
                     .filter(Boolean)
                     .join(", ");
                 const title = agent.display_name ? `${agent.id} — ${agent.display_name}` : agent.id;
-                const seen = agent.last_seen_at ? `last seen ${agent.last_seen_at}` : "never seen";
+                // L'annuaire est classé par cette date : l'afficher rend l'ordre lisible.
+                const seen = agent.last_activity_at ? `last active ${agent.last_activity_at}` : "never active";
                 return [`• ${title}${flags ? ` (${flags})` : ""}`, `  ${agent.description ?? "no description"}`, `  ${seen}`].join("\n");
             })
                 .join("\n");
@@ -302,12 +369,17 @@ export async function callTool(client, name, rawArgs) {
                 body: input.body,
                 priority: input.priority,
                 reply_to: input.reply_to ?? null,
+                thread_title: input.thread_title ?? null,
+                thread_description: input.thread_description ?? null,
             });
             const lines = [
                 `Message sent: ${result.message_id}`,
-                `Thread: ${result.thread_id}`,
+                `Thread: ${formatThreadRef(result.thread_title, result.thread_id)}`,
                 `Delivered to: ${result.delivered_to.join(", ")}`,
             ];
+            if (!result.thread_title && !input.reply_to) {
+                lines.push("This thread has no name yet — set_label with its thread_id makes it readable for everyone.");
+            }
             if (result.unknown_recipients.length > 0) {
                 lines.push(`Warning — never connected to this server, the message will wait in their mailbox: ${result.unknown_recipients.join(", ")}`);
             }
@@ -328,8 +400,14 @@ export async function callTool(client, name, rawArgs) {
         }
         case "get_thread": {
             const input = schemas.get_thread.parse(args);
-            const messages = await client.getThread(input.thread_id);
-            return [`Thread ${input.thread_id} — ${messages.length} message(s):`, "", ...messages.map(formatMessage)].join("\n\n---\n\n");
+            const { thread, messages } = await client.getThread(input.thread_id);
+            const header = [
+                `Thread ${formatThreadRef(thread?.title ?? null, input.thread_id)} — ${messages.length} message(s):`,
+                thread?.description ? `Description: ${thread.description}` : null,
+            ]
+                .filter(Boolean)
+                .join("\n");
+            return [header, "", ...messages.map(formatMessage)].join("\n\n---\n\n");
         }
         case "mark_messages": {
             const input = schemas.mark_messages.parse(args);
@@ -424,6 +502,22 @@ function asArray(value) {
         return [];
     return Array.isArray(value) ? value : [value];
 }
+/** `titre (id)`, ou l'id seul tant que le fil n'a pas été nommé. */
+function formatThreadRef(title, threadId) {
+    return title ? `${title} (${threadId})` : threadId;
+}
+function formatThread(thread) {
+    // Sans nom, le sujet d'ouverture reste le seul repère : mieux vaut l'afficher que l'id nu.
+    const name = thread.title ?? `${thread.subject} (unnamed)`;
+    return [
+        `${thread.unread > 0 ? "•" : " "} ${name}`,
+        thread.description ? `   ${thread.description}` : null,
+        `   ${thread.messages} message(s), ${thread.unread} unread · with ${thread.participants.join(", ")}`,
+        `   last activity ${thread.last_message_at} · thread ${thread.thread_id}`,
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
 function formatSummary(message) {
     const flags = [message.read ? " " : "•", message.starred ? "★" : " "].join("");
     const priority = message.priority === "normal" ? "" : ` [${message.priority}]`;
@@ -431,7 +525,7 @@ function formatSummary(message) {
         `${flags} ${message.subject}${priority}`,
         `   from ${message.from} to ${message.to.join(", ") || "—"}${message.cc.length ? ` (cc ${message.cc.join(", ")})` : ""} · ${message.created_at}`,
         `   ${message.preview}`,
-        `   id ${message.message_id} · thread ${message.thread_id}`,
+        `   id ${message.message_id} · thread ${formatThreadRef(message.thread_title, message.thread_id)}`,
     ].join("\n");
 }
 function formatMessage(message) {
@@ -443,7 +537,7 @@ function formatMessage(message) {
         `Date: ${message.created_at}`,
         `Priority: ${message.priority}`,
         `Folder: ${message.folder}${message.read ? "" : " (unread)"}${message.starred ? " ★" : ""}`,
-        `Id: ${message.message_id} · Thread: ${message.thread_id}${message.in_reply_to ? ` · reply to ${message.in_reply_to}` : ""}`,
+        `Id: ${message.message_id} · Thread: ${formatThreadRef(message.thread_title, message.thread_id)}${message.in_reply_to ? ` · reply to ${message.in_reply_to}` : ""}`,
     ]
         .filter(Boolean)
         .join("\n");

package/dist/src/server/app.js

@@ -27,6 +27,22 @@ const sendSchema = z.object({
     body: z.string().min(1).max(200_000),
     priority: z.enum(PRIORITIES).optional(),
     reply_to: z.string().trim().min(1).nullish(),
+    thread_title: z.string().trim().min(1).max(200).nullish(),
+    thread_description: z.string().trim().min(1).max(2000).nullish(),
+});
+const threadLabelSchema = z
+    .object({
+    title: z.string().trim().min(1).max(200).nullish(),
+    description: z.string().trim().min(1).max(2000).nullish(),
+})
+    .refine((v) => v.title != null || v.description != null, {
+    message: "provide `title` and/or `description`",
+});
+const listThreadsQuerySchema = z.object({
+    unread_only: z.coerce.boolean().optional(),
+    search: z.string().trim().min(1).optional(),
+    limit: z.coerce.number().int().min(1).max(100).optional(),
+    offset: z.coerce.number().int().min(0).optional(),
 });
 const listQuerySchema = z.object({
     folder: z.string().trim().min(1).optional(),
@@ -154,6 +170,8 @@ export function createApp({ store, config }) {
             body: input.body,
             priority: input.priority,
             reply_to: input.reply_to ?? null,
+            thread_title: input.thread_title ?? null,
+            thread_description: input.thread_description ?? null,
         });
         logger.info(`message ${result.message_id}: ${req.agentId} -> ${result.delivered_to.join(", ")}`);
         res.status(201).json(result);
@@ -179,8 +197,18 @@ export function createApp({ store, config }) {
         const markRead = req.query.mark_read !== "false";
         res.json(store.getMessage(req.agentId, String(req.params.id), markRead));
     });
+    api.get("/threads", (req, res) => {
+        const query = listThreadsQuerySchema.parse(req.query);
+        res.json({ threads: store.listThreads(req.agentId, query) });
+    });
     api.get("/threads/:id", (req, res) => {
-        res.json({ thread_id: req.params.id, messages: store.getThread(req.agentId, String(req.params.id)) });
+        const threadId = String(req.params.id);
+        const messages = store.getThread(req.agentId, threadId);
+        res.json({ thread_id: threadId, thread: store.getThreadInfo(threadId), messages });
+    });
+    api.patch("/threads/:id", (req, res) => {
+        const input = threadLabelSchema.parse(req.body ?? {});
+        res.json({ thread: store.setThreadLabel(req.agentId, String(req.params.id), input) });
     });
     api.get("/folders", (req, res) => {
         res.json({ folders: store.listFolders(req.agentId) });
@@ -246,10 +274,11 @@ export function createApp({ store, config }) {
         res.json(store.getMessageAdmin(String(req.params.id)));
     });
     admin.get("/threads/:id", (req, res) => {
-        const messages = store.listAllMessages({ thread_id: String(req.params.id), limit: 100 });
+        const threadId = String(req.params.id);
+        const messages = store.listAllMessages({ thread_id: threadId, limit: 100 });
         if (messages.length === 0)
-            throw new MessengerError(`thread not found: ${req.params.id}`, 404);
-        res.json({ thread_id: req.params.id, messages: messages.slice().reverse() });
+            throw new MessengerError(`thread not found: ${threadId}`, 404);
+        res.json({ thread_id: threadId, thread: store.getThreadInfo(threadId), messages: messages.slice().reverse() });
     });
     app.use("/admin", admin);
     // --- Interface web --------------------------------------------------------

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

@@ -14,6 +14,7 @@ const state = {
   search: "",
   selectedMessageId: null,
   threadId: null,
+  threadTitle: null,
 };
 
 const el = {
@@ -71,6 +72,12 @@ function formatDate(iso) {
   return Number.isNaN(date.getTime()) ? iso : date.toLocaleString();
 }
 
+/** Le titre suit l'id : le bandeau de filtre doit rester lisible, pas afficher un id nu. */
+function setThreadFilter(threadId, title) {
+  state.threadId = threadId;
+  state.threadTitle = title;
+}
+
 function renderAgents(overview) {
   el.serverStats.textContent =
     overview.messages + " message(s) · " + overview.threads + " fil(s) · " + overview.agents.length + " agent(s)";
@@ -79,14 +86,20 @@ function renderAgents(overview) {
 
   for (const agent of overview.agents) {
     const item = node("li", state.agent === agent.id ? "selected" : "");
-    item.appendChild(node("div", "id", agent.display_name ? agent.id + " — " + agent.display_name : agent.id));
+    // Le nom d'abord : l'adresse ne dit rien à l'utilisateur, elle reste là pour être copiée.
+    item.appendChild(node("div", "name", agent.display_name || "sans nom"));
+    item.appendChild(node("div", "id", agent.id));
     item.appendChild(
       node("div", "muted", "envoyés " + agent.sent + " · reçus " + agent.received + " · non lus " + agent.unread)
     );
+    // La liste est classée sur cette date : sans elle, l'ordre paraîtrait arbitraire.
+    item.appendChild(
+      node("div", "muted", agent.last_activity_at ? "activité " + formatDate(agent.last_activity_at) : "aucune activité")
+    );
     if (!agent.registered) item.appendChild(node("div", "muted", "jamais connecté"));
     item.addEventListener("click", () => {
       state.agent = state.agent === agent.id ? null : agent.id;
-      state.threadId = null;
+      setThreadFilter(null, null);
       refresh();
     });
     el.agents.appendChild(item);
@@ -96,7 +109,7 @@ function renderAgents(overview) {
 function renderMessages(messages) {
   el.filterLabel.textContent = [
     state.agent ? "agent : " + state.agent : null,
-    state.threadId ? "fil : " + state.threadId : null,
+    state.threadId ? "fil : " + (state.threadTitle || state.threadId) : null,
   ]
     .filter(Boolean)
     .join(" · ");
@@ -115,6 +128,8 @@ function renderMessages(messages) {
       subject.appendChild(badge);
     }
     item.appendChild(subject);
+    // Le nom du fil dit de quelle conversation relève le message ; sans nom, rien à afficher.
+    if (message.thread_title) item.appendChild(node("div", "thread-name", message.thread_title));
     item.appendChild(
       node("div", "route", message.from + " → " + (message.to.join(", ") || "—") + " · " + formatDate(message.created_at))
     );
@@ -154,7 +169,7 @@ function renderDetail(message) {
         "\nid " +
         message.message_id +
         " · fil " +
-        message.thread_id
+        (message.thread_title ? message.thread_title + " (" + message.thread_id + ")" : message.thread_id)
     )
   );
 
@@ -192,11 +207,16 @@ async function showThread(threadId) {
   try {
     const data = await api("/admin/threads/" + encodeURIComponent(threadId));
     const container = node("div", "detail");
-    container.appendChild(node("h3", null, "Fil " + threadId + " — " + data.messages.length + " message(s)"));
+    const title = (data.thread && data.thread.title) || null;
+    container.appendChild(node("h3", null, (title || "Fil " + threadId) + " — " + data.messages.length + " message(s)"));
+    if (title) container.appendChild(node("div", "meta", "fil " + threadId));
+    if (data.thread && data.thread.description) {
+      container.appendChild(node("div", "thread-description", data.thread.description));
+    }
 
     const filterButton = node("button", null, "Filtrer la liste sur ce fil");
     filterButton.addEventListener("click", () => {
-      state.threadId = threadId;
+      setThreadFilter(threadId, title);
       refresh({ keepDetail: true });
     });
     container.appendChild(filterButton);
@@ -246,7 +266,7 @@ async function refresh(options) {
 el.refresh.addEventListener("click", () => refresh({ keepDetail: true }));
 el.clearFilters.addEventListener("click", () => {
   state.agent = null;
-  state.threadId = null;
+  setThreadFilter(null, null);
   state.search = "";
   el.search.value = "";
   refresh({ keepDetail: true });

package/dist/src/server/ui/styles.css

@@ -180,8 +180,15 @@ ul {
   outline: 1px solid var(--accent);
 }
 
-.agents .id {
+.agents .name {
   font-weight: 600;
+}
+
+/* L'adresse reste lisible pour être recopiée, mais ne prend plus le pas sur le nom. */
+.agents .id {
+  color: var(--muted);
+  font-size: 11px;
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
   word-break: break-all;
 }
 
@@ -216,6 +223,18 @@ ul {
   font-weight: 600;
 }
 
+/* Nom du fil : au-dessus de l'expéditeur, en accent, pour rattacher le message d'un coup d'œil. */
+.messages .thread-name {
+  color: var(--accent);
+  font-size: 12px;
+  margin-top: 2px;
+}
+
+.detail .thread-description {
+  color: var(--muted);
+  margin: 6px 0 10px;
+}
+
 .messages .route {
   color: var(--muted);
   font-size: 12px;

package/dist/src/version.d.ts

@@ -1 +1 @@
-export declare const APP_VERSION = "1.0.4";
+export declare const APP_VERSION = "1.0.5";

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.4";
+export const APP_VERSION = "1.0.5";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imenam/mcp-messenger",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "main": "dist/src/index.js",
   "scripts": {
     "test": "npm run build && vitest run",
@@ -48,6 +48,7 @@
     "@types/better-sqlite3": "^7.6.13",
     "@types/express": "^5.0.6",
     "@types/node": "^22.20.1",
+    "@vitest/coverage-v8": "^3.2.7",
     "typescript": "^5.9.3",
     "vitest": "^3.2.7"
   },