@imenam/mcp-messenger 1.0.8 → 1.0.10

package/README.md

@@ -179,8 +179,8 @@ superviseur capable de lire les lignes d'un processus peut la brancher. Sans rel
 | `attach_to_mailbox` | Se brancher sur une autre boîte via son adresse ; sans argument, retour à la sienne |
 | `rename_mailbox` | Nommer ou renommer sa boîte (de quoi la session s'occupe) ; le nom de l'agent, posé par la configuration, reste |
 | `rename_thread` | Nommer ou renommer un fil (`thread_id`) ; le nom est partagé par tous ses participants |
-| `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 ; la boîte de l'appelant n'y figure pas |
+| `list_threads` | Carte des conversations : nom, participants, non-lus, dernière activité ; `with_agent` ne garde que celles partagées avec une boîte |
+| `list_agents` | Annuaire groupé par agent : un projet, ses sessions ; `agent_name` déplie un groupe. La boîte de l'appelant n'y figure pas |
 | `send_message` | Écrire à un agent — un seul destinataire par message (`to`, `priority`, `reply_to`, `thread_name`) |
 | `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 |
@@ -224,9 +224,19 @@ ont deux boîtes distinctes et ne se volent pas leur courrier.
 
 ### Faire communiquer deux agents
 
-1. Demande son adresse à l'agent A (`whoami`) — il te la donne.
+Le plus souvent, il n'y a rien à faire : l'agent B ouvre `list_agents` et y trouve
+l'adresse de A. C'est le chemin normal, et le seul qui ne puisse pas se tromper.
+
+Si tu veux désigner toi-même l'interlocuteur :
+
+1. Demande son adresse à l'agent A (`whoami`) — il te la donne, c'est à toi qu'elle est due.
 2. Transmets-la à l'agent B, qui l'utilise dans `send_message`.
 
+Dans les deux cas, une adresse ne circule jamais **dans** un message : le serveur y attache
+déjà l'expéditeur et le destinataire. Un agent qui recopie une adresse dans un corps de
+message écrit une information que le lecteur a déjà, et qui sera fausse le jour où il se
+trompe de session.
+
 Comme les adresses sont opaques, demande aux agents de nommer leur boîte
 (`rename_mailbox`) : le nom apparaît dans `list_agents` et dans la console web, ce
 qui permet de retrouver une adresse perdue.
@@ -244,12 +254,18 @@ pas au même rythme :
 | Exemple | `Ai Corrector Dev` | `Correction du parseur de copies` |
 
 Le nom de l'agent seul ne distingue pas deux sessions ouvertes sur le même projet ; le nom
-de la boîte seul ne dit pas d'où l'agent écrit. L'annuaire (`list_agents`), `whoami` et la
-console web montrent donc toujours les deux, sous la forme `Agent · Boîte`. Renommer la
-boîte ne touche jamais au nom de l'agent.
+de la boîte seul ne dit pas d'où l'agent écrit. `whoami` et la console web montrent donc
+toujours les deux, et l'annuaire (`list_agents`) les met l'un sous l'autre : le nom de
+l'agent en tête de groupe, une ligne par boîte en dessous. Renommer la boîte ne touche
+jamais au nom de l'agent.
 
 **Un nom d'agent ne désigne personne.** C'est le piège de ce modèle : plusieurs boîtes
-portent le même `agent_name`, une par session lancée depuis la même configuration. Un agent
+portent le même `agent_name`, une par session lancée depuis la même configuration.
+L'annuaire le rend visible en groupant les boîtes sous leur nom d'agent — un groupe à
+plusieurs lignes, ce sont plusieurs sessions vivantes du même projet, chacune à sa propre
+adresse. Un groupe nombreux n'affiche que ses trois sessions les plus récentes ;
+`list_agents` avec `agent_name` donne le reste, sans imposer ce second appel dans le cas
+courant. Un agent
 qui croise son propre nom d'agent dans l'annuaire regarde une *autre* session du même
 projet, jamais la sienne — sa boîte, elle, n'y figure pas du tout. Seule l'adresse identifie
 une session. Ce rappel est servi à trois endroits, du plus tôt au plus tard : les
@@ -319,6 +335,7 @@ configuration partagent alors la même boîte. Utile pour un service unique et s
 - la liste des agents avec leurs compteurs (envoyés, reçus, non lus) ;
 - tous les messages, filtrables par agent, par fil ou par recherche texte ;
 - le contenu d'un message et son état de distribution (qui l'a reçu, dans quel dossier, lu ou non) ;
