@imenam/mcp-messenger 1.0.3 → 1.0.5

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;
@@ -67,8 +115,23 @@ export interface ListMessagesOptions {
     limit?: number;
     offset?: number;
 }
+/**
+ * Présence d'un veilleur (`--watch`) sur une boîte, telle que la voit le serveur.
+ *
+ * `armed: false` veut dire que personne n'écoute : les messages arriveront en boîte,
+ * mais aucun agent n'en sera averti tant qu'il ne regarde pas de lui-même.
+ */
+export interface WatcherStatus {
+    armed: boolean;
+    /** Depuis quand ce veilleur est en place, ou null s'il n'y en a pas. */
+    since: string | null;
+    /** Dernière attente observée, y compris pour un veilleur qui vient de disparaître. */
+    last_seen: string | null;
+}
 export interface MailboxStats {
     agent_id: string;
     unread_total: number;
     folders: FolderInfo[];
+    /** Absent des réponses du store : ajouté par le serveur, qui seul voit les connexions. */
+    watcher?: WatcherStatus;
 }

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,14 +269,23 @@ 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}.`);
             }
-            lines.push(`Mailbox server: ${client.serverUrl}${health ? ` (v${health.version}, ${health.agents} mailbox(es))` : " (unreachable health endpoint)"}`, `Unread (excluding trash): ${stats.unread_total}`, "Folders:", ...folders);
+            lines.push(`Mailbox server: ${client.serverUrl}${health ? ` (v${health.version}, ${health.agents} mailbox(es))` : " (unreachable health endpoint)"}`, 
+            // Sans veilleur, un message arrive en boîte sans que personne n'en soit averti.
+            // Le dire ici est le seul moyen pour l'agent de s'en apercevoir.
+            stats.watcher?.armed
+                ? `Notifications: armed — incoming messages will interrupt you (watcher since ${stats.watcher.since}).`
+                : "Notifications: NOT armed — no incoming message will reach you. Call enable_notifications.", `Unread (excluding trash): ${stats.unread_total}`, "Folders:", ...folders);
             return lines.join("\n");
         }
         case "attach_to_mailbox": {
@@ -268,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();
@@ -283,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");
@@ -297,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(", ")}`);
             }
@@ -323,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);
@@ -371,6 +454,15 @@ export async function callTool(client, name, rawArgs) {
             writeHandoff({ mailbox, serverUrl: client.serverUrl, token: client.tokenForHandoff });
             const stats = await client.stats().catch(() => null);
             const pending = stats?.folders.find((f) => f.name === "inbox")?.unread ?? 0;
+            // Un veilleur déjà en place suffit : en armer un second doublerait chaque
+            // notification sans rien apporter.
+            if (stats?.watcher?.armed) {
+                return [
+                    `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.",
+                ].join("\n");
+            }
             const lines = [
                 `Notifications enabled for mailbox \`${mailbox}\`.`,
                 "",
@@ -410,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}]`;
@@ -417,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) {
@@ -429,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

@@ -8,6 +8,7 @@ import { rateLimit } from "express-rate-limit";
 import { z } from "zod";
 import { MessengerError, normalizeAgentId } from "../core/store.js";
 import { PRIORITIES } from "../core/types.js";
+import { WatcherRegistry } from "./watchers.js";
 import { APP_VERSION } from "../version.js";
 import { logger } from "../logger.js";
 const UI_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), "ui");
@@ -26,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(),
@@ -51,6 +68,9 @@ const folderSchema = z.object({ name: z.string().trim().min(1).max(40) });
 const waitQuerySchema = z.object({
     timeout_seconds: z.coerce.number().int().min(1).optional(),
     folder: z.string().trim().min(1).optional(),
+    // Distingue le veilleur d'un `wait_for_message` ordinaire : les deux tiennent la même
+    // attente longue, mais seul le premier prouve que l'agent est joignable en continu.
+    watcher: z.enum(["true", "1"]).optional(),
 });
 const adminListSchema = z.object({
     search: z.string().trim().min(1).optional(),
@@ -61,6 +81,8 @@ const adminListSchema = z.object({
 });
 export function createApp({ store, config }) {
     const app = express();
+    // 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);
     app.use(helmet({
@@ -136,7 +158,7 @@ export function createApp({ store, config }) {
         res.json({ agent });
     });
     api.get("/mailbox", (req, res) => {
-        res.json(store.stats(req.agentId));
+        res.json({ ...store.stats(req.agentId), watcher: watchers.status(req.agentId) });
     });
     api.post("/messages", (req, res) => {
         const input = sendSchema.parse(req.body ?? {});
@@ -148,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);
@@ -173,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) });
@@ -190,16 +224,20 @@ export function createApp({ store, config }) {
     // l'appelant ; les non-lus déjà présents sont ignorés (sinon l'outil rendrait la main
     // immédiatement tant que la boîte n'est pas vidée).
     api.get("/wait", (req, res) => {
-        const { timeout_seconds, folder } = waitQuerySchema.parse(req.query);
+        const { timeout_seconds, folder, watcher } = waitQuerySchema.parse(req.query);
         const agentId = req.agentId;
         const timeoutSeconds = Math.min(timeout_seconds ?? 30, config.maxWaitSeconds);
         if (folder && !store.listFolders(agentId).some((f) => f.name === folder)) {
             throw new MessengerError(`unknown folder: ${folder}`, 404);
         }
+        // Le relâchement doit couvrir les trois sorties possibles : message, expiration,
+        // client parti. Un compteur qui ne redescend pas ferait croire à un veilleur éternel.
+        const releaseWatcher = watcher ? watchers.begin(agentId) : () => { };
         const done = (payload) => {
             clearTimeout(timer);
             store.off("message", onMessage);
             req.off("close", onClose);
+            releaseWatcher();
             if (!res.headersSent)
                 res.json(payload);
         };
@@ -215,6 +253,7 @@ export function createApp({ store, config }) {
         const onClose = () => {
             clearTimeout(timer);
             store.off("message", onMessage);
+            releaseWatcher();
         };
         const timer = setTimeout(() => done({ timed_out: true, message: null }), timeoutSeconds * 1000);
         store.on("message", onMessage);
@@ -235,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/server/watchers.d.ts

@@ -0,0 +1,10 @@
+import type { WatcherStatus } from "../core/types.js";
+export declare class WatcherRegistry {
+    private readonly now;
+    private readonly presence;
+    /** L'horloge est injectable : le délai de grâce se teste sans faire attendre la suite. */
+    constructor(now?: () => number);
+    /** Déclare une attente de veilleur. La fonction rendue la clôt, et doit toujours être appelée. */
+    begin(agentId: string): () => void;
+    status(agentId: string): WatcherStatus;
+}