Presets : modifier le preset en service l'applique aussitôt

CTX passé à 100000 dans l'éditeur, « enregistré »… et la carte du chat
qui affiche toujours 32768. Seul le fichier du preset changeait :
config.env gardait l'ancienne valeur, le moteur tournait avec, et plus
aucun preset n'était détecté actif (empreinte différente). Il fallait
penser à rebasculer dessus à la main.

SavePresetApplying décide AVANT l'écriture si le preset édité est celui
en service (empreinte de l'ancien fichier == configuration courante) ;
si oui, la nouvelle version est installée comme une bascule
(applyPresetFile : réglages machine et moteur préservés) et le service
redémarre en arrière-plan. Un preset inactif ou nouveau reste un simple
fichier. L'UI le dit et rafraîchit l'état — la jauge de contexte suit.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XFhcmBMUXdK6UesdGUgFPH

.github/workflows/docker-publish.yml

@@ -56,5 +56,8 @@ jobs:
             LOKI_VERSION=${{ github.sha }}
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
+          # Le cache de couches réutilise les étapes whisperbuild-* (compilation
+          # whisper.cpp CUDA, ~35 min) tant que leurs lignes du Dockerfile ne
+          # bougent pas : seul le code Go et l'assemblage de l'image se refont.
           cache-from: type=gha
           cache-to: type=gha,mode=max

Dockerfile

@@ -14,6 +14,18 @@
 # Déclaré avant le premier FROM : requis pour être utilisable dans un FROM.
 ARG LLAMACPP_IMAGE=ghcr.io/ggml-org/llama.cpp:server-cuda
 
+# ⚠️ AVANT le premier FROM, obligatoirement. Un ARG posé entre deux étapes
+# appartient à l'étape où il apparaît ; les « ARG WHISPER_CMAKE_FLAGS » nus des
+# étapes whisperbuild-* héritent du scope GLOBAL — c'est-à-dire d'ici. Placé
+# plus bas, ils héritaient d'une valeur VIDE : cmake tournait sans aucun
+# drapeau, ggml se construisait en bibliothèques partagées (échec de lien sur
+# libcuda.so.1) et surtout en -march=native — le SIGILL de la PR #18 revenu en
+# silence. Un test (TestDockerfileArgFlagsGlobal) verrouille cette position.
+ARG WHISPER_CMAKE_FLAGS="-DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF \
+    -DWHISPER_BUILD_TESTS=OFF -DWHISPER_BUILD_EXAMPLES=ON \
+    -DGGML_NATIVE=OFF -DGGML_AVX512=OFF -DGGML_AMX_TILE=OFF \
+    -DGGML_AMX_INT8=OFF -DGGML_AMX_BF16=OFF"
+
 # ── Étape 1 : binaire Go loki ───────────────────────────────────────────
 FROM golang:1.25 AS gobuild
 WORKDIR /src
@@ -50,11 +62,6 @@ RUN GOBIN=/out GOTOOLCHAIN=auto go install golang.org/x/tools/gopls@latest
 # pleine transcription : « AMX is not ready to be used! », puis plus rien,
 # l'interface affichant un échec sans raison. OFF retombe sur la ligne de base
 # AVX2/FMA/F16C de ggml, présente sur tout x86-64 depuis 2013.
-ARG WHISPER_CMAKE_FLAGS="-DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF \
-    -DWHISPER_BUILD_TESTS=OFF -DWHISPER_BUILD_EXAMPLES=ON \
-    -DGGML_NATIVE=OFF -DGGML_AVX512=OFF -DGGML_AMX_TILE=OFF \
-    -DGGML_AMX_INT8=OFF -DGGML_AMX_BF16=OFF"
-
 # Ubuntu 22.04 : glibc plus ancienne que l'image runtime, donc compatible quoi
 # qu'elle embarque.
 FROM ubuntu:22.04 AS whisperbuild-cpu
@@ -62,13 +69,22 @@ ARG WHISPER_CMAKE_FLAGS
 RUN apt-get update && apt-get install -y --no-install-recommends \
         build-essential cmake git ca-certificates \
     && rm -rf /var/lib/apt/lists/*
+# Le grep final vérifie que ggml est bien lié EN STATIQUE : l'image finale ne
+# reçoit que le binaire, une .so ggml manquante ne se verrait qu'au premier
+# clic sur le micro. Des libs partagées ici = drapeaux non transmis.
 RUN git clone --depth 1 https://github.com/ggml-org/whisper.cpp /w \
     && cmake -S /w -B /w/build ${WHISPER_CMAKE_FLAGS} \
-    && cmake --build /w/build -j"$(nproc)" --target whisper-server
+    && cmake --build /w/build -j"$(nproc)" --target whisper-server \
+    && ( ! ldd /w/build/bin/whisper-server | grep -E "libggml|libwhisper" )
 
-# Version CUDA. La MAJEURE de CUDA doit correspondre à celle de l'image
-# runtime : le binaire est lié dynamiquement à libcudart, fournie par
-# LLAMACPP_IMAGE et non par cette étape.
+# Version CUDA : la MÊME que celle de l'image amont (llama.cpp bâtit avec
+# CUDA 12.8.1 sur Ubuntu 24.04). Le binaire est lié dynamiquement à libcudart,
+# fournie par LLAMACPP_IMAGE et non par cette étape.
+#
+# ⚠️ 12.8 est un PLANCHER, pas un détail de version. Les GPU Blackwell
+# (RTX 50xx, sm_120) n'existent pas pour un nvcc 12.4 : il refuse l'archi, et
+# à défaut le binaire ne tourne que par recompilation PTX au chargement, quand
+# elle est possible.
 #
 # ⚠️ -j"$(nproc)" et JAMAIS -j nu. Avec Make, « -j » sans nombre autorise un
 # parallélisme ILLIMITÉ. ggml-cuda compte ~200 fichiers d'instanciation de
@@ -76,15 +92,28 @@ RUN git clone --depth 1 https://github.com/ggml-org/whisper.cpp /w \
 # tué par l'OOM après avoir lancé 92 % des compilations en treize secondes,
 # sans écrire la moindre ligne d'erreur. L'étape CPU y survivait — peu de
 # fichiers, compilation légère — ce qui rendait le piège invisible jusqu'ici.
-FROM nvidia/cuda:12.4.1-devel-ubuntu22.04 AS whisperbuild-cuda
+#
+# CUDA_ARCHS borne le travail : ggml compile sinon pour TOUTES les
+# architectures qu'il connaît, de Maxwell à Blackwell, et chacune multiplie le
+# temps de compilation. La liste par défaut couvre Turing à Blackwell
+# (RTX 20xx → 50xx) ; l'élargir pour un GPU plus ancien se fait sans toucher
+# au fichier : --build-arg CUDA_ARCHS="61;75;86".
+FROM nvidia/cuda:12.8.1-devel-ubuntu24.04 AS whisperbuild-cuda
 ARG WHISPER_CMAKE_FLAGS
+ARG CUDA_ARCHS="75;86;89;120"
 RUN apt-get update && apt-get install -y --no-install-recommends \
         build-essential cmake git ca-certificates \
     && rm -rf /var/lib/apt/lists/*
+# Même vérification statique que l'étape CPU. libcuda.so.1 (le PILOTE) reste
+# elle une dépendance dynamique normale : absente du runner de build, injectée
+# à l'exécution par le NVIDIA Container Toolkit — l'édition de liens la
+# résout via les stubs du toolkit.
 RUN git clone --depth 1 https://github.com/ggml-org/whisper.cpp /w \
     && cmake -S /w -B /w/build ${WHISPER_CMAKE_FLAGS} -DGGML_CUDA=ON \
+         -DCMAKE_CUDA_ARCHITECTURES="${CUDA_ARCHS}" \
     && cmake --build /w/build -j"$(nproc)" --target whisper-server \
-    && strip /w/build/bin/whisper-server
+    && strip /w/build/bin/whisper-server \
+    && ( ! ldd /w/build/bin/whisper-server | grep -E "libggml|libwhisper" )
 
 # ── Étape 2 : runtime sur l'image serveur CUDA officielle ───────────────
 FROM ${LLAMACPP_IMAGE} AS runtime

README.md

@@ -290,6 +290,12 @@ Ajoutées par ce fork :
   latérale s'escamote pour rendre toute la largeur au fil ; les discussions s'y
   cherchent au clavier et les jauges **GPU / VRAM / mémoire vive** restent
   visibles en pied de colonne.
+- **Libérer la VRAM d'un clic** : sur les jauges du moniteur, un bouton décharge
+  le modèle et arrête le moteur (ainsi que le serveur de dictée, qui occupe la
+  carte lui aussi) pour rendre la mémoire vidéo à une autre application — jeu,
+  encodage, autre serveur d'inférence. Le bilan est annoncé en Gio réellement
+  rendus, et le même bouton devient **Recharger le modèle** pour reprendre la
+  main. Routes : `POST /api/vram/unload` et `POST /api/vram/reload`.
 - **API OpenAI servie par Loki** : `/v1/*` est exposé **sur le port de
   l'interface** (8090) et relayé vers llama-server, au lieu d'annoncer l'adresse
   du moteur. Conséquence directe : l'API est joignable partout où l'interface

docker-entrypoint.sh

@@ -18,7 +18,25 @@ fi
 # Le chemin du moteur est imposé par l'image (llama-server précompilé de
 # l'image officielle llama.cpp, dans /app) : on le (re)pose à chaque boot,
 # une mise à jour de l'image ne doit pas laisser un BIN obsolète en base.
-loki config set "BIN=${LOKI_ENGINE_BIN:-/app/llama-server}"
+#
+# SAUF si l'utilisateur a mis le moteur à jour depuis l'interface : celui-là
+# vit sous $LOKI_HOME/engine/<version>/ (volume de données, il survit au
+# conteneur) et c'est lui qu'il a choisi. Le reposer sur /app à chaque
+# redémarrage ramenait silencieusement l'ancien moteur — un modèle qui
+# chargeait la veille ne chargeait plus le lendemain, « unknown model
+# architecture », sans que rien n'ait été touché. On ne le garde que s'il
+# existe encore : un dossier supprimé à la main ne doit pas laisser BIN dans
+# le vide.
+cur=$(loki config get BIN)
+case "$cur" in
+    "$LOKI_HOME"/engine/*/llama-server) [ -x "$cur" ] || cur="" ;;
+    *) cur="" ;;
+esac
+if [ -n "$cur" ]; then
+    echo "[entrypoint] moteur mis à jour conservé : $cur"
+else
+    loki config set "BIN=${LOKI_ENGINE_BIN:-/app/llama-server}"
+fi
 
 # Les autres clés ne sont semées QUE si absentes : ce que l'utilisateur règle
 # ensuite dans l'UI (modèle, contexte…) est conservé d'un redémarrage à l'autre.

internal/loki/backend_models.go

@@ -539,7 +539,11 @@ func dlSourceError(resp *http.Response, dlURL string) error {
 	case 404:
 		switch code {
 		case "EntryNotFound":
-			return fmt.Errorf("fichier absent du dépôt (HTTP 404) — la révision a pu être réécrite depuis que le lien a été copié")
+			// Nommer le fichier : sur un modèle en fragments, c'est souvent UN
+			// fragment qui manque — certains dépôts n'en publient que six sur
+			// sept et livrent la table PLE à part, à lier soi-même — et sans
+			// le nom, on cherche une révision réécrite qui n'existe pas.
+			return fmt.Errorf("fichier %s absent du dépôt (HTTP 404) — dépôt réorganisé depuis la copie du lien, ou fragment jamais publié (table PLE livrée à part ?)", dlFileLabel(dlURL))
 		case "RevisionNotFound":
 			return fmt.Errorf("révision introuvable dans le dépôt (HTTP 404)")
 		}
@@ -555,6 +559,20 @@ func dlSourceError(resp *http.Response, dlURL string) error {
 	return fmt.Errorf("HTTP %d depuis la source", resp.StatusCode)
 }
 
+// dlFileLabel : « nom.gguf » entre guillemets pour un message, ou vide si le
+// lien n'a pas de nom de fichier lisible.
+func dlFileLabel(dlURL string) string {
+	u, err := url.Parse(dlURL)
+	if err != nil {
+		return ""
+	}
+	name := path.Base(u.Path)
+	if name == "" || name == "/" || name == "." {
+		return ""
+	}
+	return "« " + name + " »"
+}
+
 // dlAccessReason nomme la raison du refus. repo vide = source hors Hugging Face
 // (lien direct vers un autre hébergeur) : on ne parle alors pas de conditions à
 // accepter, qui n'existent que là-bas.

internal/loki/backend_models_dl_test.go

@@ -172,7 +172,15 @@ func TestDLSourceErrorExplainsGatedRepo(t *testing.T) {
 		},
 		{
 			name: "fichier absent", resp: resp(404, "EntryNotFound"), url: gated,
-			want: []string{"absent du dépôt", "404"},
+			want: []string{"« m.gguf » absent du dépôt", "404"},
+		},
+		{
+			// Dépôt qui publie six fragments sur sept (table PLE livrée à part) :
+			// le message doit NOMMER le fragment manquant, sinon on cherche une
+			// révision réécrite qui n'existe pas.
+			name: "fragment absent", resp: resp(404, "EntryNotFound"),
+			url:  "https://huggingface.co/x/y-GGUF/resolve/main/Q2_K/y-Q2_K-00007-of-00007.gguf",
+			want: []string{"« y-Q2_K-00007-of-00007.gguf » absent du dépôt", "fragment jamais publié"},
 		},
 		{
 			name: "source hors Hugging Face", resp: resp(403, ""), url: "https://example.com/m.gguf",

internal/loki/backend_presets.go

@@ -225,9 +225,38 @@ func applyPresetFile(target string) error {
 		}
 		next[k] = v
 	}
+	// Le moteur suit la machine, pas le preset (voir presetImposesEngine).
+	if cur["BIN"] != "" && !presetImposesEngine(next["BIN"]) {
+		next["BIN"] = cur["BIN"]
+	}
 	return WriteConfig(next)
 }
 
