Historique : plusieurs discussions, et mise à jour par l'image en conteneur

L'amont ne connaît qu'un fil unique (bkChat/conversation) que « clear chat »
effaçait définitivement. On garde toute la machinerie (un seul conv en
mémoire, mêmes flux SSE, même compactage) mais rangée par discussion :

  bkChat/index      liste des discussions (métadonnées seules)
  bkChat/active     discussion ouverte, partagée par tous les appareils
  bkChat/conv:<id>  état complet d'une discussion

Basculer réutilise le mécanisme d'epoch du reset : les abonnés SSE reçoivent
{reset:true} et rejouent le nouveau fil — aucun code de rendu à toucher. Le
fil unique existant est repris comme première discussion au premier
démarrage, et sa clé d'origine est laissée intacte.

- routes /api/conversations (liste, new, switch, rename, delete)
- barre latérale : liste (titre déduit du 1er message, date, nb d'échanges),
  bouton +, renommer, supprimer ; lignes construites en DOM et non en
  innerHTML, les titres venant de messages utilisateur
- suppression de la dernière discussion : convCreate et non convNew, qui
  aurait réenregistré celle qu'on vient d'effacer

Le bouton « Vérifier les mises à jour » répondait « GitHub a répondu 404 » :
il interrogeait les releases du dépôt du fork, qui n'en publie aucune. En
conteneur, remplacer le binaire n'a de toute façon pas de sens — l'UI, l'API
et la CLI renvoient désormais « docker compose pull ».

Vérifié en conteneur : création, bascule, renommage (titre accentué avec
< > &), suppression de l'active puis de la dernière ; /api/update et
loki update renvoient la note Docker.

internal/loki/chat_conversation.go

@@ -71,7 +71,9 @@ var conv = func() *Conversation {
 // LoadConversation recharge l'état persisté au démarrage du process. Sans état
 // enregistré (première fois) on part d'une conversation vide.
 func LoadConversation() {
-	b := getBytes(bkChat, "conversation")
+	// convEnsureActive reprend au passage le fil unique des versions
+	// précédentes (clé « conversation ») comme première discussion.
+	b := getBytes(bkChat, convKey(convEnsureActive()))
 	if len(b) == 0 {
 		return
 	}
@@ -83,16 +85,44 @@ func LoadConversation() {
 	conv.cancel = nil
 }
 
+// loadFrom remplace l'état en mémoire par une autre discussion (b vide = fil
+// neuf) et invalide les abonnés : l'epoch incrémenté leur fait vider l'écran et
+// rejouer depuis zéro, exactement comme un reset. L'appelant NE doit PAS
+// détenir mu.
+func (c *Conversation) loadFrom(b []byte) {
+	c.Stop()
+	c.mu.Lock()
+	c.Messages, c.Log, c.Seq, c.CtxUsed = nil, nil, 0, 0
+	if len(b) > 0 {
+		_ = json.Unmarshal(b, c)
+	}
+	c.Generating = false
+	c.cancel = nil
+	c.epoch++
+	c.cond.Broadcast()
+	c.mu.Unlock()
+}
+
 // persist enregistre l'état (appelé en fin de tour et sur reset, pas à chaque
-// delta). L'appelant NE doit PAS détenir mu.
+// delta) sous la discussion active, et rafraîchit ses métadonnées (titre déduit
+// du premier message, date, nombre d'échanges). L'appelant NE doit PAS détenir mu.
 func (c *Conversation) persist() {
 	c.mu.Lock()
 	b, err := json.Marshal(c)
+	title := convSummary(c.Messages)
+	turns := 0
+	for _, ev := range c.Log {
+		if _, ok := ev.Delta["user"]; ok {
+			turns++
+		}
+	}
 	c.mu.Unlock()
 	if err != nil {
 		return
 	}
-	_ = putBytes(bkChat, "conversation", b)
+	id := convEnsureActive()
+	_ = putBytes(bkChat, convKey(id), b)
+	convTouchMeta(id, title, turns)
 }
 
 // appendDelta journalise un événement d'affichage et réveille les abonnés.