@imenam/mcp-messenger 1.0.14 → 1.0.15

package/README.md

@@ -347,11 +347,16 @@ correspondants et l'état de lecture :
   **toutes ses sessions**, cliquer une boîte sur **cette seule session**. La colonne se
   replie sur les seuls avatars d'agents quand la place manque.
 
-  **Le classement se fait sur la dernière activité, la plus récente en tête** — les
-  sessions au sein d'un agent comme les agents entre eux, un agent héritant de l'activité
-  de sa session la plus vivante. Chaque boîte affiche donc la date qui la classe ; celles
-  qui n'ont jamais rien fait ferment la marche, et deux dates identiques sont départagées
-  par l'adresse pour que l'ordre ne bouge pas d'un rafraîchissement à l'autre ;
+  **Le classement se fait en deux temps : d'abord ce qui a servi, ensuite ce qui est
+  vide ; puis, dans chacun des deux, la dernière activité, la plus récente en tête.** Une
+  boîte est vide tant que rien n'y est passé, ni envoi ni réception — le serveur en alloue
+  une par session ouverte, et beaucoup n'échangeront jamais rien. Ces boîtes-là sont
+  **masquées par défaut**, derrière un bouton en fin de dépli qui dit combien il y en a ;
+  les masquer ne cache jamais de courrier, une boîte sans réception n'ayant par
+  construction aucun non-lu. Un agent dont aucune session n'a rien échangé passe de même
+  derrière les autres. Chaque boîte affiche la date qui la classe, et deux dates
+  identiques sont départagées par l'adresse pour que l'ordre ne bouge pas d'un
+  rafraîchissement à l'autre ;
 - **la liste des fils**, du plus récemment actif au plus ancien, chacun résumé par son
   nom, ses correspondants, son dernier message et sa priorité la plus haute. Trois puces
   la filtrent : tous, non lus, priorité haute ;

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