+- sous le message ouvert, les échanges qui l'ont précédé, repliés par défaut et dépliables d'un bouton, comme dans une boîte mail ;
 - le fil complet d'une conversation ;
 - un rafraîchissement automatique toutes les 5 secondes.
 

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

@@ -83,6 +83,7 @@ export declare class MessengerClient {
     }>;
     listThreads(options?: {
         unread_only?: boolean;
+        with_agent?: string;
         search?: string;
         limit?: number;
     }): Promise<ThreadSummary[]>;

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

@@ -95,6 +95,16 @@ export declare class MessageStore extends EventEmitter<StoreEvents> {
         limit?: number;
         offset?: number;
     }): MessageSummary[];
+    /**
+     * Fil complet vu du serveur, du plus ancien au plus récent, corps inclus.
+     *
+     * La console affiche les échanges antérieurs sous le message ouvert : elle a besoin du
+     * texte, pas seulement de l'aperçu. Les deux sont renvoyés, l'aperçu servant aux vues
+     * qui ne déplient rien.
+     */
+    listThreadAdmin(threadId: string): (MessageSummary & {
+        body: string;
+    })[];
     /** Message complet vu du serveur, avec l'état de lecture de chaque destinataire. */
     getMessageAdmin(messageId: string): Message & {
         deliveries: {

package/dist/src/core/store.js

@@ -376,9 +376,18 @@ export class MessageStore extends EventEmitter {
         const limit = clamp(opts.limit ?? 25, 1, MAX_LIMIT);
         const offset = Math.max(0, opts.offset ?? 0);
         const having = [];
+        const where = ["d.agent_id = ?", "d.folder != 'trash'"];
         const params = [agentId];
         if (opts.unread_only)
             having.push("unread > 0");
+        // Correspondance avec une boîte donnée : le fil compte dès qu'elle y a une livraison,
+        // qu'elle ait écrit ou seulement reçu. Les paramètres du WHERE se lient avant ceux du
+        // HAVING : cette condition doit donc être poussée avant celles de la recherche.
+        if (opts.with_agent) {
+            where.push(`EXISTS (SELECT 1 FROM deliveries d2 JOIN messages m2 ON m2.id = d2.message_id
+                  WHERE m2.thread_id = m.thread_id AND d2.agent_id = ?)`);
+            params.push(normalizeAgentId(opts.with_agent));
+        }
         if (opts.search) {
             // Le titre prime, mais un fil non nommé ne doit pas devenir introuvable :
             // la recherche couvre aussi le sujet d'ouverture.
@@ -398,7 +407,7 @@ export class MessageStore extends EventEmitter {
            FROM deliveries d
            JOIN messages m ON m.id = d.message_id
            ${THREAD_JOIN}
-          WHERE d.agent_id = ? AND d.folder != 'trash'
+          WHERE ${where.join(" AND ")}
           GROUP BY m.thread_id
           ${having.length ? `HAVING ${having.join(" AND ")}` : ""}
           ORDER BY last_message_at DESC
@@ -590,6 +599,25 @@ export class MessageStore extends EventEmitter {
         const recipients = this.recipientsFor(rows.map((r) => r.message_id));
         return rows.map((row) => this.toSummary(row, recipients));
     }
+    /**
+     * Fil complet vu du serveur, du plus ancien au plus récent, corps inclus.
+     *
+     * La console affiche les échanges antérieurs sous le message ouvert : elle a besoin du
+     * texte, pas seulement de l'aperçu. Les deux sont renvoyés, l'aperçu servant aux vues
+     * qui ne déplient rien.
+     */
+    listThreadAdmin(threadId) {
+        const rows = this.db
+            .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.thread_id = ?
+          ORDER BY m.created_at ASC, m.id ASC`)
+            .all(threadId);
+        const recipients = this.recipientsFor(rows.map((r) => r.message_id));
+        return rows.map((row) => ({ ...this.toSummary(row, recipients), body: row.body }));
+    }
     /** Message complet vu du serveur, avec l'état de lecture de chaque destinataire. */
     getMessageAdmin(messageId) {
         const row = this.db

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

@@ -111,6 +111,13 @@ export interface FolderInfo {
 export interface ListThreadsOptions {
     /** Ne garder que les fils ayant au moins un message non lu. */
     unread_only?: boolean;
+    /**
+     * Adresse d'un correspondant : ne garder que les fils qu'il partage avec cette boîte.
+     *
+     * L'unité d'une correspondance est le fil, pas le message : « ce que j'ai échangé avec
+     * cette boîte » se lit ici, et non en filtrant les messages sur leur expéditeur.
+     */
+    with_agent?: string;
     /** Texte libre confronté au titre, à la description et au sujet d'ouverture. */
     search?: string;
     limit?: number;

package/dist/src/mcp/start.js

@@ -21,7 +21,8 @@ const INSTRUCTIONS = `mcp-messenger gives this session a mailbox and lets it exc
 Who you are, and who the others are — read this before writing to anyone:
 - A session is identified by its mailbox address, and by nothing else. \`whoami\` gives you yours.
 - The agent name (e.g. "Ai Corrector Dev") comes from the configuration and says which project the agent works on. It is NOT unique: every session started from that configuration carries it.
-- So several mailboxes in \`list_agents\` can carry the same agent name as yours. Recognising your own agent name there does not mean you are looking at yourself — it is another session of the same project, a different agent, with its own mailbox. Compare addresses, never names.
+- \`list_agents\` groups mailboxes under their agent name: one group per project, one line per session. A group holding several lines is several live sessions of that project, each with its own address — pick one of those addresses, never the group name.
+- One of those groups may carry the same agent name as yours. Recognising your own agent name there does not mean you are looking at yourself — those are other sessions of the same project, each a different agent with its own mailbox. Compare addresses, never names.
 - Your own mailbox is never listed in \`list_agents\`: every address you see there belongs to someone else.
 
 Writing:

package/dist/src/mcp/tools.js

@@ -7,7 +7,7 @@ const FOLDER_HINT = `Folder name. System folders: ${SYSTEM_FOLDERS.join(", ")}.
 export const TOOLS = [
     {
         name: "whoami",
-        description: "Return this session's mailbox address, the server it is connected to, and unread counts per folder. The address is what another agent needs in order to write here: give it whenever someone asks how to reach you.",
+        description: "Return this session's mailbox address, the server it is connected to, and unread counts per folder. The address is what identifies this session: tell it to the user when they ask how to reach you. Other agents never need you to send it — list_agents gives it to them, and every message you send already carries it.",
         inputSchema: { type: "object", properties: {}, additionalProperties: false },
     },
     {
@@ -55,11 +55,15 @@ export const TOOLS = [
     },
     {
         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 rename_thread.",
+        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. Set with_agent to see everything exchanged with one mailbox. A thread with no name falls back to the subject of its opening message — name it with rename_thread.",
         inputSchema: {
             type: "object",
             properties: {
                 unread_only: { type: "boolean", description: "Keep only threads with unread messages." },
+                with_agent: {
+                    type: "string",
+                    description: "Mailbox address of a correspondent: keep only the threads shared with that mailbox. This is how you review what you have exchanged with someone — a conversation is a thread, not a stack of messages.",
+                },
                 search: { type: "string", description: "Free text matched against thread name, description and subject." },
                 limit: { type: "number", description: "1-100, defaults to 25." },
             },
@@ -68,8 +72,17 @@ export const TOOLS = [
     },
     {
         name: "list_agents",
-        description: "List the other agents known to the mailbox server, most recently active first, with their name and description. Your own mailbox is never listed — you cannot write to yourself. Use it to find the address of the agent you want to write to.",
-        inputSchema: { type: "object", properties: {}, additionalProperties: false },
+        description: "List the other agents known to the mailbox server, grouped by agent name — one group per project, one line per session mailbox inside it, most recently active first. An agent name is shared by every session of the same project, so a group with several lines means several live sessions, each with its own address. Your own mailbox is never listed — you cannot write to yourself. Use it to find the address of the agent you want to write to; pass agent_name to expand a group whose sessions were not all listed.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                agent_name: {
+                    type: "string",
+                    description: "Name of one agent (project) to expand: lists every one of its session mailboxes in full. Omit it to get the whole directory, grouped.",
+                },
+            },
+            additionalProperties: false,
+        },
     },
     {
         name: "send_message",
@@ -276,9 +289,11 @@ const schemas = {
     }),
     list_threads: z.object({
         unread_only: z.boolean().optional(),
+        with_agent: z.string().trim().min(1).optional(),
         search: z.string().trim().min(1).optional(),
         limit: z.number().int().optional(),
     }),
+    list_agents: z.object({ agent_name: z.string().trim().min(1).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() }),
@@ -299,7 +314,10 @@ export async function callTool(client, name, rawArgs) {
             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.",
+                // Personne n'a besoin qu'on la lui envoie : l'annuaire la donne, et chaque message
+                // la porte déjà. Le seul destinataire légitime est l'utilisateur, qui le demande.
+                "  ↳ this identifies this session. Other agents read it from list_agents and from the",
+                "    messages you send them — tell it to the user if asked, never inside a message body.",
                 self?.agent_name
                     ? `Agent: ${self.agent_name}`
                     : "Agent: unnamed (set MESSENGER_AGENT_NAME in the MCP configuration)",
@@ -369,38 +387,18 @@ export async function callTool(client, name, rawArgs) {
         case "list_threads": {
             const input = schemas.list_threads.parse(args);
             const threads = await client.listThreads(input);
+            const scope = input.with_agent ? ` with ${input.with_agent}` : "";
             if (threads.length === 0)
-                return "No thread in this mailbox matching these filters.";
-            return [`${threads.length} thread(s):`, "", ...threads.map(formatThread)].join("\n");
+                return `No thread in this mailbox${scope} matching these filters.`;
+            return [`${threads.length} thread(s)${scope}:`, "", ...threads.map(formatThread)].join("\n");
         }
         case "list_agents": {
+            const input = schemas.list_agents.parse(args);
             const agents = await client.listAgents();
             if (agents.length === 0)
                 return "No other agent on this server yet.";
-            const directory = agents
-                .map((agent) => {
-                const flags = agent.registered ? "" : "never connected";
-                const names = formatAgentNames(agent);
-                const title = names ? `${agent.id} — ${names}` : agent.id;
-                // 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.agent_description ?? agent.description ?? "no description"}`,
-                    `  ${seen}`,
-                ].join("\n");
-            })
-                .join("\n");
-            // Un nom d'agent est celui d'un projet, pas d'une session : plusieurs boîtes le
-            // portent, y compris celle de l'appelant. Sans ce rappel, un agent croise son propre
-            // nom d'agent dans cette liste et prend la boîte d'une autre session pour la sienne.
-            return [
-                directory,
-                "",
-                "Addresses identify sessions; agent names do not. Several mailboxes above may carry the same",
-                "agent name as yours — they are other sessions of the same project, never you: your own mailbox",
-                "is never listed here. Always write to an address taken from this list, never to a name.",
-            ].join("\n");
+            const groups = groupByAgentName(agents);
+            return input.agent_name ? formatAgentGroup(groups, input.agent_name) : formatDirectory(groups);
         }
         case "send_message": {
             const input = schemas.send_message.parse(args);
@@ -552,6 +550,111 @@ async function renameMailbox(client, name, description) {
 function formatAgentNames(agent) {
     return [agent.agent_name, agent.display_name].filter(Boolean).join(" · ");
 }
+/** Boîtes détaillées sous un nom d'agent avant de renvoyer le reste à `agent_name`. */
+const SESSIONS_SHOWN_PER_AGENT = 4;
+const NO_AGENT_NAME = "unnamed agent";
+/**
+ * Deux boîtes sans nom d'agent ne sont pas deux sessions du même projet : rien ne le dit.
+ * Chacune reste donc son propre groupe, là où un nom partagé les rassemble.
+ */
+function groupByAgentName(agents) {
+    const groups = new Map();
+    for (const agent of agents) {
+        const name = agent.agent_name?.trim() ?? "";
+        const key = name ? name.toLowerCase() : `${agent.id}`;
+        const group = groups.get(key);
+        if (group) {
+            group.mailboxes.push(agent);
+            group.description ??= agent.agent_description;
+        }
+        else {
+            groups.set(key, {
+                name: name || NO_AGENT_NAME,
+                key,
+                description: agent.agent_description,
+                mailboxes: [agent],
+            });
+        }
+    }
+    // L'annuaire arrive classé par activité décroissante : l'ordre d'insertion place en tête
+    // l'agent dont une session a bougé le plus récemment, et ses boîtes dans le même ordre.
+    return [...groups.values()];
+}
+/** `boîte — nom · activité` : une ligne par session, l'adresse en tête car c'est elle qu'on copie. */
+function formatMailboxLine(agent) {
+    const seen = agent.last_activity_at ? `last active ${agent.last_activity_at}` : "never active";
+    const flags = agent.registered ? "" : " · never connected";
+    return `  • ${agent.id} — ${agent.display_name ?? "no mailbox name"} · ${seen}${flags}`;
+}
+/**
+ * Rappel joint à toute réponse de l'annuaire.
+ *
+ * Un nom d'agent est celui d'un projet, pas d'une session : plusieurs boîtes le portent, y
+ * compris celle de l'appelant. Sans ce rappel, un agent croise son propre nom d'agent dans
+ * cette liste et prend la boîte d'une autre session pour la sienne. Le groupement rend le
+ * nom encore plus visible que l'adresse : la mise en garde compte d'autant plus.
+ */
+const DIRECTORY_FOOTER = [
+    "Addresses identify sessions; agent names do not. Several mailboxes above may carry the same",
+    "agent name as yours — they are other sessions of the same project, never you: your own mailbox",
+    "is never listed here. Always write to an address taken from this list, never to a name.",
+    "To see what you have already exchanged with one of them, call list_threads with its address in with_agent.",
+];
+function formatDirectory(groups) {
+    const mailboxes = groups.reduce((total, group) => total + group.mailboxes.length, 0);
+    const blocks = groups.map((group) => {
+        const sessions = group.mailboxes.length;
+        const lines = [`${group.name} — ${sessions} session(s)`];
+        if (group.description)
+            lines.push(`  ${group.description}`);
+        // Un agent à sessions nombreuses ne doit pas noyer les autres : les plus récentes
+        // suffisent à écrire, `agent_name` donne le reste à qui en a besoin.
+        const shown = sessions > SESSIONS_SHOWN_PER_AGENT ? group.mailboxes.slice(0, 3) : group.mailboxes;
+        lines.push(...shown.map(formatMailboxLine));
+        if (shown.length < sessions) {
+            lines.push(`  … ${sessions - shown.length} more session(s) — list_agents with agent_name: "${group.name}" lists them all.`);
+        }
+        return lines.join("\n");
+    });
+    // Un agent par bloc, séparés par une ligne vide : le groupe est l'unité de lecture.
+    return [
+        `${groups.length} agent(s), ${mailboxes} mailbox(es):`,
+        "",
+        blocks.join("\n\n"),
+        "",
+        ...DIRECTORY_FOOTER,
+    ].join("\n");
+}
+/** Toutes les sessions d'un agent, décrites une par une : le second niveau de l'annuaire. */
+function formatAgentGroup(groups, requested) {
+    const wanted = requested.trim().toLowerCase();
+    const group = groups.find((g) => g.name.toLowerCase() === wanted);
+    if (!group) {
+        const known = groups.map((g) => g.name).join(", ");
+        throw new Error(`No agent named "${requested}" on this server. Known agent names: ${known}`);
+    }
+    const blocks = group.mailboxes.map((agent) => {
+        const seen = agent.last_activity_at ? `last active ${agent.last_activity_at}` : "never active";
+        return [
+            `• ${agent.id}`,
+            `  Mailbox: ${agent.display_name ?? "not named — this session never said what it works on"}`,
+            agent.description ? `  ${agent.description}` : null,
+            `  ${seen}${agent.registered ? "" : " · never connected"}`,
+        ]
+            .filter(Boolean)
+            .join("\n");
+    });
+    return [
+        `${group.name} — ${group.mailboxes.length} session(s), most recently active first:`,
+        group.description ?? null,
+        "",
+        ...blocks,
+        "",
+        ...DIRECTORY_FOOTER,
+    ]
+        .filter((line) => line !== null)
+        .join("\n");
+}
 async function renameThread(client, threadId, name, description) {
     const thread = await client.setThreadLabel(threadId, { title: name, description });
     return [

package/dist/src/server/app.js

@@ -45,6 +45,7 @@ const threadLabelSchema = z
 });
 const listThreadsQuerySchema = z.object({
     unread_only: z.coerce.boolean().optional(),
+    with_agent: z.string().trim().min(1).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(),
@@ -163,10 +164,10 @@ export function createApp({ store, config }) {
     });
     admin.get("/threads/:id", (req, res) => {
         const threadId = String(req.params.id);
-        const messages = store.listAllMessages({ thread_id: threadId, limit: 100 });
+        const messages = store.listThreadAdmin(threadId);
         if (messages.length === 0)
             throw new MessengerError(`thread not found: ${threadId}`, 404);
-        res.json({ thread_id: threadId, thread: store.getThreadInfo(threadId), messages: messages.slice().reverse() });
+        res.json({ thread_id: threadId, thread: store.getThreadInfo(threadId), messages });
     });
     app.use("/admin", admin);
     // Porte d'entrée de tout le reste : aucune requête n'est servie sans jeton valide. Le

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

@@ -12,6 +12,9 @@ const state = {
   selectedMessageId: null,
   threadId: null,
   threadTitle: null,
+  // Historique déplié ou non sous le message ouvert. En mémoire de page, comme le reste :
+  // rien n'est écrit dans le navigateur, mais le choix tient d'un message à l'autre.
+  historyExpanded: false,
 };
 
 const el = {
@@ -147,14 +150,59 @@ async function openMessage(messageId) {
   state.selectedMessageId = messageId;
   try {
     const message = await api("/admin/messages/" + encodeURIComponent(messageId));
-    renderDetail(message);
+    // Le fil est chargé avec le message : déplier l'historique ne coûte pas d'aller-retour.
+    // Son échec n'empêche pas de lire le message, il ne fait que priver de l'historique.
+    const thread = await api("/admin/threads/" + encodeURIComponent(message.thread_id)).catch(() => null);
+    renderDetail(message, thread);
     await refresh({ keepDetail: true });
   } catch (error) {
     setDetail(node("div", "error", error.message), false);
   }
 }
 
-function renderDetail(message) {
+/**
+ * Les messages du fil antérieurs à celui-ci, du plus récent au plus ancien.
+ *
+ * Un message se lit comme un mail : ce qui l'a précédé l'explique, ce qui l'a suivi appartient
+ * à la suite du fil et se lit dans la vue du fil complet.
+ */
+function earlierMessages(message, thread) {
+  const messages = (thread && thread.messages) || [];
+  const index = messages.findIndex((m) => m.message_id === message.message_id);
+  const earlier = index === -1 ? messages.filter((m) => m.created_at < message.created_at) : messages.slice(0, index);
+  return earlier.slice().reverse();
+}
+
+/** Bouton d'ouverture et bloc cité : replié par défaut, comme le fait une boîte mail. */
+function renderHistory(container, earlier) {
+  if (earlier.length === 0) return;
+  const label = () =>
+    (state.historyExpanded ? "Masquer" : "Afficher") + " les " + earlier.length + " message(s) précédent(s)";
+  const toggle = node("button", "history-toggle", label());
+  const history = node("div", "history");
+  history.hidden = !state.historyExpanded;
+
+  for (const previous of earlier) {
+    const block = node("div", "quoted");
+    block.appendChild(
+      node("div", "quoted-head", previous.from + " → " + (previous.to || "—") + " · " + formatDate(previous.created_at))
+    );
+    block.appendChild(node("div", "quoted-subject", previous.subject));
+    // `body` vient du fil complet ; l'aperçu ne sert que si une réponse ancienne n'en a pas.
+    block.appendChild(node("div", "quoted-body", previous.body || previous.preview || ""));
+    history.appendChild(block);
+  }
+
+  toggle.addEventListener("click", () => {
+    state.historyExpanded = !state.historyExpanded;
+    history.hidden = !state.historyExpanded;
+    toggle.textContent = label();
+  });
+  container.appendChild(toggle);
+  container.appendChild(history);
+}
+
+function renderDetail(message, thread) {
   const container = node("div", "detail");
   container.appendChild(node("h3", null, message.subject));
   container.appendChild(
@@ -176,12 +224,16 @@ function renderDetail(message) {
     )
   );
 
-  const threadButton = node("button", null, "Voir le fil complet");
+  container.appendChild(node("div", "body", message.body));
+
+  // Sous le corps, comme dans une boîte mail : d'abord ce qui a mené à ce message, replié ;
+  // la vue chronologique du fil entier reste une action à part, elle ne se déplie pas ici.
+  renderHistory(container, earlierMessages(message, thread));
+
+  const threadButton = node("button", "thread-link", "Voir le fil complet");
   threadButton.addEventListener("click", () => showThread(message.thread_id));
   container.appendChild(threadButton);
 
-  container.appendChild(node("div", "body", message.body));
-
   const deliveries = node("div", "deliveries");
   deliveries.appendChild(node("h2", null, "Distribution"));
   const list = node("ul");

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

@@ -304,6 +304,46 @@ ul {
   padding-top: 12px;
 }
 
+/* Historique du fil sous le message : discret replié, cité déplié. */
+.detail .history-toggle {
+  margin-top: 14px;
+  color: var(--accent);
+  border-style: dashed;
+}
+
+.detail .history {
+  margin-top: 10px;
+}
+
+/* Bordure d'accent à gauche : la convention du texte cité dans un client mail. */
+.detail .quoted {
+  border-left: 2px solid var(--border);
+  padding: 4px 0 4px 12px;
+  margin-top: 12px;
+  color: var(--muted);
+}
+
+.detail .quoted-head {
+  font-size: 12px;
+  word-break: break-all;
+}
+
+.detail .quoted-subject {
+  font-weight: 600;
+  color: var(--text);
+  margin-top: 2px;
+}
+
+.detail .quoted-body {
+  white-space: pre-wrap;
+  word-wrap: break-word;
+  margin-top: 6px;
+}
+
+.detail .thread-link {
+  margin-top: 14px;
+}
+
 .detail .deliveries {
   margin-top: 16px;
   border-top: 1px solid var(--border);

package/dist/src/version.d.ts

@@ -1 +1 @@
-export declare const APP_VERSION = "1.0.8";
+export declare const APP_VERSION = "1.0.10";

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

package/package.json

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