@imenam/mcp-messenger 1.0.3 → 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.
@@ -143,11 +144,25 @@ n'hérite pas du bloc `env` du `.mcp.json`, donc ni de `MESSENGER_SERVER_URL` ni
 Le fichier est nommé par hachage de l'adresse, supprimé à la fin de la session, et purgé au
 bout de sept jours si la session s'est arrêtée brutalement.
 
+**Savoir si c'est vraiment armé.** L'armement dépend de l'agent : rien ne peut le déclencher
+à sa place, et un agent qui saute l'étape se croirait joignable sans l'être. Le serveur suit
+donc les attentes tenues par un veilleur, et `whoami` le dit :
+
+```
+Notifications: armed — incoming messages will interrupt you (watcher since 2026-09-07T13:31:00.203Z).
+Notifications: NOT armed — no incoming message will reach you. Call enable_notifications.
+```
+
+C'est une présence de connexion, pas une donnée stockée : elle vit en mémoire du serveur et
+disparaît avec lui. Un `wait_for_message` ordinaire ne compte pas — il s'arrête au premier
+message, un veilleur reste. Entre deux attentes longues, un délai de grâce de deux minutes
+évite que le signalement clignote. `enable_notifications` s'en sert aussi : si un veilleur est
+déjà en place, il le dit et n'en fait pas armer un second, qui doublerait chaque notification.
+
 **Ce que ça ne couvre pas.** Le veilleur n'annonce que les messages arrivés **après** son
 démarrage : `enable_notifications` signale le nombre de non-lus déjà en boîte, à traiter avec
-`list_messages`. Et l'armement dépend de l'agent : s'il saute l'étape `Monitor`, il ne sera
-jamais notifié et rien côté serveur ne le détecte. C'est pourquoi `--claude-setup-mcp` écrit
-un rappel dans le `CLAUDE.md` du projet.
+`list_messages`. Et `--claude-setup-mcp` écrit un rappel d'armement dans le `CLAUDE.md` du
+projet, pour que l'étape ne soit pas oubliée en début de session.
 
 **Sur un autre hôte que Claude Code.** `--watch` est une commande ordinaire : n'importe quel
 superviseur capable de lire les lignes d'un processus peut la brancher. Sans relais, elle lit
@@ -159,11 +174,12 @@ superviseur capable de lire les lignes d'un processus peut la brancher. Sans rel
 
 | Outil | Rôle |
 |---|---|
-| `whoami` | Adresse de cette session, serveur connecté, compteurs par dossier |
+| `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 |
@@ -175,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.
 
@@ -202,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 :
@@ -298,16 +342,18 @@ cet agent lorsque `MESSENGER_AGENT_TOKENS` est utilisé.
 | `GET` | `/api/agents` | Annuaire des boîtes |
 | `GET` | `/api/agents/:id` | Une boîte, ou 404 |
 | `PATCH` | `/api/agents/me` | Renommer la boîte courante |
-| `GET` | `/api/mailbox` | Compteurs de la boîte |
+| `GET` | `/api/mailbox` | Compteurs de la boîte, et présence d'un veilleur (`watcher`) |
 | `POST` | `/api/messages` | Envoyer un message |
 | `GET` | `/api/messages` | Lister (`folder`, `unread_only`, `from`, `thread_id`, `search`, `limit`, `offset`) |
 | `GET` | `/api/messages/:id` | Lire (`?mark_read=false` pour ne pas marquer) |
 | `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`) |
+| `GET` | `/api/wait` | Attente longue (`timeout_seconds`, `folder`, `watcher`) |
 | `GET` | `/admin/overview` · `/admin/messages[/:id]` · `/admin/threads/:id` | Supervision, lecture seule |
 
 ---
@@ -355,6 +401,7 @@ src/
   logger.ts             # journalisation sur stderr (stdout est réservé au JSON-RPC)
   core/store.ts         # SQLite : agents, messages, livraisons, dossiers
   server/app.ts         # API HTTP, authentification, supervision
+  server/watchers.ts    # présence des veilleurs, en mémoire : état de connexion
   server/start.ts       # démarrage, arrêt propre, purge de la corbeille
   server/ui/            # console web (HTML/CSS/JS sans dépendance)
   cli/watch.ts          # mode veilleur : une ligne sur stdout par message entrant
@@ -366,7 +413,7 @@ test/                   # store, config, API HTTP, outils MCP, binaire réel
 
 ### Tests
 
-104 tests couvrant : le stockage et l'isolation des boîtes, la validation de configuration,
+112 tests couvrant : le stockage et l'isolation des boîtes, la validation de configuration,
 l'API HTTP et son authentification (refus systématique sans jeton, jeton partagé, jetons par
 agent, jeton de console distinct), les outils MCP de bout en bout (deux agents qui
 conversent à travers un vrai serveur), l'allocation des boîtes par session — deux processus
@@ -376,7 +423,8 @@ troisième session reprend la boîte de l'une d'elles — et le binaire publié
 La notification passive est couverte de bout en bout : le relais vers le veilleur (isolation
 entre boîtes, adresse jamais transformée en chemin, nettoyage), le format d'évènement (une
 ligne, quel que soit le sujet), et un veilleur réellement lancé comme processus séparé, sans
-jeton dans son environnement, qui émet sa ligne à l'arrivée d'un message.
+jeton dans son environnement, qui émet sa ligne à l'arrivée d'un message — et `whoami` qui
+passe de « NOT armed » à « armed » quand ce veilleur prend son poste.
 
 ---
 

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);
@@ -63,7 +65,7 @@ export async function runWatchMode(mailbox) {
     let backoff = BACKOFF_MIN_MS;
     for (;;) {
         try {
-            const result = await client.waitForMessage(POLL_SECONDS);
+            const result = await client.waitForMessage(POLL_SECONDS, undefined, { watcher: true });
             backoff = BACKOFF_MIN_MS;
             if (result.timed_out || !result.message)
                 continue;

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,10 +78,30 @@ 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>;
-    waitForMessage(timeoutSeconds: number, folder?: string): Promise<WaitResult>;
+    /**
+     * `watcher` signale une attente tenue par un veilleur `--watch`, et non par un
+     * `wait_for_message` ponctuel : c'est ce qui permet au serveur de dire si la boîte est
+     * réellement surveillée.
+     */
+    waitForMessage(timeoutSeconds: number, folder?: string, options?: {
+        watcher?: boolean;
+    }): Promise<WaitResult>;
     private request;
 }

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");
@@ -139,10 +147,15 @@ export class MessengerClient {
         const { moved } = await this.request("DELETE", `/api/folders/${encodeURIComponent(name)}`);
         return moved;
     }
-    async waitForMessage(timeoutSeconds, folder) {
+    /**
+     * `watcher` signale une attente tenue par un veilleur `--watch`, et non par un
+     * `wait_for_message` ponctuel : c'est ce qui permet au serveur de dire si la boîte est
+     * réellement surveillée.
+     */
+    async waitForMessage(timeoutSeconds, folder, options = {}) {
         // L'attente longue peut dépasser le délai HTTP par défaut : on l'étend d'une marge.
         return this.request("GET", "/api/wait", {
-            query: { timeout_seconds: timeoutSeconds, folder },
+            query: { timeout_seconds: timeoutSeconds, folder, watcher: options.watcher ? "true" : undefined },
             timeoutMs: timeoutSeconds * 1000 + this.config.timeoutMs,
         });
     }

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)];
 }