@@ -33,6 +33,8 @@ const state = {
   selection: { kind: "all", key: null },
   /** Noms d'agents dépliés dans la colonne de gauche. Tout est replié au départ. */
   expanded: new Set(),
+  /** Agents dont on a demandé à voir les boîtes vides. Elles sont cachées au départ. */
+  showEmpty: new Set(),
   /** "all" | "unread" | "high" — les puces au-dessus de la liste des fils. */
   filter: "all",
   search: "",
@@ -287,23 +289,41 @@ function groupByAgent(boxes) {
   for (const box of boxes) {
     const key = box.agent_name || box.id;
     if (!groups.has(key)) {
-      groups.set(key, { key, name: box.agent_name || boxLabel(box), boxes: [], unread: 0, activity: "" });
+      groups.set(key, { key, name: box.agent_name || boxLabel(box), boxes: [], unread: 0, filled: 0, activity: "" });
     }
     const group = groups.get(key);
     group.boxes.push(box);
     group.unread += box.unread;
+    if (!isEmptyBox(box)) group.filled += 1;
     // L'agent hérite de l'activité de sa session la plus vivante.
     if (activityOf(box) > group.activity) group.activity = activityOf(box);
   }
   const list = [...groups.values()];
-  for (const group of list) group.boxes.sort(byActivity);
+  for (const group of list) group.boxes.sort(byBox);
   // Le classement est refait ici plutôt que laissé à l'ordre d'arrivée de l'annuaire :
-  // ce que la colonne promet — le plus récent en tête — ne doit pas dépendre du hasard
-  // d'un tri fait ailleurs.
-  list.sort((a, b) => compareActivity(a.activity, b.activity) || (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+  // ce que la colonne promet ne doit pas dépendre du hasard d'un tri fait ailleurs. Un
+  // agent dont aucune session n'a rien échangé passe derrière les autres, comme ses boîtes.
+  list.sort(
+    (a, b) =>
+      compareEmpty(a.filled === 0, b.filled === 0) ||
+      compareActivity(a.activity, b.activity) ||
+      (a.key < b.key ? -1 : a.key > b.key ? 1 : 0)
+  );
   return list;
 }
 
+/**
+ * Une boîte est vide tant que rien n'y est passé, ni envoi ni réception.
+ *
+ * Le serveur alloue une boîte à chaque session ouverte : beaucoup n'échangeront jamais
+ * rien et n'ont donc rien à dire à qui supervise. Une boîte vide n'a par construction
+ * aucun non-lu — `received` à zéro l'implique — la masquer ne cache donc jamais de
+ * courrier en attente.
+ */
+function isEmptyBox(box) {
+  return box.sent + box.received === 0;
+}
+
 /** Dernière activité d'une boîte, ou chaîne vide quand elle n'a jamais rien fait. */
 function activityOf(box) {
   return box.last_activity_at || "";
@@ -320,9 +340,23 @@ function compareActivity(left, right) {
   return left < right ? 1 : -1;
 }
 
-/** À activité égale, l'adresse départage : deux rendus donnent le même ordre. */
-function byActivity(a, b) {
-  return compareActivity(activityOf(a), activityOf(b)) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+/** Le plein avant le vide. Premier critère du classement, avant même la date. */
+function compareEmpty(left, right) {
+  if (left === right) return 0;
+  return left ? 1 : -1;
+}
+
+/**
+ * Deux classements emboîtés : d'abord les boîtes qui ont servi, puis les vides ; dans
+ * chacun des deux, la plus récemment active en tête. À égalité, l'adresse départage, pour
+ * que l'ordre ne bouge pas d'un rafraîchissement à l'autre.
+ */
+function byBox(a, b) {
+  return (
+    compareEmpty(isEmptyBox(a), isEmptyBox(b)) ||
+    compareActivity(activityOf(a), activityOf(b)) ||
+    (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)
+  );
 }
 
 function isSelected(kind, key) {
@@ -415,12 +449,17 @@ function groupRow(group) {
     )
   );
 
+  const empty = group.boxes.length - group.filled;
+  // Le décompte annonce ce que le dépli va montrer : sans quoi « 5 boîtes » suivi de deux
+  // lignes se lirait comme un bug plutôt que comme des boîtes vides mises de côté.
+  const counts = empty > 0 ? `${plural(group.filled, "boîte")} · ${plural(empty, "vide")}` : plural(group.filled, "boîte");
+
   const text = node("div", "agent-text");
   text.appendChild(node("div", "agent-name", group.name));
-  text.appendChild(node("div", "agent-box", plural(group.boxes.length, "boîte")));
+  text.appendChild(node("div", "agent-box", counts));
   row.appendChild(text);
   if (group.unread > 0) row.appendChild(node("span", "count count--accent", String(group.unread)));
-  row.title = `${group.name} · ${plural(group.boxes.length, "boîte")}`;
+  row.title = `${group.name} · ${counts}`;
   row.addEventListener("click", () => {
     state.expanded.add(group.key);
     select("agent", group.key);
@@ -430,15 +469,37 @@ function groupRow(group) {
 
   if (open) {
     const list = node("ul", "box-list");
-    for (const box of group.boxes) list.appendChild(boxRow(box));
+    // Les vides sont derrière dans `group.boxes` : les montrer, c'est allonger la liste,
+    // jamais en réordonner le début.
+    const revealed = state.showEmpty.has(group.key);
+    for (const box of group.boxes) {
+      if (isEmptyBox(box) && !revealed) continue;
+      list.appendChild(boxRow(box));
+    }
+    if (empty > 0) list.appendChild(emptyToggleRow(group, empty, revealed));
     item.appendChild(list);
   }
   return item;
 }
 
+/** Dernière ligne du dépli : ouvre ou referme les boîtes qui n'ont jamais rien échangé. */
+function emptyToggleRow(group, empty, revealed) {
+  const item = node("li");
+  const what = empty > 1 ? `les ${empty} boîtes vides` : "la boîte vide";
+  const toggle = button("box-empty-toggle", `${revealed ? "Masquer" : "Afficher"} ${what}`, () => {
+    if (revealed) state.showEmpty.delete(group.key);
+    else state.showEmpty.add(group.key);
+    renderAgents({ agents: [...state.directory.values()], threads: currentThreadCount() });
+  });
+  toggle.setAttribute("aria-expanded", revealed ? "true" : "false");
+  item.appendChild(toggle);
+  return item;
+}
+
 function boxRow(box) {
   const item = node("li");
   const classes = ["agent", "box"];
+  if (isEmptyBox(box)) classes.push("is-empty");
   if (isSelected("box", box.id)) classes.push("is-selected");
   if (box.unread > 0) classes.push("has-unread");
   if (!box.registered) classes.push("agent--muted");
@@ -894,6 +955,7 @@ el.logout.addEventListener("click", async () => {
   await fetch("/ui/logout", { method: "POST", credentials: "same-origin" }).catch(() => null);
   state.selection = { kind: "all", key: null };
   state.expanded = new Set();
+  state.showEmpty = new Set();
   state.threadId = null;
   state.messageId = null;
   state.directory = new Map();

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

@@ -577,6 +577,42 @@ body {
   font-size: 11px;
 }
 
+/* Les boîtes vides sont repliées derrière ce bouton : le lien ferme la liste plutôt que
+   d'aligner des sessions qui n'ont jamais rien échangé. */
+.box-empty-toggle {
+  display: block;
+  width: 100%;
+  padding: 6px 10px;
+  border: 0;
+  border-radius: var(--radius);
+  background: none;
+  font: inherit;
+  font-size: 12px;
+  color: var(--muted);
+  text-align: left;
+  cursor: pointer;
+}
+
+.box-empty-toggle:hover {
+  background: var(--border-soft);
+  color: var(--accent);
+}
+
+.box-empty-toggle:focus-visible {
+  outline: 2px solid var(--accent);
+  outline-offset: -2px;
+}
+
+/* Une boîte vide reste lisible mais s'efface : elle est là pour être retrouvée, pas lue. */
+.box.is-empty .agent-name {
+  color: var(--muted);
+  font-weight: 400;
+}
+
+.box.is-empty .avatar {
+  opacity: 0.5;
+}
+
 .agents-foot {
   padding: 16px 20px;
   font-size: 12px;

package/dist/src/version.d.ts

@@ -1 +1 @@
-export declare const APP_VERSION = "1.0.14";
+export declare const APP_VERSION = "1.0.15";

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

package/package.json

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