+// presetImposesEngine : le BIN d'un preset a-t-il son mot à dire ?
+//
+// Le moteur est un réglage de MACHINE. Un preset créé avant une mise à jour du
+// moteur (Réglages → Moteur, qui installe sous $LOKI_HOME/engine/) embarque
+// encore le chemin de l'image, /app/llama-server ; l'appliquer — changer de
+// modèle, une tâche planifiée — ramenait silencieusement ce vieux moteur, et
+// un modèle qui chargeait la veille mourait sur « unknown model architecture »
+// sans qu'aucun réglage visible ait bougé. Le moteur de l'image, un moteur
+// téléchargé par Loki ou un précompilé ne sont donc jamais imposés par un
+// preset : le courant reste.
+//
+// Un backend PERSONNALISÉ (compilé pour un modèle précis, backend_llamacpp.go :
+// « un backend custom se choisit par modèle »), lui, est un vrai choix par
+// modèle : le preset gagne.
+func presetImposesEngine(p string) bool {
+	p = strings.TrimSpace(p)
+	if p == "" || engineOwns(p) || prebuiltOwns(p) {
+		return false
+	}
+	if img := strings.TrimSpace(os.Getenv("LOKI_ENGINE_BIN")); img != "" && samePath(p, img) {
+		return false
+	}
+	return true
+}
+
 // SwitchToPreset installe le preset et redémarre le service. Les réglages
 // « appareil » (preservedKeys) sont conservés à travers la bascule.
 func SwitchToPreset(target string) error {
@@ -287,6 +316,10 @@ func cmdSwitch(args []string) error {
 // mélangeaient donc aux options cochées pour le nouveau, et il fallait penser à
 // tout nettoyer à la main. On repart d'une base vide : les valeurs non
 // renseignées sont les défauts documentés (CTX 32768, NGL 999, BATCH 2048…).
+//
+// BIN n'est repris que s'il désigne un backend personnalisé (presetImposesEngine) :
+// figer /app/llama-server dans chaque preset, c'est ce qui faisait perdre le
+// moteur mis à jour à la première bascule.
 var newPresetSeedKeys = []string{"BIN", "HOST", "PORT"}
 
 // newPresetSeed renvoie la configuration de départ d'un preset créé depuis l'UI.
@@ -294,9 +327,11 @@ func newPresetSeed() map[string]string {
 	cur := ReadConfig()
 	seed := map[string]string{}
 	for _, k := range newPresetSeedKeys {
-		if v := cur[k]; v != "" {
-			seed[k] = v
+		v := cur[k]
+		if v == "" || (k == "BIN" && !presetImposesEngine(v)) {
+			continue
 		}
+		seed[k] = v
 	}
 	return seed
 }
@@ -331,6 +366,41 @@ func SavePreset(id, name, content string) (string, error) {
 	return id, os.WriteFile(p, []byte(content), 0o644)
 }
 
+// SavePresetApplying enregistre un preset et, si c'était celui EN SERVICE,
+// installe aussitôt la nouvelle version comme configuration active (mêmes
+// règles qu'une bascule : applyPresetFile). Renvoie applied=true dans ce cas —
+// l'appelant redémarre alors le moteur.
+//
+// Vécu : CTX passé à 100000 dans l'éditeur, « enregistré »… et la carte du
+// chat qui affiche toujours 32768. Seul le fichier du preset avait changé ;
+// config.env gardait l'ancienne valeur, le moteur tournait avec, et plus aucun
+// preset n'était détecté actif (empreinte différente). Éditer le preset en
+// service, c'est vouloir ces réglages-là tout de suite. Un preset inactif ou
+// nouveau, lui, n'est qu'un fichier : rien ne bouge.
+//
+// « Actif » se décide AVANT l'écriture : c'est l'ancienne version du fichier qui
+// porte l'empreinte de la configuration courante.
+func SavePresetApplying(id, name, content string) (newID string, applied bool, err error) {
+	wasActive := false
+	if id != "" {
+		if old, rerr := ReadPreset(id); rerr == nil {
+			wasActive = presetFingerprint([]byte(old)) == configFingerprint(ReadConfig())
+		}
+	}
+	newID, err = SavePreset(id, name, content)
+	if err != nil || !wasActive {
+		return newID, false, err
+	}
+	p, err := safePresetPath(newID)
+	if err != nil {
+		return newID, false, err
+	}
+	if err := applyPresetFile(p); err != nil {
+		return newID, false, err
+	}
+	return newID, true, nil
+}
+
 // DeletePreset removes a preset by id; refuses if it is the active config.
 func DeletePreset(id string) error {
 	p, err := safePresetPath(id)

internal/loki/backend_presets_test.go

@@ -68,6 +68,64 @@ func TestSwitchToPresetGardeLesReglagesMachine(t *testing.T) {
 	}
 }
 
+// Le moteur suit la machine. Vécu : moteur mis à jour depuis l'interface
+// (BIN → /data/engine/server-cuda-b10680), Qwen3.8-Flash-Next charge ; on
+// change de modèle — le preset, créé avant, porte BIN=/app/llama-server — et
+// le vieux moteur revient : « unknown model architecture: 'qwen4exp' ». Seul
+// un backend personnalisé, choix par modèle, a le droit d'imposer son BIN.
+func TestSwitchToPresetGardeLeMoteur(t *testing.T) {
+	home := testHome(t)
+	t.Setenv("LOKI_ENGINE_BIN", "/app/llama-server")
+	write := func(p, body string) {
+		if err := os.WriteFile(p, []byte(body), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	engine := filepath.Join(home, "engine", "server-cuda-b10680", "llama-server")
+	setConfig(t, "MODEL=ancien.gguf\nBIN="+engine+"\n")
+
+	// Preset d'avant la mise à jour : il porte le moteur de l'image.
+	image := filepath.Join(home, "image.env")
+	write(image, "MODEL=nouveau.gguf\nBIN=/app/llama-server\n")
+	if err := applyPresetFile(image); err != nil {
+		t.Fatal(err)
+	}
+	if got := ReadConfig()["BIN"]; got != engine {
+		t.Errorf("BIN = %q après bascule, attendu le moteur mis à jour %q", got, engine)
+	}
+	// Preset muet sur le moteur : idem.
+	muet := filepath.Join(home, "muet.env")
+	write(muet, "MODEL=autre.gguf\n")
+	if err := applyPresetFile(muet); err != nil {
+		t.Fatal(err)
+	}
+	if got := ReadConfig()["BIN"]; got != engine {
+		t.Errorf("BIN = %q après preset muet, attendu %q conservé", got, engine)
+	}
+	// Backend personnalisé : le preset gagne.
+	custom := filepath.Join(home, "custom.env")
+	write(custom, "MODEL=exotique.gguf\nBIN=/opt/mon-fork/llama-server\n")
+	if err := applyPresetFile(custom); err != nil {
+		t.Fatal(err)
+	}
+	if got := ReadConfig()["BIN"]; got != "/opt/mon-fork/llama-server" {
+		t.Errorf("BIN = %q, attendu le backend personnalisé du preset", got)
+	}
+	// Un nouveau preset ne fige pas ce backend-là… si, justement : c'est un
+	// choix par modèle. Mais il ne fige ni l'image ni un moteur téléchargé.
+	if seed := newPresetSeed(); seed["BIN"] != "/opt/mon-fork/llama-server" {
+		t.Errorf("seed BIN = %q, attendu le backend personnalisé", seed["BIN"])
+	}
+	setConfig(t, "MODEL=ancien.gguf\nBIN="+engine+"\n")
+	if seed := newPresetSeed(); seed["BIN"] != "" {
+		t.Errorf("seed BIN = %q, un moteur téléchargé ne doit pas être figé dans un preset", seed["BIN"])
+	}
+	setConfig(t, "MODEL=ancien.gguf\nBIN=/app/llama-server\n")
+	if seed := newPresetSeed(); seed["BIN"] != "" {
+		t.Errorf("seed BIN = %q, le moteur de l'image ne doit pas être figé dans un preset", seed["BIN"])
+	}
+}
+
 // Un preset qui définit LUI-MÊME la sélection de cartes doit gagner sur celle
 // de la machine : « FABLE 2 GPU » impose CUDA_VISIBLE_DEVICES=1,0 pour que son
 // --tensor-split ait deux cartes. Écraser ça par une sélection mono-GPU faisait
@@ -102,3 +160,54 @@ func TestSwitchToPresetLaisseLePresetImposerSesGPU(t *testing.T) {
 		t.Errorf("WEB_ENGINE = %q, attendu go (réglage machine, jamais dicté par un preset)", cfg["WEB_ENGINE"])
 	}
 }
+
+// Modifier le preset ACTIF doit changer la configuration courante. Vécu : CTX
+// passé à 100000 dans l'éditeur, « enregistré » — et la carte du chat qui
+// affiche toujours 32768, parce que seul le fichier du preset avait bougé ;
+// config.env, lui, gardait l'ancienne valeur et plus aucun preset n'était
+// détecté actif. Un preset qui n'est pas celui en service, ou un preset
+// nouveau, ne touche pas à la configuration.
+func TestModifierLePresetActifLApplique(t *testing.T) {
+	testHome(t)
+	dir := presetsDir()
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	write := func(name, body string) {
+		if err := os.WriteFile(filepath.Join(dir, name+".env"), []byte(body), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	write("actif", "# NAME=Actif\nMODEL=foo.gguf\nCTX=32768\n")
+	write("autre", "# NAME=Autre\nMODEL=bar.gguf\nCTX=4096\n")
+	setConfig(t, "MODEL=foo.gguf\nCTX=32768\nMEM_MODE=always\n")
+
+	// Le preset en service : la config suit, les réglages machine restent.
+	id, applied, err := SavePresetApplying("actif", "Actif", "# NAME=Actif\nMODEL=foo.gguf\nCTX=100000\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if id != "actif" || !applied {
+		t.Fatalf("id=%q applied=%v, attendu actif/true", id, applied)
+	}
+	cfg := ReadConfig()
+	if cfg["CTX"] != "100000" || cfg["MEM_MODE"] != "always" {
+		t.Fatalf("configuration non suivie : %v", cfg)
+	}
+
+	// Un autre preset : le fichier change, la config non.
+	if _, applied, err = SavePresetApplying("autre", "Autre", "# NAME=Autre\nMODEL=bar.gguf\nCTX=8192\n"); err != nil {
+		t.Fatal(err)
+	}
+	if applied || ReadConfig()["CTX"] != "100000" {
+		t.Fatalf("un preset inactif a touché la configuration (applied=%v, CTX=%q)", applied, ReadConfig()["CTX"])
+	}
+
+	// Un preset nouveau : jamais appliqué à la volée.
+	if _, applied, err = SavePresetApplying("", "Neuf", "MODEL=baz.gguf\n"); err != nil {
+		t.Fatal(err)
+	}
+	if applied || ReadConfig()["MODEL"] != "foo.gguf" {
+		t.Fatalf("un preset nouveau a touché la configuration (applied=%v)", applied)
+	}
+}

internal/loki/chat_conversation.go

@@ -216,6 +216,21 @@ func (c *Conversation) compactLogLocked() {
 		bufKey, toks, ts0, seq0 = "", 0, 0, 0
 	}
 	for _, ev := range c.Log {
+		// Outils : un appel s'écrit en de nombreux événements (annonce done=false,
+		// frappe du corps, streaming des arguments) jusqu'au done=true, qui porte
+		// déjà l'état FINAL (résultat + diff). Les intermédiaires ne servent qu'à
+		// l'affichage EN DIRECT ; les garder dans le journal le faisait enfler sur
+		// une conversation agentique (gros write, appels en chaîne) jusqu'à
+		// maxLogEvents → troncature des plus VIEUX événements, donc perte des
+		// premiers messages à l'affichage. On ne conserve donc que le done=true
+		// (même politique que coalesceReplay au replay/export).
+		if tu, ok := ev.Delta["tool_used"].(map[string]any); ok {
+			flush()
+			if done, _ := tu["done"].(bool); done {
+				out = append(out, ev)
+			}
+			continue
+		}
 		key := textKey(ev.Delta)
 		if key == "" {
 			flush()
@@ -777,11 +792,15 @@ func coalesceReplay(events []LogEvent, from int) []map[string]any {
 			continue
 		}
 		_, isTool := ev.Delta["tool_used"].(map[string]any)
-		// Tout événement NON-outil clôt une éventuelle bulle d'outil en attente, pour
-		// préserver l'ordre (l'outil non terminé s'affiche avant ce qui le suit).
-		if !isTool {
-			flushTool()
-		}
+		// ⚠️ On ne « flushe » PAS l'annonce d'outil en attente sur un événement
+		// non-outil. Un appel d'outil s'écrit dans le journal en DEUX temps : une
+		// annonce (done=false, juste « je vais lancer X ») puis le résultat
+		// (done=true). Si un événement non-outil (stats, un bout de raisonnement)
+		// se glisse ENTRE les deux, flusher ici émettait l'annonce PUIS le done →
+		// le même outil apparaissait DEUX fois (à l'export Markdown et au replay).
+		// On garde donc l'annonce en attente : le done la remplace (émis une seule
+		// fois), et si aucun done n'arrive jamais (outil interrompu par un stop),
+		// le flushTool final l'émet une seule fois, en fin de fil.
 		// Delta texte ? (une seule clé content ou reasoning_content, valeur string)
 		key := ""
 		if s, ok := ev.Delta["content"].(string); ok {
@@ -852,6 +871,17 @@ func (c *Conversation) Subscribe(ctx context.Context, from int, emit func(map[st
 	snapshot := append([]LogEvent(nil), c.Log...)
 	epoch := c.epoch
 	c.mu.Unlock()
+	// ⚠️ Garde-fou anti-« premiers messages manquants au changement de session ».
+	// Le client se réabonne avec from=lastSeq (le dernier Seq qu'il a vu). Les Seq
+	// ne sont PAS globaux : ouvrir une session PLUS ANCIENNE charge un journal dont
+	// les Seq sont plus bas. Si le client garde un from élevé (hérité de la session
+	// qu'il quittait) et se reconnecte, coalesceReplay saute tout (Seq <= from) →
+	// la conversation ouverte apparaît tronquée, voire vide. En session normale, le
+	// client ne peut jamais avoir un from SUPÉRIEUR au dernier Seq du journal ; s'il
+	// l'est, son curseur vient d'une autre session → on repart du début.
+	if n := len(snapshot); n > 0 && from > snapshot[n-1].Seq {
+		from = 0
+	}
 	last := from
 	for _, ev := range coalesceReplay(snapshot, from) {
 		if ctx.Err() != nil {

internal/loki/chat_conversation_test.go

@@ -225,3 +225,87 @@ func TestLiveSelectionSurJournalTronque(t *testing.T) {
 	c.appendDelta(c.epoch, map[string]any{"content": "suite"})
 	waitSeq(t, got, 503)
 }
+
+// --- Régressions v0.12.7 : journal d'affichage (outils, replay, changement de session) ---
+
+// compactLogLocked doit coalescer les événements tool_used d'un même appel en un
+// seul (le done=true, qui porte l'état final) : les intermédiaires (annonce, frappe
+// du corps) ne servent qu'à l'affichage en direct et faisaient enfler le journal
+// jusqu'à la troncature des premiers messages.
+func TestCompactLogCoalesceTools(t *testing.T) {
+	c := newTestConv()
+	c.Log = []LogEvent{
+		{Seq: 1, Delta: map[string]any{"user": "édite"}},
+		{Seq: 2, Delta: map[string]any{"tool_used": map[string]any{"name": "edit", "label": "f"}}},
+		{Seq: 3, Delta: map[string]any{"tool_used": map[string]any{"name": "edit", "label": "f", "typing": true, "body": "a"}}},
+		{Seq: 4, Delta: map[string]any{"tool_used": map[string]any{"name": "edit", "label": "f", "result": "ok", "done": true}}},
+		{Seq: 5, Delta: map[string]any{"content": "fini"}},
+	}
+	c.mu.Lock()
+	c.compactLogLocked()
+	c.mu.Unlock()
+	nTool := 0
+	for _, ev := range c.Log {
+		if tu, ok := ev.Delta["tool_used"].(map[string]any); ok {
+			nTool++
+			if done, _ := tu["done"].(bool); !done {
+				t.Error("un tool_used non terminé a survécu à la compaction")
+			}
+		}
+	}
+	if nTool != 1 {
+		t.Fatalf("compactLogLocked garde %d tool_used au lieu de 1", nTool)
+	}
+}
+
+// coalesceReplay ne doit émettre un outil qu'UNE fois même si un événement non-outil
+// (stats, un bout de raisonnement) tombe entre l'annonce (done=false) et le done=true.
+func TestCoalesceReplayNoDoubleTool(t *testing.T) {
+	events := []LogEvent{
+		{Seq: 1, Delta: map[string]any{"tool_used": map[string]any{"name": "bash", "label": "ls"}}},
+		{Seq: 2, Delta: map[string]any{"stats": map[string]any{"gen_tokens": 3}}},
+		{Seq: 3, Delta: map[string]any{"tool_used": map[string]any{"name": "bash", "label": "ls", "result": "x", "done": true}}},
+	}
+	n := 0
+	for _, ev := range coalesceReplay(events, 0) {
+		if _, ok := ev["tool_used"]; ok {
+			n++
+		}
+	}
+	if n != 1 {
+		t.Fatalf("outil émis %d fois au replay (attendu 1)", n)
+	}
+}
+
+// Un abonné qui arrive avec un `from` SUPÉRIEUR au dernier Seq du journal (curseur
+// hérité d'une autre session, plus récente) doit obtenir le fil COMPLET, pas rien :
+// sans ce garde-fou, ouvrir une session plus ancienne la montrait tronquée/vide.
+func TestSubscribeStaleFromCrossSession(t *testing.T) {
+	c := newTestConv()
+	c.appendDelta(c.epoch, map[string]any{"user": "premier message"})
+	c.appendDelta(c.epoch, map[string]any{"content": "réponse"})
+	// Le journal va jusqu'à Seq 2 ; on s'abonne avec from=9999 (curseur d'une autre session).
+	ctx, cancel := context.WithCancel(context.Background())
+	var got []map[string]any
+	done := make(chan struct{})
+	go func() {
+		c.Subscribe(ctx, 9999, func(ev map[string]any) bool {
+			got = append(got, ev)
+			if ev["caught_up"] != nil {
+				cancel()
+			}
+			return true
+		})
+		close(done)
+	}()
+	<-done
+	seen := ""
+	for _, ev := range got {
+		if u, ok := ev["user"].(string); ok {
+			seen += u
+		}
+	}
+	if !strings.Contains(seen, "premier message") {
+		t.Fatalf("le premier message n'a pas été rejoué avec un from périmé (reçu: %q)", seen)
+	}
+}

internal/loki/chat_export.go

@@ -103,12 +103,78 @@ func (c *Conversation) ExportJSON(o exportOpts) ([]byte, error) {
 		Version:    Version,
 		ExportedAt: time.Now().Format(time.RFC3339),
 		CtxUsed:    ctxUsed,
-		Messages:   msgs,
+		Messages:   stripInlineImages(msgs),
 		Log:        filterLog(log, o),
 	}
 	return json.MarshalIndent(p, "", "  ")
 }
 
+// stripInlineImages remplace les images en base64 (data URI) portées par les
+// messages multimodaux (vision : pièces jointes images + outil see_image) par un
+// court marqueur. Sans ça, l'export JSON d'une conversation avec images embarquait
+// plusieurs Mo de base64 par image — un fichier énorme et illisible. Le Markdown,
+// lui, n'était pas concerné : il ne cite que les NOMS de fichiers. Le journal
+// d'affichage non plus (il ne porte pas les images). On ne touche donc qu'ici, et
+// sur une COPIE : les messages appartiennent à la conversation vivante.
+func stripInlineImages(msgs []Message) []Message {
+	out := make([]Message, len(msgs))
+	for i, m := range msgs {
+		out[i] = m
+		out[i].Content = stripInlineImagesValue(m.Content)
+	}
+	return out
+}
+
+func stripInlineImagesValue(v any) any {
+	// Une partie image (format OpenAI) : {"type":"image_url","image_url":{"url":"data:…"}}.
+	// On copie la partie et on élide l'URL data: en gardant l'en-tête (type MIME) lisible.
+	elide := func(part map[string]any) map[string]any {
+		cp := make(map[string]any, len(part))
+		for k, val := range part {
+			cp[k] = val
+		}
+		if iu, ok := cp["image_url"].(map[string]any); ok {
+			c2 := make(map[string]any, len(iu))
+			for k, val := range iu {
+				c2[k] = val
+			}
+			if url, ok := c2["url"].(string); ok && strings.HasPrefix(url, "data:") {
+				c2["url"] = elideDataURI(url)
+			}
+			cp["image_url"] = c2
+		}
+		return cp
+	}
+	switch parts := v.(type) {
+	case []map[string]any: // message fraîchement produit
+		out := make([]map[string]any, len(parts))
+		for i, p := range parts {
+			out[i] = elide(p)
+		}
+		return out
+	case []any: // message relu depuis la base (JSON) : []any de maps
+		out := make([]any, len(parts))
+		for i, p := range parts {
+			if mp, ok := p.(map[string]any); ok {
+				out[i] = elide(mp)
+			} else {
+				out[i] = p
+			}
+		}
+		return out
+	}
+	return v // simple chaîne (cas courant) : rien à faire
+}
+
+// elideDataURI garde l'en-tête « data:<mime>;base64, » (lisible) et remplace le
+// corps base64 par sa taille, pour que l'export reste informatif sans le poids.
+func elideDataURI(url string) string {
+	if i := strings.Index(url, ","); i >= 0 {
+		return url[:i+1] + fmt.Sprintf("<élidé — %s>", humanBytes(int64(len(url)-i-1)))
+	}
+	return "<image élidée>"
+}
+
 // filterLog applique au journal les MÊMES cases que le Markdown. Les deux
 // formats avaient auparavant des options distinctes (le JSON proposait un
 // obscur « journal d'affichage » à la place des trois autres) : personne ne

internal/loki/chat_export_test.go

@@ -258,3 +258,35 @@ func TestCmdExportEcritLeFichier(t *testing.T) {
 		t.Fatal("option inconnue acceptée")
 	}
 }
+
+// L'export JSON d'un message multimodal (vision) doit ÉLIDER le base64 des images :
+// sinon le fichier pesait plusieurs Mo par image. Le Markdown, lui, n'a jamais porté
+// les images (juste les noms de fichiers).
+func TestExportJSONElideImages(t *testing.T) {
+	t.Cleanup(func() { conv.Reset() })
+	big := strings.Repeat("A", 300000)
+	conv.mu.Lock()
+	conv.Messages = []Message{
+		{Role: "user", Content: []map[string]any{
+			{"type": "text", "text": "regarde"},
+			{"type": "image_url", "image_url": map[string]any{"url": "data:image/png;base64," + big}},
+		}},
+		{Role: "assistant", Content: "vu"},
+	}
+	conv.Log = []LogEvent{{Seq: 1, TS: 1, Delta: map[string]any{"user": "regarde"}}}
+	conv.Seq = 1
+	conv.mu.Unlock()
+	b, err := conv.ExportJSON(defaultExportOpts())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(string(b), big) {
+		t.Error("le base64 brut d'une image est encore présent dans le JSON")
+	}
+	if len(b) > 10000 {
+		t.Errorf("JSON toujours énorme malgré l'élision : %d octets", len(b))
+	}
+	if !strings.Contains(string(b), "élidé") {
+		t.Error("marqueur d'élision absent du JSON")
+	}
+}

internal/loki/chat_memory.go

@@ -3,6 +3,7 @@ package loki
 import (
 	"errors"
 	"fmt"
+	"math"
 	"os"
 	"path/filepath"
 	"regexp"
@@ -98,36 +99,93 @@ func MemList() []MemPage {
 // MemSearch cherche les termes de la requête dans le nom + le contenu de chaque
 // page, renvoie une liste classée {fichier, titre, extrait}. Comme un moteur de
 // recherche : à compléter par mem_read sur la page la plus pertinente.
+//
+// Classement en deux temps, pour ne PAS laisser une grosse page bourrée d'un mot
+// fréquent écraser une petite page qui matche VRAIMENT la requête :
+//  1. Couverture d'abord : les pages qui contiennent le PLUS de termes distincts
+//     de la requête passent devant (chercher « copine Nathan » doit remonter la
+//     page qui a les deux mots, pas celle qui répète « Nathan » 40 fois).
+//  2. À couverture égale, score pondéré par la RARETÉ du terme (IDF) : un mot
+//     rare et discriminant (« copine ») pèse bien plus qu'un mot omniprésent
+//     (« Nathan »). La fréquence est amortie (log) pour que le bourrage ne gagne
+//     pas, et un match dans le NOM ou le TITRE est fortement bonifié.
 func MemSearch(query string, limit int) []MemHit {
 	if limit <= 0 || limit > 30 {
 		limit = 8
 	}
-	terms := strings.Fields(strings.ToLower(query))
-	type scored struct {
-		hit   MemHit
-		score int
+	terms := uniqueTerms(strings.ToLower(query))
+
+	type doc struct {
+		p       MemPage
+		name    string // minuscules
+		title   string // minuscules
+		content string // brut (pour l'extrait)
+		hay     string // minuscules : nom + contenu
 	}
-	var ranked []scored
+	docs := make([]doc, 0)
+	df := make(map[string]int) // nb de pages contenant chaque terme
 	for _, p := range MemList() {
 		b, _ := os.ReadFile(filepath.Join(memoryDir(), p.Name))
 		content := string(b)
-		hay := strings.ToLower(p.Name + "\n" + content)
-		score := 0
+		d := doc{
+			p:       p,
+			name:    strings.ToLower(p.Name),
+			title:   strings.ToLower(p.Title),
+			content: content,
+			hay:     strings.ToLower(p.Name + "\n" + content),
+		}
+		docs = append(docs, d)
 		for _, t := range terms {
-			score += strings.Count(hay, t)
-			if strings.Contains(strings.ToLower(p.Name), t) {
-				score += 3 // bonus si le terme est dans le nom de la page
+			if strings.Contains(d.hay, t) {
+				df[t]++
 			}
 		}
-		if score == 0 && query != "" {
+	}
+	n := len(docs)
+
+	type scored struct {
+		hit     MemHit
+		matched int     // termes distincts trouvés (clé de tri primaire)
+		score   float64 // pertinence pondérée (clé secondaire)
+	}
+	var ranked []scored
+	for _, d := range docs {
+		matched := 0
+		score := 0.0
+		for _, t := range terms {
+			cnt := strings.Count(d.hay, t)
+			if cnt == 0 {
+				continue
+			}
+			matched++
+			// IDF : rare = discriminant. +1 pour qu'un terme fréquent compte encore.
+			idf := math.Log(float64(n+1)/float64(df[t]+1)) + 1
+			// Fréquence amortie : 10 occurrences ne valent pas 10x une occurrence.
+			tf := 1.0 + math.Log(float64(cnt))
+			field := 1.0
+			if strings.Contains(d.name, t) {
+				field += 4 // le terme est dans le NOM de la page
+			}
+			if strings.Contains(d.title, t) {
+				field += 2 // ... ou dans son TITRE
+			}
+			score += idf * tf * field
+		}
+		if matched == 0 && len(terms) > 0 {
 			continue
 		}
 		ranked = append(ranked, scored{
-			hit:   MemHit{File: p.Name, Title: p.Title, Snippet: snippetAround(content, terms)},
-			score: score,
+			hit:     MemHit{File: d.p.Name, Title: d.p.Title, Snippet: snippetAround(d.content, terms)},
+			matched: matched,
+			score:   score,
 		})
 	}
-	sort.SliceStable(ranked, func(i, j int) bool { return ranked[i].score > ranked[j].score })
+	sort.SliceStable(ranked, func(i, j int) bool {
+		if ranked[i].matched != ranked[j].matched {
+			return ranked[i].matched > ranked[j].matched // couverture d'abord
+		}
+		return ranked[i].score > ranked[j].score
+	})
 	out := []MemHit{}
 	for i, r := range ranked {
 		if i >= limit {
@@ -138,6 +196,19 @@ func MemSearch(query string, limit int) []MemHit {
 	return out
 }
 
+// uniqueTerms découpe une requête en mots distincts (dédupliqués, ordre gardé).
+func uniqueTerms(q string) []string {
+	seen := map[string]bool{}
+	var out []string
+	for _, t := range strings.Fields(q) {
+		if !seen[t] {
+			seen[t] = true
+			out = append(out, t)
+		}
+	}
+	return out
+}
+
 // snippetAround renvoie un court extrait autour de la 1re occurrence d'un terme.
 func snippetAround(content string, terms []string) string {
 	flat := strings.Join(strings.Fields(content), " ")

internal/loki/chat_memory_test.go

@@ -0,0 +1,50 @@
+package loki
+
+import (
+	"strings"
+	"testing"
+)
+
+// Reproduit le bug rapporté : une petite page dont le NOM et le TITRE contiennent
+// « copine » ne remontait pas pour la requête « copine Nathan », noyée par de
+// grosses pages qui répètent « Nathan » des dizaines de fois. Le classement doit
+// mettre en tête la page qui matche le PLUS de termes distincts (couverture),
+// puis pondérer par la rareté.
+func TestMemSearchCoverageBeatsFrequency(t *testing.T) {
+	testHome(t)
+
+	// Deux pages « bruyantes » bourrées de « Nathan », sans « copine ».
+	if err := MemAdd("business-nathan.md", "# Business Nathan\n"+strings.Repeat("Nathan veut un business. ", 40)); err != nil {
+		t.Fatal(err)
+	}
+	if err := MemAdd("guide-ajean.md", "# Guide AJEAN\n"+strings.Repeat("projet de Nathan. ", 30)); err != nil {
+		t.Fatal(err)
+	}
+	// La petite page cible : matche les DEUX termes de la requête.
+	if err := MemAdd("profil-copine-nathan.md", "# Profil : Copine de Nathan\n- Prénom : Bao\n"); err != nil {
+		t.Fatal(err)
+	}
+
+	hits := MemSearch("copine Nathan", 8)
+	if len(hits) == 0 {
+		t.Fatal("aucun résultat pour « copine Nathan »")
+	}
+	if hits[0].File != "profil-copine-nathan.md" {
+		var names []string
+		for _, h := range hits {
+			names = append(names, h.File)
+		}
+		t.Fatalf("la page copine devrait être 1re (matche les 2 termes), obtenu ordre : %v", names)
+	}
+}
+
+// Une requête mono-terme rare doit privilégier un match dans le nom/titre.
+func TestMemSearchNameTitleBoost(t *testing.T) {
+	testHome(t)
+	_ = MemAdd("notes-diverses.md", "# Notes\nUn jour Bao est passée dire bonjour, puis repartie.\n")
+	_ = MemAdd("profil-copine.md", "# Profil : Copine\n- Prénom : Bao\n")
+	hits := MemSearch("copine", 8)
+	if len(hits) == 0 || hits[0].File != "profil-copine.md" {
+		t.Fatalf("la page dont le nom/titre porte « copine » devrait être 1re, obtenu : %+v", hits)
+	}
+}

internal/loki/dictate_server.go

@@ -21,6 +21,7 @@ import (
 	"strconv"
 	"strings"
 	"sync"
+	"sync/atomic"
 	"time"
 )
 
@@ -170,6 +171,13 @@ const whisperIdle = 10 * time.Minute
 const whisperReady = 120 * time.Second
 
 var wsrvMu sync.Mutex
+
+// wsrvDemarrage : le processus en cours de démarrage, visible SANS le verrou.
+// whisperStartLocked garde wsrvMu pendant tout le chargement du modèle ; c'est
+// la seule poignée qu'un autre appelant (whisperShutdownVite) a sur lui pour
+// l'interrompre. Nil hors démarrage.
+var wsrvDemarrage atomic.Pointer[exec.Cmd]
+
 var wsrv struct {
 	cmd    *exec.Cmd
 	port   int
@@ -231,7 +239,10 @@ func whisperStartLocked(cfg DictateCfg) (int, error) {
 	}
 	wsrv.cmd, wsrv.port, wsrv.cfg = cmd, port, dictateCfgLoad()
 	wsrv.log, wsrv.note, wsrv.depuis = log, note, time.Now()
-	if err := whisperAttendPret(cmd, port, log); err != nil {
+	wsrvDemarrage.Store(cmd)
+	err = whisperAttendPret(cmd, port, log)
+	wsrvDemarrage.Store(nil)
+	if err != nil {
 		whisperStopLocked()
 		return 0, err
 	}
@@ -301,6 +312,30 @@ func whisperShutdown() {
 	whisperStopLocked()
 }
 
+// whisperShutdownVite arrête le serveur sans jamais attendre derrière un
+// démarrage. whisperShutdown prend wsrvMu, et whisperEnsure le garde pendant
+// tout le chargement du modèle — jusqu'à whisperReady (deux minutes) depuis un
+// disque lent. Appelé par un geste de l'interface (libérer la VRAM), ce blocage
+// ferait abandonner le navigateur alors que le moteur, lui, est déjà arrêté.
+//
+// Si le verrou est pris, on tue le processus en train de démarrer : sa mort
+// fait sortir whisperAttendPret, le verrou se libère, et on finit le ménage
+// par la voie normale. La dictée qui attendait reçoit une erreur de démarrage —
+// c'est l'utilisateur qui vient de demander la carte, pas une panne.
+func whisperShutdownVite() {
+	for i := 0; i < 20; i++ {
+		if wsrvMu.TryLock() {
+			whisperStopLocked()
+			wsrvMu.Unlock()
+			return
+		}
+		if cmd := wsrvDemarrage.Load(); cmd != nil && cmd.Process != nil {
+			_ = cmd.Process.Kill()
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+}
+
 // whisperInfer garantit le serveur puis lui soumet le WAV.
 func whisperInfer(ctx context.Context, wav []byte) (string, error) {
 	port, err := whisperEnsure()

internal/loki/ui/index.html

@@ -311,6 +311,10 @@ details>summary::-webkit-details-marker{display:none}
 .preset-add{display:none;font-size:14px;padding:0 8px;margin:0 8px 0 auto;line-height:1.4;background:var(--panel);color:var(--text);border:1px solid var(--border);border-radius:3px;cursor:pointer}
 .preset-add:hover{border-color:var(--accent);color:var(--accent)}
 details[open]>summary>.preset-add{display:inline-block}
+/* Les panneaux de réglages ne sont plus des <details>/<summary> mais des
+   <section class="set-pane"> : sans cette règle, le « + » des Presets restait
+   en display:none et il n'y avait plus aucun moyen d'en créer un. */
+.set-pane-h>.preset-add{display:inline-block}
 .tag{display:inline-block;padding:2px 8px;border-radius:4px;font-size:11px;background:var(--panel);border:1px solid var(--border)}
 .tag.ok{color:var(--ok);border-color:var(--ok)}
 .tag.err{color:var(--err);border-color:var(--err)}
@@ -782,9 +786,6 @@ textarea.sctl{min-height:76px;resize:vertical;line-height:1.5}
 .lc-update-link{color:var(--dim);text-decoration:none;cursor:pointer}
 .lc-update-link:hover{color:var(--accent)}
 /* Choix du moteur dans l'éditeur de modèle (3 options : rapide/optimisé/perso) */
-.be-opts{display:flex;flex-direction:column;gap:7px;margin:6px 0 8px}
-.be-opt{display:flex;align-items:center;gap:8px;font-size:13px;color:var(--text);cursor:pointer}
-.be-opt input{margin:0;flex-shrink:0}
 .be-note{font-size:11px;color:var(--dim);margin-left:auto}
 
 /* ===== Éditeur de preset — listes groupées façon Réglages iOS ======== */
@@ -876,7 +877,6 @@ textarea.sctl{min-height:76px;resize:vertical;line-height:1.5}
 .pe-seg>label{flex:1;text-align:center;font-size:13px;font-weight:500;padding:7px 4px;border-radius:3px;cursor:pointer;color:var(--dim);transition:background .12s,color .12s}
 .pe-seg>label:has(input:checked){background:var(--panel);color:var(--text);box-shadow:0 1px 2px rgba(0,0,0,.22)}
 .pe-seg input{display:none}
-.pe-seg .be-note{display:none}
 .pe-seg-note{font-size:11px;color:var(--dim);padding:0 2px;min-height:14px}
 .pe-note{font-size:11px;color:var(--dim);line-height:1.45}
 /* Barre de progression (téléchargement de modèle). Sans total connu, elle
@@ -1716,6 +1716,16 @@ html[data-files="1"] #files-btn{color:var(--accent)}
 /* --- Moniteur machine (pied de barre latérale) ----------------------- */
 .perf-head{display:flex;align-items:center;gap:8px;margin-bottom:11px;
   font-size:14px;font-weight:600;color:var(--text);letter-spacing:-.01em}
+/* Bouton du moniteur (« Libérer la VRAM » / « Recharger le modèle ») : poussé
+   à droite du titre, discret tant qu'on ne le cherche pas. En mode rechargement
+   il prend la couleur d'accent — le moteur est arrêté, c'est l'action qui
+   compte à ce moment-là. */
+.perf-act{margin-left:auto;flex:none;padding:3px 8px;font-size:11px;line-height:1.4;
+  color:var(--dim);border:1px solid var(--border);border-radius:4px;cursor:pointer;
+  white-space:nowrap}
+.perf-act:hover:not(:disabled){color:var(--text)}
+.perf-act:disabled{opacity:.55;cursor:progress}
+.perf-act.reload{color:var(--accent);border-color:color-mix(in srgb,var(--accent) 45%,transparent)}
 .perf-row{margin:0 0 14px}
 .perf-l{display:flex;align-items:baseline;gap:8px;font-size:12.5px;color:var(--text);margin-bottom:6px}
 .perf-l b{flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;
@@ -2227,7 +2237,11 @@ html[data-files="1"] #files-btn{color:var(--accent)}
        fil. Le détail chiffré (Gio, température) vit sous chaque jauge, et le
        bloc entier se replie d'un clic. -->
   <div id="side-perf">
-    <div class="perf-head"><span>Performance</span></div>
+    <!-- « Libérer la VRAM » est posé LÀ, sur les jauges : c'est en les regardant
+         qu'on décide de rendre la carte à une autre application. Le libellé
+         bascule en « Recharger le modèle » dès que le moteur est arrêté — voir
+         paintVramBtn (js/05-status.js). -->
+    <div class="perf-head"><span>Performance</span><button id="vram-btn" class="perf-act" onclick="vramBtnClick()" title="décharge le modèle et arrête le moteur — la mémoire vidéo repart à la machine">Libérer la VRAM</button></div>
     <div class="perf-body"><div id="vram">…</div><div id="ram-details"><div id="ram"></div></div></div>
   </div>
 </div>
@@ -2331,7 +2345,8 @@ html[data-files="1"] #files-btn{color:var(--accent)}
 <!-- Fichiers : ce qui appartient à la DISCUSSION ouverte — pièces jointes
      déposées, captures, ce que l'agent y a écrit. Panneau de DROITE, symétrique
      des réglages à gauche, ouvert et fermé par le bouton dossier du pied de
-     carte. Il ne se remplit qu'à l'ouverture (loadFiles) — un ReadDir à chaque
+     carte. Il ne se remplit qu'à l'ouverture (loadFiles), puis se redessine seul
+     à chaque résultat d'outil, fin de tour ou dépôt (filesOnActivity) — un ReadDir à chaque
      chargement de page pour un panneau fermé serait payé par tout le monde et
      utile à personne. -->
 <div id="files-backdrop" onclick="toggleFiles()"></div>
@@ -2587,15 +2602,18 @@ html[data-files="1"] #files-btn{color:var(--accent)}
       <pre id="lc-log" hidden></pre>
     </div>
     </div>
-    <!-- Ces trois boutons pilotent le service qui fait tourner llama-server :
-         leur place est ici, avec le moteur, et pas dans une section « Service »
-         à part qui ne contenait qu'eux. -->
-    <div class="subhead">Service du moteur<span class="help" tabindex="0" onclick="event.preventDefault();event.stopPropagation();this.classList.toggle('open')">?<span class="tip">Démarre, redémarre ou arrête <b>llama-server</b> — le processus qui charge le modèle et répond. Un redémarrage recharge le modèle du preset actif (quelques secondes à quelques minutes selon sa taille).</span></span></div>
+    <!-- Ces boutons pilotent le service qui fait tourner llama-server : leur
+         place est ici, avec le moteur, et pas dans une section « Service » à
+         part qui ne contenait qu'eux. Le dernier, « libérer la VRAM », fait
+         plus qu'arrêter : il éteint aussi la dictée et annonce la mémoire
+         vidéo rendue (c'est le même geste que le bouton du moniteur). -->
+    <div class="subhead">Service du moteur<span class="help" tabindex="0" onclick="event.preventDefault();event.stopPropagation();this.classList.toggle('open')">?<span class="tip">Démarre, redémarre ou arrête <b>llama-server</b> — le processus qui charge le modèle et répond. Un redémarrage recharge le modèle du preset actif (quelques secondes à quelques minutes selon sa taille).<br><b>Libérer la VRAM</b> arrête le moteur <i>et</i> la dictée, puis annonce la mémoire vidéo rendue : c'est ce qu'il faut quand une autre application réclame la carte. Le même bouton vit sur les jauges, en pied de barre latérale.</span></span></div>
     <div class="slist"><div class="rowbody">
       <div class="row" style="margin:0">
         <button onclick="act('start')">démarrer</button>
         <button onclick="act('restart')">redémarrer</button>
         <button onclick="act('stop')">arrêter</button>
+        <button onclick="vramUnload(false)" title="décharge le modèle et rend la mémoire vidéo à la machine">libérer la VRAM</button>
       </div>
     </div></div>
   </section>
@@ -3131,31 +3149,10 @@ html[data-files="1"] #files-btn{color:var(--accent)}
           </div>
         </div>
 
-        <div class="pe-group">
-          <div class="pe-gh">Moteur</div>
-          <!-- « Image » n'apparaît qu'en conteneur (moteur fourni), où
-               « Précompilé » et « Compilé » sont au contraire masqués : ils
-               désignent des installations que Loki ne fait pas ici. -->
-          <div class="pe-seg">
-            <label id="be-lab-image" style="display:none"><input type="radio" name="m-be" value="image" onchange="onBackendMode('image')"><span>Image</span><span class="be-note" id="be-image-note"></span></label>
-            <label id="be-lab-fast"><input type="radio" name="m-be" value="fast" onchange="onBackendMode('fast')"><span>Précompilé</span><span class="be-note" id="be-fast-note"></span></label>
-            <label id="be-lab-opt"><input type="radio" name="m-be" value="opt" onchange="onBackendMode('opt')"><span>Compilé</span><span class="be-note" id="be-opt-note"></span></label>
-            <label id="be-lab-custom"><input type="radio" name="m-be" value="custom" onchange="onBackendMode('custom')"><span>Personnalisé</span></label>
-          </div>
-          <div id="m-backend-custom" class="pe-list" style="display:none;margin-top:8px">
-            <div class="pe-row">
-              <span class="pe-row-l">Backend</span>
-              <span class="pe-row-c"><span class="pe-selc"><select id="m-backend-detected" onchange="onPickDetected()"></select></span></span>
-            </div>
-            <div class="pe-row stack">
-              <input id="m-backend-path" class="pe-inp" oninput="onCustomPath()" placeholder="ou un chemin vers llama-server(.exe)">
-              <div class="pe-note" id="be-drop-hint"></div>
-            </div>
-          </div>
-        </div>
-
-        <!-- Cartes graphiques : la liste vient du moteur choisi juste au-dessus,
-             car les noms ET l'ordre dépendent du backend compilé dedans. Le
+        <!-- Cartes graphiques : la liste vient du moteur de la machine (celui de
+             l'image ou celui mis à jour dans Réglages → Moteur — le moteur n'est
+             pas un réglage de preset), car les noms ET l'ordre dépendent du backend
+             compilé dedans. Le
              groupe reste masqué tant qu'on n'a pas AU MOINS DEUX cartes : avec
              une seule, il n'y a rien à arbitrer. -->
         <div class="pe-group" id="m-gpu-group" hidden>
@@ -3701,6 +3698,14 @@ async function loadStatus(){
   el.className='statuspill '+cls;
   el.innerHTML='<span class="dot"></span>'+txt;
   MODEL_READY = !!(s.active && s.health);
+  // Le bouton « Libérer la VRAM » suit l'état RÉEL du moteur (et pas un drapeau
+  // local) : un arrêt venu d'un autre onglet, du terminal ou d'un job doit se
+  // lire ici aussi, sinon le bouton propose de libérer une carte déjà libre.
+  ENGINE_ACTIVE = !!s.active;
+  // Un moteur qui a PLANTÉ au chargement n'est pas « déchargé » : sans ce
+  // drapeau, syncSendBtn proposerait de recharger un modèle qui va replanter.
+  LOAD_ERROR = s.load_error || '';
+  paintVramBtn();
   // Le bouton d'envoi suit l'état du moteur : inutile de pouvoir envoyer un
   // message à un modèle qui n'est pas encore chargé (voir syncSendBtn).
   STATUS_SEEN = true;
@@ -3865,6 +3870,83 @@ async function loadVram(){
       g.name+' · '+vram));
   });
 }
+// ─── Libérer la mémoire vidéo ───────────────────────────────────────────────
+// Tant que le moteur tourne, le modèle occupe la VRAM : une autre application
+// qui réclame la carte (un jeu, un encodage, un autre serveur d'inférence) ne
+// trouve plus rien à prendre. Ce bouton l'en sort, et le MÊME bouton la
+// reprend ensuite — le geste existait déjà (« arrêter » le service, au fond des
+// réglages), mais son nom ne disait pas qu'il rendait la carte.
+//
+// ENGINE_ACTIVE vient de /api/status (relu toutes les 5 s), jamais d'un drapeau
+// posé au clic : sinon un second onglet, ou un arrêt venu du terminal,
+// afficherait un bouton qui ment.
+let ENGINE_ACTIVE = true, VRAM_BUSY = false, LOAD_ERROR = '';
+function paintVramBtn(){
+  const b = document.getElementById('vram-btn');
+  if(!b || VRAM_BUSY) return; // pendant l'opération, le libellé appartient à vramBusy
+  b.disabled = false;
+  b.classList.toggle('reload', !ENGINE_ACTIVE);
+  b.textContent = ENGINE_ACTIVE ? 'Libérer la VRAM' : 'Recharger le modèle';
+  b.title = ENGINE_ACTIVE
+    ? 'décharge le modèle et arrête le moteur — la mémoire vidéo repart à la machine'
+    : 'relance le moteur : le modèle revient en mémoire vidéo';
+}
+function vramBtnClick(){ return ENGINE_ACTIVE ? vramUnload(false) : vramReload(); }
+function vramBusy(on, label){
+  VRAM_BUSY = on;
+  const b = document.getElementById('vram-btn');
+  if(b){ b.disabled = on; if(on && label) b.textContent = label; }
+  if(!on) paintVramBtn();
+}
+// force=true : on a déjà demandé confirmation ET accepté de couper une réponse
+// en cours d'écriture (le serveur refuse sans ça, voir handleVramUnload).
+// Les deux gestes sont exclusifs : un second clic (le bouton des réglages
+// pendant que celui du moniteur travaille) lancerait un « stop » au milieu d'un
+// démarrage, ou l'inverse. VRAM_BUSY tient lieu de verrou.
+async function vramUnload(force){
+  if(VRAM_BUSY) return;
+  if(!force){
+    const ok = await askConfirm(
+      'Décharger le modèle ? Le moteur s\'arrête et rend la mémoire vidéo — le chat reste indisponible jusqu\'au rechargement.',
+      {title:'Libérer la VRAM', okText:'Libérer'});
+    if(!ok) return;
+  }
+  vramBusy(true, 'libération…');
+  let r = null;
+  try{ r = await jpost('/api/vram/unload', {force: !!force}); }catch(_){}
+  // Le serveur dit l'état RÉEL après coup : le repeindre depuis l'ancien
+  // ENGINE_ACTIVE (relu seulement toutes les 5 s) afficherait « Libérer » sur
+  // un moteur déjà arrêté.
+  if(r && typeof r.active === 'boolean') ENGINE_ACTIVE = r.active;
+  vramBusy(false);
+  if(r && r.generating){
+    const ok = await askConfirm('Une réponse est en cours d\'écriture : décharger maintenant l\'interrompt. Continuer ?',
+      {title:'Génération en cours', okText:'Décharger quand même'});
+    if(ok) return vramUnload(true);
+    return;
+  }
+  // La mesure d'abord : la dictée peut avoir rendu de la VRAM alors même que le
+  // moteur était déjà arrêté — annoncer « déjà arrêté » nierait ce qui vient
+  // d'être libéré. Sous quelques dizaines de Mo, c'est le bruit du bureau entre
+  // deux lectures, pas une libération : on ne l'annonce pas.
+  if(!r || !r.ok) toast('échec : ' + ((r && r.error) || 'réseau'));
+  else if(r.gpu && r.freed_mb >= 64) toast('VRAM libérée : ' + fmtMo(r.freed_mb));
+  else if(!r.was_active) toast('le moteur était déjà arrêté');
+  else toast('modèle déchargé');
+  loadAll();
+}
+function fmtMo(mb){ return mb >= 1024 ? (mb/1024).toFixed(1) + ' Gio' : mb + ' Mo'; }
+async function vramReload(){
+  if(VRAM_BUSY) return;
+  vramBusy(true, 'démarrage…');
+  let r = null;
+  try{ r = await jpost('/api/vram/reload', {}); }catch(_){}
+  if(r && r.ok) ENGINE_ACTIVE = true;
+  vramBusy(false);
+  if(!r || !r.ok){ toast('échec : ' + ((r && r.error) || 'réseau')); return; }
+  toast('modèle en cours de chargement…');
+  loadAll();
+}
 async function loadRam(){
   const m=await jget('/api/ram');
   const box=document.getElementById('ram-details');
@@ -4532,7 +4614,7 @@ async function openItem(kind, key){
     document.getElementById('m-quant').value = currentQuantInTextarea();
     populateSettings();
     attachDownload();                      // téléchargement encore en cours côté serveur ?
-    await Promise.all([populateBackend(), populateModelPicker(), populateMmproj(), populateDlDirs()]);
+    await Promise.all([loadGpuDevices(), populateModelPicker(), populateMmproj(), populateDlDirs()]);
     if(seq !== openSeq) return;
   }
   // On lève le voile SANS transition (voir la note dans styles.css), puis on rend
@@ -4804,111 +4886,18 @@ async function populateMmproj(){
   sel.innerHTML = html;
 }
 
-// Choix du moteur PAR MODÈLE : 3 options (précompilé / compilé / personnalisé)
-// qui réécrivent la ligne BIN= du preset. C'est LE point où on décide quel
-// backend fait tourner ce modèle — la barre latérale ne fait qu'installer.
-function currentBinInTextarea(){
-  return readEnvKey(document.getElementById('m-content').value, 'BIN');
-}
 // Compare deux chemins de binaire en neutralisant séparateurs et casse (Windows).
+// Sert à la ligne MOTEUR du panneau d'état (05-status.js).
 function sameBinPath(a, b){
   const n = x => String(x||'').replace(/\\/g,'/').replace(/\/+$/,'').toLowerCase();
   return !!a && !!b && n(a) === n(b);
 }
-// Écrit (ou remplace) la ligne BIN= dans le contenu du preset.
-function setBinInTextarea(val){
-  const ta = document.getElementById('m-content');
-  if(/^\s*BIN\s*=.*$/m.test(ta.value)) ta.value = ta.value.replace(/^\s*BIN\s*=.*$/m, 'BIN="'+val+'"');
-  else ta.value = 'BIN="'+val+'"\n' + ta.value;
-}
-// Le moteur précompilé s'installe dans un dossier versionné (…/llama-b10280/) :
-// le BIN d'un preset écrit avant une mise à jour ne vaut plus le chemin courant,
-// alors qu'il désigne bien ce moteur. On reconnaît donc l'appartenance au
-// dossier, sinon tous les presets retombaient en « personnalisé » à chaque MAJ.
-function underDir(p, dir){
-  const n = x => String(x||'').replace(/\\/g,'/').replace(/\/+$/,'').toLowerCase();
-  return !!p && !!dir && n(p).startsWith(n(dir)+'/');
-}
-let beFastPath = '', beOptPath = '', beFastDir = '', beImagePath = '';
-async function populateBackend(){
-  // Chemins des deux moteurs gérés + liste des backends détectés (dossier loki).
-  let lc = {}; try{ lc = await jget('/api/llamacpp'); }catch(_){}
-  beFastPath = (lc.prebuilt && lc.prebuilt.bin) || '';
-  beFastDir  = (lc.prebuilt && lc.prebuilt.dir) || '';
-  beOptPath  = lc.bin || '';
-  // Conteneur : le moteur vient de l'image. « Précompilé » et « Compilé »
-  // désignent des installations que Loki ne fait pas ici — les proposer ne
-  // menait qu'à « installez d'abord… ». On les remplace par « Image ».
-  beImagePath = lc.provided ? (lc.provided_bin || '') : '';
-  document.getElementById('be-lab-image').style.display = beImagePath ? '' : 'none';
-  document.getElementById('be-lab-fast').style.display  = beImagePath ? 'none' : '';
-  document.getElementById('be-lab-opt').style.display   = beImagePath ? 'none' : '';
-  // En conteneur, « Personnalisé » ne mène nulle part (rien à compiler, et le
-  // moteur se met à jour par la carte Moteur des réglages) : on le retire.
-  document.getElementById('be-lab-custom').style.display = beImagePath ? 'none' : '';
-  document.getElementById('be-image-note').textContent  = beImagePath ? 'llama.cpp officiel' : '';
-  // Menu « backend détecté » du mode personnalisé : tout ce qu'on trouve dans
-  // le dossier backends de loki (l'utilisateur peut y déposer son propre build).
-  const detected = await jget('/api/backends');
-  const sel = document.getElementById('m-backend-detected');
-  let html = '<option value="">— ou choisir un backend détecté —</option>';
-  for(const b of (detected||[])) html += '<option value="'+b.path+'">'+b.name+'</option>';
-  sel.innerHTML = html;
-  document.getElementById('be-drop-hint').textContent = lc.backends_dir
-    ? ('Astuce : déposez votre binaire dans un sous-dossier de '+lc.backends_dir+' pour le voir apparaître ci-dessus.') : '';
-  // Sélectionne l'option correspondant au BIN actuel du preset.
-  const cur = currentBinInTextarea();
-  let mode = 'custom';
-  // Un preset sans BIN hérite du moteur global : en conteneur c'est celui de
-  // l'image, qu'on affiche comme tel plutôt qu'en « personnalisé ». Et comme
-  // l'option Personnalisé n'y est plus proposée, TOUT BIN non reconnu retombe
-  // aussi sur l'image (un vieux preset pointant un chemin mort redevient sain).
-  if(beImagePath && (sameBinPath(cur, beImagePath) || !cur)) mode = 'image';
-  else if(beImagePath) mode = 'image';
-  else if(sameBinPath(cur, beFastPath) || underDir(cur, beFastDir)) mode = 'fast';
-  else if(sameBinPath(cur, beOptPath)) mode = 'opt';
-  const radio = document.querySelector('input[name=m-be][value='+mode+']');
-  if(radio) radio.checked = true;
-  toggleBackendCustom(mode);
-  if(mode === 'custom') document.getElementById('m-backend-path').value = cur;
-  // Attendu (et non lancé dans le vide) : la liste des GPU change la hauteur du
-  // bloc « moteur ». Sans ce await, elle arrivait APRÈS la levée du voile de
-  // chargement et on voyait le bloc bouger tout seul.
-  await loadGpuDevices();
-}
-function toggleBackendCustom(mode){
-  document.getElementById('m-backend-custom').style.display = (mode==='custom') ? 'block' : 'none';
-}
-function onBackendMode(mode){
-  toggleBackendCustom(mode);
-  if(mode === 'image'){
-    if(!beImagePath){ toast('aucun moteur fourni par l\'image'); return; }
-    setBinInTextarea(beImagePath); toast('moteur : llama.cpp de l\'image');
-    loadGpuDevices();
-  } else if(mode === 'fast'){
-    if(!beFastPath){ toast('installez d\'abord llama.cpp précompilé (section MOTEUR)'); return; }
-    setBinInTextarea(beFastPath); toast('moteur : llama.cpp précompilé');
-    loadGpuDevices();
-  } else if(mode === 'opt'){
-    if(!beOptPath){ toast('installez d\'abord llama.cpp compilé (section MOTEUR)'); return; }
-    setBinInTextarea(beOptPath); toast('moteur : llama.cpp compilé');
-    loadGpuDevices();
-  }
-  // custom : on attend que l'utilisateur saisisse un chemin / choisisse un backend
-}
-function onCustomPath(){
-  const v = document.getElementById('m-backend-path').value.trim();
-  if(v){ setBinInTextarea(v); loadGpuDevices(); }
-}
-function onPickDetected(){
-  const v = document.getElementById('m-backend-detected').value;
-  if(!v) return;
-  document.getElementById('m-backend-path').value = v;
-  setBinInTextarea(v); toast('moteur personnalisé');
-  loadGpuDevices();
-}
 
 // --- Cartes graphiques (--device / --tensor-split) --------------------------
+// Le moteur n'est PAS un réglage de preset : c'est celui de la machine (l'image,
+// ou la version mise à jour dans Réglages → Moteur), et applyPresetFile le
+// conserve à la bascule. L'éditeur n'offre donc plus de choix de moteur — il
+// interroge celui qui tourne pour lister les cartes.
 // Ces réglages vivent dans le PRESET, pas dans une variable d'environnement :
 // --device est compris par TOUS les backends (CUDA, Vulkan, ROCm), alors que
 // CUDA_VISIBLE_DEVICES n'a aucun effet sur un moteur Vulkan — d'où des modèles
@@ -4922,14 +4911,18 @@ const GPU_THUMB = 16;
 let gpuDevices = [];
 const gpuCache = {}; // bin -> devices : évite de relancer le moteur à chaque ouverture
 
-// Interroge le moteur du preset (--list-devices) : les noms de device et leur
-// ordre lui appartiennent, une liste issue de nvidia-smi désignerait la mauvaise
-// carte sur un backend Vulkan. Le groupe reste MASQUÉ tant que la réponse n'est
-// pas là, et le reste s'il y a moins de deux cartes : rien à arbitrer, et ça
-// évite un encart qui surgit après coup.
+// Interroge le moteur de la machine (--list-devices) : les noms de device et
+// leur ordre lui appartiennent, une liste issue de nvidia-smi désignerait la
+// mauvaise carte sur un backend Vulkan. Le groupe reste MASQUÉ tant que la
+// réponse n'est pas là, et le reste s'il y a moins de deux cartes : rien à
+// arbitrer, et ça évite un encart qui surgit après coup.
+// Chemin du moteur courant (config_bin de /api/llamacpp), mémorisé au
+// préchauffage : l'éditeur s'en sert sans refaire l'appel.
+let engineBin = '';
 // Remplit le cache sans rien peindre (appelé au chargement de la page pour le
 // moteur actif) : à l'ouverture de l'éditeur, l'encart est déjà prêt.
 async function prefetchGpuDevices(bin){
+  if(bin) engineBin = bin;
   if(!bin || gpuCache[bin]) return;
   try{
     const r = await jpost('/api/backends/devices', {bin});
@@ -4937,16 +4930,24 @@ async function prefetchGpuDevices(bin){
   }catch(_){}
 }
 
+// Moteur courant : ce que le préchauffage a vu, sinon on le demande (éditeur
+// ouvert avant que le statut llama.cpp ne soit arrivé).
+async function currentEngineBin(){
+  if(engineBin) return engineBin;
+  try{ const lc = await jget('/api/llamacpp'); engineBin = lc.config_bin || ''; }catch(_){}
+  return engineBin;
+}
+
 async function loadGpuDevices(){
   const group = document.getElementById('m-gpu-group');
-  const bin = currentBinInTextarea();
+  const bin = await currentEngineBin();
   if(!bin){ group.hidden = true; gpuDevices = []; return; }
   if(gpuCache[bin]){ gpuDevices = gpuCache[bin]; renderGpu(); return; }
   let r = {};
   try{ r = await jpost('/api/backends/devices', {bin}); }catch(_){ r = {ok:false}; }
-  // Le moteur a pu changer pendant l'appel (clic rapide) : on ne peint que si la
-  // réponse concerne toujours le moteur affiché.
-  if(currentBinInTextarea() !== bin) return;
+  // Le moteur a pu changer pendant l'appel (mise à jour en cours) : on ne peint
+  // que si la réponse concerne toujours le moteur courant.
+  if(engineBin !== bin) return;
   gpuDevices = (r.ok && r.devices) ? r.devices : [];
   if(r.ok) gpuCache[bin] = gpuDevices;
   renderGpu();
@@ -5279,6 +5280,21 @@ function closeModal(){ hideModal('modal'); document.getElementById('modal').clas
 async function saveItem(){
   const K = KINDS[editingKind];
   const name = document.getElementById('m-name').value.trim();
+  // Interrupteur « Raisonnement » : on matérialise son état dans le preset AVANT
+  // de lire le contenu. onchange ne part que sur une interaction : un switch
+  // laissé sur off à la création n'écrivait donc jamais REASONING=, et la clé
+  // ABSENTE laisse le moteur raisonner malgré l'interrupteur affiché sur off
+  // (amont, issue #46). Décoché → REASONING=off explicite. Coché → on, sauf si
+  // une valeur active plus précise (auto/deepseek) est déjà là : on la garde.
+  if(editingKind==='preset'){
+    const rsw = document.getElementById('s-reasoning');
+    if(rsw){
+      const cur = cfgReadKey('REASONING');
+      const active = /^(on|1|true|auto|deepseek)$/i.test(cur);
+      if(!rsw.checked){ if(!/^off$/i.test(cur)) cfgWriteKey('REASONING', 'off'); }
+      else if(!active){ cfgWriteKey('REASONING', 'on'); }
+    }
+  }
   const content = document.getElementById('m-content').value;
   if(!name){ toast('nom requis'); return; }
   // Presets: keyed by id (filename); duplicate display names are allowed.
@@ -5288,6 +5304,10 @@ async function saveItem(){
     : {name, old: editingKey, content};
   const r = await jpost(K.saveUrl, payload);
   if(!r.ok){ toast('erreur : ' + (r.error||'')); return; }
+  // Preset EN SERVICE modifié : le serveur l'a réappliqué et relance le moteur
+  // (SavePresetApplying). On le dit, et on rafraîchit l'état global — la carte
+  // du chat doit montrer le nouveau contexte, pas l'ancien.
+  if(r.applied){ toast('enregistré et appliqué — redémarrage…'); closeModal(); K.reload(); if(typeof loadAll==='function') loadAll(); return; }
   toast('enregistré'); closeModal(); K.reload();
 }
 async function delItem(){
@@ -6466,11 +6486,23 @@ function syncSendBtn(){
   // répond pas du tout) — dans le doute on laisse la main.
   const ready = !STATUS_SEEN || MODEL_READY;
   sb.disabled = !ready;
-  sb.title = ready ? '' : 'le modèle n\'est pas encore chargé';
+  // Moteur ARRÊTÉ (VRAM libérée à la demande, ou service coupé) : dire « le
+  // modèle charge » serait faux, et on attendrait un chargement qui ne viendra
+  // jamais. On nomme alors le geste qui remet le modèle en mémoire.
+  // Trois raisons de ne pas être prêt, trois messages : planté au chargement
+  // (recharger ne ferait que replanter — la cause est affichée dans le
+  // moniteur), déchargé à la demande, ou simplement en train de charger.
+  const failed = !ready && !!LOAD_ERROR;
+  const unloaded = !ready && !failed && !ENGINE_ACTIVE;
+  sb.title = ready ? '' : failed ? 'le modèle n\'a pas pu charger — voir l\'erreur dans le moniteur'
+                        : (unloaded ? 'le modèle est déchargé — recharge-le pour écrire'
+                                    : 'le modèle n\'est pas encore chargé');
   const hint=document.getElementById('sendhint');
   if(hint){
     hint.textContent = ready ? 'Entrée pour envoyer · Maj+Entrée = nouvelle ligne'
-                             : 'Le modèle charge — envoi possible dès qu\'il est prêt.';
+                     : failed ? 'Le modèle n\'a pas pu charger — l\'erreur est affichée dans le moniteur, en bas de la barre latérale.'
+                     : unloaded ? 'Modèle déchargé — « Recharger le modèle » dans le moniteur, en bas de la barre latérale.'
+                                : 'Le modèle charge — envoi possible dès qu\'il est prêt.';
     hint.classList.toggle('waiting', !ready);
   }
 }
@@ -6643,7 +6675,8 @@ function handleDelta(d){
     if(T.serverStats) renderStats(T.contentEl||T.reasonEl, T.serverStats);
     else if(T.contentEl) paintStats(T.contentEl);   // sans mesures serveur, la durée reste
     paintTurnClock();                               // fige le total au-dessus de la carte
-    setBusy(false); if(!REPLAYING && typeof loadConversations==='function') loadConversations(); return; }
+    setBusy(false); if(!REPLAYING && typeof loadConversations==='function') loadConversations();
+    if(typeof filesOnActivity==='function') filesOnActivity(); return; }
   if(d.error){ settleBlocks(); removeTyping(); T.contentEl=null; T.reasonEl=null; const eb=addMsg('assistant',''); eb.classList.add('errmsg'); renderBody(eb, d.error); return; }
   if(d.compacting!==undefined){ setCompacting(d.compacting); return; }
   if(d.compacted){ setCompacting(false); addCompactMark(); return; }
@@ -6681,7 +6714,8 @@ function handleDelta(d){
       // Carte à image : retirée de la liste du tour, sinon le repli de fin de
       // tour (collapseAll) la fermerait quand même.
       if(tu.image && T.pendingToolEl){ const i=T.turnCollapsibles.indexOf(T.pendingToolEl); if(i>=0) T.turnCollapsibles.splice(i,1); }
-      T.pendingToolEl=null; if(tu.name==='mem_add'||tu.name==='mem_edit') loadMem(); }
+      T.pendingToolEl=null; if(tu.name==='mem_add'||tu.name==='mem_edit') loadMem();
+      if(typeof filesOnActivity==='function') filesOnActivity(); }
     return; }
   if(d.drop_reasoning){
     smoothReset(); cancelRender(); // le bloc raisonnement disparaît : rien à rendre
@@ -7898,6 +7932,7 @@ window.addEventListener('drop', e=>{
 // rouge, elle dit déjà ce qui s'est passé.
 async function attachPaths(){
   await Promise.all(ATTACH.filter(a=>a.state==='queued').map(uploadAttach));
+  if(typeof filesOnActivity==='function') filesOnActivity(); // les dépôts apparaissent dans le panneau Fichiers
   return ATTACH.filter(a=>a.state==='ok'&&a.path).map(a=>a.path);
 }
 renderAttach();
@@ -8166,6 +8201,21 @@ function filesOnConvChange(){
   if(FILES_OPEN) loadFiles('');
 }
 
+// Quelque chose a pu changer sur disque : un outil vient de rendre son résultat
+// (l'agent écrit un rapport, une capture, un script), le tour est fini, une
+// pièce jointe vient d'être déposée. Le panneau se redessine tout seul —
+// jusqu'ici il fallait cliquer « rafraîchir » pour voir apparaître ce que
+// l'agent venait d'écrire. Regroupé : une rafale d'appels d'outils ne
+// déclenche qu'une lecture. Panneau fermé ou rejeu du journal : rien à faire,
+// l'ouverture recharge de toute façon.
+let filesRefreshT = 0;
+function filesOnActivity(){
+  if(!FILES_OPEN) return;
+  if(typeof REPLAYING !== 'undefined' && REPLAYING) return;
+  clearTimeout(filesRefreshT);
+  filesRefreshT = setTimeout(()=>{ filesRefreshT = 0; loadFiles(); }, 400);
+}
+
 // Date courte : l'heure pour aujourd'hui, la date sinon. Ce qu'on veut savoir,
 // c'est « est-ce que ça vient du tour que je viens de lancer ? ».
 document.addEventListener('DOMContentLoaded', initFiles);

internal/loki/ui/src/index.tmpl.html

@@ -90,7 +90,11 @@ document.documentElement.setAttribute('data-side',localStorage.getItem('loki-sid
        fil. Le détail chiffré (Gio, température) vit sous chaque jauge, et le
        bloc entier se replie d'un clic. -->
   <div id="side-perf">
-    <div class="perf-head"><span>Performance</span></div>
+    <!-- « Libérer la VRAM » est posé LÀ, sur les jauges : c'est en les regardant
+         qu'on décide de rendre la carte à une autre application. Le libellé
+         bascule en « Recharger le modèle » dès que le moteur est arrêté — voir
+         paintVramBtn (js/05-status.js). -->
+    <div class="perf-head"><span>Performance</span><button id="vram-btn" class="perf-act" onclick="vramBtnClick()" title="décharge le modèle et arrête le moteur — la mémoire vidéo repart à la machine">Libérer la VRAM</button></div>
     <div class="perf-body"><div id="vram">…</div><div id="ram-details"><div id="ram"></div></div></div>
   </div>
 </div>
@@ -194,7 +198,8 @@ document.documentElement.setAttribute('data-side',localStorage.getItem('loki-sid
 <!-- Fichiers : ce qui appartient à la DISCUSSION ouverte — pièces jointes
      déposées, captures, ce que l'agent y a écrit. Panneau de DROITE, symétrique
      des réglages à gauche, ouvert et fermé par le bouton dossier du pied de
-     carte. Il ne se remplit qu'à l'ouverture (loadFiles) — un ReadDir à chaque
+     carte. Il ne se remplit qu'à l'ouverture (loadFiles), puis se redessine seul
+     à chaque résultat d'outil, fin de tour ou dépôt (filesOnActivity) — un ReadDir à chaque
      chargement de page pour un panneau fermé serait payé par tout le monde et
      utile à personne. -->
 <div id="files-backdrop" onclick="toggleFiles()"></div>
@@ -450,15 +455,18 @@ document.documentElement.setAttribute('data-side',localStorage.getItem('loki-sid
       <pre id="lc-log" hidden></pre>
     </div>
     </div>
-    <!-- Ces trois boutons pilotent le service qui fait tourner llama-server :
-         leur place est ici, avec le moteur, et pas dans une section « Service »
-         à part qui ne contenait qu'eux. -->
-    <div class="subhead">Service du moteur<span class="help" tabindex="0" onclick="event.preventDefault();event.stopPropagation();this.classList.toggle('open')">?<span class="tip">Démarre, redémarre ou arrête <b>llama-server</b> — le processus qui charge le modèle et répond. Un redémarrage recharge le modèle du preset actif (quelques secondes à quelques minutes selon sa taille).</span></span></div>
+    <!-- Ces boutons pilotent le service qui fait tourner llama-server : leur
+         place est ici, avec le moteur, et pas dans une section « Service » à
+         part qui ne contenait qu'eux. Le dernier, « libérer la VRAM », fait
+         plus qu'arrêter : il éteint aussi la dictée et annonce la mémoire
+         vidéo rendue (c'est le même geste que le bouton du moniteur). -->
+    <div class="subhead">Service du moteur<span class="help" tabindex="0" onclick="event.preventDefault();event.stopPropagation();this.classList.toggle('open')">?<span class="tip">Démarre, redémarre ou arrête <b>llama-server</b> — le processus qui charge le modèle et répond. Un redémarrage recharge le modèle du preset actif (quelques secondes à quelques minutes selon sa taille).<br><b>Libérer la VRAM</b> arrête le moteur <i>et</i> la dictée, puis annonce la mémoire vidéo rendue : c'est ce qu'il faut quand une autre application réclame la carte. Le même bouton vit sur les jauges, en pied de barre latérale.</span></span></div>
     <div class="slist"><div class="rowbody">
       <div class="row" style="margin:0">
         <button onclick="act('start')">démarrer</button>
         <button onclick="act('restart')">redémarrer</button>
         <button onclick="act('stop')">arrêter</button>
+        <button onclick="vramUnload(false)" title="décharge le modèle et rend la mémoire vidéo à la machine">libérer la VRAM</button>
       </div>
     </div></div>
   </section>
@@ -994,31 +1002,10 @@ document.documentElement.setAttribute('data-side',localStorage.getItem('loki-sid
           </div>
         </div>
 
-        <div class="pe-group">
-          <div class="pe-gh">Moteur</div>
-          <!-- « Image » n'apparaît qu'en conteneur (moteur fourni), où
-               « Précompilé » et « Compilé » sont au contraire masqués : ils
-               désignent des installations que Loki ne fait pas ici. -->
-          <div class="pe-seg">
-            <label id="be-lab-image" style="display:none"><input type="radio" name="m-be" value="image" onchange="onBackendMode('image')"><span>Image</span><span class="be-note" id="be-image-note"></span></label>
-            <label id="be-lab-fast"><input type="radio" name="m-be" value="fast" onchange="onBackendMode('fast')"><span>Précompilé</span><span class="be-note" id="be-fast-note"></span></label>
-            <label id="be-lab-opt"><input type="radio" name="m-be" value="opt" onchange="onBackendMode('opt')"><span>Compilé</span><span class="be-note" id="be-opt-note"></span></label>
-            <label id="be-lab-custom"><input type="radio" name="m-be" value="custom" onchange="onBackendMode('custom')"><span>Personnalisé</span></label>
-          </div>
-          <div id="m-backend-custom" class="pe-list" style="display:none;margin-top:8px">
-            <div class="pe-row">
-              <span class="pe-row-l">Backend</span>
-              <span class="pe-row-c"><span class="pe-selc"><select id="m-backend-detected" onchange="onPickDetected()"></select></span></span>
-            </div>
-            <div class="pe-row stack">
-              <input id="m-backend-path" class="pe-inp" oninput="onCustomPath()" placeholder="ou un chemin vers llama-server(.exe)">
-              <div class="pe-note" id="be-drop-hint"></div>
-            </div>
-          </div>
-        </div>
-
-        <!-- Cartes graphiques : la liste vient du moteur choisi juste au-dessus,
-             car les noms ET l'ordre dépendent du backend compilé dedans. Le
+        <!-- Cartes graphiques : la liste vient du moteur de la machine (celui de
+             l'image ou celui mis à jour dans Réglages → Moteur — le moteur n'est
+             pas un réglage de preset), car les noms ET l'ordre dépendent du backend
+             compilé dedans. Le
              groupe reste masqué tant qu'on n'a pas AU MOINS DEUX cartes : avec
              une seule, il n'y a rien à arbitrer. -->
         <div class="pe-group" id="m-gpu-group" hidden>

internal/loki/ui/src/js/05-status.js

@@ -18,6 +18,14 @@ async function loadStatus(){
   el.className='statuspill '+cls;
   el.innerHTML='<span class="dot"></span>'+txt;
   MODEL_READY = !!(s.active && s.health);
+  // Le bouton « Libérer la VRAM » suit l'état RÉEL du moteur (et pas un drapeau
+  // local) : un arrêt venu d'un autre onglet, du terminal ou d'un job doit se
+  // lire ici aussi, sinon le bouton propose de libérer une carte déjà libre.
+  ENGINE_ACTIVE = !!s.active;
+  // Un moteur qui a PLANTÉ au chargement n'est pas « déchargé » : sans ce
+  // drapeau, syncSendBtn proposerait de recharger un modèle qui va replanter.
+  LOAD_ERROR = s.load_error || '';
+  paintVramBtn();
   // Le bouton d'envoi suit l'état du moteur : inutile de pouvoir envoyer un
   // message à un modèle qui n'est pas encore chargé (voir syncSendBtn).
   STATUS_SEEN = true;
@@ -182,6 +190,83 @@ async function loadVram(){
       g.name+' · '+vram));
   });
 }
+// ─── Libérer la mémoire vidéo ───────────────────────────────────────────────
+// Tant que le moteur tourne, le modèle occupe la VRAM : une autre application
+// qui réclame la carte (un jeu, un encodage, un autre serveur d'inférence) ne
+// trouve plus rien à prendre. Ce bouton l'en sort, et le MÊME bouton la
+// reprend ensuite — le geste existait déjà (« arrêter » le service, au fond des
+// réglages), mais son nom ne disait pas qu'il rendait la carte.
+//
+// ENGINE_ACTIVE vient de /api/status (relu toutes les 5 s), jamais d'un drapeau
+// posé au clic : sinon un second onglet, ou un arrêt venu du terminal,
+// afficherait un bouton qui ment.
+let ENGINE_ACTIVE = true, VRAM_BUSY = false, LOAD_ERROR = '';
+function paintVramBtn(){
+  const b = document.getElementById('vram-btn');
+  if(!b || VRAM_BUSY) return; // pendant l'opération, le libellé appartient à vramBusy
+  b.disabled = false;
+  b.classList.toggle('reload', !ENGINE_ACTIVE);
+  b.textContent = ENGINE_ACTIVE ? 'Libérer la VRAM' : 'Recharger le modèle';
+  b.title = ENGINE_ACTIVE
+    ? 'décharge le modèle et arrête le moteur — la mémoire vidéo repart à la machine'
+    : 'relance le moteur : le modèle revient en mémoire vidéo';
+}
+function vramBtnClick(){ return ENGINE_ACTIVE ? vramUnload(false) : vramReload(); }
+function vramBusy(on, label){
+  VRAM_BUSY = on;
+  const b = document.getElementById('vram-btn');
+  if(b){ b.disabled = on; if(on && label) b.textContent = label; }
+  if(!on) paintVramBtn();
+}
+// force=true : on a déjà demandé confirmation ET accepté de couper une réponse
+// en cours d'écriture (le serveur refuse sans ça, voir handleVramUnload).
+// Les deux gestes sont exclusifs : un second clic (le bouton des réglages
+// pendant que celui du moniteur travaille) lancerait un « stop » au milieu d'un
+// démarrage, ou l'inverse. VRAM_BUSY tient lieu de verrou.
+async function vramUnload(force){
+  if(VRAM_BUSY) return;
+  if(!force){
+    const ok = await askConfirm(
+      'Décharger le modèle ? Le moteur s\'arrête et rend la mémoire vidéo — le chat reste indisponible jusqu\'au rechargement.',
+      {title:'Libérer la VRAM', okText:'Libérer'});
+    if(!ok) return;
+  }
+  vramBusy(true, 'libération…');
+  let r = null;
+  try{ r = await jpost('/api/vram/unload', {force: !!force}); }catch(_){}
+  // Le serveur dit l'état RÉEL après coup : le repeindre depuis l'ancien
+  // ENGINE_ACTIVE (relu seulement toutes les 5 s) afficherait « Libérer » sur
+  // un moteur déjà arrêté.
+  if(r && typeof r.active === 'boolean') ENGINE_ACTIVE = r.active;
+  vramBusy(false);
+  if(r && r.generating){
+    const ok = await askConfirm('Une réponse est en cours d\'écriture : décharger maintenant l\'interrompt. Continuer ?',
+      {title:'Génération en cours', okText:'Décharger quand même'});
+    if(ok) return vramUnload(true);
+    return;
+  }
+  // La mesure d'abord : la dictée peut avoir rendu de la VRAM alors même que le
+  // moteur était déjà arrêté — annoncer « déjà arrêté » nierait ce qui vient
+  // d'être libéré. Sous quelques dizaines de Mo, c'est le bruit du bureau entre
+  // deux lectures, pas une libération : on ne l'annonce pas.
+  if(!r || !r.ok) toast('échec : ' + ((r && r.error) || 'réseau'));
+  else if(r.gpu && r.freed_mb >= 64) toast('VRAM libérée : ' + fmtMo(r.freed_mb));
+  else if(!r.was_active) toast('le moteur était déjà arrêté');
+  else toast('modèle déchargé');
+  loadAll();
+}
+function fmtMo(mb){ return mb >= 1024 ? (mb/1024).toFixed(1) + ' Gio' : mb + ' Mo'; }
+async function vramReload(){
+  if(VRAM_BUSY) return;
+  vramBusy(true, 'démarrage…');
+  let r = null;
+  try{ r = await jpost('/api/vram/reload', {}); }catch(_){}
+  if(r && r.ok) ENGINE_ACTIVE = true;
+  vramBusy(false);
+  if(!r || !r.ok){ toast('échec : ' + ((r && r.error) || 'réseau')); return; }
+  toast('modèle en cours de chargement…');
+  loadAll();
+}
 async function loadRam(){
   const m=await jget('/api/ram');
   const box=document.getElementById('ram-details');

internal/loki/ui/src/js/07-models.js

@@ -161,7 +161,7 @@ async function openItem(kind, key){
     document.getElementById('m-quant').value = currentQuantInTextarea();
     populateSettings();
     attachDownload();                      // téléchargement encore en cours côté serveur ?
-    await Promise.all([populateBackend(), populateModelPicker(), populateMmproj(), populateDlDirs()]);
+    await Promise.all([loadGpuDevices(), populateModelPicker(), populateMmproj(), populateDlDirs()]);
     if(seq !== openSeq) return;
   }
   // On lève le voile SANS transition (voir la note dans styles.css), puis on rend
@@ -433,111 +433,18 @@ async function populateMmproj(){
   sel.innerHTML = html;
 }
 
-// Choix du moteur PAR MODÈLE : 3 options (précompilé / compilé / personnalisé)
-// qui réécrivent la ligne BIN= du preset. C'est LE point où on décide quel
-// backend fait tourner ce modèle — la barre latérale ne fait qu'installer.
-function currentBinInTextarea(){
-  return readEnvKey(document.getElementById('m-content').value, 'BIN');
-}
 // Compare deux chemins de binaire en neutralisant séparateurs et casse (Windows).
+// Sert à la ligne MOTEUR du panneau d'état (05-status.js).
 function sameBinPath(a, b){
   const n = x => String(x||'').replace(/\\/g,'/').replace(/\/+$/,'').toLowerCase();
   return !!a && !!b && n(a) === n(b);
 }
-// Écrit (ou remplace) la ligne BIN= dans le contenu du preset.
-function setBinInTextarea(val){
-  const ta = document.getElementById('m-content');
-  if(/^\s*BIN\s*=.*$/m.test(ta.value)) ta.value = ta.value.replace(/^\s*BIN\s*=.*$/m, 'BIN="'+val+'"');
-  else ta.value = 'BIN="'+val+'"\n' + ta.value;
-}
-// Le moteur précompilé s'installe dans un dossier versionné (…/llama-b10280/) :
-// le BIN d'un preset écrit avant une mise à jour ne vaut plus le chemin courant,
-// alors qu'il désigne bien ce moteur. On reconnaît donc l'appartenance au
-// dossier, sinon tous les presets retombaient en « personnalisé » à chaque MAJ.
-function underDir(p, dir){
-  const n = x => String(x||'').replace(/\\/g,'/').replace(/\/+$/,'').toLowerCase();
-  return !!p && !!dir && n(p).startsWith(n(dir)+'/');
-}
-let beFastPath = '', beOptPath = '', beFastDir = '', beImagePath = '';
-async function populateBackend(){
-  // Chemins des deux moteurs gérés + liste des backends détectés (dossier loki).
-  let lc = {}; try{ lc = await jget('/api/llamacpp'); }catch(_){}
-  beFastPath = (lc.prebuilt && lc.prebuilt.bin) || '';
-  beFastDir  = (lc.prebuilt && lc.prebuilt.dir) || '';
-  beOptPath  = lc.bin || '';
-  // Conteneur : le moteur vient de l'image. « Précompilé » et « Compilé »
-  // désignent des installations que Loki ne fait pas ici — les proposer ne
-  // menait qu'à « installez d'abord… ». On les remplace par « Image ».
-  beImagePath = lc.provided ? (lc.provided_bin || '') : '';
-  document.getElementById('be-lab-image').style.display = beImagePath ? '' : 'none';
-  document.getElementById('be-lab-fast').style.display  = beImagePath ? 'none' : '';
-  document.getElementById('be-lab-opt').style.display   = beImagePath ? 'none' : '';
-  // En conteneur, « Personnalisé » ne mène nulle part (rien à compiler, et le
-  // moteur se met à jour par la carte Moteur des réglages) : on le retire.
-  document.getElementById('be-lab-custom').style.display = beImagePath ? 'none' : '';
-  document.getElementById('be-image-note').textContent  = beImagePath ? 'llama.cpp officiel' : '';
-  // Menu « backend détecté » du mode personnalisé : tout ce qu'on trouve dans
-  // le dossier backends de loki (l'utilisateur peut y déposer son propre build).
-  const detected = await jget('/api/backends');
-  const sel = document.getElementById('m-backend-detected');
-  let html = '<option value="">— ou choisir un backend détecté —</option>';
-  for(const b of (detected||[])) html += '<option value="'+b.path+'">'+b.name+'</option>';
-  sel.innerHTML = html;
-  document.getElementById('be-drop-hint').textContent = lc.backends_dir
-    ? ('Astuce : déposez votre binaire dans un sous-dossier de '+lc.backends_dir+' pour le voir apparaître ci-dessus.') : '';
-  // Sélectionne l'option correspondant au BIN actuel du preset.
-  const cur = currentBinInTextarea();
-  let mode = 'custom';
-  // Un preset sans BIN hérite du moteur global : en conteneur c'est celui de
-  // l'image, qu'on affiche comme tel plutôt qu'en « personnalisé ». Et comme
-  // l'option Personnalisé n'y est plus proposée, TOUT BIN non reconnu retombe
-  // aussi sur l'image (un vieux preset pointant un chemin mort redevient sain).
-  if(beImagePath && (sameBinPath(cur, beImagePath) || !cur)) mode = 'image';
-  else if(beImagePath) mode = 'image';
-  else if(sameBinPath(cur, beFastPath) || underDir(cur, beFastDir)) mode = 'fast';
-  else if(sameBinPath(cur, beOptPath)) mode = 'opt';
-  const radio = document.querySelector('input[name=m-be][value='+mode+']');
-  if(radio) radio.checked = true;
-  toggleBackendCustom(mode);
-  if(mode === 'custom') document.getElementById('m-backend-path').value = cur;
-  // Attendu (et non lancé dans le vide) : la liste des GPU change la hauteur du
-  // bloc « moteur ». Sans ce await, elle arrivait APRÈS la levée du voile de
-  // chargement et on voyait le bloc bouger tout seul.
-  await loadGpuDevices();
-}
-function toggleBackendCustom(mode){
-  document.getElementById('m-backend-custom').style.display = (mode==='custom') ? 'block' : 'none';
-}
-function onBackendMode(mode){
-  toggleBackendCustom(mode);
-  if(mode === 'image'){
-    if(!beImagePath){ toast('aucun moteur fourni par l\'image'); return; }
-    setBinInTextarea(beImagePath); toast('moteur : llama.cpp de l\'image');
-    loadGpuDevices();
-  } else if(mode === 'fast'){
-    if(!beFastPath){ toast('installez d\'abord llama.cpp précompilé (section MOTEUR)'); return; }
-    setBinInTextarea(beFastPath); toast('moteur : llama.cpp précompilé');
-    loadGpuDevices();
-  } else if(mode === 'opt'){
-    if(!beOptPath){ toast('installez d\'abord llama.cpp compilé (section MOTEUR)'); return; }
-    setBinInTextarea(beOptPath); toast('moteur : llama.cpp compilé');
-    loadGpuDevices();
-  }
-  // custom : on attend que l'utilisateur saisisse un chemin / choisisse un backend
-}
-function onCustomPath(){
-  const v = document.getElementById('m-backend-path').value.trim();
-  if(v){ setBinInTextarea(v); loadGpuDevices(); }
-}
-function onPickDetected(){
-  const v = document.getElementById('m-backend-detected').value;
-  if(!v) return;
-  document.getElementById('m-backend-path').value = v;
-  setBinInTextarea(v); toast('moteur personnalisé');
-  loadGpuDevices();
-}
 
 // --- Cartes graphiques (--device / --tensor-split) --------------------------
+// Le moteur n'est PAS un réglage de preset : c'est celui de la machine (l'image,
+// ou la version mise à jour dans Réglages → Moteur), et applyPresetFile le
+// conserve à la bascule. L'éditeur n'offre donc plus de choix de moteur — il
+// interroge celui qui tourne pour lister les cartes.
 // Ces réglages vivent dans le PRESET, pas dans une variable d'environnement :
 // --device est compris par TOUS les backends (CUDA, Vulkan, ROCm), alors que
 // CUDA_VISIBLE_DEVICES n'a aucun effet sur un moteur Vulkan — d'où des modèles
@@ -551,14 +458,18 @@ const GPU_THUMB = 16;
 let gpuDevices = [];
 const gpuCache = {}; // bin -> devices : évite de relancer le moteur à chaque ouverture
 
-// Interroge le moteur du preset (--list-devices) : les noms de device et leur
-// ordre lui appartiennent, une liste issue de nvidia-smi désignerait la mauvaise
-// carte sur un backend Vulkan. Le groupe reste MASQUÉ tant que la réponse n'est
-// pas là, et le reste s'il y a moins de deux cartes : rien à arbitrer, et ça
-// évite un encart qui surgit après coup.
+// Interroge le moteur de la machine (--list-devices) : les noms de device et
+// leur ordre lui appartiennent, une liste issue de nvidia-smi désignerait la
+// mauvaise carte sur un backend Vulkan. Le groupe reste MASQUÉ tant que la
+// réponse n'est pas là, et le reste s'il y a moins de deux cartes : rien à
+// arbitrer, et ça évite un encart qui surgit après coup.
+// Chemin du moteur courant (config_bin de /api/llamacpp), mémorisé au
+// préchauffage : l'éditeur s'en sert sans refaire l'appel.
+let engineBin = '';
 // Remplit le cache sans rien peindre (appelé au chargement de la page pour le
 // moteur actif) : à l'ouverture de l'éditeur, l'encart est déjà prêt.
 async function prefetchGpuDevices(bin){
+  if(bin) engineBin = bin;
   if(!bin || gpuCache[bin]) return;
   try{
     const r = await jpost('/api/backends/devices', {bin});
@@ -566,16 +477,24 @@ async function prefetchGpuDevices(bin){
   }catch(_){}
 }
 
+// Moteur courant : ce que le préchauffage a vu, sinon on le demande (éditeur
+// ouvert avant que le statut llama.cpp ne soit arrivé).
+async function currentEngineBin(){
+  if(engineBin) return engineBin;
+  try{ const lc = await jget('/api/llamacpp'); engineBin = lc.config_bin || ''; }catch(_){}
+  return engineBin;
+}
+
 async function loadGpuDevices(){
   const group = document.getElementById('m-gpu-group');
-  const bin = currentBinInTextarea();
+  const bin = await currentEngineBin();
   if(!bin){ group.hidden = true; gpuDevices = []; return; }
   if(gpuCache[bin]){ gpuDevices = gpuCache[bin]; renderGpu(); return; }
   let r = {};
   try{ r = await jpost('/api/backends/devices', {bin}); }catch(_){ r = {ok:false}; }
-  // Le moteur a pu changer pendant l'appel (clic rapide) : on ne peint que si la
-  // réponse concerne toujours le moteur affiché.
-  if(currentBinInTextarea() !== bin) return;
+  // Le moteur a pu changer pendant l'appel (mise à jour en cours) : on ne peint
+  // que si la réponse concerne toujours le moteur courant.
+  if(engineBin !== bin) return;
   gpuDevices = (r.ok && r.devices) ? r.devices : [];
   if(r.ok) gpuCache[bin] = gpuDevices;
   renderGpu();
@@ -908,6 +827,21 @@ function closeModal(){ hideModal('modal'); document.getElementById('modal').clas
 async function saveItem(){
   const K = KINDS[editingKind];
   const name = document.getElementById('m-name').value.trim();
+  // Interrupteur « Raisonnement » : on matérialise son état dans le preset AVANT
+  // de lire le contenu. onchange ne part que sur une interaction : un switch
+  // laissé sur off à la création n'écrivait donc jamais REASONING=, et la clé
+  // ABSENTE laisse le moteur raisonner malgré l'interrupteur affiché sur off
+  // (amont, issue #46). Décoché → REASONING=off explicite. Coché → on, sauf si
+  // une valeur active plus précise (auto/deepseek) est déjà là : on la garde.
+  if(editingKind==='preset'){
+    const rsw = document.getElementById('s-reasoning');
+    if(rsw){
+      const cur = cfgReadKey('REASONING');
+      const active = /^(on|1|true|auto|deepseek)$/i.test(cur);
+      if(!rsw.checked){ if(!/^off$/i.test(cur)) cfgWriteKey('REASONING', 'off'); }
+      else if(!active){ cfgWriteKey('REASONING', 'on'); }
+    }
+  }
   const content = document.getElementById('m-content').value;
   if(!name){ toast('nom requis'); return; }
   // Presets: keyed by id (filename); duplicate display names are allowed.
@@ -917,6 +851,10 @@ async function saveItem(){
     : {name, old: editingKey, content};
   const r = await jpost(K.saveUrl, payload);
   if(!r.ok){ toast('erreur : ' + (r.error||'')); return; }
+  // Preset EN SERVICE modifié : le serveur l'a réappliqué et relance le moteur
+  // (SavePresetApplying). On le dit, et on rafraîchit l'état global — la carte
+  // du chat doit montrer le nouveau contexte, pas l'ancien.
+  if(r.applied){ toast('enregistré et appliqué — redémarrage…'); closeModal(); K.reload(); if(typeof loadAll==='function') loadAll(); return; }
   toast('enregistré'); closeModal(); K.reload();
 }
 async function delItem(){

internal/loki/ui/src/js/09-stream.js

@@ -277,11 +277,23 @@ function syncSendBtn(){
   // répond pas du tout) — dans le doute on laisse la main.
   const ready = !STATUS_SEEN || MODEL_READY;
   sb.disabled = !ready;
-  sb.title = ready ? '' : 'le modèle n\'est pas encore chargé';
+  // Moteur ARRÊTÉ (VRAM libérée à la demande, ou service coupé) : dire « le
+  // modèle charge » serait faux, et on attendrait un chargement qui ne viendra
+  // jamais. On nomme alors le geste qui remet le modèle en mémoire.
+  // Trois raisons de ne pas être prêt, trois messages : planté au chargement
+  // (recharger ne ferait que replanter — la cause est affichée dans le
+  // moniteur), déchargé à la demande, ou simplement en train de charger.
+  const failed = !ready && !!LOAD_ERROR;
+  const unloaded = !ready && !failed && !ENGINE_ACTIVE;
+  sb.title = ready ? '' : failed ? 'le modèle n\'a pas pu charger — voir l\'erreur dans le moniteur'
+                        : (unloaded ? 'le modèle est déchargé — recharge-le pour écrire'
+                                    : 'le modèle n\'est pas encore chargé');
   const hint=document.getElementById('sendhint');
   if(hint){
     hint.textContent = ready ? 'Entrée pour envoyer · Maj+Entrée = nouvelle ligne'
-                             : 'Le modèle charge — envoi possible dès qu\'il est prêt.';
+                     : failed ? 'Le modèle n\'a pas pu charger — l\'erreur est affichée dans le moniteur, en bas de la barre latérale.'
+                     : unloaded ? 'Modèle déchargé — « Recharger le modèle » dans le moniteur, en bas de la barre latérale.'
+                                : 'Le modèle charge — envoi possible dès qu\'il est prêt.';
     hint.classList.toggle('waiting', !ready);
   }
 }
@@ -454,7 +466,8 @@ function handleDelta(d){
     if(T.serverStats) renderStats(T.contentEl||T.reasonEl, T.serverStats);
     else if(T.contentEl) paintStats(T.contentEl);   // sans mesures serveur, la durée reste
     paintTurnClock();                               // fige le total au-dessus de la carte
-    setBusy(false); if(!REPLAYING && typeof loadConversations==='function') loadConversations(); return; }
+    setBusy(false); if(!REPLAYING && typeof loadConversations==='function') loadConversations();
+    if(typeof filesOnActivity==='function') filesOnActivity(); return; }
   if(d.error){ settleBlocks(); removeTyping(); T.contentEl=null; T.reasonEl=null; const eb=addMsg('assistant',''); eb.classList.add('errmsg'); renderBody(eb, d.error); return; }
   if(d.compacting!==undefined){ setCompacting(d.compacting); return; }
   if(d.compacted){ setCompacting(false); addCompactMark(); return; }
@@ -492,7 +505,8 @@ function handleDelta(d){
       // Carte à image : retirée de la liste du tour, sinon le repli de fin de
       // tour (collapseAll) la fermerait quand même.
       if(tu.image && T.pendingToolEl){ const i=T.turnCollapsibles.indexOf(T.pendingToolEl); if(i>=0) T.turnCollapsibles.splice(i,1); }
-      T.pendingToolEl=null; if(tu.name==='mem_add'||tu.name==='mem_edit') loadMem(); }
+      T.pendingToolEl=null; if(tu.name==='mem_add'||tu.name==='mem_edit') loadMem();
+      if(typeof filesOnActivity==='function') filesOnActivity(); }
     return; }
   if(d.drop_reasoning){
     smoothReset(); cancelRender(); // le bloc raisonnement disparaît : rien à rendre

internal/loki/ui/src/js/14-attach.js

@@ -365,6 +365,7 @@ window.addEventListener('drop', e=>{
 // rouge, elle dit déjà ce qui s'est passé.
 async function attachPaths(){
   await Promise.all(ATTACH.filter(a=>a.state==='queued').map(uploadAttach));
+  if(typeof filesOnActivity==='function') filesOnActivity(); // les dépôts apparaissent dans le panneau Fichiers
   return ATTACH.filter(a=>a.state==='ok'&&a.path).map(a=>a.path);
 }
 renderAttach();

internal/loki/ui/src/js/15-files.js

@@ -263,6 +263,21 @@ function filesOnConvChange(){
   if(FILES_OPEN) loadFiles('');
 }
 
+// Quelque chose a pu changer sur disque : un outil vient de rendre son résultat
+// (l'agent écrit un rapport, une capture, un script), le tour est fini, une
+// pièce jointe vient d'être déposée. Le panneau se redessine tout seul —
+// jusqu'ici il fallait cliquer « rafraîchir » pour voir apparaître ce que
+// l'agent venait d'écrire. Regroupé : une rafale d'appels d'outils ne
+// déclenche qu'une lecture. Panneau fermé ou rejeu du journal : rien à faire,
+// l'ouverture recharge de toute façon.
+let filesRefreshT = 0;
+function filesOnActivity(){
+  if(!FILES_OPEN) return;
+  if(typeof REPLAYING !== 'undefined' && REPLAYING) return;
+  clearTimeout(filesRefreshT);
+  filesRefreshT = setTimeout(()=>{ filesRefreshT = 0; loadFiles(); }, 400);
+}
+
 // Date courte : l'heure pour aujourd'hui, la date sinon. Ce qu'on veut savoir,
 // c'est « est-ce que ça vient du tour que je viens de lancer ? ».
 document.addEventListener('DOMContentLoaded', initFiles);

internal/loki/ui/src/styles.css

@@ -280,6 +280,10 @@ details>summary::-webkit-details-marker{display:none}
 .preset-add{display:none;font-size:14px;padding:0 8px;margin:0 8px 0 auto;line-height:1.4;background:var(--panel);color:var(--text);border:1px solid var(--border);border-radius:3px;cursor:pointer}
 .preset-add:hover{border-color:var(--accent);color:var(--accent)}
 details[open]>summary>.preset-add{display:inline-block}
+/* Les panneaux de réglages ne sont plus des <details>/<summary> mais des
+   <section class="set-pane"> : sans cette règle, le « + » des Presets restait
+   en display:none et il n'y avait plus aucun moyen d'en créer un. */
+.set-pane-h>.preset-add{display:inline-block}
 .tag{display:inline-block;padding:2px 8px;border-radius:4px;font-size:11px;background:var(--panel);border:1px solid var(--border)}
 .tag.ok{color:var(--ok);border-color:var(--ok)}
 .tag.err{color:var(--err);border-color:var(--err)}
@@ -751,9 +755,6 @@ textarea.sctl{min-height:76px;resize:vertical;line-height:1.5}
 .lc-update-link{color:var(--dim);text-decoration:none;cursor:pointer}
 .lc-update-link:hover{color:var(--accent)}
 /* Choix du moteur dans l'éditeur de modèle (3 options : rapide/optimisé/perso) */
-.be-opts{display:flex;flex-direction:column;gap:7px;margin:6px 0 8px}
-.be-opt{display:flex;align-items:center;gap:8px;font-size:13px;color:var(--text);cursor:pointer}
-.be-opt input{margin:0;flex-shrink:0}
 .be-note{font-size:11px;color:var(--dim);margin-left:auto}
 
 /* ===== Éditeur de preset — listes groupées façon Réglages iOS ======== */
@@ -845,7 +846,6 @@ textarea.sctl{min-height:76px;resize:vertical;line-height:1.5}
 .pe-seg>label{flex:1;text-align:center;font-size:13px;font-weight:500;padding:7px 4px;border-radius:3px;cursor:pointer;color:var(--dim);transition:background .12s,color .12s}
 .pe-seg>label:has(input:checked){background:var(--panel);color:var(--text);box-shadow:0 1px 2px rgba(0,0,0,.22)}
 .pe-seg input{display:none}
-.pe-seg .be-note{display:none}
 .pe-seg-note{font-size:11px;color:var(--dim);padding:0 2px;min-height:14px}
 .pe-note{font-size:11px;color:var(--dim);line-height:1.45}
 /* Barre de progression (téléchargement de modèle). Sans total connu, elle
@@ -1685,6 +1685,16 @@ html[data-files="1"] #files-btn{color:var(--accent)}
 /* --- Moniteur machine (pied de barre latérale) ----------------------- */
 .perf-head{display:flex;align-items:center;gap:8px;margin-bottom:11px;
   font-size:14px;font-weight:600;color:var(--text);letter-spacing:-.01em}
+/* Bouton du moniteur (« Libérer la VRAM » / « Recharger le modèle ») : poussé
+   à droite du titre, discret tant qu'on ne le cherche pas. En mode rechargement
+   il prend la couleur d'accent — le moteur est arrêté, c'est l'action qui
+   compte à ce moment-là. */
+.perf-act{margin-left:auto;flex:none;padding:3px 8px;font-size:11px;line-height:1.4;
+  color:var(--dim);border:1px solid var(--border);border-radius:4px;cursor:pointer;
+  white-space:nowrap}
+.perf-act:hover:not(:disabled){color:var(--text)}
+.perf-act:disabled{opacity:.55;cursor:progress}
+.perf-act.reload{color:var(--accent);border-color:color-mix(in srgb,var(--accent) 45%,transparent)}
 .perf-row{margin:0 0 14px}
 .perf-l{display:flex;align-items:baseline;gap:8px;font-size:12.5px;color:var(--text);margin-bottom:6px}
 .perf-l b{flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;

internal/loki/web_api.go

@@ -8,7 +8,6 @@ import (
 	"net"
 	"net/http"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"strconv"
 	"strings"
@@ -170,28 +169,15 @@ func handleServiceLog(w http.ResponseWriter, r *http.Request) {
 	sendJSON(w, 200, map[string]any{"log": serviceLogTail(n)})
 }
 
+// handleVram expose l'état des cartes à l'interface (jauges du moniteur).
+// La lecture nvidia-smi elle-même vit dans web_vram.go, avec le déchargement
+// de la VRAM qui s'en sert pour chiffrer la mémoire rendue.
 func handleVram(w http.ResponseWriter, r *http.Request) {
-	out, err := hideCmd(exec.Command("nvidia-smi",
-		"--query-gpu=name,memory.used,memory.total,utilization.gpu,temperature.gpu",
-		"--format=csv,noheader,nounits")).Output()
 	gpus := []map[string]any{}
-	if err == nil {
-		for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") {
-			parts := strings.Split(line, ",")
-			if len(parts) != 5 {
-				continue
-			}
-			for i := range parts {
-				parts[i] = strings.TrimSpace(parts[i])
-			}
-			used, _ := strconv.Atoi(parts[1])
-			total, _ := strconv.Atoi(parts[2])
-			util, _ := strconv.Atoi(parts[3])
-			temp, _ := strconv.Atoi(parts[4])
-			gpus = append(gpus, map[string]any{
-				"name": parts[0], "used": used, "total": total, "util": util, "temp": temp,
-			})
-		}
+	for _, g := range gpuStats() {
+		gpus = append(gpus, map[string]any{
+			"name": g.Name, "used": g.Used, "total": g.Total, "util": g.Util, "temp": g.Temp,
+		})
 	}
 	sendJSON(w, 200, gpus)
 }
@@ -437,12 +423,24 @@ func handlePresetSave(w http.ResponseWriter, r *http.Request) {
 		sendJSON(w, 400, map[string]any{"ok": false, "error": err.Error()})
 		return
 	}
-	newID, err := SavePreset(req.ID, req.Name, req.Content)
+	// Le preset en service modifié est réappliqué sur-le-champ, moteur relancé
+	// en arrière-plan comme pour une bascule (handleSwitch) : la réponse ne
+	// doit pas attendre l'arrêt de llama-server.
+	newID, applied, err := SavePresetApplying(req.ID, req.Name, req.Content)
 	if err != nil {
 		sendJSON(w, 400, map[string]any{"ok": false, "error": err.Error()})
 		return
 	}
-	sendJSON(w, 200, map[string]any{"ok": true, "id": newID, "name": req.Name})
+	if applied {
+		fmt.Printf("%s config.env <- %s (preset actif modifié)\n", green("[ok]"), newID)
+		fmt.Println(dim("[info] redémarrage du service..."))
+		go func() {
+			if err := serviceAction("restart"); err != nil {
+				fmt.Printf("%s redémarrage après modification du preset: %v\n", red("[ERREUR]"), err)
+			}
+		}()
+	}
+	sendJSON(w, 200, map[string]any{"ok": true, "id": newID, "name": req.Name, "applied": applied})
 }
 
 func handlePresetDelete(w http.ResponseWriter, r *http.Request) {

internal/loki/web_devices.go

@@ -15,6 +15,7 @@ import (
 	"context"
 	"encoding/json"
 	"net/http"
+	"os"
 	"os/exec"
 	"path/filepath"
 	"regexp"
@@ -75,6 +76,45 @@ func devCachePut(bin string, devs []map[string]any) {
 	devCacheMu.Unlock()
 }
 
+// Cache PERSISTANT de la dernière énumération RÉUSSIE (exit 0) de --list-devices,
+// par clé moteur+CVD. But : quand le moteur tourne et sature déjà une carte, un
+// nouvel appel --list-devices peut PLANTER (CUDA out of memory en initialisant le
+// device plein) et ne renvoyer qu'une partie des cartes — l'UI perdait alors le
+// tensor split (slider caché faute de 2e GPU) après un simple redémarrage de
+// l'interface, qui vide le cache mémoire. On garde donc sur disque la dernière
+// liste complète : identité, ordre et mémoire TOTALE sont des faits matériels
+// stables issus du moteur lui-même (pas de nvidia-smi, dont l'ordre peut différer,
+// voir l'en-tête de ce fichier). Seule la mémoire LIBRE y est périmée, ce qui est
+// sans importance pour choisir les cartes et régler la répartition.
+var devPersistMu sync.Mutex
+
+func devPersistPath() string { return filepath.Join(LokiHome(), "devices.json") }
+
+func devPersistLoad() map[string][]map[string]any {
+	m := map[string][]map[string]any{}
+	if b, err := os.ReadFile(devPersistPath()); err == nil {
+		_ = json.Unmarshal(b, &m)
+	}
+	return m
+}
+
+func devPersistGet(key string) ([]map[string]any, bool) {
+	devPersistMu.Lock()
+	defer devPersistMu.Unlock()
+	d, ok := devPersistLoad()[key]
+	return d, ok && len(d) > 0
+}
+
+func devPersistPut(key string, devs []map[string]any) {
+	devPersistMu.Lock()
+	defer devPersistMu.Unlock()
+	m := devPersistLoad()
+	m[key] = devs
+	if b, err := json.MarshalIndent(m, "", "  "); err == nil {
+		_ = os.WriteFile(devPersistPath(), b, 0o644)
+	}
+}
+
 // fillMissingMemory complète les mémoires que le moteur n'a pas su lire. Quand
 // une carte est déjà saturée par le modèle en cours, llama.cpp annonce 0 Mio —
 // l'UI n'avait alors rien à afficher pour elle, ce qui donnait une liste
@@ -156,26 +196,60 @@ func handleBackendDevices(w http.ResponseWriter, r *http.Request) {
 		sendJSON(w, 400, map[string]any{"ok": false, "error": "ce chemin n'est pas un llama-server"})
 		return
 	}
-	if devs, ok := devCacheGet(bin); ok {
+	// L'ordre d'énumération DOIT être celui du serveur en marche, sinon la liste
+	// affichée (et donc le --tensor-split que l'utilisateur règle carte par carte)
+	// se retrouve inversée par rapport à la réalité. Le moteur réel force
+	// CUDA_DEVICE_ORDER=PCI_BUS_ID (+ le filtre CUDA_VISIBLE_DEVICES) dans
+	// backend_serve.go ; par défaut CUDA classe « le plus rapide d'abord », ce qui
+	// peut être l'ordre INVERSE. On reproduit donc le même environnement ici.
+	cfg := ReadConfig()
+	cvd := cfg["CUDA_VISIBLE_DEVICES"]
+	cacheKey := bin + "\x00" + cvd
+	if devs, ok := devCacheGet(cacheKey); ok {
 		sendJSON(w, 200, map[string]any{"ok": true, "devices": devs})
 		return
 	}
 	ctx, cancel := context.WithTimeout(r.Context(), 20*time.Second)
 	defer cancel()
 	cmd := hideCmd(exec.CommandContext(ctx, bin, "--list-devices"))
-	cmd.Env = libraryPathEnv(filepath.Dir(bin))
+	env := libraryPathEnv(filepath.Dir(bin))
+	if cvd != "" {
+		env = append(env, "CUDA_VISIBLE_DEVICES="+cvd, "CUDA_DEVICE_ORDER=PCI_BUS_ID")
+	}
+	cmd.Env = env
 	out, err := cmd.CombinedOutput()
-	if err != nil && len(out) == 0 {
-		sendJSON(w, 200, map[string]any{"ok": false, "error": "le moteur n'a pas répondu : " + err.Error()})
+	devs := parseListDevices(string(out))
+	// err != nil = le moteur est sorti en erreur (typiquement il a PLANTÉ en OOM
+	// sur une carte déjà pleine pendant qu'il l'énumérait, cf. « CUDA error: out of
+	// memory »). La sortie est alors TRONQUÉE : on ne peut pas s'y fier (il manque
+	// des cartes). On rend plutôt la dernière liste complète connue, pour ne pas
+	// perdre le tensor split pendant que le moteur tourne.
+	if err != nil {
+		if good, ok := devPersistGet(cacheKey); ok {
+			sendJSON(w, 200, map[string]any{"ok": true, "devices": good, "stale": true})
+			return
+		}
+		if len(devs) == 0 {
+			sendJSON(w, 200, map[string]any{"ok": false, "error": "le moteur n'a pas répondu : " + err.Error()})
+			return
+		}
+		// Pas de repli disponible : on rend ce qu'on a lu, sans le figer (ni cache
+		// mémoire ni persistant) puisque la liste est probablement incomplète.
+		sendJSON(w, 200, map[string]any{"ok": true, "devices": devs, "stale": true})
 		return
 	}
-	devs := parseListDevices(string(out))
 	fillMissingMemory(devs)
 	// Quand une carte est déjà saturée par le modèle en cours, le moteur peut
 	// annoncer 0 Mio de mémoire : c'est une lecture transitoire, on ne la fige
 	// pas dans le cache (sinon l'UI affiche « 0 Go » pendant dix minutes).
 	if !hasZeroMemory(devs) {
-		devCachePut(bin, devs)
+		devCachePut(cacheKey, devs)
+	}
+	// Énumération propre (exit 0) = liste complète et faisant foi : on la garde sur
+	// disque comme repli pour les futurs appels où le moteur, chargé, ferait planter
+	// --list-devices.
+	if len(devs) > 0 {
+		devPersistPut(cacheKey, devs)
 	}
 	sendJSON(w, 200, map[string]any{"ok": true, "devices": devs})
 }

internal/loki/web_server.go

@@ -175,6 +175,10 @@ func newWebMux() *http.ServeMux {
 	api("/api/dictate/state", handleDictateState)              // serveur allumé, modèle chargé, dernière erreur
 	api("/api/service/log", handleServiceLog)                  // journal du service pour diagnostiquer un modèle qui ne charge pas
 	api("/api/vram", handleVram)
+	// Rendre la carte à la machine : le modèle occupe la VRAM tant que le moteur
+	// tourne, et une autre application qui en a besoin ne trouve rien.
+	api("/api/vram/unload", handleVramUnload) // arrête moteur + dictée, rapporte la VRAM rendue
+	api("/api/vram/reload", handleVramReload) // relance le moteur (le modèle se recharge)
 	api("/api/ram", handleRam)
 	api("/api/config", handleConfigEnv)
 	api("/api/paths", handlePaths)

internal/loki/web_transcribe_test.go

@@ -3,6 +3,7 @@ package loki
 import (
 	"os"
 	"regexp"
+	"strconv"
 	"strings"
 	"testing"
 )
@@ -122,6 +123,63 @@ func TestDockerfileDeuxBinairesWhisper(t *testing.T) {
 	}
 }
 
+// L'étape CUDA doit être bâtie avec un nvcc qui CONNAÎT les GPU visés. CUDA
+// 12.4 ignore Blackwell (RTX 50xx, sm_120) : il refuse l'architecture, et le
+// binaire ne tournerait au mieux que par recompilation PTX au chargement.
+// 12.8 est le plancher, et c'est aussi la version avec laquelle llama.cpp bâtit
+// l'image amont qui fournit libcudart.
+func TestDockerfileCudaAssezRecent(t *testing.T) {
+	const majeurMin, mineurMin = 12, 8
+	trouve := false
+	for nom, txt := range etapesWhisperbuild(t) {
+		m := regexp.MustCompile(`nvidia/cuda:(\d+)\.(\d+)`).FindStringSubmatch(txt)
+		if m == nil {
+			continue
+		}
+		trouve = true
+		maj, _ := strconv.Atoi(m[1])
+		min, _ := strconv.Atoi(m[2])
+		if maj < majeurMin || (maj == majeurMin && min < mineurMin) {
+			t.Errorf("étape %s : CUDA %s.%s — trop ancien pour Blackwell (sm_120), il faut au moins %d.%d",
+				nom, m[1], m[2], majeurMin, mineurMin)
+		}
+		// Sans borne d'architectures, ggml compile de Maxwell à Blackwell :
+		// chaque architecture multiplie le temps de compilation, et le build
+		// dépassait quarante minutes.
+		if !strings.Contains(txt, "CMAKE_CUDA_ARCHITECTURES") {
+			t.Errorf("étape %s : aucune borne CMAKE_CUDA_ARCHITECTURES — la compilation vise toutes les architectures connues", nom)
+		}
+	}
+	if !trouve {
+		t.Error("aucune étape whisperbuild ne part d'une image nvidia/cuda")
+	}
+}
+
+// L'ARG qui porte les drapeaux doit être déclaré AVANT le premier FROM. Un ARG
+// posé entre deux étapes appartient à l'étape où il apparaît ; les « ARG » nus
+// des étapes whisperbuild-* héritent alors du scope global — vide. cmake a
+// tourné sans aucun drapeau : ggml en bibliothèques partagées (échec de lien),
+// et -march=native — le SIGILL de la PR #18 revenu en silence. 51 minutes de
+// build pour le découvrir.
+func TestDockerfileArgFlagsGlobal(t *testing.T) {
+	b, err := os.ReadFile("../../Dockerfile")
+	if err != nil {
+		t.Fatalf("lecture du Dockerfile : %v", err)
+	}
+	src := string(b)
+	// Ancré en début de ligne : une occurrence dans un commentaire ne compte
+	// pas — c'est précisément ainsi qu'une première version de ce test s'est
+	// laissée berner par sa propre contre-épreuve.
+	argLoc := regexp.MustCompile(`(?m)^ARG WHISPER_CMAKE_FLAGS=`).FindStringIndex(src)
+	fromLoc := regexp.MustCompile(`(?m)^FROM `).FindStringIndex(src)
+	if argLoc == nil {
+		t.Fatal("ARG WHISPER_CMAKE_FLAGS= introuvable dans le Dockerfile")
+	}
+	if fromLoc != nil && argLoc[0] > fromLoc[0] {
+		t.Error("ARG WHISPER_CMAKE_FLAGS= est déclaré APRÈS un FROM : les étapes whisperbuild-* hériteront d'une valeur vide et cmake tournera sans aucun drapeau")
+	}
+}
+
 func clefs(m map[string]string) []string {
 	out := make([]string, 0, len(m))
 	for k := range m {

internal/loki/web_vram.go

@@ -0,0 +1,243 @@
+// web_vram.go — rendre la mémoire vidéo à la machine, à la demande.
+//
+// Tant que le moteur tourne, le modèle occupe la VRAM : une autre application
+// (jeu, encodage, entraînement, un second serveur d'inférence…) qui réclame la
+// carte ne trouve plus rien à prendre. Le geste existait déjà — arrêter le
+// service — mais il vivait dans les réglages sous le nom « arrêter », qui ne
+// dit pas qu'il libère la carte, et il laissait tourner le serveur de dictée
+// qui, lui aussi, garde de la VRAM quand il est allumé sur GPU.
+//
+//	POST /api/vram/unload  → arrête le moteur ET la dictée, puis rapporte la
+//	                          mémoire réellement rendue (before/after/freed)
+//	POST /api/vram/reload  → relance le moteur (le modèle se recharge)
+package loki
+
+import (
+	"encoding/json"
+	"net/http"
+	"os/exec"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// gpuStat : une carte vue par nvidia-smi. Mémoire en Mo (unité de nvidia-smi,
+// et celle que /api/vram expose déjà à l'interface).
+type gpuStat struct {
+	Name  string
+	Used  int
+	Total int
+	Util  int
+	Temp  int
+}
+
+// gpuStats interroge nvidia-smi. Renvoie nil quand il est absent (machine sans
+// GPU NVIDIA, Mac, CPU seul) : l'absence de mesure n'est pas une erreur, elle
+// prive juste le déchargement de son bilan chiffré.
+func gpuStats() []gpuStat {
+	out, err := hideCmd(exec.Command("nvidia-smi",
+		"--query-gpu=name,memory.used,memory.total,utilization.gpu,temperature.gpu",
+		"--format=csv,noheader,nounits")).Output()
+	if err != nil {
+		return nil
+	}
+	var gpus []gpuStat
+	for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") {
+		parts := strings.Split(line, ",")
+		if len(parts) != 5 {
+			continue
+		}
+		for i := range parts {
+			parts[i] = strings.TrimSpace(parts[i])
+		}
+		g := gpuStat{Name: parts[0]}
+		g.Used, _ = strconv.Atoi(parts[1])
+		g.Total, _ = strconv.Atoi(parts[2])
+		g.Util, _ = strconv.Atoi(parts[3])
+		g.Temp, _ = strconv.Atoi(parts[4])
+		gpus = append(gpus, g)
+	}
+	return gpus
+}
+
+// gpuUsedMB : VRAM occupée, toutes cartes confondues.
+func gpuUsedMB(gpus []gpuStat) int {
+	used := 0
+	for _, g := range gpus {
+		used += g.Used
+	}
+	return used
+}
+
+// gpuSettle attend que la VRAM ait fini de redescendre avant de la relire. Le
+// pilote ne rend pas la mémoire à l'instant où le processus meurt — taskkill et
+// Process.Kill reviennent avant même que CUDA ait commencé son ménage — et une
+// lecture prise trop tôt rapporterait « 0 Mo libérés » après un déchargement
+// qui a pourtant marché. Trois règles, chacune née d'un faux bilan :
+//
+//   - une mesure ratée (nvidia-smi absent, ou en pleine réinitialisation juste
+//     après l'arrêt) n'est PAS « 0 Mo » : on la saute et on garde la dernière
+//     lecture valide — la compter à zéro annoncerait tout le modèle comme
+//     libéré alors que rien n'a bougé ;
+//   - un palier n'est concluant qu'une fois la baisse commencée : avant, c'est
+//     le pilote qui n'a pas encore réagi, pas la mémoire qui a fini de partir ;
+//   - deux lectures égales de suite après la baisse, et on rend la valeur.
+//     Sans baisse du tout, on rend la dernière lecture après ~4 s.
+//
+// sample renvoie (Mo occupés, lecture réussie). before : la lecture prise
+// avant l'arrêt, qui sert de repère à « la baisse a commencé ».
+func gpuSettle(before int, sample func() (int, bool), pause time.Duration) int {
+	last, lu := before, false
+	baisse, palier := false, 0
+	for i := 0; i < 8; i++ {
+		time.Sleep(pause)
+		cur, ok := sample()
+		if !ok {
+			continue
+		}
+		if cur < before {
+			baisse = true
+		}
+		if lu && cur == last {
+			palier++
+		} else {
+			palier = 0
+		}
+		last, lu = cur, true
+		if baisse && palier >= 1 {
+			return cur
+		}
+	}
+	return last
+}
+
+func gpuUsedSettled(before int) int {
+	return gpuSettle(before, func() (int, bool) {
+		g := gpuStats()
+		return gpuUsedMB(g), g != nil
+	}, 500*time.Millisecond)
+}
+
+// engineNeedsStop : faut-il envoyer « stop » ? Actif, évidemment. Mais sous
+// systemd, « is-active » ne répond « active » qu'une fois le service établi :
+// une unité en train de (re)démarrer — Restart=on-failure sur un modèle qui
+// meurt au chargement — répond « activating », et la sauter laisserait systemd
+// relancer llama-server toutes les trois secondes, GPU repris à chaque tour,
+// pendant que l'interface affirme « le moteur était déjà arrêté ». On garde la
+// condition pour le bilan, mais élargie aux états transitoires.
+func engineNeedsStop() bool {
+	if serviceIsActive() {
+		return true
+	}
+	if !systemdAvailable() {
+		return false
+	}
+	out, _ := exec.Command("systemctl", "is-active", serviceName()).Output()
+	switch strings.TrimSpace(string(out)) {
+	case "activating", "reloading", "deactivating":
+		return true
+	}
+	return false
+}
+
+// postOnly refuse tout sauf POST. Ces routes changent l'état de la machine —
+// elles arrêtent des processus — et un simple GET ne doit pas y suffire : sans
+// clé de pilotage configurée, une balise <img> sur une page tierce visitée par
+// hasard suffirait sinon à couper le moteur.
+func postOnly(w http.ResponseWriter, r *http.Request) bool {
+	if r.Method == http.MethodPost {
+		return true
+	}
+	w.Header().Set("Allow", http.MethodPost)
+	sendJSON(w, 405, map[string]any{"ok": false, "error": "méthode " + r.Method + " refusée : POST attendu"})
+	return false
+}
+
+// ansiRe / plainErr : les messages de preflightEngine sont écrits pour le
+// terminal (bold() y glisse des séquences ANSI). Envoyés tels quels à
+// l'interface, ils y affichent des « [1m » au milieu de la phrase.
+var ansiRe = regexp.MustCompile("\x1b\\[[0-9;]*m")
+
+func plainErr(err error) string {
+	if err == nil {
+		return ""
+	}
+	return ansiRe.ReplaceAllString(err.Error(), "")
+}
+
+// handleVramUnload arrête le moteur (et la dictée) pour rendre la mémoire
+// vidéo. Refuse pendant une génération — la couper perdrait la réponse en
+// cours — sauf si l'appelant insiste avec {force:true}.
+func handleVramUnload(w http.ResponseWriter, r *http.Request) {
+	if !postOnly(w, r) {
+		return
+	}
+	var req struct {
+		Force bool `json:"force"`
+	}
+	_ = json.NewDecoder(r.Body).Decode(&req)
+	if !req.Force && conv.isGenerating() {
+		sendJSON(w, 409, map[string]any{"ok": false, "generating": true,
+			"error": "une réponse est en cours d'écriture — décharger maintenant l'interromprait"})
+		return
+	}
+	gpus := gpuStats()
+	before := gpuUsedMB(gpus)
+	wasActive := engineNeedsStop()
+
+	var errs []string
+	if wasActive {
+		if err := serviceAction("stop"); err != nil {
+			errs = append(errs, "arrêt du moteur : "+plainErr(err))
+		}
+	}
+	// La dictée tourne dans un processus séparé, allumé à la demande et éteint
+	// après dix minutes d'inactivité : sur GPU, elle occupe la carte pendant tout
+	// ce temps. Libérer la VRAM sans elle ne libérerait pas tout. La variante
+	// « vite » : ne jamais attendre derrière un démarrage de la dictée, qui
+	// peut tenir le verrou deux minutes — le navigateur aurait abandonné bien
+	// avant, moteur pourtant déjà arrêté.
+	whisperShutdownVite()
+
+	after := before
+	if gpus != nil {
+		after = gpuUsedSettled(before)
+	}
+	freed := before - after
+	if freed < 0 {
+		freed = 0
+	}
+	sendJSON(w, 200, map[string]any{
+		"ok":         len(errs) == 0,
+		"error":      strings.Join(errs, " ; "),
+		"was_active": wasActive,
+		"active":     serviceIsActive(),
+		"gpu":        gpus != nil,
+		"before_mb":  before,
+		"used_mb":    after,
+		"freed_mb":   freed,
+	})
+}
+
+// handleVramReload relance le moteur après un déchargement. Le préflight évite
+// de démarrer un service condamné à mourir en boucle (BIN ou MODEL absents) :
+// mieux vaut la vraie raison tout de suite qu'un « chargement… » sans fin.
+func handleVramReload(w http.ResponseWriter, r *http.Request) {
+	if !postOnly(w, r) {
+		return
+	}
+	if serviceIsActive() {
+		sendJSON(w, 200, map[string]any{"ok": true, "already": true})
+		return
+	}
+	if err := preflightEngine(); err != nil {
+		sendJSON(w, 200, map[string]any{"ok": false, "error": plainErr(err)})
+		return
+	}
+	if err := serviceAction("start"); err != nil {
+		sendJSON(w, 200, map[string]any{"ok": false, "error": plainErr(err)})
+		return
+	}
+	sendJSON(w, 200, map[string]any{"ok": true})
+}

internal/loki/web_vram_test.go

@@ -0,0 +1,72 @@
+package loki
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+// gpuSettle : le bilan « VRAM libérée » est calculé sur ces lectures. Chaque cas
+// est un faux bilan qu'on a vu — ou qu'on aurait vu — dans l'interface.
+func TestGpuSettle(t *testing.T) {
+	seq := func(vals ...int) func() (int, bool) {
+		i := 0
+		return func() (int, bool) {
+			if i >= len(vals) {
+				return vals[len(vals)-1], true
+			}
+			v := vals[i]
+			i++
+			if v < 0 { // lecture ratée (nvidia-smi absent ou en réinitialisation)
+				return 0, false
+			}
+			return v, true
+		}
+	}
+	for _, c := range []struct {
+		name string
+		seq  []int
+		want int
+	}{
+		// Le pilote met un temps à réagir : palier AVANT la baisse, puis la
+		// mémoire part. L'ancienne version rendait 20000 dès le premier palier.
+		{"palier avant la baisse", []int{20000, 20000, 12000, 3000, 500, 500}, 500},
+		// Baisse immédiate et régulière, puis stable.
+		{"baisse puis stable", []int{15000, 8000, 400, 400}, 400},
+		// Une lecture ratée au milieu n'est pas « 0 Mo » : on la saute.
+		{"lecture ratée ignorée", []int{14000, -1, 600, 600}, 600},
+		// Toutes les lectures ratées : on rend « avant », donc 0 Mo libérés,
+		// plutôt que d'annoncer 14 Go rendus.
+		{"aucune lecture", []int{-1, -1, -1, -1, -1, -1, -1, -1}, 14000},
+		// Rien ne baisse (moteur déjà arrêté) : dernière lecture valide.
+		{"rien ne bouge", []int{14000, 14000, 14000, 14000, 14000, 14000, 14000, 14000}, 14000},
+	} {
+		t.Run(c.name, func(t *testing.T) {
+			if got := gpuSettle(14000, seq(c.seq...), 0); got != c.want {
+				t.Errorf("gpuSettle = %d, attendu %d", got, c.want)
+			}
+		})
+	}
+}
+
+// Les deux routes arrêtent ou relancent des processus : un GET — une balise
+// <img> sur une page tierce, sans clé de pilotage — ne doit rien déclencher.
+func TestVramRoutesRefusentGET(t *testing.T) {
+	for path, h := range map[string]http.HandlerFunc{
+		"/api/vram/unload": handleVramUnload,
+		"/api/vram/reload": handleVramReload,
+	} {
+		rec := httptest.NewRecorder()
+		h(rec, httptest.NewRequest(http.MethodGet, path, nil))
+		if rec.Code != 405 {
+			t.Errorf("%s GET : code %d, attendu 405", path, rec.Code)
+		}
+		if rec.Header().Get("Allow") != "POST" {
+			t.Errorf("%s GET : en-tête Allow %q, attendu POST", path, rec.Header().Get("Allow"))
+		}
+		if !strings.Contains(rec.Body.String(), "POST attendu") {
+			t.Errorf("%s GET : corps %q sans explication", path, rec.Body.String())
+		}
+	}
+}