Optimiseur : le ménage du verrou ne croise plus sa prise ni son rendu

TestTuneRecoverNeverReapsOwnLock échouait au hasard sous Linux (2 fois sur
5 déjà en v0.15.0, CI rouge). Le ménage (tuneReapStale) déplaçait un verrou
vivant, le relisait puis le remettait en place ; si release() passait entre
les deux, il ne trouvait plus le fichier et rendait l'inscription. Le verrou
remis en place devenait orphelin, et le ménage suivant le prenait pour une
optimisation interrompue : moteur relancé, preset « rétabli » à tort.

Un mutex de processus (tuneFileMu) sérialise désormais les opérations sur
le fichier — prise, réécriture, rendu, déplacement-relecture du ménage.
L'arrêt d'un essai orphelin et le retour du preset restent hors du mutex.
Vérifié sous Linux : 40 passages sans échec, suite complète verte.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Dockerfile

@@ -87,8 +87,12 @@ LABEL org.opencontainers.image.revision="${LOKI_VERSION}" \
 # via npx ; tini en PID 1. curl et libgomp1 sont déjà dans l'image amont.
 # Node 22 depuis NodeSource et non depuis Ubuntu (qui livre Node 18) : Playwright
 # et la plupart des serveurs MCP réclament Node ≥ 20.
+# python3 + python3-venv : l'installeur et le serveur du moteur Strata
+# (backend_strata.go) sont en Python ≥ 3.10 et créent leur propre .venv dans
+# /data/strata. Le moteur et le modèle ne sont PAS dans l'image : téléchargés
+# à la demande depuis Paramètres → Moteur.
 RUN apt-get update && apt-get install -y --no-install-recommends \
-        git tini ca-certificates curl gnupg \
+        git tini ca-certificates curl gnupg python3 python3-venv \
     && curl -fsSL https://deb.nodesource.com/setup_22.x | bash - \
     && apt-get install -y --no-install-recommends nodejs \
     && rm -rf /var/lib/apt/lists/*

NOTICE.md

@@ -52,6 +52,16 @@ et le **chiffrement de la mémoire** (`mem_crypto.go`, `mem_vault.go`,
 **pas** reprise : elle vise ajean.link, le service de l'auteur amont. Loki
 expose à la place un export/import de paquet chiffré en fichier local.
 
+## Moteur Strata
+
+Le second moteur de Loki (`internal/loki/backend_strata.go`) est
+**[Strata](https://github.com/Niko1221/Strata)** (MIT), spécialisé dans
+Qwen3.8-Flash-Next. Son intégration est reprise d'AJEAN (« AJEAN MoE 1.0 »,
+`backend_moe.go`) : Loki télécharge le paquet figé publié par AJEAN sur sa
+release `moe-v1.0` (sources de Strata et binaire Linux CUDA 12 compilé, avec
+les modifications d'AJEAN), vérifié par SHA-256. Ni Strata ni le modèle ne sont
+inclus dans l'image : ils sont téléchargés à la demande.
+
 ## Services externes
 
 Le tunnel d'accès distant continue de pointer vers **ajean.link**, le relais

README.md

@@ -93,6 +93,33 @@ la recherche qu'au téléchargement. À défaut, la variable d'environnement
 priorité. Un jeton en **lecture** suffit (huggingface.co/settings/tokens), et il
 n'est envoyé qu'aux adresses Hugging Face.
 
+## Choisir son moteur : llama.cpp ou Strata
+
+Loki a deux moteurs, et le choix se fait **par preset** (clé `ENGINE`) :
+
+- **llama.cpp** (par défaut) — n'importe quel GGUF, réglages complets dans
+  l'éditeur de preset.
+- **[Strata](https://github.com/Niko1221/Strata)** — spécialisé dans
+  **Qwen3.8 Flash Next** (MoE de 125 B) : les experts sont répartis entre
+  VRAM, RAM et disque pour faire tourner ce modèle sur une carte de joueur.
+  Intégration reprise d'AJEAN (paquet figé « AJEAN MoE 1.0 », vérifié par
+  SHA-256).
+
+**Paramètres → Moteur → Strata** : la fenêtre lit la machine (cartes, RAM,
+disque), propose la version (Classique ou Swift 1.5) et la qualité qui tient,
+puis installe et active le modèle en un clic (téléchargement de 66 à 84 Go dans
+`/data/strata`). Le modèle installé devient un preset comme les autres :
+basculer dessus lance Strata, basculer sur un autre preset revient à llama.cpp.
+Son engrenage ouvre les réglages propres à Strata (contexte jusqu'à 262 144,
+cache KV fp16/8 bits, prédiction MTP, lecture des images, carte d'appoint).
+
+Pré-requis : Linux + NVIDIA RTX 20 ou plus récente (8 Go de VRAM minimum, une
+deuxième carte est utilisée comme carte d'appoint), environ 46 Go de RAM pour
+la plus petite qualité, pilote compatible CUDA 12.8. Le conteneur doit pouvoir
+verrouiller la mémoire : `ulimits: memlock: -1` (déjà présent dans les
+fichiers compose fournis). Le benchmark et l'optimiseur ne s'appliquent qu'à
+llama.cpp.
+
 ## Installation sur Unraid
 
 L'image est construite et publiée par GitHub Actions sur GHCR
@@ -135,7 +162,7 @@ un reverse proxy (`loki.mondomaine.fr`), définir une clé
 `LOKI_TRUSTED_HOSTS`.
 
 En CLI dans le conteneur : `docker exec -it loki loki status` (aussi :
-`logs`, `restart`, `config`, `bench`, `test`…).
+`logs`, `restart`, `config`, `bench`, `tune`, `test`…).
 
 ### Données et persistance
 
@@ -356,6 +383,9 @@ Ajoutées par ce fork :
   → maximale) et rejoue le message sans rien perdre de l'historique — une fois,
   puis la traduction est retenue pour ce modèle. La liste est grisée quand le
   raisonnement est coupé pour ce modèle.
+- **Performance** : cache de prompts, slots, décodage spéculatif, placement
+  MoE et multi-GPU, optimiseur — tout est rassemblé dans la section
+  [Performance](#performance), avec la table des clés et leur défaut.
 - **Discussions multiples** : historique complet dans la barre latérale, titre
   repris du premier message (renommable), suppression. **Chaque discussion a son
   dossier de fichiers** (`workspace/discussions/<id>/`) : les pièces jointes
@@ -461,6 +491,526 @@ Retirées par ce fork :
   sa route n'avait aucun consommateur et son repli embarqué datait de 2024. La
   recherche Hugging Face le remplace.
 
+## Performance
+
+Le but : des tours plus courts **sans dénaturer le modèle**. Rien ici ne
+touche à la quantification des poids, à l'échantillonnage, à la température, au
+budget de raisonnement ni au contenu du contexte. Tout ce qui changerait ce
+qu'envoie Loki au modèle, le placement des poids ou les slots du moteur est
+**désactivé par défaut**, derrière une clé ; sans clé, la requête et la ligne de
+commande restent celles d'avant. Les clés se posent dans le preset (éditeur) ou
+par `loki config set CLÉ valeur` ; celles marquées « moteur relancé » demandent
+un redémarrage du moteur.
+
+### Actif par défaut, sans perte
+
+- **Cache de prompts dimensionné** (`--cache-ram`) : agrandi pour un modèle
+  tout-GPU d'après l'état mesuré dans le GGUF, jamais sous le défaut du moteur ;
+  et le slot est effacé après un sous-agent, une vérification, une tâche ou un
+  bench, pour que la conversation revienne du cache RAM au lieu d'être
+  recalculée.
+- **Préfixe stable** : rappels de Loki gardés dans l'historique tels
+  qu'envoyés, relance après un 500 sans toucher aux outils ni au système, ligne
+  MCP présente dès le premier tour, ordre des trackers fixe.
+- **Comptage du contexte** sans le raisonnement jamais renvoyé : la compaction
+  (avec perte) part moins tôt, et son résumé n'est plus amputé de l'état
+  d'avancement.
+- **Threads CPU** : sans `THREADS`, le moteur prend ses cœurs physiques (plus
+  tous les threads logiques) ; conteneur à l'étroit (cpuset, quota) borné.
+- **Deux GPU** : `CUDA_SCALE_LAUNCH_QUEUES=4x` quand le pipeline entre cartes
+  est possible (même calcul, seul le prompt peut gagner).
+- **Points de reprise des hybrides** sur un moteur officiel antérieur à
+  `b10864` : `--checkpoint-min-step 2048` d'office si la RAM le permet, et un
+  avis « moteur trop ancien » ; l'encart « version recommandée » propose la mise
+  à jour (sur clic seulement, voir [Mettre à jour llama.cpp](#mettre-à-jour-llamacpp-sans-reconstruire-limage)).
+- **Côté Go** : écriture d'un gros fichier en temps linéaire, persistance de la
+  discussion hors du chemin du premier jeton, un seul `nvidia-smi` partagé
+  (moniteur et éditeur de preset), stockage Unraid servi par FUSE signalé.
+- **Mesure** : télémétrie par complétion (cache repris, recalculé, brouillon
+  accepté) dans l'interface et `GET /api/perf/summary`, sonde du gabarit de
+  chat (lecture seule, `/apply-template`), bench honnête en tâche de fond.
+- **Garde-fous** : un cache KV quantifié, `--context-shift` ou `--cache-reuse`
+  posés à la main sont signalés ; un mode de chargement résident voué à
+  l'échec est refusé (`LOAD_GUARD`) ; avis de placement MoE dans l'éditeur.
+
+### Les clés
+
+| Clé | Défaut | Effet | Prix, zone grise |
+|---|---|---|---|
+| `CACHE_RAM` | auto | cache de prompts en RAM hôte (`--cache-ram`, Mio), copie exacte des conversations quittées | `-1` = RAM non bornée (déconseillé avec un MoE mmappé), `0` = coupé |
+| `CACHE_ISOLATE` | actif | efface le slot après un travail annexe (sous-agent, vérification, tâche, bench) | `off` pour couper ; sans objet avec `SIDE_SLOT` |
+| `THREADS` / `THREADS_BATCH` | vide = cœurs physiques | `-t` / `-tb` | — |
+| `CUDA_LAUNCH_QUEUES` | auto (4x sur ≥ 2 GPU si pipeline) | file de lancements CUDA | `off`, ou `0.25x`…`4x` imposé ; réglage de machine |
+| `CTX_CHECKPOINTS` | moteur (32) | points de reprise par slot d'un hybride | 70 à 200 Mio de RAM hôte chacun |
+| `CKPT_MIN_STEP` | moteur (2048 d'office : hybride, moteur officiel < `b10864`) | espacement minimal des points de reprise | — |
+| `LOAD_GUARD` | actif | refuse un `--load-mode` résident qui ne tient pas en RAM | `off` = lancer quand même |
+| `REASONING_ECHO` | off | renvoie au moteur local la réflexion du modèle, au format entraîné | plus de contexte par tour, compaction plus tôt |
+| `REASONING_PRESERVE` | vide = défaut du moteur | `--reasoning-preserve` / `--no-reasoning-preserve` | change le rendu : `off` rend l'ancien historique à Qwen3.6, mais change celui de Qwen3.8 |
+| `PROJ_SNAPSHOT` | off | bloc projet figé par discussion, changements en `<context_update>` ; date et dossier sortent du système | le modèle lit les changements en tête du message suivant |
+| `PREWARM` | off | `on` : prépare le prochain tour pendant que tu lis ; `full` : aussi la discussion qu'on ouvre | une requête de plus au moteur au repos (1 jeton, jeté) |
+| `COMPACT_CONTINUATION` | off | le résumé de compaction prolonge le prompt en cache au lieu d'une transcription à froid | repli sur l'ancien chemin au moindre écart |
+| `KEEP_TURN_IMAGES` | off | garde dans l'historique les images montrées par les outils | **zone grise** : plus de contexte, compaction plus tôt ; une API externe refacture les images |
+| `NUDGE_IN_TOOL` | off | le rappel de budget d'outils part au bout du dernier résultat d'outil | **zone grise** : un modèle peut moins bien suivre une consigne lue dans un outil |
+| `SIDE_SLOT` | off (moteur relancé) | second slot pour les travaux annexes, la discussion garde le sien | cache KV et état récurrent en double en VRAM |
+| `SLOT_PERSIST` | off | état du slot gardé sur disque à la bascule de preset, rechargé au retour | 2 fichiers de 8 Gio au plus ; refusé avec `SPEC` |
+| `SPEC` | off (moteur relancé) | décodage spéculatif : `auto`, `mtp`, `ngram`, `mtp+ngram` | même distribution, pas le même texte au bit près ; MTP : 1 à 2 Go de VRAM |
+| `MODEL_DRAFT` | — | tête MTP publiée à part ou petit modèle brouillon | VRAM |
+| `SPEC_N_MAX` | moteur (3) | jetons anticipés par étape | — |
+| `SPEC_SAMPLING` | greedy (exact) | `probabilistic` seulement avec `SPEC=mtp` ou `mtp+ngram` | — |
+| `SPLIT_MODE` | couches | `tensor` : parallélisme de tenseurs entre cartes CUDA | expérimental : décodage plus rapide, prefill plus lent |
+| `FIT_TARGET` | 1024 Mio par carte | marge laissée libre par le placement auto (`--fit-target`) | — |
+| `OP_OFFLOAD_MIN_BATCH` | moteur (32) | lot à partir duquel les experts MoE sur CPU sont recopiés vers le GPU | à mesurer |
+| `CUDA_GRAPH_OPT` | off | branches Q/K/V en parallèle au décodage | expérimental ; `off` puis redémarrage s'il plante |
+| `KV_TYPE` (`_K`, `_V`) | f16 | quantification du cache KV | **zone grise** : `q8_0` modifie légèrement les sorties, `q4_0` perte mesurable — jamais posé par Loki |
+| `BATCH` / `UBATCH` | 2048 / 512 | lots du prefill | MoE aux experts en RAM : `UBATCH` 2048+ |
+| `LOKI_PERF_LOG` (environnement) | absent | une ligne `[perf]` par complétion sur stderr | — |
+
+Outils sans clé, qui ne font rien d'eux-mêmes :
+
+| Outil | Ce qu'il fait |
+|---|---|
+| **Bench** (bouton, `loki bench`, `--full`) | mesure en tâche de fond, à profondeur réelle avec le mode complet (prefill à froid, tours qui reprennent le cache, decode) |
+| **Optimiseur** (`loki tune`, bouton « Optimiser… ») | cherche lots, threads, marges, placement (`--placement`) et options opt-in (`--opt-in`) sur un moteur d'essai ; rien n'est écrit sans un clic |
+| **Dupliquer en placement auto…** (éditeur, MoE) | copie du preset où `--fit` place les experts au lieu de `-ot` / `--n-cpu-moe` |
+| **Version recommandée** (panneau Moteur) | met à jour llama.cpp vers un build ≥ `b10864`, sur clic, avec retour à la version précédente |
+
+### Ordre de test conseillé
+
+Une étape à la fois, mesurée avant la suivante :
+
+1. **Bench complet** du preset tel quel : la référence.
+2. **`PREWARM=on` et `COMPACT_CONTINUATION=on`**, puis une vraie session de
+   travail ; `GET /api/perf/summary` dit, par nature de requête
+   (`kinds.main`…), combien de fois et de jetons le cache a été perdu
+   (`lost_events`, `lost_tokens`) et le prefill par tour.
+3. **Optimiseur** (« Optimiser… ») sur le preset en service : lots, threads,
+   marges.
+4. **MoE aux experts en RAM** : « Dupliquer en placement auto… », bascule sur
+   la copie, `successfully fit params` au journal, bench complet des deux.
+5. **Mise à jour du moteur** vers la version recommandée si l'encart s'affiche
+   (points de reprise des hybrides, MTP rapide) ; vérifier le rendu du gabarit
+   dans le panneau.
+6. **`SPEC=auto`** (ou `mtp`) si le modèle a une tête MTP : bench, puis
+   `draft_rate` dans `/api/perf/summary`.
+
+### Ce qui a été écarté, et pourquoi
+
+- **`--cache-reuse`** : réutilise des morceaux de cache calculés sous un autre
+  contexte, donc change les sorties ; llama.cpp le coupe d'ailleurs pour les
+  hybrides et le multimodal. Signalé s'il est posé à la main.
+- **`--context-shift`** à la place de la compaction : retire des jetons du
+  contexte (perte), et ne marche pas sur les hybrides. Signalé lui aussi.
+- **Cache KV quantifié par défaut** : `q8_0` n'est pas exact, `q4_0` perd
+  mesurablement, pour un gain d'environ 2 Gio sur un 27B hybride (16 couches
+  sur 64 portent du KV). Reste un choix explicite et étiqueté (`KV_TYPE`).
+- Aussi : `-sm tensor` par défaut (prefill plus lent, expérimental), plus de
+  slots par défaut (OOM : états récurrents par slot), `--cache-ram -1` (RAM
+  non bornée), et tout réglage d'échantillonnage ou de quantification « pour
+  aller plus vite ».
+
+### Détail des clés et des outils
+
+- **Bench** (bouton du preset, `loki bench`, `--full` pour le mode complet) :
+  en tâche de fond (`POST /api/bench`, progression et annulation), chat,
+  tâches et compaction refusés le temps de la mesure. Le mode rapide mesure une
+  ligne courte avec le gabarit, le raisonnement et l'échantillonnage du preset ;
+  le mode complet ajoute un prefill à froid à profondeur réelle (jusqu'à 32 k
+  jetons, 16 k si des poids tournent sur CPU) et trois tours qui reprennent le
+  cache — reprise lue dans `cache_n`, jamais supposée. Rien n'est enregistré
+  sans réponses valides et timings réels ; l'empreinte du preset accompagne
+  chaque mesure.
+- **Raisonnement renvoyé au modèle** (clé `REASONING_ECHO`, **off** par défaut,
+  `loki config set REASONING_ECHO on`) : le raisonnement que le moteur local a
+  séparé (`reasoning_content`) est gardé avec chaque message et renvoyé au même
+  modèle. Les gabarits Qwen3.5/3.6 relisent alors les étapes d'une boucle
+  d'outils avec leur réflexion — le format entraîné — au lieu de blocs vides, et
+  le moteur ne recalcule plus le dernier message. Avec `REASONING_PRESERVE=on`
+  (gabarits qui ont ce réglage, Qwen3.6), le préfixe reste stable d'un message
+  utilisateur à l'autre ; Qwen3.5 n'en a pas, le gain y reste interne au tour.
+  Contrepartie : plus de contexte par tour, donc compaction plus tôt. Jamais
+  vers une API externe ni vers un autre modèle ; un prompt trop long est d'abord
+  rejoué sans raisonnement, et un gabarit qui le refuse le suspend pour ce
+  modèle jusqu'au redémarrage.
+- **Bloc projet figé** (clé `PROJ_SNAPSHOT`, **off** par défaut,
+  `loki config set PROJ_SNAPSHOT on`) : le contexte du projet (description,
+  index mémoire, trackers, `AGENTS.md`) part en tête du premier message ; sans
+  la clé il est reconstruit à chaque tour, et une page créée ou une valeur de
+  tracker notée fait recalculer toute la conversation derrière lui. Avec la clé,
+  chaque discussion garde une copie datée du bloc, envoyée à l'identique, et les
+  changements arrivent en tête du message suivant dans un bloc
+  `<context_update>` : pages ajoutées, modifiées, retirées, nouvelle ligne d'un
+  tracker, et le texte **complet** d'une description ou d'un `AGENTS.md` modifié
+  — rien n'est perdu, seul ce petit bloc est à calculer. Une ligne du prompt
+  système (présente seulement avec la clé) dit au modèle que ces blocs viennent
+  de Loki et que le plus récent l'emporte. La date du jour et le dossier de
+  travail de la discussion (ou, pour un poste distant ciblé, son nom, son
+  dossier et s'il est hors ligne) quittent aussi le prompt système pour ce
+  bloc, les consignes restant dans le système : système et outils deviennent
+  les mêmes d'une discussion à l'autre, et passer minuit n'ajoute qu'une ligne
+  de mise à jour au lieu de tout recalculer. Le bloc est repris tout neuf, et les
+  anciens `<context_update>` retirés, quand le début du prompt change de toute
+  façon : compaction, système ou outils modifiés (réglages, mode), redémarrage de
+  Loki, changement de modèle, de preset, de projet, de mode mémoire ou de mode
+  Code — et dès que les mises à jour accumulées deviennent trop longues. Les
+  tâches planifiées gardent le bloc à jour à chaque tour et, comme les
+  sous-agents, la vérification et le terminal, leur système d'avant, date et
+  dossier compris ; sans agent, rien du
+  projet n'est envoyé ; un preset externe (API) n'est jamais concerné. Le titre, l'export JSON, le résumé de compaction et la
+  passe de vérification ne voient pas ces blocs.
+- **Préchauffage du prochain tour** (clé `PREWARM`, **off** par défaut,
+  `loki config set PREWARM on`) : certains recalculs sont inévitables — prompt
+  réécrit par une compaction, dernier message rendu autrement au tour suivant,
+  discussion reprise après une tâche planifiée qui a pris le slot — et sans la
+  clé ils retardent le premier mot du message suivant. Avec `on`, dès que le
+  moteur local est libre après un tour ou une tâche, Loki lui envoie la requête
+  du prochain tour, assemblée par les mêmes fonctions que la vraie (contenu
+  vivant, rien de figé), suivie d'un message `.` et limitée à 1 jeton : le
+  moteur calcule le préfixe pendant que tu lis, et le vrai message ne calcule
+  plus que lui-même. Le jeton et le `.` sont jetés, rien n'est enregistré. Toute
+  autre requête de Loki l'annule aussitôt, sauf un message dont la requête
+  prolonge exactement le préfixe préparé (même historique, mêmes outils, mêmes
+  réglages du gabarit). Jamais avec plus d'un slot (`PARALLEL` ou `-np` dans
+  `EXTRA_ARGS`) — sauf les deux de `SIDE_SLOT`, où il prépare le slot de la
+  discussion —, pendant un tour, une tâche, un bench, ni vers un preset externe.
+  `full` prépare aussi la discussion qu'on ouvre, si on y reste 3 s. Visible dans
+  la télémétrie sous `prewarm`. Ce que voit le modèle ne change pas : au pire, le
+  préchauffage ne sert à rien (moteur sans points de reprise aux messages
+  utilisateur, image juste avant, agent ou web changé avant d'envoyer).
+- **Compaction en continuation** (clé `COMPACT_CONTINUATION`, **off** par
+  défaut, `loki config set COMPACT_CONTINUATION on`) : sans la clé, le résumé
+  d'une compaction part dans une requête à part — un prompt de résumeur et une
+  transcription des anciens tours — que le moteur local calcule à froid, des
+  dizaines de secondes sur un 27B, des minutes sur un MoE. Avec la clé, quand le
+  slot porte encore le prompt de la discussion, Loki renvoie la requête du tour
+  telle qu'elle est partie (mêmes messages, outils, arguments du gabarit et
+  intensité de raisonnement) suivie d'une seule demande de résumé : le moteur ne
+  calcule que celle-ci. La demande désigne le premier message gardé tel quel,
+  demande de tout résumer avant lui et de dater l'état d'avancement à cet
+  endroit ; mêmes règles de résumé qu'avant (mode Code compris), même budget,
+  température 0.2 sans l'échantillonnage du preset, réflexion coupée,
+  `tool_choice` à `none`. Ce qui est compacté, archivé et rangé ne change pas :
+  la requête sert seulement à obtenir le résumé, et rien du prompt système ou du
+  projet n'entre dans l'historique. Repli sur la transcription au moindre
+  écart : autre requête passée par le slot depuis le tour (vérification du mode Code,
+  sous-agent, tâche, préchauffage, bench, client `/v1`, autre discussion),
+  moteur relancé sur un autre modèle ou une autre fenêtre, marge insuffisante
+  dans la fenêtre, refus du moteur, appel d'outil émis, résumé vide ou fait de
+  seul raisonnement ; un refus du gabarit ou un appel d'outil la suspend pour ce
+  modèle jusqu'au redémarrage (gpt-oss à intensité haute peut épuiser le budget
+  en réflexion : repli). La clé évite aussi un résumé voué au refus (même vide,
+  il ne réduirait pas le contexte de 20 %) et, après un refus faute de réduction,
+  n'en redemande pas avant que le contexte ait grossi de 10 % sur le même fil —
+  sauf à 90 % de la fenêtre ou après une édition, une régénération ou un fil
+  vidé. Le filet réactif (prompt refusé), le bouton « compacter », les tâches,
+  les sous-agents et un preset externe gardent le chemin d'avant. Visible dans la
+  télémétrie sous `compact`.
+- **Images d'outils gardées** (clé `KEEP_TURN_IMAGES`, **off** par défaut,
+  **zone grise**, `loki config set KEEP_TURN_IMAGES on`) : sans la clé, une
+  image montrée par un outil (`web_screenshot`, `browser_screenshot`,
+  `see_image`) n'est vue que pendant le tour ; au tour suivant elle manque à
+  l'historique, et toute la boucle d'outils qui la suivait — souvent des
+  dizaines d'étapes de navigation — est recalculée. Avec `on`, elle reste dans
+  l'historique telle qu'envoyée, rangée par référence (`chatimg/`, chiffrée si
+  la mémoire l'est), sous conditions : vision réellement active (projecteur
+  chargé, revérifié à chaque tour — un preset sans vision n'en reçoit jamais) ;
+  coût mesuré par le moteur (écart du nombre de jetons du prompt entre deux
+  requêtes), et une image qu'on ne sait pas mesurer reste éphémère ; toutes les
+  images gardées tiennent dans 10 % de la fenêtre, la première qui dépasse et
+  celles qui la suivent dans le tour restent éphémères. Plus d'images gardées,
+  c'est plus de contexte, donc une compaction (avec perte) plus tôt : toute
+  compaction ou réduction forcée retire ces images **d'abord** (leur légende et
+  une mention « image non gardée » restent) et ne résume ensuite que si c'est
+  encore nécessaire ; rouvrir la discussion les retire aussi, comme les pièces
+  jointes. Discussion seulement (ni tâche, ni sous-agent, ni vérification). Un
+  preset externe n'est concerné que si sa vision est déclarée, et l'API
+  refacture alors ces images à chaque tour. Le gain suppose que le moteur
+  reprenne son cache au-delà d'une image ; sur un modèle hybride (Qwen3.5/3.6),
+  dont les points de reprise ne suivent pas toujours une image, à vérifier dans
+  la télémétrie (`lost` du tour suivant) avant de l'adopter. Sans la clé, la
+  requête est identique à l'octet près.
+- **Rappel de budget dans le résultat d'outil** (clé `NUDGE_IN_TOOL`, **off**
+  par défaut, **zone grise**, `loki config set NUDGE_IN_TOOL on`) : après un
+  grand nombre d'appels d'outils dans un même tour, Loki rappelle au modèle de
+  conclure, dans un message à part. Sur un gabarit dont le rendu change dès
+  qu'un message s'ajoute (Qwen3.5 : ce message devient la « dernière question »
+  et tout le tour est rendu autrement), ce rappel fait recalculer toute la
+  boucle d'outils du tour. Avec `on`, le rappel part au bout du dernier résultat
+  d'outil, et seul ce bout est à calculer — sur le moteur local, et seulement
+  si la sonde de gabarit a conclu que le rendu de ce modèle bouge pour la forme
+  de cette requête — mêmes outils, `chat_template_kwargs` et niveau de
+  raisonnement (« inconnu » ou forme jamais sondée : message à part, comme
+  sans la clé). Le texte du rappel ne change pas, sa
+  place si : un modèle entraîné à se méfier des consignes lues dans une sortie
+  d'outil peut moins bien le suivre. À comparer (tours qui concluent après le
+  rappel) avant de l'adopter.
+- **Second slot pour les travaux annexes** (clé `SIDE_SLOT`, **off** par
+  défaut, `loki config set SIDE_SLOT on`, moteur relancé) : avec un seul slot,
+  une vérification du mode Code, un sous-agent, une tâche planifiée ou un bench
+  prennent la place de la discussion ; son état part dans le cache RAM et en
+  revient — ou est recalculé s'il n'y tient plus. Avec `on`, le moteur ouvre
+  deux slots de `CTX` jetons **chacun** (`-c` 2×`CTX`, `--parallel 2`,
+  `--no-kv-unified`) : deux flux de cache KV séparés, si bien qu'un slot ne
+  peut jamais manquer de place à cause de l'autre, et que les travaux annexes
+  gardent toute la fenêtre. Chaque requête de Loki porte alors son `id_slot` :
+  le tour, ses étapes, le préchauffage et le résumé en continuation sur le
+  slot 0 ; vérification, sous-agents, tâches, bench, résumé sur transcription
+  et clients `/v1` (forcés, quel que soit l'`id_slot` demandé) sur le slot 1.
+  L'état de la discussion ne bouge plus ; l'effacement de slot après un
+  travail annexe (`CACHE_ISOLATE`) n'a plus lieu d'être et s'abstient. Le prix :
+  le cache KV et l'état récurrent d'un hybride en double en VRAM (le
+  brouillon MTP et les points de reprise en RAM hôte aussi) — l'éditeur de
+  preset affiche ce surcoût sous le cache de prompts, et le lancement refuse la
+  clé (un slot, comme sans elle, avec une note dans le journal) si modèle et
+  deux états dépassent 90 % de la VRAM, si la VRAM est inconnue (macOS, AMD),
+  si des poids sont sur CPU (`--n-cpu-moe`, `-ot …=CPU`, `NGL` partiel), si le
+  moteur ne connaît pas `--no-kv-unified`, ou si `PARALLEL`≠2, `-c`, `-np`,
+  `-kvu`, `--kv-unified-per-slot`, `--cache-idle-slots` (ou leurs
+  `LLAMA_ARG_*`) sont réglés à la main. Le routage ne s'active que si le moteur
+  annonce bien deux slots d'au moins `CTX` jetons (`/props`) ; sinon les
+  requêtes partent sans `id_slot`, comme avant. Ce que voit le modèle ne
+  change pas : deux slots qui calculent en même temps donnent des logits égaux
+  au bruit de virgule flottante près, comme un découpage de lots différent.
+  Un « cache KV plein » sans nombre de jetons (le pool, pas le prompt) est
+  rejoué tel quel et ne déclenche jamais de compaction.
+- **État du slot gardé à la bascule de preset** (clé `SLOT_PERSIST`, **off**
+  par défaut, `loki config set SLOT_PERSIST on`) : passer d'un preset A à B
+  puis revenir à A relance le moteur deux fois, et la conversation de A est
+  recalculée en entier au retour. Avec `on`, juste avant une bascule faite
+  depuis l'interface ou par une tâche, Loki demande au moteur d'écrire l'état
+  du slot de la discussion (`/slots/0?action=save`, sous `LOKI_HOME/slots`),
+  et le recharge au retour, avant le premier message de cette discussion.
+  Conditions strictes, sinon rien n'est écrit ou rechargé et le calcul est
+  normal : la dernière requête passée par le slot était bien un tour de
+  cette discussion (pas une vérification, une tâche, un préchauffage ou un
+  client `/v1`), au moins 4096 jetons, au plus 8 Gio estimés et le double
+  de place libre ; au retour, le moteur doit avoir **exactement** la même
+  empreinte — ligne de commande complète (modèle, `CTX`, types KV, `NGL`,
+  lots, gabarit, `EXTRA_ARGS`…), variables `LLAMA_ARG_*`/`GGML_*`/`CUDA_*`,
+  taille et date du modèle, du projecteur, du binaire et de ses bibliothèques
+  — et son slot 0 ne doit encore avoir servi aucune tâche. Une mise à jour du
+  moteur change l'empreinte : jamais de reprise d'un build à l'autre. Une
+  seule tentative par fichier, retiré ensuite ; deux fichiers au plus,
+  supprimés dès que la clé est retirée. Réglage de la machine : il survit aux
+  bascules comme `HOST` (un preset qui le pose l'emporte). Refusé au lancement (note au journal)
+  avec le décodage spéculatif (`SPEC`, brouillon dans `EXTRA_ARGS` : la
+  sauvegarde du moteur ne garde pas l'état du brouillon, et un brouillon MTP
+  détecté sur le slot bloque aussi), des poids sur CPU (MoE déporté), un
+  `--slot-save-path` déjà réglé, ou un moteur joignable par d'autres sans clé
+  d'API (`HOST` autre que `127.0.0.1`). `loki switch` en ligne de commande ne
+  garde rien (seul le process web sait ce que porte le slot). Le gain est
+  réel surtout sur un modèle dense ; sur un hybride (Qwen3.5/3.6), le fichier
+  n'a pas de points de reprise et ne sert que si le message suivant prolonge
+  exactement les jetons gardés (gabarit qui rend le dernier tour à
+  l'identique), sinon recalcul comme avant. Ce que voit le modèle ne change
+  pas : llama.cpp ne reprend un état que sur un préfixe de jetons identique.
+  Avec `PREWARM`, le préchauffage passe par le slot après chaque tour : une
+  bascule faite ensuite ne garde rien (les deux clés se recouvrent peu). Une
+  simple lecture d'un client (`/v1/models`, `/health`) ne compte pas.
+- **Spéculation par n-grammes** (clé `SPEC`, valeurs `ngram` et `mtp+ngram`,
+  **off** par défaut, `loki config set SPEC ngram`, moteur relancé) : en mode
+  Code, le modèle recopie sans cesse ce qui est déjà dans le contexte (chemins,
+  diffs, arguments JSON, fichiers réécrits). `ngram` y cherche la suite des
+  24 derniers jetons et propose d'un coup les 48 à 64 suivants
+  (`--spec-type ngram-mod --spec-ngram-mod-n-match 24 --spec-ngram-mod-n-min 48
+  --spec-ngram-mod-n-max 64`, toujours en clair, jamais `--spec-default` dont
+  le contenu peut changer d'une version à l'autre) ; `mtp+ngram` ajoute la tête
+  MTP (`--spec-type draft-mtp,ngram-mod`), les n-grammes passant d'abord quand
+  ils trouvent. Chaque jeton reste tiré par le modèle et un jeton proposé n'est
+  gardé que s'il coïncide : même distribution, mais pas le même texte au bit
+  près (la vérification par lots n'emprunte pas les noyaux du décodage jeton
+  par jeton) — on compare des sessions rejouées, pas des diffs. Rien n'est posé
+  si le moteur ne connaît pas `--spec-ngram-mod-n-match`, si `EXTRA_ARGS` ou
+  `LLAMA_ARG_SPEC_TYPE` règlent déjà la spéculation (`--spec-type`, qui
+  s'additionne au lieu de remplacer, `--spec-default`, `--spec-ngram-*`, `-md`…),
+  ou, pour `ngram`, si un `--spec-draft-*` y figure. `mtp+ngram` sans tête MTP
+  (ni dans le fichier ni en `MODEL_DRAFT`) ou sans `draft-mtp` dans le moteur
+  retombe sur les n-grammes seuls, avec une note. Avec `ngram`, une tête MTP
+  présente reste inutilisée (le type explicite coupe le choix automatique) : la
+  note le dit. Poids sur CPU (`--n-cpu-moe`, `-ot …=CPU`, `NGL` partiel) :
+  refusé tant que `GGML_OP_OFFLOAD_MIN_BATCH` (clé `OP_OFFLOAD_MIN_BATCH`) ne
+  dépasse pas le lot de vérification de 65 jetons — sinon chaque brouillon
+  recopierait les experts vers le GPU ; `OP_OFFLOAD_MIN_BATCH=128` pour
+  l'essayer, en mesurant aussi les lectures disque si le modèle dépasse la RAM.
+  Sur un hybride, chaque brouillon copie l'état récurrent (point de reprise)
+  et le recharge s'il est rejeté. `/api/perf/summary` donne l'acceptation par
+  nature de requête (`kinds.<nature>.draft_rate`) : à garder là où elle paie.
+  Les drapeaux d'acceptation synthétique (`--spec-synth-*`, « benchmarking
+  only »), que Loki ne pose jamais, déclenchent un avertissement au lancement.
+- **Parallélisme de tenseurs** (clé `SPLIT_MODE=tensor`, **off** par défaut,
+  expérimental, moteur relancé) : au lieu de donner à chaque carte des couches
+  entières (`-sm layer`, défaut), chaque couche est coupée entre les cartes,
+  qui additionnent ensuite leurs morceaux. L'amont mesure un décodage plus
+  rapide mais un prefill nettement plus lent : sur deux GeForce en PCIe et une
+  boucle d'agent qui relit beaucoup, à mesurer par tour avant de l'adopter.
+  Loki n'active le mode que si l'aide du moteur liste `{none,layer,row,tensor}`
+  (le mot « tensor » seul est partout), et ajoute alors `-ngl all`, `-ts` au
+  prorata de la VRAM totale des cartes dans l'ordre du moteur (`--device`
+  compris), `-fa on` — chacun seulement s'il n'est pas déjà dans `EXTRA_ARGS`
+  ou une `LLAMA_ARG_*` — et `GGML_CUDA_ALLREDUCE=internal` si l'environnement
+  ne le fixe pas : le chemin NCCL compresse en BF16 les grosses réductions du
+  prefill, une perte de précision ; la réduction interne garde le type natif.
+  « NCCL not compiled in » au journal est alors sans effet ; `GGML_CUDA_P2P=1`
+  reste à poser soi-même si le pilote le permet. Pas de `--fit` en mode
+  tensor : Loki estime poids + cache de `CTX` jetons et refuse au-delà de 90 %
+  de la VRAM — jamais en réduisant `CTX`. Refusé aussi (découpe par couches,
+  note au journal) avec un cache KV autre que f16/bf16/f32 (jamais réécrit
+  d'office), des poids ou le cache KV sur CPU (`--n-cpu-moe`, `-ot`, `NGL`
+  partiel, `-nkvo`), `--backend-sampling`, `-fa off`, un `-sm` déjà réglé,
+  `SPEC`, `SIDE_SLOT`, `CTX` non chiffré, une seule carte ou une carte non
+  CUDA, une architecture que llama.cpp exclut (et `qwen4exp`), un preset
+  externe ; `SLOT_PERSIST` est refusé avec la clé.
+- **Guide de placement entre cartes inégales** (éditeur de preset, groupe
+  « Cartes graphiques », dès deux cartes ; un conseil, rien n'est appliqué
+  d'office) : chaque carte CUDA affiche sa liaison PCIe maximale (génération,
+  largeur), l'actuelle et l'horloge mémoire en info-bulle — lues par
+  `nvidia-smi` en une requête, jointes par nom de carte (rien pour deux
+  cartes homonymes ni pour un moteur Vulkan), avec repli sur la requête
+  historique si un vieux pilote refuse un champ. `loki gpu` les affiche aussi.
+  Le guide rappelle les deux règles du moteur, dans l'ordre qu'il voit
+  (`--device` compris) : en placement auto, `--fit` remplit d'abord la
+  **dernière** carte, qui porte la couche de sortie (modèle dense : la plus
+  rapide en dernier, ou une marge `FIT_TARGET` plus large sur la lente) ; les
+  experts MoE en RAM sont recopiés au prefill vers la **première** (à elle la
+  liaison la plus large). Les marges `FIT_TARGET` du preset sont montrées carte
+  par carte ; un `--tensor-split` (qui désactive `--fit`) ou un
+  `CUDA_VISIBLE_DEVICES` propre au preset (ordre réel différent) est signalé.
+  Un lien « inverser l'ordre » écrit `--device` (et retourne `--tensor-split`)
+  dans le preset édité. Pas de bouton de mesure automatique : comparer deux
+  ordres demande deux rechargements du moteur et un ordre inversé peut manquer
+  de VRAM sur la petite carte — dupliquer le preset, inverser l'ordre dans la
+  copie, « bench complet » sur chacun, et vérifier `offloaded N/N layers`.
+- **MoE aux experts sur CPU : avis et copie en placement auto** (jamais de
+  réécriture du preset). Au lancement (journal) et dans l'éditeur, sous
+  « Experts MoE sur CPU », pour un modèle dont le GGUF annonce des experts :
+  experts placés à la main (`-ot` visant `…exps…` vers le CPU, `--n-cpu-moe`,
+  `--cpu-moe` — un `-ot` de la seule couche d'entrée `per_layer_token_embd` ne
+  compte pas) → `--fit` ne les place pas, et monter `UBATCH` seul grossirait
+  le tampon de calcul de chaque carte sans personne pour rééquilibrer (monter
+  `--n-cpu-moe` d'abord) ; placement auto avec un modèle plus gros que la VRAM
+  et `UBATCH` ≤ 512 → « UBATCH 2048+ recommandé » (les experts restés en RAM
+  sont recopiés vers le GPU à chaque micro-lot du prefill) ; moteur sans
+  `--fit` → « garde `--n-cpu-moe` » ; `--fit` coupé par un autre `-ot` → rien
+  ne sort les experts du GPU. Le bouton **« Dupliquer en placement auto… »**
+  crée une **copie** du preset affiché, sous « (placement auto) », sans la
+  bascule : `-ot` des experts (et celui de `per_layer_token_embd`, redondant :
+  llama.cpp garde toujours la couche d'entrée au CPU), `--n-cpu-moe`,
+  `--cpu-moe`, `-ngl`, `--tensor-split`, `--fit off`, `-b`/`-ub` et drapeaux
+  de chargement retirés ; `NGL` retiré (`-ngl auto`), `UBATCH=2048`,
+  `BATCH=4096`, `--load-mode mmap` ; `CTX`, cache KV (quantifié ou non : à
+  garder identique pour comparer), échantillonnage intacts. Refusé si la copie
+  ne tournerait pas en `--fit` (autre `-ot`, `-sm row/tensor`, `SPLIT_MODE`,
+  `--n-cpu-ffn`) ou si `CTX` vaut 0. Après bascule : `successfully fit params`
+  au journal (`failed to fit` = tous les experts sur GPU, revenir à
+  l'original), puis bench complet des deux.
+- **Garde du mode de chargement** (clé d'échappement `LOAD_GUARD=off`, dans
+  le preset) : `--load-mode none`, `mlock`, `dio`, `mmap+mlock` (ou
+  `--no-mmap`, `--mlock` sur un moteur ancien, ou leurs `LLAMA_ARG_*`) gardent
+  en RAM tous les poids laissés au CPU. Loki en estime la part — modèle
+  (toutes tranches) moins VRAM totale, tout le modèle sur un Mac Apple Silicon — face à la
+  RAM effective (limite du conteneur cgroup comprise) : avertissement au-delà
+  de 80 % (llama.cpp #26110 : swap, décodage de 25 à 7,5 t/s ; mlock : processus
+  tué) ; **refus** au lancement seulement quand la borne basse dépasse 90 %
+  (échec certain), avec la raison en clair, aussi affichée par l'interface.
+  Le refus sort avec le code 78, que l'unité systemd écrite par
+  `loki install` ne relance pas (`RestartPreventExitStatus=78`) ; une unité
+  d'une version précédente (ou launchd) reçoit une sortie sans erreur pour ne
+  pas boucler — `sudo systemctl edit loki-engine` (section `[Service]`,
+  `RestartPreventExitStatus=78`) met l'unité à jour.
+  La VRAM qui fonde un refus est celle des cartes que le moteur liste
+  lui-même (`--list-devices`, lu seulement quand un refus se profile sur la
+  VRAM NVIDIA) : un moteur Vulkan sur cartes mixtes NVIDIA + AMD compte les
+  deux. Liste illisible, VRAM inconnue (Mac Intel, AMD seule, `--device`) ou
+  serveurs `--rpc` : avertissement, jamais de refus. `mmap` et `auto` ne sont jamais concernés ;
+  `LLAMA_ARG_NO_MMAP`/`LLAMA_ARG_MLOCK` ne comptent que sur un moteur ancien
+  (un moteur à `--load-mode` les ignore). Rien ne change dans la ligne de
+  commande.
+- **Optimiseur sans perte** (`loki tune`, bouton **« Optimiser… »** dans
+  l'éditeur du preset en service ; rien ne tourne de soi-même, aucune clé de
+  config). Cherche, pour cette machine et ce build du moteur, les réglages
+  d'ordonnancement qui raccourcissent un tour de conversation, sans rien changer
+  à ce que calcule le modèle (sortie équivalente en distribution : les sommes
+  flottantes ne sont pas identiques au bit près d'un lot ou d'un placement à
+  l'autre ; la spéculation vérifie chaque jeton). **Isolation** : le vrai moteur
+  est arrêté (comme « décharger la VRAM »), chaque essai est une **copie** de la
+  configuration avec ses surcharges dans `LOKI_HOME/tune/run/` — `config.env`
+  n'est jamais écrit — lancée par `loki serve` sur `127.0.0.1` et un port libre,
+  mêmes `CUDA_VISIBLE_DEVICES` ; son groupe de processus est tué en sortie
+  quoi qu'il arrive, puis le vrai moteur est relancé. **Verrou** exclusif entre
+  processus (`LOKI_HOME/tune.lock`, PID + instant de démarrage + binaire) :
+  pendant la mesure, tout démarrage du moteur (`serviceAction`, toutes
+  plateformes), bascule ou enregistrement de preset, choix des GPU, clé d'API,
+  mise à jour ou recompilation du moteur, rechargement de la VRAM, bench, chat,
+  compaction, `bash_bg` et clients `/v1` (503) sont refusés avec une phrase
+  claire ; les tâches planifiées attendent. Un verrou dont le propriétaire est
+  mort (Loki tué en plein essai) est écarté avant tout démarrage du moteur :
+  l'essai orphelin n'est arrêté que si PID, instant de démarrage ET binaire
+  concordent (`taskkill /T` sous Windows), et le moteur est relancé s'il
+  tournait avant — au démarrage de l'interface, puis toutes les 30 s par le
+  processus web (un `stat` tant qu'aucun verrou n'existe) : un `loki tune` tué
+  par `kill -9` ne laisse plus le moteur arrêté. **Refus d'entrée** : preset
+  externe, aucun preset actif, génération, tâche, bench ou job `bash_bg` en
+  cours, moteur occupé (`/slots`) — en ligne de commande, seul ce dernier
+  contrôle voit le processus web : préférer le bouton. En ligne de commande
+  aussi, un moteur qui ne serait pas celui de ce `LOKI_HOME` (il répond alors
+  que ce dossier le dit arrêté, refuse sa clé d'API ou sert un autre `MODEL` :
+  typiquement `sudo loki tune`, qui perd un `LOKI_HOME` exporté) fait
+  refuser, avec la marche à suivre. **Essais** (descente étape par étape depuis
+  la meilleure configuration du moment, chaque axe seulement si l'aide du
+  moteur et la machine le permettent) : placement — seulement avec « inclure
+  le placement » / `--placement` : `--fit` à la place des experts placés à la
+  main (`-ot …exps…`, `--n-cpu-moe`, `--cpu-moe`) ou d'un `--tensor-split` ;
+  marges `FIT_TARGET` (2 cartes ou plus, `--fit-target` dans l'aide) ;
+  `UBATCH` ∈ {512, 1024, 2048, + 4096 pour un MoE} × `BATCH` ∈ {max(2048, ub),
+  2 × ub ≤ 8192}, lot > micro-lot sur 2 cartes tout GPU, jamais de micro-lot
+  plus grand sans `nvidia-smi` ; `OP_OFFLOAD_MIN_BATCH` ∈ {32, 128, 512} et
+  threads (omis = cœurs physiques, physiques − 1, moitié ; Linux) seulement
+  avec des poids sur CPU ; `CUDA_LAUNCH_QUEUES` off/4x sur 2 cartes ou plus ;
+  avec « inclure les options opt-in » / `--opt-in` : `SPEC=auto`,
+  `SPEC_N_MAX` ∈ {2, 3, 4}, `CUDA_GRAPH_OPT=on`, `--backend-sampling`. Un
+  réglage qu'`EXTRA_ARGS` écraserait (`-ub`, `-t`, `-fitt`…) est réglé **dans
+  EXTRA_ARGS, sur place** ; EXTRA_ARGS est traité jeton par jeton et seuls les
+  drapeaux de la liste blanche (`-ot` des experts, `-ncmoe`, `-cmoe`, `-sm`,
+  `-ts`, `-mg`, `-fit`, `-fitt`, `-b`, `-ub`, `-t`, `-tb`, + `--spec-draft-n-max`
+  et `-bs` en opt-in) bougent ; tous les autres jetons (`--cache-type-k`,
+  `--flash-attn`, `--chat-template-file`…) ressortent à l'octet près. **Jamais
+  touchés** : `MODEL`, `CTX`, `KV_TYPE*` (un cache déjà quantifié est signalé
+  zone grise, jamais modifié), `MMPROJ`, `REASONING*`, `TEMP` et autres clés
+  d'échantillonnage, `PARALLEL`, `NGL`, `SPLIT_MODE`, `CUDA_VISIBLE_DEVICES`.
+  **Garde-fous** : chaque essai est d'abord composé à blanc (`loki serve` sans
+  rien charger) et sa ligne de commande comparée à celle de référence hors
+  réglages permis — toute autre différence (contexte, cache KV, flash-attn,
+  slots, variable du moteur…) l'écarte comme « dénature » ; une fois chargé,
+  `n_ctx`, `total_slots` (`/props`) et les types du cache KV (journal) sont
+  recomparés ; moins de couches déportées que la référence = « fit en recul »
+  (performance), écarté ; moins de 768 Mio de VRAM libre sur une carte après la
+  mesure (+ 512 avec `MMPROJ`) = « trop juste », jamais retenu ; échec de
+  chargement ou OOM = essai ignoré ; deux essais à la même ligne de commande ne
+  sont mesurés qu'une fois. **Mesure** : le bench complet (prefill à froid à une
+  profondeur D fixe pour tous les essais, trois tours qui reprennent le cache —
+  points de reprise réels d'un hybride compris —, decode à D, ligne courte en
+  prose), avec l'échantillonnage et le raisonnement du preset. **Score** : durée
+  d'un tour type = K / prefill des tours + G / decode à D + f × D / prefill à
+  froid, K, G et f tirés des médianes de la télémétrie (`/api/perf/summary`)
+  quand elle en a vu assez, sinon 2000, 600 et 5 %. La référence est mesurée
+  deux fois ; un essai ne gagne que s'il bat la meilleure configuration du
+  moment de plus de max(3 %, écart entre passages) sur **deux** passages, sans
+  ralentir de plus de 5 % le decode en prose. Budget par défaut 30 min
+  (`--budget`), ETA et annulation ; au-delà, résultat partiel dit tel ; étapes de
+  base à la carte (`--stages lots,threads…`, cases de la fenêtre). **Résultat**
+  : les mesures de chaque essai et le diff des clés, enregistrés par preset
+  avec l'empreinte et le build du moteur (l'éditeur propose de relancer après
+  une mise à jour du moteur). **Rien n'est écrit sans un clic** : « enregistrer
+  dans une copie » (preset « (optimisé) », non activé) ou « appliquer à ce
+  preset » après confirmation du diff — et une confirmation de plus si
+  EXTRA_ARGS est réécrit par le placement. Le preset est sauvegardé
+  (`LOKI_HOME/tune/backup/`), réécrit clé par clé (commentaires et ordre
+  intacts), réappliqué ; la configuration active doit alors être exactement la
+  référence plus les clés réglées, le moteur redémarre et doit répondre avec le
+  même contexte et les mêmes slots puis tenir une sonde (prompt de D jetons et
+  decode) — sinon l'ancienne version est rétablie et le moteur relancé. Pendant
+  la mesure, le chat est indisponible : prévoir 10 à 40 minutes selon la taille
+  du modèle (un modèle relu depuis un disque lent recharge à chaque essai).
+
 ## Différences avec l'amont
 
 | | AJEAN (amont) | Loki (ce fork) |
@@ -536,6 +1086,40 @@ courant n'est pas touché. Le moteur livré par l'image reste par ailleurs intac
 Quand cette limite est atteinte pour de bon (CUDA majeur trop ancien), la
 solution reste le rebuild avec un `LLAMACPP_IMAGE` récent, ci-dessus.
 
+**Version recommandée.** Quand le moteur officiel qui tourne est antérieur à
+`b10864`, le panneau affiche un encart qui dit ce que la mise à jour apporte :
+les points de reprise des modèles hybrides (Qwen3.5/3.6, Qwen3-Next) ne sont plus
+évincés trop tôt — jusqu'à ~8 k jetons recalculés à chaque reprise —, le MTP
+rapide (graphes CUDA) arrive à `b11009` et le MTP de qwen4exp à `b11331`. Le
+décodage spéculatif reste coupé tant que `SPEC` n'est pas posé. L'encart se
+décide sans réseau, sur le build du moteur (jamais pour un llama.cpp compilé ou
+un fork, dont le numéro ne prouve rien). Le bouton **Mettre à jour vers la
+version recommandée** n'interroge le registre qu'au clic : il prend le dernier
+build publié, vérifie qu'il atteint `b10864` et que son tag figé
+(`server-cuda-bNNNNN`) existe bien, puis demande confirmation. Sans réseau, il
+le dit et n'installe rien. Rien n'est jamais mis à jour d'office, ni au
+démarrage.
+
+**Revenir à la version précédente.** Après une mise à jour, la version
+téléchargée qui tournait juste avant est gardée (les plus anciennes partent,
+~450 Mo chacune) ; le bouton **Revenir à la version précédente** y ramène sans
+réseau, et la version quittée devient à son tour « la précédente ».
+
+**Le rendu du raisonnement.** Depuis `b10763`, llama-server garde par défaut la
+réflexion des tours passés dans le gabarit (`preserve_reasoning`). Un gabarit
+qui la retirait de lui-même (Qwen3.6, gabarits à `clear_thinking`) la rend alors
+— vide, puisque Loki ne la renvoie pas sans `REASONING_ECHO` : le modèle
+relirait un historique où il n'a jamais réfléchi. Avant de basculer vers un tel
+moteur, Loki lit le gabarit chargé et le verdict de la sonde de gabarit ; si le
+prompt rendu va changer et que `REASONING_PRESERVE` n'est pas posé, la
+confirmation l'explique et propose de poser `REASONING_PRESERVE=off` dans le
+preset actif (case cochée seulement quand le changement est établi :
+sur un gabarit qui garde déjà la réflexion, comme Qwen3.8, `off` changerait à
+son tour le rendu). L'utilisateur choisit. Après la bascule, le rendu de
+quelques conversations synthétiques est comparé, via `/apply-template`, entre
+l'ancien et le nouveau moteur une fois le modèle chargé : le panneau dit s'il
+est identique, ou montre le premier écart.
+
 Derrière un miroir de registre ou un réseau qui n'atteint pas ghcr.io :
 `LOKI_OCI_REGISTRY=https://mon-miroir.interne` dans l'environnement du conteneur.
 

RELEASE_NOTES.md

@@ -1,93 +1,149 @@
-# Loki 0.14.0
+# Loki 0.15.0
 
-Loki rattrape AJEAN jusqu'à la 0.17.6 et reprend une série d'idées d'OpenFox
-pour le mode Code. Le gros du travail est invisible : des discussions qui ne se
-bloquent plus sur un contexte plein, des réponses qui survivent à une coupure
-réseau, un agent de code qui gaspille moins de tours.
+Une version entièrement consacrée à la vitesse, avec une règle tenue de bout en
+bout : **ne jamais dénaturer le modèle**. Rien ne touche à la quantification
+des poids, à l'échantillonnage, à la température, au budget de raisonnement ni
+au contenu du contexte. Ce qui est sans perte est actif d'office ; tout ce qui
+changerait ce que voit le modèle, le placement des poids ou les slots du moteur
+attend une clé. Sans clé, la requête et la ligne de commande restent celles
+d'avant.
 
-## Le contexte ne bloque plus la discussion
+La section **Performance** du README rassemble toutes les clés, leur défaut et
+leur prix.
 
-Sur une fenêtre de 65k, un tour qui lisait plusieurs gros fichiers d'un coup
-passait de 60 % à plus de 130 % sans jamais compacter, et le moteur répondait
-par un 400 qui figeait la discussion.
+## Actif d'office, sans perte
 
-- Le compactage en cours de tour compte aussi les résultats d'outils que le
-  moteur n'a pas encore vus.
-- Tout résultat d'outil est borné à 30 000 caractères **pour le modèle** ;
-  l'interface garde le résultat complet (« voir plus »).
-- En dernier recours, les gros résultats sont tronqués puis les plus vieux
-  échanges retirés, au lieu de laisser remonter l'erreur.
-- Le compactage ne fait plus répondre deux fois à une vieille question, et le
-  texte écrit avant un appel d'outil n'est plus rangé en double.
+**La conversation n'est plus recalculée pour rien.**
 
-## Presets : API compatible OpenAI
+- **Cache de prompts dimensionné** : le moteur garde en RAM une copie exacte des
+  conversations qu'il quitte. Son défaut ne tenait pas une conversation de 30 à
+  65 k jetons à côté d'un vérificateur ou d'un sous-agent : il l'évinçait, et
+  tout était recalculé (30 à 80 s sur un 27B). Il est maintenant agrandi pour un
+  modèle tout-GPU, et le slot est effacé après chaque travail annexe pour que la
+  conversation revienne du cache.
+- **Préfixe stable** : les rappels de Loki entrent dans l'historique tels
+  qu'envoyés, la relance après un 500 ne change plus les outils, la ligne MCP ne
+  manque plus au premier tour après un démarrage, l'ordre des trackers ne bouge
+  plus. Chacun de ces écarts faisait recalculer toute la boucle d'outils.
+- **Compaction moins tôt** : le raisonnement que Loki ne renvoie jamais ne
+  compte plus dans le contexte. La compaction (qui perd de l'information)
+  partait vers 44-47 k au lieu de 49 k sur une fenêtre de 65 k. Son résumé n'est
+  plus amputé de l'état d'avancement.
+- **Hybrides (Qwen3.5/3.6) sur un moteur ancien** : `--checkpoint-min-step 2048`
+  d'office quand la RAM le permet, pour ne plus retomber jusqu'à ~8 k jetons en
+  arrière à chaque reprise.
 
-Les presets d'API externe gagnent ce qui leur manquait :
+**Le matériel est mieux employé.**
 
-- une case **« le modèle accepte les images »** pour un modèle distant
-  multimodal ;
-- plus de `chat_template_kwargs` (propre à llama.cpp) envoyé à l'API : une API
-  stricte répondait 400 et **chaque compactage échouait** ;
-- **reprise automatique** quand le flux se coupe en pleine réponse (Wi-Fi, VPN,
-  proxy) : jusqu'à 5 fois, le modèle reprend là où il s'était arrêté ;
-- un 401, 429 ou 502 n'est plus pris pour un appel d'outil mal formé ;
-- le débit est mesuré même quand l'API ne le donne pas ; le benchmark refuse de
-  mesurer un moteur local qui n'est pas celui du preset ; le badge des réponses
-  porte le nom du modèle distant.
+- **Threads CPU** : « auto » veut dire les cœurs physiques, plus tous les
+  threads logiques — c'est le décodage des experts MoE sur CPU qui payait.
+- **Deux GPU** : file de lancements CUDA élargie quand le pipeline entre cartes
+  est possible (même calcul ; seul le prompt peut gagner).
 
-## Mode Code
+**Loki lui-même pèse moins.**
 
-- **La vérification attend que le builder ait fini.** Il marque chaque critère
-  `completed` une fois fait ; tant qu'il en reste d'ouverts, il est relancé au
-  lieu de payer une passe de vérification sur un travail inachevé. Plus aucune
-  vérification ne part quand il vient de poser une question.
-- **Écriture refusée dès son chemin** : un `write` sur un fichier jamais lu
-  était refusé après tout le fichier généré. Le chemin passe maintenant en
-  premier et le refus coupe la génération aussitôt.
-- **Appel d'outil écrit en texte** (`<tool_call>`, format XML de Qwen3-Coder) :
-  repéré pendant le flux, coupé, et la relance cite l'extrait fautif.
-- `read_file`, `str_replace`, `old_string`… appris d'autres agents sont
-  traduits vers les vrais outils.
-- Les consignes du dépôt (**AGENTS.md**, CLAUDE.md) font partie du contexte.
-- Terminal : `cmd | tail -N` rend le **vrai** code de sortie, la sortie déjà
-  produite est gardée au délai dépassé, les couleurs ANSI sont retirées.
-- `git_status` / `git_diff` trouvent le dépôt cloné dans un sous-dossier.
-- Le compactage garde les fichiers touchés, les erreurs résolues et l'état des
-  critères.
+- Écrire un gros fichier ne coûte plus un temps quadratique côté Go (jusqu'à
+  8 s de CPU volées au décodage sur un MoE).
+- L'enregistrement de la discussion ne retarde plus le premier jeton.
+- Un seul `nvidia-smi` pour tous les onglets, aucun pour un onglet caché, un
+  seul à l'ouverture de l'éditeur de preset.
+- Unraid : un `/data` ou `/models` servi par la couche FUSE est signalé, avec
+  le remède.
 
-## Tâches et chat
+**On peut enfin mesurer.**
 
-- **« Rappelle-moi dans 20 minutes »** : `task_create` accepte `in_minutes` ou
-  `at`, à l'heure du navigateur (le conteneur tourne en UTC).
-- **Écrire pendant que l'IA répond** : le message part en file et le modèle en
-  tient compte dans la suite de sa réponse ; deux appareils qui envoient en
-  même temps ne se refusent plus.
-- Longues discussions : au chargement, les 20 derniers échanges, le début d'un
-  clic ; la liste des discussions se dessine par pages et montre la nouvelle
-  dès le premier message.
-- Mémoire : un mode par projet, et un quatrième, « recherche ».
-- Appels d'outils parallèles séparés selon leur index ; bascule de preset par
-  identifiant ; un raisonnement qui reprend après la réponse a sa propre bulle.
+- Chaque réponse dit ce qu'elle a repris du cache, recalculé et accepté du
+  brouillon ; `GET /api/perf/summary` en fait la synthèse par nature de requête
+  (`lost_events`, `lost_tokens` : le cache perdu, et après quoi).
+- **Bench** honnête, en tâche de fond : mode complet à profondeur réelle, tours
+  qui reprennent le cache, rien d'enregistré sans timings réels.
+- Une sonde du gabarit de chat dit, sans rien envoyer au modèle, si le rendu
+  reste stable d'un message à l'autre.
 
-## Sécurité et données
+**Garde-fous.** Un cache KV quantifié, `--context-shift` ou `--cache-reuse`
+posés à la main sont signalés. Un mode de chargement résident voué à l'échec
+(poids restés en RAM au-delà de 90 %) est refusé avec la raison en clair —
+`LOAD_GUARD=off` pour passer outre ; le refus n'est plus relancé en boucle par
+systemd, et un moteur Vulkan sur cartes mixtes n'est plus refusé à tort.
 
-- **Un site tiers ne peut plus piloter Loki** depuis le navigateur (Origin /
-  Sec-Fetch-Site, DNS rebinding). ⚠️ Derrière un reverse proxy par nom de
-  domaine, définis une clé de pilotage ou `LOKI_TRUSTED_HOSTS` **avant** la mise
-  à jour, et vérifie que le proxy transmet l'en-tête `Host` d'origine.
-- **Chiffrement de la mémoire** : l'activer rendait illisibles la discussion
-  active et le mode Code. Corrigé ; une base déjà touchée est réparée au
-  déverrouillage. Les résultats d'outils (« voir plus ») et les images du fil
-  sont désormais chiffrés eux aussi, et les images effacées après 24 h.
+## En opt-in : à essayer, à mesurer
 
-## Moteur
+| Clé | Ce qu'elle fait |
+|---|---|
+| `PREWARM=on` | prépare le prochain tour pendant que tu lis (`full` : aussi la discussion qu'on ouvre) |
+| `COMPACT_CONTINUATION=on` | le résumé de compaction prolonge le prompt en cache au lieu d'être calculé à froid |
+| `PROJ_SNAPSHOT=on` | bloc projet figé par discussion, changements livrés à part ; date et dossier sortent du système |
+| `REASONING_ECHO=on` | renvoie au moteur local la réflexion du modèle, au format entraîné |
+| `SPEC=auto` / `mtp` | décodage spéculatif MTP (tête détectée dans le fichier, garde-fous VRAM) |
+| `SPEC=ngram` / `mtp+ngram` | n-grammes du contexte, utiles en mode Code |
+| `SIDE_SLOT=on` | second slot pour les travaux annexes (VRAM en double) |
+| `SLOT_PERSIST=on` | état du slot gardé à la bascule de preset |
+| `SPLIT_MODE=tensor` | parallélisme de tenseurs entre cartes (expérimental) |
+| `FIT_TARGET`, `OP_OFFLOAD_MIN_BATCH`, `CUDA_GRAPH_OPT` | réglages d'expert pour cartes inégales et MoE |
+| `KEEP_TURN_IMAGES=on` | **zone grise** : garde les images des outils dans l'historique |
+| `NUDGE_IN_TOOL=on` | **zone grise** : rappel de budget dans le résultat d'outil |
 
-- `--mlock` seul ne coupe plus le mmap (OOM au chargement).
-- Port déjà occupé refusé avec un message clair ; cache KV lent signalé.
-- Réponses web compressées en gzip.
+Et deux outils qui ne font rien d'eux-mêmes :
+
+- **Optimiseur** (`loki tune`, bouton « Optimiser… ») : cherche lots, threads,
+  marges et placement sur un moteur d'essai isolé ; rien n'est écrit sans un
+  clic, et l'application est vérifiée puis défaite si le moteur ne tient pas.
+- **« Dupliquer en placement auto… »** pour un MoE aux experts placés à la
+  main : une copie du preset où `--fit` les répartit.
+
+## Ordre de test conseillé
+
+Une étape à la fois, mesurée avant la suivante :
+
+1. **Bench complet** du preset tel quel : la référence.
+2. **`PREWARM` + `COMPACT_CONTINUATION`**, une vraie session de travail, puis
+   `/api/perf/summary` : le cache perdu (`lost`) doit baisser.
+3. **Optimiseur** sur le preset en service.
+4. **MoE** : « Dupliquer en placement auto… », bench complet des deux.
+5. **Mise à jour du moteur** vers la version recommandée (encart du panneau
+   Moteur).
+6. **`SPEC=auto`** (ou `mtp`) si le modèle a une tête MTP.
+
+## Moteur : version recommandée et retour arrière
+
+Quand le moteur officiel est antérieur à `b10864`, le panneau Moteur dit ce
+qu'une mise à jour apporte (points de reprise des hybrides, MTP rapide) et la
+propose — sur clic seulement, version vérifiée sur le registre. La version
+quittée est gardée : **Revenir à la version précédente** y ramène sans réseau.
+
+Depuis `b10763`, llama-server garde par défaut la réflexion des tours passés :
+un gabarit comme Qwen3.6 la rendrait vide. Avant de basculer, Loki le détecte et
+propose `REASONING_PRESERVE=off` ; après, il compare le rendu de l'ancien et du
+nouveau moteur et signale le premier écart.
+
+## Ce qui a été écarté
+
+- **`--cache-reuse`** : réutilise du cache calculé sous un autre contexte, donc
+  change les sorties.
+- **`--context-shift`** : retire des jetons du contexte, et ne marche pas sur
+  les hybrides.
+- **Cache KV quantifié par défaut** : `q8_0` n'est pas exact, `q4_0` perd
+  mesurablement, pour ~2 Gio gagnés sur un 27B hybride. Reste un choix
+  explicite (`KV_TYPE`).
+
+## Autres corrections
+
+- Une compaction en plein tour ne fait plus disparaître le rappel des pages
+  mémoire lues.
+- Un `loki tune` tué net ne laisse plus le moteur arrêté ; lancé avec un autre
+  `LOKI_HOME` que l'interface (`sudo`), il refuse au lieu de charger un essai à
+  côté d'un moteur vivant.
+- L'ancienne option « n-grammes (mod) » de l'éditeur rejoint `SPEC=ngram`, avec
+  une migration proposée (jamais faite d'office).
+- Accès refusé : l'interface dit pourquoi et comment le lever.
 
 ## Mise à jour
 
 ```
 docker compose pull && docker compose up -d
 ```
+
+Installation systemd (`loki install`) : l'unité du moteur gagne
+`RestartPreventExitStatus=78`. `loki update` ne réécrit pas les unités ;
+`sudo loki install`, ou `sudo systemctl edit loki-engine` avec cette ligne dans
+`[Service]`, la met à jour.

cmd/loki/versioninfo.json

@@ -2,13 +2,13 @@
   "FixedFileInfo": {
     "FileVersion": {
       "Major": 0,
-      "Minor": 14,
+      "Minor": 15,
       "Patch": 0,
       "Build": 0
     },
     "ProductVersion": {
       "Major": 0,
-      "Minor": 14,
+      "Minor": 15,
       "Patch": 0,
       "Build": 0
     },
@@ -25,7 +25,7 @@
     "LegalCopyright": "Copyright (c) 2026 Loki contributors. MIT License.",
     "OriginalFilename": "loki.exe",
     "ProductName": "Loki",
-    "ProductVersion": "0.14.0",
+    "ProductVersion": "0.15.0",
     "Comments": "https://github.com/R0m1k3/Loki — projet open source (MIT)"
   },
   "VarFileInfo": {

docker-compose.unraid.yml

@@ -64,4 +64,8 @@ services:
       - /mnt/user/appdata/loki/data:/data
       # /models : dossier de .gguf déposés à la main (gros fichiers)
       - /mnt/user/appdata/loki/models:/models
+    # Moteur Strata (Qwen3.8 Flash Next) : il verrouille ses experts en RAM
+    # (mlock, 30 à 50 Go). La limite Docker par défaut (64 Ko) l'en empêche.
+    ulimits:
+      memlock: -1
     restart: unless-stopped

docker-compose.yml

@@ -37,4 +37,8 @@ services:
             - driver: nvidia
               count: all
               capabilities: ["gpu"]
+    # Moteur Strata (Qwen3.8 Flash Next) : il verrouille ses experts en RAM
+    # (mlock, 30 à 50 Go). La limite Docker par défaut (64 Ko) l'en empêche.
+    ulimits:
+      memlock: -1
     restart: unless-stopped

internal/loki/backend_build.go

@@ -44,20 +44,45 @@ func emitBuildLine(line string) {
 // Sert à téer la sortie des commandes de runStep quand un sink est actif.
 // (mutex : stdout et stderr d'une même commande peuvent écrire en parallèle)
 type sinkWriter struct {
-	mu  sync.Mutex
-	buf []byte
+	mu       sync.Mutex
+	buf      []byte
+	lastProg time.Time // dernière ligne de progression (\r) émise
 }
 
+// sinkProgressEvery : une barre de progression (tqdm, téléchargements de
+// l'installeur de Strata) se redessine sur place avec \r, sans jamais finir sa
+// ligne. On en montre une version toutes les 10 s : sans elle, un téléchargement
+// de 76 Go laissait le journal figé pendant une heure ; toutes, elles le noieraient.
+const sinkProgressEvery = 10 * time.Second
+
 func (s *sinkWriter) Write(p []byte) (int, error) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	s.buf = append(s.buf, p...)
 	for {
-		i := strings.IndexByte(string(s.buf), '\n')
+		i := strings.IndexAny(string(s.buf), "\r\n")
 		if i < 0 {
 			break
 		}
-		emitBuildLine(strings.TrimRight(string(s.buf[:i]), "\r"))
+		if s.buf[i] == '\n' {
+			emitBuildLine(strings.TrimRight(string(s.buf[:i]), "\r"))
+			s.buf = s.buf[i+1:]
+			continue
+		}
+		// \r : fin de ligne Windows (\r\n) ou barre qui se redessine. Le \n peut
+		// arriver dans l'écriture suivante : on attend de le savoir.
+		if i+1 >= len(s.buf) {
+			break
+		}
+		if s.buf[i+1] == '\n' {
+			emitBuildLine(string(s.buf[:i]))
+			s.buf = s.buf[i+2:]
+			continue
+		}
+		if prog := strings.TrimSpace(string(s.buf[:i])); prog != "" && time.Since(s.lastProg) >= sinkProgressEvery {
+			s.lastProg = time.Now()
+			emitBuildLine(prog)
+		}
 		s.buf = s.buf[i+1:]
 	}
 	return len(p), nil

internal/loki/backend_build_sink_test.go

@@ -0,0 +1,29 @@
+package loki
+
+import (
+	"reflect"
+	"testing"
+	"time"
+)
+
+// Une barre de progression (\r sans \n) doit apparaître dans le journal, sans
+// le noyer ; \r\n reste une fin de ligne ordinaire, même coupé entre deux écritures.
+func TestSinkWriterProgression(t *testing.T) {
+	var got []string
+	setBuildSink(func(l string) { got = append(got, l) })
+	defer setBuildSink(nil)
+
+	s := &sinkWriter{}
+	s.Write([]byte("Step 5\r"))
+	s.Write([]byte("\n  modèle : 1 / 76 GB\r  modèle : 2 / 76 GB\r"))
+	s.Write([]byte("  modèle : 3 / 76 GB\r"))
+	s.lastProg = time.Now().Add(-time.Minute) // 10 s écoulées
+	s.Write([]byte("  modèle : 40 / 76 GB\r[ok] fini\n"))
+
+	// « 3 » finissait sa propre écriture : il attendait de savoir si un saut de
+	// ligne suivait, et part donc avec l'écriture suivante.
+	want := []string{"Step 5", "modèle : 1 / 76 GB", "modèle : 3 / 76 GB", "[ok] fini"}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("lignes %q, attendu %q", got, want)
+	}
+}

internal/loki/backend_config.go

@@ -92,6 +92,9 @@ func maskAPIKey(k string) string {
 //	loki set-api-key           génère une clé aléatoire
 //	loki set-api-key ""        supprime la protection
 func cmdSetAPIKey(args []string) error {
+	if err := tuneGuard(); err != nil {
+		return err
+	}
 	var key string
 	switch {
 	case len(args) == 0:

internal/loki/backend_external_serve_test.go

@@ -0,0 +1,43 @@
+package loki
+
+import "testing"
+
+// Preset externe actif : `loki serve` n'a aucun moteur local à lancer. Il
+// sortait en erreur « MODEL non défini », que systemd (Restart=on-failure)
+// relançait en boucle (amont #95).
+func TestServeExitsCleanlyForExternalPreset(t *testing.T) {
+	testHome(t)
+	if err := WriteConfig(map[string]string{extKeyFlag: "1", "PORT": "8080"}); err != nil {
+		t.Fatal(err)
+	}
+	if err := cmdServe(nil); err != nil {
+		t.Fatalf("loki serve sur un preset externe : %v", err)
+	}
+}
+
+// Le pré-vol refusait `loki start` / `loki restart` sur un preset externe,
+// en invitant à réinstaller llama.cpp.
+func TestPreflightAcceptsExternalPreset(t *testing.T) {
+	testHome(t)
+	if err := WriteConfig(map[string]string{extKeyFlag: "1"}); err != nil {
+		t.Fatal(err)
+	}
+	if err := preflightEngine(); err != nil {
+		t.Fatalf("pré-vol refusé sur un preset externe : %v", err)
+	}
+}
+
+// Strata : le pré-vol vérifie sa configuration à lui, pas BIN/MODEL.
+func TestPreflightStrataWithoutConfig(t *testing.T) {
+	testHome(t)
+	if err := WriteConfig(map[string]string{"ENGINE": "strata"}); err != nil {
+		t.Fatal(err)
+	}
+	err := preflightEngine()
+	if err == nil {
+		t.Fatal("un preset Strata sans STRATA_CONFIG devrait être refusé")
+	}
+	if want := "STRATA_CONFIG"; !contains(err.Error(), want) {
+		t.Fatalf("message attendu sur %s : %v", want, err)
+	}
+}

internal/loki/backend_gpu.go

@@ -2,11 +2,14 @@ package loki
 
 import (
 	"bufio"
+	"context"
+	"errors"
 	"fmt"
 	"os"
 	"os/exec"
 	"strconv"
 	"strings"
+	"time"
 )
 
 // backend_gpu.go — sélection du/des GPU utilisés par llama-server.
@@ -26,6 +29,39 @@ type gpuInfo struct {
 	MemTotal string // en MiB
 	MemUsed  string
 	Cap      string // compute capability
+
+	// Liaison PCIe et horloge mémoire, pour guider le placement entre cartes
+	// inégales (voir annotateDevices). Zéro = inconnu : pilote trop ancien,
+	// « [N/A] », ou requête retombée sur les seuls champs historiques.
+	BusID        string
+	LinkGen      int // génération PCIe ACTUELLE — elle descend au repos (économie d'énergie)
+	LinkGenMax   int // génération maximale négociable carte + carte mère
+	LinkWidth    int // largeur actuelle (×N), elle aussi réduite au repos sur certaines cartes
+	LinkWidthMax int
+	MemClockMax  int // horloge mémoire maximale, MHz
+}
+
+// gpuBaseFields : la requête historique de detectGPUs, que tout pilote connaît.
+// gpuLinkFields : les champs de liaison, ajoutés en fin de ligne. nvidia-smi
+// refuse TOUTE la requête au moindre champ inconnu (« is not a valid field to
+// query ») : la largeur du bus mémoire, qui n'existe pas, n'y figure donc pas,
+// et un refus fait retomber sur la requête historique — jamais de GPU perdu
+// pour une information de confort.
+const (
+	gpuBaseFields = "index,name,memory.total,memory.used,compute_cap"
+	gpuLinkFields = "pci.bus_id,pcie.link.gen.current,pcie.link.gen.max,pcie.link.width.current,pcie.link.width.max,clocks.max.memory"
+)
+
+// nvidiaSmiGPUQuery lance « nvidia-smi --query-gpu=<fields> ». Variable pour
+// que les tests substituent un faux nvidia-smi. Borné dans le temps comme la
+// lecture des jauges (nvidiaSmiTimeout) : un pilote coincé ne doit pas figer
+// « loki gpu » ni l'éditeur de preset.
+var nvidiaSmiGPUQuery = func(fields string) ([]byte, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), nvidiaSmiTimeout)
+	defer cancel()
+	cmd := hideCmd(exec.CommandContext(ctx, "nvidia-smi", "--query-gpu="+fields, "--format=csv,noheader,nounits"))
+	cmd.WaitDelay = time.Second
+	return cmd.Output()
 }
 
 func cmdGPU(args []string) error {
@@ -83,6 +119,9 @@ func gpuList() error {
 	for _, g := range gpus {
 		mark := "  "
 		line := fmt.Sprintf("[%d] %s  —  %s/%s MiB  (cc %s)", g.Index, g.Name, g.MemUsed, g.MemTotal, g.Cap)
+		if l := g.linkSummary(); l != "" {
+			line += "  " + l
+		}
 		active := sel == "" || selected[g.Index]
 		if sel != "" && selected[g.Index] {
 			mark = green("● ")
@@ -109,6 +148,10 @@ func gpuList() error {
 // gpuSet writes (or clears) CUDA_VISIBLE_DEVICES in config.env then offers a
 // restart so the change takes effect.
 func gpuSet(value string) error {
+	// La sélection GPU relance le moteur : pas pendant une optimisation.
+	if err := tuneGuard(); err != nil {
+		return err
+	}
 	if err := SetConfigKey("CUDA_VISIBLE_DEVICES", value); err != nil {
 		return err
 	}
@@ -131,14 +174,46 @@ func detectGPUs() ([]gpuInfo, error) {
 	if !hasTool("nvidia-smi") {
 		return nil, fmt.Errorf("nvidia-smi introuvable — sélection GPU disponible uniquement sur NVIDIA")
 	}
-	out, err := hideCmd(exec.Command("nvidia-smi",
-		"--query-gpu=index,name,memory.total,memory.used,compute_cap",
-		"--format=csv,noheader,nounits")).Output()
+	return queryGPUs(nvidiaSmiGPUQuery)
+}
+
+// queryGPUs : le cœur de detectGPUs, la requête passée en paramètre pour être
+// testée sans nvidia-smi. UNE invocation d'ordinaire : champs historiques et
+// liaison ensemble. La seconde n'a lieu que si nvidia-smi refuse un champ de
+// liaison (pilote ancien) — pas sur un délai dépassé, qu'une relance ne ferait
+// que doubler.
+func queryGPUs(query func(fields string) ([]byte, error)) ([]gpuInfo, error) {
+	out, err := query(gpuBaseFields + "," + gpuLinkFields)
+	if err != nil && smiFieldRefused(out, err) {
+		out, err = query(gpuBaseFields)
+	}
 	if err != nil {
 		return nil, fmt.Errorf("nvidia-smi a échoué: %w", err)
 	}
+	gpus := parseGPUQuery(string(out))
+	if len(gpus) == 0 {
+		return nil, fmt.Errorf("aucun GPU NVIDIA détecté")
+	}
+	return gpus, nil
+}
+
+// smiFieldRefused : nvidia-smi a-t-il rejeté un champ de la requête ? Il
+// l'écrit sur sa sortie standard et sort en code 2 (argument invalide).
+func smiFieldRefused(out []byte, err error) bool {
+	if strings.Contains(string(out), "valid field") {
+		return true
+	}
+	var ee *exec.ExitError
+	return errors.As(err, &ee) && ee.ExitCode() == 2
+}
+
+// parseGPUQuery lit la sortie CSV de detectGPUs, avec ou sans les champs de
+// liaison. Fonction pure. Une ligne de moins de cinq colonnes est ignorée,
+// comme avant ; une valeur de liaison illisible (« [N/A] », « [Not
+// Supported] ») vaut zéro, sans faire tomber la carte.
+func parseGPUQuery(out string) []gpuInfo {
 	var gpus []gpuInfo
-	for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") {
+	for _, line := range strings.Split(strings.TrimSpace(out), "\n") {
 		parts := strings.Split(line, ",")
 		if len(parts) < 5 {
 			continue
@@ -147,12 +222,51 @@ func detectGPUs() ([]gpuInfo, error) {
 			parts[i] = strings.TrimSpace(parts[i])
 		}
 		idx, _ := strconv.Atoi(parts[0])
-		gpus = append(gpus, gpuInfo{
-			Index: idx, Name: parts[1], MemTotal: parts[2], MemUsed: parts[3], Cap: parts[4],
-		})
+		g := gpuInfo{Index: idx, Name: parts[1], MemTotal: parts[2], MemUsed: parts[3], Cap: parts[4]}
+		if len(parts) >= 11 {
+			if b := parts[5]; b != "" && b != "N/A" && !strings.HasPrefix(b, "[") {
+				g.BusID = b
+			}
+			g.LinkGen, g.LinkGenMax = smiNum(parts[6]), smiNum(parts[7])
+			g.LinkWidth, g.LinkWidthMax = smiNum(parts[8]), smiNum(parts[9])
+			g.MemClockMax = smiNum(parts[10])
+		}
+		gpus = append(gpus, g)
 	}
-	if len(gpus) == 0 {
-		return nil, fmt.Errorf("aucun GPU NVIDIA détecté")
+	return gpus
+}
+
+// smiNum lit un entier de nvidia-smi ; « [N/A] », vide ou autre chose = 0.
+func smiNum(s string) int {
+	n, err := strconv.Atoi(strings.TrimSpace(s))
+	if err != nil || n < 0 {
+		return 0
 	}
-	return gpus, nil
+	return n
+}
+
+// linkSummary : la liaison PCIe en clair, « PCIe 4 ×16 », maximum d'abord —
+// l'actuel descend au repos et ne dit rien de la carte sous charge. Vide =
+// inconnue.
+func (g gpuInfo) linkSummary() string {
+	if g.LinkGenMax == 0 && g.LinkWidthMax == 0 {
+		return ""
+	}
+	s := "PCIe"
+	if g.LinkGenMax > 0 {
+		s += " " + strconv.Itoa(g.LinkGenMax)
+	}
+	if g.LinkWidthMax > 0 {
+		s += " ×" + strconv.Itoa(g.LinkWidthMax)
+	}
+	if (g.LinkGen > 0 && g.LinkGen < g.LinkGenMax) || (g.LinkWidth > 0 && g.LinkWidth < g.LinkWidthMax) {
+		known := func(n int) string {
+			if n <= 0 {
+				return "?"
+			}
+			return strconv.Itoa(n)
+		}
+		s += " (actuellement " + known(g.LinkGen) + " ×" + known(g.LinkWidth) + ", réduit au repos)"
+	}
+	return s
 }

internal/loki/backend_gpu_test.go

@@ -0,0 +1,88 @@
+package loki
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+// La sortie enrichie : liaison et horloge lues, « [N/A] » et « [Not
+// Supported] » valent zéro sans faire tomber la carte.
+func TestParseGPUQueryLiaison(t *testing.T) {
+	out := `0, NVIDIA GeForce RTX 5060 Ti, 16311, 900, 12.0, 00000000:01:00.0, 1, 5, 8, 8, 14001
+1, NVIDIA GeForce RTX 3060, 12288, 300, 8.6, 00000000:05:00.0, [N/A], 4, [Not Supported], 16, [N/A]
+`
+	g := parseGPUQuery(out)
+	if len(g) != 2 {
+		t.Fatalf("%d carte(s), attendu 2 : %+v", len(g), g)
+	}
+	if g[0].BusID != "00000000:01:00.0" || g[0].LinkGen != 1 || g[0].LinkGenMax != 5 ||
+		g[0].LinkWidth != 8 || g[0].LinkWidthMax != 8 || g[0].MemClockMax != 14001 {
+		t.Errorf("carte 0 mal lue : %+v", g[0])
+	}
+	if g[1].LinkGen != 0 || g[1].LinkGenMax != 4 || g[1].LinkWidth != 0 || g[1].LinkWidthMax != 16 || g[1].MemClockMax != 0 {
+		t.Errorf("valeurs [N/A] mal tolérées : %+v", g[1])
+	}
+	if g[1].MemTotal != "12288" || g[1].Cap != "8.6" {
+		t.Errorf("champs historiques perdus : %+v", g[1])
+	}
+	if s := g[0].linkSummary(); s != "PCIe 5 ×8 (actuellement 1 ×8, réduit au repos)" {
+		t.Errorf("résumé de liaison : %q", s)
+	}
+	if s := g[1].linkSummary(); s != "PCIe 4 ×16" {
+		t.Errorf("résumé sans valeur actuelle : %q", s)
+	}
+}
+
+// La sortie historique (cinq colonnes) se lit comme avant, sans liaison.
+func TestParseGPUQueryHistorique(t *testing.T) {
+	g := parseGPUQuery("0, NVIDIA GeForce RTX 3080 Ti, 12288, 1442, 8.6\n")
+	if len(g) != 1 || g[0].Name != "NVIDIA GeForce RTX 3080 Ti" || g[0].MemTotal != "12288" {
+		t.Fatalf("lecture historique cassée : %+v", g)
+	}
+	if g[0].LinkGenMax != 0 || g[0].BusID != "" || g[0].linkSummary() != "" {
+		t.Errorf("liaison inventée : %+v", g[0])
+	}
+}
+
+// Un pilote qui refuse un champ de liaison : la requête historique prend le
+// relais, les cartes restent détectées. Une autre erreur (délai dépassé) n'est
+// pas relancée.
+func TestQueryGPUsRepli(t *testing.T) {
+	var calls []string
+	refuse := func(fields string) ([]byte, error) {
+		calls = append(calls, fields)
+		if strings.Contains(fields, "pcie") {
+			return []byte(`Field "pcie.link.gen.max" is not a valid field to query.` + "\n"), errors.New("exit status 2")
+		}
+		return []byte("0, NVIDIA GeForce RTX 3060, 12288, 300, 8.6\n"), nil
+	}
+	g, err := queryGPUs(refuse)
+	if err != nil || len(g) != 1 || g[0].Name != "NVIDIA GeForce RTX 3060" {
+		t.Fatalf("repli raté : %+v, %v", g, err)
+	}
+	if len(calls) != 2 || calls[1] != gpuBaseFields {
+		t.Errorf("requêtes : %q", calls)
+	}
+
+	calls = nil
+	hang := func(fields string) ([]byte, error) {
+		calls = append(calls, fields)
+		return nil, errors.New("signal: killed")
+	}
+	if _, err := queryGPUs(hang); err == nil {
+		t.Error("erreur avalée")
+	}
+	if len(calls) != 1 {
+		t.Errorf("un délai dépassé relancé : %d requêtes", len(calls))
+	}
+
+	calls = nil
+	ok := func(fields string) ([]byte, error) {
+		calls = append(calls, fields)
+		return []byte("0, NVIDIA GeForce RTX 3060, 12288, 300, 8.6, 00000000:05:00.0, 4, 4, 16, 16, 7501\n"), nil
+	}
+	if g, err := queryGPUs(ok); err != nil || len(calls) != 1 || g[0].LinkWidthMax != 16 {
+		t.Errorf("une seule requête attendue : %d, %+v, %v", len(calls), g, err)
+	}
+}

internal/loki/backend_llamacpp.go

@@ -217,6 +217,9 @@ func llamacppInstall(args []string) error {
 // ---------------------------------------------------------------------------
 
 func llamacppUpdate(args []string) error {
+	if err := tuneGuard(); err != nil {
+		return err
+	}
 	ref := ""
 	clean := false
 	noRestart := false

internal/loki/backend_presets.go

@@ -113,7 +113,69 @@ func ListPresets() ([]Preset, error) {
 		})
 	}
 	sort.Slice(out, func(i, j int) bool { return out[i].Name < out[j].Name })
-	return out, nil
+	return applyPresetOrder(out), nil
+}
+
+// presetOrderKey : ordre d'affichage choisi par glisser-déposer dans l'UI
+// (repris d'AJEAN v0.10.9), une liste d'IDs persistée en base.
+const presetOrderKey = "preset_order"
+
+func loadPresetOrder() []string {
+	var ids []string
+	getJSON(bkState, presetOrderKey, &ids)
+	return ids
+}
+
+func savePresetOrder(ids []string) error { return putJSON(bkState, presetOrderKey, ids) }
+
+// applyPresetOrder réordonne `list` (déjà trié par nom) selon l'ordre stocké :
+// d'abord les presets classés dans l'ordre choisi, puis les non classés
+// (fraîchement créés) dans leur ordre alphabétique. Tri STABLE.
+func applyPresetOrder(list []Preset) []Preset {
+	order := loadPresetOrder()
+	if len(order) == 0 {
+		return list
+	}
+	pos := map[string]int{}
+	for i, id := range order {
+		pos[id] = i
+	}
+	sort.SliceStable(list, func(i, j int) bool {
+		pi, oki := pos[list[i].ID]
+		pj, okj := pos[list[j].ID]
+		if oki && okj {
+			return pi < pj
+		}
+		if oki != okj {
+			return oki // un preset classé passe avant un non classé
+		}
+		return false // deux non classés : l'ordre alphabétique reste
+	})
+	return list
+}
+
+// presetCtx : la taille de contexte d'un preset, formatée pour la pastille de
+// la liste (« 32K », « 128K », « 1M »). CTX absent = 32768, le défaut de serve.
+func presetCtx(content string) string {
+	raw := strings.TrimSpace(parseEnv(content)["CTX"])
+	if raw == "" {
+		raw = "32768"
+	}
+	n, err := strconv.Atoi(raw)
+	if err != nil || n <= 0 {
+		return ""
+	}
+	// Multiple de 1024 (32768, 131072…) : écrit comme on le pense, « 32K »,
+	// « 128K » ; sinon décimal, comme on le tape (40000 → « 40K »).
+	switch {
+	case n >= 1024 && n%1024 == 0 && n < 1<<20:
+		return strconv.Itoa(n/1024) + "K"
+	case n >= 1000000:
+		return strings.TrimSuffix(strconv.FormatFloat(float64(n)/1000000, 'f', 1, 64), ".0") + "M"
+	case n >= 1000:
+		return strconv.Itoa((n+500)/1000) + "K"
+	}
+	return strconv.Itoa(n)
 }
 
 // uniquePresetID derives a unique filename id from a display name, appending
@@ -192,7 +254,10 @@ func safePresetPath(name string) (string, error) {
 // CUDA_LAUNCH_QUEUES (files de lancement CUDA, voir launchQueuesEnv) suit la
 // même logique : un « off » posé parce que CETTE machine bloque ne doit pas
 // disparaître à la bascule suivante.
-var preservedKeys = []string{"MEM_MODE", "CRAWL4AI_URL", "WEB_ENGINE", "CUDA_VISIBLE_DEVICES", "HOST", "CUDA_LAUNCH_QUEUES"}
+// SLOT_PERSIST (état du slot gardé à la bascule, backend_serve_persist.go) est
+// par nature un réglage de bascule : posé sur A seulement, il disparaîtrait en
+// passant sur B, dont le lancement effacerait l'état gardé de A.
+var preservedKeys = []string{"MEM_MODE", "CRAWL4AI_URL", "WEB_ENGINE", "CUDA_VISIBLE_DEVICES", "HOST", "CUDA_LAUNCH_QUEUES", "SLOT_PERSIST"}
 
 // softPreservedKeys : préservées SEULEMENT si le preset d'arrivée ne les définit
 // pas lui-même. CUDA_VISIBLE_DEVICES est dans ce cas : c'est d'ordinaire un
@@ -203,7 +268,7 @@ var preservedKeys = []string{"MEM_MODE", "CRAWL4AI_URL", "WEB_ENGINE", "CUDA_VIS
 // modèle se retrouvait entièrement sur une seule carte et mourait sur
 // « cudaMalloc failed: out of memory ». Le preset explicite gagne.
 // CUDA_LAUNCH_QUEUES aussi : un preset peut l'imposer pour son modèle.
-var softPreservedKeys = map[string]bool{"CUDA_VISIBLE_DEVICES": true, "HOST": true, "CUDA_LAUNCH_QUEUES": true}
+var softPreservedKeys = map[string]bool{"CUDA_VISIBLE_DEVICES": true, "HOST": true, "CUDA_LAUNCH_QUEUES": true, "SLOT_PERSIST": true}
 
 // applyPresetFile installe le preset comme configuration active, en réinjectant
 // les réglages « appareil » par-dessus. Séparé de SwitchToPreset pour être
@@ -264,6 +329,13 @@ func presetImposesEngine(p string) bool {
 // 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 {
+	if err := tuneGuard(); err != nil {
+		return err
+	}
+	// SLOT_PERSIST : relevé sur la configuration d'avant, gardé juste avant
+	// l'arrêt (llm_slotpersist.go). Sans la clé, ou hors du process web (rien
+	// n'y dit ce que porte le slot) : nil, rien ne se passe.
+	persist := slotPersistPrepare()
 	if err := applyPresetFile(target); err != nil {
 		return err
 	}
@@ -277,9 +349,11 @@ func SwitchToPreset(target string) error {
 		if !serviceIsActive() {
 			return nil
 		}
+		persist.save()
 		return serviceAction("stop")
 	}
 	fmt.Println(dim("[info] redémarrage du service..."))
+	persist.save()
 	return serviceAction("restart")
 }
 

internal/loki/backend_presets_order_test.go

@@ -0,0 +1,60 @@
+package loki
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// Ordre choisi par glisser-déposer : les presets classés d'abord, dans cet
+// ordre ; les nouveaux (non classés) ensuite, par nom.
+func TestPresetOrder(t *testing.T) {
+	testHome(t)
+	_ = os.MkdirAll(presetsDir(), 0o755)
+	for _, id := range []string{"alpha", "bravo", "charlie", "delta"} {
+		if err := os.WriteFile(filepath.Join(presetsDir(), id+".env"), []byte("# NAME="+id+"\nCTX=4096\n"), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ids := func() []string {
+		list, err := ListPresets()
+		if err != nil {
+			t.Fatal(err)
+		}
+		var out []string
+		for _, p := range list {
+			out = append(out, p.ID)
+		}
+		return out
+	}
+	if got := ids(); got[0] != "alpha" || got[3] != "delta" {
+		t.Fatalf("sans ordre enregistré, tri par nom attendu : %v", got)
+	}
+	if err := savePresetOrder([]string{"charlie", "alpha"}); err != nil {
+		t.Fatal(err)
+	}
+	want := []string{"charlie", "alpha", "bravo", "delta"}
+	got := ids()
+	for i := range want {
+		if got[i] != want[i] {
+			t.Fatalf("ordre %v, attendu %v", got, want)
+		}
+	}
+}
+
+func TestPresetCtx(t *testing.T) {
+	cases := map[string]string{
+		"":                 "32K", // défaut de serve : 32768
+		"CTX=40000\n":      "40K",
+		"CTX=\"131072\"\n": "128K",
+		"CTX=1000000\n":    "1M",
+		"CTX=1500000\n":    "1.5M",
+		"CTX=512\n":        "512",
+		"CTX=abc\n":        "",
+	}
+	for in, want := range cases {
+		if got := presetCtx(in); got != want {
+			t.Errorf("presetCtx(%q) = %q, attendu %q", in, got, want)
+		}
+	}
+}

internal/loki/backend_serve.go

@@ -9,6 +9,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"runtime"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -259,6 +260,32 @@ func downgradeLoadMode(args []string) ([]string, string) {
 // vérifie en table de tests plutôt qu'en relançant un moteur.
 func cmdServe(args []string) error {
 	cfg := ReadConfig()
+	// Moteur d'ESSAI de l'optimiseur (backend_tune_run.go) : sa configuration
+	// est une copie posée dans le dossier de l'essai, jamais config.env, et rien
+	// de ce que le vrai moteur laisse derrière lui (état des slots, jeton de
+	// SPEC=auto) n'est touché. Sans la variable, rien ne change.
+	trialDir := os.Getenv(tuneTrialEnv)
+	if trialDir != "" {
+		c, err := readTuneTrialConfig(trialDir)
+		if err != nil {
+			return err
+		}
+		cfg = c
+	}
+	// API externe : aucun moteur local. On sort SANS erreur, sinon systemd
+	// (Restart=on-failure) relance en boucle « MODEL non défini » (amont #95).
+	if isExternalConfig(cfg) {
+		fmt.Println("[info] preset externe actif : pas de moteur local à lancer")
+		return nil
+	}
+	// Preset ENGINE=strata (backend_strata.go) : un autre moteur, lancé par son
+	// propre serveur. L'optimiseur ne règle que llama-server.
+	if isStrataConfig(cfg) {
+		if trialDir != "" {
+			return fmt.Errorf("l'optimiseur ne s'applique pas à un preset Strata")
+		}
+		return serveStrata(cfg)
+	}
 	bin := cfg["BIN"]
 	if bin == "" {
 		return fmt.Errorf("BIN non défini — lance « loki edit »")
@@ -341,11 +368,19 @@ func cmdServe(args []string) error {
 	// launchQueuesEnv). Après la sélection GPU, qui fait partie de la réponse.
 	probeServeGPUs(cfg, extra, &si)
 	probeExpertEnv(&si)
+	probeLoadEnv(&si)
 	probeFidelityEnv(&si)
 	probeCacheRAM(cfg, extra, &si)
 	probeCkptEnv(&si)
+	probeSideSlotEnv(cfg, &si)
+	// SPLIT_MODE=tensor seulement : cartes listées par CE moteur, dans son ordre.
+	probeSplit(cfg, bin, &si)
+	// LOAD_GUARD : un refus envisagé sur la VRAM NVIDIA se décide sur les
+	// cartes du moteur (Vulkan sur cartes mixtes, ROCm…). Sinon rien n'est lu.
+	normExtra, _ := normalizeLoadFlags(extra, helpSupportsLoadMode(si.Help))
+	probeLoadDevices(cfg, normExtra, bin, &si)
 	spec := specMode(cfg)
-	if spec == "auto" || spec == "mtp" {
+	if spec != "off" && spec != "" {
 		probeSpec(cfg, &si)
 	}
 	// Build du moteur : seulement pour un hybride ou SPEC=auto, les seuls cas où
@@ -360,15 +395,56 @@ func cmdServe(args []string) error {
 	if spec == "auto" {
 		si.SpecAutoBlocked, specRecord = specAutoPeek(specMark)
 	}
+	probeSlotPersistEnv(cfg, &si)
 	if strings.Contains(si.Help, "--slot-save-path") && !hasAnyFlag(extra, "--slot-save-path") {
-		si.SlotDir = prepareSlotDir(LokiHome())
+		if trialDir != "" {
+			// L'essai a son propre dossier : celui du vrai moteur garde ses états.
+			si.SlotDir = prepareSlotDir(trialDir, false)
+		} else {
+			si.SlotDir = prepareSlotDir(LokiHome(), slotPersistOn(cfg))
+		}
 	}
 
 	llmArgs, env, notes := buildServeArgs(cfg, extra, bin, si)
 	applyServeEnv(env)
+	// SLOT_PERSIST (backend_serve_persist.go) : la clé de CE lancement, et les
+	// états gardés au-delà de deux retirés. Refusé pour ce preset (brouillon,
+	// poids sur CPU…) : ceux des autres presets restent, pour leur retour.
+	// Clé retirée : plus aucun état gardé sur le disque.
+	persistKey := ""
+	persistOK, _ := slotPersistPlan(cfg, extra, si)
+	switch {
+	case trialDir != "":
+		// Un essai ne garde rien et n'efface rien.
+	case persistOK:
+		persistKey = slotPersistKey(llmArgs, env, si, bin)
+		slotPersistPrune(si.SlotDir)
+	case !slotPersistOn(cfg):
+		slotPersistPurge(filepath.Join(LokiHome(), "slots"))
+	}
 	for _, n := range notes {
 		fmt.Fprintln(os.Stderr, "[loki serve] "+n)
 	}
+	// Chargement résident avec plus de poids en RAM que la machine n'en a :
+	// échec certain (voir loadModeRisk), LOAD_GUARD=off pour passer outre.
+	if _, refuse := loadModeRisk(cfg, llmArgs, si); refuse != "" {
+		return loadGuardRefusal(refuse, trialDir != "")
+	}
+
+	// Essai : écoute sur 127.0.0.1 et le port libre choisi par l'optimiseur,
+	// même si EXTRA_ARGS en nomme d'autres (le dernier --port gagne). La ligne
+	// composée est rendue à l'optimiseur, qui la compare à celle de référence
+	// AVANT de charger quoi que ce soit ; à blanc, on s'arrête là.
+	if trialDir != "" {
+		llmArgs = tuneForceAddr(llmArgs, cfg["HOST"], cfg["PORT"])
+		l := tuneLaunch{Bin: bin, Args: llmArgs, Env: env, Notes: notes, Probe: tuneProbeFrom(si)}
+		if err := writeTuneLaunch(trialDir, l); err != nil {
+			return err
+		}
+		if os.Getenv(tuneDryRunEnv) != "" {
+			return nil
+		}
+	}
 
 	// Working dir = LOKI_HOME so relative paths in EXTRA_ARGS (e.g. --mmproj
 	// mmproj-F16.gguf) still resolve.
@@ -388,13 +464,23 @@ func cmdServe(args []string) error {
 	// Jeton de tentative : l'ancien consommé (et l'échec inscrit), le nouveau
 	// posé, au dernier moment — port libre, l'ancien moteur est donc bien parti
 	// et le process web ne peut pas le confondre avec lui.
-	if spec == "auto" {
+	if spec == "auto" && trialDir == "" {
 		_, _, auto := specArgs(cfg, extra, si)
 		specAutoSettle(specMark, si.SpecAutoBlocked, specRecord, auto)
 	}
 
+	// Posée au dernier moment, port libre : l'ancien moteur est parti, la clé
+	// lue par le process web est celle du moteur qui répondra.
+	if trialDir == "" {
+		writeSlotPersistMarker(LokiHome(), persistKey)
+	}
+
 	fmt.Fprintf(os.Stderr, "[loki serve] %s  model=%s  port=%s\n",
 		bin, filepath.Base(model), port)
+	// Ligne de commande réellement lancée, gardée pour l'interface (amont #108).
+	if trialDir == "" {
+		recordEngineCmdline(env, llmArgs)
+	}
 
 	// Hand off to the llama-server process. On Unix this replaces the current
 	// process (exec); on Windows it runs as a child and waits. See sys_platform_*.go.
@@ -424,7 +510,12 @@ type serveSysInfo struct {
 	RAMMiB      int64     // RAM de la machine, limite du conteneur comprise
 	RAMAvailMiB int64     // RAM libre au lancement
 	VRAMMiB     int64     // VRAM NVIDIA des cartes visibles
-	SlotDir     string    // dossier de --slot-save-path, créé et vérifié ; vide = pas de drapeau
+	UnifiedMem  bool      // macOS : RAM et VRAM ne font qu'une (voir loadModeRisk)
+	// VRAM des cartes listées par le moteur lui-même (--list-devices), lue
+	// seulement quand LOAD_GUARD envisage un refus (probeLoadDevices) ; 0 =
+	// non lue : un avis au plus, jamais de refus sur la seule VRAM NVIDIA.
+	EngineVRAMMiB int64
+	SlotDir       string // dossier de --slot-save-path, créé et vérifié ; vide = pas de drapeau
 
 	// Build d'un moteur officiel (engineBuildTrusted), lu seulement pour un
 	// modèle hybride ou SPEC=auto ; 0 = inconnu ou non lu : ni avis ni drapeau
@@ -437,6 +528,10 @@ type serveSysInfo struct {
 	DraftErr        string    // pourquoi MODEL_DRAFT n'a pas été trouvé
 	DraftGGUF       *GGUFInfo // métadonnées du brouillon ; nil = illisibles
 	SpecAutoBlocked string    // un essai automatique précédent a échoué : la raison
+
+	// Cartes listées par le moteur (--list-devices), lues seulement pour
+	// SPLIT_MODE=tensor (voir backend_serve_split.go) ; vide = inconnues.
+	SplitDevs []splitDev
 }
 
 // cudaDeviceEnv : sélection GPU (loki gpu), on filtre les devices visibles par
@@ -498,16 +593,30 @@ func buildServeArgs(cfg map[string]string, extra []string, bin string, si serveS
 		notes = append(notes, loadNote)
 	}
 
+	// Parallélisme de tenseurs (SPLIT_MODE=tensor, voir backend_serve_split.go) :
+	// sans la clé, splitOn est faux et rien de ce qui suit ne change. Accepté, il
+	// compte pour les réglages qui lisent le placement dans EXTRA_ARGS (files de
+	// lancement, graphes CUDA, --fit) comme un -sm tensor écrit à la main.
+	splitOn, splitA, splitNGLArgs, splitEnv, splitNotes := splitTensorArgs(cfg, extra, si)
+	place := extra
+	if splitOn {
+		place = append(append([]string{}, extra...), "-sm", "tensor")
+	}
+	for k, v := range splitEnv {
+		env[k] = v
+	}
+	notes = append(notes, splitNotes...)
+
 	// Files de lancement CUDA : une variable d'environnement, pas un drapeau —
 	// la ligne de commande n'en dépend pas (voir launchQueuesEnv).
-	q, qNotes := launchQueuesEnv(cfg, extra, si)
+	q, qNotes := launchQueuesEnv(cfg, place, si)
 	if q != "" {
 		env["CUDA_SCALE_LAUNCH_QUEUES"] = q
 	}
 	notes = append(notes, qNotes...)
 	// Réglages d'expert passés par variable (voir backend_serve_expert.go) :
 	// absents du preset, ils ne posent rien.
-	g, gNotes := graphOptEnv(cfg, extra, si)
+	g, gNotes := graphOptEnv(cfg, place, si)
 	if g != "" {
 		env["GGML_CUDA_GRAPH_OPT"] = g
 	}
@@ -521,9 +630,16 @@ func buildServeArgs(cfg map[string]string, extra []string, bin string, si serveS
 	// physiques au lieu de tous les threads logiques (voir threadArgs).
 	threads, threadNotes := threadArgs(cfg["THREADS"], cfg["THREADS_BATCH"], extra, si.CPU)
 	notes = append(notes, threadNotes...)
+	// Second slot (SIDE_SLOT, voir backend_serve_side.go) : sans la clé, sideCtx
+	// vaut 0 et rien de ce qui suit ne change.
+	sideCtx, sideMiB, sideWhy := sideSlotPlan(cfg, extra, si)
+	ctxArg := get("CTX", "32768")
+	if sideCtx > 0 {
+		ctxArg = strconv.Itoa(2 * sideCtx)
+	}
 	args = []string{bin,
 		"-m", si.Model,
-		"-c", get("CTX", "32768"),
+		"-c", ctxArg,
 	}
 	args = append(args, threads...)
 	args = append(args,
@@ -540,9 +656,16 @@ func buildServeArgs(cfg map[string]string, extra []string, bin string, si serveS
 	// uniquement à cause de ce nouveau défaut. PARALLEL=n dans le preset pour qui
 	// veut vraiment servir plusieurs requêtes à la fois — ou --parallel dans
 	// EXTRA_ARGS, auquel cas on ne redouble pas le drapeau.
-	if !hasAnyFlag(extra, "--parallel", "-np") {
+	if sideCtx > 0 {
+		// Deux flux KV séparés de sideCtx jetons : aucun slot ne peut manger la
+		// place de l'autre (voir backend_serve_side.go).
+		args = append(args, "--parallel", "2", "--no-kv-unified")
+	} else if !hasAnyFlag(extra, "--parallel", "-np") {
 		args = append(args, "--parallel", get("PARALLEL", "1"))
 	}
+	if n := sideSlotNote(sideCtx, sideMiB, sideWhy, nglForced(cfg, extra)); n != "" {
+		notes = append(notes, n)
+	}
 	// Couches GPU. Quatre cas, dans cet ordre :
 	//
 	//   NGL=auto      → rien du tout    (le moteur décide seul)
@@ -563,7 +686,9 @@ func buildServeArgs(cfg map[string]string, extra []string, bin string, si serveS
 	// ci-dessus. Sur un moteur qui connaît « auto », 999 devient donc auto, et on
 	// le DIT sur stderr plutôt que de le faire en douce. Qui veut réellement
 	// forcer tout sur le GPU écrit NGL=all (ou un nombre qui n'est pas 999).
-	if !hasAnyFlag(extra, "-ngl", "--n-gpu-layers", "--gpu-layers") {
+	if splitOn {
+		args = append(args, splitNGLArgs...) // « -ngl all », ou rien si EXTRA_ARGS l'a déjà
+	} else if !hasAnyFlag(extra, "-ngl", "--n-gpu-layers", "--gpu-layers") {
 		ngl, note := nglArgs(get("NGL", ""), helpFitsLayersItself(si.Help))
 		if note != "" {
 			notes = append(notes, note)
@@ -572,8 +697,8 @@ func buildServeArgs(cfg map[string]string, extra []string, bin string, si serveS
 	}
 	// Marge VRAM par carte du placement automatique (FIT_TARGET, voir
 	// fitTargetArgs) : seulement si --fit tournera vraiment.
-	fitt, fitNotes := fitTargetArgs(cfg, extra, si)
-	args = append(args, fitt...)
+	fitt, fitNotes := fitTargetArgs(cfg, place, si)
+	args = append(append(args, fitt...), splitA...)
 	notes = append(notes, fitNotes...)
 	if ktv != "" {
 		args = append(args, "-ctk", ktv)
@@ -628,6 +753,9 @@ func buildServeArgs(cfg map[string]string, extra []string, bin string, si serveS
 	cram, cramNotes := cacheRAMArgs(cfg, extra, si)
 	args = append(append(args, cram...), slotSaveArgs(cfg, extra, si)...)
 	notes = append(notes, cramNotes...)
+	if n := slotPersistNote(slotPersistPlan(cfg, extra, si)); n != "" {
+		notes = append(notes, n)
+	}
 	// Points de reprise des hybrides (voir backend_serve_ckpt.go).
 	ck, ckNotes := ckptArgs(cfg, extra, si)
 	args = append(args, ck...)
@@ -647,6 +775,13 @@ func buildServeArgs(cfg map[string]string, extra []string, bin string, si serveS
 		notes = append(notes, n)
 	}
 	notes = append(notes, lossyCacheNotes(extra, si)...)
+	// Experts MoE et mode de chargement (voir backend_serve_moe.go) : des notes
+	// seulement, la ligne ne bouge pas. Le refus d'un chargement voué à l'échec
+	// se décide dans cmdServe, sur cette même ligne.
+	notes = append(notes, moeNotes(cfg, extra, si)...)
+	if w, _ := loadModeRisk(cfg, args, si); w != "" {
+		notes = append(notes, w)
+	}
 	return args, env, notes
 }
 

internal/loki/backend_serve_cache.go

@@ -11,6 +11,7 @@ import (
 	"runtime"
 	"strconv"
 	"strings"
+	"sync"
 	"time"
 )
 
@@ -74,8 +75,12 @@ func probeCacheRAM(cfg map[string]string, extra []string, si *serveSysInfo) {
 			}
 		}
 	}
-	// Mémoire unifiée (macOS), AMD, Vulkan, --device choisi à la main : pas de
-	// total VRAM fiable, donc pas d'agrandissement.
+	// Mémoire unifiée : Apple Silicon seulement. Un Mac Intel à carte AMD a une
+	// VRAM à lui, que Loki ne sait pas mesurer (loadModeRisk la tient pour
+	// inconnue, jamais pour nulle).
+	si.UnifiedMem = runtime.GOOS == "darwin" && runtime.GOARCH == "arm64"
+	// macOS, AMD, Vulkan, --device choisi à la main : pas de total VRAM fiable,
+	// donc pas d'agrandissement.
 	if runtime.GOOS == "darwin" || hasAnyFlag(extra, "-dev", "--device") || si.ArgEnv["LLAMA_ARG_DEVICE"] != "" {
 		return
 	}
@@ -117,17 +122,54 @@ func cgroupMemMiB(fsys fs.FS) (limit, current int64) {
 // nvidiaVRAMMiB : VRAM totale des cartes que llama-server verra. Borné dans le
 // temps comme nvidiaGPUCount ; au moindre doute, 0.
 func nvidiaVRAMMiB(cvd string, pciOrder bool, timeout time.Duration) int64 {
-	if !hasTool("nvidia-smi") {
+	out, ok := smiTotals.get(time.Now, timeout)
+	if !ok {
 		return 0
 	}
+	return vramFromSMI(out, cvd, pciOrder)
+}
+
+// nvidiaTotalsQuery : la lecture brute des mémoires totales. Variable pour
+// les tests.
+var nvidiaTotalsQuery = func(timeout time.Duration) (string, error) {
+	if !hasTool("nvidia-smi") {
+		return "", exec.ErrNotFound
+	}
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
 	out, err := hideCmd(exec.CommandContext(ctx, "nvidia-smi", "--query-gpu=index,memory.total",
 		"--format=csv,noheader,nounits")).Output()
-	if err != nil {
-		return 0
+	return string(out), err
+}
+
+// smiTotalsCache : la lecture des mémoires totales, partagée quelques
+// secondes. L'éditeur de preset demande à l'ouverture la taille du cache de
+// prompts (et celle du second slot) et les avis MoE, en parallèle : chacun
+// lançait SON nvidia-smi pour une réponse identique — la mémoire totale d'une
+// carte ne bouge pas. Le verrou tenu pendant la lecture fait attendre les
+// appels simultanés sur la même ; la sélection des cartes (CUDA_VISIBLE_DEVICES)
+// s'applique après, sur la sortie brute. Un échec est gardé aussi, le temps du
+// délai : la même salve ne relance pas trois lectures qui échoueront.
+type smiTotalsCache struct {
+	mu  sync.Mutex
+	exp time.Time
+	out string
+	ok  bool
+}
+
+const smiTotalsTTL = 10 * time.Second
+
+var smiTotals smiTotalsCache
+
+func (c *smiTotalsCache) get(now func() time.Time, timeout time.Duration) (string, bool) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if now().Before(c.exp) {
+		return c.out, c.ok
 	}
-	return vramFromSMI(string(out), cvd, pciOrder)
+	out, err := nvidiaTotalsQuery(timeout)
+	c.out, c.ok, c.exp = out, err == nil, now().Add(smiTotalsTTL)
+	return c.out, c.ok
 }
 
 // vramFromSMI additionne la VRAM des cartes sélectionnées par
@@ -450,30 +492,29 @@ func loopbackHost(h string) bool {
 // restore, qui écrivent des Gio sur le disque, à quiconque joint le moteur. On
 // ne le pose donc que si le moteur est fermé aux autres (boucle locale, ou clé
 // d'API exigée), que le dossier existe (le moteur refuse de démarrer sinon), et
-// que l'isolation servira : cache actif, CACHE_ISOLATE pas à off. Les proxys de
-// Loki refusent de leur côté tout /slots qui n'est pas une lecture.
+// qu'il servira : à l'isolation (cache actif, CACHE_ISOLATE pas à off), ou à
+// SLOT_PERSIST accepté (backend_serve_persist.go). Les proxys de Loki refusent
+// de leur côté tout /slots qui n'est pas une lecture.
 func slotSaveArgs(cfg map[string]string, extra []string, si serveSysInfo) []string {
-	if si.SlotDir == "" || !strings.Contains(si.Help, "--slot-save-path") ||
-		hasAnyFlag(extra, "--slot-save-path") || !cacheIsolationOn(cfg) || cacheRAMOff(cfg, extra, si.ArgEnv) {
+	if si.SlotDir == "" || !strings.Contains(si.Help, "--slot-save-path") || hasAnyFlag(extra, "--slot-save-path") {
 		return nil
 	}
-	host := flagValue(extra, "--host")
-	if host == "" {
-		host = cfg["HOST"]
+	persist, _ := slotPersistPlan(cfg, extra, si)
+	if !persist && (!cacheIsolationOn(cfg) || cacheRAMOff(cfg, extra, si.ArgEnv)) {
+		return nil
 	}
-	if host == "" {
-		host = "0.0.0.0"
-	}
-	if !loopbackHost(host) && si.APIKey == "" {
+	if !slotSaveSafe(cfg, extra, si) {
 		return nil
 	}
 	return []string{"--slot-save-path", si.SlotDir}
 }
 
-// prepareSlotDir crée LOKI_HOME/slots (0700) et le vide : Loki n'y sauve jamais
-// rien, un fichier présent ne peut venir que d'un appel qui n'aurait pas dû
-// passer. Vide = dossier indisponible, le drapeau ne sera pas posé.
-func prepareSlotDir(home string) string {
+// prepareSlotDir crée LOKI_HOME/slots (0700) et le vide : un fichier présent ne
+// peut venir que d'un appel qui n'aurait pas dû passer. Seule exception, avec
+// keepPersist (SLOT_PERSIST demandé) : les états que Loki y a lui-même gardés
+// à la bascule de preset, au nom reconnaissable. Vide = dossier indisponible,
+// le drapeau ne sera pas posé.
+func prepareSlotDir(home string, keepPersist bool) string {
 	dir := filepath.Join(home, "slots")
 	if err := os.MkdirAll(dir, 0o700); err != nil {
 		return ""
@@ -483,7 +524,7 @@ func prepareSlotDir(home string) string {
 	}
 	if entries, err := os.ReadDir(dir); err == nil {
 		for _, e := range entries {
-			if e.Type().IsRegular() {
+			if e.Type().IsRegular() && !(keepPersist && slotPersistFileRe.MatchString(e.Name())) {
 				_ = os.Remove(filepath.Join(dir, e.Name()))
 			}
 		}

internal/loki/backend_serve_cache_test.go

@@ -1,12 +1,16 @@
 package loki
 
 import (
+	"errors"
 	"os"
 	"path/filepath"
 	"reflect"
 	"strings"
+	"sync"
+	"sync/atomic"
 	"testing"
 	"testing/fstest"
+	"time"
 )
 
 const helpCacheRAM = helpRecent + `-cram,  --cache-ram N                   set the maximum cache size in MiB (default: 8192, -1 - no limit, 0 - disable)
@@ -238,7 +242,7 @@ func TestBuildServeArgsCacheRAM(t *testing.T) {
 
 func TestPrepareSlotDir(t *testing.T) {
 	home := t.TempDir()
-	dir := prepareSlotDir(home)
+	dir := prepareSlotDir(home, false)
 	if dir != filepath.Join(home, "slots") {
 		t.Fatalf("dossier = %q", dir)
 	}
@@ -246,7 +250,7 @@ func TestPrepareSlotDir(t *testing.T) {
 	if err := os.WriteFile(stray, []byte("x"), 0o600); err != nil {
 		t.Fatal(err)
 	}
-	if prepareSlotDir(home) == "" {
+	if prepareSlotDir(home, false) == "" {
 		t.Fatal("second appel")
 	}
 	if _, err := os.Stat(stray); !os.IsNotExist(err) {
@@ -258,7 +262,58 @@ func TestPrepareSlotDir(t *testing.T) {
 	if err := os.WriteFile(filepath.Join(bad, "slots"), nil, 0o600); err != nil {
 		t.Fatal(err)
 	}
-	if got := prepareSlotDir(bad); got != "" {
+	if got := prepareSlotDir(bad, false); got != "" {
 		t.Fatalf("slots est un fichier : %q", got)
 	}
 }
+
+// L'éditeur demande en parallèle le cache de prompts, le second slot et les
+// avis MoE : une seule lecture nvidia-smi pour tous, la sélection des cartes
+// appliquée ensuite. Après le délai, une lecture neuve ; un échec n'est pas
+// relancé dans la même salve.
+func TestNvidiaVRAMShared(t *testing.T) {
+	var calls atomic.Int32
+	fail := false
+	prevQ := nvidiaTotalsQuery
+	nvidiaTotalsQuery = func(time.Duration) (string, error) {
+		calls.Add(1)
+		time.Sleep(20 * time.Millisecond) // les appels simultanés attendent la même lecture
+		if fail {
+			return "", errors.New("exit status 9")
+		}
+		return "0, 16311\n1, 12288\n", nil
+	}
+	t.Cleanup(func() {
+		nvidiaTotalsQuery = prevQ
+		smiTotals.mu.Lock()
+		smiTotals.exp = time.Time{} // les tests suivants relisent nvidia-smi
+		smiTotals.mu.Unlock()
+	})
+	expire := func() {
+		smiTotals.mu.Lock()
+		smiTotals.exp = time.Time{}
+		smiTotals.mu.Unlock()
+	}
+	expire()
+	var wg sync.WaitGroup
+	got := make([]int64, 3)
+	for i, cvd := range []string{"", "0", "1"} {
+		wg.Add(1)
+		go func() { defer wg.Done(); got[i] = nvidiaVRAMMiB(cvd, true, time.Second) }()
+	}
+	wg.Wait()
+	if n := calls.Load(); n != 1 {
+		t.Errorf("%d lectures nvidia-smi pour trois demandes simultanées", n)
+	}
+	if !reflect.DeepEqual(got, []int64{16311 + 12288, 16311, 12288}) {
+		t.Errorf("sélection des cartes : %v", got)
+	}
+	expire()
+	fail = true
+	if v := nvidiaVRAMMiB("", true, time.Second); v != 0 {
+		t.Errorf("échec : %d, attendu 0", v)
+	}
+	if v := nvidiaVRAMMiB("", true, time.Second); v != 0 || calls.Load() != 2 {
+		t.Errorf("échec relancé dans la même salve : %d lectures", calls.Load())
+	}
+}

internal/loki/backend_serve_ckpt.go

@@ -289,12 +289,19 @@ func ckptArgs(cfg map[string]string, extra []string, si serveSysInfo) (args, not
 //
 // Le compromis, qui explique pourquoi Loki ne choisit pas : depuis b10763 le
 // moteur active preserve_reasoning par défaut, et le gabarit garde alors la
-// réflexion de TOUS les tours passés. Mais Loki ne renvoie pas le raisonnement
-// des tours passés : un gabarit qui ne conserve rien de lui-même (Qwen3.6) rend
-// alors des blocs de réflexion vides, là où « off » rend l'historique des
-// anciens moteurs. À l'inverse, un gabarit qui conserve déjà de lui-même
-// (Qwen3.8) changerait de rendu avec « off ». Aucun choix global n'est neutre
-// pour tous les modèles : vide = défaut du moteur, inchangé.
+// réflexion de TOUS les tours passés. Mais sans REASONING_ECHO, Loki ne renvoie
+// pas le raisonnement des tours passés : un gabarit qui ne conserve rien de
+// lui-même (Qwen3.6) rend alors des blocs de réflexion vides, là où « off » rend
+// l'historique des anciens moteurs. À l'inverse, un gabarit qui conserve déjà de
+// lui-même (Qwen3.8) changerait de rendu avec « off ». Aucun choix global n'est
+// neutre pour tous les modèles : vide = défaut du moteur, inchangé.
+//
+// Avec REASONING_ECHO=on (llm_reasoning_echo.go), les deux clés se complètent
+// sans se recouvrir : l'écho fournit le raisonnement, cette clé décide si le
+// gabarit le garde au-delà du tour en cours. « on » donne alors un préfixe
+// stable d'un message utilisateur à l'autre, au prix de plus de contexte ; le
+// comptage de Loki suit le verdict de la sonde de gabarit (preservesHistory),
+// pas cette clé, car un gabarit sans le réglage (Qwen3.5) l'ignore.
 func reasoningPreserveArgs(cfg map[string]string, extra []string, si serveSysInfo) (args, notes []string) {
 	v := strings.ToLower(strings.TrimSpace(cfg["REASONING_PRESERVE"]))
 	if v == "" {

internal/loki/backend_serve_fidelity.go

@@ -23,7 +23,7 @@ import (
 // ils décident. LLAMA_ARG_NO_CONTEXT_SHIFT est celle des moteurs anciens.
 var fidelityArgEnv = []string{"LLAMA_ARG_CACHE_TYPE_K", "LLAMA_ARG_CACHE_TYPE_V",
 	"LLAMA_ARG_CONTEXT_SHIFT", "LLAMA_ARG_NO_CONTEXT_SHIFT", "LLAMA_ARG_CACHE_REUSE",
-	"LLAMA_ARG_MMPROJ", "LLAMA_ARG_MMPROJ_URL"}
+	"LLAMA_ARG_MMPROJ", "LLAMA_ARG_MMPROJ_URL", "LLAMA_ARG_SPEC_SYNTH_LEN"}
 
 // probeFidelityEnv complète ArgEnv avec fidelityArgEnv. Appelée après
 // probeServeGPUs, qui crée ArgEnv.
@@ -168,6 +168,16 @@ func lossyCacheNotes(extra []string, si serveSysInfo) []string {
 			"de cache calculés sous un autre préfixe : les sorties ne sont plus exactement celles d'un calcul "+
 			"complet%s.", n, src, ignored))
 	}
+	// Acceptation SYNTHÉTIQUE (« benchmarking only ») : le moteur garde des
+	// jetons du brouillon au hasard, sans les comparer à ce qu'aurait tiré le
+	// modèle. Loki ne les pose jamais ; écrits à la main, on le crie.
+	if f := hasFlagPrefix(extra, "--spec-synth-"); f != "" || si.ArgEnv["LLAMA_ARG_SPEC_SYNTH_LEN"] != "" {
+		if f == "" {
+			f = "LLAMA_ARG_SPEC_SYNTH_LEN"
+		}
+		notes = append(notes, "avertissement : "+f+" — le moteur accepte des jetons du brouillon AU HASARD, sans "+
+			"vérification : les réponses ne sont plus celles du modèle. Réservé aux mesures, retire-le.")
+	}
 	return notes
 }
 

internal/loki/backend_serve_moe.go

@@ -0,0 +1,628 @@
+package loki
+
+import (
+	"fmt"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// Experts MoE et chargement du modèle : des avis et un garde-fou, jamais de
+// réécriture silencieuse du preset.
+//
+//	moeNotes             au lancement et dans l'éditeur : experts placés à la
+//	                     main (--fit ne les place pas), UBATCH conseillé quand
+//	                     --fit laisse des experts en RAM, moteur sans --fit
+//	loadModeRisk         --load-mode none/mlock/dio/mmap+mlock (ou --no-mmap,
+//	                     --mlock) avec plus de poids en RAM que la machine n'en
+//	                     a : avertissement ; refus seulement si l'échec est
+//	                     certain, LOAD_GUARD=off pour passer outre
+//	autoPlacementPreset  COPIE d'un preset MoE placé à la main, en placement
+//	                     automatique ; l'original n'est pas touché
+//
+// Rien de tout cela ne change ce que calcule le modèle : placement des poids
+// et découpage des lots seulement, mêmes types de cache, même contexte.
+
+// otPatterns : chaque motif « regex=tampon » des -ot / --override-tensor (et
+// de LLAMA_ARG_OVERRIDE_TENSOR) ; llama.cpp en accepte plusieurs par drapeau,
+// séparés par des virgules.
+func otPatterns(extra []string, argEnv map[string]string) []string {
+	vals := flagValues(extra, "-ot", "--override-tensor")
+	if v := argEnv["LLAMA_ARG_OVERRIDE_TENSOR"]; v != "" {
+		vals = append(vals, v)
+	}
+	var out []string
+	for _, v := range vals {
+		for _, el := range strings.Split(v, ",") {
+			if el = strings.TrimSpace(el); el != "" {
+				out = append(out, el)
+			}
+		}
+	}
+	return out
+}
+
+// otTargetsExperts : le motif vise-t-il les tenseurs d'experts (ffn_*_exps,
+// ffn_*_chexps) ? Un motif qui ne vise que la couche d'entrée
+// (per_layer_token_embd) n'en est pas.
+func otTargetsExperts(pattern string) bool {
+	return strings.Contains(strings.ToLower(pattern), "exps")
+}
+
+// otOnCPU : le tampon du motif est-il la RAM hôte (CPU, CPU_REPACK…) ?
+func otOnCPU(el string) bool {
+	_, buft, ok := strings.Cut(el, "=")
+	return ok && strings.HasPrefix(strings.ToUpper(strings.TrimSpace(buft)), "CPU")
+}
+
+// cpuExperts dit comment des experts MoE sont envoyés en RAM à la main, ou
+// vide. Plus étroit que cpuWeights : un -ot ne compte que s'il vise les
+// experts, et le cache KV ou un NGL partiel n'en sont pas.
+func cpuExperts(extra []string, argEnv map[string]string) string {
+	for _, el := range otPatterns(extra, argEnv) {
+		pat, _, _ := strings.Cut(el, "=")
+		if otTargetsExperts(pat) && otOnCPU(el) {
+			return "-ot experts=CPU"
+		}
+	}
+	if hasAnyFlag(extra, "--cpu-moe", "-cmoe") || envTruthy(argEnv["LLAMA_ARG_CPU_MOE"]) {
+		return "--cpu-moe"
+	}
+	for _, v := range append(flagValues(extra, "-ncmoe", "--n-cpu-moe"), argEnv["LLAMA_ARG_N_CPU_MOE"]) {
+		if v = strings.TrimSpace(v); v != "" && v != "0" {
+			return "--n-cpu-moe " + v
+		}
+	}
+	return ""
+}
+
+// fitFlagRe : « --fit » lui-même dans l'aide, pas seulement --fit-target.
+var fitFlagRe = regexp.MustCompile(`(^|[\s,])--fit([\s,=\[]|$)`)
+
+// helpSupportsFit : ce moteur sait-il placer les poids tout seul (--fit) ?
+func helpSupportsFit(help string) bool { return fitFlagRe.MatchString(help) }
+
+// serveUBatch : le micro-lot que verra le moteur (-ub d'EXTRA_ARGS, sinon
+// UBATCH, sinon le défaut de Loki). 0 = illisible.
+func serveUBatch(cfg map[string]string, extra []string) int {
+	s := flagValue(extra, "-ub", "--ubatch-size")
+	if s == "" {
+		s = strings.TrimSpace(cfg["UBATCH"])
+	}
+	if s == "" {
+		s = "512"
+	}
+	n, err := strconv.Atoi(strings.TrimSpace(s))
+	if err != nil || n < 0 {
+		return 0
+	}
+	return n
+}
+
+// gibText : des Mio en « 12,3 Gio ».
+func gibText(mib int64) string {
+	return strings.Replace(strconv.FormatFloat(float64(mib)/1024, 'f', 1, 64), ".", ",", 1) + " Gio"
+}
+
+// moeNotes : ce qu'il faut savoir du placement d'un MoE, pour ce lancement.
+// Fonction pure, comme nglArgs : des notes seulement, aucun drapeau.
+//
+//   - experts placés à la main (-ot visant les experts, --n-cpu-moe,
+//     --cpu-moe) : --fit ne les place pas. Monter UBATCH seul y serait un
+//     piège : le tampon de calcul grossit sur CHAQUE carte, sans personne pour
+//     rééquilibrer, et le moteur finit en « cudaMalloc failed » ;
+//   - placement auto, modèle plus gros que la VRAM : --fit laisse des experts
+//     en RAM, recopiés vers le GPU à chaque micro-lot du prefill — un UBATCH de
+//     2048 ou plus en paie quatre fois moins. --fit, lui, retient de la place
+//     pour ce tampon plus gros ;
+//   - moteur sans --fit (ancien, fork) : rien ne sort les experts du GPU,
+//     garder --n-cpu-moe ;
+//   - --fit coupé par un autre -ot : même chose.
+//
+// Muette sur un modèle dense, un preset externe, une VRAM inconnue (macOS,
+// --device, AMD) ou une aide du moteur illisible.
+func moeNotes(cfg map[string]string, extra []string, si serveSysInfo) []string {
+	if isExternalConfig(cfg) || si.GGUF == nil || si.GGUF.ExpertCount <= 0 {
+		return nil
+	}
+	ub := serveUBatch(cfg, extra)
+	if r := cpuExperts(extra, si.ArgEnv); r != "" {
+		n := "experts placés à la main (" + r + ") : --fit ne les place pas"
+		if ub > 0 && ub <= 512 {
+			n += " ; UBATCH plus grand = tampon de calcul plus gros sur chaque GPU : monte --n-cpu-moe d'abord, " +
+				"ou passe au placement auto (--fit, « Dupliquer en placement auto » dans l'éditeur)"
+		}
+		return []string{n}
+	}
+	modelMiB := si.ModelBytes >> 20
+	if modelMiB <= 0 || si.VRAMMiB <= 0 || si.UnifiedMem || strings.TrimSpace(si.Help) == "" {
+		return nil
+	}
+	cards := int64(si.GPUs)
+	if cards < 1 {
+		cards = 1
+	}
+	if modelMiB <= si.VRAMMiB-fitTargetMin*cards {
+		return nil // tout tient sur GPU : pas d'expert recopié
+	}
+	sizes := "modèle " + gibText(modelMiB) + ", VRAM " + gibText(si.VRAMMiB)
+	if !helpSupportsFit(si.Help) {
+		// Un NGL chiffré sous 999 laisse déjà des couches (et leurs experts) au
+		// CPU : l'utilisateur a tranché.
+		if n, err := strconv.Atoi(strings.TrimSpace(firstNonEmpty(flagValue(extra, "-ngl", "--n-gpu-layers", "--gpu-layers"), cfg["NGL"]))); err == nil && n < 999 {
+			return nil
+		}
+		return []string{"MoE plus gros que la VRAM (" + sizes + ") : ce moteur ne place pas les experts (pas de --fit) — " +
+			"garde --n-cpu-moe"}
+	}
+	if why := fitBlocker(cfg, extra, si); why != "" {
+		if why == "surcharge de tenseurs" {
+			return []string{"MoE plus gros que la VRAM (" + sizes + ") et --fit coupé par un -ot qui ne vise pas les " +
+				"experts : rien ne les sort du GPU — --n-cpu-moe, ou retire ce -ot"}
+		}
+		return nil
+	}
+	if ub > 0 && ub <= 512 {
+		return []string{"UBATCH 2048+ recommandé : --fit laisse des experts en RAM (" + sizes + "), recopiés vers le " +
+			"GPU à chaque micro-lot du prefill ; BATCH 4096 avec — à mesurer (bench complet)"}
+	}
+	return nil
+}
+
+// firstNonEmpty : la première valeur non vide.
+func firstNonEmpty(vals ...string) string {
+	for _, v := range vals {
+		if strings.TrimSpace(v) != "" {
+			return v
+		}
+	}
+	return ""
+}
+
+// loadArgEnv : les variables qui règlent le chargement sans drapeau.
+// LLAMA_ARG_RPC n'en est pas une, mais dit que des poids partent sur des
+// machines distantes (loadModeRisk).
+var loadArgEnv = []string{"LLAMA_ARG_LOAD_MODE", "LLAMA_ARG_MLOCK", "LLAMA_ARG_NO_MMAP", "LLAMA_ARG_RPC"}
+
+// probeLoadEnv relève ces variables. Appelée après probeServeGPUs, qui
+// remet ArgEnv à zéro.
+func probeLoadEnv(si *serveSysInfo) {
+	if si.ArgEnv == nil {
+		si.ArgEnv = map[string]string{}
+	}
+	for _, k := range loadArgEnv {
+		if v := strings.TrimSpace(os.Getenv(k)); v != "" {
+			si.ArgEnv[k] = v
+		}
+	}
+}
+
+// residentLoadMode : le mode de chargement qui garde ENTIÈREMENT en RAM les
+// poids laissés au CPU, tel qu'écrit (« --load-mode none », « --no-mmap »…),
+// ou vide. mmap (et auto) laisse le système relire les pages au besoin : lent
+// quand la RAM manque, jamais fatal. none et dio copient les poids en mémoire
+// anonyme, mlock et mmap+mlock les verrouillent. Lu sur la ligne finale
+// (normalizeLoadFlags a déjà traduit l'une ou l'autre forme), puis dans les
+// LLAMA_ARG_* si elle se tait.
+func residentLoadMode(args []string, argEnv map[string]string) string {
+	mode := strings.ToLower(strings.TrimSpace(flagValue(args, "--load-mode", "-lm")))
+	mlock, nommap := hasAnyFlag(args, "--mlock"), hasAnyFlag(args, "--no-mmap")
+	if mode == "" && !mlock && !nommap {
+		mode = strings.ToLower(strings.TrimSpace(argEnv["LLAMA_ARG_LOAD_MODE"]))
+		if mode == "" {
+			mlock, nommap = envTruthy(argEnv["LLAMA_ARG_MLOCK"]), envTruthy(argEnv["LLAMA_ARG_NO_MMAP"])
+		}
+	}
+	switch mode {
+	case "none", "mlock", "dio", "mmap+mlock":
+		return "--load-mode " + mode
+	}
+	switch {
+	case mlock && nommap:
+		return "--mlock --no-mmap"
+	case mlock:
+		return "--mlock"
+	case nommap:
+		return "--no-mmap"
+	}
+	return ""
+}
+
+// loadGuardMarker : la fin du message de refus, que l'interface reconnaît
+// dans le journal du service (modelLoadError).
+const loadGuardMarker = "LOAD_GUARD=off pour lancer quand même"
+
+// loadGuardOff : LOAD_GUARD=off, la clé d'échappement du refus.
+func loadGuardOff(cfg map[string]string) bool {
+	switch strings.ToLower(strings.TrimSpace(cfg["LOAD_GUARD"])) {
+	case "off", "0", "false", "non", "no":
+		return true
+	}
+	return false
+}
+
+// loadGuardExitStatus : le code de sortie de « loki serve » quand LOAD_GUARD
+// refuse. Le refus est certain et ne dépend que du preset et de la machine :
+// relancer ne changerait rien. Sous systemd, Restart=on-failure relançait
+// pourtant toutes les trois secondes, sans fin ; l'unité écrite par
+// « loki install » porte donc RestartPreventExitStatus pour ce code-là
+// (EX_CONFIG de sysexits.h : erreur de configuration). Le conteneur, lui, ne
+// relance jamais le moteur de lui-même.
+const loadGuardExitStatus = 78
+
+// unitPreventsRefusalRestart : l'unité systemd (son texte) s'abstient-elle de
+// relancer sur loadGuardExitStatus ? Une unité écrite par une version
+// d'avant ne le fait pas.
+func unitPreventsRefusalRestart(unit string) bool {
+	for _, line := range strings.Split(unit, "\n") {
+		k, v, ok := strings.Cut(strings.TrimSpace(line), "=")
+		if !ok || strings.TrimSpace(k) != "RestartPreventExitStatus" {
+			continue
+		}
+		for _, f := range strings.Fields(v) {
+			if f == strconv.Itoa(loadGuardExitStatus) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// loadGuardRefusal : l'erreur rendue par cmdServe pour un refus, avec son code
+// de sortie. Un superviseur qui relancerait quand même sur ce code (unité
+// systemd d'une version d'avant, launchd, qui relance toute sortie non nulle)
+// reçoit 0 : une sortie « propre » n'est pas relancée, et la raison reste en
+// clair dans le journal, où l'interface la reconnaît (modelLoadError). Le
+// moteur d'essai de l'optimiseur garde le vrai code : c'est lui qui dit
+// l'échec à « loki tune ».
+func loadGuardRefusal(refuse string, trial bool) error {
+	code := loadGuardExitStatus
+	if !trial {
+		if restarts, hint := supervisorRestartsRefusal(); restarts {
+			code = 0
+			if hint != "" {
+				fmt.Fprintln(os.Stderr, "[loki serve] "+hint)
+			}
+		}
+	}
+	return &exitStatusError{code: code, err: fmt.Errorf("%s", refuse)}
+}
+
+// loadModeRisk : un mode de chargement résident avec trop de poids en RAM.
+// Fonction pure ; args est la ligne finale (ou EXTRA_ARGS normalisé).
+//
+// llama.cpp #26110 : un modèle de 65 Go sur 60 Go de RAM, --load-mode none →
+// swap, décodage de 25 à 7,5 t/s ; mlock → processus tué faute de mémoire.
+// Seuls comptent les poids qui RESTENT en RAM : ceux qui partent en VRAM n'y
+// séjournent pas. On en connaît une borne basse — modèle moins VRAM totale
+// (tout le modèle sur macOS, mémoire unifiée) — et une estimation haute quand
+// la VRAM est inconnue (le modèle entier).
+//
+//   - refuse : la borne basse dépasse 90 % de la RAM effective (limite du
+//     conteneur comprise) — l'échec est certain. LOAD_GUARD=off lève le refus ;
+//   - warn   : l'estimation dépasse 80 % — on prévient, on lance.
+//
+// Un refus fait sortir « loki serve » en erreur, comme un modèle introuvable :
+// mieux vaut la raison en clair qu'un moteur tué en boucle par le noyau. Le code
+// de sortie (loadGuardRefusal) empêche le superviseur de relancer en boucle.
+func loadModeRisk(cfg map[string]string, args []string, si serveSysInfo) (warn, refuse string) {
+	if isExternalConfig(cfg) {
+		return "", ""
+	}
+	// Un moteur qui connaît --load-mode n'a plus LLAMA_ARG_MLOCK ni
+	// LLAMA_ARG_NO_MMAP : restées dans l'environnement, elles n'ont aucun effet
+	// et ne doivent pas faire refuser un lancement en mmap.
+	env := si.ArgEnv
+	if helpSupportsLoadMode(si.Help) && (env["LLAMA_ARG_MLOCK"] != "" || env["LLAMA_ARG_NO_MMAP"] != "") {
+		env = map[string]string{"LLAMA_ARG_LOAD_MODE": si.ArgEnv["LLAMA_ARG_LOAD_MODE"]}
+	}
+	mode := residentLoadMode(args, env)
+	modelMiB := si.ModelBytes >> 20
+	if mode == "" || modelMiB <= 0 || si.RAMMiB <= 0 {
+		return "", ""
+	}
+	// Serveurs RPC : une part des poids part sur d'autres machines, la VRAM
+	// locale ne borne plus rien — inconnu, donc un avis au plus, jamais un refus.
+	remote := hasAnyFlag(args, "--rpc") || strings.TrimSpace(si.ArgEnv["LLAMA_ARG_RPC"]) != ""
+	low, est, upTo, unsure := int64(0), modelMiB, true, false
+	switch {
+	case remote:
+	case si.UnifiedMem:
+		low, est, upTo = modelMiB, modelMiB, false
+	case si.EngineVRAMMiB > 0:
+		// Les cartes que le moteur liste lui-même : rien au-delà ne peut
+		// recevoir de poids, la borne basse est sûre.
+		low = max(modelMiB-si.EngineVRAMMiB, 0)
+		est, upTo = low, false
+	case si.VRAMMiB > 0:
+		// nvidia-smi seulement : un moteur Vulkan sur cartes mixtes NVIDIA +
+		// AMD en utilise davantage, un moteur ROCm d'autres. Une estimation,
+		// jamais une borne : un avis au plus (voir probeLoadDevices).
+		est, upTo, unsure = max(modelMiB-si.VRAMMiB, 0), false, true
+	}
+	ram := si.RAMMiB
+	what := "environ "
+	if upTo {
+		what = "jusqu'à "
+	}
+	if unsure && est*10 > ram*9 && !loadGuardOff(cfg) {
+		return fmt.Sprintf("%s : environ %s de poids en RAM (modèle %s, VRAM NVIDIA %s) pour %s — échec probable ; "+
+			"refus seulement si les cartes listées par le moteur le confirment, lancement sinon ; "+
+			"--load-mode mmap est plus sûr", mode, gibText(est), gibText(modelMiB), gibText(si.VRAMMiB), gibText(ram)), ""
+	}
+	if low*10 > ram*9 {
+		msg := fmt.Sprintf("%s : au moins %s de poids restent en RAM (modèle %s) pour %s de RAM, limite du conteneur "+
+			"comprise — échec certain : swap et décodage effondré, ou processus tué (llama.cpp #26110). "+
+			"--load-mode mmap laisse le système relire les pages au besoin", mode, gibText(low), gibText(modelMiB), gibText(ram))
+		if loadGuardOff(cfg) {
+			return msg + " ; LOAD_GUARD=off : lancé quand même", ""
+		}
+		return "", msg + " ; " + loadGuardMarker
+	}
+	if est*10 > ram*8 {
+		return fmt.Sprintf("%s : %s%s de poids en RAM pour %s — au-delà, swap (décodage de 25 à 7,5 t/s dans "+
+			"llama.cpp #26110) ou processus tué ; --load-mode mmap est plus sûr", mode, what, gibText(est), gibText(ram)), ""
+	}
+	return "", ""
+}
+
+// loadGuardNeedsDevices : un refus se profile sur la seule VRAM NVIDIA
+// (nvidia-smi) ? Il ne sera prononcé que sur les cartes du moteur lui-même —
+// à lire d'abord (probeLoadDevices). Fonction pure.
+func loadGuardNeedsDevices(cfg map[string]string, args []string, si serveSysInfo) bool {
+	if si.EngineVRAMMiB > 0 || si.VRAMMiB <= 0 {
+		return false
+	}
+	si.EngineVRAMMiB = si.VRAMMiB
+	_, refuse := loadModeRisk(cfg, args, si)
+	return refuse != ""
+}
+
+// engineDevsVRAM : la VRAM des cartes listées par le moteur, toutes
+// additionnées — sans --device, llama.cpp ne place rien ailleurs, et une carte
+// qu'il listerait sans s'en servir (iGPU) ne fait que rendre le refus plus
+// rare. 0 (inconnu) si la liste est vide ou si une carte annonce 0 Mio (déjà
+// pleine : lecture transitoire, voir handleBackendDevices).
+func engineDevsVRAM(devs []splitDev) int64 {
+	var total int64
+	for _, d := range devs {
+		if d.TotalMiB <= 0 {
+			return 0
+		}
+		total += d.TotalMiB
+	}
+	return total
+}
+
+// probeLoadDevices : seulement quand loadGuardNeedsDevices — un mode de
+// chargement résident qu'on s'apprête à refuser. Les cartes de SPLIT_MODE si
+// elles sont déjà lues, sinon --list-devices dans l'environnement du
+// lancement (sélection GPU comprise). Échec de lecture : EngineVRAMMiB reste
+// à 0, loadModeRisk avertit sans refuser. args : EXTRA_ARGS normalisé.
+func probeLoadDevices(cfg map[string]string, args []string, bin string, si *serveSysInfo) {
+	if !loadGuardNeedsDevices(cfg, args, *si) {
+		return
+	}
+	devs := si.SplitDevs
+	if len(devs) == 0 {
+		devs = listEngineDevices(bin)
+	}
+	si.EngineVRAMMiB = engineDevsVRAM(devs)
+}
+
+// previewServeHelp : l'aide supposée d'un moteur récent, pour les aperçus de
+// l'éditeur (le process web ne lance pas le moteur pour lire son aide). Le
+// lancement, lui, décide sur la vraie aide.
+const previewServeHelp = "--load-mode  --fit [on|off]  --fit-target"
+
+// moePreview : les avis de moeNotes et loadModeRisk pour l'éditeur, calculés
+// comme au lancement, sur un moteur supposé récent.
+func moePreview(content string) (notes []string, load string) {
+	cfg := parseEnv(content)
+	if isExternalConfig(cfg) {
+		return nil, ""
+	}
+	si := serveSysInfo{Help: previewServeHelp, ArgEnv: map[string]string{}}
+	for _, k := range append(append(append([]string{}, serveArgEnv...), fitArgEnv...), loadArgEnv...) {
+		if v, ok := os.LookupEnv(k); ok && strings.TrimSpace(v) != "" {
+			si.ArgEnv[k] = v
+		}
+	}
+	if m := strings.TrimSpace(cfg["MODEL"]); m != "" {
+		if p, err := resolveServeModelPath(m); err == nil {
+			si.Model = p
+		}
+	}
+	if si.Model == "" {
+		return nil, ""
+	}
+	extra := splitArgs(cfg["EXTRA_ARGS"])
+	probeCacheRAM(cfg, extra, &si)
+	norm, _ := normalizeLoadFlags(extra, true)
+	// Les cartes du moteur, sans le lancer : la dernière liste complète qu'il a
+	// donnée à l'éditeur (devices.json). Absente : un avis, pas un refus.
+	if loadGuardNeedsDevices(cfg, norm, si) {
+		bin := prebuiltResolveBin(firstNonEmpty(cfg["BIN"], ReadConfig()["BIN"]))
+		if list, ok := devPersistGet(bin + "\x00" + cfg["CUDA_VISIBLE_DEVICES"]); ok {
+			si.EngineVRAMMiB = engineDevsVRAM(splitDevsFrom(list))
+		}
+	}
+	warn, refuse := loadModeRisk(cfg, norm, si)
+	if refuse != "" {
+		warn = "refusé au lancement — " + refuse
+	}
+	return moeNotes(cfg, extra, si), warn
+}
+
+// autoPlacementPreset prépare la COPIE d'un preset MoE placé à la main, en
+// placement automatique. Fonction pure : elle rend le nouveau contenu et la
+// liste de ce qui change ; l'appelant l'enregistre sous un nouveau nom, et le
+// preset d'origine reste tel quel — le repli si --fit échoue.
+//
+// Dans la copie :
+//
+//   - retirés d'EXTRA_ARGS : les -ot qui visent les experts, un -ot qui
+//     n'envoie au CPU que per_layer_token_embd (couche d'entrée : llama.cpp la
+//     laisse toujours au CPU, le motif est redondant mais coupe --fit),
+//     --n-cpu-moe, --cpu-moe, -ngl, --tensor-split, --fit off, -b/-ub et les
+//     drapeaux de chargement ;
+//   - NGL retiré (Loki écrit -ngl auto sur un moteur qui sait placer),
+//     UBATCH=2048, BATCH=4096, « --load-mode mmap » (rien sur un moteur
+//     ancien, qui charge déjà ainsi) ;
+//   - CTX, cache KV, échantillonnage, raisonnement : intouchés.
+//
+// Refus (err) quand la copie ne tournerait pas en --fit — un autre -ot, -sm
+// row/tensor, SPLIT_MODE=tensor, --n-cpu-ffn — ou quand CTX vaut 0 (--fit
+// pourrait réduire le contexte), et quand il n'y a rien à migrer. Jamais de
+// --tensor-read-lazy ni --lazy-mode : leur nom change d'un moteur à l'autre.
+func autoPlacementPreset(content string) (out string, changes []string, err error) {
+	cfg := parseEnv(content)
+	if isExternalConfig(cfg) {
+		return "", nil, fmt.Errorf("preset externe : le modèle tourne ailleurs")
+	}
+	extra := splitArgs(cfg["EXTRA_ARGS"])
+	var kept []string
+	migrated := false
+	drop := func(s string) { changes = append(changes, "retiré : "+s) }
+	for i := 0; i < len(extra); i++ {
+		a := extra[i]
+		name, val, hasEq := strings.Cut(a, "=")
+		value := func() string {
+			if hasEq {
+				return val
+			}
+			if i+1 < len(extra) {
+				i++
+				return extra[i]
+			}
+			return ""
+		}
+		switch name {
+		case "-ot", "--override-tensor":
+			v := value()
+			var rest []string
+			for _, el := range strings.Split(v, ",") {
+				el = strings.TrimSpace(el)
+				pat, _, _ := strings.Cut(el, "=")
+				switch {
+				case el == "":
+				case otTargetsExperts(pat):
+					drop(name + " " + el + " (experts : --fit les place)")
+					migrated = true
+				case strings.Contains(strings.ToLower(pat), "per_layer_token_embd") && otOnCPU(el):
+					drop(name + " " + el + " (couche d'entrée, toujours au CPU)")
+				default:
+					rest = append(rest, el)
+				}
+			}
+			if len(rest) > 0 {
+				kept = append(kept, name, strings.Join(rest, ","))
+			}
+		case "-ncmoe", "--n-cpu-moe":
+			v := value()
+			drop(name + " " + v)
+			if strings.TrimSpace(v) != "0" {
+				migrated = true
+			}
+		case "-cmoe", "--cpu-moe":
+			drop(name)
+			migrated = true
+		case "-ngl", "--n-gpu-layers", "--gpu-layers", "-ts", "--tensor-split",
+			"-b", "--batch-size", "-ub", "--ubatch-size", "--load-mode", "-lm":
+			drop(name + " " + value())
+		case "--mlock", "--no-mmap", "--mmap":
+			drop(name)
+		case "-fit", "--fit":
+			v := value()
+			switch strings.ToLower(strings.TrimSpace(v)) {
+			case "off", "disabled", "false", "0":
+				drop(name + " " + v)
+			default:
+				kept = append(kept, name, v)
+			}
+		default:
+			kept = append(kept, a)
+		}
+	}
+	if !migrated {
+		return "", nil, fmt.Errorf("rien à migrer : ce preset ne place pas d'experts à la main (-ot …exps…, --n-cpu-moe, --cpu-moe)")
+	}
+	kept = append(kept, "--load-mode", "mmap")
+	nc := map[string]string{}
+	for k, v := range cfg {
+		nc[k] = v
+	}
+	nc["EXTRA_ARGS"] = joinArgs(kept)
+	nc["UBATCH"], nc["BATCH"] = "2048", "4096"
+	delete(nc, "NGL")
+	if ctx, ok := ctxFixed(nc, kept); !ok {
+		return "", nil, fmt.Errorf("contexte « %s » non chiffré : --fit pourrait le réduire pour tenir — donne un CTX chiffré d'abord", ctx)
+	}
+	if splitModeKey(nc) == "tensor" {
+		return "", nil, fmt.Errorf("SPLIT_MODE=tensor coupe --fit : retire-le d'abord")
+	}
+	if why := fitBlocker(nc, kept, serveSysInfo{Help: previewServeHelp, ArgEnv: map[string]string{}}); why != "" {
+		return "", nil, fmt.Errorf("--fit resterait inactif (%s) : retire-le à la main d'abord", why)
+	}
+	if ngl := strings.TrimSpace(cfg["NGL"]); ngl != "" {
+		changes = append(changes, "NGL="+ngl+" retiré : le moteur place les couches (-ngl auto)")
+	}
+	changes = append(changes, "UBATCH=2048, BATCH=4096 (avant : "+firstNonEmpty(cfg["UBATCH"], "512")+" / "+
+		firstNonEmpty(cfg["BATCH"], "2048")+")", "--load-mode mmap")
+	ctx, _ := ctxFixed(nc, kept)
+	changes = append(changes, "CTX conservé : "+ctx)
+	if k, v := serveKVTypes(nc); k != "" || v != "" ||
+		flagValue(kept, "-ctk", "--cache-type-k") != "" || flagValue(kept, "-ctv", "--cache-type-v") != "" {
+		changes = append(changes, "cache KV conservé tel quel — garde-le identique pour comparer les deux presets")
+	}
+	out = content
+	out = presetSetKey(out, "EXTRA_ARGS", nc["EXTRA_ARGS"])
+	out = presetSetKey(out, "UBATCH", "2048")
+	out = presetSetKey(out, "BATCH", "4096")
+	out = presetSetKey(out, "NGL", "")
+	return out, changes, nil
+}
+
+// joinArgs : l'inverse de splitArgs — un argument qui contient un blanc est
+// entouré d'apostrophes (de guillemets s'il en contient une), pour être relu
+// d'un seul tenant.
+func joinArgs(args []string) string {
+	parts := make([]string, len(args))
+	for i, a := range args {
+		switch {
+		case a == "":
+			parts[i] = `""`
+		case strings.ContainsAny(a, " \t"):
+			if strings.Contains(a, "'") {
+				parts[i] = `"` + a + `"`
+			} else {
+				parts[i] = "'" + a + "'"
+			}
+		default:
+			parts[i] = a
+		}
+	}
+	return strings.Join(parts, " ")
+}
+
+// presetSetKey remplace les lignes KEY=… d'un preset (toutes : parseEnv
+// retient la dernière, une ancienne restée plus bas l'emporterait), l'ajoute à
+// la fin si elle manque, les retire si val est vide. Le reste du fichier —
+// commentaires, ordre, NAME — ne bouge pas : c'est l'équivalent de cfgWriteKey
+// côté éditeur.
+func presetSetKey(content, key, val string) string {
+	re := regexp.MustCompile(`(?m)^[ \t]*(?:export[ \t]+)?` + regexp.QuoteMeta(key) + `[ \t]*=.*$`)
+	if val == "" {
+		return regexp.MustCompile(`(?m)^[ \t]*(?:export[ \t]+)?`+regexp.QuoteMeta(key)+`[ \t]*=.*(?:\n|$)`).
+			ReplaceAllLiteralString(content, "")
+	}
+	line := key + "=" + quoteValue(val)
+	if re.MatchString(content) {
+		return re.ReplaceAllLiteralString(content, line)
+	}
+	if content != "" && !strings.HasSuffix(content, "\n") {
+		content += "\n"
+	}
+	return content + line + "\n"
+}

internal/loki/backend_serve_moe_test.go

@@ -0,0 +1,389 @@
+package loki
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+const gib = int64(1) << 30
+
+// Un -ot ne compte comme experts en RAM que s'il vise les experts ET la RAM ;
+// celui de la couche d'entrée (per_layer_token_embd) n'en est pas.
+func TestCpuExperts(t *testing.T) {
+	cases := []struct {
+		extra string
+		env   map[string]string
+		want  bool
+	}{
+		{`-ot per_layer_token_embd.weight=CPU`, nil, false},
+		{`-ot "blk\..*\.ffn_.*_exps\.=CPU"`, nil, true},
+		{`--override-tensor=per_layer_token_embd.weight=CPU,\.ffn_(up|down)_exps=CPU`, nil, true},
+		{`-ot \.ffn_.*_exps=CUDA1`, nil, false},
+		{`-cmoe`, nil, true},
+		{`--n-cpu-moe 0`, nil, false},
+		{`--n-cpu-moe 40`, nil, true},
+		{`-ncmoe=12`, nil, true},
+		{``, map[string]string{"LLAMA_ARG_N_CPU_MOE": "20"}, true},
+		{``, map[string]string{"LLAMA_ARG_CPU_MOE": "1"}, true},
+		{`-nkvo -ngl 20`, nil, false},
+	}
+	for _, c := range cases {
+		if got := cpuExperts(splitArgs(c.extra), c.env) != ""; got != c.want {
+			t.Errorf("cpuExperts(%q, %v) = %v, want %v", c.extra, c.env, got, c.want)
+		}
+	}
+}
+
+// moeNotes : les avis, au bon endroit et seulement là.
+func TestMoeNotes(t *testing.T) {
+	moe := &GGUFInfo{ExpertCount: 128, BlockCount: 48}
+	big := serveSysInfo{Help: helpFit, GGUF: moe, ModelBytes: 82 * gib, VRAMMiB: 28 << 10, GPUs: 2}
+	cases := []struct {
+		name string
+		cfg  map[string]string
+		si   serveSysInfo
+		want string // sous-chaîne attendue ; vide = aucune note
+	}{
+		{name: "modèle dense : rien",
+			cfg: map[string]string{"EXTRA_ARGS": "--n-cpu-moe 40"},
+			si:  serveSysInfo{Help: helpFit, GGUF: &GGUFInfo{BlockCount: 64}, ModelBytes: 82 * gib, VRAMMiB: 28 << 10}},
+		{name: "placement manuel, UBATCH 512 : ne pas monter UBATCH seul",
+			cfg: map[string]string{"EXTRA_ARGS": "--n-cpu-moe 40"}, si: big, want: "monte --n-cpu-moe d'abord"},
+		{name: "placement manuel, UBATCH 2048 : --fit ne les place pas, sans conseil de lot",
+			cfg: map[string]string{"EXTRA_ARGS": "--n-cpu-moe 40", "UBATCH": "2048"}, si: big, want: "--fit ne les place pas"},
+		{name: "placement auto, MoE plus gros que la VRAM, UBATCH 512 : UBATCH 2048+",
+			cfg: map[string]string{}, si: big, want: "UBATCH 2048+ recommandé"},
+		{name: "placement auto, UBATCH 4096 : rien",
+			cfg: map[string]string{"UBATCH": "4096", "BATCH": "4096"}, si: big},
+		{name: "-ub dans EXTRA_ARGS l'emporte sur UBATCH",
+			cfg: map[string]string{"UBATCH": "512", "EXTRA_ARGS": "-ub 2048"}, si: big},
+		{name: "le modèle tient en VRAM : rien",
+			cfg: map[string]string{},
+			si:  serveSysInfo{Help: helpFit, GGUF: moe, ModelBytes: 20 * gib, VRAMMiB: 28 << 10, GPUs: 2}},
+		{name: "moteur sans --fit : garder --n-cpu-moe",
+			cfg: map[string]string{}, si: serveSysInfo{Help: helpOld, GGUF: moe, ModelBytes: 82 * gib, VRAMMiB: 28 << 10},
+			want: "garde --n-cpu-moe"},
+		{name: "moteur sans --fit, NGL partiel : l'utilisateur a tranché",
+			cfg: map[string]string{"NGL": "20"}, si: serveSysInfo{Help: helpOld, GGUF: moe, ModelBytes: 82 * gib, VRAMMiB: 28 << 10}},
+		{name: "aide illisible : rien",
+			cfg: map[string]string{}, si: serveSysInfo{GGUF: moe, ModelBytes: 82 * gib, VRAMMiB: 28 << 10}},
+		{name: "-ot de la seule couche d'entrée : --fit coupé, experts tous sur GPU",
+			cfg: map[string]string{"EXTRA_ARGS": "-ot per_layer_token_embd.weight=CPU"}, si: big,
+			want: "-ot qui ne vise pas les experts"},
+		{name: "VRAM inconnue : rien",
+			cfg: map[string]string{}, si: serveSysInfo{Help: helpFit, GGUF: moe, ModelBytes: 82 * gib}},
+		{name: "macOS, mémoire unifiée : rien",
+			cfg: map[string]string{}, si: serveSysInfo{Help: helpFit, GGUF: moe, ModelBytes: 82 * gib, VRAMMiB: 28 << 10, UnifiedMem: true}},
+		{name: "preset externe : rien",
+			cfg: map[string]string{extKeyFlag: "1", extKeyURL: "https://api.example.com/v1", "EXTRA_ARGS": "--n-cpu-moe 40"}, si: big},
+	}
+	for _, c := range cases {
+		notes := moeNotes(c.cfg, splitArgs(c.cfg["EXTRA_ARGS"]), c.si)
+		switch {
+		case c.want == "" && len(notes) != 0:
+			t.Errorf("%s : notes inattendues %q", c.name, notes)
+		case c.want != "" && (len(notes) != 1 || !strings.Contains(notes[0], c.want)):
+			t.Errorf("%s : notes %q, attendu %q", c.name, notes, c.want)
+		}
+	}
+	// Placement manuel en UBATCH 2048 : pas de conseil de lot.
+	n := moeNotes(map[string]string{"UBATCH": "2048"}, splitArgs("--n-cpu-moe 40"), big)
+	if len(n) != 1 || strings.Contains(n[0], "UBATCH") {
+		t.Errorf("conseil de lot en trop : %q", n)
+	}
+}
+
+// loadModeRisk : un avertissement d'ordinaire, un refus seulement quand la
+// borne basse des poids en RAM dépasse 90 % de la RAM effective.
+func TestLoadModeRisk(t *testing.T) {
+	cases := []struct {
+		name         string
+		cfg          map[string]string
+		args         string
+		si           serveSysInfo
+		warn, refuse bool
+	}{
+		{name: "mmap : rien",
+			args: "--load-mode mmap", si: serveSysInfo{ModelBytes: 82 * gib, VRAMMiB: 16 << 10, RAMMiB: 60 << 10}},
+		{name: "sans drapeau : rien",
+			si: serveSysInfo{ModelBytes: 82 * gib, VRAMMiB: 16 << 10, RAMMiB: 60 << 10}},
+		{name: "none, 66 Gio certains en RAM pour 60 : refus (#26110)",
+			args: "--load-mode none", si: serveSysInfo{ModelBytes: 82 * gib, EngineVRAMMiB: 16 << 10, RAMMiB: 60 << 10}, refuse: true},
+		{name: "même chose, LOAD_GUARD=off : avertissement seulement",
+			cfg: map[string]string{"LOAD_GUARD": "off"}, args: "--load-mode none",
+			si: serveSysInfo{ModelBytes: 82 * gib, EngineVRAMMiB: 16 << 10, RAMMiB: 60 << 10}, warn: true},
+		{name: "mlock, 54 Gio en RAM pour 64 : avertissement",
+			args: "--load-mode mlock", si: serveSysInfo{ModelBytes: 82 * gib, VRAMMiB: 28 << 10, RAMMiB: 64 << 10}, warn: true},
+		{name: "dense tout en VRAM sur une machine à peu de RAM : rien (pas de faux positif)",
+			args: "--load-mode none", si: serveSysInfo{ModelBytes: 16 * gib, VRAMMiB: 24 << 10, RAMMiB: 8 << 10}},
+		{name: "VRAM inconnue : avertissement « jusqu'à », jamais de refus",
+			args: "--load-mode dio", si: serveSysInfo{ModelBytes: 82 * gib, RAMMiB: 60 << 10}, warn: true},
+		{name: "macOS, mémoire unifiée : tout le modèle compte",
+			args: "--load-mode mmap+mlock", si: serveSysInfo{ModelBytes: 60 * gib, RAMMiB: 64 << 10, UnifiedMem: true}, refuse: true},
+		{name: "moteur ancien : --no-mmap",
+			args: "--no-mmap", si: serveSysInfo{ModelBytes: 82 * gib, EngineVRAMMiB: 16 << 10, RAMMiB: 60 << 10}, refuse: true},
+		{name: "moteur ancien : --mlock --no-mmap",
+			args: "--mlock --no-mmap", si: serveSysInfo{ModelBytes: 82 * gib, VRAMMiB: 28 << 10, RAMMiB: 64 << 10}, warn: true},
+		{name: "LLAMA_ARG_NO_MMAP dans l'environnement",
+			si: serveSysInfo{ModelBytes: 82 * gib, EngineVRAMMiB: 16 << 10, RAMMiB: 60 << 10,
+				ArgEnv: map[string]string{"LLAMA_ARG_NO_MMAP": "1"}}, refuse: true},
+		// Corrections de relecture du lot 2 : pas de refus sur une borne fausse.
+		{name: "LLAMA_ARG_NO_MMAP sans effet sur un moteur à --load-mode : rien",
+			si: serveSysInfo{Help: "--load-mode", ModelBytes: 82 * gib, VRAMMiB: 16 << 10, RAMMiB: 60 << 10,
+				ArgEnv: map[string]string{"LLAMA_ARG_NO_MMAP": "1"}}},
+		{name: "--rpc : une part des poids part ailleurs, avis seulement",
+			args: "--load-mode none --rpc 10.0.0.2:50052", si: serveSysInfo{ModelBytes: 82 * gib, VRAMMiB: 16 << 10, RAMMiB: 60 << 10}, warn: true},
+		{name: "LLAMA_ARG_RPC : de même",
+			args: "--load-mode none", si: serveSysInfo{ModelBytes: 82 * gib, VRAMMiB: 16 << 10, RAMMiB: 60 << 10,
+				ArgEnv: map[string]string{"LLAMA_ARG_RPC": "10.0.0.2:50052"}}, warn: true},
+		{name: "limite du conteneur (RAM effective) : refus",
+			args: "--load-mode none", si: serveSysInfo{ModelBytes: 40 * gib, EngineVRAMMiB: 16 << 10, RAMMiB: 16 << 10}, refuse: true},
+		// Lot 3 : la VRAM comptée est celle des cartes du moteur ; nvidia-smi
+		// seul ne fait jamais refuser.
+		{name: "VRAM NVIDIA seule, cartes du moteur non lues : avertissement, jamais de refus",
+			args: "--load-mode none", si: serveSysInfo{ModelBytes: 82 * gib, VRAMMiB: 16 << 10, RAMMiB: 60 << 10}, warn: true},
+		{name: "VRAM NVIDIA seule, LOAD_GUARD=off : l'avis ordinaire",
+			cfg: map[string]string{"LOAD_GUARD": "off"}, args: "--load-mode none",
+			si: serveSysInfo{ModelBytes: 82 * gib, VRAMMiB: 16 << 10, RAMMiB: 60 << 10}, warn: true},
+		{name: "Vulkan, NVIDIA 12 Gio + AMD 16 Gio listées par le moteur : rien (faux refus sur la seule VRAM NVIDIA)",
+			args: "--load-mode none", si: serveSysInfo{ModelBytes: 70 * gib, VRAMMiB: 12 << 10, EngineVRAMMiB: 28 << 10, RAMMiB: 60 << 10}},
+		{name: "taille inconnue : rien",
+			args: "--load-mode none", si: serveSysInfo{VRAMMiB: 16 << 10, RAMMiB: 16 << 10}},
+	}
+	for _, c := range cases {
+		cfg := c.cfg
+		if cfg == nil {
+			cfg = map[string]string{}
+		}
+		warn, refuse := loadModeRisk(cfg, splitArgs(c.args), c.si)
+		if (warn != "") != c.warn || (refuse != "") != c.refuse {
+			t.Errorf("%s : warn=%q refuse=%q", c.name, warn, refuse)
+		}
+		if refuse != "" && !strings.Contains(refuse, "LOAD_GUARD=off") {
+			t.Errorf("%s : refus sans clé d'échappement : %q", c.name, refuse)
+		}
+		if loadGuardOff(cfg) && strings.Contains(warn, "refus") {
+			t.Errorf("%s : refus évoqué avec LOAD_GUARD=off : %q", c.name, warn)
+		}
+	}
+}
+
+// Sans ces clés, la ligne et l'environnement ne bougent pas quand le modèle
+// est un MoE : seules des notes s'ajoutent.
+func TestBuildServeArgsMoeNotesOnly(t *testing.T) {
+	const bin, model = "/opt/llama/llama-server", "/models/Qwen-MoE-Q4.gguf"
+	cfg := map[string]string{"CTX": "65536", "EXTRA_ARGS": "--n-cpu-moe 40 --load-mode none"}
+	extra := splitArgs(cfg["EXTRA_ARGS"])
+	plain := serveSysInfo{Help: helpFit, Model: model}
+	moe := plain
+	moe.GGUF, moe.ModelBytes, moe.VRAMMiB, moe.RAMMiB = &GGUFInfo{ExpertCount: 128}, 82*gib, 28<<10, 64<<10
+	a1, e1, n1 := buildServeArgs(cfg, extra, bin, plain)
+	a2, e2, n2 := buildServeArgs(cfg, extra, bin, moe)
+	if !reflect.DeepEqual(a1, a2) || !reflect.DeepEqual(e1, e2) {
+		t.Fatalf("la ligne a bougé :\n%q\n%q\nenv %v / %v", a1, a2, e1, e2)
+	}
+	if len(n2) != len(n1)+2 {
+		t.Fatalf("notes attendues (placement manuel + chargement) : %q", n2)
+	}
+}
+
+// La copie en placement auto du preset MoE de l'utilisateur.
+func TestAutoPlacementPreset(t *testing.T) {
+	src := "# NAME=QWEN 3.6 MOE\n# experts à la main\nMODEL=Qwen-MoE-Q4.gguf\nCTX=65536\nNGL=999\nUBATCH=512\n" +
+		`EXTRA_ARGS="-ot per_layer_token_embd.weight=CPU --n-cpu-moe 40 --cache-type-k q8_0 --cache-type-v q8_0 --jinja --mlock --chat-template-file '/mes modèles/tpl.jinja'"` + "\n"
+	out, changes, err := autoPlacementPreset(src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	cfg := parseEnv(out)
+	wantExtra := []string{"--cache-type-k", "q8_0", "--cache-type-v", "q8_0", "--jinja",
+		"--chat-template-file", "/mes modèles/tpl.jinja", "--load-mode", "mmap"}
+	if got := splitArgs(cfg["EXTRA_ARGS"]); !reflect.DeepEqual(got, wantExtra) {
+		t.Errorf("EXTRA_ARGS = %q\nwant %q", got, wantExtra)
+	}
+	if cfg["UBATCH"] != "2048" || cfg["BATCH"] != "4096" || cfg["CTX"] != "65536" || cfg["MODEL"] != "Qwen-MoE-Q4.gguf" {
+		t.Errorf("clés : %v", cfg)
+	}
+	if _, ok := cfg["NGL"]; ok {
+		t.Errorf("NGL gardé : %v", cfg)
+	}
+	if !strings.Contains(out, "# experts à la main") || !strings.HasPrefix(out, "# NAME=QWEN 3.6 MOE") {
+		t.Errorf("commentaires perdus :\n%s", out)
+	}
+	if len(changes) == 0 || !strings.Contains(strings.Join(changes, "\n"), "cache KV conservé") {
+		t.Errorf("changements : %q", changes)
+	}
+	// L'original n'est pas touché (chaîne passée par valeur, mais on vérifie la
+	// fonction : elle ne rend rien d'autre que la copie).
+	if parseEnv(src)["UBATCH"] != "512" {
+		t.Error("source modifiée")
+	}
+
+	refus := []struct{ name, content string }{
+		{"rien à migrer", "CTX=65536\nEXTRA_ARGS=--jinja\n"},
+		{"CTX=0", "CTX=0\nEXTRA_ARGS=--n-cpu-moe 40\n"},
+		{"-ot hors experts restant", `CTX=65536` + "\n" + `EXTRA_ARGS="-ot blk\.0\.attn.*=CUDA0,\.ffn_.*_exps=CPU"` + "\n"},
+		{"-sm row", "CTX=65536\nEXTRA_ARGS=\"--n-cpu-moe 40 -sm row\"\n"},
+		{"SPLIT_MODE=tensor", "CTX=65536\nSPLIT_MODE=tensor\nEXTRA_ARGS=--n-cpu-moe 40\n"},
+		{"--n-cpu-ffn", "CTX=65536\nEXTRA_ARGS=\"--n-cpu-moe 40 --n-cpu-ffn 4\"\n"},
+		{"preset externe", extKeyFlag + "=1\n" + extKeyURL + "=https://api.example.com/v1\nEXTRA_ARGS=--n-cpu-moe 40\n"},
+	}
+	for _, r := range refus {
+		if _, _, err := autoPlacementPreset(r.content); err == nil {
+			t.Errorf("%s : accepté", r.name)
+		}
+	}
+	// --cpu-moe et -ngl / --tensor-split / --fit off retirés ensemble.
+	out, _, err = autoPlacementPreset("CTX=32768\nEXTRA_ARGS=\"-cmoe -ngl 99 -ts 1,1 --fit off -ub 512\"\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := parseEnv(out)["EXTRA_ARGS"]; got != "--load-mode mmap" {
+		t.Errorf("EXTRA_ARGS = %q", got)
+	}
+}
+
+// presetSetKey : remplace, ajoute, retire — sans toucher aux voisines (BATCH
+// n'est pas UBATCH) ni aux commentaires.
+func TestPresetSetKey(t *testing.T) {
+	src := "# BATCH=1\nUBATCH=512\nBATCH=2048\n"
+	if got := presetSetKey(src, "BATCH", "4096"); got != "# BATCH=1\nUBATCH=512\nBATCH=4096\n" {
+		t.Errorf("remplacement : %q", got)
+	}
+	if got := presetSetKey(src, "NGL", "auto"); got != src+"NGL=auto\n" {
+		t.Errorf("ajout : %q", got)
+	}
+	if got := presetSetKey("A=1", "B", "2"); got != "A=1\nB=2\n" {
+		t.Errorf("ajout sans fin de ligne : %q", got)
+	}
+	if got := presetSetKey(src, "UBATCH", ""); got != "# BATCH=1\nBATCH=2048\n" {
+		t.Errorf("retrait : %q", got)
+	}
+	if got := presetSetKey("X=\"a b\"\n", "X", "c d"); parseEnv(got)["X"] != "c d" {
+		t.Errorf("guillemets : %q", got)
+	}
+	// Clé en double : parseEnv retient la dernière, toutes sont réécrites.
+	if got := presetSetKey("NGL=999\nCTX=1\nexport NGL=40\n", "NGL", "auto"); parseEnv(got)["NGL"] != "auto" {
+		t.Errorf("doublon : %q", got)
+	}
+	if got := presetSetKey("NGL=999\nCTX=1\nNGL=40", "NGL", ""); got != "CTX=1\n" {
+		t.Errorf("retrait des doublons : %q", got)
+	}
+}
+
+// joinArgs relu par splitArgs rend les mêmes arguments.
+func TestJoinArgsRoundTrip(t *testing.T) {
+	args := []string{"--jinja", "--chat-template-file", "/mes modèles/tpl.jinja", "-ot", `blk\.(1|2)\.ffn=CPU`, "", "it's here"}
+	if got := splitArgs(joinArgs(args)); !reflect.DeepEqual(got, args) {
+		t.Errorf("aller-retour : %q", got)
+	}
+}
+
+// Le refus de LOAD_GUARD s'arrête avant tout chargement : l'interface doit le
+// dire plutôt qu'un « chargement… » sans fin, même après un chargement réussi
+// plus haut dans le journal.
+func TestModelLoadErrorLoadGuard(t *testing.T) {
+	_, refuse := loadModeRisk(map[string]string{}, splitArgs("--load-mode none"),
+		serveSysInfo{ModelBytes: 82 * gib, EngineVRAMMiB: 16 << 10, RAMMiB: 60 << 10})
+	log := "llama_model_load: loading model\nmain: model loaded\nserver is listening\n[ERREUR] " + refuse + "\n"
+	if got := modelLoadErrorFrom(log); !strings.Contains(got, "LOAD_GUARD=off") {
+		t.Errorf("refus non signalé : %q", got)
+	}
+	// Une tentative suivante qui charge efface le refus.
+	if got := modelLoadErrorFrom(log + "loading model\nmodel loaded\n"); got != "" {
+		t.Errorf("refus ancien encore signalé : %q", got)
+	}
+}
+
+// Un refus de LOAD_GUARD ne doit pas être relancé en boucle : l'unité systemd
+// écrite par « loki install » exclut son code de sortie, une unité d'avant ne
+// le fait pas.
+func TestUnitPreventsRefusalRestart(t *testing.T) {
+	for _, c := range []struct {
+		unit string
+		want bool
+	}{
+		{"[Service]\nRestart=on-failure\nRestartSec=3\n", false},
+		{"[Service]\nRestart=on-failure\nRestartPreventExitStatus=78\n", true},
+		{"[Service]\n  RestartPreventExitStatus = 1 78 SIGKILL\n", true},
+		{"[Service]\nRestartPreventExitStatus=178\n", false},
+		{"[Service]\n# RestartPreventExitStatus=78\n", false},
+	} {
+		if got := unitPreventsRefusalRestart(c.unit); got != c.want {
+			t.Errorf("%q : %v, attendu %v", c.unit, got, c.want)
+		}
+	}
+}
+
+// Le refus sort avec son propre code (pas 1), y compris enveloppé ; une erreur
+// ordinaire garde 1. Le moteur d'essai garde toujours le vrai code.
+func TestLoadGuardRefusalExitStatus(t *testing.T) {
+	err := loadGuardRefusal("refus ; "+loadGuardMarker, true)
+	if got := exitStatusOf(err); got != loadGuardExitStatus {
+		t.Errorf("essai : code %d, attendu %d", got, loadGuardExitStatus)
+	}
+	if !strings.Contains(err.Error(), loadGuardMarker) {
+		t.Errorf("raison perdue : %q", err)
+	}
+	if got := exitStatusOf(fmt.Errorf("enveloppé : %w", err)); got != loadGuardExitStatus {
+		t.Errorf("enveloppé : code %d", got)
+	}
+	if got := exitStatusOf(errors.New("modèle introuvable")); got != 1 {
+		t.Errorf("erreur ordinaire : code %d, attendu 1", got)
+	}
+	// Hors superviseur (les tests ne tournent ni sous systemd ni sous launchd) :
+	// le vrai code aussi.
+	if restarts, _ := supervisorRestartsRefusal(); !restarts {
+		if got := exitStatusOf(loadGuardRefusal("refus", false)); got != loadGuardExitStatus {
+			t.Errorf("hors superviseur : code %d", got)
+		}
+	}
+}
+
+// Le refus envisagé sur la VRAM NVIDIA attend les cartes du moteur ; rien
+// n'est lu sans refus en vue.
+func TestLoadGuardNeedsDevices(t *testing.T) {
+	none := splitArgs("--load-mode none")
+	base := serveSysInfo{ModelBytes: 82 * gib, VRAMMiB: 16 << 10, RAMMiB: 60 << 10}
+	if !loadGuardNeedsDevices(map[string]string{}, none, base) {
+		t.Error("refus en vue sur nvidia-smi : cartes du moteur non demandées")
+	}
+	confirmed := base
+	confirmed.EngineVRAMMiB = 16 << 10
+	for name, c := range map[string]struct {
+		cfg  map[string]string
+		args []string
+		si   serveSysInfo
+	}{
+		"déjà lues":      {map[string]string{}, none, confirmed},
+		"LOAD_GUARD=off": {map[string]string{"LOAD_GUARD": "off"}, none, base},
+		"mmap":           {map[string]string{}, splitArgs("--load-mode mmap"), base},
+		"VRAM inconnue":  {map[string]string{}, none, serveSysInfo{ModelBytes: 82 * gib, RAMMiB: 60 << 10}},
+		"loin du seuil":  {map[string]string{}, none, serveSysInfo{ModelBytes: 30 * gib, VRAMMiB: 16 << 10, RAMMiB: 60 << 10}},
+	} {
+		if loadGuardNeedsDevices(c.cfg, c.args, c.si) {
+			t.Errorf("%s : cartes demandées sans refus en vue", name)
+		}
+	}
+}
+
+// La VRAM des cartes du moteur : toutes additionnées, inconnue dès qu'une
+// carte annonce 0 Mio (déjà pleine) ; devices.json relu en JSON (float64).
+func TestEngineDevsVRAM(t *testing.T) {
+	mixed := splitDevsFrom([]map[string]any{
+		{"id": "Vulkan0", "total_mib": 12288},
+		{"id": "Vulkan1", "total_mib": float64(16368)},
+	})
+	if got := engineDevsVRAM(mixed); got != 12288+16368 {
+		t.Errorf("cartes mixtes : %d", got)
+	}
+	if got := engineDevsVRAM([]splitDev{{"CUDA0", 12288}, {"CUDA1", 0}}); got != 0 {
+		t.Errorf("carte à 0 Mio : %d, attendu inconnu", got)
+	}
+	if got := engineDevsVRAM(nil); got != 0 {
+		t.Errorf("liste vide : %d", got)
+	}
+}

internal/loki/backend_serve_persist.go

@@ -0,0 +1,267 @@
+package loki
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+)
+
+// État du slot gardé à travers une bascule de preset (SLOT_PERSIST, off par
+// défaut).
+//
+// Basculer d'un preset A vers B puis revenir à A relance llama-server deux
+// fois : au retour, la conversation de A est recalculée en entier — 30 à 80 s
+// sur un 27B dense. Avec SLOT_PERSIST=on, Loki demande au moteur, juste avant
+// la bascule, d'écrire l'état du slot 0 sur disque (/slots/0?action=save), et
+// le recharge au retour, avant la première requête de la discussion
+// (llm_slotpersist.go). llama-server ne reprend un état que sur un préfixe de
+// jetons identique : au pire, rien n'est repris.
+//
+// Mais rien, dans le fichier, ne dit quel moteur ni quels réglages ont calculé
+// ce cache : llama.cpp ne vérifie que les types et les tailles. Le recharger
+// sous un autre build, une autre fenêtre ou un autre placement donnerait au
+// modèle un contexte que ce moteur n'aurait jamais produit. D'où la clé : une
+// empreinte de TOUT ce qui touche au calcul — ligne de commande complète
+// (modèle, fenêtre, types KV, NGL, lots, gabarit, EXTRA_ARGS…), variables
+// LLAMA_ARG_*, GGML_* et CUDA_*, identité (taille, date) du modèle et de ses
+// tranches, du projecteur, du brouillon, du binaire et de ses bibliothèques.
+// Un fichier ne se recharge que sous la même clé ; une mise à jour du moteur
+// change donc tout, et n'est jamais un cas de reprise.
+//
+// Refusé d'emblée : le décodage spéculatif (la sauvegarde de llama.cpp ne
+// garde que le modèle cible, pas le brouillon MTP — l'état rechargé serait
+// incohérent pour lui), les poids sur CPU (MoE déporté : états de plusieurs
+// Gio pour un recalcul de toute façon lent), et un moteur joignable par
+// d'autres sans clé d'API : save et restore écrivent des Gio sur le disque.
+
+// slotPersistOn : la clé SLOT_PERSIST est-elle posée ?
+func slotPersistOn(cfg map[string]string) bool {
+	switch strings.ToLower(strings.TrimSpace(cfg["SLOT_PERSIST"])) {
+	case "on", "1", "true", "yes", "oui":
+		return true
+	}
+	return false
+}
+
+// slotPersistArgEnv : variables qui contredisent SLOT_PERSIST sans drapeau.
+var slotPersistArgEnv = []string{"LLAMA_ARG_SLOT_SAVE_PATH", "LLAMA_ARG_SPEC_TYPE", "LLAMA_ARG_SPEC_DRAFT_MODEL",
+	"LLAMA_ARG_SPEC_DRAFT_HF_REPO"}
+
+// probeSlotPersistEnv complète ArgEnv, seulement si la clé est posée.
+func probeSlotPersistEnv(cfg map[string]string, si *serveSysInfo) {
+	if !slotPersistOn(cfg) {
+		return
+	}
+	if si.ArgEnv == nil {
+		si.ArgEnv = map[string]string{}
+	}
+	for _, k := range slotPersistArgEnv {
+		if v, ok := os.LookupEnv(k); ok && strings.TrimSpace(v) != "" {
+			si.ArgEnv[k] = v
+		}
+	}
+}
+
+// slotPersistPlan : SLOT_PERSIST vaut-il pour ce lancement ? why dit pourquoi
+// non (vide = clé absente).
+func slotPersistPlan(cfg map[string]string, extra []string, si serveSysInfo) (ok bool, why string) {
+	if !slotPersistOn(cfg) {
+		return false, ""
+	}
+	switch {
+	case isExternalConfig(cfg):
+		return false, "preset externe"
+	case !strings.Contains(si.Help, "--slot-save-path"):
+		return false, "ce moteur ne connaît pas --slot-save-path"
+	case hasAnyFlag(extra, "--slot-save-path") || si.ArgEnv["LLAMA_ARG_SLOT_SAVE_PATH"] != "":
+		return false, "--slot-save-path est déjà réglé à la main"
+	case si.SlotDir == "":
+		return false, "dossier des slots indisponible"
+	case specMode(cfg) != "off" || specUserSet(extra, si.ArgEnv) || si.ArgEnv["LLAMA_ARG_SPEC_TYPE"] != "":
+		return false, "décodage spéculatif : la sauvegarde du moteur ne garde pas l'état du brouillon"
+	case splitModeKey(cfg) != "":
+		return false, "SPLIT_MODE : état réparti entre cartes, sauvegarde non validée"
+	}
+	if !slotSaveSafe(cfg, extra, si) {
+		return false, "moteur joignable par d'autres sans clé d'API (HOST=127.0.0.1 ou une clé d'API)"
+	}
+	blocks := 0
+	if si.GGUF != nil {
+		blocks = si.GGUF.BlockCount
+	}
+	if r := cpuWeights(cfg, extra, si.ArgEnv, blocks); r != "" {
+		return false, r
+	}
+	return true, ""
+}
+
+// slotSaveSafe : le moteur n'est joignable que par la machine, ou exige une
+// clé d'API. Sans ça, --slot-save-path donnerait à n'importe qui le droit
+// d'écrire des Gio sur le disque.
+func slotSaveSafe(cfg map[string]string, extra []string, si serveSysInfo) bool {
+	host := flagValue(extra, "--host")
+	if host == "" {
+		host = cfg["HOST"]
+	}
+	if host == "" {
+		host = "0.0.0.0"
+	}
+	return loopbackHost(host) || si.APIKey != ""
+}
+
+// slotPersistNote : ce que le lancement dit de SLOT_PERSIST.
+func slotPersistNote(ok bool, why string) string {
+	if ok || why == "" {
+		return ""
+	}
+	return "SLOT_PERSIST refusé (" + why + ") : l'état du slot ne sera pas gardé à la bascule de preset"
+}
+
+// slotPersistFileRe : les seuls fichiers que Loki écrit dans le dossier des
+// slots — clé du moteur, empreinte de la discussion.
+var slotPersistFileRe = regexp.MustCompile(`^persist-[0-9a-f]{16}-[0-9a-f]{12}\.bin$`)
+
+// slotPersistMaxFiles : au plus deux états gardés (A→B→A, puis B→A→B).
+const slotPersistMaxFiles = 2
+
+// slotPersistKey : l'empreinte de tout ce qui décide du calcul du cache.
+// args : la ligne de commande finale (la clé d'API n'y entre pas) ; env : ce
+// que buildServeArgs pose. Les fichiers sont pris par taille et date : un
+// modèle retéléchargé, un moteur mis à jour changent la clé.
+func slotPersistKey(args []string, env map[string]string, si serveSysInfo, bin string) string {
+	h := sha256.New()
+	w := func(s string) { h.Write([]byte(s)); h.Write([]byte{0}) }
+	for i := 0; i < len(args); i++ {
+		if args[i] == "--api-key" {
+			i++
+			continue
+		}
+		w(args[i])
+	}
+	vars := map[string]string{}
+	for _, kv := range os.Environ() {
+		k, v, _ := strings.Cut(kv, "=")
+		if strings.HasPrefix(k, "LLAMA_ARG_") || strings.HasPrefix(k, "GGML_") || strings.HasPrefix(k, "CUDA_") {
+			vars[k] = v
+		}
+	}
+	for k, v := range env {
+		vars[k] = v
+	}
+	delete(vars, "LLAMA_ARG_API_KEY")
+	keys := make([]string, 0, len(vars))
+	for k := range vars {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	for _, k := range keys {
+		w(k + "=" + vars[k])
+	}
+	stat := func(p string) {
+		if p == "" {
+			return
+		}
+		if st, err := os.Stat(p); err == nil {
+			w(fmt.Sprintf("%s|%d|%d", p, st.Size(), st.ModTime().UnixNano()))
+		} else {
+			w(p + "|?")
+		}
+	}
+	if si.Model != "" {
+		for _, n := range shardFamily(filepath.Base(si.Model)) {
+			stat(filepath.Join(filepath.Dir(si.Model), n))
+		}
+		stat(si.Model)
+	}
+	stat(si.MMProj)
+	stat(si.Draft)
+	stat(bin)
+	// Bibliothèques du moteur (libllama, ggml-cuda…) : une mise à jour peut
+	// les changer sans toucher au binaire.
+	if entries, err := os.ReadDir(filepath.Dir(bin)); err == nil {
+		for _, e := range entries {
+			n := strings.ToLower(e.Name())
+			if strings.HasSuffix(n, ".so") || strings.Contains(n, ".so.") || strings.HasSuffix(n, ".dll") || strings.HasSuffix(n, ".dylib") {
+				stat(filepath.Join(filepath.Dir(bin), e.Name()))
+			}
+		}
+	}
+	w(fmt.Sprintf("build=%d", si.EngineBuild))
+	return hex.EncodeToString(h.Sum(nil))[:16]
+}
+
+// slotPersistMarker : la clé du moteur lancé, écrite par « loki serve » juste
+// avant de lui céder la place, lue par le process web. Hors du dossier des
+// slots : le moteur ne peut pas l'écraser par un save.
+func slotPersistMarker(home string) string { return filepath.Join(home, "slots-engine.key") }
+
+// writeSlotPersistMarker pose (key non vide) ou retire la clé du moteur.
+func writeSlotPersistMarker(home, key string) {
+	p := slotPersistMarker(home)
+	if key == "" {
+		_ = os.Remove(p)
+		return
+	}
+	_ = os.WriteFile(p, []byte(key+"\n"), 0o600)
+}
+
+// readSlotPersistMarker : la clé du moteur en service ; vide = SLOT_PERSIST
+// refusé ou absent à son lancement.
+func readSlotPersistMarker(home string) string {
+	b, err := os.ReadFile(slotPersistMarker(home))
+	if err != nil {
+		return ""
+	}
+	k := strings.TrimSpace(string(b))
+	if len(k) != 16 {
+		return ""
+	}
+	if _, err := hex.DecodeString(k); err != nil {
+		return ""
+	}
+	return k
+}
+
+// slotPersistPrune garde les slotPersistMaxFiles états les plus récents.
+func slotPersistPrune(dir string) {
+	type f struct {
+		name string
+		at   int64
+	}
+	var fs []f
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return
+	}
+	for _, e := range entries {
+		if !e.Type().IsRegular() || !slotPersistFileRe.MatchString(e.Name()) {
+			continue
+		}
+		if info, err := e.Info(); err == nil {
+			fs = append(fs, f{e.Name(), info.ModTime().UnixNano()})
+		}
+	}
+	sort.Slice(fs, func(i, j int) bool { return fs[i].at > fs[j].at })
+	for i := slotPersistMaxFiles; i < len(fs); i++ {
+		_ = os.Remove(filepath.Join(dir, fs[i].name))
+	}
+}
+
+// slotPersistPurge retire tous les états gardés : la clé n'est plus là, ils
+// n'ont plus rien à faire sur le disque.
+func slotPersistPurge(dir string) {
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return
+	}
+	for _, e := range entries {
+		if e.Type().IsRegular() && slotPersistFileRe.MatchString(e.Name()) {
+			_ = os.Remove(filepath.Join(dir, e.Name()))
+		}
+	}
+}

internal/loki/backend_serve_side.go

@@ -0,0 +1,211 @@
+package loki
+
+import (
+	"fmt"
+	"math"
+	"os"
+	"strconv"
+	"strings"
+)
+
+// Second slot pour les travaux annexes (SIDE_SLOT, off par défaut).
+//
+// En --parallel 1, un vérificateur, un sous-agent, une tâche ou un bench
+// prennent LE slot de la conversation : son état part dans le cache RAM et
+// revient après — quand il y tient encore. Avec SIDE_SLOT=on, le moteur ouvre
+// deux slots, la conversation garde le slot 0 et tout le reste passe par le
+// slot 1 (id_slot, voir llm_sideslot.go) : l'état principal ne bouge plus du
+// tout.
+//
+// Le dimensionnement est le cœur de l'affaire. Un cache KV UNIFIÉ partagé entre
+// deux slots laisse chacun grandir jusqu'à la taille du pool : quand les deux
+// travaillent et que le pool est plein, llama.cpp renvoie « Context size has
+// been exceeded. » aux DEUX, et Loki prendrait ça pour un débordement de la
+// conversation — compaction, voire réduction, d'un fil qui tenait très bien
+// dans sa fenêtre. Et --kv-unified-per-slot plafonne tous les slots à la même
+// valeur, sans rien garantir sur la somme. On prend donc le cache NON unifié
+// (--no-kv-unified) avec -c 2×CTX : llama.cpp découpe alors le pool en deux
+// flux de CTX jetons chacun, séparés. Un débordement concurrent est impossible
+// par construction, chaque slot a exactement la fenêtre de la conversation (les
+// travaux annexes ne sont pas raccourcis), et --cache-idle-slots ne vide plus
+// les slots au repos (il ne le fait que sous cache unifié) : rien d'autre à
+// régler.
+//
+// Le prix : le cache KV (et l'état récurrent d'un hybride) en double, en VRAM.
+// On refuse donc l'option quand le compte ne tient pas, quand des poids vivent
+// en RAM (le KV en plus pousserait le placement automatique à sortir des
+// couches du GPU), et dès que l'utilisateur a réglé lui-même l'un des leviers
+// en jeu : on ne mélange pas ses réglages et les nôtres.
+
+// sideSlotOn : la clé SIDE_SLOT est-elle posée ?
+func sideSlotOn(cfg map[string]string) bool {
+	switch strings.ToLower(strings.TrimSpace(cfg["SIDE_SLOT"])) {
+	case "on", "1", "true", "yes", "oui":
+		return true
+	}
+	return false
+}
+
+// sideSlotConflictFlags : les drapeaux d'EXTRA_ARGS qui décident déjà de ce que
+// SIDE_SLOT règle. Un seul suffit à refuser.
+var sideSlotConflictFlags = []string{
+	"-c", "--ctx-size",
+	"-np", "--parallel",
+	"-kvu", "--kv-unified", "-no-kvu", "--no-kv-unified",
+	"--kv-unified-per-slot",
+	"--cache-idle-slots", "--no-cache-idle-slots",
+}
+
+// sideSlotArgEnv : les mêmes leviers posés par variable. La ligne de commande
+// les écraserait sans rien dire : un choix de l'utilisateur, on s'abstient.
+var sideSlotArgEnv = []string{"LLAMA_ARG_N_PARALLEL", "LLAMA_ARG_KV_UNIFIED", "LLAMA_ARG_KV_UNIFIED_PER_SLOT",
+	"LLAMA_ARG_CACHE_IDLE_SLOTS", "LLAMA_ARG_CTX_SIZE"}
+
+// probeSideSlotEnv complète ArgEnv avec sideSlotArgEnv, seulement si la clé est
+// posée : sans elle, rien n'est lu.
+func probeSideSlotEnv(cfg map[string]string, si *serveSysInfo) {
+	if !sideSlotOn(cfg) {
+		return
+	}
+	if si.ArgEnv == nil {
+		si.ArgEnv = map[string]string{}
+	}
+	for _, k := range sideSlotArgEnv {
+		if v, ok := os.LookupEnv(k); ok && strings.TrimSpace(v) != "" {
+			si.ArgEnv[k] = v
+		}
+	}
+}
+
+// sideSlotPlan décide de SIDE_SLOT pour ce lancement. ctx > 0 : accepté, chaque
+// slot aura ctx jetons (le pool en fait le double) ; extraMiB est la VRAM de
+// plus, estimée. ctx == 0 : refusé (why dit pourquoi), ou clé absente (why vide)
+// — la ligne de commande est alors celle d'avant, à l'octet près.
+func sideSlotPlan(cfg map[string]string, extra []string, si serveSysInfo) (ctx int, extraMiB int64, why string) {
+	if !sideSlotOn(cfg) {
+		return 0, 0, ""
+	}
+	if isExternalConfig(cfg) {
+		return 0, 0, "preset externe"
+	}
+	if p := strings.TrimSpace(cfg["PARALLEL"]); p != "" && p != "2" {
+		return 0, 0, "PARALLEL=" + p + " (SIDE_SLOT ouvre exactement 2 slots)"
+	}
+	for _, f := range sideSlotConflictFlags {
+		if hasAnyFlag(extra, f) {
+			return 0, 0, f + " est réglé dans EXTRA_ARGS"
+		}
+	}
+	for _, k := range sideSlotArgEnv {
+		if si.ArgEnv[k] != "" {
+			return 0, 0, k + " est posée"
+		}
+	}
+	if !strings.Contains(si.Help, "--no-kv-unified") {
+		return 0, 0, "ce moteur ne connaît pas --no-kv-unified"
+	}
+	n, err := strconv.Atoi(strings.TrimSpace(cfg["CTX"]))
+	if strings.TrimSpace(cfg["CTX"]) == "" {
+		n, err = 32768, nil
+	}
+	if err != nil || n <= 0 {
+		return 0, 0, "CTX doit être un nombre de jetons explicite"
+	}
+	extraMiB, why = sideSlotVRAM(cfg, extra, si, n)
+	if why != "" {
+		return 0, 0, why
+	}
+	return n, extraMiB, ""
+}
+
+// sideSlotVRAM estime la VRAM du second slot (cache KV de ctx jetons et état
+// récurrent) et vérifie que modèle + deux états tiennent dans 90 % de la VRAM,
+// la même marge que cacheRAMAuto. Inconnu = refus : on ne double pas le cache
+// KV à l'aveugle, c'est exactement la panne de mémoire qu'on a déjà vécue.
+func sideSlotVRAM(cfg map[string]string, extra []string, si serveSysInfo, ctx int) (extraMiB int64, why string) {
+	switch {
+	case si.VRAMMiB <= 0:
+		return 0, "VRAM NVIDIA inconnue (macOS, AMD, --device…)"
+	case si.GGUF == nil:
+		return 0, "métadonnées GGUF illisibles"
+	case si.ModelBytes <= 0:
+		return 0, "taille du modèle inconnue"
+	}
+	if r := cpuWeights(cfg, extra, si.ArgEnv, si.GGUF.BlockCount); r != "" {
+		return 0, r
+	}
+	kt, vt, _ := effectiveKVTypes(cfg, extra, si.ArgEnv)
+	perTok, rec := ggufStateBytes(*si.GGUF, kt, vt)
+	if perTok <= 0 {
+		return 0, "taille d'état inconnue"
+	}
+	state := perTok*float64(ctx) + float64(rec)
+	if float64(si.ModelBytes)+2*state > 0.9*float64(si.VRAMMiB)*(1<<20) {
+		return 0, fmt.Sprintf("VRAM insuffisante : modèle + 2 × %d Mio d'état dépassent 90 %% de %d Mio",
+			int64(math.Ceil(state/(1<<20))), si.VRAMMiB)
+	}
+	return int64(math.Ceil(state / (1 << 20))), ""
+}
+
+// sideSlotNote : ce que le lancement dit de SIDE_SLOT, accepté ou refusé.
+func sideSlotNote(ctx int, extraMiB int64, why string, nglForced bool) string {
+	if ctx <= 0 {
+		if why == "" {
+			return ""
+		}
+		return "SIDE_SLOT refusé (" + why + ") : un seul slot, comme sans la clé"
+	}
+	n := fmt.Sprintf("SIDE_SLOT : 2 slots de %d jetons (-c %d, --no-kv-unified), ~%d Mio de VRAM en plus "+
+		"pour le second (cache KV et état récurrent ; le brouillon MTP éventuel et les points de reprise en RAM hôte "+
+		"doublent aussi)", ctx, 2*ctx, extraMiB)
+	if nglForced {
+		return n + " ; NGL est imposé : surveille la VRAM au premier long prompt"
+	}
+	return n + " ; le placement automatique sortira des couches du GPU s'il manque de place"
+}
+
+// sideSlotPreview : l'avis de SIDE_SLOT pour l'éditeur de preset, calculé comme
+// au lancement, à l'aide du moteur près (supposée connaître --no-kv-unified :
+// un moteur trop ancien sera refusé au lancement, et le journal le dira).
+func sideSlotPreview(content string) (on bool, extraMiB int64, why string) {
+	cfg := parseEnv(content)
+	if !sideSlotOn(cfg) {
+		return false, 0, ""
+	}
+	if isExternalConfig(cfg) {
+		return false, 0, "preset externe"
+	}
+	extra := splitArgs(cfg["EXTRA_ARGS"])
+	si := serveSysInfo{Help: "--no-kv-unified", ArgEnv: map[string]string{}}
+	for _, k := range append(append(append(append([]string{}, serveArgEnv...), fidelityArgEnv...), cacheArgEnv...), sideSlotArgEnv...) {
+		if v, ok := os.LookupEnv(k); ok && strings.TrimSpace(v) != "" {
+			si.ArgEnv[k] = v
+		}
+	}
+	if m := strings.TrimSpace(cfg["MODEL"]); m != "" {
+		if p, err := resolveServeModelPath(m); err == nil {
+			si.Model = p
+		}
+	}
+	if si.Model == "" {
+		return false, 0, "modèle introuvable"
+	}
+	probeCacheRAM(cfg, extra, &si)
+	ctx, mib, why := sideSlotPlan(cfg, extra, si)
+	return ctx > 0, mib, why
+}
+
+// nglForced : le preset impose-t-il un nombre de couches GPU ? Alors le
+// placement automatique ne tourne pas, et un second état de trop finit en
+// panne de mémoire plutôt qu'en couches sorties du GPU. 999 est la sentinelle
+// « toutes », traduite en auto sur un moteur récent (voir nglArgs).
+func nglForced(cfg map[string]string, extra []string) bool {
+	v := flagValue(extra, "-ngl", "--n-gpu-layers", "--gpu-layers")
+	if v == "" {
+		v = strings.TrimSpace(cfg["NGL"])
+		if v == "999" {
+			return false
+		}
+	}
+	return v != "" && !strings.EqualFold(v, "auto")
+}

internal/loki/backend_serve_side_test.go

@@ -0,0 +1,147 @@
+package loki
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// helpSide : un moteur qui connaît le cache KV non unifié.
+const helpSide = helpCacheRAM + `-kvu,   --kv-unified, -no-kvu, --no-kv-unified
+                                        use single unified KV buffer shared across all sequences
+`
+
+// sideCfg : le preset de denseGPU (0,25 Mio d'état par jeton) à 32k, avec ou
+// sans SIDE_SLOT.
+func sideCfg(kv ...string) map[string]string {
+	cfg := map[string]string{"CTX": "32768", "NGL": "999"}
+	for i := 0; i+1 < len(kv); i += 2 {
+		cfg[kv[i]] = kv[i+1]
+	}
+	return cfg
+}
+
+func sideSI() serveSysInfo {
+	si := denseGPU()
+	si.Help = helpSide
+	return si
+}
+
+// Sans la clé (ou à off), la ligne de commande est celle d'avant, à l'octet
+// près, notes comprises.
+func TestSideSlotDefautIdentique(t *testing.T) {
+	for _, v := range []string{"", "off", "0"} {
+		cfg := sideCfg()
+		if v != "" {
+			cfg["SIDE_SLOT"] = v
+		}
+		got, _, notes := buildServeArgs(cfg, nil, "/bin/llama-server", sideSI())
+		want, _, wantNotes := buildServeArgs(sideCfg(), nil, "/bin/llama-server", sideSI())
+		if !reflect.DeepEqual(got, want) || !reflect.DeepEqual(notes, wantNotes) {
+			t.Fatalf("SIDE_SLOT=%q change la ligne :\n%v\n%v", v, got, want)
+		}
+		if argValue(got, "--parallel") != "1" || argValue(got, "-c") != "32768" {
+			t.Fatalf("défaut : %v", got)
+		}
+		for _, a := range got {
+			if a == "--no-kv-unified" {
+				t.Fatal("--no-kv-unified sans la clé")
+			}
+		}
+	}
+}
+
+// Accepté : deux slots de CTX jetons chacun, flux KV séparés — le pool fait
+// le double, aucun slot ne peut déborder sur l'autre.
+func TestSideSlotAccepte(t *testing.T) {
+	for _, cfg := range []map[string]string{sideCfg("SIDE_SLOT", "on"), sideCfg("SIDE_SLOT", "on", "PARALLEL", "2")} {
+		args, _, notes := buildServeArgs(cfg, nil, "/bin/llama-server", sideSI())
+		if argValue(args, "-c") != "65536" || argValue(args, "--parallel") != "2" {
+			t.Fatalf("args = %v", args)
+		}
+		n := 0
+		for i, a := range args {
+			if a == "--no-kv-unified" {
+				n++
+				if args[i-1] != "2" || args[i-2] != "--parallel" {
+					t.Fatalf("--no-kv-unified mal placé : %v", args)
+				}
+			}
+			if a == "--kv-unified-per-slot" || a == "-kvu" || a == "--kv-unified" {
+				t.Fatalf("drapeau inattendu %s", a)
+			}
+		}
+		if n != 1 {
+			t.Fatalf("--no-kv-unified × %d", n)
+		}
+		found := false
+		for _, s := range notes {
+			if strings.HasPrefix(s, "SIDE_SLOT : 2 slots de 32768 jetons") && strings.Contains(s, "~8192 Mio") {
+				found = true
+			}
+		}
+		if !found {
+			t.Fatalf("note de VRAM absente : %q", notes)
+		}
+	}
+}
+
+// Refusé : la ligne est exactement celle sans la clé, plus une note qui dit
+// pourquoi.
+func TestSideSlotRefus(t *testing.T) {
+	cases := []struct {
+		name  string
+		cfg   map[string]string
+		extra []string
+		si    func(*serveSysInfo)
+		why   string
+	}{
+		{name: "PARALLEL=3", cfg: sideCfg("SIDE_SLOT", "on", "PARALLEL", "3"), why: "PARALLEL=3"},
+		{name: "-c dans EXTRA_ARGS", extra: []string{"-c", "16384"}, why: "-c "},
+		{name: "--ctx-size=", extra: []string{"--ctx-size=16384"}, why: "--ctx-size"},
+		{name: "-np", extra: []string{"-np", "4"}, why: "-np"},
+		{name: "-kvu", extra: []string{"-kvu"}, why: "-kvu"},
+		{name: "--no-kv-unified", extra: []string{"--no-kv-unified"}, why: "--no-kv-unified"},
+		{name: "--kv-unified-per-slot", extra: []string{"--kv-unified-per-slot", "8192"}, why: "--kv-unified-per-slot"},
+		{name: "--cache-idle-slots", extra: []string{"--cache-idle-slots"}, why: "--cache-idle-slots"},
+		{name: "--no-cache-idle-slots", extra: []string{"--no-cache-idle-slots"}, why: "--no-cache-idle-slots"},
+		{name: "variable LLAMA_ARG_N_PARALLEL", si: func(si *serveSysInfo) { si.ArgEnv["LLAMA_ARG_N_PARALLEL"] = "4" }, why: "LLAMA_ARG_N_PARALLEL"},
+		{name: "variable LLAMA_ARG_KV_UNIFIED", si: func(si *serveSysInfo) { si.ArgEnv["LLAMA_ARG_KV_UNIFIED"] = "1" }, why: "LLAMA_ARG_KV_UNIFIED"},
+		{name: "moteur sans --no-kv-unified", si: func(si *serveSysInfo) { si.Help = helpCacheRAM }, why: "--no-kv-unified"},
+		{name: "CTX=0", cfg: sideCfg("SIDE_SLOT", "on", "CTX", "0"), why: "CTX"},
+		{name: "VRAM trop juste à 64k", cfg: sideCfg("SIDE_SLOT", "on", "CTX", "65536"), why: "VRAM insuffisante"},
+		{name: "VRAM inconnue", si: func(si *serveSysInfo) { si.VRAMMiB = 0 }, why: "VRAM"},
+		{name: "GGUF illisible", si: func(si *serveSysInfo) { si.GGUF = nil }, why: "GGUF"},
+		{name: "experts sur CPU", extra: []string{"--n-cpu-moe", "20"}, why: "CPU"},
+		{name: "-ot sur CPU", extra: []string{"-ot", "exps=CPU"}, why: "CPU"},
+		{name: "NGL partiel", cfg: sideCfg("SIDE_SLOT", "on", "NGL", "30"), why: "couches GPU"},
+	}
+	for _, c := range cases {
+		cfg := c.cfg
+		if cfg == nil {
+			cfg = sideCfg("SIDE_SLOT", "on")
+		}
+		si := sideSI()
+		if c.si != nil {
+			c.si(&si)
+		}
+		_, _, why := sideSlotPlan(cfg, c.extra, si)
+		if !strings.Contains(why, c.why) {
+			t.Errorf("%s : why = %q, attendu %q", c.name, why, c.why)
+		}
+		got, _, notes := buildServeArgs(cfg, c.extra, "/bin/llama-server", si)
+		off := map[string]string{}
+		for k, v := range cfg {
+			if k != "SIDE_SLOT" {
+				off[k] = v
+			}
+		}
+		want, _, wantNotes := buildServeArgs(off, c.extra, "/bin/llama-server", si)
+		if !reflect.DeepEqual(got, want) {
+			t.Errorf("%s : refus qui change la ligne\n%v\n%v", c.name, got, want)
+		}
+		if len(notes) != len(wantNotes)+1 {
+			t.Errorf("%s : notes %q", c.name, notes)
+		}
+	}
+}

internal/loki/backend_serve_spec.go

@@ -22,6 +22,8 @@ import (
 //	MODEL_DRAFT=<nom>  → la tête ou le brouillon, résolu comme MMPROJ
 //	SPEC_N_MAX=<n>     → --spec-draft-n-max (défaut du moteur : 3)
 //	SPEC_SAMPLING=probabilistic → seulement avec SPEC=mtp ; greedy sinon
+//	SPEC=ngram         → n-grammes tirés du contexte (ngram-mod), sans brouillon
+//	SPEC=mtp+ngram     → les deux ; un n-gramme trouvé passe avant la tête MTP
 //
 // Rien n'y touche au modèle : chaque jeton émis est tiré par l'échantillonneur
 // du modèle cible, un jeton du brouillon n'est gardé que s'il coïncide
@@ -30,6 +32,11 @@ import (
 // empêcher le moteur de démarrer. D'où l'opt-in, les garde-fous d'auto et le
 // jeton de tentative (specAutoVerdict) : un lancement automatique qui n'a
 // jamais répondu ne se retente pas avec la même configuration.
+//
+// Une vérification par lot n'emprunte pas les mêmes noyaux qu'un décodage jeton
+// par jeton : même distribution, mais pas le même texte au bit près — deux
+// candidats presque à égalité peuvent s'inverser à graine égale, comme entre
+// prefill et décodage. On compare donc des sessions rejouées, pas des diffs.
 
 const (
 	// specAutoMinBuild : premier build officiel où Loki ose l'auto (MTP serveur,
@@ -37,6 +44,19 @@ const (
 	// peut connaître le drapeau sans le tenir.
 	specAutoMinBuild = 11009
 	specNMaxLimit    = 64
+
+	// Bornes de ngram-mod, toujours écrites en clair : --spec-default pose les
+	// mêmes aujourd'hui, mais son code porte un TODO qui annonce d'autres types —
+	// une mise à jour du moteur changerait le réglage sans un mot. Un brouillon
+	// part dès 24 jetons qui se répètent mot pour mot, et fait 48 à 64 jetons :
+	// ce que recopie une boucle d'outils (chemins, diffs, arguments JSON).
+	specNgramNMatch = 24
+	specNgramNMin   = 48
+	specNgramNMax   = 64
+
+	// ggmlOffloadMinBatchDefault : seuil par défaut du moteur (ggml-cuda.cu) à
+	// partir duquel un lot recopie vers le GPU les poids restés en RAM.
+	ggmlOffloadMinBatchDefault = 32
 )
 
 // specArgEnv : les variables qui règlent la spéculation sans drapeau. Posées,
@@ -45,10 +65,28 @@ var specArgEnv = []string{"LLAMA_ARG_SPEC_TYPE", "LLAMA_ARG_SPEC_DRAFT_MODEL", "
 	"LLAMA_ARG_SPEC_DRAFT_N_MAX", "LLAMA_ARG_SPEC_DRAFT_SAMPLING"}
 
 // specUserFlags : la spéculation réglée à la main. Les ajouter EN PLUS ferait
-// cumuler les types (--spec-type s'additionne) ou charger deux brouillons.
-var specUserFlags = []string{"--spec-type", "-md", "--model-draft", "--spec-draft-model",
+// cumuler les types (--spec-type s'additionne, sans l'avertissement « specified
+// multiple times » des autres drapeaux) ou charger deux brouillons.
+var specUserFlags = []string{"--spec-type", "--spec_type", "-md", "--model-draft", "--spec-draft-model",
 	"-hfd", "-hfrd", "--spec-draft-hf", "--hf-repo-draft", "--spec-default"}
 
+// specUserPrefixes : des réglages de n-grammes à la main (--spec-ngram-mod-n-max,
+// --spec-ngram-simple-size-n…) disent la même chose qu'un --spec-type.
+var specUserPrefixes = []string{"--spec-ngram-", "--spec_ngram_"}
+
+// hasFlagPrefix : un drapeau d'args commence-t-il par l'un de ces préfixes ?
+func hasFlagPrefix(args []string, prefixes ...string) string {
+	for _, a := range args {
+		for _, p := range prefixes {
+			if strings.HasPrefix(a, p) {
+				name, _, _ := strings.Cut(a, "=")
+				return name
+			}
+		}
+	}
+	return ""
+}
+
 // probeSpec : variables du moteur, puis MODEL_DRAFT résolu comme MMPROJ (nom
 // simple cherché dans les dossiers déclarés, ou chemin absolu). Introuvable ne
 // bloque PAS le lancement, contrairement au projecteur : le brouillon n'est
@@ -91,20 +129,23 @@ func specSidecarArch(arch string) bool {
 	return false
 }
 
-// specMode lit SPEC : "off", "auto", "mtp", ou "" si illisible.
+// specMode lit SPEC : "off", "auto", "mtp", "ngram", "mtp+ngram", ou "" si
+// illisible.
 func specMode(cfg map[string]string) string {
 	switch v := strings.ToLower(strings.TrimSpace(cfg["SPEC"])); v {
 	case "", "off", "non", "no", "0":
 		return "off"
-	case "auto", "mtp":
+	case "auto", "mtp", "ngram", "mtp+ngram":
 		return v
+	case "ngram+mtp":
+		return "mtp+ngram"
 	}
 	return ""
 }
 
 // specUserSet : EXTRA_ARGS ou l'environnement règlent déjà la spéculation.
 func specUserSet(extra []string, argEnv map[string]string) bool {
-	if hasAnyFlag(extra, specUserFlags...) {
+	if hasAnyFlag(extra, specUserFlags...) || hasFlagPrefix(extra, specUserPrefixes...) != "" {
 		return true
 	}
 	for _, k := range []string{"LLAMA_ARG_SPEC_TYPE", "LLAMA_ARG_SPEC_DRAFT_MODEL", "LLAMA_ARG_SPEC_DRAFT_HF_REPO"} {
@@ -204,7 +245,7 @@ func specArgs(cfg map[string]string, extra []string, si serveSysInfo) (args, not
 	draftKey := strings.TrimSpace(cfg["MODEL_DRAFT"])
 	switch mode {
 	case "":
-		return nil, []string{"SPEC=" + cfg["SPEC"] + " illisible (off, auto ou mtp) : sans décodage spéculatif"}, false
+		return nil, []string{"SPEC=" + cfg["SPEC"] + " illisible (off, auto, mtp, ngram ou mtp+ngram) : sans décodage spéculatif"}, false
 	case "off":
 		if draftKey != "" {
 			return nil, []string{"MODEL_DRAFT ignoré : SPEC=off (auto ou mtp pour s'en servir)"}, false
@@ -218,49 +259,40 @@ func specArgs(cfg map[string]string, extra []string, si serveSysInfo) (args, not
 		return nil, []string{"SPEC=" + mode + " : " + why + " — sans décodage spéculatif"}, false
 	}
 
-	// La source : MODEL_DRAFT s'il est posé, sinon la tête MTP du modèle. Dans
-	// les deux cas, on regarde les TENSEURS, comme llama.cpp : une clé
-	// nextn_predict_layers seule ne prouve pas que la tête est dans le fichier.
-	mtp := false
-	switch {
-	case draftKey != "":
-		switch {
-		case si.Draft == "":
-			why := "MODEL_DRAFT=" + draftKey + " introuvable"
-			if si.DraftErr != "" {
-				why += " (" + si.DraftErr + ")"
-			}
+	// N-grammes : leurs garde-fous d'abord, ils valent pour les deux formes.
+	if mode == "ngram" || mode == "mtp+ngram" {
+		if why := ngramBlocker(cfg, extra, si, mode); why != "" {
 			return skip(why)
-		case si.DraftGGUF == nil:
-			return skip("MODEL_DRAFT illisible (GGUF incomplet ou en cours de téléchargement ?)")
-		case si.DraftGGUF.HasNextNTensor:
-			if !helpSupportsMTP(si.Help) {
-				return skip("ce moteur ne connaît pas draft-mtp")
-			}
-			// Type explicite : llama.cpp ne le devine que sur la première tranche.
-			args, mtp = []string{"-md", si.Draft, "--spec-type", "draft-mtp"}, true
-		case specSidecarArch(si.DraftGGUF.Arch):
-			return skip("MODEL_DRAFT est une tête " + si.DraftGGUF.Arch +
-				", pas un modèle brouillon : règle -md et --spec-type dans EXTRA_ARGS")
-		default:
-			if !strings.Contains(si.Help, "--spec-type") || !strings.Contains(si.Help, "draft-simple") {
-				return skip("ce moteur ne connaît pas --spec-type draft-simple")
-			}
-			// Sans type, un brouillon qui n'est pas une tête MTP serait chargé en
-			// VRAM puis jamais utilisé.
-			args = []string{"-md", si.Draft, "--spec-type", "draft-simple"}
 		}
-	case si.GGUF == nil:
-		return skip("métadonnées du modèle illisibles")
-	case !si.GGUF.HasNextNTensor:
-		if mode == "mtp" || si.GGUF.NextN > 0 {
-			return skip("pas de tête MTP dans ce fichier (publiée à part ? MODEL_DRAFT=mtp-….gguf)")
+	}
+	if mode == "ngram" {
+		args, notes = ngramSpecArgs(cfg, extra, si, "")
+		return args, notes, false
+	}
+
+	src, mtp, why, quiet := specSource(mode, draftKey, si)
+	if mode == "mtp+ngram" && !mtp {
+		// Pas de tête MTP utilisable : la passer quand même ferait mourir le
+		// moteur sur « failed to create MTP context », et boucler. Les n-grammes,
+		// eux, n'ont besoin de rien.
+		if why == "" {
+			why = "MODEL_DRAFT n'est pas une tête MTP"
 		}
-		return nil, nil, false // auto sur un modèle sans MTP : rien à dire
-	case !helpSupportsMTP(si.Help):
-		return skip("ce moteur ne connaît pas draft-mtp")
-	default:
-		args, mtp = []string{"--spec-type", "draft-mtp"}, true
+		args, notes = ngramSpecArgs(cfg, extra, si, "SPEC=mtp+ngram : sans MTP ("+why+") → n-grammes seuls. ")
+		return args, notes, false
+	}
+	if why != "" {
+		return skip(why)
+	}
+	if quiet {
+		return nil, nil, false
+	}
+	args = src
+	if mode == "mtp+ngram" {
+		// Une seule liste : --spec-type s'additionne, mais une valeur unique se
+		// lit d'un coup d'œil dans le journal.
+		args[len(args)-1] = "draft-mtp,ngram-mod"
+		args = append(args, ngramModParams()...)
 	}
 
 	label := "brouillon " + baseName(si.Draft)
@@ -275,7 +307,10 @@ func specArgs(cfg map[string]string, extra []string, si serveSysInfo) (args, not
 		notes = append(notes, "SPEC=auto → "+label+" : sortie inchangée (chaque jeton est vérifié par le modèle), "+
 			"~1-2 Go de VRAM en plus. Mesure le prefill ; SPEC=off pour couper.")
 	} else {
-		note := "SPEC=mtp → " + label + " imposé : sortie inchangée, ~1-2 Go de VRAM en plus"
+		note := "SPEC=" + mode + " → " + label + " imposé : sortie inchangée, ~1-2 Go de VRAM en plus"
+		if mode == "mtp+ngram" {
+			note += " ; n-grammes en plus (ngram-mod, prioritaires quand ils trouvent une répétition)"
+		}
 		if why := fitBlocker(cfg, extra, si); why != "" || hasAnyFlag(extra, "-dev", "--device") {
 			if why == "" {
 				why = "--device"
@@ -290,6 +325,9 @@ func specArgs(cfg map[string]string, extra []string, si serveSysInfo) (args, not
 			note += " ; MTP qwen4exp très récent"
 		}
 		notes = append(notes, note)
+		if mode == "mtp+ngram" {
+			notes = append(notes, ngramCostNotes(cfg, extra, si)...)
+		}
 	}
 
 	// Nombre de jetons anticipés : défaut du moteur (3) si la clé est vide.
@@ -314,7 +352,7 @@ func specArgs(cfg map[string]string, extra []string, si serveSysInfo) (args, not
 	case "", "greedy":
 	case "probabilistic":
 		switch {
-		case mode != "mtp":
+		case mode == "auto":
 			notes = append(notes, "SPEC_SAMPLING=probabilistic ignoré avec SPEC=auto (SPEC=mtp pour le choisir) : greedy")
 		case statefulSampler(extra) != "":
 			notes = append(notes, "SPEC_SAMPLING=probabilistic refusé avec "+statefulSampler(extra)+
@@ -334,6 +372,158 @@ func specArgs(cfg map[string]string, extra []string, si serveSysInfo) (args, not
 	return args, notes, auto
 }
 
+// specSource : d'où vient le brouillon de SPEC=auto|mtp|mtp+ngram. MODEL_DRAFT
+// s'il est posé, sinon la tête MTP du modèle ; dans les deux cas on regarde les
+// TENSEURS, comme llama.cpp : une clé nextn_predict_layers seule ne prouve pas
+// que la tête est dans le fichier. why non vide = aucun brouillon ; quiet =
+// rien à dire (auto sur un modèle sans MTP).
+func specSource(mode, draftKey string, si serveSysInfo) (args []string, mtp bool, why string, quiet bool) {
+	switch {
+	case draftKey != "":
+		switch {
+		case si.Draft == "":
+			why := "MODEL_DRAFT=" + draftKey + " introuvable"
+			if si.DraftErr != "" {
+				why += " (" + si.DraftErr + ")"
+			}
+			return nil, false, why, false
+		case si.DraftGGUF == nil:
+			return nil, false, "MODEL_DRAFT illisible (GGUF incomplet ou en cours de téléchargement ?)", false
+		case si.DraftGGUF.HasNextNTensor:
+			if !helpSupportsMTP(si.Help) {
+				return nil, false, "ce moteur ne connaît pas draft-mtp", false
+			}
+			// Type explicite : llama.cpp ne le devine que sur la première tranche.
+			return []string{"-md", si.Draft, "--spec-type", "draft-mtp"}, true, "", false
+		case specSidecarArch(si.DraftGGUF.Arch):
+			return nil, false, "MODEL_DRAFT est une tête " + si.DraftGGUF.Arch +
+				", pas un modèle brouillon : règle -md et --spec-type dans EXTRA_ARGS", false
+		case mode == "mtp+ngram":
+			return nil, false, "", false // un modèle brouillon n'est pas une tête MTP
+		default:
+			if !strings.Contains(si.Help, "--spec-type") || !strings.Contains(si.Help, "draft-simple") {
+				return nil, false, "ce moteur ne connaît pas --spec-type draft-simple", false
+			}
+			// Sans type, un brouillon qui n'est pas une tête MTP serait chargé en
+			// VRAM puis jamais utilisé.
+			return []string{"-md", si.Draft, "--spec-type", "draft-simple"}, false, "", false
+		}
+	case si.GGUF == nil:
+		return nil, false, "métadonnées du modèle illisibles", false
+	case !si.GGUF.HasNextNTensor:
+		if mode != "auto" || si.GGUF.NextN > 0 {
+			return nil, false, "pas de tête MTP dans ce fichier (publiée à part ? MODEL_DRAFT=mtp-….gguf)", false
+		}
+		return nil, false, "", true
+	case !helpSupportsMTP(si.Help):
+		return nil, false, "ce moteur ne connaît pas draft-mtp", false
+	}
+	return []string{"--spec-type", "draft-mtp"}, true, "", false
+}
+
+// ngramModParams : les trois bornes de ngram-mod, toujours explicites.
+func ngramModParams() []string {
+	return []string{
+		"--spec-ngram-mod-n-match", strconv.Itoa(specNgramNMatch),
+		"--spec-ngram-mod-n-min", strconv.Itoa(specNgramNMin),
+		"--spec-ngram-mod-n-max", strconv.Itoa(specNgramNMax),
+	}
+}
+
+// ngramBlocker dit pourquoi SPEC=ngram|mtp+ngram ne s'active pas, ou vide.
+//
+//   - Le moteur doit connaître --spec-ngram-mod-n-match, pas seulement le mot
+//     « ngram-mod » : les moteurs d'avant le renommage ont encore le type dans
+//     leur liste mais refusent les drapeaux actuels, et meurent au démarrage.
+//   - SPEC=ngram n'a pas de brouillon : un --spec-draft-* d'EXTRA_ARGS veut dire
+//     qu'on règle un brouillon à la main, on ne mélange pas.
+//   - Poids en RAM (experts MoE sur CPU…) : llama.cpp recopie vers le GPU les
+//     poids d'un lot dès GGML_OP_OFFLOAD_MIN_BATCH jetons (32 par défaut). Un
+//     lot de vérification de n_max+1 jetons au-dessus du seuil ferait passer
+//     les experts de chaque couche par le PCIe — voire par le disque si le
+//     modèle mappé dépasse la RAM — à chaque brouillon. Refusé tant que le seuil
+//     n'est pas relevé au-dessus du lot.
+func ngramBlocker(cfg map[string]string, extra []string, si serveSysInfo, mode string) string {
+	if !strings.Contains(si.Help, "--spec-ngram-mod-n-match") {
+		return "ce moteur ne connaît pas --spec-ngram-mod-n-match"
+	}
+	if mode == "ngram" {
+		if f := hasFlagPrefix(extra, "--spec-draft-", "--spec_draft_"); f != "" {
+			return f + " dans EXTRA_ARGS (brouillon réglé à la main)"
+		}
+	}
+	blocks := 0
+	if si.GGUF != nil {
+		blocks = si.GGUF.BlockCount
+	}
+	if r := cpuWeights(cfg, extra, si.ArgEnv, blocks); r != "" {
+		if thr := opOffloadThreshold(cfg, si); specNgramNMax+1 >= thr {
+			return fmt.Sprintf("%s : un lot de vérification de %d jetons atteint GGML_OP_OFFLOAD_MIN_BATCH (%d) et "+
+				"recopierait ces poids vers le GPU à chaque brouillon — OP_OFFLOAD_MIN_BATCH=128 pour l'essayer, à mesurer",
+				r, specNgramNMax+1, thr)
+		}
+	}
+	return ""
+}
+
+// opOffloadThreshold : le seuil GGML_OP_OFFLOAD_MIN_BATCH que verra le moteur —
+// celui de l'environnement, sinon celui d'OP_OFFLOAD_MIN_BATCH, sinon le défaut.
+func opOffloadThreshold(cfg map[string]string, si serveSysInfo) int {
+	v := strings.TrimSpace(si.UserEnv["GGML_OP_OFFLOAD_MIN_BATCH"])
+	if v == "" {
+		v, _ = opOffloadMinBatchEnv(cfg, si)
+	}
+	if n, err := strconv.Atoi(v); err == nil && n > 0 {
+		return n
+	}
+	return ggmlOffloadMinBatchDefault
+}
+
+// ngramSpecArgs : SPEC=ngram, ou le repli de mtp+ngram sans tête MTP (lead dit
+// pourquoi). Pas de --spec-draft-* : il n'y a pas de brouillon.
+func ngramSpecArgs(cfg map[string]string, extra []string, si serveSysInfo, lead string) (args, notes []string) {
+	args = append([]string{"--spec-type", "ngram-mod"}, ngramModParams()...)
+	notes = append(notes, lead+fmt.Sprintf("SPEC=ngram → n-grammes du contexte (ngram-mod, brouillons de %d à %d jetons) : "+
+		"distribution inchangée (chaque jeton vérifié), ~16 Mo de RAM ; utile surtout en mode code, à mesurer "+
+		"(acceptation par nature dans /api/perf/summary)", specNgramNMin, specNgramNMax))
+	if lead == "" {
+		// --spec-type explicite : llama.cpp ne choisit plus de lui-même la tête MTP.
+		switch {
+		case strings.TrimSpace(cfg["MODEL_DRAFT"]) != "":
+			notes = append(notes, "MODEL_DRAFT ignoré avec SPEC=ngram : SPEC=mtp+ngram pour les deux")
+		case si.GGUF != nil && si.GGUF.HasNextNTensor:
+			notes = append(notes, "tête MTP du modèle inutilisée avec SPEC=ngram : SPEC=mtp+ngram pour les deux")
+		}
+	}
+	if strings.TrimSpace(cfg["SPEC_N_MAX"]) != "" || strings.TrimSpace(cfg["SPEC_SAMPLING"]) != "" {
+		notes = append(notes, "SPEC_N_MAX et SPEC_SAMPLING ignorés : les n-grammes n'ont pas de brouillon à régler")
+	}
+	return args, append(notes, ngramCostNotes(cfg, extra, si)...)
+}
+
+// ngramCostNotes : ce que les longs brouillons coûtent, là où ça se voit.
+func ngramCostNotes(cfg map[string]string, extra []string, si serveSysInfo) []string {
+	var notes []string
+	if si.GGUF != nil && si.GGUF.Hybrid {
+		notes = append(notes, "modèle hybride : chaque brouillon n-gramme copie l'état récurrent (point de reprise en RAM "+
+			"hôte) et le recharge s'il est rejeté — compare le temps par tour, pas seulement le débit")
+	}
+	blocks := 0
+	if si.GGUF != nil {
+		blocks = si.GGUF.BlockCount
+	}
+	if cpuWeights(cfg, extra, si.ArgEnv, blocks) != "" && si.ModelBytes > 0 && si.RAMMiB > 0 &&
+		si.ModelBytes > si.RAMMiB<<20 {
+		notes = append(notes, "modèle plus gros que la RAM, poids sur CPU : un lot de vérification lit la plupart des "+
+			"experts de chaque couche — surveille les lectures disque, pas seulement les jetons/s")
+	}
+	if nglForced(cfg, extra) {
+		notes = append(notes, fmt.Sprintf("NGL imposé (--fit inactif) : les logits de %d positions par slot prennent "+
+			"quelques dizaines de Mio de VRAM en plus", specNgramNMax+1))
+	}
+	return notes
+}
+
 // --- Jeton de tentative ------------------------------------------------------
 //
 // Un essai automatique qui fait tomber le moteur ne doit pas se rejouer : sous

internal/loki/backend_serve_spec_test.go

@@ -332,3 +332,164 @@ func TestLastOffload(t *testing.T) {
 		t.Errorf("tout sur GPU : got %d/%d", n, m)
 	}
 }
+
+// helpNgram : un moteur qui connaît les drapeaux actuels de ngram-mod.
+const helpNgram = helpSpec + `--spec-ngram-mod-n-min N                minimum number of ngram tokens (default: 48)
+--spec-ngram-mod-n-max N                maximum number of ngram tokens (default: 64)
+--spec-ngram-mod-n-match N              ngram-mod lookup length (default: 24)
+`
+
+func TestSpecArgsNgram(t *testing.T) {
+	ngram := []string{"--spec-type", "ngram-mod",
+		"--spec-ngram-mod-n-match", "24", "--spec-ngram-mod-n-min", "48", "--spec-ngram-mod-n-max", "64"}
+	both := []string{"--spec-type", "draft-mtp,ngram-mod",
+		"--spec-ngram-mod-n-match", "24", "--spec-ngram-mod-n-min", "48", "--spec-ngram-mod-n-max", "64",
+		"--spec-draft-sampling", "greedy"}
+	cfgOf := func(kv ...string) map[string]string {
+		m := map[string]string{}
+		for i := 0; i+1 < len(kv); i += 2 {
+			m[kv[i]] = kv[i+1]
+		}
+		return m
+	}
+	dense := func(s *serveSysInfo) { s.GGUF = &GGUFInfo{Arch: "llama", BlockCount: 32} }
+	cases := []struct {
+		name  string
+		cfg   map[string]string
+		extra []string
+		si    func(*serveSysInfo)
+		want  []string
+		notes int
+	}{
+		{name: "ngram, modèle dense : forme explicite, jamais --spec-default",
+			cfg: cfgOf("SPEC", "ngram"), si: dense, want: ngram, notes: 1},
+		{name: "ngram+mtp s'écrit aussi dans l'autre sens",
+			cfg: cfgOf("SPEC", "ngram+mtp"), want: both, notes: 2},
+		{name: "ngram sur un modèle hybride à tête MTP : tête inutilisée et points de reprise dits",
+			cfg: cfgOf("SPEC", "ngram"), want: ngram, notes: 3},
+		{name: "ngram, moteur qui n'a que le type dans sa liste : rien",
+			cfg: cfgOf("SPEC", "ngram"), notes: 1, si: func(s *serveSysInfo) { s.Help = helpSpec }},
+		{name: "mtp+ngram, moteur sans drapeaux ngram-mod : rien",
+			cfg: cfgOf("SPEC", "mtp+ngram"), notes: 1, si: func(s *serveSysInfo) { s.Help = helpSpec }},
+		{name: "mtp+ngram avec la tête dans le fichier : une seule liste de types",
+			cfg: cfgOf("SPEC", "mtp+ngram"), want: both, notes: 2},
+		{name: "mtp+ngram sans tête MTP : n-grammes seuls, jamais « failed to create MTP context »",
+			cfg: cfgOf("SPEC", "mtp+ngram"), si: dense, want: ngram, notes: 1},
+		{name: "mtp+ngram, moteur sans draft-mtp : n-grammes seuls",
+			cfg: cfgOf("SPEC", "mtp+ngram"), want: ngram, notes: 2,
+			si: func(s *serveSysInfo) {
+				s.Help = strings.ReplaceAll(s.Help, "draft-mtp", "draft-xxx")
+			}},
+		{name: "mtp+ngram avec un petit modèle brouillon : n-grammes seuls, pas de -md",
+			cfg: cfgOf("SPEC", "mtp+ngram", "MODEL_DRAFT", "Qwen3-0.6B.gguf"), want: ngram, notes: 2,
+			si: func(s *serveSysInfo) {
+				s.Draft = "/models/Qwen3-0.6B.gguf"
+				s.DraftGGUF = &GGUFInfo{Arch: "qwen3", BlockCount: 28}
+			}},
+		{name: "mtp+ngram avec la tête MTP publiée à part",
+			cfg: cfgOf("SPEC", "mtp+ngram", "MODEL_DRAFT", "mtp-q.gguf"), notes: 2,
+			want: append([]string{"-md", "/models/mtp-q.gguf"}, both...),
+			si: func(s *serveSysInfo) {
+				s.GGUF.HasNextNTensor = false
+				s.Draft = "/models/mtp-q.gguf"
+				s.DraftGGUF = &GGUFInfo{Arch: "qwen35", BlockCount: 65, HasNextNTensor: true}
+			}},
+		{name: "ngram + MODEL_DRAFT : brouillon ignoré, et dit",
+			cfg: cfgOf("SPEC", "ngram", "MODEL_DRAFT", "mtp-q.gguf"), si: dense, want: ngram, notes: 2},
+		{name: "ngram + SPEC_N_MAX : ignoré, et dit",
+			cfg: cfgOf("SPEC", "ngram", "SPEC_N_MAX", "4"), si: dense, want: ngram, notes: 2},
+		{name: "--spec-type dans EXTRA_ARGS : Loki se tait",
+			cfg: cfgOf("SPEC", "ngram"), extra: []string{"--spec-type", "ngram-simple"}, notes: 1},
+		{name: "--spec_type=… dans EXTRA_ARGS : Loki se tait",
+			cfg: cfgOf("SPEC", "ngram"), extra: []string{"--spec_type=ngram-mod"}, notes: 1},
+		{name: "--spec-default dans EXTRA_ARGS : Loki se tait",
+			cfg: cfgOf("SPEC", "mtp+ngram"), extra: []string{"--spec-default"}, notes: 1},
+		{name: "--spec-ngram-mod-n-max dans EXTRA_ARGS : Loki se tait",
+			cfg: cfgOf("SPEC", "ngram"), extra: []string{"--spec-ngram-mod-n-max=16"}, notes: 1},
+		{name: "-md dans EXTRA_ARGS : Loki se tait",
+			cfg: cfgOf("SPEC", "mtp+ngram"), extra: []string{"-md", "d.gguf"}, notes: 1},
+		{name: "LLAMA_ARG_SPEC_TYPE posée : Loki se tait", cfg: cfgOf("SPEC", "ngram"), notes: 1,
+			si: func(s *serveSysInfo) { s.ArgEnv["LLAMA_ARG_SPEC_TYPE"] = "ngram-mod" }},
+		{name: "ngram + --spec-draft-n-max à la main : rien",
+			cfg: cfgOf("SPEC", "ngram"), si: dense, extra: []string{"--spec-draft-n-max", "8"}, notes: 1},
+		{name: "mtp+ngram + --spec-draft-n-max à la main : la règle de SPEC=mtp",
+			cfg: cfgOf("SPEC", "mtp+ngram"), extra: []string{"--spec-draft-n-max", "8"}, want: both, notes: 2},
+		{name: "experts sur CPU, seuil par défaut : refusé, OP_OFFLOAD_MIN_BATCH suggéré",
+			cfg: cfgOf("SPEC", "ngram"), si: dense, extra: []string{"--n-cpu-moe", "40"}, notes: 1},
+		{name: "experts sur CPU, mtp+ngram : refusé aussi",
+			cfg: cfgOf("SPEC", "mtp+ngram"), extra: []string{"-ot", "exps=CPU"}, notes: 1},
+		{name: "experts sur CPU, OP_OFFLOAD_MIN_BATCH=64 : encore sous le lot de 65, refusé",
+			cfg: cfgOf("SPEC", "ngram", "OP_OFFLOAD_MIN_BATCH", "64"), si: dense, extra: []string{"-cmoe"}, notes: 1},
+		{name: "experts sur CPU, OP_OFFLOAD_MIN_BATCH=128 : accepté",
+			cfg: cfgOf("SPEC", "ngram", "OP_OFFLOAD_MIN_BATCH", "128"), si: dense, extra: []string{"-cmoe"}, want: ngram, notes: 1},
+		{name: "experts sur CPU, GGML_OP_OFFLOAD_MIN_BATCH=256 dans l'environnement : accepté",
+			cfg: cfgOf("SPEC", "ngram"), extra: []string{"--n-cpu-moe", "40"}, want: ngram, notes: 1,
+			si: func(s *serveSysInfo) {
+				dense(s)
+				s.UserEnv = map[string]string{"GGML_OP_OFFLOAD_MIN_BATCH": "256"}
+			}},
+		{name: "experts sur CPU, modèle plus gros que la RAM : accepté avec l'avertissement",
+			cfg: cfgOf("SPEC", "ngram", "OP_OFFLOAD_MIN_BATCH", "128"), extra: []string{"--n-cpu-moe", "40"},
+			want: ngram, notes: 2,
+			si: func(s *serveSysInfo) {
+				dense(s)
+				s.ModelBytes, s.RAMMiB = 82<<30, 64<<10
+			}},
+		{name: "NGL imposé : logits en VRAM dits",
+			cfg: cfgOf("SPEC", "ngram", "NGL", "40"), si: dense, want: ngram, notes: 2},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			si := mtpReady()
+			si.Help = helpNgram
+			if c.si != nil {
+				c.si(&si)
+			}
+			got, notes, isAuto := specArgs(c.cfg, c.extra, si)
+			if !reflect.DeepEqual(got, c.want) {
+				t.Errorf("args = %q, attendu %q", got, c.want)
+			}
+			if isAuto {
+				t.Error("ngram n'est jamais automatique")
+			}
+			if len(notes) != c.notes {
+				t.Errorf("%d notes, attendu %d : %q", len(notes), c.notes, notes)
+			}
+			for _, a := range got {
+				if a == "--spec-default" || strings.HasPrefix(a, "--spec-synth") {
+					t.Errorf("drapeau interdit %q", a)
+				}
+			}
+		})
+	}
+}
+
+// Sans SPEC, la même ligne qu'avant, quel que soit le moteur.
+func TestBuildServeArgsNgramDefault(t *testing.T) {
+	si := mtpReady()
+	si.Help = helpNgram
+	base, _, _ := buildServeArgs(map[string]string{}, nil, "/bin/llama-server", si)
+	for _, a := range base {
+		if strings.HasPrefix(a, "--spec") {
+			t.Fatalf("SPEC absent : aucun drapeau de spéculation, %q", base)
+		}
+	}
+	got, _, _ := buildServeArgs(map[string]string{"SPEC": "ngram"}, []string{"--jinja"}, "/bin/llama-server", si)
+	i := slices.Index(got, "--spec-type")
+	if i < 0 || got[i+1] != "ngram-mod" || slices.Index(got, "--jinja") < i {
+		t.Fatalf("SPEC=ngram : %q", got)
+	}
+}
+
+func TestSynthAcceptanceWarned(t *testing.T) {
+	for _, extra := range [][]string{{"--spec-synth-len", "3"}, {"--spec-synth-rates=0.5,0.5"}} {
+		if n := lossyCacheNotes(extra, serveSysInfo{ArgEnv: map[string]string{}}); len(n) != 1 ||
+			!strings.Contains(n[0], "AU HASARD") {
+			t.Errorf("%q : %q", extra, n)
+		}
+	}
+	si := serveSysInfo{ArgEnv: map[string]string{"LLAMA_ARG_SPEC_SYNTH_LEN": "3"}}
+	if n := lossyCacheNotes(nil, si); len(n) != 1 {
+		t.Errorf("variable : %q", n)
+	}
+}

internal/loki/backend_serve_split.go

@@ -0,0 +1,381 @@
+package loki
+
+import (
+	"context"
+	"fmt"
+	"math"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// Parallélisme de tenseurs (SPLIT_MODE=tensor, off par défaut) : expérimental.
+//
+// La découpe par couches (défaut de llama.cpp) donne à chaque carte des
+// couches entières, traversées l'une après l'autre. En mode tensor, chaque
+// couche est coupée entre les cartes, qui calculent en même temps puis
+// additionnent leurs morceaux (all-reduce). Sur deux RTX 4090, l'amont mesure
+// +21-30 % au décodage, mais -37 % au prefill — et la boucle d'agent de Loki
+// relit beaucoup. Sur deux GeForce en PCIe sans P2P, la somme passe par
+// l'hôte : un gain net par tour est loin d'être acquis. D'où l'opt-in, et une
+// longue liste de refus propres plutôt qu'un moteur qui meurt en boucle.
+//
+// Fidélité : l'all-reduce change l'ordre des additions (bruit de virgule
+// flottante), mais le chemin NCCL va plus loin — au-delà de 32 768 éléments il
+// COMPRESSE les sommes partielles en BF16 (ggml-cuda.cu), soit à chaque couche
+// de chaque prefill : une perte de précision du calcul, de la classe d'une
+// quantification. Loki pose donc GGML_CUDA_ALLREDUCE=internal (réduction dans
+// le type natif), sauf si l'utilisateur a choisi lui-même. Le cache KV doit
+// rester f16, bf16 ou f32 : le mode tensor ne gère pas les caches quantifiés,
+// et Loki ne réécrit jamais un type de cache d'office (ça change le budget
+// VRAM). Pas de --fit en mode tensor (common/fit.cpp) : Loki estime la VRAM
+// lui-même et refuse si le compte ne tient pas, sans jamais réduire CTX.
+
+// splitDev : une carte telle que la voit CE moteur (--list-devices), dans son
+// ordre — celui que suivent -ts et --device.
+type splitDev struct {
+	ID       string // CUDA0, Vulkan1…
+	TotalMiB int64
+}
+
+// splitTensorDenyArch : les architectures que llama.cpp refuse en mode tensor
+// (llm_arch_supports_sm_tensor) — il mourrait au chargement, et systemd
+// relancerait en boucle. qwen4exp n'y est pas, mais Loki l'écarte : son preset
+// place les experts sur CPU avec un cache q8_0, l'inverse de ce qu'exige le
+// mode tensor.
+var splitTensorDenyArch = map[string]bool{
+	"grok": true, "mpt": true, "plamo2": true, "minicpm3": true, "gemma3n": true, "mamba": true, "mamba2": true,
+	"jamba": true, "falcon-h1": true, "olmo2": true, "olmoe": true, "deepseek2": true, "deepseek32": true,
+	"hy_v4": true, "dots3note": true, "glm-dsa": true, "bitnet": true, "t5": true, "nemotron_h": true,
+	"nemotron_h_moe": true, "granitehybrid": true, "minimax-01": true, "minimax-m2": true, "minimax-m3": true,
+	"mistral4": true, "kimi-linear": true, "bailingmoe3": true, "kimi-k3": true, "glm5-next": true,
+	"qwen3tts": true, "qwen4exp": true,
+}
+
+// splitArgEnv : les variables qui décident de ce que SPLIT_MODE règlerait.
+var splitArgEnv = []string{"LLAMA_ARG_FLASH_ATTN", "LLAMA_ARG_BACKEND_SAMPLING", "LLAMA_ARG_TENSOR_SPLIT"}
+
+// splitModeKey lit SPLIT_MODE : "" (clé absente, off ou layer — le défaut du
+// moteur, rien à poser), "tensor", ou "?" si illisible.
+func splitModeKey(cfg map[string]string) string {
+	switch v := strings.ToLower(strings.TrimSpace(cfg["SPLIT_MODE"])); v {
+	case "", "off", "layer", "non", "no", "0":
+		return ""
+	case "tensor":
+		return v
+	}
+	return "?"
+}
+
+// helpSupportsSplitTensor : la liste LITTÉRALE des valeurs de -sm. Le mot
+// « tensor » seul est partout dans l'aide (--tensor-split, --override-tensor) :
+// s'y fier ferait passer -sm tensor à un moteur qui le refuse au démarrage.
+func helpSupportsSplitTensor(help string) bool {
+	return strings.Contains(help, "{none,layer,row,tensor}")
+}
+
+// probeSplit : seulement si SPLIT_MODE=tensor et que le moteur le propose —
+// sans la clé, rien n'est lu ni lancé. --list-devices tourne dans
+// l'environnement du vrai lancement (bibliothèques, CUDA_VISIBLE_DEVICES et
+// PCI_BUS_ID déjà posés par cmdServe) : même ordre de cartes que le moteur.
+func probeSplit(cfg map[string]string, bin string, si *serveSysInfo) {
+	if splitModeKey(cfg) != "tensor" || !helpSupportsSplitTensor(si.Help) {
+		return
+	}
+	if si.ArgEnv == nil {
+		si.ArgEnv = map[string]string{}
+	}
+	for _, k := range splitArgEnv {
+		if v, ok := os.LookupEnv(k); ok && strings.TrimSpace(v) != "" {
+			si.ArgEnv[k] = v
+		}
+	}
+	if si.UserEnv == nil {
+		si.UserEnv = map[string]string{}
+	}
+	if v := os.Getenv("GGML_CUDA_ALLREDUCE"); v != "" {
+		si.UserEnv["GGML_CUDA_ALLREDUCE"] = v
+	}
+	si.SplitDevs = listEngineDevices(bin)
+}
+
+// listEngineDevices : les cartes que CE moteur voit (--list-devices), dans
+// l'environnement du processus — celui du vrai lancement quand cmdServe
+// appelle. nil si le moteur échoue : sortie tronquée (carte pleine, moteur
+// planté), on ne s'y fie pas.
+func listEngineDevices(bin string) []splitDev {
+	ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
+	defer cancel()
+	out, err := hideCmd(exec.CommandContext(ctx, bin, "--list-devices")).CombinedOutput()
+	if err != nil {
+		return nil
+	}
+	return splitDevsFrom(parseListDevices(string(out)))
+}
+
+// splitDevsFrom : les cartes de parseListDevices (ou de devices.json, relu en
+// JSON : les nombres y sont des float64).
+func splitDevsFrom(list []map[string]any) []splitDev {
+	var devs []splitDev
+	for _, d := range list {
+		id, _ := d["id"].(string)
+		var total int64
+		switch v := d["total_mib"].(type) {
+		case int:
+			total = int64(v)
+		case float64:
+			total = int64(v)
+		}
+		devs = append(devs, splitDev{ID: id, TotalMiB: total})
+	}
+	return devs
+}
+
+// splitPlan décide de SPLIT_MODE=tensor pour ce lancement. Fonction pure.
+//
+//	on       : accepté ; la ligne gagne -sm tensor et ses compagnons
+//	why      : pourquoi refusé (vide = clé absente)
+//	devs     : les cartes du découpage, dans l'ordre du moteur
+//	needMiB  : la VRAM estimée (poids + cache de CTX jetons)
+func splitPlan(cfg map[string]string, extra []string, si serveSysInfo) (on bool, why string, devs []splitDev, needMiB int64) {
+	switch splitModeKey(cfg) {
+	case "":
+		return false, "", nil, 0
+	case "?":
+		return false, "SPLIT_MODE=" + strings.TrimSpace(cfg["SPLIT_MODE"]) + " illisible (tensor ou off)", nil, 0
+	}
+	refuse := func(why string) (bool, string, []splitDev, int64) { return false, why, nil, 0 }
+	if isExternalConfig(cfg) {
+		return refuse("preset externe")
+	}
+	if !helpSupportsSplitTensor(si.Help) {
+		return refuse("ce moteur ne propose pas -sm tensor")
+	}
+	if sm := flagValue(extra, "-sm", "--split-mode"); sm != "" {
+		return refuse("-sm " + sm + " déjà dans EXTRA_ARGS")
+	}
+	if si.ArgEnv["LLAMA_ARG_SPLIT_MODE"] != "" {
+		return refuse("LLAMA_ARG_SPLIT_MODE déjà posée")
+	}
+	fa := flagValue(extra, "-fa", "--flash-attn")
+	if fa == "" {
+		fa = si.ArgEnv["LLAMA_ARG_FLASH_ATTN"]
+	}
+	switch strings.ToLower(strings.TrimSpace(fa)) {
+	case "off", "disabled", "false", "0":
+		return refuse("Flash Attention coupée (-fa " + fa + ") : le mode tensor l'exige")
+	}
+	if hasAnyFlag(extra, "-bs", "--backend-sampling") || envTruthy(si.ArgEnv["LLAMA_ARG_BACKEND_SAMPLING"]) {
+		return refuse("échantillonnage sur GPU (--backend-sampling) non pris en charge en mode tensor")
+	}
+	k, v, _ := effectiveKVTypes(cfg, extra, si.ArgEnv)
+	if !splitKVOK(k) || !splitKVOK(v) {
+		return refuse(fmt.Sprintf("cache KV %s/%s : le mode tensor n'accepte que f16, bf16 ou f32 "+
+			"(jamais réécrit d'office : la VRAM changerait)", kvName(k), kvName(v)))
+	}
+	if r := tensorOverride(extra, si.ArgEnv); r != "" {
+		return refuse(r + " : le mode tensor met tout sur les cartes")
+	}
+	if !kvOffloaded(extra, si.ArgEnv) {
+		return refuse("cache KV sur CPU")
+	}
+	switch {
+	case si.GGUF == nil || si.ModelBytes <= 0:
+		return refuse("métadonnées ou taille du modèle illisibles")
+	case splitTensorDenyArch[strings.ToLower(si.GGUF.Arch)]:
+		return refuse("architecture " + si.GGUF.Arch + " exclue du mode tensor")
+	}
+	if _, why := splitNGL(cfg, extra, si.GGUF.BlockCount); why != "" {
+		return refuse(why)
+	}
+	ctxS, ok := ctxFixed(cfg, extra)
+	if !ok {
+		return refuse("contexte « " + ctxS + " » non chiffré : pas de --fit en mode tensor, donne un CTX explicite")
+	}
+	if sideSlotOn(cfg) {
+		return refuse("SIDE_SLOT : cache doublé, sans --fit pour rattraper")
+	}
+	if specMode(cfg) != "off" || specUserSet(extra, si.ArgEnv) {
+		return refuse("décodage spéculatif : brouillon et vérification par lots non validés en mode tensor")
+	}
+	devs, why = splitDevices(extra, si)
+	if why != "" {
+		return refuse(why)
+	}
+	// VRAM : poids + cache de CTX jetons (et état récurrent) contre 90 % des
+	// cartes, la marge de SIDE_SLOT. Les tampons de calcul n'y sont pas : c'est
+	// un minimum, pas une promesse — le journal dira le reste.
+	ctx, _ := strconv.Atoi(ctxS)
+	perTok, rec := ggufStateBytes(*si.GGUF, k, v)
+	if perTok <= 0 {
+		return refuse("taille du cache KV inconnue pour ce modèle")
+	}
+	var total int64
+	for _, d := range devs {
+		total += d.TotalMiB
+	}
+	mm := int64(0)
+	if si.MMProj != "" {
+		if st, err := os.Stat(si.MMProj); err == nil {
+			mm = st.Size()
+		}
+	}
+	need := float64(si.ModelBytes+mm) + perTok*float64(ctx) + float64(rec)
+	needMiB = int64(math.Ceil(need / (1 << 20)))
+	if need > 0.9*float64(total)*(1<<20) {
+		return refuse(fmt.Sprintf("VRAM insuffisante sans --fit : ~%d Mio (poids + cache de %d jetons) pour %d Mio "+
+			"sur %d cartes — CTX n'est jamais réduit d'office", needMiB, ctx, total, len(devs)))
+	}
+	return true, "", devs, needMiB
+}
+
+func splitKVOK(t string) bool {
+	switch strings.ToLower(strings.TrimSpace(t)) {
+	case "", "f16", "bf16", "f32":
+		return true
+	}
+	return false
+}
+
+func kvName(t string) string {
+	if t == "" {
+		return "f16"
+	}
+	return t
+}
+
+// splitNGL : les couches GPU en mode tensor, où tout doit être sur les cartes.
+// Un -ngl d'EXTRA_ARGS reste celui de l'utilisateur (rien à ajouter) s'il dit
+// « tout » ; sinon NGL est traduit en « -ngl all » (999, auto et la clé absente
+// visent déjà le tout-GPU, mais auto ne fait rien sans --fit). Une valeur qui
+// laisse des couches au CPU est refusée.
+func splitNGL(cfg map[string]string, extra []string, blocks int) (args []string, why string) {
+	all := func(v string) bool {
+		v = strings.ToLower(strings.TrimSpace(v))
+		if v == "all" || v == "999" {
+			return true
+		}
+		n, err := strconv.Atoi(v)
+		return err == nil && blocks > 0 && n >= blocks+1
+	}
+	if v := flagValue(extra, "-ngl", "--n-gpu-layers", "--gpu-layers"); v != "" {
+		if all(v) {
+			return nil, ""
+		}
+		return nil, "-ngl " + v + " dans EXTRA_ARGS : le mode tensor veut toutes les couches sur les cartes (all)"
+	}
+	switch v := strings.TrimSpace(cfg["NGL"]); {
+	case v == "" || strings.EqualFold(v, "auto") || all(v):
+		return []string{"-ngl", "all"}, ""
+	default:
+		return nil, "NGL=" + v + " : le mode tensor veut toutes les couches sur les cartes (all)"
+	}
+}
+
+// splitDevices : les cartes du découpage. --device (EXTRA_ARGS ou variable)
+// choisit lesquelles, dans son ordre ; sinon toutes celles que liste le
+// moteur. Toutes CUDA (l'all-reduce n'existe qu'entre cartes CUDA), deux au
+// moins.
+func splitDevices(extra []string, si serveSysInfo) ([]splitDev, string) {
+	if len(si.SplitDevs) == 0 {
+		return nil, "cartes inconnues (--list-devices n'a rien répondu)"
+	}
+	devs := si.SplitDevs
+	sel := flagValue(extra, "-dev", "--device")
+	if sel == "" {
+		sel = si.ArgEnv["LLAMA_ARG_DEVICE"]
+	}
+	if sel = strings.TrimSpace(sel); sel != "" {
+		devs = nil
+		for _, name := range strings.Split(sel, ",") {
+			name = strings.TrimSpace(name)
+			found := false
+			for _, d := range si.SplitDevs {
+				if strings.EqualFold(d.ID, name) {
+					devs, found = append(devs, d), true
+					break
+				}
+			}
+			if !found {
+				return nil, "--device " + name + " inconnu de ce moteur"
+			}
+		}
+	}
+	for _, d := range devs {
+		if !strings.HasPrefix(strings.ToUpper(d.ID), "CUDA") {
+			return nil, d.ID + " n'est pas une carte CUDA"
+		}
+	}
+	if len(devs) < 2 {
+		return nil, "une seule carte"
+	}
+	return devs, ""
+}
+
+// splitTS : la répartition par défaut, au prorata de la VRAM TOTALE de chaque
+// carte (la libre varie avec ce qui tourne encore au lancement), en pour cent.
+func splitTS(devs []splitDev) string {
+	var total int64
+	for _, d := range devs {
+		total += d.TotalMiB
+	}
+	if total <= 0 {
+		return ""
+	}
+	parts := make([]string, len(devs))
+	for i, d := range devs {
+		parts[i] = strconv.FormatInt(int64(math.Round(100*float64(d.TotalMiB)/float64(total))), 10)
+	}
+	return strings.Join(parts, ",")
+}
+
+// splitTensorArgs : ce que SPLIT_MODE=tensor ajoute à la ligne, à la place du -ngl
+// habituel (nglOut), l'environnement et les notes. on=false : rien, et la
+// ligne reste celle d'avant à l'octet près.
+func splitTensorArgs(cfg map[string]string, extra []string, si serveSysInfo) (on bool, args, ngl []string, env map[string]string, notes []string) {
+	ok, why, devs, needMiB := splitPlan(cfg, extra, si)
+	if !ok {
+		if why != "" {
+			notes = append(notes, "SPLIT_MODE=tensor refusé ("+why+") : découpe par couches, comme sans la clé")
+		}
+		return false, nil, nil, nil, notes
+	}
+	ngl, _ = splitNGL(cfg, extra, si.GGUF.BlockCount)
+	args = []string{"-sm", "tensor"}
+	ts := ""
+	if !hasAnyFlag(extra, "-ts", "--tensor-split") && si.ArgEnv["LLAMA_ARG_TENSOR_SPLIT"] == "" {
+		if ts = splitTS(devs); ts != "" {
+			args = append(args, "-ts", ts)
+		}
+	}
+	// llama.cpp active de lui-même Flash Attention en mode tensor ; l'écrire
+	// le rend lisible dans le journal. Jamais en double d'un -fa de l'utilisateur.
+	if !hasAnyFlag(extra, "-fa", "--flash-attn") && si.ArgEnv["LLAMA_ARG_FLASH_ATTN"] == "" {
+		args = append(args, "-fa", "on")
+	}
+	env = map[string]string{}
+	note := fmt.Sprintf("SPLIT_MODE=tensor (expérimental) : -sm tensor sur %d cartes", len(devs))
+	if ts != "" {
+		note += ", -ts " + ts + " (VRAM totale)"
+	}
+	note += fmt.Sprintf(", ~%d Mio estimés sans --fit ; décodage plus rapide, prefill plus lent — compare le temps par tour", needMiB)
+	switch ar := strings.ToLower(strings.TrimSpace(si.UserEnv["GGML_CUDA_ALLREDUCE"])); ar {
+	case "":
+		env["GGML_CUDA_ALLREDUCE"] = "internal"
+		note += " ; GGML_CUDA_ALLREDUCE=internal : sommes dans le type natif (NCCL les compresserait en BF16, avec perte). " +
+			"« NCCL not compiled in » ou « NCCL is unavailable » au journal : sans effet ici. GeForce sans P2P : les " +
+			"sommes passent par l'hôte ; GGML_CUDA_P2P=1 à poser soi-même si le pilote le permet"
+	case "nccl":
+		note += " ; avertissement : GGML_CUDA_ALLREDUCE=nccl (environnement) — NCCL compresse en BF16 les grosses " +
+			"réductions du prefill : calcul avec perte. « NCCL not compiled in » au journal = repli sur la réduction interne"
+	default:
+		note += " ; GGML_CUDA_ALLREDUCE=" + ar + " (environnement) gardé"
+	}
+	if si.GGUF.Hybrid {
+		note += " ; modèle hybride : état récurrent et points de reprise répartis entre cartes, non validés en amont"
+	}
+	notes = append(notes, note)
+	return true, args, ngl, env, notes
+}

internal/loki/backend_serve_split_test.go

@@ -0,0 +1,214 @@
+package loki
+
+import (
+	"reflect"
+	"slices"
+	"strings"
+	"testing"
+)
+
+const helpTensor = helpRecent + `-sm,   --split-mode {none,layer,row,tensor}
+                                        how to split the model across multiple GPUs
+-ts,   --tensor-split N0,N1,N2,...      fraction of the model to offload to each GPU
+`
+
+// tensorReady : un hybride 64 couches de 16 Gio sur 16 + 12 Gio de VRAM, sur
+// un moteur qui propose -sm tensor. Le cas où SPLIT_MODE=tensor est accepté.
+func tensorReady() serveSysInfo {
+	return serveSysInfo{
+		Help:  helpTensor,
+		Model: "/models/Qwen3.6-27B.gguf",
+		GGUF: &GGUFInfo{Arch: "qwen35", BlockCount: 64, KeyLen: 256, ValLen: 256, HeadCountKV: 4,
+			Hybrid: true, FullAttnInterval: 4},
+		ModelBytes: 16 << 30,
+		ArgEnv:     map[string]string{},
+		UserEnv:    map[string]string{},
+		SplitDevs:  []splitDev{{ID: "CUDA0", TotalMiB: 16311}, {ID: "CUDA1", TotalMiB: 12288}},
+	}
+}
+
+func TestSplitTensorPlan(t *testing.T) {
+	tensor := map[string]string{"SPLIT_MODE": "tensor", "CTX": "65536"}
+	with := func(kv ...string) map[string]string {
+		m := map[string]string{}
+		for k, v := range tensor {
+			m[k] = v
+		}
+		for i := 0; i+1 < len(kv); i += 2 {
+			m[kv[i]] = kv[i+1]
+		}
+		return m
+	}
+	cases := []struct {
+		name  string
+		cfg   map[string]string
+		extra []string
+		si    func(*serveSysInfo)
+		on    bool
+		why   string // fragment attendu de la raison du refus
+	}{
+		{name: "clé absente : rien, en silence", cfg: map[string]string{}},
+		{name: "SPLIT_MODE=layer : le défaut, rien", cfg: map[string]string{"SPLIT_MODE": "layer"}},
+		{name: "accepté", cfg: tensor, on: true},
+		{name: "illisible", cfg: with("SPLIT_MODE", "rows"), why: "illisible"},
+		{name: "aide qui ne cite que --tensor-split : refusé",
+			cfg: tensor, why: "-sm tensor", si: func(s *serveSysInfo) { s.Help = helpRecent + "-ts, --tensor-split N0,N1\n" }},
+		{name: "preset externe", cfg: with(extKeyFlag, "1"), why: "externe"},
+		{name: "-sm dans EXTRA_ARGS : l'utilisateur garde la main", cfg: tensor, extra: []string{"-sm", "layer"}, why: "-sm layer"},
+		{name: "LLAMA_ARG_SPLIT_MODE", cfg: tensor, why: "LLAMA_ARG_SPLIT_MODE",
+			si: func(s *serveSysInfo) { s.ArgEnv["LLAMA_ARG_SPLIT_MODE"] = "row" }},
+		{name: "-fa off : refusé", cfg: tensor, extra: []string{"-fa", "off"}, why: "Flash Attention"},
+		{name: "-fa on : accepté", cfg: tensor, extra: []string{"-fa", "on"}, on: true},
+		{name: "--backend-sampling : refusé", cfg: tensor, extra: []string{"--backend-sampling"}, why: "backend-sampling"},
+		{name: "LLAMA_ARG_BACKEND_SAMPLING : refusé", cfg: tensor, why: "backend-sampling",
+			si: func(s *serveSysInfo) { s.ArgEnv["LLAMA_ARG_BACKEND_SAMPLING"] = "1" }},
+		{name: "KV_TYPE=q8_0 : refusé, jamais réécrit", cfg: with("KV_TYPE", "q8_0"), why: "q8_0"},
+		{name: "-ctk q8_0 dans EXTRA_ARGS (preset MoE) : refusé", cfg: tensor,
+			extra: []string{"--cache-type-k", "q8_0", "--cache-type-v", "q8_0"}, why: "q8_0"},
+		{name: "KV_TYPE_V=q4_0 : refusé", cfg: with("KV_TYPE_V", "q4_0"), why: "q4_0"},
+		{name: "KV bf16 : accepté", cfg: with("KV_TYPE", "bf16"), on: true},
+		{name: "--n-cpu-moe : refusé", cfg: tensor, extra: []string{"--n-cpu-moe", "40"}, why: "n-cpu-moe"},
+		{name: "-ot : refusé", cfg: tensor, extra: []string{"-ot", "exps=CPU"}, why: "surcharge"},
+		{name: "cache KV sur CPU : refusé", cfg: tensor, extra: []string{"-nkvo"}, why: "KV sur CPU"},
+		{name: "NGL=40 : refusé", cfg: with("NGL", "40"), why: "NGL=40"},
+		{name: "NGL=999 : accepté", cfg: with("NGL", "999"), on: true},
+		{name: "-ngl 99 dans EXTRA_ARGS (≥ toutes les couches) : accepté", cfg: tensor, extra: []string{"-ngl", "99"}, on: true},
+		{name: "-ngl 30 dans EXTRA_ARGS : refusé", cfg: tensor, extra: []string{"-ngl", "30"}, why: "-ngl 30"},
+		{name: "CTX=0 : refusé", cfg: with("CTX", "0"), why: "non chiffré"},
+		{name: "VRAM insuffisante : refusé, CTX jamais réduit", cfg: with("CTX", "262144"), why: "VRAM insuffisante"},
+		{name: "qwen4exp : refusé", cfg: tensor, why: "qwen4exp", si: func(s *serveSysInfo) { s.GGUF.Arch = "qwen4exp" }},
+		{name: "mamba (refusé par llama.cpp) : refusé proprement", cfg: tensor, why: "mamba",
+			si: func(s *serveSysInfo) { s.GGUF.Arch = "mamba" }},
+		{name: "GGUF illisible", cfg: tensor, why: "illisibles", si: func(s *serveSysInfo) { s.GGUF = nil }},
+		{name: "SPEC=mtp : refusé", cfg: with("SPEC", "mtp"), why: "spéculatif"},
+		{name: "SIDE_SLOT=on : refusé", cfg: with("SIDE_SLOT", "on"), why: "SIDE_SLOT"},
+		{name: "une seule carte", cfg: tensor, why: "une seule carte",
+			si: func(s *serveSysInfo) { s.SplitDevs = s.SplitDevs[:1] }},
+		{name: "cartes inconnues", cfg: tensor, why: "inconnues", si: func(s *serveSysInfo) { s.SplitDevs = nil }},
+		{name: "moteur Vulkan : refusé", cfg: tensor, why: "CUDA",
+			si: func(s *serveSysInfo) { s.SplitDevs = []splitDev{{"Vulkan0", 16311}, {"Vulkan1", 12288}} }},
+		{name: "--device d'une seule carte : refusé", cfg: tensor, extra: []string{"--device", "CUDA0"}, why: "une seule carte"},
+		{name: "--device inconnu : refusé", cfg: tensor, extra: []string{"-dev", "CUDA0,CUDA7"}, why: "CUDA7"},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			si := tensorReady()
+			if c.si != nil {
+				c.si(&si)
+			}
+			on, why, _, _ := splitPlan(c.cfg, c.extra, si)
+			if on != c.on {
+				t.Fatalf("on = %v, attendu %v (%q)", on, c.on, why)
+			}
+			if !strings.Contains(why, c.why) || (c.why == "" && why != "") {
+				t.Errorf("raison %q, attendu %q", why, c.why)
+			}
+		})
+	}
+}
+
+func TestSplitTensorArgs(t *testing.T) {
+	const bin = "/opt/llama/llama-server"
+	cfg := map[string]string{"SPLIT_MODE": "tensor", "CTX": "65536", "NGL": "999"}
+
+	// Clé absente : la ligne et l'environnement d'avant, à l'octet près, même
+	// sur un moteur et une machine où le mode tensor serait possible.
+	plain := map[string]string{"CTX": "65536", "NGL": "999"}
+	got, env, _ := buildServeArgs(plain, nil, bin, tensorReady())
+	si := tensorReady()
+	si.Help, si.SplitDevs = helpRecent, nil
+	want, wantEnv, _ := buildServeArgs(plain, nil, bin, si)
+	if !reflect.DeepEqual(got, want) || !reflect.DeepEqual(env, wantEnv) {
+		t.Fatalf("sans SPLIT_MODE : %q %v, attendu %q %v", got, env, want, wantEnv)
+	}
+
+	got, env, notes := buildServeArgs(cfg, nil, bin, tensorReady())
+	tail := []string{"-ngl", "all", "-sm", "tensor", "-ts", "57,43", "-fa", "on"}
+	if i := slices.Index(got, "-ngl"); i < 0 || !reflect.DeepEqual(got[i:i+len(tail)], tail) {
+		t.Fatalf("args = %q, attendu …%q…", got, tail)
+	}
+	if env["GGML_CUDA_ALLREDUCE"] != "internal" {
+		t.Errorf("GGML_CUDA_ALLREDUCE = %q, attendu internal (NCCL compresse en BF16)", env["GGML_CUDA_ALLREDUCE"])
+	}
+	if len(notes) == 0 || !strings.Contains(strings.Join(notes, "\n"), "NCCL") {
+		t.Errorf("la note doit parler de NCCL : %q", notes)
+	}
+
+	// Les choix de l'utilisateur gagnent et ne sont jamais doublés.
+	extra := []string{"-ts", "60,40", "-fa", "on", "-ngl", "all"}
+	got, _, _ = buildServeArgs(cfg, extra, bin, tensorReady())
+	for _, f := range []string{"-ts", "-fa", "-ngl", "-sm"} {
+		if n := countFlag(got, f); n != 1 {
+			t.Errorf("%s présent %d fois : %q", f, n, got)
+		}
+	}
+
+	// --device dans l'ordre inverse : la répartition suit.
+	got, _, _ = buildServeArgs(cfg, []string{"--device", "CUDA1,CUDA0"}, bin, tensorReady())
+	if argValue(got, "-ts") != "43,57" {
+		t.Errorf("-ts = %q, attendu 43,57", argValue(got, "-ts"))
+	}
+
+	// GGML_CUDA_ALLREDUCE déjà posé : gardé, et NCCL signalé comme avec perte.
+	si = tensorReady()
+	si.UserEnv["GGML_CUDA_ALLREDUCE"] = "nccl"
+	_, env, notes = buildServeArgs(cfg, nil, bin, si)
+	if _, set := env["GGML_CUDA_ALLREDUCE"]; set {
+		t.Errorf("choix de l'utilisateur écrasé : %v", env)
+	}
+	if !strings.Contains(strings.Join(notes, "\n"), "BF16") {
+		t.Errorf("NCCL doit être signalé : %q", notes)
+	}
+
+	// Les réglages qui lisent le placement voient le mode tensor : pas de
+	// graphes Q/K/V en parallèle, pas de --fit-target, pas de file CUDA.
+	withOpts := map[string]string{"CUDA_GRAPH_OPT": "on", "FIT_TARGET": "1024"}
+	for k, v := range cfg {
+		withOpts[k] = v
+	}
+	got, env, _ = buildServeArgs(withOpts, nil, bin, tensorReady())
+	if env["GGML_CUDA_GRAPH_OPT"] != "" || slices.Contains(got, "--fit-target") {
+		t.Errorf("mode tensor : ni GGML_CUDA_GRAPH_OPT ni --fit-target, %q %v", got, env)
+	}
+
+	// Moteur sans -sm tensor : aucun compagnon (-ngl all, -ts, -fa), une note.
+	si = tensorReady()
+	si.Help = helpRecent
+	got, env, notes = buildServeArgs(cfg, nil, bin, si)
+	if slices.Contains(got, "-sm") || slices.Contains(got, "-ts") || slices.Contains(got, "-fa") ||
+		argValue(got, "-ngl") != "auto" || env["GGML_CUDA_ALLREDUCE"] != "" {
+		t.Errorf("refusé : ligne d'avant attendue, %q %v", got, env)
+	}
+	if !strings.Contains(strings.Join(notes, "\n"), "SPLIT_MODE=tensor refusé") {
+		t.Errorf("le refus doit se dire : %q", notes)
+	}
+}
+
+func countFlag(args []string, f string) int {
+	n := 0
+	for _, a := range args {
+		if a == f {
+			n++
+		}
+	}
+	return n
+}
+
+func TestSplitTensorSlotPersist(t *testing.T) {
+	si := tensorReady()
+	si.Help += "--slot-save-path PATH\n"
+	si.SlotDir = "/data/slots"
+	cfg := map[string]string{"SLOT_PERSIST": "on", "HOST": "127.0.0.1", "SPLIT_MODE": "tensor"}
+	if ok, why := slotPersistPlan(cfg, nil, si); ok || !strings.Contains(why, "SPLIT_MODE") {
+		t.Errorf("SLOT_PERSIST avec SPLIT_MODE : refusé attendu, got %v %q", ok, why)
+	}
+}
+
+func TestHelpSupportsSplitTensor(t *testing.T) {
+	if helpSupportsSplitTensor(helpRecent + "-ts, --tensor-split N0,N1  fraction\n--override-tensor\n") {
+		t.Error("« tensor » ailleurs dans l'aide ne suffit pas")
+	}
+	if !helpSupportsSplitTensor(helpTensor) {
+		t.Error("liste littérale de -sm : oui")
+	}
+}

internal/loki/backend_strata_test.go

@@ -0,0 +1,364 @@
+package loki
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func strataArgs(t *testing.T, cfg map[string]any) []string {
+	t.Helper()
+	var out []string
+	for _, a := range cfg["args"].([]any) {
+		out = append(out, a.(string))
+	}
+	return out
+}
+
+func argAfter(args []string, flag string) string {
+	for i := 0; i+1 < len(args); i++ {
+		if args[i] == flag {
+			return args[i+1]
+		}
+	}
+	return ""
+}
+
+func TestStrataBuildConfigApplyTuning(t *testing.T) {
+	base := map[string]any{
+		"exe":  "/x/engine-cuda12/strata",
+		"args": []any{"--pack", "/p", "--prefill", "8192", "--max-context", "131072"},
+		"port": 8080.0,
+	}
+	out, err := strataBuildConfig(base, map[string]string{"PORT": "8081", "CTX": "65536"}, "k", "ram")
+	if err != nil {
+		t.Fatal(err)
+	}
+	a := strataArgs(t, out)
+	for flag, want := range map[string]string{"--prefill": "16384", "--short-read": "150", "--prompt-cache-root": "256", "--max-context": "65536", "--pack": "/p"} {
+		if got := argAfter(a, flag); got != want {
+			t.Errorf("%s = %q, attendu %q (args %v)", flag, got, want, a)
+		}
+	}
+	if strings.Count(strings.Join(a, " "), "--prefill") != 1 {
+		t.Errorf("--prefill dupliqué : %v", a)
+	}
+	if strataHasArg(a, "--remote-expert-opt") || strataHasArg(a, "--expert-cache-device1") {
+		t.Errorf("aide 2e carte sans 2e carte : %v", a)
+	}
+	if out["port"] != 8081 || out["api_key"] != "k" || out["host"] != "127.0.0.1" {
+		t.Errorf("port/clé/hôte : %v %v %v", out["port"], out["api_key"], out["host"])
+	}
+	// la config de l'installeur n'est pas modifiée
+	if base["args"].([]any)[3] != "8192" {
+		t.Error("la config de base a été modifiée")
+	}
+}
+
+func TestStrataBuildConfigHelperGPU(t *testing.T) {
+	base := map[string]any{"args": []any{"--pack", "/p", "--mmap-experts", "--vram-reserve-mib", "700"}, "gpu": 1.0,
+		"vision": map[string]any{"exe": "v", "gpu": true}}
+	out, err := strataBuildConfig(base, map[string]string{"STRATA_HELPER_GPU": "0"}, "", "ram")
+	if err != nil {
+		t.Fatal(err)
+	}
+	a := strataArgs(t, out)
+	if argAfter(a, "--expert-cache-device1") != "auto" || !strataHasArg(a, "--remote-expert-opt") {
+		t.Errorf("aide 2e carte absente : %v", a)
+	}
+	if strataHasArg(a, "--vram-reserve-mib") || strataHasArg(a, "700") {
+		t.Errorf("réserve de VRAM gardée : %v", a)
+	}
+	if _, has := out["api_key"]; has {
+		t.Error("api_key posée sans clé")
+	}
+	if _, has := out["gpu"]; has {
+		t.Error("clé gpu gardée avec une carte d'aide (le serveur en ferait un --layer-split)")
+	}
+	if out["vision"].(map[string]any)["cuda_device"] != 0 {
+		t.Errorf("encodeur pas sur la carte d'aide : %v", out["vision"])
+	}
+	if out["env"].(map[string]any)["STRATA_PLE_BATCH"] != "0" {
+		t.Errorf("STRATA_PLE_BATCH absent : %v", out["env"])
+	}
+}
+
+func TestStrataCudaDevices(t *testing.T) {
+	cases := []struct {
+		main, helper, want string
+	}{
+		{"1", "0", "1,0"},
+		{"0", "-1", "0"},
+		{"0", "", "0"},
+		{"", "", ""},
+	}
+	for _, c := range cases {
+		got := strataCudaDevices(map[string]string{"STRATA_MAIN_GPU": c.main, "STRATA_HELPER_GPU": c.helper})
+		if got != c.want {
+			t.Errorf("main=%q helper=%q : %q, attendu %q", c.main, c.helper, got, c.want)
+		}
+	}
+}
+
+func TestStrataRecommend(t *testing.T) {
+	// la machine de test : 5060 Ti 16 Go + 3070 8 Go, 47 Go de RAM, disque large
+	env := strataEnv{Supported: true, Main: 1, Helper: 0, RAMGB: 47, AvailGB: 47, DiskFreeGB: 400,
+		GPUs: []strataGPU{{Index: 0, VRAMGB: 8, Arch: 86}, {Index: 1, VRAMGB: 16, Arch: 120}}}
+	if got := strataRecommend("swift", env); got != "IQ3_XXS" {
+		t.Errorf("swift : %q, attendu IQ3_XXS", got)
+	}
+	// IQ3_S demande de garder 50 Go d'experts en RAM : pas sur 47 Go
+	if got := strataRecommend("qwen", env); got != "IQ3_XXS" {
+		t.Errorf("qwen 47 Go : %q, attendu IQ3_XXS", got)
+	}
+	f := strataFitFor(strataQuants["IQ3_XXS"], env, 0)
+	// trop juste pour tout garder en RAM : experts lus depuis le disque (le mode
+	// hors RAM demande un experts.bin, qu'une installation neuve n'a pas)
+	if !f.OK || !f.Mmap || f.Drop {
+		t.Errorf("IQ3_XXS sur 47 Go : ok=%v mmap=%v drop=%v (attendu ok, disque)", f.OK, f.Mmap, f.Drop)
+	}
+	// 64 Go : IQ3_S tient en RAM
+	env.RAMGB, env.AvailGB = 64, 64
+	if got := strataRecommend("qwen", env); got != "IQ3_S" {
+		t.Errorf("qwen 64 Go : %q, attendu IQ3_S", got)
+	}
+	// 16 Go de RAM et une seule carte de 8 Go : rien ne tient
+	small := strataEnv{Supported: true, Main: 0, Helper: -1, RAMGB: 16, DiskFreeGB: 400,
+		GPUs: []strataGPU{{Index: 0, VRAMGB: 8, Arch: 86}}}
+	if got := strataRecommend("swift", small); got != "" {
+		t.Errorf("petite machine : %q, attendu aucune recommandation", got)
+	}
+	// disque trop petit
+	env.DiskFreeGB = 50
+	if f := strataFitFor(strataQuants["Q2_0"], env, 0); f.OK {
+		t.Error("Q2_0 accepté avec 50 Go de disque")
+	}
+}
+
+func TestStrataPresetName(t *testing.T) {
+	if got := strataPresetName("swift", "IQ3_XXS"); got != "STRATA FLASH NEXT SWIFT 1.5 IQ3_XXS" {
+		t.Errorf("%q", got)
+	}
+	if got := strataPresetName("qwen", "Q2_0"); got != "STRATA FLASH NEXT CLASSIQUE Q2_0" {
+		t.Errorf("%q", got)
+	}
+}
+
+func TestStrataFitCountsExistingData(t *testing.T) {
+	env := strataEnv{Supported: true, Main: 1, Helper: 0, RAMGB: 47, DiskFreeGB: 32,
+		GPUs: []strataGPU{{Index: 0, VRAMGB: 8, Arch: 86}, {Index: 1, VRAMGB: 16, Arch: 120}}}
+	if f := strataFitFor(strataQuants["IQ3_XXS"], env, 120); !f.OK {
+		t.Errorf("données déjà présentes, refusé quand même : %s", f.Why)
+	}
+	if f := strataFitFor(strataQuants["IQ3_XXS"], env, 0); f.OK {
+		t.Error("32 Go libres sans données : accepté")
+	}
+}
+
+func TestStrataBuildConfigPresetOverrides(t *testing.T) {
+	base := map[string]any{"args": []any{"--kv", "int8", "--spec", "4"}}
+	out, _ := strataBuildConfig(base, map[string]string{"STRATA_KV": "fp16", "STRATA_SPEC": "3"}, "", "ram")
+	a := strataArgs(t, out)
+	if argAfter(a, "--kv") != "fp16" || argAfter(a, "--spec") != "3" {
+		t.Errorf("%v", a)
+	}
+}
+
+func TestStrataDetailsFor(t *testing.T) {
+	home := t.TempDir()
+	t.Setenv("LOKI_HOME", home)
+	base := filepath.Join(home, "base.json")
+	if err := os.WriteFile(base, []byte(`{"args":["--pack","/p","--kv","int8","--spec","4","--max-context","131072"],"vision":{"exe":"v"}}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	_ = os.MkdirAll(presetsDir(), 0o755)
+	preset := "ENGINE=strata\nSTRATA_CONFIG=" + base + "\nSTRATA_MAIN_GPU=1\nSTRATA_HELPER_GPU=0\nSTRATA_MMAP=1\nSTRATA_KV=fp16\nSTRATA_KV_RESIDENT=32768\nSTRATA_SPEC=3\n"
+	if err := os.WriteFile(filepath.Join(presetsDir(), "X.env"), []byte(preset), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	env := strataEnv{GPUs: []strataGPU{{Index: 0, Name: "NVIDIA GeForce RTX 3070", VRAMGB: 8}, {Index: 1, Name: "NVIDIA GeForce RTX 5060 Ti", VRAMGB: 16}}}
+	d := strataDetailsFor("X", env)
+	if d == nil {
+		t.Fatal("pas de détails")
+	}
+	if d.KV != "fp16" || d.KVResident != "32768" || d.Spec != "3" || d.Ctx != "131072" || !d.Mmap ||
+		d.MainGPU != "RTX 5060 Ti (16 Go)" || d.HelperGPU != "RTX 3070 (8 Go)" || d.VisionGPU != "RTX 3070 (8 Go)" ||
+		d.ShortRead != "150" || d.CacheRoot != "256" || d.Prefill != "16384" {
+		t.Errorf("%+v", *d)
+	}
+}
+
+func TestStrataHaveGBPerChoice(t *testing.T) {
+	t.Setenv("LOKI_HOME", t.TempDir())
+	write := func(rel string, n int) {
+		p := filepath.Join(strataDataDir(), rel)
+		_ = os.MkdirAll(filepath.Dir(p), 0o755)
+		if err := os.WriteFile(p, make([]byte, n), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	write("models/swift-IQ3_XXS/a.gguf", 3000)
+	write("packs/swift-iq3_xxs/experts.bin", 2000)
+	write("mtp/rt/x", 500)
+	write("models/IQ2_XS/b.gguf", 7000) // un autre choix : ne compte pas pour swift IQ3_XXS
+	if got := strataHaveGB("swift", "IQ3_XXS") * 1e9; got != 5500 {
+		t.Errorf("swift IQ3_XXS : %v octets, attendu 5500", got)
+	}
+	if got := strataHaveGB("swift", "IQ2_XS") * 1e9; got != 500 {
+		t.Errorf("swift IQ2_XS : %v octets, attendu 500 (seulement la tête MTP commune)", got)
+	}
+}
+
+func TestStrataApplySettings(t *testing.T) {
+	in := "# NAME=x\nENGINE=strata\nCTX=131072\nSTRATA_KV=fp16\nSTRATA_SPEC=3\nSTRATA_HELPER_GPU=0\n"
+	out, err := strataApplySettings(in, strataSettingsReq{Ctx: 65536, KV: "int8", Spec: 4, Vision: false, Helper: false})
+	if err != nil {
+		t.Fatal(err)
+	}
+	cfg := parseEnv(out)
+	if cfg["CTX"] != "65536" || cfg["STRATA_KV"] != "int8" || cfg["STRATA_SPEC"] != "4" || cfg["STRATA_VISION"] != "0" ||
+		cfg["STRATA_HELPER"] != "0" || cfg["STRATA_HELPER_GPU"] != "0" || cfg["ENGINE"] != "strata" {
+		t.Errorf("%q", out)
+	}
+	if strings.Count(out, "CTX=") != 1 {
+		t.Errorf("CTX dupliqué : %q", out)
+	}
+	if strataHelperOn(cfg) || strataCudaDevices(map[string]string{"STRATA_MAIN_GPU": "1", "STRATA_HELPER_GPU": "0", "STRATA_HELPER": "0"}) != "1" {
+		t.Error("carte d'aide coupée mais encore utilisée")
+	}
+	base := map[string]any{"args": []any{"--vision", "--pack", "/p"}, "vision": map[string]any{"exe": "v"}}
+	b, _ := strataBuildConfig(base, cfg, "", "ram")
+	if strataHasArg(strataArgs(t, b), "--vision") || b["vision"] != nil || strataHasArg(strataArgs(t, b), "--expert-cache-device1") {
+		t.Errorf("vision / aide coupées mais présentes : %v", b)
+	}
+	for _, bad := range []strataSettingsReq{{Ctx: 1000, KV: "fp16", Spec: 3}, {Ctx: 32768, KV: "q2", Spec: 3}, {Ctx: 32768, KV: "fp16", Spec: 9}} {
+		if _, err := strataApplySettings(in, bad); err == nil {
+			t.Errorf("accepté : %+v", bad)
+		}
+	}
+}
+
+func TestEngineOf(t *testing.T) {
+	cases := map[string]string{"": engineLlamacpp, "llamacpp": engineLlamacpp, "strata": engineStrata, " Strata ": engineStrata, "moe": engineStrata, "autre": engineLlamacpp}
+	for in, want := range cases {
+		if got := engineOf(map[string]string{"ENGINE": in}); got != want {
+			t.Errorf("ENGINE=%q : %q, attendu %q", in, got, want)
+		}
+	}
+}
+
+func TestModelLoadErrorStrata(t *testing.T) {
+	ok := strataServeMarker + " (paquet AJEAN MoE 1.0)\nloading the model (the first start takes a minute or two) ...\nready: http://127.0.0.1:8080/v1  (OpenAI: /v1/chat/completions)\n"
+	if got := modelLoadErrorFrom(ok); got != "" {
+		t.Errorf("Strata prêt signalé en échec : %q", got)
+	}
+	crash := strataServeMarker + "\nTraceback (most recent call last):\n  File \"server.py\", line 1\nRuntimeError: boom\n"
+	if got := modelLoadErrorFrom(crash); !strings.Contains(got, "Strata") {
+		t.Errorf("trace Python non signalée : %q", got)
+	}
+	// une trace d'un lancement PRÉCÉDENT ne compte pas
+	if got := modelLoadErrorFrom(crash + strataServeMarker + "\nloading the model ...\n"); got != "" {
+		t.Errorf("ancienne trace prise pour l'échec en cours : %q", got)
+	}
+}
+
+// Où vont les experts : décidé sur la RAM DISPONIBLE. Vécu : 62 Go dont 18 pris
+// ailleurs, mode « hors RAM » choisi sur la RAM totale, moteur tué par le noyau.
+func TestStrataResolveExperts(t *testing.T) {
+	home := t.TempDir()
+	t.Setenv("LOKI_HOME", home)
+	pack := filepath.Join(home, "pack")
+	_ = os.MkdirAll(pack, 0o755)
+	args := []string{"--pack", pack}
+	cfg := map[string]string{"STRATA_CONFIG": "/x/strata-swift-iq3_xxs.json", "STRATA_HELPER_GPU": "1", "STRATA_DROP": "1"}
+	// IQ3_XXS : 42,9 Go d'experts
+	cases := []struct {
+		experts string
+		avail   float64
+		want    string
+	}{
+		{"", 44, "disk"}, // le cas vécu : 44 Go disponibles, pas de experts.bin
+		{"", 60, "ram"},  // assez de RAM pour tout charger avec la marge
+		{"auto", 52.8, "disk"},
+		{"disk", 60, "disk"}, // choix de l'utilisateur
+		{"ram", 20, "ram"},   // choix de l'utilisateur, même à l'étroit
+	}
+	for _, c := range cases {
+		cfg["STRATA_EXPERTS"] = c.experts
+		if got := strataResolveExperts(cfg, args, c.avail, 12); got != c.want {
+			t.Errorf("experts=%q dispo=%.0f : %s, attendu %s", c.experts, c.avail, got, c.want)
+		}
+	}
+	// experts.bin présent (moteur du paquet) : le mode hors RAM et le mappage deviennent possibles
+	_ = os.WriteFile(filepath.Join(pack, "experts.bin"), []byte("x"), 0o644)
+	_ = os.MkdirAll(filepath.Join(strataSrcDir(), "engine-cuda12"), 0o755)
+	_ = os.WriteFile(strataEngineMarker(), []byte(strataEngineAsset+"\n"), 0o644)
+	cfg["STRATA_EXPERTS"] = ""
+	if got := strataResolveExperts(cfg, args, 44, 12); got != "drop" {
+		t.Errorf("44 Go + carte d'appoint 12 Go + experts.bin : %s, attendu drop", got)
+	}
+	if got := strataResolveExperts(cfg, args, 30, 12); got != "arena" {
+		t.Errorf("30 Go + experts.bin : %s, attendu arena", got)
+	}
+	cfg["STRATA_HELPER"] = "0"
+	if got := strataResolveExperts(cfg, args, 44, 12); got != "arena" {
+		t.Errorf("carte d'appoint coupée : %s, attendu arena", got)
+	}
+	cfg["STRATA_EXPERTS"] = "disk"
+	if got := strataResolveExperts(cfg, args, 60, 12); got != "arena" {
+		t.Errorf("disque demandé avec experts.bin : %s, attendu arena", got)
+	}
+	// quant inconnu : on ne parie pas sur la RAM
+	if got := strataResolveExperts(map[string]string{"STRATA_CONFIG": "/x/autre.json"}, nil, 500, 0); got != "disk" {
+		t.Errorf("quant inconnu : %s, attendu disk", got)
+	}
+}
+
+func TestStrataBuildConfigModes(t *testing.T) {
+	base := map[string]any{"args": []any{"--pack", "/p", "--resident-experts", "--pcie-frac", "0.3"}, "env": map[string]any{"X": "1"}}
+	cfg := map[string]string{"STRATA_HELPER_GPU": "1"}
+	env := func(m map[string]any) map[string]any { return m["env"].(map[string]any) }
+
+	out, _ := strataBuildConfig(base, cfg, "", "disk")
+	a := strataArgs(t, out)
+	if !strataHasArg(a, "--mmap-experts") || strataHasArg(a, "--resident-experts") || argAfter(a, "--pcie-frac") != "0" ||
+		env(out)["STRATA_ARENA_MMAP"] != nil || env(out)["X"] != "1" {
+		t.Errorf("disk : %v %v", a, env(out))
+	}
+	out, _ = strataBuildConfig(base, cfg, "", "ram")
+	a = strataArgs(t, out)
+	if strataHasArg(a, "--mmap-experts") || strataHasArg(a, "--resident-experts") || env(out)["STRATA_ARENA_MMAP"] != nil || env(out)["STRATA_REMOTE_DROP"] != nil {
+		t.Errorf("ram : %v %v", a, env(out))
+	}
+	out, _ = strataBuildConfig(base, cfg, "", "arena")
+	if a = strataArgs(t, out); argAfter(a, "--pcie-frac") != "0" || env(out)["STRATA_ARENA_MMAP"] != "1" {
+		t.Errorf("arena : %v %v", a, env(out))
+	}
+	out, _ = strataBuildConfig(base, cfg, "", "drop")
+	if a = strataArgs(t, out); strataHasArg(a, "--pcie-frac") || env(out)["STRATA_REMOTE_DROP"] != "1" {
+		t.Errorf("drop : la part PCIe doit être automatique : %v %v", a, env(out))
+	}
+	// drop sans carte d'appoint : rien de spécial, c'est le mode ram
+	out, _ = strataBuildConfig(base, map[string]string{"STRATA_HELPER_GPU": "-1"}, "", "drop")
+	if env(out)["STRATA_REMOTE_DROP"] != nil {
+		t.Error("mode hors RAM sans carte d'appoint")
+	}
+}
+
+func TestStrataApplySettingsExperts(t *testing.T) {
+	in := "ENGINE=strata\nSTRATA_EXPERTS=auto\n"
+	r := strataSettingsReq{Ctx: 131072, KV: "fp16", Spec: 3, Experts: "disk"}
+	out, err := strataApplySettings(in, r)
+	if err != nil || parseEnv(out)["STRATA_EXPERTS"] != "disk" {
+		t.Fatalf("%v %q", err, out)
+	}
+	r.Experts = "nvme"
+	if _, err := strataApplySettings(in, r); err == nil {
+		t.Error("placement inconnu accepté")
+	}
+	r.Experts = ""
+	if out, _ := strataApplySettings(in, r); parseEnv(out)["STRATA_EXPERTS"] != "auto" {
+		t.Errorf("vide doit laisser le choix en place : %q", out)
+	}
+}

internal/loki/backend_tune_job.go

@@ -0,0 +1,392 @@
+package loki
+
+import (
+	"bufio"
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"net/http"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+)
+
+// L'optimiseur côté web et en ligne de commande.
+//
+//	POST /api/tune          lance (202), 409 si le moteur est occupé
+//	GET  /api/tune/status   phase, essais, ETA ; puis le résultat
+//	POST /api/tune/cancel   annule (l'essai en cours est arrêté, le moteur relancé)
+//	POST /api/tune/apply    {target:"copy"|"preset"} — SEULEMENT sur un clic
+//	GET  /api/tune/last     dernier résultat d'un preset, et si le moteur a changé depuis
+//
+// Rien ne tourne de soi-même : ni au démarrage, ni après une mise à jour du
+// moteur (l'interface PROPOSE alors de relancer).
+
+// tuneJob : l'optimisation en cours ou la dernière (une seule à la fois).
+var tuneJob struct {
+	mu       sync.Mutex
+	running  bool
+	tracker  *tuneTracker
+	cancel   context.CancelFunc
+	result   *tuneResult
+	err      string
+	finished time.Time
+	// application en cours (preset réécrit, redémarrage, sonde)
+	applying bool
+	applyLog []string
+	applyMsg string
+	applyErr string
+}
+
+// tuneRunner est runTune, remplaçable dans les tests.
+var tuneRunner = runTune
+
+func tuneStart(opts tuneOpts) (int, error) {
+	if err := tunePreflight(context.Background(), true); err != nil {
+		code := http.StatusConflict
+		if externalActive() {
+			code = http.StatusBadRequest
+		}
+		return code, err
+	}
+	tuneJob.mu.Lock()
+	defer tuneJob.mu.Unlock()
+	if tuneJob.running || tuneJob.applying {
+		return http.StatusConflict, errTuneBusy
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	// Le verrou de la discussion : un message, une tâche, une compaction
+	// reçoivent « optimisation en cours » au lieu d'attendre un moteur absent.
+	// Le bouton stop du chat annule l'optimisation, comme un bench.
+	release, err := conv.measureLease(cancel, errTuneBusy)
+	if err != nil {
+		cancel()
+		return http.StatusConflict, conv.busyReason()
+	}
+	tr := &tuneTracker{}
+	tuneJob.running, tuneJob.tracker, tuneJob.cancel = true, tr, cancel
+	tuneJob.result, tuneJob.err = nil, ""
+	tuneJob.applyLog, tuneJob.applyMsg, tuneJob.applyErr = nil, "", ""
+	opts.Via = "web"
+	go func() {
+		defer cancel()
+		res, err := tuneRunner(ctx, opts, tr)
+		tr.mu.Lock()
+		tr.ended = time.Now()
+		tr.mu.Unlock()
+		release()
+		tuneJob.mu.Lock()
+		defer tuneJob.mu.Unlock()
+		tuneJob.running, tuneJob.cancel, tuneJob.finished = false, nil, time.Now()
+		tuneJob.result = res
+		if err != nil {
+			tuneJob.err = err.Error()
+			if ctx.Err() != nil {
+				tuneJob.err = "optimisation annulée"
+			}
+		}
+	}()
+	return http.StatusAccepted, nil
+}
+
+func tuneStatus() map[string]any {
+	tuneJob.mu.Lock()
+	defer tuneJob.mu.Unlock()
+	st := map[string]any{"ok": true, "running": tuneJob.running, "applying": tuneJob.applying}
+	if tuneJob.tracker != nil {
+		for k, v := range tuneJob.tracker.snapshot() {
+			st[k] = v
+		}
+	}
+	if !tuneJob.running {
+		if tuneJob.result != nil {
+			st["result"] = tuneJob.result
+		}
+		if tuneJob.err != "" {
+			st["error"] = tuneJob.err
+		}
+	}
+	if len(tuneJob.applyLog) > 0 || tuneJob.applyMsg != "" || tuneJob.applyErr != "" {
+		st["apply"] = map[string]any{"log": tuneJob.applyLog, "message": tuneJob.applyMsg, "error": tuneJob.applyErr}
+	}
+	// Une optimisation lancée ailleurs (« loki tune » en ligne de commande).
+	if o, busy := tuneActive(); busy && !tuneJob.running && !tuneJob.applying {
+		st["elsewhere"] = o.Via
+	}
+	return st
+}
+
+func handleTune(w http.ResponseWriter, r *http.Request) {
+	if !postOnly(w, r) {
+		return
+	}
+	var body struct {
+		Placement bool     `json:"placement"`
+		OptIn     bool     `json:"optin"`
+		BudgetMin int      `json:"budget_min"`
+		Stages    []string `json:"stages"`
+	}
+	_ = json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<16)).Decode(&body)
+	opts := tuneOpts{Placement: body.Placement, OptIn: body.OptIn, Stages: body.Stages}
+	if body.BudgetMin > 0 {
+		opts.Budget = time.Duration(body.BudgetMin) * time.Minute
+	}
+	code, err := tuneStart(opts)
+	if err != nil {
+		sendJSON(w, code, map[string]any{"ok": false, "error": err.Error()})
+		return
+	}
+	sendJSON(w, code, map[string]any{"ok": true})
+}
+
+func handleTuneStatus(w http.ResponseWriter, r *http.Request) { sendJSON(w, 200, tuneStatus()) }
+
+func handleTuneCancel(w http.ResponseWriter, r *http.Request) {
+	if !postOnly(w, r) {
+		return
+	}
+	tuneJob.mu.Lock()
+	ok := tuneJob.running && tuneJob.cancel != nil
+	if ok {
+		tuneJob.cancel()
+	}
+	tuneJob.mu.Unlock()
+	sendJSON(w, 200, map[string]any{"ok": ok})
+}
+
+// handleTuneApply écrit le dernier résultat, sur le clic de l'utilisateur
+// (l'interface a montré le diff et demandé confirmation). Copie : immédiat.
+// Preset : en arrière-plan (redémarrage, sonde, retour arrière si besoin).
+func handleTuneApply(w http.ResponseWriter, r *http.Request) {
+	if !postOnly(w, r) {
+		return
+	}
+	var body struct {
+		Target string `json:"target"`
+	}
+	_ = json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<16)).Decode(&body)
+	tuneJob.mu.Lock()
+	res := tuneJob.result
+	busy := tuneJob.running || tuneJob.applying
+	tuneJob.mu.Unlock()
+	if busy {
+		sendJSON(w, 409, map[string]any{"ok": false, "error": errTuneBusy.Error()})
+		return
+	}
+	if res == nil {
+		sendJSON(w, 400, map[string]any{"ok": false, "error": "aucun résultat à appliquer"})
+		return
+	}
+	if body.Target == tuneApplyCopy {
+		msg, err := tuneApply(context.Background(), res, tuneApplyCopy, func(string) {})
+		if err != nil {
+			sendJSON(w, 200, map[string]any{"ok": false, "error": err.Error()})
+			return
+		}
+		sendJSON(w, 200, map[string]any{"ok": true, "message": msg})
+		return
+	}
+	if body.Target != tuneApplyPreset {
+		sendJSON(w, 400, map[string]any{"ok": false, "error": "cible inconnue"})
+		return
+	}
+	if _, _, err := tunePlanApply(res); err != nil {
+		sendJSON(w, 200, map[string]any{"ok": false, "error": err.Error()})
+		return
+	}
+	if conv.isGenerating() {
+		sendJSON(w, 409, map[string]any{"ok": false, "error": conv.busyReason().Error()})
+		return
+	}
+	// Vérifié et posé d'un seul tenant : deux clics rapprochés passaient tous
+	// deux le test du début, et le perdant remettait applying à faux pendant
+	// que le premier écrivait encore.
+	tuneJob.mu.Lock()
+	if tuneJob.running || tuneJob.applying {
+		tuneJob.mu.Unlock()
+		sendJSON(w, 409, map[string]any{"ok": false, "error": errTuneBusy.Error()})
+		return
+	}
+	tuneJob.applying, tuneJob.applyLog, tuneJob.applyMsg, tuneJob.applyErr = true, nil, "", ""
+	tuneJob.mu.Unlock()
+	go func() {
+		say := func(s string) {
+			tuneJob.mu.Lock()
+			tuneJob.applyLog = append(tuneJob.applyLog, s)
+			tuneJob.mu.Unlock()
+		}
+		msg, err := tuneApply(context.Background(), res, tuneApplyPreset, say)
+		tuneJob.mu.Lock()
+		defer tuneJob.mu.Unlock()
+		tuneJob.applying = false
+		tuneJob.applyMsg = msg
+		if err != nil {
+			tuneJob.applyErr = err.Error()
+		}
+	}()
+	sendJSON(w, 202, map[string]any{"ok": true})
+}
+
+// handleTuneLast : le dernier résultat enregistré d'un preset, et si le moteur
+// a changé depuis (build différent) — l'interface propose alors de relancer.
+func handleTuneLast(w http.ResponseWriter, r *http.Request) {
+	id := r.URL.Query().Get("id")
+	res, ok := loadTuneResult(id)
+	if !ok {
+		sendJSON(w, 200, map[string]any{"ok": false})
+		return
+	}
+	out := map[string]any{"ok": true, "result": res}
+	if content, err := ReadPreset(id); err == nil {
+		out["preset_changed"] = presetFingerprint([]byte(content)) != res.PresetFP
+	}
+	if bin := tuneEngineBin(ReadConfig()); bin != "" && res.EngineBuild > 0 {
+		if b := engineBuildCached(bin); b > 0 && b != res.EngineBuild {
+			out["engine_changed"] = fmt.Sprintf("b%d → b%d", res.EngineBuild, b)
+		}
+	}
+	sendJSON(w, 200, out)
+}
+
+// tuneEngineBin : le binaire du moteur, résolu comme cmdServe le fait.
+func tuneEngineBin(cfg map[string]string) string {
+	bin := strings.TrimSpace(cfg["BIN"])
+	if bin == "" {
+		return ""
+	}
+	if !filepath.IsAbs(bin) {
+		bin = filepath.Join(LokiHome(), bin)
+	}
+	return prebuiltResolveBin(bin)
+}
+
+// --- ligne de commande -------------------------------------------------------------
+
+// cmdTune : « loki tune [--placement] [--opt-in] [--budget MIN] [--stages …] ». Mesure, montre,
+// puis DEMANDE où écrire le résultat — rien n'est écrit sans réponse. Comme
+// « loki bench », ce processus ne voit pas la discussion du processus web :
+// seule la vérification /slots (moteur occupé) protège un tour en cours ; une
+// fois le verrou pris, le processus web refuse tout nouveau tour. Le bouton de
+// l'interface, lui, voit tout.
+func cmdTune(args []string) error {
+	fs := flag.NewFlagSet("tune", flag.ContinueOnError)
+	placement := fs.Bool("placement", false, "essayer --fit à la place du placement manuel (réécrit EXTRA_ARGS)")
+	optIn := fs.Bool("opt-in", false, "essayer aussi SPEC, CUDA_GRAPH_OPT et --backend-sampling")
+	budget := fs.Int("budget", int(tuneDefaultBudget/time.Minute), "budget en minutes")
+	stages := fs.String("stages", "", "étapes de base, séparées par des virgules : marges,lots,delestage,threads,files (vide = toutes)")
+	if err := fs.Parse(args); err != nil {
+		return err
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	if err := tunePreflight(ctx, false); err != nil {
+		return err
+	}
+	fmt.Printf("\n  %s — essais sur un moteur privé (127.0.0.1), config.env jamais modifié.\n", cyan("Optimiseur sans perte"))
+	fmt.Println(dim("  Le chat et les tâches attendent pendant la mesure ; Ctrl-C annule (le moteur est relancé)."))
+	fmt.Println()
+	// Ctrl-C annule proprement : l'essai est arrêté, le vrai moteur relancé.
+	// Le terminal fermé (SIGHUP ; CTRL_CLOSE_EVENT, livré en SIGTERM sous
+	// Windows) ou un kill aussi : sans ça, le processus mourait sans ses defers,
+	// le vrai moteur restait arrêté et l'essai gardait la VRAM.
+	sig := make(chan os.Signal, 1)
+	signal.Notify(sig, os.Interrupt, syscall.SIGTERM, syscall.SIGHUP)
+	defer signal.Stop(sig)
+	go func() {
+		if _, ok := <-sig; ok {
+			cancel()
+		}
+	}()
+	tr := &tuneTracker{print: true}
+	var only []string
+	for _, s := range strings.Split(*stages, ",") {
+		if s = strings.TrimSpace(s); s != "" {
+			only = append(only, s)
+		}
+	}
+	res, err := runTune(ctx, tuneOpts{Placement: *placement, OptIn: *optIn,
+		Budget: time.Duration(*budget) * time.Minute, Via: "cli", Stages: only}, tr)
+	if err != nil {
+		return err
+	}
+	// Les essais sont finis : Ctrl-C reprend son sens ordinaire aux questions.
+	signal.Stop(sig)
+	printTuneResult(res)
+	if len(res.Set) == 0 {
+		return nil
+	}
+	in := bufio.NewScanner(os.Stdin)
+	ask := func(q string) string {
+		fmt.Print(q)
+		if !in.Scan() {
+			return ""
+		}
+		return strings.ToLower(strings.TrimSpace(in.Text()))
+	}
+	switch ask("  Enregistrer ? [c] dans une copie du preset · [p] dans « " + res.PresetName + " » (redémarre le moteur) · [N] non : ") {
+	case "c":
+		msg, err := tuneApply(context.Background(), res, tuneApplyCopy, func(string) {})
+		if err != nil {
+			return err
+		}
+		fmt.Println(green("[ok] ") + msg)
+	case "p":
+		if res.Placement && ask("  Le placement réécrit EXTRA_ARGS (voir ci-dessus). Confirmer ? [o/N] ") != "o" {
+			fmt.Println(dim("  rien n'a été écrit"))
+			return nil
+		}
+		msg, err := tuneApply(context.Background(), res, tuneApplyPreset, func(s string) { fmt.Println("  " + s) })
+		if err != nil {
+			return err
+		}
+		fmt.Println(green("[ok] ") + msg)
+	default:
+		fmt.Println(dim("  rien n'a été écrit (le résultat reste visible dans l'éditeur du preset)"))
+	}
+	return nil
+}
+
+func printTuneResult(res *tuneResult) {
+	fmt.Println()
+	row := func(t tuneTrial) {
+		turn := "—"
+		if t.TurnSec > 0 {
+			turn = fmt.Sprintf("%.1f s", t.TurnSec)
+		}
+		why := t.Why
+		if t.Headroom >= 0 {
+			why += fmt.Sprintf(" · %d Mio libres", t.Headroom)
+		}
+		fmt.Printf("  %-10s %-44s %8s  %-8s %s\n", t.Stage, t.Label, turn, t.Status, strings.TrimPrefix(why, " · "))
+	}
+	fmt.Printf("  %s (K=%.0f jetons lus, G=%.0f écrits, %.0f %% à froid à %d jetons — %s)\n",
+		cyan("Durée d'un tour type"), res.Weights.K, res.Weights.G, res.Weights.FCold*100, res.Depth, res.Weights.From)
+	row(res.Baseline)
+	for _, t := range res.Trials {
+		row(t)
+	}
+	for _, s := range res.Skipped {
+		fmt.Println(dim("  sauté — " + s))
+	}
+	for _, n := range res.Notes {
+		fmt.Println(yellow("  ! ") + n)
+	}
+	if res.Partial != "" {
+		fmt.Println(yellow("  ! résultat partiel : ") + res.Partial)
+	}
+	fmt.Println()
+	if len(res.Set) == 0 {
+		fmt.Println("  La configuration actuelle reste la meilleure : rien à changer.")
+		return
+	}
+	fmt.Printf("  %s %s : −%.1f %% par tour\n", green("Meilleur :"), res.Best, res.Gain*100)
+	for _, c := range res.Changes {
+		fmt.Println("    " + c)
+	}
+	fmt.Println()
+}

internal/loki/backend_tune_lock.go

@@ -0,0 +1,477 @@
+package loki
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+// Verrou de l'optimiseur (loki tune, bouton « Optimiser »).
+//
+// Pendant une optimisation, la VRAM appartient au moteur d'ESSAI : le vrai
+// moteur est arrêté, et le relancer à côté (bascule de preset, enregistrement du
+// preset actif, choix des GPU, mise à jour du moteur, « recharger » la VRAM…)
+// chargerait deux modèles sur des cartes qui n'en tiennent qu'un — un OOM certain,
+// et une mesure faussée. Un drapeau en mémoire ne suffit pas : « loki tune » en
+// ligne de commande et le processus web sont deux processus distincts. Le verrou
+// est donc un FICHIER de LOKI_HOME, créé de façon exclusive, que tout le monde
+// lit :
+//
+//   - serviceAction("start"/"restart") le consulte sur toutes les plateformes —
+//     aucun démarrage du moteur ne passe à côté ;
+//   - le chat, les tâches planifiées (qui attendent), les jobs du mode code, les
+//     clients /v1, le bench, la bascule et l'enregistrement de preset refusent
+//     avec une phrase claire.
+//
+// Le fichier porte l'identité du processus qui le tient (PID, instant de
+// démarrage, binaire) et celle de l'essai en cours. Un verrou dont le
+// propriétaire est mort (Loki redémarré en plein essai) est périmé : avant tout
+// démarrage du moteur, l'essai orphelin est arrêté — seulement si PID, instant
+// de démarrage ET binaire concordent, jamais sur la foi d'un PID recyclé — puis
+// le fichier est retiré.
+
+const tuneLockName = "tune.lock"
+
+// tuneLockFreshness : un verrou illisible plus jeune que ça est en cours
+// d'écriture, pas abandonné.
+const tuneLockFreshness = 10 * time.Second
+
+var errTuneBusy = errors.New("optimisation en cours (loki tune) : le moteur est réservé aux essais — " +
+	"attends la fin ou annule-la")
+
+// tuneProc : un processus désigné sans ambiguïté.
+type tuneProc struct {
+	PID   int      `json:"pid"`
+	Start string   `json:"start,omitempty"` // procIdentity ; vide = illisible au moment de l'écrire
+	Exes  []string `json:"exes,omitempty"`  // binaires admis (un « loki serve » devient llama-server par exec)
+}
+
+// tuneOwner : le contenu du verrou.
+type tuneOwner struct {
+	Owner tuneProc `json:"owner"`
+	Via   string   `json:"via"`   // « web » ou « cli »
+	Phase string   `json:"phase"` // « essais » ou « application »
+	Since int64    `json:"since"`
+	// Nonce : distingue deux verrous pris par le même processus dans la même
+	// seconde (tuneHeldKey). Absent des verrous d'une version d'avant : 0.
+	Nonce int64     `json:"nonce,omitempty"`
+	Trial *tuneProc `json:"trial,omitempty"`
+	// MainWasActive : le vrai moteur tournait avant l'optimisation. Un verrou
+	// périmé trouvé au démarrage du processus web le relance.
+	MainWasActive bool `json:"main_was_active"`
+	// Application en cours (phase « application ») : la version d'avant du
+	// preset, sauvée avant toute écriture. Un verrou périmé dans cette phase
+	// veut dire que l'application n'a jamais été vérifiée : elle est défaite.
+	Backup     string `json:"backup,omitempty"`
+	PresetID   string `json:"preset_id,omitempty"`
+	PresetName string `json:"preset_name,omitempty"`
+}
+
+func tuneLockPath() string { return filepath.Join(LokiHome(), tuneLockName) }
+
+// tuneProcAlive dit si p désigne encore le MÊME processus. Variable pour les
+// tests.
+var tuneProcAlive = func(p tuneProc) bool {
+	start, exe, ok := procIdentity(p.PID)
+	if !ok {
+		return false
+	}
+	if p.Start != "" && start != p.Start {
+		return false
+	}
+	if exe == "" || len(p.Exes) == 0 {
+		return true
+	}
+	for _, e := range p.Exes {
+		if sameExe(e, exe) {
+			return true
+		}
+	}
+	return false
+}
+
+// sameExe compare deux binaires par leur nom de fichier (sans .exe, sans
+// casse) : /proc/<pid>/exe résout les liens symboliques, ps n'en donne parfois
+// que le nom.
+func sameExe(a, b string) bool {
+	norm := func(s string) string {
+		s = strings.TrimSuffix(strings.TrimSpace(s), " (deleted)") // binaire remplacé (Linux)
+		s = strings.ToLower(filepath.Base(strings.ReplaceAll(s, `\`, "/")))
+		return strings.TrimSuffix(s, ".exe")
+	}
+	return a != "" && b != "" && norm(a) == norm(b)
+}
+
+// selfProc : ce processus, tel que le verrou le note.
+func selfProc() tuneProc {
+	p := tuneProc{PID: os.Getpid()}
+	if start, exe, ok := procIdentity(p.PID); ok {
+		p.Start = start
+		if exe != "" {
+			p.Exes = []string{exe}
+		}
+	}
+	if self, err := os.Executable(); err == nil && len(p.Exes) == 0 {
+		p.Exes = []string{self}
+	}
+	return p
+}
+
+func readTuneOwner(path string) (tuneOwner, bool) {
+	var o tuneOwner
+	b, err := os.ReadFile(path)
+	if err != nil || json.Unmarshal(b, &o) != nil || o.Owner.PID <= 0 {
+		return tuneOwner{}, false
+	}
+	return o, true
+}
+
+// tuneActive : une optimisation tient-elle le moteur, dans ce processus ou dans
+// un autre ? Un verrou périmé (propriétaire mort) ne compte pas.
+func tuneActive() (tuneOwner, bool) {
+	o, ok := readTuneOwner(tuneLockPath())
+	if !ok {
+		return tuneOwner{}, false
+	}
+	return o, tuneOwnerAlive(o)
+}
+
+// tuneHeld : verrous pris par CE processus et pas encore rendus (tuneHeldKey).
+var tuneHeld sync.Map
+
+// tuneFileMu sérialise, DANS CE PROCESSUS, les opérations sur le fichier de
+// verrou : prise, réécriture, rendu, et le déplacement-relecture du ménage
+// (tuneReapStale). Sans lui, le ménage pouvait déplacer un verrou vivant
+// pendant que release() le cherchait : release, ne le trouvant plus, rendait
+// l'inscription ; le ménage le remettait ensuite en place, désormais orphelin,
+// et le ménage suivant le prenait pour une optimisation interrompue (moteur
+// relancé, preset « rétabli »). Vu en CI : TestTuneRecoverNeverReapsOwnLock.
+var tuneFileMu sync.Mutex
+
+func tuneHeldKey(o tuneOwner) string { return fmt.Sprintf("%s|%d|%d", o.Via, o.Since, o.Nonce) }
+
+// tuneOwnerAlive : le propriétaire d'un verrou vit-il encore ? Un verrou qui
+// porte NOTRE PID sans être l'un des nôtres vient d'un processus mort dont le
+// PID nous est échu (redémarrage) : périmé, quoi que dise son identité.
+func tuneOwnerAlive(o tuneOwner) bool {
+	if o.Owner.PID == os.Getpid() {
+		if _, ours := tuneHeld.Load(tuneHeldKey(o)); !ours {
+			return false
+		}
+	}
+	return tuneProcAlive(o.Owner)
+}
+
+// tuneGuard : nil si rien ne tient le moteur, errTuneBusy sinon.
+func tuneGuard() error {
+	if _, busy := tuneActive(); busy {
+		return errTuneBusy
+	}
+	return nil
+}
+
+// tuneDenyHTTP répond 409 et rend true quand une optimisation tient le moteur.
+func tuneDenyHTTP(w http.ResponseWriter) bool {
+	if err := tuneGuard(); err != nil {
+		sendJSON(w, http.StatusConflict, map[string]any{"ok": false, "tuning": true, "error": err.Error()})
+		return true
+	}
+	return false
+}
+
+// tuneLock : le verrou tenu par CE processus.
+type tuneLock struct {
+	mu    sync.Mutex
+	path  string
+	owner tuneOwner
+	held  bool // inscrit dans tuneHeld, jusqu'à release
+}
+
+// tuneLockAcquire prend le verrou, ou dit qui le tient. Un verrou périmé est
+// d'abord écarté (tuneReapStale), essai orphelin compris.
+func tuneLockAcquire(via string, mainActive bool) (*tuneLock, error) {
+	path := tuneLockPath()
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		return nil, err
+	}
+	l := &tuneLock{path: path, owner: tuneOwner{Owner: selfProc(), Via: via, Phase: "essais",
+		Since: time.Now().Unix(), Nonce: time.Now().UnixNano(), MainWasActive: mainActive}}
+	// Inscrit comme nôtre AVANT que le fichier n'existe : la reprise du
+	// processus web (tuneRecoverWatch, toutes les 30 s) tient pour mort un
+	// verrou qui porte notre PID sans être inscrit, et l'écarterait entre la
+	// création et l'inscription.
+	key := tuneHeldKey(l.owner)
+	tuneHeld.Store(key, true)
+	for attempt := 0; attempt < 3; attempt++ {
+		tuneFileMu.Lock()
+		f, err := os.OpenFile(path, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0o644)
+		if err == nil {
+			b, _ := json.Marshal(l.owner)
+			_, werr := f.Write(b)
+			cerr := f.Close()
+			if werr != nil || cerr != nil {
+				_ = os.Remove(path)
+				tuneHeld.Delete(key)
+				tuneFileMu.Unlock()
+				return nil, fmt.Errorf("verrou de l'optimiseur : %v", errors.Join(werr, cerr))
+			}
+			l.held = true
+			tuneFileMu.Unlock()
+			return l, nil
+		}
+		tuneFileMu.Unlock()
+		if !os.IsExist(err) {
+			tuneHeld.Delete(key)
+			return nil, err
+		}
+		if o, busy := tuneActive(); busy {
+			tuneHeld.Delete(key)
+			return nil, fmt.Errorf("une optimisation tourne déjà (%s, PID %d, depuis %s)", o.Via, o.Owner.PID,
+				time.Unix(o.Since, 0).Format("15:04"))
+		}
+		tuneReapStale()
+	}
+	tuneHeld.Delete(key)
+	return nil, errors.New("verrou de l'optimiseur indisponible : réessaie")
+}
+
+// write réécrit le verrou d'un bloc (fichier voisin puis renommage) : un
+// lecteur ne voit jamais un JSON à moitié écrit.
+func (l *tuneLock) write() error {
+	tuneFileMu.Lock()
+	defer tuneFileMu.Unlock()
+	return l.writeLocked()
+}
+
+// writeLocked : write, tuneFileMu déjà tenu par l'appelant.
+func (l *tuneLock) writeLocked() error {
+	b, err := json.Marshal(l.owner)
+	if err != nil {
+		return err
+	}
+	tmp := l.path + ".tmp-" + strconv.Itoa(os.Getpid())
+	if err := os.WriteFile(tmp, b, 0o644); err != nil {
+		return err
+	}
+	// Windows refuse de remplacer un fichier qu'un autre processus lit à cet
+	// instant (tuneGuard d'une requête) : on réessaie un peu avant de renoncer.
+	for i := 0; ; i++ {
+		err := os.Rename(tmp, l.path)
+		if err == nil || i == 4 {
+			if err != nil {
+				_ = os.Remove(tmp)
+			}
+			return err
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+}
+
+// setTrial note l'essai en cours (nil : aucun), AVANT qu'il ne charge quoi que
+// ce soit d'important : c'est ce qui permet à un Loki redémarré de l'arrêter.
+func (l *tuneLock) setTrial(p *tuneProc) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.owner.Trial = p
+	_ = l.write()
+}
+
+func (l *tuneLock) setPhase(phase string) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.owner.Phase = phase
+	_ = l.write()
+}
+
+// setBackup note la sauvegarde du preset avant son écriture (tuneApply).
+func (l *tuneLock) setBackup(backup, id, name string) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.owner.Backup, l.owner.PresetID, l.owner.PresetName = backup, id, name
+	_ = l.write()
+}
+
+// release rend le verrou — seulement s'il est encore le nôtre.
+//
+// La reprise du processus web (tuneRecoverWatch) tourne toutes les 30 s,
+// pendant que ce même processus prend et rend ses verrous. Elle tient pour
+// mort un verrou à notre PID qui n'est plus inscrit (tuneHeld) : si le fichier
+// survivait à l'inscription — sous Windows, un fichier qu'un autre lit à cet
+// instant ne se supprime pas —, elle l'écarterait, et en phase « application »
+// défairait le preset tout juste vérifié (tuneUndoApply), ou relancerait le
+// moteur. Le verrou est donc d'abord réécrit NEUTRE (rien à défaire, rien à
+// relancer, aucun essai), puis retiré, et l'inscription ne part qu'après.
+func (l *tuneLock) release() {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	tuneFileMu.Lock()
+	defer tuneFileMu.Unlock()
+	if l.held {
+		// Un fichier absent un instant (renommé par un ménage qui le remet en
+		// place, voir tuneReapStale) n'est pas un fichier rendu : on relit.
+		ours := false
+		for i := 0; i < 5; i++ {
+			if o, ok := readTuneOwner(l.path); ok {
+				ours = sameTuneLock(o, l.owner)
+				break
+			}
+			time.Sleep(20 * time.Millisecond)
+		}
+		if ours {
+			l.owner.Phase, l.owner.Trial, l.owner.MainWasActive = "rendu", nil, false
+			l.owner.Backup, l.owner.PresetID, l.owner.PresetName = "", "", ""
+			_ = l.writeLocked()
+			for i := 0; i < 5; i++ {
+				if err := os.Remove(l.path); err == nil || os.IsNotExist(err) {
+					break
+				}
+				time.Sleep(20 * time.Millisecond)
+			}
+		}
+		l.held = false
+		tuneHeld.Delete(tuneHeldKey(l.owner))
+		return
+	}
+	if o, ok := readTuneOwner(l.path); ok && sameTuneLock(o, l.owner) {
+		_ = os.Remove(l.path)
+	}
+}
+
+// tuneReapStale écarte un verrou dont le propriétaire est mort : l'essai qu'il
+// désigne est arrêté s'il est encore là (identité complète vérifiée), puis le
+// fichier disparaît. Rend MainWasActive du verrou écarté (false sans verrou
+// périmé). Le renommage d'abord : de deux processus qui trouvent le même verrou
+// périmé, un seul l'emporte, et aucun ne retire un verrou neuf posé entre-temps.
+func tuneReapStale() (mainWasActive bool) {
+	o, ok := tuneReapClaim()
+	if !ok {
+		return false
+	}
+	if o.Trial != nil && tuneProcAlive(*o.Trial) {
+		fmt.Fprintf(os.Stderr, "[loki tune] essai orphelin (PID %d) d'une optimisation interrompue : arrêt\n", o.Trial.PID)
+		tuneKillTree(o.Trial.PID, nil)
+	}
+	tuneUndoApply(o)
+	return o.MainWasActive
+}
+
+// tuneReapClaim : la partie de tuneReapStale qui touche au fichier, sous
+// tuneFileMu — lecture, déplacement, relecture, remise en place. Rend le
+// verrou périmé effectivement retiré (ok=false : rien à écarter).
+func tuneReapClaim() (tuneOwner, bool) {
+	tuneFileMu.Lock()
+	defer tuneFileMu.Unlock()
+	path := tuneLockPath()
+	o, ok := readTuneOwner(path)
+	if !ok {
+		// Illisible (écriture interrompue) : périmé lui aussi, s'il est là —
+		// mais pas tout juste créé : entre sa création exclusive et l'écriture de
+		// son contenu, un verrou neuf est vide quelques instants, et le retirer
+		// laisserait passer une seconde optimisation ou un démarrage du moteur.
+		if fi, err := os.Stat(path); err == nil && time.Since(fi.ModTime()) > tuneLockFreshness {
+			_ = os.Remove(path)
+		}
+		return tuneOwner{}, false
+	}
+	if tuneOwnerAlive(o) {
+		return tuneOwner{}, false
+	}
+	stale := fmt.Sprintf("%s.stale-%d-%d", path, os.Getpid(), time.Now().UnixNano())
+	if os.Rename(path, stale) != nil {
+		return tuneOwner{}, false
+	}
+	defer os.Remove(stale)
+	// Entre la lecture et le renommage, le verrou lu a pu être rendu et un
+	// neuf, vivant, pris à sa place : c'est alors CELUI-LÀ qu'on vient de
+	// déplacer. La reprise du processus web tournant toutes les 30 s, pendant
+	// que ce même processus prend et rend ses verrous, ce n'est plus un cas
+	// d'école. On relit donc ce qu'on a déplacé ; un autre verrou est remis en
+	// place (un lien : jamais par-dessus un verrou posé entre-temps).
+	if got, ok := readTuneOwner(stale); !ok || !sameTuneLock(got, o) || tuneOwnerAlive(got) {
+		if err := os.Link(stale, path); err != nil {
+			fmt.Fprintf(os.Stderr, "[loki tune] verrou vivant déplacé par erreur, remise en place impossible : %v\n", err)
+		}
+		return tuneOwner{}, false
+	}
+	return o, true
+}
+
+// sameTuneLock : a et b désignent-ils la même prise de verrou (propriétaire et
+// instant de la prise), quelle que soit sa phase ?
+func sameTuneLock(a, b tuneOwner) bool {
+	return a.Owner.PID == b.Owner.PID && a.Owner.Start == b.Owner.Start && tuneHeldKey(a) == tuneHeldKey(b)
+}
+
+// tuneUndoApply : une application interrompue avant sa vérification (Loki tué
+// pendant la sonde) remet la version d'avant du preset — c'est ce que la
+// vérification aurait fait en échouant. Sans sauvegarde notée, rien.
+func tuneUndoApply(o tuneOwner) {
+	if o.Phase != "application" || o.Backup == "" || o.PresetID == "" {
+		return
+	}
+	b, err := os.ReadFile(o.Backup)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "[loki tune] application interrompue : sauvegarde illisible (%v)\n", err)
+		return
+	}
+	if _, _, err := SavePresetApplying(o.PresetID, o.PresetName, string(b)); err != nil {
+		fmt.Fprintf(os.Stderr, "[loki tune] application interrompue : retour impossible (%v) — l'ancienne version est dans %s\n", err, o.Backup)
+		return
+	}
+	fmt.Fprintf(os.Stderr, "[loki tune] application interrompue avant sa vérification : ancienne version du preset rétablie\n")
+}
+
+// tuneRecoverStale : une optimisation interrompue (Loki redémarré en plein
+// essai, « loki tune » tué par kill -9) a laissé le vrai moteur arrêté et peut-
+// être un essai en VRAM. On arrête l'essai, puis on relance le moteur s'il
+// tournait avant — ce que l'optimisation aurait fait en finissant. Sans
+// verrou, un simple stat : rien d'autre n'est lu.
+func tuneRecoverStale() {
+	if _, err := os.Stat(tuneLockPath()); err != nil {
+		return
+	}
+	if tuneReapStale() {
+		tuneRecoverStart()
+	}
+}
+
+// tuneRecoverStart relance le moteur après une optimisation interrompue, sauf
+// preset externe, moteur déjà reparti ou configuration incomplète. Variable
+// pour les tests.
+var tuneRecoverStart = func() {
+	if externalActive() || serviceIsActive() {
+		return
+	}
+	if err := preflightEngine(); err != nil {
+		return
+	}
+	fmt.Println(dim("[loki tune] optimisation interrompue : relance du moteur"))
+	// serviceAction, pas serviceActionOS : la reprise tourne désormais toutes
+	// les 30 s, et une optimisation neuve a pu prendre le verrou entre le
+	// ménage et ce démarrage — tuneGuard le voit, et le moteur reste arrêté
+	// pour elle.
+	_ = serviceAction("start")
+}
+
+// tuneRecoverEvery : la période de la reprise dans le processus web.
+const tuneRecoverEvery = 30 * time.Second
+
+// tuneRecoverWatch : au démarrage du processus web, puis à chaque tic. Le
+// démarrage seul ne suffisait pas : un « loki tune » en ligne de commande tué
+// sans ses defers (kill -9, terminal perdu) laissait le moteur arrêté jusqu'au
+// prochain redémarrage de l'interface. Le tic ne coûte qu'un stat tant
+// qu'aucun verrou n'existe ; pendant une optimisation vivante, une lecture du
+// verrou et de l'identité de son propriétaire.
+func tuneRecoverWatch(tick <-chan time.Time) {
+	tuneRecoverStale()
+	for range tick {
+		tuneRecoverStale()
+	}
+}

internal/loki/chat_cmd.go

@@ -64,6 +64,8 @@ func cmdChat(args []string) error {
 		full := strings.Builder{}
 		inReason := false
 		var stats *StatsEvent
+		// Raisonnement de la réponse finale (REASONING_ECHO), rangé avec elle.
+		var echo *ReasoningEcho
 		// Print the assistant prefix once; reasoning is shown inline with a tag.
 		fmt.Print(cyan("loki") + " > ")
 		caps := globalCaps()
@@ -74,22 +76,22 @@ func cmdChat(args []string) error {
 			fmt.Println(dim("[contexte compacté pour tenir dans la fenêtre]"))
 		}
 		sent, tools := prepareTurn(msgs, caps)
+		hist := msgs
 		extra, err := runChatTools(context.Background(), sent, tools, 0.7, caps, func(ev StreamEvent) bool {
 			switch {
 			case ev.Err != nil:
 				fmt.Printf("\n%s\n", red("[erreur] "+ev.Err.Error()))
 			case ev.NewHistory != nil:
 				// Compaction survenue pendant le tour : elle REMPLACE l'historique (elle
-				// contient déjà le tour en cours), préfixe système injecté retiré. Sans
-				// ça le terminal repartirait du fil complet au tour suivant.
-				base := ev.NewHistory
-				for len(base) > 0 && base[0].Role == "system" {
-					base = base[1:]
-				}
-				msgs = append([]Message(nil), base...)
+				// contient déjà le tour en cours), préfixe système injecté retiré —
+				// le /sys de l'utilisateur, lui, reste (historyFromView). Sans ça le
+				// terminal repartirait du fil complet au tour suivant.
+				msgs = historyFromView(ev.NewHistory, hist)
 				fmt.Println(dim("\n[contexte compacté pour tenir dans la fenêtre]"))
 			case ev.Stats != nil:
 				stats = ev.Stats
+			case ev.Echo != nil:
+				echo = ev.Echo
 			case ev.DropReasoning:
 				// Le tour a « pensé sans agir » : on relance. Impossible d'effacer le
 				// texte déjà imprimé en terminal — on referme juste la ligne reasoning.
@@ -113,7 +115,7 @@ func cmdChat(args []string) error {
 				case "edit":
 					icon = "✏️"
 					verb = "édition"
-				case "web_search", "web_open", "web_read", "web_grep":
+				case "web_search", "web_images", "web_open", "web_read", "web_grep":
 					icon = "🌐"
 					verb = "web"
 				case "web_screenshot":
@@ -155,7 +157,7 @@ func cmdChat(args []string) error {
 			// answer, so next turn the model remembers it already did them instead
 			// of re-invoking the same skill/command from scratch.
 			msgs = append(msgs, extra...)
-			msgs = append(msgs, Message{Role: "assistant", Content: full.String()})
+			msgs = append(msgs, withEcho(Message{Role: "assistant", Content: full.String()}, echo))
 		}
 	}
 }

internal/loki/chat_compact.go

@@ -72,6 +72,9 @@ func compactEnabled() bool {
 
 // ctxWindow renvoie la fenêtre de contexte configurée (config.env CTX), 32768
 // par défaut — la même valeur que celle passée à llama-server au lancement.
+// Avec SIDE_SLOT, le moteur reçoit -c 2×CTX, mais chacun de ses deux slots
+// fait CTX jetons : la fenêtre d'une conversation, comme d'un travail annexe,
+// reste CTX (backend_serve_side.go).
 func ctxWindow() int {
 	if v := ReadConfig()["CTX"]; v != "" {
 		if n, err := strconv.Atoi(v); err == nil && n > 0 {
@@ -171,21 +174,31 @@ func msgText(m Message) string {
 // par token, plus un forfait par message pour le rôle et les délimiteurs). C'est
 // volontairement approximatif : le comptage EXACT vient de llama.cpp
 // (PromptTokensTotal) ; ici on veut juste décider quand compacter.
+// Sans le raisonnement renvoyé (REASONING_ECHO) : celui-ci dépend de la
+// position du message et de la politique d'envoi, il s'ajoute par echoTokens
+// (estimateTokens, compactBounds).
 func msgTokens(m Message) int {
 	n := 4
 	n += len(msgText(m)) / 4
 	for _, tc := range m.ToolCalls {
 		n += (len(tc.Function.Name) + len(tc.Function.Arguments)) / 4
 	}
-	return n
+	// Image gardée (KEEP_TURN_IMAGES) : son coût mesuré par le moteur, que le
+	// seul marqueur textuel sous-estimerait de loin. 0 sans la clé.
+	return n + m.imgTokens
 }
 
-// estimateTokens estime la taille de l'historique en tokens.
+// estimateTokens estime la taille de l'historique en tokens, raisonnement
+// renvoyé compris quand il part réellement (echoTokens : rien sans
+// REASONING_ECHO).
 func estimateTokens(msgs []Message) int {
 	total := 0
 	for _, m := range msgs {
 		total += msgTokens(m)
 	}
+	for _, n := range echoTokens(msgs) {
+		total += n
+	}
 	return total
 }
 
@@ -331,8 +344,14 @@ func compactBounds(msgs []Message, tailBudget int) (head, tailStart int) {
 	}
 	tailStart = len(msgs)
 	acc := 0
+	// Même compte que estimateTokens, qui fixe le budget : raisonnement renvoyé
+	// compris, sinon la queue avalait plus que sa part.
+	echo := echoTokens(msgs)
 	for i := len(msgs) - 1; i >= head; i-- {
 		acc += msgTokens(msgs[i])
+		if echo != nil {
+			acc += echo[i]
+		}
 		tailStart = i
 		if acc >= tailBudget {
 			break
@@ -352,6 +371,35 @@ func compactBounds(msgs []Message, tailBudget int) (head, tailStart int) {
 }
 
 func compactMessages(ctx context.Context, msgs []Message, caps Caps) ([]Message, bool) {
+	out, changed, _ := compactMessagesOpt(ctx, msgs, caps, compactOpts{})
+	return out, changed
+}
+
+// compactMessagesOpt : compactMessages, avec les options de
+// COMPACT_CONTINUATION (chat_compact_cont.go) — options nulles, exactement le
+// chemin d'avant. Bornes, archives, demande réinjectée et sortie restent sur la
+// vue MODÈLE (msgs) dans tous les cas ; la vue d'envoi ne sert qu'à construire
+// la requête de résumé. refused : un résumé a été obtenu, mais la réduction
+// reste sous les 20 % exigés.
+//
+// Images gardées par KEEP_TURN_IMAGES (chat_keep_images.go) : retirées
+// D'ABORD, dans tout l'historique — leur légende et imageLostMarker restent.
+// Leur retrait suffit à changer l'historique, même si le résumé qui suit est
+// refusé. Sans la clé, il n'y en a aucune : chemin d'avant.
+func compactMessagesOpt(ctx context.Context, msgs []Message, caps Caps, opt compactOpts) (out []Message, changed, refused bool) {
+	stripped, freed := dropKeptImages(msgs)
+	if freed == 0 {
+		return compactMessagesCore(ctx, msgs, caps, opt)
+	}
+	logKeptImagesDropped("compaction", freed)
+	if out, changed, _ = compactMessagesCore(ctx, stripped, caps, opt); changed {
+		return out, true, false
+	}
+	return stripped, true, false
+}
+
+// compactMessagesCore : la compaction elle-même (voir compactMessagesOpt).
+func compactMessagesCore(ctx context.Context, msgs []Message, caps Caps, opt compactOpts) (out []Message, changed, refused bool) {
 	// Budget de queue = fraction de la CONVERSATION (pas de la fenêtre). Le lier à
 	// la fenêtre était le bug : une conversation de 25k tokens dans une fenêtre de
 	// 64k gardait 16k (0.25×64k) en queue → torse minuscule → réduction < 20% →
@@ -362,11 +410,20 @@ func compactMessages(ctx context.Context, msgs []Message, caps Caps) ([]Message,
 
 	// Rien à compacter : le torse [head, tailStart) est vide.
 	if tailStart <= head {
-		return msgs, false
+		return msgs, false, false
 	}
 
 	torso := msgs[head:tailStart]
 
+	// Même un résumé vide ne ferait pas passer la garantie de réduction (plus
+	// bas) : inutile d'appeler le modèle ni d'archiver quoi que ce soit, la
+	// compaction serait refusée. Borne basse exacte, jamais un refus de plus
+	// qu'aujourd'hui. Avec COMPACT_CONTINUATION seulement.
+	if opt.precheck && compactHopeless(msgs, head, tailStart) {
+		fmt.Fprintf(os.Stderr, "[compact] résumé non demandé : même vide, la réduction resterait sous 20 %%\n")
+		return msgs, false, false
+	}
+
 	// 3. Archivage des gros blocs (mémoire longue). AVANT de compacter, chaque bloc
 	//    du torse assez long est enregistré VERBATIM sous un id (r7…) : le résumé et
 	//    le repli le remplacent par une référence à cet id, que le modèle pourra
@@ -403,6 +460,10 @@ func compactMessages(ctx context.Context, msgs []Message, caps Caps) ([]Message,
 	pruned := make([]Message, len(torso))
 	for i, m := range torso {
 		pruned[i] = m
+		// Le raisonnement renvoyé (REASONING_ECHO) d'un tour compacté ne repart
+		// pas : comme le résumé, qui ne l'a jamais vu (renderTranscript), le torse
+		// revient à ce que Loki envoyait sans la clé.
+		pruned[i].ReasoningContent, pruned[i].ReasoningModel = "", ""
 		if e := archived[i]; e != nil {
 			pruned[i].Content = recallMarker(e.id, e.label)
 			continue
@@ -450,7 +511,23 @@ func compactMessages(ctx context.Context, msgs []Message, caps Caps) ([]Message,
 			}
 		}
 	}
-	summary, err := summarizeTranscriptFor(ctx, renderTranscript(forSummary), caps.Code)
+	// Sans les mises à jour du projet (PROJ_SNAPSHOT) : ce sont des données de
+	// Loki, pas la conversation, et le bloc projet est repris tout neuf après la
+	// compaction. Sans la clé, rien à retirer.
+	forSummary = stripContextUpdates(forSummary)
+	var summary string
+	var err error
+	if opt.view != nil {
+		// COMPACT_CONTINUATION : le résumé prolonge le prompt que le moteur a
+		// déjà en cache. Au moindre écart, repli sur la transcription d'avant.
+		summary, err = summarizeContinuation(ctx, msgs, tailStart, opt.view, caps.Code)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "[compact] continuation écartée (%v) : résumé sur transcription\n", err)
+			summary, err = summarizeTranscriptFor(ctx, renderTranscript(forSummary), caps.Code)
+		}
+	} else {
+		summary, err = summarizeTranscriptFor(ctx, renderTranscript(forSummary), caps.Code)
+	}
 	var mid []Message
 	if err != nil || summaryLooksEmpty(summary) {
 		// Résumé raté (erreur, vide, ou juste une référence recall) → on garde le
@@ -475,7 +552,7 @@ func compactMessages(ctx context.Context, msgs []Message, caps Caps) ([]Message,
 		}
 		mid = []Message{
 			{Role: "user", Content: sumMsg},
-			{Role: "assistant", Content: "Understood. I'll resume from exactly where I left off, using the findings above, and call recall(id) if I need the full content of an archived block, without redoing work that is already done."},
+			{Role: "assistant", Content: compactAckMsg},
 		}
 	}
 
@@ -500,31 +577,13 @@ func compactMessages(ctx context.Context, msgs []Message, caps Caps) ([]Message,
 	// Un rappel de loki (budget d'outils, relance) a le rôle `user` sans être une
 	// demande (isLokiInjected) : ni il ne prouve qu'une demande a été servie, ni
 	// il ne se réinjecte à la place de la vraie.
-	tailHasUser := false
-	for _, m := range msgs[tailStart:] {
-		if m.Role == "user" && !isLokiInjected(m) {
-			tailHasUser = true
-			break
-		}
-	}
 	summarized := err == nil && !summaryLooksEmpty(summary)
 	var pending []Message
-	for i := len(torso) - 1; i >= 0 && summarized && !tailHasUser; i-- {
-		if torso[i].Role != "user" || isLokiInjected(torso[i]) {
-			continue
-		}
-		if strings.HasPrefix(msgText(torso[i]), compactSummaryPrefix) {
-			continue // résumé d'une compaction précédente, pas une demande
-		}
-		pending = []Message{torso[i]}
-		break
+	if summarized {
+		pending = compactPending(msgs, torso, tailStart)
 	}
 
-	out := make([]Message, 0, head+len(mid)+len(pending)+len(msgs)-tailStart)
-	out = append(out, msgs[:head]...)
-	out = append(out, mid...)
-	out = append(out, pending...)
-	out = append(out, msgs[tailStart:]...)
+	out = compactAssemble(msgs, head, tailStart, mid, pending)
 
 	// Garantie de réduction : on n'accepte la compaction que si elle enlève au
 	// moins ~20% du contexte estimé. Sinon (torse déjà maigre, résumé peu rentable)
@@ -532,9 +591,55 @@ func compactMessages(ctx context.Context, msgs []Message, caps Caps) ([]Message,
 	// vraiment réduire, puis re-déclenchait aussitôt.
 	before, after := estimateTokens(msgs), estimateTokens(out)
 	if after > before*4/5 {
-		return msgs, false
+		return msgs, false, summarized
 	}
-	return out, true
+	return out, true, false
+}
+
+// compactAckMsg : la réponse assistant synthétique qui suit le résumé.
+const compactAckMsg = "Understood. I'll resume from exactly where I left off, using the findings above, and call recall(id) if I need the full content of an archived block, without redoing work that is already done."
+
+// compactPending : la demande en cours à réinjecter avant la queue (voir
+// compactMessagesOpt), quand un résumé a été obtenu ; nil sinon.
+func compactPending(msgs, torso []Message, tailStart int) []Message {
+	for _, m := range msgs[tailStart:] {
+		if m.Role == "user" && !isLokiInjected(m) {
+			return nil
+		}
+	}
+	for i := len(torso) - 1; i >= 0; i-- {
+		if torso[i].Role != "user" || isLokiInjected(torso[i]) {
+			continue
+		}
+		if strings.HasPrefix(msgText(torso[i]), compactSummaryPrefix) {
+			continue // résumé d'une compaction précédente, pas une demande
+		}
+		return []Message{torso[i]}
+	}
+	return nil
+}
+
+// compactAssemble : tête, zone résumée, demande réinjectée, queue.
+func compactAssemble(msgs []Message, head, tailStart int, mid, pending []Message) []Message {
+	out := make([]Message, 0, head+len(mid)+len(pending)+len(msgs)-tailStart)
+	out = append(out, msgs[:head]...)
+	out = append(out, mid...)
+	out = append(out, pending...)
+	return append(out, msgs[tailStart:]...)
+}
+
+// compactHopeless : la compaction serait refusée par la garantie de réduction
+// quel que soit le résumé. Le plancher est la sortie avec un résumé VIDE —
+// message d'en-tête court, sans index ni critères, réponse assistant, demande
+// réinjectée, queue : toute vraie sortie a la même forme avec des messages au
+// moins aussi longs, donc une estimation au moins aussi grande.
+func compactHopeless(msgs []Message, head, tailStart int) bool {
+	torso := msgs[head:tailStart]
+	floor := compactAssemble(msgs, head, tailStart, []Message{
+		{Role: "user", Content: compactSummaryUserMsg("", nil)},
+		{Role: "assistant", Content: compactAckMsg},
+	}, compactPending(msgs, torso, tailStart))
+	return estimateTokens(floor) > estimateTokens(msgs)*4/5
 }
 
 // summaryLooksEmpty détecte un résumé raté : trop court, ou constitué seulement
@@ -666,13 +771,7 @@ func renderTranscript(msgs []Message) string {
 // summarizeResp modélise le sous-ensemble utile d'une réponse non-streamée de
 // /v1/chat/completions.
 type summarizeResp struct {
-	Choices []struct {
-		Message struct {
-			Content          string `json:"content"`
-			ReasoningContent string `json:"reasoning_content"`
-		} `json:"message"`
-		FinishReason string `json:"finish_reason"`
-	} `json:"choices"`
+	Choices []summaryChoice `json:"choices"`
 }
 
 // summarizeTranscript demande au modèle local un résumé dense et fidèle du torse.
@@ -691,13 +790,17 @@ This is a CODING session. Also keep:
 - Errors hit (build, tests, tools) and how each was resolved — or that it is still open
 - The commands that build and test the project`
 
-// summarizeTranscriptFor : code = résumé d'une session du mode Code.
-func summarizeTranscriptFor(ctx context.Context, transcript string, code bool) (string, error) {
-	sys := `You are a context compactor. You are given the transcript of the older turns of a conversation between a user and an AI assistant (with its tools). The PURPOSE of your summary is to let the conversation continue in a fresh, smaller context WITHOUT losing any information that is useful or important to understand what came before and keep working — preserve everything that matters, drop only what is redundant.
+// compactTranscriptIntro : le rôle du résumeur sur transcription. Les règles
+// qui suivent (compactSummaryRules) servent aussi au résumé en continuation
+// (chat_compact_cont.go) : les deux chemins gardent les mêmes exigences.
+const compactTranscriptIntro = `You are a context compactor. You are given the transcript of the older turns of a conversation between a user and an AI assistant (with its tools). The PURPOSE of your summary is to let the conversation continue in a fresh, smaller context WITHOUT losing any information that is useful or important to understand what came before and keep working — preserve everything that matters, drop only what is redundant.
 
 The assistant is MID-TASK: it will read your summary and must resume exactly where it left off, WITHOUT redoing work it has already done. Its own internal reasoning is NOT part of the transcript and is lost — your summary is the only memory it keeps.
 
-Summarize densely and faithfully, keeping ONLY the essentials:
+`
+
+// compactSummaryRules : ce que tout résumé de compaction doit garder.
+const compactSummaryRules = `Summarize densely and faithfully, keeping ONLY the essentials:
 - The user's CURRENT request, goal(s) and constraints
 - FINDINGS: the concrete information already gathered — facts, figures, dates, names, URLs, file paths, values, config. This is the most important part: whatever is not here is lost and will have to be looked up again.
 - Sources already consulted (URLs opened, files read, commands run) — so they are not consulted a second time
@@ -705,6 +808,10 @@ Summarize densely and faithfully, keeping ONLY the essentials:
 - STATE OF PROGRESS: what is already answered, what is still missing, and the next concrete step
 Strict rules: no preamble or conclusion, no verbatim or long quotes, no throwaway detail. Use short bullet points. Be as concise as you can WHILE keeping every fact, decision and still-open task: a detail you drop here is lost for good, so when in doubt keep it. This is a dense compression summary, not a report. Always write ACTUAL prose sentences/bullets — never answer with just an id or a reference.
 Write the summary in the SAME language as the conversation.`
+
+// summarizeTranscriptFor : code = résumé d'une session du mode Code.
+func summarizeTranscriptFor(ctx context.Context, transcript string, code bool) (string, error) {
+	sys := compactTranscriptIntro + compactSummaryRules
 	if code {
 		sys += codeSummaryRules
 	}
@@ -735,19 +842,59 @@ Write the summary in the SAME language as the conversation.`
 		// argument inconnu par un 400, et la compaction échouait à chaque fois.
 		delete(payload, "chat_template_kwargs")
 	}
+	// SIDE_SLOT : la transcription est un prompt neuf, calculé à froid — sur le
+	// second slot, qui fait CTX jetons comme le premier, elle laisse intact le
+	// slot de la discussion. Sans second slot en service, aucun id_slot.
+	setEngineSlot(payload, engineSlotFor(ep, false))
+	ch, err := postSummary(ctx, ep, payload, perfTag{kind: perfCompact, conv: perfTagOf(ctx).conv})
+	if err != nil {
+		return "", err
+	}
+	return cleanSummary(ch.Message.Content, ch.Message.ReasoningContent, ch.FinishReason)
+}
+
+// summaryChoice : le premier choix d'une réponse de résumé.
+type summaryChoice struct {
+	Message struct {
+		Content          string `json:"content"`
+		ReasoningContent string `json:"reasoning_content"`
+		// Appels d'outil émis malgré tool_choice « none » (résumé en
+		// continuation, qui garde les outils du tour) : jamais un résumé.
+		ToolCalls []json.RawMessage `json:"tool_calls"`
+	} `json:"message"`
+	FinishReason string `json:"finish_reason"`
+}
+
+// summaryHTTPError : le moteur a refusé la requête de résumé.
+type summaryHTTPError struct {
+	who    string
+	status int
+	body   string
+}
+
+func (e *summaryHTTPError) Error() string {
+	return fmt.Sprintf("résumé: %s %d: %s", e.who, e.status, e.body)
+}
+
+// postSummary envoie une requête de résumé non streamée et rend son premier
+// choix. Partagé par le résumé sur transcription et celui en continuation
+// (chat_compact_cont.go) : même compteur de requêtes en vol, même télémétrie
+// (kind=compact), mêmes erreurs.
+func postSummary(ctx context.Context, ep chatEndpoint, payload map[string]any, tag perfTag) (summaryChoice, error) {
 	body, _ := json.Marshal(payload)
 	req, err := http.NewRequestWithContext(ctx, "POST", ep.URL, bytes.NewReader(body))
 	if err != nil {
-		return "", err
+		return summaryChoice{}, err
 	}
 	req.Header.Set("Content-Type", "application/json")
 	ep.auth(req.Header.Set)
 	if !ep.External {
-		defer engineRequestStart()() // voir llm_slots.go
+		end, _ := engineRequestBeginSide(nil, payloadOnSideSlot(payload)) // voir llm_slots.go
+		defer end()
 	}
 	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
-		return "", friendlyLLMError(err)
+		return summaryChoice{}, friendlyLLMError(err)
 	}
 	defer resp.Body.Close()
 	if resp.StatusCode != http.StatusOK {
@@ -756,28 +903,27 @@ Write the summary in the SAME language as the conversation.`
 		if ep.External {
 			who = "API externe"
 		}
-		return "", fmt.Errorf("résumé: %s %d: %s", who, resp.StatusCode, strings.TrimSpace(string(b)))
+		return summaryChoice{}, &summaryHTTPError{who: who, status: resp.StatusCode, body: strings.TrimSpace(string(b))}
 	}
 	raw, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return "", err
+		return summaryChoice{}, err
 	}
 	// Decoder et non Unmarshal : comme avant, seule la première valeur JSON
 	// compte — un octet parasite après elle (proxy, passerelle) ne doit pas
 	// faire échouer une compaction qui passait.
 	var out summarizeResp
 	if err := json.NewDecoder(bytes.NewReader(raw)).Decode(&out); err != nil {
-		return "", err
+		return summaryChoice{}, err
 	}
 	// Télémétrie de la compaction : réponse non streamée, timings et usage sont
 	// à la racine. Lue à part et sans échec possible (perfWire) : un compteur
 	// mal typé ne doit jamais faire échouer la compaction.
-	perfRecord(perfRecFromWire(perfTag{kind: perfCompact, conv: perfTagOf(ctx).conv}, decodePerfWire(raw)), nil)
+	perfRecord(perfRecFromWire(tag, decodePerfWire(raw)), nil)
 	if len(out.Choices) == 0 {
-		return "", fmt.Errorf("résumé: réponse vide")
+		return summaryChoice{}, fmt.Errorf("résumé: réponse vide")
 	}
-	ch := out.Choices[0]
-	return cleanSummary(ch.Message.Content, ch.Message.ReasoningContent, ch.FinishReason)
+	return out.Choices[0], nil
 }
 
 // summaryRuneCap borne le résumé en caractères, en filet de sécurité
@@ -888,6 +1034,10 @@ const shrinkTruncMarker = "\n[…tronqué : contexte plein. Relance l'outil de f
 // typiquement un tour qui a lu beaucoup de gros fichiers d'un coup, tout est
 // dans la queue protégée). Avant, l'erreur 400 remontait telle quelle et la
 // conversation restait bloquée. Ici on réduit pour de bon :
+//  0. le raisonnement renvoyé (REASONING_ECHO), du plus ancien au plus récent :
+//     c'est ce que Loki n'envoyait pas sans la clé, à retirer avant tout le reste
+//     — y compris dans un seul long tour sans frontière `user`, que l'étape 2
+//     ne sait pas couper ;
 //  1. les gros résultats d'outils (du plus ancien au plus récent) sont tronqués ;
 //  2. si ça ne suffit pas, on retire les plus vieux échanges, par tour entier
 //     (frontière `user`), en gardant les messages système de tête.
@@ -905,6 +1055,21 @@ func shrinkToFit(msgs []Message, actual int) ([]Message, bool) {
 	}
 	target := int(float64(ctxWindow()) * 0.6 / ratio)
 	out := append([]Message(nil), msgs...)
+	// Avant tout : les images gardées par KEEP_TURN_IMAGES, retirées en bloc
+	// comme à la compaction (sans la clé, aucune).
+	if s, freed := dropKeptImages(out); freed > 0 {
+		logKeptImagesDropped("réduction", freed)
+		out = s
+	}
+	for i := range out {
+		if out[i].ReasoningContent == "" && out[i].ReasoningModel == "" {
+			continue
+		}
+		if estimateTokens(out) <= target {
+			break
+		}
+		out[i].ReasoningContent, out[i].ReasoningModel = "", ""
+	}
 	for i := range out {
 		if estimateTokens(out) <= target {
 			break

internal/loki/chat_compact_cont.go

@@ -0,0 +1,476 @@
+package loki
+
+// chat_compact_cont.go — COMPACT_CONTINUATION : la compaction proactive comme
+// suite du prompt que le moteur a déjà en cache.
+//
+// Pourquoi. Aujourd'hui, le résumé d'une compaction part dans une requête à
+// part : son propre prompt système et une transcription du torse. Le moteur
+// local la calcule à froid (5 à 46k jetons), puis recalcule à froid le prompt
+// compacté au message suivant. Sur un 27B, des dizaines de secondes ; sur un
+// MoE aux experts en RAM, des minutes — à chaque compaction.
+//
+// Avec la clé (off par défaut), quand le slot porte selon toute vraisemblance
+// le prompt de CETTE discussion, la requête de résumé est la requête du tour
+// telle qu'elle est partie — mêmes messages assemblés par les mêmes fonctions
+// (turnViewDry, wireMessages, buildChatPayload), mêmes outils, mêmes arguments
+// du gabarit, même intensité de raisonnement — suivie d'un seul message
+// utilisateur qui demande le résumé. Le moteur ne calcule que ce message.
+//
+// Ce qui ne change pas :
+//   - la compaction elle-même : bornes, archives recall, demande réinjectée,
+//     garantie de réduction et historique rangé sont calculés sur la vue
+//     MODÈLE, comme avant. La vue d'envoi ne sert qu'à construire la requête :
+//     ni prompt système, ni skills, ni bloc projet n'entrent dans l'historique ;
+//   - les exigences du résumé : mêmes règles (compactSummaryRules, plus
+//     codeSummaryRules en mode Code), même budget, même température 0.2 sans
+//     l'échantillonnage du preset, réflexion coupée (enable_thinking=false,
+//     ajouté aux arguments du tour) ;
+//   - le modèle principal, ses tours et leur échantillonnage.
+//
+// Ce qui change : le résumeur voit le torse entier dans son format natif (plus
+// que la transcription, qui raccourcit les résultats d'outils), depuis la
+// place de l'agent. La frontière lui est désignée par le nombre de messages
+// gardés et le début du premier d'entre eux ; en cas de doute, il doit plutôt
+// répéter que laisser tomber, et dater l'état d'avancement à la frontière.
+//
+// Repli sur la transcription d'avant, sans rien perdre, au moindre écart :
+// preset externe, autre requête passée par le slot depuis le dernier tour
+// (vérificateur, sous-agent, tâche, préchauffage, résumé, bench, client /v1,
+// autre discussion), moteur relancé sur un autre modèle ou une autre fenêtre,
+// étape de secours (outils coupés), marge insuffisante dans la fenêtre, vue
+// désalignée, refus du moteur (gabarit qui exige l'alternance, fenêtre
+// pleine…), erreur réseau, appel d'outil émis, raisonnement sans résumé,
+// résumé vide. Un refus du gabarit ou un appel d'outil suspend la continuation
+// pour ce modèle jusqu'au redémarrage ; deux résumés ratés de suite aussi.
+//
+// La clé apporte aussi deux économies sans effet sur le résultat :
+//   - un résumé n'est pas demandé quand même un résumé vide ne passerait pas la
+//     garantie de réduction (compactHopeless, borne exacte) ;
+//   - une compaction refusée parce que le résumé obtenu était trop long n'est
+//     retentée, en début ou fin de tour et entre deux étapes, qu'une fois le
+//     contexte grossi de 10 % sur le même fil (un historique réécrit retente)
+//     — jamais pour le filet réactif, le bouton « compacter », une fenêtre
+//     pleine à 90 % ou plus.
+//
+// Réactif (prompt refusé par le moteur), fenêtre pleine en pleine génération,
+// bouton manuel, tâches, sous-agents, terminal : chemin d'avant, toujours.
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"strings"
+	"sync"
+	"unicode/utf8"
+)
+
+// compactContinuationOn : clé posée, moteur local.
+func compactContinuationOn(cfg map[string]string) bool {
+	if isExternalConfig(cfg) {
+		return false
+	}
+	switch strings.ToLower(strings.TrimSpace(cfg["COMPACT_CONTINUATION"])) {
+	case "on", "1", "true", "yes", "oui":
+		return true
+	}
+	return false
+}
+
+// compactView : la requête du tour telle qu'elle est partie, pour un résumé
+// en continuation. wire couvre les n premiers messages de la vue modèle.
+type compactView struct {
+	wire   []Message
+	n      int
+	tools  []Tool
+	effort string
+	kwargs map[string]any
+	used   int    // contexte réel (dernier compte du moteur + ce qu'il n'a pas vu)
+	conv   string // discussion, pour la télémétrie
+}
+
+// compactOpts : options d'une compaction. Nulles : le chemin d'avant, exact.
+type compactOpts struct {
+	view     *compactView // nil : résumé sur transcription
+	precheck bool         // pas de résumé quand même un vide serait refusé
+	conv     string       // discussion, pour la mémoire des refus
+	used     int
+}
+
+// compactViewLen : la vue s'arrête avant les messages utilisateur de fin (le
+// nouveau message, ceux de la file, une image montrée à l'étape) : le moteur
+// ne les a pas en cache, et un second message utilisateur d'affilée ferait
+// refuser la requête par les gabarits à alternance stricte.
+func compactViewLen(msgs []Message) int {
+	k := len(msgs)
+	for k > 0 && msgs[k-1].Role == "user" {
+		k--
+	}
+	return k
+}
+
+// compactOptsFor : options des compactions de début et de fin de tour.
+func (c *Conversation) compactOptsFor(caps Caps, msgs []Message, used int, conv string) compactOpts {
+	cfg := ReadConfig()
+	if conv == "" || !compactContinuationOn(cfg) {
+		return compactOpts{}
+	}
+	opt := compactOpts{precheck: true, conv: conv, used: used}
+	if used <= 0 || !engineSlotHolds(conv) || compactContDisabled() {
+		return opt
+	}
+	k := compactViewLen(msgs)
+	if k == 0 {
+		return opt
+	}
+	sent, tools := c.turnViewDry(caps, msgs[:k], caps.Agent)
+	_, effort, _, kwargs := turnReasoning(cfg)
+	wire, _ := wireMessages(sent, false, turnEchoPolicy(false))
+	opt.view = &compactView{wire: wire, n: k, tools: tools, effort: effort, kwargs: kwargs, used: used, conv: conv}
+	return opt
+}
+
+// compactOptsMid : options d'une compaction entre deux étapes d'un tour
+// (runChatTools). messages porte déjà le prompt système et le bloc projet ;
+// pol est la politique de raisonnement renvoyé de la dernière requête.
+// rescue : étape de secours (outils coupés ou neutralisés), dont le prompt
+// n'est pas celui du tour.
+func compactOptsMid(cfg map[string]string, ep chatEndpoint, conv string, messages []Message, used int,
+	tools []Tool, effort string, kwargs map[string]any, pol echoPolicy, rescue bool) compactOpts {
+	if conv == "" || ep.External || !compactContinuationOn(cfg) {
+		return compactOpts{}
+	}
+	opt := compactOpts{precheck: true, conv: conv, used: used}
+	if rescue || used <= 0 || !engineSlotHolds(conv) || compactContDisabled() {
+		return opt
+	}
+	k := compactViewLen(messages)
+	if k == 0 {
+		return opt
+	}
+	wire, _ := wireMessages(messages[:k], false, pol)
+	opt.view = &compactView{wire: wire, n: k, tools: tools, effort: effort, kwargs: kwargs, used: used, conv: conv}
+	return opt
+}
+
+// compactMessagesNoted : compactMessagesOpt, plus la mémoire des refus.
+func compactMessagesNoted(ctx context.Context, msgs []Message, caps Caps, opt compactOpts) ([]Message, bool) {
+	out, changed, refused := compactMessagesOpt(ctx, msgs, caps, opt)
+	if opt.conv != "" {
+		if changed {
+			compactRefusedClear(opt.conv)
+		} else if refused {
+			compactRefusedNote(opt.conv, opt.used, msgs)
+		}
+	}
+	return out, changed
+}
+
+// --- refus mémorisés --------------------------------------------------------
+
+// compactRefusal : une compaction refusée faute de réduction, à at jetons de
+// contexte, sur un historique de n messages d'empreinte hash. En mémoire
+// seulement : un redémarrage retente.
+type compactRefusal struct {
+	at, window int
+	model      string
+	n          int
+	hash       uint64
+}
+
+// historyHash : empreinte d'un historique (celle de perfPrefix).
+func historyHash(msgs []Message) uint64 {
+	if len(msgs) == 0 {
+		return 0
+	}
+	p := perfPrefix(msgs)
+	return p[len(p)-1]
+}
+
+var compactRefused struct {
+	mu sync.Mutex
+	m  map[string]compactRefusal
+}
+
+const compactRefusedMax = 64
+
+// compactRefusedSkip : la dernière compaction de conv a été refusée, msgs ne
+// fait que prolonger l'historique d'alors, et le contexte n'a pas grossi de
+// 10 % depuis. Jamais à 90 % de la fenêtre ou plus ; oublié dès que
+// l'historique a été réécrit (compaction, édition, régénération, discussion
+// vidée), que le contexte baisse, ou que le modèle ou la fenêtre changent.
+func compactRefusedSkip(conv string, used int, msgs []Message) bool {
+	if conv == "" || used <= 0 || !compactContinuationOn(ReadConfig()) {
+		return false
+	}
+	model, window := engineMainNow()
+	compactRefused.mu.Lock()
+	r, ok := compactRefused.m[conv]
+	compactRefused.mu.Unlock()
+	if !ok {
+		return false
+	}
+	if r.model != model || r.window != window || used < r.at || used >= r.at+r.at/10 ||
+		len(msgs) < r.n || historyHash(msgs[:r.n]) != r.hash {
+		compactRefusedClear(conv)
+		return false
+	}
+	if used*10 >= window*9 {
+		return false
+	}
+	fmt.Fprintf(os.Stderr, "[compact] pas de nouvel essai : refusée à %d jetons, contexte à %d\n", r.at, used)
+	return true
+}
+
+func compactRefusedNote(conv string, used int, msgs []Message) {
+	if conv == "" || used <= 0 {
+		return
+	}
+	model, window := engineMainNow()
+	hash := historyHash(msgs)
+	compactRefused.mu.Lock()
+	defer compactRefused.mu.Unlock()
+	if compactRefused.m == nil {
+		compactRefused.m = map[string]compactRefusal{}
+	}
+	if _, ok := compactRefused.m[conv]; !ok && len(compactRefused.m) >= compactRefusedMax {
+		for k := range compactRefused.m {
+			delete(compactRefused.m, k)
+			break
+		}
+	}
+	compactRefused.m[conv] = compactRefusal{at: used, window: window, model: model, n: len(msgs), hash: hash}
+}
+
+func compactRefusedClear(conv string) {
+	compactRefused.mu.Lock()
+	delete(compactRefused.m, conv)
+	compactRefused.mu.Unlock()
+}
+
+// --- échecs par modèle ------------------------------------------------------
+
+// compactContFails : échecs de la continuation par modèle, jusqu'au
+// redémarrage. À compactContMaxFails, elle n'est plus tentée pour ce modèle.
+var compactContFails struct {
+	mu sync.Mutex
+	m  map[string]int
+}
+
+const compactContMaxFails = 2
+
+func compactContDisabled() bool {
+	model, _ := engineMainNow()
+	compactContFails.mu.Lock()
+	defer compactContFails.mu.Unlock()
+	return compactContFails.m[model] >= compactContMaxFails
+}
+
+// compactContFail : hard = refus du gabarit ou appel d'outil, qui se
+// reproduiraient à l'identique : suspendue tout de suite.
+func compactContFail(hard bool) {
+	model, _ := engineMainNow()
+	compactContFails.mu.Lock()
+	defer compactContFails.mu.Unlock()
+	if compactContFails.m == nil {
+		compactContFails.m = map[string]int{}
+	}
+	n := compactContFails.m[model] + 1
+	if hard {
+		n = compactContMaxFails
+	}
+	if n >= compactContMaxFails && compactContFails.m[model] < compactContMaxFails {
+		fmt.Fprintf(os.Stderr, "[compact] continuation suspendue pour %s jusqu'au redémarrage : résumés sur transcription\n", model)
+	}
+	compactContFails.m[model] = n
+}
+
+func compactContOK() {
+	model, _ := engineMainNow()
+	compactContFails.mu.Lock()
+	delete(compactContFails.m, model)
+	compactContFails.mu.Unlock()
+}
+
+// --- la requête -------------------------------------------------------------
+
+// compactWireIndex : position dans view.wire du message msgs[i] de la vue
+// modèle (len(view.wire) pour i == view.n : toute la vue), -1 si les deux vues
+// ne se correspondent pas. L'assemblage n'ajoute ou ne déplace que des
+// messages système (prompt, skills, bloc projet, rappel des pages lues) ; les
+// autres se suivent un pour un, dans le même ordre — vérifié rôle par rôle,
+// appel par appel, plutôt que supposé.
+func compactWireIndex(msgs []Message, view *compactView, i int) int {
+	if view == nil || view.n > len(msgs) || i < 0 || i > view.n {
+		return -1
+	}
+	var a, b []int
+	for j, m := range msgs[:view.n] {
+		if m.Role != "system" {
+			a = append(a, j)
+		}
+	}
+	for j, m := range view.wire {
+		if m.Role != "system" {
+			b = append(b, j)
+		}
+	}
+	if len(a) != len(b) {
+		return -1
+	}
+	at := -1
+	for j := range a {
+		m, w := msgs[a[j]], view.wire[b[j]]
+		if m.Role != w.Role || m.ToolCallID != w.ToolCallID || len(m.ToolCalls) != len(w.ToolCalls) {
+			return -1
+		}
+		if a[j] == i {
+			at = b[j]
+		}
+	}
+	if i == view.n {
+		return len(view.wire)
+	}
+	return at
+}
+
+// clipRunes : s sur une ligne, coupé à n caractères.
+func clipRunes(s string, n int) string {
+	s = strings.Join(strings.Fields(s), " ")
+	if utf8.RuneCountInString(s) <= n {
+		return s
+	}
+	return string([]rune(s)[:n]) + "…"
+}
+
+// compactBoundaryDesc désigne le premier message gardé, m (vue modèle), qui
+// est wire[wi] : son rôle, et l'appel d'outil ou le début du texte. Un début
+// déjà vu plus haut est allongé, pour rester sans ambiguïté.
+func compactBoundaryDesc(wire []Message, wi int, m Message) string {
+	if m.Role == "assistant" && strings.TrimSpace(msgText(m)) == "" && len(m.ToolCalls) > 0 {
+		f := m.ToolCalls[0].Function
+		return fmt.Sprintf("your call to the tool %s(%s)", f.Name, clipRunes(f.Arguments, 120))
+	}
+	who := "the user message"
+	switch m.Role {
+	case "assistant":
+		who = "your message"
+	case "tool":
+		who = "the tool result"
+	}
+	m, _ = withoutCtxUpdate(m)
+	text := msgText(m)
+	snip := clipRunes(text, 80)
+	for _, w := range wire[:wi] {
+		if strings.Contains(strings.Join(strings.Fields(msgText(w)), " "), strings.TrimSuffix(snip, "…")) {
+			snip = clipRunes(text, 200)
+			break
+		}
+	}
+	return fmt.Sprintf("%s that starts with «%s»", who, snip)
+}
+
+// compactContPrefix ouvre la demande de résumé : jamais rangée, elle ne vit
+// que dans la requête.
+const compactContPrefix = "[COMPACTION]"
+
+// compactContInstruction : la demande ajoutée en fin de requête. kept =
+// messages gardés tels quels à partir de la frontière (0 : tout est résumé).
+func compactContInstruction(kept int, desc string, code bool) string {
+	var b strings.Builder
+	b.WriteString(compactContPrefix)
+	b.WriteString(" Pause the task: do not answer and do not call any tool. The context is full: the older part of this conversation will be replaced by the summary you write now, and your past reasoning will be lost — this summary is the only memory kept of that part.\n")
+	if kept > 0 {
+		fmt.Fprintf(&b, "Summarize every message BEFORE %s. That message and the ones after it (the last %d) stay verbatim after your summary: mention them briefly at most, but never leave out anything that comes before. Write the STATE OF PROGRESS as of that message, not later.\n", desc, kept)
+	} else {
+		b.WriteString("Summarize the whole conversation above.\n")
+	}
+	b.WriteString("Leave out the system instructions and any <project_context> or <context_update> block: they are sent again separately.\n\n")
+	b.WriteString(compactSummaryRules)
+	if code {
+		b.WriteString(codeSummaryRules)
+	}
+	return b.String()
+}
+
+// summarizeContinuation demande le résumé du torse [.., tailStart) en
+// prolongeant la requête du tour (view). Toute erreur fait retomber
+// l'appelant sur la transcription.
+func summarizeContinuation(ctx context.Context, msgs []Message, tailStart int, view *compactView, code bool) (string, error) {
+	ep := resolveChatEndpoint()
+	if ep.External {
+		return "", errors.New("preset externe")
+	}
+	if tailStart > view.n {
+		return "", errors.New("frontière hors de la vue")
+	}
+	// Relu à l'envoi : une requête partie depuis la construction de la vue
+	// aurait pris le slot.
+	if !engineSlotHolds(view.conv) {
+		return "", errors.New("slot repris entre-temps")
+	}
+	wi := compactWireIndex(msgs, view, tailStart)
+	if wi < 0 {
+		return "", errors.New("vue d'envoi désalignée")
+	}
+	kept, desc := len(view.wire)-wi, ""
+	if kept > 0 {
+		desc = compactBoundaryDesc(view.wire, wi, msgs[tailStart])
+	}
+	instr := Message{Role: "user", Content: compactContInstruction(kept, desc, code)}
+	// Marge : contexte réel, la demande, le résumé, et 5 % de la fenêtre pour
+	// ce que l'estimation ne voit pas.
+	if need := view.used + msgTokens(instr) + compactSummaryBudget() + ctxWindow()*5/100; need > ctxWindow() {
+		return "", fmt.Errorf("marge insuffisante : %d jetons pour une fenêtre de %d", need, ctxWindow())
+	}
+	// Arguments du gabarit du tour, réflexion coupée : sur les gabarits
+	// hybrides (Qwen3…), enable_thinking ne change que l'ouverture de la
+	// réponse ; reasoning_effort, rendu dans le préfixe par gpt-oss, reste
+	// celui du tour.
+	kwargs := map[string]any{}
+	for k, v := range view.kwargs {
+		kwargs[k] = v
+	}
+	kwargs["enable_thinking"] = false
+	sent := append(append([]Message(nil), view.wire...), instr)
+	// tool_choice « none » : les outils restent rendus dans le prompt (le
+	// préfixe en cache tient), aucun appel n'est attendu.
+	payload := buildChatPayload(ep, sent, 0.2, chatPayloadOpts{
+		tools: view.tools, toolChoiceNone: true, effort: view.effort, kwargs: kwargs, noSampling: true,
+	})
+	payload["stream"] = false
+	delete(payload, "stream_options")
+	payload["max_tokens"] = compactSummaryBudget()
+	// SIDE_SLOT : elle prolonge le prompt du slot de la discussion, elle y va.
+	setEngineSlot(payload, engineSlotFor(ep, true))
+	ch, err := postSummary(ctx, ep, payload, perfTag{kind: perfCompact, conv: view.conv})
+	if err != nil {
+		// Refus de la requête elle-même (gabarit à alternance stricte, champ
+		// inconnu…) : il se reproduirait à chaque compaction. Une fenêtre
+		// pleine, un moteur en chargement ou une coupure réseau, non.
+		var he *summaryHTTPError
+		if errors.As(err, &he) && (he.status == 400 || he.status == 422 || he.status == 500) && !contextOverflow(he.body, nil) {
+			compactContFail(true)
+		}
+		return "", err
+	}
+	if len(ch.Message.ToolCalls) > 0 {
+		compactContFail(true)
+		return "", errors.New("appel d'outil émis au lieu d'un résumé")
+	}
+	if textualToolCallSnippet(ch.Message.Content) != "" {
+		compactContFail(false)
+		return "", errors.New("appel d'outil écrit en texte")
+	}
+	s, err := cleanSummary(ch.Message.Content, ch.Message.ReasoningContent, ch.FinishReason)
+	if err != nil {
+		compactContFail(false)
+		return "", err
+	}
+	if summaryLooksEmpty(s) {
+		compactContFail(false)
+		return "", errors.New("résumé vide")
+	}
+	compactContOK()
+	return s, nil
+}

internal/loki/chat_compact_cont_test.go

@@ -0,0 +1,680 @@
+package loki
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"reflect"
+	"strings"
+	"sync"
+	"testing"
+)
+
+// oldCompactorSys : le prompt du résumeur tel qu'il était avant le partage de
+// ses règles avec la continuation — copie figée, à l'octet près.
+const oldCompactorSys = `You are a context compactor. You are given the transcript of the older turns of a conversation between a user and an AI assistant (with its tools). The PURPOSE of your summary is to let the conversation continue in a fresh, smaller context WITHOUT losing any information that is useful or important to understand what came before and keep working — preserve everything that matters, drop only what is redundant.
+
+The assistant is MID-TASK: it will read your summary and must resume exactly where it left off, WITHOUT redoing work it has already done. Its own internal reasoning is NOT part of the transcript and is lost — your summary is the only memory it keeps.
+
+Summarize densely and faithfully, keeping ONLY the essentials:
+- The user's CURRENT request, goal(s) and constraints
+- FINDINGS: the concrete information already gathered — facts, figures, dates, names, URLs, file paths, values, config. This is the most important part: whatever is not here is lost and will have to be looked up again.
+- Sources already consulted (URLs opened, files read, commands run) — so they are not consulted a second time
+- Decisions made and established facts
+- STATE OF PROGRESS: what is already answered, what is still missing, and the next concrete step
+Strict rules: no preamble or conclusion, no verbatim or long quotes, no throwaway detail. Use short bullet points. Be as concise as you can WHILE keeping every fact, decision and still-open task: a detail you drop here is lost for good, so when in doubt keep it. This is a dense compression summary, not a report. Always write ACTUAL prose sentences/bullets — never answer with just an id or a reference.
+Write the summary in the SAME language as the conversation.`
+
+const contSummary = "- L'utilisateur prépare un voyage à Lyon ; horaires trouvés : départ 8 h 12, arrivée 10 h 05."
+
+// moteurCont : faux llama-server. Tours streamés : « ok. ». Résumés :
+// contSummary ; pour la continuation, contStatus (refus) ou contReply s'ils
+// sont posés.
+type moteurCont struct {
+	mu         sync.Mutex
+	bodies     []string
+	contStatus int
+	contReply  map[string]any
+}
+
+func (m *moteurCont) start(t *testing.T) {
+	t.Helper()
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		var buf bytes.Buffer
+		_, _ = buf.ReadFrom(r.Body)
+		body := buf.String()
+		switch r.URL.Path {
+		case "/health":
+			sendJSON(w, 200, map[string]any{"status": "ok"})
+			return
+		case "/props":
+			sendJSON(w, 200, map[string]any{"total_slots": 1, "build_info": "b9000-x"})
+			return
+		}
+		m.mu.Lock()
+		m.bodies = append(m.bodies, body)
+		status, reply := m.contStatus, m.contReply
+		m.mu.Unlock()
+		if strings.Contains(body, `"stream":true`) {
+			w.Header().Set("Content-Type", "text/event-stream")
+			_, _ = w.Write([]byte(sseChunk("ok.") + sseFinal("stop", 100, 2) + "data: [DONE]\n\n"))
+			return
+		}
+		if isContBody(body) {
+			if status != 0 {
+				sendJSON(w, status, map[string]any{"error": map[string]any{"message": "template error"}})
+				return
+			}
+			if reply != nil {
+				sendJSON(w, 200, reply)
+				return
+			}
+		}
+		sendJSON(w, 200, map[string]any{
+			"choices": []any{map[string]any{"message": map[string]any{"content": contSummary}, "finish_reason": "stop"}},
+			"usage":   map[string]any{"prompt_tokens": 900, "completion_tokens": 40},
+			"timings": map[string]any{"prompt_n": 30, "cache_n": 870, "predicted_n": 40},
+		})
+	}))
+	t.Cleanup(srv.Close)
+	u, _ := url.Parse(srv.URL)
+	if err := SetConfigKey("PORT", u.Port()); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func isContBody(body string) bool {
+	var p struct {
+		Messages []Message `json:"messages"`
+	}
+	_ = json.Unmarshal([]byte(body), &p)
+	n := len(p.Messages)
+	return n > 0 && strings.HasPrefix(msgText(p.Messages[n-1]), compactContPrefix)
+}
+
+func isTranscriptBody(body string) bool {
+	var p struct {
+		Messages []Message `json:"messages"`
+	}
+	_ = json.Unmarshal([]byte(body), &p)
+	return len(p.Messages) == 2 && p.Messages[0].Role == "system" &&
+		strings.HasPrefix(msgText(p.Messages[0]), "You are a context compactor.")
+}
+
+func (m *moteurCont) all() []string {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	return append([]string(nil), m.bodies...)
+}
+
+// contReset : état global de la continuation remis à neuf.
+func contReset(t *testing.T) {
+	reset := func() {
+		engineGate.mu.Lock()
+		engineGate.main = engineMainStamp{}
+		engineGate.mu.Unlock()
+		compactContFails.mu.Lock()
+		compactContFails.m = nil
+		compactContFails.mu.Unlock()
+		compactRefused.mu.Lock()
+		compactRefused.m = nil
+		compactRefused.mu.Unlock()
+	}
+	reset()
+	t.Cleanup(reset)
+}
+
+func contSetup(t *testing.T, keys map[string]string) *moteurCont {
+	t.Helper()
+	withWorkspace(t)
+	activeProjMu.Lock()
+	activeProjCache = ""
+	activeProjMu.Unlock()
+	setProjectOverride("")
+	t.Cleanup(func() {
+		activeProjMu.Lock()
+		activeProjCache = ""
+		activeProjMu.Unlock()
+		setProjectOverride("")
+	})
+	ensureDefaultProject()
+	freshTplProbe(t)
+	convEnsureActive()
+	contReset(t)
+	if err := SetConfigKey("MODEL", "/models/"+echoTestModel); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetConfigKey("CTX", "8192"); err != nil {
+		t.Fatal(err)
+	}
+	for k, v := range keys {
+		if err := SetConfigKey(k, v); err != nil {
+			t.Fatal(err)
+		}
+	}
+	m := &moteurCont{}
+	m.start(t)
+	return m
+}
+
+// contHistory : une longue discussion, de quoi compacter.
+func contHistory() []Message {
+	var h []Message
+	for i := 0; i < 10; i++ {
+		h = append(h, um("question "+string(rune('a'+i))+" "+strings.Repeat("u", 1500)),
+			am("réponse "+string(rune('a'+i))+" "+strings.Repeat("r", 1500)))
+	}
+	return h
+}
+
+// contTwoTurns : un premier tour sans compaction (il pose le tampon du slot),
+// puis un second dont le début compacte. Rend les corps envoyés pendant le
+// second tour, et celui du premier tour.
+func contTwoTurns(t *testing.T, m *moteurCont, c *Conversation, caps Caps) (first string, second []string) {
+	t.Helper()
+	c.mu.Lock()
+	c.Messages = contHistory()
+	c.CtxUsed, c.ctxUsedLen = 1000, len(c.Messages)
+	c.mu.Unlock()
+	prewarmTurn(t, c, caps, "première demande")
+	bodies := m.all()
+	if len(bodies) != 1 {
+		t.Fatalf("premier tour : 1 requête attendue, %d", len(bodies))
+	}
+	c.mu.Lock()
+	c.CtxUsed, c.ctxUsedLen = 6200, len(c.Messages)
+	c.mu.Unlock()
+	prewarmTurn(t, c, caps, "deuxième demande")
+	return bodies[0], m.all()[1:]
+}
+
+// Sans la clé : la requête de résumé est celle d'avant — prompt du résumeur
+// identique à l'octet près, transcription, aucun champ de plus — et aucun
+// tampon de slot n'est posé.
+func TestCompactContDefautIdentique(t *testing.T) {
+	m := contSetup(t, map[string]string{"TOP_P": "0.9", "REASONING_EFFORT": "high"})
+	c := newTestConv()
+	_, second := contTwoTurns(t, m, c, Caps{Agent: true})
+	if len(second) != 2 || !isTranscriptBody(second[0]) {
+		t.Fatalf("sans la clé : résumé sur transcription puis tour attendus, %d requêtes", len(second))
+	}
+	var p map[string]any
+	if err := json.Unmarshal([]byte(second[0]), &p); err != nil {
+		t.Fatal(err)
+	}
+	want := map[string]any{"model": p["model"], "stream": false, "temperature": 0.2, "max_tokens": float64(700),
+		"chat_template_kwargs": map[string]any{"enable_thinking": false}, "messages": p["messages"]}
+	if !reflect.DeepEqual(p, want) {
+		t.Fatalf("champs du résumé changés : %v", p)
+	}
+	if sys := p["messages"].([]any)[0].(map[string]any)["content"]; sys != oldCompactorSys {
+		t.Fatalf("prompt du résumeur changé :\n%v", sys)
+	}
+	engineGate.mu.Lock()
+	stamp := engineGate.main
+	engineGate.mu.Unlock()
+	if stamp.seq != 0 {
+		t.Fatal("tampon de slot posé sans la clé")
+	}
+	if compactContinuationOn(ReadConfig()) || compactRefusedSkip(convActiveID(), 7000, nil) {
+		t.Fatal("continuation ou mémoire des refus active sans la clé")
+	}
+}
+
+// Avec la clé : la requête de résumé prolonge EXACTEMENT celle du premier tour
+// (même préfixe, mêmes outils et réglages du gabarit), plus la réponse rangée
+// et une seule demande de résumé ; sans l'échantillonnage du preset ; et rien
+// d'injecté n'entre dans l'historique.
+func TestCompactContPrefixeEtHistorique(t *testing.T) {
+	m := contSetup(t, map[string]string{"COMPACT_CONTINUATION": "on", "TOP_P": "0.9", "REASONING_EFFORT": "high"})
+	c := newTestConv()
+	first, second := contTwoTurns(t, m, c, Caps{Agent: true})
+	if len(second) != 2 || !isContBody(second[0]) {
+		t.Fatalf("continuation puis tour attendus, %d requêtes (transcription : %v)", len(second), len(second) > 0 && isTranscriptBody(second[0]))
+	}
+	var f, s map[string]any
+	if err := json.Unmarshal([]byte(first), &f); err != nil {
+		t.Fatal(err)
+	}
+	if err := json.Unmarshal([]byte(second[0]), &s); err != nil {
+		t.Fatal(err)
+	}
+	fm, sm := f["messages"].([]any), s["messages"].([]any)
+	if len(sm) != len(fm)+2 {
+		t.Fatalf("continuation : %d messages, premier tour %d (+ réponse + demande attendus)", len(sm), len(fm))
+	}
+	if !reflect.DeepEqual(sm[:len(fm)], fm) {
+		t.Fatal("la continuation ne prolonge pas la requête du premier tour")
+	}
+	if a := sm[len(fm)].(map[string]any); a["role"] != "assistant" || a["content"] != "ok." {
+		t.Fatalf("réponse rangée attendue après le préfixe : %v", a)
+	}
+	last := sm[len(sm)-1].(map[string]any)
+	if last["role"] != "user" || !strings.Contains(last["content"].(string), "STATE OF PROGRESS") {
+		t.Fatalf("demande de résumé : %v", last)
+	}
+	for _, k := range []string{"tools", "parallel_tool_calls", "reasoning_effort", "model"} {
+		if !reflect.DeepEqual(f[k], s[k]) {
+			t.Fatalf("champ %s : tour %v, continuation %v", k, f[k], s[k])
+		}
+	}
+	if s["tool_choice"] != "none" || s["stream"] != false || s["max_tokens"] != float64(700) ||
+		s["temperature"] != 0.2 || s["top_p"] != nil || s["stream_options"] != nil {
+		t.Fatalf("champs de réponse : %v", s)
+	}
+	if f["top_p"] != 0.9 {
+		t.Fatal("le tour lui-même doit garder l'échantillonnage du preset")
+	}
+	kw, _ := s["chat_template_kwargs"].(map[string]any)
+	if kw["enable_thinking"] != false || kw["reasoning_effort"] != "high" {
+		t.Fatalf("arguments du gabarit : %v", kw)
+	}
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	found := false
+	for _, msg := range c.Messages {
+		txt := msgText(msg)
+		if msg.Role == "system" || strings.HasPrefix(txt, compactContPrefix) || strings.Contains(txt, "<project_context>") {
+			t.Fatalf("message injecté rangé dans l'historique : %s %.80q", msg.Role, txt)
+		}
+		if strings.Contains(txt, contSummary) {
+			found = true
+		}
+	}
+	if !found {
+		t.Fatal("résumé absent de l'historique compacté")
+	}
+	kinds := false
+	for _, r := range perfLog.snapshot() {
+		if r.Kind == perfCompact && r.Conv == convActiveID() {
+			kinds = true
+		}
+	}
+	if !kinds {
+		t.Fatal("aucune complétion kind=compact rattachée à la discussion")
+	}
+}
+
+// contViewOpts : options en cours de tour pour msgs, slot tamponné pour conv.
+func contViewOpts(t *testing.T, msgs []Message, used int) compactOpts {
+	t.Helper()
+	end, seq := engineRequestBegin(nil)
+	end()
+	engineMarkMain(seq, "conv-test")
+	return compactOptsMid(ReadConfig(), resolveChatEndpoint(), "conv-test", msgs, used, nil, "", nil, echoPolicy{}, false)
+}
+
+func contMidMsgs() []Message {
+	return append([]Message{{Role: "system", Content: "SYS"}}, contHistory()...)
+}
+
+// Les replis : refus du moteur (gabarit), appel d'outil émis, marge
+// insuffisante, slot pris entre-temps — la compaction passe par la
+// transcription et réussit quand même. Un refus du gabarit ou un appel
+// d'outil suspend la continuation pour ce modèle.
+func TestCompactContReplis(t *testing.T) {
+	cases := []struct {
+		name     string
+		setup    func(m *moteurCont)
+		used     int
+		stale    bool
+		wantCont bool
+		disabled bool
+	}{
+		{"gabarit 500", func(m *moteurCont) { m.contStatus = 500 }, 5000, false, true, true},
+		{"appel d'outil", func(m *moteurCont) {
+			m.contReply = map[string]any{"choices": []any{map[string]any{"message": map[string]any{
+				"content": "", "tool_calls": []any{map[string]any{"id": "x", "type": "function"}}}, "finish_reason": "tool_calls"}}}
+		}, 5000, false, true, true},
+		{"raisonnement seul", func(m *moteurCont) {
+			m.contReply = map[string]any{"choices": []any{map[string]any{"message": map[string]any{
+				"content": "", "reasoning_content": "je réfléchis"}, "finish_reason": "length"}}}
+		}, 5000, false, true, false},
+		{"marge", func(*moteurCont) {}, 7500, false, false, false},
+		{"slot pris", func(*moteurCont) {}, 5000, true, false, false},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			m := contSetup(t, map[string]string{"COMPACT_CONTINUATION": "on"})
+			tc.setup(m)
+			msgs := contMidMsgs()
+			opt := contViewOpts(t, msgs, tc.used)
+			if opt.view == nil {
+				t.Fatal("vue attendue")
+			}
+			if tc.stale {
+				engineRequestStart()()
+			}
+			out, changed := compactMessagesNoted(context.Background(), msgs, Caps{}, opt)
+			if !changed {
+				t.Fatal("compaction refusée")
+			}
+			if out[0].Role != "system" || msgText(out[0]) != "SYS" || !strings.Contains(msgText(out[1]), contSummary) {
+				t.Fatalf("sortie inattendue : %v / %.80q", out[0], msgText(out[1]))
+			}
+			bodies := m.all()
+			cont := len(bodies) == 2 && isContBody(bodies[0]) && isTranscriptBody(bodies[1])
+			direct := len(bodies) == 1 && isTranscriptBody(bodies[0])
+			if tc.wantCont && !cont || !tc.wantCont && !direct {
+				t.Fatalf("requêtes inattendues (%d)", len(bodies))
+			}
+			if compactContDisabled() != tc.disabled {
+				t.Fatalf("suspension pour le modèle : %v, attendu %v", compactContDisabled(), tc.disabled)
+			}
+		})
+	}
+}
+
+// Deux résumés ratés de suite suspendent la continuation ; un réussi remet le
+// compte à zéro.
+func TestCompactContSuspension(t *testing.T) {
+	contSetup(t, map[string]string{"COMPACT_CONTINUATION": "on"})
+	compactContFail(false)
+	if compactContDisabled() {
+		t.Fatal("suspendue après un seul échec")
+	}
+	compactContOK()
+	compactContFail(false)
+	if compactContDisabled() {
+		t.Fatal("le succès n'a pas remis le compte à zéro")
+	}
+	compactContFail(false)
+	if !compactContDisabled() {
+		t.Fatal("pas suspendue après deux échecs")
+	}
+	if o := contViewOpts(t, contMidMsgs(), 5000); o.view != nil || !o.precheck {
+		t.Fatal("vue construite pour un modèle suspendu")
+	}
+}
+
+// Le tampon du slot : posé par une étape d'un tour de discussion, perdu dès
+// qu'une autre requête part (résumé, vérification, préchauffage…), ou que le
+// modèle ou la fenêtre changent.
+func TestEngineSlotHolds(t *testing.T) {
+	testHome(t)
+	contReset(t)
+	if err := SetConfigKey("MODEL", "/models/a.gguf"); err != nil {
+		t.Fatal(err)
+	}
+	mark := func() {
+		end, seq := engineRequestBegin(nil)
+		end()
+		engineMarkMain(seq, "c1")
+	}
+	mark()
+	if !engineSlotHolds("c1") || engineSlotHolds("c2") || engineSlotHolds("") {
+		t.Fatal("tampon mal lu")
+	}
+	engineRequestStart()()
+	if engineSlotHolds("c1") {
+		t.Fatal("tampon gardé après une autre requête")
+	}
+	// Une requête partie entre le départ et l'acceptation : pas de tampon.
+	end, seq := engineRequestBegin(nil)
+	end()
+	engineRequestStart()()
+	engineMarkMain(seq, "c1")
+	if engineSlotHolds("c1") {
+		t.Fatal("tampon posé pour une requête dépassée")
+	}
+	mark()
+	p := &prewarmRun{cancel: func() {}}
+	if endP, ok := prewarmBegin(p); ok {
+		endP()
+	}
+	if engineSlotHolds("c1") {
+		t.Fatal("tampon gardé après un préchauffage")
+	}
+	mark()
+	if err := SetConfigKey("MODEL", "/models/b.gguf"); err != nil {
+		t.Fatal(err)
+	}
+	if engineSlotHolds("c1") {
+		t.Fatal("tampon gardé après un changement de modèle")
+	}
+}
+
+// Une étape d'un sous-agent ou d'une vérification ne pose pas de tampon :
+// après elle, la compaction de fin de tour passe par la transcription.
+func TestCompactContPasApresVerification(t *testing.T) {
+	contSetup(t, map[string]string{"COMPACT_CONTINUATION": "on"})
+	end, seq := engineRequestBegin(nil)
+	end()
+	engineMarkMain(seq, convActiveID())
+	ctx := withPerf(context.Background(), perfMain, convActiveID())
+	if _, err := runChat(withPerfKind(ctx, perfVerify), []Message{um("vérifie")}, 0.2, Caps{}, func(StreamEvent) bool { return true }); err != nil {
+		t.Fatal(err)
+	}
+	if engineSlotHolds(convActiveID()) {
+		t.Fatal("tampon gardé après une vérification")
+	}
+	if _, err := runChat(ctx, []Message{um("suite")}, 0.2, Caps{}, func(StreamEvent) bool { return true }); err != nil {
+		t.Fatal(err)
+	}
+	if !engineSlotHolds(convActiveID()) {
+		t.Fatal("une étape du tour devrait poser le tampon")
+	}
+}
+
+// La correspondance des deux vues : messages système ajoutés ou déplacés,
+// les autres un pour un ; tout écart rend -1.
+func TestCompactWireIndex(t *testing.T) {
+	msgs := []Message{
+		{Role: "system", Content: memReminderPrefix + " pages"},
+		um("a"), atc("bash"), tm("r"), am("b"), um("c"),
+	}
+	wire := normalizeSystemMessages(append([]Message{{Role: "system", Content: "SYS"}, {Role: "system", Content: projectContextPrefix + " p"}}, msgs[:5]...))
+	v := &compactView{wire: wire, n: 5}
+	if wire[0].Role != "system" || len(wire) != 5 {
+		t.Fatalf("vue d'envoi : %v", wire)
+	}
+	for i, want := range map[int]int{1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 0: -1, 6: -1} {
+		if got := compactWireIndex(msgs, v, i); got != want {
+			t.Errorf("index %d : %d, attendu %d", i, got, want)
+		}
+	}
+	bad := append([]Message(nil), wire...)
+	bad[3] = am("x")
+	if compactWireIndex(msgs, &compactView{wire: bad, n: 5}, 2) != -1 {
+		t.Fatal("vue désalignée acceptée")
+	}
+	if compactWireIndex(msgs, &compactView{wire: wire[:4], n: 5}, 2) != -1 {
+		t.Fatal("vue tronquée acceptée")
+	}
+}
+
+// La frontière désignée : appel d'outil par son nom et ses arguments, texte
+// par son début, allongé s'il est déjà apparu plus haut.
+func TestCompactBoundaryDesc(t *testing.T) {
+	call := Message{Role: "assistant", ToolCalls: []ToolCall{{ID: "c1", Function: ToolCallFunc{Name: "web_read", Arguments: `{"url":"https://exemple.fr"}`}}}}
+	if d := compactBoundaryDesc(nil, 0, call); !strings.Contains(d, `web_read({"url":"https://exemple.fr"})`) {
+		t.Fatalf("appel d'outil : %s", d)
+	}
+	long := strings.Repeat("même début ", 10) + "fin unique"
+	wire := []Message{um(strings.Repeat("même début ", 10) + "autre fin"), um(long)}
+	d := compactBoundaryDesc(wire, 1, wire[1])
+	if !strings.Contains(d, "fin unique") {
+		t.Fatalf("début ambigu non allongé : %s", d)
+	}
+	if d := compactBoundaryDesc(nil, 0, um("court")); d != "the user message that starts with «court»" {
+		t.Fatalf("texte : %s", d)
+	}
+}
+
+// La demande de résumé reprend les règles du résumeur, et celles du mode Code.
+func TestCompactContInstruction(t *testing.T) {
+	s := compactContInstruction(3, "the user message that starts with «x»", true)
+	for _, want := range []string{compactContPrefix, compactSummaryRules, codeSummaryRules, "the last 3", "BEFORE the user message"} {
+		if !strings.Contains(s, want) {
+			t.Fatalf("demande sans %q", want)
+		}
+	}
+	if s := compactContInstruction(0, "", false); !strings.Contains(s, "whole conversation") || strings.Contains(s, "CODING") {
+		t.Fatal("demande sans frontière")
+	}
+}
+
+// Pré-contrôle : quand même un résumé vide ne réduirait pas de 20 %, aucun
+// résumé n'est demandé ni aucun bloc archivé ; sans lui (sans la clé), la
+// requête part comme avant, pour être refusée ensuite.
+func TestCompactHopeless(t *testing.T) {
+	m := contSetup(t, nil)
+	// Torse minuscule, queue énorme : rien à gagner.
+	msgs := []Message{um("a"), am("b"), um("c"), am(strings.Repeat("r", 40000))}
+	head, tailStart := compactBounds(msgs, int(float64(estimateTokens(msgs))*compactTailFrac))
+	if !compactHopeless(msgs, head, tailStart) {
+		t.Fatal("cas sans issue non reconnu")
+	}
+	if _, changed, _ := compactMessagesOpt(context.Background(), msgs, Caps{Agent: true}, compactOpts{precheck: true}); changed {
+		t.Fatal("compaction acceptée")
+	}
+	if n := len(m.all()); n != 0 {
+		t.Fatalf("résumé demandé malgré le pré-contrôle (%d requêtes)", n)
+	}
+	_, changed, refused := compactMessagesOpt(context.Background(), msgs, Caps{Agent: true}, compactOpts{})
+	if changed || !refused || len(m.all()) != 1 {
+		t.Fatalf("sans pré-contrôle : changed=%v refused=%v requêtes=%d", changed, refused, len(m.all()))
+	}
+	// Un refus après résumé est noté ; il n'arrête ni le filet réactif ni le
+	// bouton manuel (compactMessages, sans options), qui redemandent un résumé.
+	if _, changed := compactMessagesNoted(context.Background(), msgs, Caps{}, compactOpts{conv: "c9", used: 7000}); changed {
+		t.Fatal("compaction acceptée")
+	}
+	compactRefused.mu.Lock()
+	_, noted := compactRefused.m["c9"]
+	compactRefused.mu.Unlock()
+	if !noted {
+		t.Fatal("refus non noté")
+	}
+	if err := SetConfigKey("COMPACT_CONTINUATION", "on"); err != nil {
+		t.Fatal(err)
+	}
+	before := len(m.all())
+	compactMessages(context.Background(), msgs, Caps{})
+	if len(m.all()) != before+1 {
+		t.Fatal("le chemin réactif ne doit pas tenir compte des refus mémorisés")
+	}
+	// Un cas qui réussit n'est jamais déclaré sans issue.
+	h := contHistory()
+	head, tailStart = compactBounds(h, int(float64(estimateTokens(h))*compactTailFrac))
+	if compactHopeless(h, head, tailStart) {
+		t.Fatal("compaction faisable déclarée sans issue")
+	}
+}
+
+// Mémoire des refus : pas de nouvel essai avant +10 % de contexte, jamais à
+// 90 % de la fenêtre, oubliée quand le contexte baisse ou que l'historique est
+// réécrit ; rien sans la clé.
+func TestCompactRefusedSkip(t *testing.T) {
+	testHome(t)
+	contReset(t)
+	if err := SetConfigKey("CTX", "65536"); err != nil {
+		t.Fatal(err)
+	}
+	h := contHistory()
+	grown := append(append([]Message(nil), h...), um("suite"))
+	compactRefusedNote("c1", 50000, h)
+	if compactRefusedSkip("c1", 52000, grown) {
+		t.Fatal("sans la clé, aucun essai ne doit être sauté")
+	}
+	if err := SetConfigKey("COMPACT_CONTINUATION", "on"); err != nil {
+		t.Fatal(err)
+	}
+	if !compactRefusedSkip("c1", 52000, grown) || compactRefusedSkip("c2", 52000, grown) {
+		t.Fatal("refus mal appliqué")
+	}
+	if compactRefusedSkip("c1", 59000, grown) {
+		t.Fatal("essai sauté à 90 % de la fenêtre")
+	}
+	if compactRefusedSkip("c1", 55000, grown) {
+		t.Fatal("essai sauté après +10 %")
+	}
+	if compactRefusedSkip("c1", 52000, grown) {
+		t.Fatal("refus non oublié après +10 %")
+	}
+	compactRefusedNote("c1", 50000, h)
+	if compactRefusedSkip("c1", 30000, grown) || compactRefusedSkip("c1", 50000, grown) {
+		t.Fatal("refus non oublié quand le contexte baisse")
+	}
+	// Historique réécrit (édition, régénération, discussion vidée puis
+	// regarnie) : même taille de contexte, autre fil — on retente.
+	compactRefusedNote("c1", 50000, h)
+	edited := append([]Message(nil), grown...)
+	edited[3] = um("message modifié")
+	if compactRefusedSkip("c1", 51000, edited) || compactRefusedSkip("c1", 51000, grown) {
+		t.Fatal("refus gardé pour un historique réécrit")
+	}
+	compactRefusedNote("c1", 50000, h)
+	if compactRefusedSkip("c1", 51000, h[:5]) {
+		t.Fatal("refus gardé pour un historique raccourci")
+	}
+	// Une compaction réussie l'efface.
+	compactRefusedNote("c1", 50000, h)
+	compactRefusedClear("c1")
+	if compactRefusedSkip("c1", 51000, grown) {
+		t.Fatal("refus non effacé")
+	}
+}
+
+// buildChatPayload : sans noSampling, l'échantillonnage du preset est posé
+// comme avant ; avec, il ne l'est pas.
+func TestBuildChatPayloadNoSampling(t *testing.T) {
+	testHome(t)
+	if err := SetConfigKey("TOP_P", "0.9"); err != nil {
+		t.Fatal(err)
+	}
+	ep := chatEndpoint{Model: "m"}
+	if p := buildChatPayload(ep, []Message{um("x")}, 0.7, chatPayloadOpts{}); p["top_p"] != 0.9 {
+		t.Fatalf("échantillonnage perdu : %v", p)
+	}
+	if p := buildChatPayload(ep, []Message{um("x")}, 0.2, chatPayloadOpts{noSampling: true}); p["top_p"] != nil || p["temperature"] != 0.2 {
+		t.Fatalf("échantillonnage posé malgré noSampling : %v", p)
+	}
+}
+
+// Corrections de relecture du lot 2 : une lecture passée par les proxys de
+// Loki (GET /v1/models, /health d'un client qui sonde) ne calcule rien dans un
+// slot — elle ne retire pas le tampon de la discussion et n'annule pas un
+// préchauffage. Une complétion de client, si.
+func TestProxyReadKeepsSlotStamp(t *testing.T) {
+	testHome(t)
+	contReset(t)
+	if err := SetConfigKey("MODEL", "/models/a.gguf"); err != nil {
+		t.Fatal(err)
+	}
+	end, seq := engineRequestBegin(nil)
+	end()
+	engineMarkMain(seq, "c1")
+	cancelled := false
+	p := &prewarmRun{cancel: func() { cancelled = true }}
+	endP, ok := prewarmBegin(p)
+	if !ok {
+		t.Fatal("préchauffage refusé, moteur libre")
+	}
+	defer endP()
+	// Le préchauffage retire lui-même le tampon : reposé à la main, pour voir
+	// ce que fait la lecture seule.
+	engineGate.mu.Lock()
+	engineGate.main.seq = engineGate.seq
+	engineGate.mu.Unlock()
+	for _, m := range []string{http.MethodGet, http.MethodHead} {
+		r := httptest.NewRequest(m, "/v1/models", nil)
+		engineProxyBegin(r, false)()
+	}
+	if cancelled {
+		t.Error("une lecture a annulé le préchauffage")
+	}
+	if !engineSlotHolds("c1") {
+		t.Error("une lecture a retiré le tampon de la discussion")
+	}
+	engineProxyBegin(httptest.NewRequest(http.MethodPost, "/v1/chat/completions", nil), false)()
+	if !cancelled {
+		t.Error("une complétion de client n'a pas annulé le préchauffage")
+	}
+	if engineSlotHolds("c1") {
+		t.Error("tampon gardé après une complétion de client")
+	}
+}

internal/loki/chat_conversation.go

@@ -67,6 +67,10 @@ type Conversation struct {
 	// persisté : un rechargement repart du seul CtxUsed, comme avant.
 	ctxUsedLen int
 	genPeak    int
+	// ProjSnap : bloc projet figé de la discussion et dernier état annoncé au
+	// modèle (PROJ_SNAPSHOT, chat_projsnap.go). nil = pas d'instantané : le
+	// prochain tour en prend un. Toujours nil sans la clé (JSON inchangé).
+	ProjSnap *projSnapshot `json:"proj_snap,omitempty"`
 
 	Generating bool               `json:"-"`
 	cancel     context.CancelFunc // annule la génération en cours (/stop)
@@ -80,6 +84,10 @@ type Conversation struct {
 	// benching : le verrou est tenu par un benchmark (llm_bench_job.go). Même
 	// logique que la tâche : l'interface et les refus disent qui occupe le moteur.
 	benching bool
+	// leaseWhy : le refus à donner tant que benching tient le verrou —
+	// errBenchBusy pour un bench, errTuneBusy pour l'optimiseur, qui prend le
+	// même verrou (backend_tune_job.go).
+	leaseWhy error
 
 	// File d'attente des messages envoyés PENDANT une génération (AJEAN
 	// 0.14.0). Ils sont injectés dans le tour en cours à la prochaine frontière
@@ -182,6 +190,8 @@ func LoadConversation() {
 	}
 	conv.mu.Lock()
 	defer conv.mu.Unlock()
+	// Unmarshal ne remet pas à zéro un champ absent du JSON.
+	conv.ProjSnap = nil
 	_ = json.Unmarshal(b, conv)
 	// Guérit les conversations d'avant le passage des captures en éphémère : un
 	// base64 d'image persisté était rejoué à chaque tour et dépassait le contexte.
@@ -212,6 +222,10 @@ func (c *Conversation) loadFrom(id string, b []byte) {
 	}
 	c.Messages, c.Log, c.Seq, c.CtxUsed = nil, nil, 0, 0
 	c.ctxUsedLen, c.genPeak = 0, 0
+	// Bloc figé de l'ancienne discussion : json.Unmarshal ne remet pas à zéro un
+	// champ absent, une discussion neuve (ou enregistrée sans lui) l'aurait hérité
+	// — avec la description et l'index d'un autre projet.
+	c.ProjSnap = nil
 	c.queued = nil // file de l'ancienne discussion : elle ne suit pas la bascule
 	if len(b) > 0 {
 		_ = json.Unmarshal(b, c)
@@ -340,6 +354,17 @@ func compactLog(log []LogEvent) []LogEvent {
 		if tu, ok := ev.Delta["tool_used"].(map[string]any); ok {
 			flush()
 			if done, _ := tu["done"].(bool); done {
+				// L'aperçu du navigateur (shot) n'est que du direct : on ne le
+				// garde pas une fois le tour fini (voir cu_autoshot.go).
+				if _, has := tu["shot"]; has {
+					cp := make(map[string]any, len(tu))
+					for k, v := range tu {
+						if k != "shot" {
+							cp[k] = v
+						}
+					}
+					ev.Delta = map[string]any{"tool_used": cp}
+				}
 				out = append(out, ev)
 			}
 			continue
@@ -379,9 +404,12 @@ func compactLog(log []LogEvent) []LogEvent {
 // messages donne ce que l'estimation ne voit pas (prompt système injecté,
 // schémas d'outils, gabarit de chat). On le rajoute à l'estimation d'après
 // compaction, sinon la jauge s'effondre puis resaute au tour suivant.
-func (c *Conversation) compactAndPublish(ctx context.Context, epoch int, phase string, msgs []Message, ctxUsed int, caps Caps) ([]Message, bool) {
+//
+// opt : options de COMPACT_CONTINUATION (chat_compact_cont.go) ; nulles, le
+// chemin d'avant.
+func (c *Conversation) compactAndPublish(ctx context.Context, epoch int, phase string, msgs []Message, ctxUsed int, caps Caps, opt compactOpts) ([]Message, bool) {
 	c.appendDelta(epoch, map[string]any{"compacting": true})
-	compacted, changed := compactMessages(ctx, msgs, caps)
+	compacted, changed := compactMessagesNoted(ctx, msgs, caps, opt)
 	c.appendDelta(epoch, map[string]any{"compacting": false})
 	logCompact(phase, ctxUsed, msgs, compacted, changed)
 	if !changed {
@@ -397,6 +425,12 @@ func (c *Conversation) compactAndPublish(ctx context.Context, epoch int, phase s
 	if caps.Agent {
 		compacted = remindReadMemPages(compacted, msgs)
 	}
+	// PROJ_SNAPSHOT : le début du prompt est réécrit, le bloc projet sera donc
+	// repris tout neuf au prochain tour (ProjSnap = nil). Les mises à jour déjà
+	// livrées le suivraient dans la queue gardée telle quelle, une vieille valeur
+	// après la fraîche : retirées ici, elles n'apprennent rien que le bloc neuf
+	// ne dise. Sans la clé, rien à retirer.
+	compacted = stripContextUpdates(compacted)
 	overhead := ctxUsed - estimateTokens(msgs)
 	if overhead < 0 {
 		overhead = 0
@@ -405,6 +439,7 @@ func (c *Conversation) compactAndPublish(ctx context.Context, epoch int, phase s
 	c.mu.Lock()
 	if c.epoch == epoch {
 		c.Messages = compacted
+		c.ProjSnap = nil
 		c.CtxUsed = est // le vrai compte reviendra avec les stats du prochain tour
 		c.ctxUsedLen = len(compacted)
 	}
@@ -414,6 +449,47 @@ func (c *Conversation) compactAndPublish(ctx context.Context, epoch int, phase s
 	return compacted, true
 }
 
+// historyFromView rend l'historique à ranger après une compaction en cours de
+// tour : la vue publiée (NewHistory), sans les messages système que la vue
+// d'envoi avait posés en tête — préambule et prompt du preset, consignes du
+// dépôt, contexte du projet ou bloc figé.
+//
+// Retirer TOUS les systèmes de tête effaçait aussi ceux de l'historique
+// lui-même : le rappel des pages mémoire lues ([MEMORY PAGES REMINDER]), posé
+// par une compaction de début de tour, disparaissait à la première compaction
+// en cours de tour, et le modèle perdait la liste des pages à relire. Un
+// système de tête n'est donc gardé que s'il figurait en tête de hist,
+// l'historique dont la vue est partie : la compaction garde la tête telle
+// quelle, et la vue d'envoi n'y ajoute que ses propres messages. Seule
+// exception, le premier : InjectSkills a pu fusionner le préambule devant un
+// système de l'historique (« préambule\n\nsystème ») — on rend alors celui-ci.
+func historyFromView(view, hist []Message) []Message {
+	own := map[string]int{}
+	for _, m := range hist {
+		if m.Role != "system" {
+			break
+		}
+		own[msgText(m)]++
+	}
+	var out []Message
+	i := 0
+	for ; i < len(view) && view[i].Role == "system"; i++ {
+		k := msgText(view[i])
+		if own[k] > 0 {
+			own[k]--
+			out = append(out, view[i])
+			continue
+		}
+		if i == 0 && len(hist) > 0 && hist[0].Role == "system" {
+			if h := msgText(hist[0]); h != "" && own[h] > 0 && strings.HasSuffix(k, "\n\n"+h) {
+				own[h]--
+				out = append(out, hist[0])
+			}
+		}
+	}
+	return append(out, view[i:]...)
+}
+
 // convState renvoie un instantané léger (pour /api/chat/state).
 func (c *Conversation) state() map[string]any {
 	c.mu.Lock()
@@ -455,9 +531,12 @@ var ErrBusy = fmt.Errorf("génération en cours")
 // nomme la tâche et on dit comment reprendre la main.
 func (c *Conversation) busyReason() error {
 	c.mu.Lock()
-	name, bench := c.runningTaskName, c.benching
+	name, bench, why := c.runningTaskName, c.benching, c.leaseWhy
 	c.mu.Unlock()
 	if bench {
+		if why != nil {
+			return why
+		}
 		return errBenchBusy
 	}
 	if name == "" {
@@ -477,6 +556,11 @@ var errModelLoading = fmt.Errorf("⏳ Le modèle est encore en train de charger
 // MODÈLE en tête du message, mais rendues comme pastilles dans la bulle : le fil
 // doit montrer ce que l'utilisateur a écrit, pas la consigne qu'on ajoute pour lui.
 func (c *Conversation) StartTurn(text string, files []attachInfo, caps Caps, temperature float64) error {
+	// Optimisation en cours (backend_tune_lock.go) : le vrai moteur est arrêté,
+	// « le modèle charge » serait faux — on dit pourquoi.
+	if err := tuneGuard(); err != nil {
+		return err
+	}
 	if !healthCheck() {
 		return errModelLoading
 	}
@@ -495,20 +579,19 @@ func (c *Conversation) StartTurn(text string, files []attachInfo, caps Caps, tem
 	if strings.TrimSpace(prompt) == "" {
 		prompt = "Prends-en connaissance."
 	}
+	askedCaps := caps
 	// Mode code : fige le rôle du tour (plan demandé → planner, sinon builder).
 	// La détection de bascule (puce « passer en mode Code ? ») est émise après
 	// la bulle utilisateur, plus bas.
-	if caps.Code && caps.Role == "" {
-		caps.Role = "builder"
-		if wantsPlan(text) {
-			caps.Role = "planner"
-		}
-	}
+	caps = withTurnRole(caps, text)
 	// Content = simple texte d'ordinaire ; format multimodal (texte + images) quand
 	// la vision est active et qu'une pièce jointe est une image (userMessageContent).
 	c.Messages = append(c.Messages, Message{Role: "user", Content: userMessageContent(files, prompt)})
 	epoch := c.epoch
 	c.mu.Unlock()
+	// Capacités demandées pour ce tour, retenues en mémoire (jamais persistées)
+	// pour préchauffer le suivant (PREWARM, chat_prewarm.go).
+	prewarmNoteCaps(convActiveID(), askedCaps)
 
 	// Borne de tour + bulle utilisateur (rejouables). Persistée tout de suite
 	// (sur disque quelques ms plus tard, voir persistAsync) : si le process
@@ -746,9 +829,15 @@ func (c *Conversation) generate(ctx context.Context, caps Caps, temperature floa
 		// (pas d'extrait de réponse) : la notif transite par Apple/Google. Pas
 		// de notification après un « stop » (retour ci-dessus) : l'utilisateur
 		// est là et a coupé volontairement.
-		if !c.startQueuedIfAny() && hasPushSubs() {
+		started := c.startQueuedIfAny()
+		if !started && hasPushSubs() {
 			go sendPushToAll("Loki", "Réponse prête · "+fmtDurFR(time.Since(turnStart)))
 		}
+		// Plus rien ne suit : le prochain tour peut être préparé pendant que
+		// l'utilisateur lit (PREWARM, off par défaut — sans la clé, rien ne part).
+		if !started {
+			c.prewarmKick(prewarmTurnEnd)
+		}
 	}()
 	// Télémétrie : tout ce que ce tour envoie au moteur (étapes, compaction,
 	// sous-agents, vérification) est rattaché à la discussion active.
@@ -772,11 +861,20 @@ func (c *Conversation) generate(ctx context.Context, caps Caps, temperature floa
 	// d'affichage garde le fil complet. Le résumé est un appel modèle non streamé :
 	// il bloque plusieurs secondes AVANT que la vraie réponse commence, d'où la
 	// bannière de progression émise par compactAndPublish.
+	// KEEP_TURN_IMAGES (chat_keep_images.go) : images gardées retirées d'abord
+	// si le contexte le demande ou si elles ne doivent plus partir. Sans la
+	// clé, il n'y en a aucune : rien ne change.
+	msgs, ctxUsed = c.keptImagesTurnStart(epoch, msgs, ctxUsed, peak)
 	// Estimation de début de tour, comparée au premier compte réel du moteur
 	// (journal [ctx], seulement au-delà de 2 % d'écart).
 	startEst := ctxUsed
-	if compactNeeded(msgs, ctxUsed, peak) {
-		if out, changed := c.compactAndPublish(ctx, epoch, "début-tour", msgs, ctxUsed, caps); changed {
+	// COMPACT_CONTINUATION (off par défaut) : un refus récent n'est pas retenté
+	// tout de suite, et le résumé peut prolonger le prompt en cache. Sans la
+	// clé, ni l'un ni l'autre.
+	conv := perfTagOf(ctx).conv
+	if compactNeeded(msgs, ctxUsed, peak) && !compactRefusedSkip(conv, ctxUsed, msgs) {
+		opt := c.compactOptsFor(caps, msgs, ctxUsed, conv)
+		if out, changed := c.compactAndPublish(ctx, epoch, "début-tour", msgs, ctxUsed, caps, opt); changed {
 			msgs = out
 			// Le chiffre d'avant compaction ne dit plus rien de la requête qui
 			// part : on compare celui que la compaction vient de poser.
@@ -797,21 +895,23 @@ func (c *Conversation) generate(ctx context.Context, caps Caps, temperature floa
 	// agent, on veut parler au modèle nu, comme à un llama-server direct. Le
 	// prompt du preset et l'index mémoire décrivent des outils que ce mode n'a
 	// pas : le modèle se mettait à écrire des <tool_call> en clair.
-	final := msgs
-	if caps.Agent {
-		final = append(projectSystemMessages(), msgs...)
-		if m, ok := codeInstructionsMessage(caps); ok {
-			final = append([]Message{m}, final...)
-		}
-		if sp := readSysPrompt(); sp != "" {
-			final = append([]Message{{Role: "system", Content: sp}}, final...)
-		}
+	//
+	// Assemblage dans turnView (chat_projsnap.go) : avec PROJ_SNAPSHOT, le bloc
+	// projet est celui, figé, de la discussion, et ses changements partent en
+	// tête de ce message — après la compaction de début de tour, sous c.mu.
+	sent, tools, snapTurn := c.turnView(caps, epoch, msgs, caps.Agent)
+	hist := msgs // l'historique d'où part la vue : voir historyFromView
+	runCtx := ctx
+	if snapTurn != nil {
+		runCtx = withProjSnapTurn(ctx, snapTurn)
 	}
 
 	// newBase : vue modèle publiée par une compaction survenue PENDANT le tour.
 	// Non-nil = elle remplace l'historique (elle contient déjà le tour en cours).
 	var newBase []Message
 	var content strings.Builder
+	// echo : raisonnement de la réponse finale (REASONING_ECHO), rangé avec elle.
+	var echo *ReasoningEcho
 	// Le comptage EXACT du contexte vient de `usage.prompt_tokens` (option
 	// include_usage). Tous les moteurs ne le renvoient pas — un llama-server
 	// récent a cessé de le faire, et la jauge est restée bloquée à zéro sur des
@@ -823,8 +923,7 @@ func (c *Conversation) generate(ctx context.Context, caps Caps, temperature floa
 	// asked : le tour s'est terminé sur une question à l'utilisateur (outil ask) —
 	// pas de vérification du mode Code avant sa réponse.
 	asked := false
-	sent, tools := prepareTurn(final, caps)
-	extra, _ := runChatTools(ctx, sent, tools, temperature, caps, func(ev StreamEvent) bool {
+	extra, _ := runChatTools(runCtx, sent, tools, temperature, caps, func(ev StreamEvent) bool {
 		switch {
 		case ev.Err != nil:
 			c.appendDelta(epoch, map[string]any{"error": ev.Err.Error()})
@@ -857,6 +956,9 @@ func (c *Conversation) generate(ctx context.Context, caps Caps, temperature floa
 			if ev.ToolUsed.Image != "" {
 				tu["image"] = ev.ToolUsed.Image
 			}
+			if ev.ToolUsed.Shot != "" {
+				tu["shot"] = ev.ToolUsed.Shot
+			}
 			// Aperçu seulement dans le flux : taille réelle + id pour « voir plus ».
 			if ev.ToolUsed.ResultChars > 0 {
 				tu["result_chars"] = ev.ToolUsed.ResultChars
@@ -867,15 +969,14 @@ func (c *Conversation) generate(ctx context.Context, caps Caps, temperature floa
 			c.appendDelta(epoch, map[string]any{"tool_used": tu})
 		case ev.NewHistory != nil:
 			// Compaction faite en cours de tour : elle remplace la base au lieu de
-			// s'ajouter à l'ancienne (voir StreamEvent.NewHistory). On retire le
-			// préfixe système injecté à la volée (prompt perso + skills, fusionnés en
-			// UN message system en tête) : il n'appartient pas à l'historique persisté
-			// et doit rester modifiable à chaud.
-			base := ev.NewHistory
-			for len(base) > 0 && base[0].Role == "system" {
-				base = base[1:]
-			}
-			newBase = append([]Message(nil), base...)
+			// s'ajouter à l'ancienne (voir StreamEvent.NewHistory). On retire ce
+			// que la vue d'envoi a posé en tête (prompt perso + préambule, contexte
+			// du projet) : il n'appartient pas à l'historique persisté et doit
+			// rester modifiable à chaud. Le rappel des pages lues, lui, en fait
+			// partie (historyFromView).
+			newBase = historyFromView(ev.NewHistory, hist)
+		case ev.Echo != nil:
+			echo = ev.Echo
 		case ev.Compacting != nil:
 			// Compaction déclenchée pendant la boucle d'outils : même bannière que la
 			// compaction de début de tour.
@@ -923,9 +1024,14 @@ func (c *Conversation) generate(ctx context.Context, caps Caps, temperature floa
 		if newBase != nil {
 			c.Messages = newBase
 		}
+		// Bloc projet rafraîchi par une compaction en cours de tour
+		// (PROJ_SNAPSHOT) : c'est lui que le tour suivant renvoie.
+		if s := snapTurn.takeRefreshed(); s != nil {
+			c.ProjSnap = s
+		}
 		c.Messages = append(c.Messages, extra...)
 		if s := content.String(); strings.TrimSpace(s) != "" {
-			c.Messages = append(c.Messages, Message{Role: "assistant", Content: s})
+			c.Messages = append(c.Messages, withEcho(Message{Role: "assistant", Content: s}, echo))
 		}
 		// Rappel de loki resté sans réponse (stop, erreur) ou collé à un autre
 		// user : retiré, sinon deux `user` d'affilée au tour suivant.
@@ -980,12 +1086,20 @@ func (c *Conversation) generate(ctx context.Context, caps Caps, temperature floa
 	// retombe tout de suite et le tour suivant démarre avec de la marge.
 	// Sauf si un Reset est passé (rien à compacter) ou si le tour a été annulé
 	// (bouton stop) : on n'enchaîne pas plusieurs secondes de résumé sur un stop.
-	if stale || ctx.Err() != nil || !compactNeeded(msgs, ctxUsed, peak) {
+	// KEEP_TURN_IMAGES : comme en début de tour, les images gardées partent
+	// d'abord si le contexte le demande, et le résumé ne suit que s'il reste
+	// nécessaire. Sans la clé, aucune image gardée : rien ne change.
+	if !stale && ctx.Err() == nil {
+		msgs, ctxUsed = c.keptImagesTurnStart(epoch, msgs, ctxUsed, peak)
+	}
+	if stale || ctx.Err() != nil || !compactNeeded(msgs, ctxUsed, peak) || compactRefusedSkip(conv, ctxUsed, msgs) {
 		return
 	}
 	// context.Background() et non ctx : le tour est terminé, son contexte peut
-	// être annulé alors que cette compaction-là doit aller au bout.
-	c.compactAndPublish(context.Background(), epoch, "fin-tour", msgs, ctxUsed, caps)
+	// être annulé alors que cette compaction-là doit aller au bout. Après une
+	// vérification du mode Code, le slot porte son prompt : pas de
+	// continuation (engineSlotHolds), transcription comme avant.
+	c.compactAndPublish(context.Background(), epoch, "fin-tour", msgs, ctxUsed, caps, c.compactOptsFor(caps, msgs, ctxUsed, conv))
 }
 
 // ctxNowLocked : contexte à juger pour compacter, c.mu tenu. llama-server
@@ -1006,6 +1120,9 @@ func (c *Conversation) ctxNowLocked(msgs []Message, local bool) int {
 // événements passent par le flux d'abonnement, donc tous les appareils voient la
 // progression. Renvoie ErrBusy si un tour est déjà en cours.
 func (c *Conversation) CompactNow() error {
+	if err := tuneGuard(); err != nil {
+		return err
+	}
 	if !healthCheck() {
 		return errModelLoading
 	}
@@ -1034,7 +1151,7 @@ func (c *Conversation) CompactNow() error {
 			}
 			c.mu.Unlock()
 		}()
-		if _, changed := c.compactAndPublish(ctx, epoch, "manuel", msgs, lastReal, Caps{}); changed {
+		if _, changed := c.compactAndPublish(ctx, epoch, "manuel", msgs, lastReal, Caps{}, compactOpts{}); changed {
 			c.persist()
 		}
 	}()
@@ -1076,9 +1193,11 @@ func (c *Conversation) Reset() {
 	c.Seq = 0
 	c.CtxUsed = 0
 	c.ctxUsedLen, c.genPeak = 0, 0
+	c.ProjSnap = nil
 	c.epoch++
 	c.Generating = false
 	c.benching = false // Stop a annulé le bench : le verrou est rendu ici
+	c.leaseWhy = nil
 	c.cancel = nil
 	c.queued = nil // les messages en attente visaient le fil qu'on vient de vider
 	c.cond.Broadcast()

internal/loki/chat_envctx.go

@@ -0,0 +1,116 @@
+package loki
+
+// chat_envctx.go — PROJ_SNAPSHOT : la date et le dossier de travail sortent du
+// prompt système pour entrer dans le bloc projet figé de la discussion.
+//
+// Pourquoi. Le système (préambule + briefing machine) et les outils forment le
+// début de chaque requête ; tant qu'ils ne bougent pas, le moteur reprend son
+// cache. Deux valeurs y bougeaient pourtant : la date — à minuit, tout le prompt
+// d'une discussion en cours est recalculé — et le dossier de travail, propre à
+// chaque discussion — deux discussions ne partageaient donc rien, pas même le
+// système. Avec la clé, le système ne garde que des consignes (« ton dossier de
+// travail est dans ton contexte ») et les valeurs partent dans le bloc projet,
+// en tête du premier message utilisateur, avec le reste du contexte figé.
+//
+// Rien n'est mémorisé au-delà du bloc lui-même : chaque tour relit la date, le
+// dossier et la cible, et tout écart part en <context_update> dans le message
+// suivant — une ligne pour un changement de jour, le bloc entier sinon (poste
+// distant passé hors ligne, autre cible, autre dossier). Les mêmes faits, à une
+// autre place ; aucun n'est retenu par Loki plus longtemps qu'avant.
+//
+// Seul un tour de discussion avec la clé y passe (assembleTurn pose
+// caps.envInCtx). Une tâche planifiée, un sous-agent, la vérification du mode
+// Code, le terminal gardent leur système d'avant, date et dossier compris.
+
+import (
+	"strings"
+	"time"
+)
+
+// envContextPrefix ouvre le message (isProjectSystem le range avec le contexte
+// du projet). Assez particulier pour qu'aucun prompt de preset ne commence ainsi.
+const envContextPrefix = "Environment (from Loki)"
+
+// nodeOfflineLine : l'avertissement d'un poste distant hors ligne — dans le
+// système sans la clé, dans le bloc projet avec.
+const nodeOfflineLine = "⚠ It is currently OFFLINE: those tools will fail until it reconnects. Tell the user instead of trying repeatedly."
+
+// envNow : l'horloge du bloc (remplaçable en test).
+var envNow = time.Now
+
+// envDateLine : la date du jour, avec l'année et l'année périmée que la
+// consigne web du système désignait jusque-là par leur valeur.
+func envDateLine(day string) string {
+	year := day
+	if len(day) >= 4 {
+		year = day[:4]
+	}
+	return "Date: " + day + " (the current year is " + year + ", not " + prevYear(year) + ")."
+}
+
+// envMachineFacts : les valeurs du briefing machine qui varient — dossier de la
+// discussion, ou poste distant (nom, système, dossier, état). "" sans agent.
+// Les consignes qui les accompagnent restent dans machineSystemPrompt.
+func envMachineFacts(caps Caps) string {
+	if !caps.Agent {
+		return ""
+	}
+	if tgt, ok := nodeTargetMetaGet(); ok {
+		s := "Machine: REMOTE node " + tgt.name
+		if tgt.os != "" {
+			s += " (" + tgt.os + ")"
+		}
+		if tgt.root != "" {
+			s += ", working folder " + tgt.root
+		}
+		s += "."
+		if !tgt.connected {
+			s += " " + nodeOfflineLine
+		}
+		return s
+	}
+	if cwd := agentCwd(); cwd != "" {
+		return "Working folder (cwd): " + cwd + "."
+	}
+	return ""
+}
+
+// envCapture : la date (si le préambule en portait une) et les valeurs machine
+// de ce tour.
+func envCapture(caps Caps) (day, facts string) {
+	if caps.Agent || caps.Mem != MemOff {
+		day = envNow().Format("2006-01-02")
+	}
+	return day, envMachineFacts(caps)
+}
+
+// envContextMessage : le message du bloc, ok=false s'il n'a rien à dire.
+func envContextMessage(day, facts string) (Message, bool) {
+	var lines []string
+	if day != "" {
+		lines = append(lines, envDateLine(day))
+	}
+	if facts != "" {
+		lines = append(lines, facts)
+	}
+	if len(lines) == 0 {
+		return Message{}, false
+	}
+	return Message{Role: "system", Content: envContextPrefix + ":\n" + strings.Join(lines, "\n")}, true
+}
+
+// envDelta : la mise à jour entre l'environnement annoncé et le vivant. Un
+// changement de jour seul tient en une ligne ; tout autre écart renvoie le
+// message entier.
+func envDelta(oldDay, oldFacts, day, facts string) string {
+	switch {
+	case oldFacts == facts && oldDay == day:
+		return ""
+	case oldFacts == facts && day != "" && oldDay != "":
+		return "New day — " + envDateLine(day) + "\n"
+	}
+	if m, ok := envContextMessage(day, facts); ok {
+		return "Current version, replaces any earlier one — " + msgText(m) + "\n"
+	}
+	return "Environment: removed.\n"
+}

internal/loki/chat_envctx_test.go

@@ -0,0 +1,185 @@
+package loki
+
+import (
+	"encoding/json"
+	"os"
+	"os/user"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+// sysPlaceholders remplace dans un prompt système les valeurs propres à la
+// machine et au jour (date, année, hôte, utilisateur, dossiers) par des jetons
+// fixes : ce qui reste doit être identique, octet pour octet, d'une machine à
+// l'autre.
+func sysPlaceholders(s string) string {
+	now := time.Now()
+	year := now.Format("2006")
+	host, _ := os.Hostname()
+	if host == "" {
+		host = "unknown"
+	}
+	who := ""
+	if u, err := user.Current(); err == nil {
+		who = u.Username
+	}
+	pairs := []string{
+		now.Format("2006-01-02"), "<DATE>",
+		scriptsDir(), "<SCRIPTS>",
+		agentCwd(), "<CWD>",
+		"host=" + host, "host=<HOST>",
+		runtime.GOOS + "/" + runtime.GOARCH, "<OS>/<ARCH>",
+		"The shell is " + agentTargetShellName(), "The shell is <SHELL>",
+	}
+	if who != "" {
+		pairs = append(pairs, "user="+who, "user=<USER>")
+	}
+	pairs = append(pairs, year, "<YEAR>", prevYear(year), "<PREVYEAR>")
+	for i := 0; i < len(pairs); i += 2 {
+		s = strings.ReplaceAll(s, pairs[i], pairs[i+1])
+	}
+	return s
+}
+
+func sysOf(t *testing.T, msgs []Message) string {
+	t.Helper()
+	if len(msgs) == 0 || msgs[0].Role != "system" {
+		t.Fatalf("pas de système en tête : %+v", msgs)
+	}
+	s, _ := msgs[0].Content.(string)
+	return s
+}
+
+// Gabarits du système SANS PROJ_SNAPSHOT, relevés sur le code d'avant le
+// déplacement de la date et du dossier de travail : ils ne doivent pas bouger
+// d'un octet (valeurs du jour et de la machine remplacées par des jetons).
+var sysGolden = map[string]string{
+	"agent":    "You are Loki, an expert assistant operating directly on this machine with real tools. You evolve with every conversation: you actively maintain a persistent memory so nothing useful is lost between sessions.\n\nThe shell is <SHELL>: use its syntax.\n\nManaging your memory is part of the job, not optional:\n- Save anything worth keeping (a preference, fact, decision, how-to) with mem_add, or mem_edit to update a page — on your own, without being asked.\n- The memory index (page list) is in your context: when a page looks relevant, mem_read it directly. mem_search is only for finding something by content.\nFor anything about the system or files, use bash instead of guessing. Act immediately — call the right tool, then answer. Never end your turn after only thinking. Be concise.\nTo give the user a file, link it in Markdown with its path relative to your working directory — [le rapport](rapport.pdf) — which downloads it. A raw server path is useless: they read you in a browser.\nYou can schedule work for yourself with task_create — only for what must recur or happen later, never a one-off you can do now. A script from your scripts folder runs as a task with no model at all.\n\nDate: <DATE>\n\nMachine: host=<HOST>, <OS>/<ARCH>, user=<USER>, cwd=<CWD>. This is your working folder: relative paths in write/edit/bash resolve here, and it is the DEFAULT place for scratch work — notes, outputs, a clone, a test. But it is DISPOSABLE: deleting the discussion wipes it. Any script you want to KEEP (or schedule), write it into your scripts folder <SCRIPTS> instead — a separate folder a workspace wipe won't touch; you write and run scripts there normally. Do NOT install or write files into system directories such as /usr/local/bin, /usr, /bin or /etc: those need root and are not yours. Only use an absolute path outside this folder (except your scripts folder) when the user explicitly named that location.",
+	"internet": "You are Loki, an expert assistant operating directly on this machine with real tools. You evolve with every conversation: you actively maintain a persistent memory so nothing useful is lost between sessions.\n\nThe shell is <SHELL>: use its syntax.\n\nManaging your memory is part of the job, not optional:\n- Save anything worth keeping (a preference, fact, decision, how-to) with mem_add, or mem_edit to update a page — on your own, without being asked.\n- The memory index (page list) is in your context: when a page looks relevant, mem_read it directly. mem_search is only for finding something by content.\nFor anything about the system or files, use bash instead of guessing. Act immediately — call the right tool, then answer. Never end your turn after only thinking. Be concise.\nTo give the user a file, link it in Markdown with its path relative to your working directory — [le rapport](rapport.pdf) — which downloads it. A raw server path is useless: they read you in a browser.\nYou can schedule work for yourself with task_create — only for what must recur or happen later, never a one-off you can do now. A script from your scripts folder runs as a task with no model at all.\n\nWeb: web_open first, then web_read/web_grep on it.\nYour training data is stale. For ANY question about recent/latest/current things (releases, versions, news, prices, scores, 'since when') call web_search BEFORE writing any date or version, and match what you actually read.\nToday is in <YEAR>. If a query needs a year use ONLY <YEAR>, never a remembered past year like <PREVYEAR> — it biases results toward stale pages; better still, omit the year. Don't hedge ('probably') about a fact a tool can verify — search instead.\n\nDate: <DATE>\n\nMachine: host=<HOST>, <OS>/<ARCH>, user=<USER>, cwd=<CWD>. This is your working folder: relative paths in write/edit/bash resolve here, and it is the DEFAULT place for scratch work — notes, outputs, a clone, a test. But it is DISPOSABLE: deleting the discussion wipes it. Any script you want to KEEP (or schedule), write it into your scripts folder <SCRIPTS> instead — a separate folder a workspace wipe won't touch; you write and run scripts there normally. Do NOT install or write files into system directories such as /usr/local/bin, /usr, /bin or /etc: those need root and are not yours. Only use an absolute path outside this folder (except your scripts folder) when the user explicitly named that location.",
+	"ondemand": "You are Loki, an expert assistant operating directly on this machine with real tools.\n\nThe shell is <SHELL>: use its syntax.\n\nMemory is ON-DEMAND: you have the mem_* tools but do NOT read or write memory on your own. Call mem_search/mem_read only when the user explicitly asks you to recall or look something up, and mem_add/mem_edit only when the user explicitly asks you to remember something. Otherwise leave memory untouched and answer directly.\nFor anything about the system or files, use bash instead of guessing. Act immediately — call the right tool, then answer. Never end your turn after only thinking. Be concise.\nTo give the user a file, link it in Markdown with its path relative to your working directory — [le rapport](rapport.pdf) — which downloads it. A raw server path is useless: they read you in a browser.\nYou can schedule work for yourself with task_create — only for what must recur or happen later, never a one-off you can do now. A script from your scripts folder runs as a task with no model at all.\n\nDate: <DATE>\n\nMachine: host=<HOST>, <OS>/<ARCH>, user=<USER>, cwd=<CWD>. This is your working folder: relative paths in write/edit/bash resolve here, and it is the DEFAULT place for scratch work — notes, outputs, a clone, a test. But it is DISPOSABLE: deleting the discussion wipes it. Any script you want to KEEP (or schedule), write it into your scripts folder <SCRIPTS> instead — a separate folder a workspace wipe won't touch; you write and run scripts there normally. Do NOT install or write files into system directories such as /usr/local/bin, /usr, /bin or /etc: those need root and are not yours. Only use an absolute path outside this folder (except your scripts folder) when the user explicitly named that location.",
+	"memseule": "You are Loki, an expert assistant operating directly on this machine with real tools. You evolve with every conversation: you actively maintain a persistent memory so nothing useful is lost between sessions.\n\n\nManaging your memory is part of the job, not optional:\n- Save anything worth keeping (a preference, fact, decision, how-to) with mem_add, or mem_edit to update a page — on your own, without being asked.\n- The memory index (page list) is in your context: when a page looks relevant, mem_read it directly. mem_search is only for finding something by content.\n\nDate: <DATE>",
+}
+
+func TestSystemeSansCleInchange(t *testing.T) {
+	projSnapSetup(t, false)
+	cases := map[string]Caps{
+		"agent":    {Agent: true, Mem: MemAlways},
+		"internet": {Agent: true, Internet: true, Mem: MemAlways},
+		"ondemand": {Agent: true, Mem: MemOnDemand},
+		"memseule": {Mem: MemAlways},
+	}
+	for name, caps := range cases {
+		got, _ := prepareTurn([]Message{um("salut")}, caps)
+		s := sysPlaceholders(sysOf(t, got))
+		if want, ok := sysGolden[name]; !ok || s != want {
+			t.Errorf("%s : système changé sans la clé\nreçu   %q\nattendu %q", name, s, want)
+		}
+	}
+}
+
+// toolsOf : le champ tools d'une requête, tel qu'envoyé.
+func toolsOf(t *testing.T, body string) string {
+	t.Helper()
+	var p struct {
+		Tools json.RawMessage `json:"tools"`
+	}
+	if err := json.Unmarshal([]byte(body), &p); err != nil {
+		t.Fatal(err)
+	}
+	return string(p.Tools)
+}
+
+// Avec la clé : deux discussions dans deux dossiers ont le MÊME système et les
+// mêmes outils ; la date et le dossier sont dans le bloc projet de chacune.
+func TestEnvCtxSystemeCommunAuxDiscussions(t *testing.T) {
+	m := projSnapSetup(t, true)
+	t.Cleanup(func() { setTaskWorkspace("") })
+	caps := Caps{Agent: true, Internet: true, Mem: MemAlways}
+	var bodies []string
+	dirs := []string{t.TempDir(), t.TempDir()}
+	for _, d := range dirs {
+		setTaskWorkspace(d)
+		bodies = append(bodies, playTurn(t, m, newTestConv(), caps, "salut"))
+	}
+	s0, s1 := systemContent(t, bodies[0]), systemContent(t, bodies[1])
+	if s0 != s1 || toolsOf(t, bodies[0]) != toolsOf(t, bodies[1]) {
+		t.Fatalf("système ou outils différents d'une discussion à l'autre :\n%q\n%q", s0, s1)
+	}
+	today := time.Now().Format("2006-01-02")
+	year := today[:4]
+	for _, v := range []string{today, year, dirs[0], dirs[1], "cwd="} {
+		if strings.Contains(s0, v) {
+			t.Fatalf("%q encore dans le système : %q", v, s0)
+		}
+	}
+	if !strings.Contains(s0, "Your working folder (cwd) is given in your context") || !strings.Contains(s0, scriptsDir()) {
+		t.Fatalf("consignes du dossier de travail perdues : %q", s0)
+	}
+	for i, b := range bodies {
+		u := userContents(t, b)[0]
+		if !strings.Contains(u, envContextPrefix+":\n"+envDateLine(today)) || !strings.Contains(u, "Working folder (cwd): "+dirs[i]+".") {
+			t.Fatalf("discussion %d : date ou dossier absents du bloc : %q", i, u)
+		}
+	}
+}
+
+// Changement de jour : une ligne de mise à jour, une seule fois ; système et
+// bloc figé inchangés, donc tout le début du prompt reste en cache.
+func TestEnvCtxChangementDeJour(t *testing.T) {
+	m := projSnapSetup(t, true)
+	day := time.Date(2026, 12, 31, 23, 50, 0, 0, time.Local)
+	envNow = func() time.Time { return day }
+	t.Cleanup(func() { envNow = time.Now })
+	c := newTestConv()
+	caps := Caps{Agent: true, Mem: MemAlways}
+	b1 := playTurn(t, m, c, caps, "salut")
+	day = day.Add(20 * time.Minute)
+	b2 := playTurn(t, m, c, caps, "et maintenant ?")
+	b3 := playTurn(t, m, c, caps, "merci")
+	if systemContent(t, b1) != systemContent(t, b2) || systemContent(t, b2) != systemContent(t, b3) {
+		t.Fatal("le système a changé avec le jour")
+	}
+	u1, u2, u3 := userContents(t, b1), userContents(t, b2), userContents(t, b3)
+	if u1[0] != u2[0] || u2[0] != u3[0] || !strings.Contains(u1[0], "Date: 2026-12-31 (the current year is 2026, not 2025).") {
+		t.Fatalf("bloc figé modifié ou sans date : %q / %q", u1[0], u2[0])
+	}
+	want := ctxUpdOpen
+	last := u2[len(u2)-1]
+	if !strings.HasPrefix(last, want) || !strings.Contains(last, "New day — Date: 2027-01-01 (the current year is 2027, not 2026).") {
+		t.Fatalf("mise à jour du jour attendue : %q", last)
+	}
+	if u3[1] != last || strings.Contains(u3[len(u3)-1], ctxUpdOpen) {
+		t.Fatalf("la mise à jour doit partir une fois, puis rester telle quelle : %q", u3)
+	}
+}
+
+// Tâches, sous-agents, vérification, terminal : la clé ne change rien à leur
+// système, qui garde la date et le dossier.
+func TestEnvCtxHorsDiscussionInchange(t *testing.T) {
+	projSnapSetup(t, true)
+	caps := Caps{Agent: true, Mem: MemAlways}
+	got, _ := prepareTurn([]Message{um("tâche")}, caps)
+	s := sysOf(t, got)
+	if !strings.Contains(s, "\nDate: "+time.Now().Format("2006-01-02")) || !strings.Contains(s, ", cwd="+agentCwd()+".") {
+		t.Fatalf("système d'une tâche modifié par la clé : %q", s)
+	}
+	if mp := machineSystemPrompt(caps); !strings.Contains(mp, "cwd="+agentCwd()) {
+		t.Fatalf("briefing d'un sous-agent sans dossier : %q", mp)
+	}
+}
+
+// Poste distant passé hors ligne, autre dossier : le bloc entier repart, rien
+// n'est retenu d'avant.
+func TestEnvDelta(t *testing.T) {
+	if d := envDelta("2026-10-04", "x", "2026-10-04", "x"); d != "" {
+		t.Fatalf("rien de changé : %q", d)
+	}
+	if d := envDelta("2026-10-04", "Working folder (cwd): /a.", "2026-10-04", "Machine: REMOTE node pc. "+nodeOfflineLine); !strings.Contains(d, "Current version") || !strings.Contains(d, nodeOfflineLine) || !strings.Contains(d, "Date: 2026-10-04") {
+		t.Fatalf("bloc entier attendu : %q", d)
+	}
+	if d := envDelta("2026-10-04", "x", "2026-10-05", "x"); d != "New day — "+envDateLine("2026-10-05")+"\n" {
+		t.Fatalf("une ligne attendue : %q", d)
+	}
+}

internal/loki/chat_export.go

@@ -103,8 +103,10 @@ func (c *Conversation) ExportJSON(o exportOpts) ([]byte, error) {
 		Version:    Version,
 		ExportedAt: time.Now().Format(time.RFC3339),
 		CtxUsed:    ctxUsed,
-		Messages:   stripInlineImages(msgs),
-		Log:        filterLog(log, o),
+		// Sans les mises à jour du projet (PROJ_SNAPSHOT) : l'export rend la
+		// conversation, pas les données que Loki y a glissées.
+		Messages: stripInlineImages(stripContextUpdates(msgs)),
+		Log:      filterLog(log, o),
 	}
 	return json.MarshalIndent(p, "", "  ")
 }

internal/loki/chat_history_view_test.go

@@ -0,0 +1,76 @@
+package loki
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Compaction EN COURS de tour : la vue publiée perd ce que la vue d'envoi avait
+// posé en tête (préambule, prompt du preset, contexte du projet), mais garde le
+// rappel des pages lues, qui appartient à l'historique.
+func TestCompactionEnTourGardeLeRappel(t *testing.T) {
+	for _, on := range []bool{false, true} {
+		m := projSnapSetup(t, on)
+		if err := saveSysPrompt("Réponds en français."); err != nil {
+			t.Fatal(err)
+		}
+		if err := MemAdd("nas.md", "# NAS\n"); err != nil {
+			t.Fatal(err)
+		}
+		reminder, _ := buildReminderMessage([]string{"nas.md"})
+		c := newTestConv()
+		c.Messages = []Message{reminder}
+		for i := 0; i < 12; i++ {
+			c.Messages = append(c.Messages, um("continue "+strings.Repeat("x", 600)), am("étape "+strings.Repeat("détail ", 300)))
+		}
+		n := len(m.all())
+		m.mu.Lock()
+		m.reply = func(k int, _ string) (int, string) {
+			if k == n {
+				return 400, `{"error":{"code":400,"message":"request (99999 tokens) exceeds the available context size"}}`
+			}
+			return 200, sseChunk("ok.") + sseFinal("stop", 100, 2)
+		}
+		m.mu.Unlock()
+		playTurn(t, m, c, Caps{Agent: true, Mem: MemAlways}, "et le NAS ?")
+		if len(m.all()) < n+2 {
+			t.Fatalf("clé %v : pas de requête rejouée après compaction", on)
+		}
+		if len(c.Messages) == 0 || !reflect.DeepEqual(c.Messages[0], reminder) {
+			t.Fatalf("clé %v : rappel des pages lues perdu : %+v", on, c.Messages[0])
+		}
+		for _, msg := range c.Messages[1:] {
+			if msg.Role == "system" {
+				t.Fatalf("clé %v : système injecté rangé dans l'historique : %q", on, msgText(msg))
+			}
+		}
+		if len(c.Messages) >= 25 {
+			t.Fatalf("clé %v : compaction non rangée (%d messages)", on, len(c.Messages))
+		}
+		if err := saveSysPrompt(""); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+func TestHistoryFromView(t *testing.T) {
+	rem := Message{Role: "system", Content: memReminderPrefix + " Memory pages you read earlier: a.md"}
+	sys := Message{Role: "system", Content: "/sys perso"}
+	u := um("q")
+	cases := []struct {
+		name       string
+		view, hist []Message
+		want       []Message
+	}{
+		{"injectés seuls", []Message{{Role: "system", Content: "préambule"}, {Role: "system", Content: projectContextPrefix + " x"}, u}, []Message{u}, []Message{u}},
+		{"rappel gardé", []Message{{Role: "system", Content: "préambule"}, {Role: "system", Content: projectContextPrefix + " x"}, rem, u}, []Message{rem, u}, []Message{rem, u}},
+		{"système fusionné rendu", []Message{{Role: "system", Content: "préambule\n\n/sys perso"}, u}, []Message{sys, u}, []Message{sys, u}},
+		{"sans système", []Message{u}, []Message{u}, []Message{u}},
+	}
+	for _, tc := range cases {
+		if got := historyFromView(tc.view, tc.hist); !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("%s : %+v, attendu %+v", tc.name, got, tc.want)
+		}
+	}
+}

internal/loki/chat_internet_tools.go

@@ -297,7 +297,7 @@ func cmdInternet(args []string) error {
 		if err := setInternetEnabled(true); err != nil {
 			return err
 		}
-		fmt.Println(green("[ok]") + " accès internet activé — l'IA dispose de web_search/web_open/web_read/web_grep (si le mode agent est actif)")
+		fmt.Println(green("[ok]") + " accès internet activé — l'IA dispose de web_search/web_images/web_open/web_read/web_grep (si le mode agent est actif)")
 	case "off":
 		if err := setInternetEnabled(false); err != nil {
 			return err
@@ -352,7 +352,7 @@ func cmdInternet(args []string) error {
 		fmt.Printf("%s  état: %s\n", cyan("Accès internet"), state)
 		if webEngine() == engineGo {
 			fmt.Printf("  moteur  : %s (aucune installation, pas de rendu JavaScript)\n", bold("intégré"))
-			fmt.Printf("  outils  : web_search, web_open, web_read, web_grep\n")
+			fmt.Printf("  outils  : web_search, web_images, web_open, web_read, web_grep\n")
 			return nil
 		}
 		fmt.Printf("  moteur  : %s\n", bold("crawl4ai"))
@@ -366,7 +366,7 @@ func cmdInternet(args []string) error {
 			reach = green("joignable")
 		}
 		fmt.Printf("  serveur : %s (%s)\n", bold(u), reach)
-		fmt.Printf("  outils  : web_search, web_open, web_read, web_grep\n")
+		fmt.Printf("  outils  : web_search, web_images, web_open, web_read, web_grep\n")
 	default:
 		return fmt.Errorf("usage: loki internet [on|off|status|engine <go|crawl4ai>|url <url>|key <clé>]")
 	}

internal/loki/chat_keep_images.go

@@ -0,0 +1,434 @@
+package loki
+
+// chat_keep_images.go — KEEP_TURN_IMAGES : garder dans l'historique les images
+// que montrent les outils (web_screenshot, browser_screenshot, see_image), au
+// lieu de les jeter à la fin du tour. Opt-in, off par défaut, ZONE GRISE.
+//
+// Sans la clé, ces images sont ÉPHÉMÈRES (voir runChat) : le modèle les voit
+// pendant le tour, puis elles disparaissent de l'historique. Le tour suivant
+// renvoie donc un fil où elles manquent : le préfixe que le moteur a en cache
+// diverge à la première, et toute la boucle d'outils qui suivait — souvent des
+// dizaines d'étapes de navigation — est recalculée.
+//
+// Avec la clé, une image est gardée telle qu'envoyée, sous conditions :
+//
+//   - vision réellement active (visionEnabled et engineSeesImages, revérifiés à
+//     chaque tour : un preset sans vision n'en reçoit jamais) ; un preset
+//     externe n'est concerné que si sa vision est déclarée, et chaque image
+//     gardée y est alors refacturée à chaque tour ;
+//   - rangée par référence (chat_images.go, chiffrée si la mémoire l'est) et
+//     relue à l'octet près avant d'être gardée : le modèle reçoit les mêmes
+//     octets à chaque envoi ;
+//   - coût MESURÉ par le moteur (écart de usage.prompt_tokens entre deux
+//     requêtes, moins l'estimation du texte ajouté) et non estimé : une image
+//     dont le coût ne se mesure pas (moteur sans usage, requête relancée,
+//     historique réécrit entre-temps) reste éphémère ;
+//   - toutes les images gardées tiennent dans keepImgPct % de la fenêtre. La
+//     première qui ne tient pas reste éphémère, et toutes celles qui la suivent
+//     dans le tour aussi : le préfixe divergera de toute façon à elle ;
+//   - retirées D'ABORD par toute compaction ou réduction forcée (légende et
+//     imageLostMarker gardés), avant tout résumé ; un rechargement du fil les
+//     retire aussi (stripImageParts), comme les pièces jointes.
+//
+// Ce que ça coûte : plus d'information gardée, donc une compaction (avec
+// perte) qui arrive plus tôt — d'où la borne et le retrait prioritaire.
+
+import (
+	"encoding/base64"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+// keepImgPct : part maximale de la fenêtre que les images gardées occupent.
+const keepImgPct = 10
+
+// keepImgMinTokens : en dessous, la mesure ne vaut rien (écart noyé dans
+// l'erreur d'estimation du texte) — l'image reste éphémère.
+const keepImgMinTokens = 16
+
+func keepTurnImagesOn(cfg map[string]string) bool {
+	switch strings.ToLower(strings.TrimSpace(cfg["KEEP_TURN_IMAGES"])) {
+	case "on", "1", "true", "yes", "oui":
+		return true
+	}
+	return false
+}
+
+func keepImgBudget() int { return ctxWindow() * keepImgPct / 100 }
+
+// keptImageTokens : coût total des images gardées de ces messages.
+func keptImageTokens(msgs []Message) int {
+	n := 0
+	for _, m := range msgs {
+		n += m.imgTokens
+	}
+	return n
+}
+
+func hasKeptImages(msgs []Message) bool {
+	for _, m := range msgs {
+		if m.imgTokens > 0 {
+			return true
+		}
+	}
+	return false
+}
+
+// dropKeptImages renvoie une COPIE des messages où chaque image gardée devient
+// sa légende suivie d'imageLostMarker (la forme de stripImageParts), et le coût
+// libéré. Rien de gardé : msgs tel quel, 0. Le message reste un relais
+// (ImgRelay) : ni une demande, ni la preuve qu'une demande a été servie.
+func dropKeptImages(msgs []Message) ([]Message, int) {
+	var out []Message
+	freed := 0
+	for i, m := range msgs {
+		if m.imgTokens <= 0 {
+			continue
+		}
+		if out == nil {
+			out = append([]Message(nil), msgs...)
+		}
+		var texts []string
+		for _, p := range contentParts(m.Content) {
+			if t, ok := p["text"].(string); ok && p["type"] == "text" {
+				texts = append(texts, t)
+			}
+		}
+		freed += m.imgTokens
+		m.Content = strings.Join(texts, "\n") + imageLostMarker
+		m.imgTokens = 0
+		out[i] = m
+	}
+	if out == nil {
+		return msgs, 0
+	}
+	return out, freed
+}
+
+func logKeptImagesDropped(phase string, freed int) {
+	fmt.Fprintf(os.Stderr, "[images] %s : images gardées retirées (%d jetons)\n", phase, freed)
+}
+
+// stripRelayTags retire la marque ImgRelay avant l'envoi : propre à Loki, elle
+// n'a rien à faire dans la requête. Aucune marque : msgs tel quel, sans copie.
+func stripRelayTags(msgs []Message) []Message {
+	var out []Message
+	for i, m := range msgs {
+		// La marque des blocs <context_update> (PROJ_SNAPSHOT) non plus ne
+		// quitte jamais Loki.
+		if !m.ImgRelay && !m.CtxUpd {
+			continue
+		}
+		if out == nil {
+			out = append([]Message(nil), msgs...)
+		}
+		m.ImgRelay, m.CtxUpd = false, false
+		out[i] = m
+	}
+	if out == nil {
+		return msgs
+	}
+	return out
+}
+
+// refRelayImage range l'image d'un relais par référence et renvoie le message
+// qui la porte ainsi, avec le poids de l'image (octets, pour répartir une
+// mesure entre plusieurs images d'une même étape). ok=false — format sans
+// extension connue, disque plein, mémoire chiffrée verrouillée, relecture qui
+// ne redonne pas exactement la même data-URL — : l'image reste éphémère.
+func refRelayImage(m Message) (Message, int, bool) {
+	parts := contentParts(m.Content)
+	np := make([]map[string]any, len(parts))
+	weight := 0
+	for i, p := range parts {
+		np[i] = p
+		_, u := partImageURL(p)
+		if u == "" {
+			continue
+		}
+		if weight > 0 || !strings.HasPrefix(u, "data:image/") {
+			return m, 0, false
+		}
+		k := strings.Index(u, ";base64,")
+		if k < 0 {
+			return m, 0, false
+		}
+		mime := u[5:k]
+		if imgExtByMime[mime] == "" {
+			return m, 0, false
+		}
+		b, err := base64.StdEncoding.DecodeString(u[k+8:])
+		if err != nil || len(b) == 0 {
+			return m, 0, false
+		}
+		ref, err := storeChatImage(b, mime)
+		if err != nil {
+			return m, 0, false
+		}
+		// Gardée en vie : storeChatImage ne réécrit pas un fichier déjà là (mêmes
+		// octets), et pruneChatImages efface au bout de chatImgKeep d'après la
+		// date du fichier — une image revue aujourd'hui ne doit pas tomber demain
+		// en « [image indisponible] » au milieu d'un fil.
+		now := time.Now()
+		_ = os.Chtimes(filepath.Join(chatImgDir(), strings.TrimPrefix(ref, imgRefScheme)), now, now)
+		if back, ok := chatImageDataURL(ref); !ok || back != u {
+			return m, 0, false
+		}
+		np[i] = map[string]any{"type": "image_url", "image_url": map[string]any{"url": ref}}
+		weight = len(b)
+	}
+	if weight == 0 {
+		return m, 0, false
+	}
+	m.Content = np
+	return m, weight, true
+}
+
+// keepImages : l'état de KEEP_TURN_IMAGES pendant UN tour (runChat). nil = clé
+// absente, tâche, sous-agent, vérification ou vision inactive : toutes ses
+// méthodes rendent alors le comportement d'avant.
+type keepImages struct {
+	// stopped : une image de ce tour n'a pas été gardée ; les suivantes ne le
+	// sont pas non plus (le préfixe du tour suivant diverge à elle).
+	stopped bool
+	// Images ajoutées à l'étape courante, gardées à l'essai jusqu'à la mesure
+	// de la requête qui les montre la première.
+	pend []keepPend
+	// pendReq : numéro de cette requête. pendBase : contexte que la complétion
+	// précédente laisse (ctxAfter). pendFrom : premier message ajouté depuis.
+	pendReq, pendBase, pendFrom int
+	// reqN : requêtes envoyées ; sentLen : messages de la dernière.
+	reqN, sentLen int
+	// lastAfter : ctxAfter de la dernière complétion complète (0 = inconnu).
+	lastAfter int
+}
+
+type keepPend struct{ msgIdx, extraIdx, weight int }
+
+// newKeepImages : l'état du tour, ou nil. Fil principal d'une discussion
+// seulement : les tâches, sous-agents et la vérification ne persistent pas
+// leur historique comme elle.
+func newKeepImages(cfg map[string]string, tag perfTag) *keepImages {
+	if !keepTurnImagesOn(cfg) || tag.kind != perfMain || tag.conv == "" {
+		return nil
+	}
+	if !visionEnabled() || !engineSeesImages() {
+		return nil
+	}
+	return &keepImages{}
+}
+
+// relay ajoute le message qui relaie une image d'outil. Sans état : à la vue
+// du modèle seulement, comme avant. Avec : gardé à l'essai dans extra aussi,
+// par référence, si le budget n'est pas déjà plein. from = début des messages
+// de l'étape (premier résultat d'outil).
+func (k *keepImages) relay(messages, extra []Message, m Message, from int) ([]Message, []Message) {
+	if k == nil {
+		return append(messages, m), extra
+	}
+	m.ImgRelay = true
+	if k.stopped {
+		return append(messages, m), extra
+	}
+	// Budget déjà plein : inutile de ranger le fichier.
+	r, w, ok := Message{}, 0, false
+	if keptImageTokens(messages) < keepImgBudget() {
+		r, w, ok = refRelayImage(m)
+	}
+	if !ok {
+		k.stopped = true
+		return append(messages, m), extra
+	}
+	if len(k.pend) == 0 {
+		k.pendReq, k.pendBase, k.pendFrom = k.reqN+1, k.lastAfter, from
+	}
+	messages = append(messages, r)
+	extra = append(extra, r)
+	k.pend = append(k.pend, keepPend{msgIdx: len(messages) - 1, extraIdx: len(extra) - 1, weight: w})
+	return messages, extra
+}
+
+// sending : une requête part avec n messages.
+func (k *keepImages) sending(n int) {
+	if k == nil {
+		return
+	}
+	k.reqN++
+	k.sentLen = n
+}
+
+// observe : une complétion est lue. Mesure le coût des images à l'essai si
+// c'est la requête qui les a montrées la première, et les garde si le budget
+// le permet ; sinon elles redeviennent éphémères (retirées d'extra). Renvoie
+// extra.
+func (k *keepImages) observe(complete bool, st StatsEvent, messages, extra []Message) []Message {
+	if k == nil {
+		return extra
+	}
+	after := 0
+	if complete && st.PromptTokensTotal > 0 {
+		after = st.ctxAfter()
+	}
+	if len(k.pend) > 0 {
+		if !k.measure(after, st.PromptTokensTotal, messages, extra) {
+			extra = k.reject(extra)
+		}
+		k.pend = nil
+	}
+	k.lastAfter = after
+	return extra
+}
+
+// measure répartit le coût mesuré entre les images à l'essai et les garde si
+// tout tient dans le budget. false = mesure impossible ou budget dépassé.
+func (k *keepImages) measure(after, prompt int, messages, extra []Message) bool {
+	if after <= 0 || k.pendBase <= 0 || k.pendReq != k.reqN ||
+		k.pendFrom > k.sentLen || k.sentLen > len(messages) {
+		return false
+	}
+	// Ce que la requête a ajouté depuis la précédente, hors images : résultats
+	// d'outils, légendes exceptées, ajouts en cours de réponse, rappels.
+	text := 0
+	for _, m := range messages[k.pendFrom:k.sentLen] {
+		if !m.ImgRelay {
+			text += msgTokens(m)
+		}
+	}
+	img := prompt - k.pendBase - text
+	weight := 0
+	for _, p := range k.pend {
+		weight += p.weight
+	}
+	if weight <= 0 || img < keepImgMinTokens*len(k.pend) {
+		return false
+	}
+	if keptImageTokens(messages)+img > keepImgBudget() {
+		return false
+	}
+	shares := make([]int, len(k.pend))
+	left := img
+	for i, p := range k.pend {
+		shares[i] = img * p.weight / weight
+		if i == len(k.pend)-1 {
+			shares[i] = left
+		}
+		if shares[i] < keepImgMinTokens {
+			return false
+		}
+		left -= shares[i]
+	}
+	for _, p := range k.pend {
+		if p.msgIdx >= len(messages) || p.extraIdx >= len(extra) || !messages[p.msgIdx].ImgRelay || !extra[p.extraIdx].ImgRelay {
+			return false
+		}
+	}
+	for i, p := range k.pend {
+		messages[p.msgIdx].imgTokens = shares[i]
+		extra[p.extraIdx].imgTokens = shares[i]
+	}
+	return true
+}
+
+// reject retire d'extra les images à l'essai : éphémères, comme sans la clé.
+func (k *keepImages) reject(extra []Message) []Message {
+	if len(k.pend) == 0 {
+		return extra
+	}
+	k.stopped = true
+	drop := map[int]bool{}
+	for _, p := range k.pend {
+		drop[p.extraIdx] = true
+	}
+	out := make([]Message, 0, len(extra))
+	for i, m := range extra {
+		if !drop[i] {
+			out = append(out, m)
+		}
+	}
+	k.pend = nil
+	return out
+}
+
+// rewritten : l'historique vient d'être réécrit en cours de tour (compaction,
+// réduction) et extra repart de zéro. Les images à l'essai ne se mesurent plus
+// (ni base ni position) : éphémères, et le tour s'arrête là pour les suivantes.
+func (k *keepImages) rewritten() {
+	if k == nil {
+		return
+	}
+	if len(k.pend) > 0 {
+		k.stopped = true
+	}
+	k.pend = nil
+}
+
+// publishable : l'historique publié par une réécriture en cours de tour, sans
+// les relais dont l'image n'est pas gardée (éphémères, ou à l'essai). Sans
+// état, tel quel — comportement d'avant.
+func (k *keepImages) publishable(msgs []Message) []Message {
+	if k == nil {
+		return msgs
+	}
+	out := msgs[:0:0]
+	for _, m := range msgs {
+		if m.ImgRelay && m.imgTokens == 0 && hasImagePart(m) {
+			continue
+		}
+		out = append(out, m)
+	}
+	return out
+}
+
+// finish : fin du tour. Une image encore à l'essai (tour arrêté, erreur, fin
+// juste après elle) n'a pas été mesurée : éphémère.
+func (k *keepImages) finish(extra []Message) []Message {
+	if k == nil {
+		return extra
+	}
+	return k.reject(extra)
+}
+
+func hasImagePart(m Message) bool {
+	for _, p := range contentParts(m.Content) {
+		if p["type"] == "image_url" {
+			return true
+		}
+	}
+	return false
+}
+
+// keptImagesTurnStart : début d'un tour de discussion. Les images gardées
+// sont retirées d'abord — avant toute compaction, qui ne résume alors que si
+// c'est encore nécessaire — quand le contexte la réclame, ou quand elles ne
+// doivent plus partir : clé retirée, vision absente (un moteur sans projecteur
+// refuserait la requête). Renvoie l'historique et le contexte à jour.
+func (c *Conversation) keptImagesTurnStart(epoch int, msgs []Message, ctxUsed, peak int) ([]Message, int) {
+	if !hasKeptImages(msgs) {
+		return msgs, ctxUsed
+	}
+	if keepTurnImagesOn(ReadConfig()) && visionEnabled() && engineSeesImages() && !compactNeeded(msgs, ctxUsed, peak) {
+		return msgs, ctxUsed
+	}
+	out, freed := dropKeptImages(msgs)
+	logKeptImagesDropped("début-tour", freed)
+	if ctxUsed > 0 {
+		ctxUsed = max(ctxUsed-freed, 1)
+	}
+	c.mu.Lock()
+	cur := 0
+	if c.epoch == epoch {
+		c.Messages = append([]Message(nil), out...)
+		if c.CtxUsed > 0 {
+			c.CtxUsed = max(c.CtxUsed-freed, 1)
+		}
+		cur = c.CtxUsed
+	}
+	c.mu.Unlock()
+	if cur > 0 {
+		c.appendDelta(epoch, map[string]any{"ctx_used": cur})
+	}
+	return out, ctxUsed
+}

internal/loki/chat_keep_images_test.go

@@ -0,0 +1,668 @@
+package loki
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"image"
+	"image/color"
+	"image/png"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+)
+
+// sseSeeImage : le modèle demande see_image sur img.png ; usage du prompt
+// prompt (complétion de 20 jetons). prompt = 0 : aucun usage, comme un moteur
+// qui ne le renvoie pas.
+func sseSeeImage(prompt int) string {
+	s := `data: {"choices":[{"delta":{"tool_calls":[{"index":0,"id":"v1","type":"function","function":{"name":"see_image","arguments":"{\"file\":\"img.png\"}"}}]}}]}` + "\n\n" +
+		`data: {"choices":[{"delta":{},"finish_reason":"tool_calls"}]}` + "\n\n"
+	if prompt > 0 {
+		s += fmt.Sprintf(`data: {"choices":[],"usage":{"prompt_tokens":%d,"completion_tokens":20}}`, prompt) + "\n\n"
+	}
+	return s + "data: [DONE]\n\n"
+}
+
+func sseAnswer(text string, prompt int) string {
+	s := sseChunk(text) + `data: {"choices":[{"delta":{},"finish_reason":"stop"}]}` + "\n\n"
+	if prompt > 0 {
+		s += fmt.Sprintf(`data: {"choices":[],"usage":{"prompt_tokens":%d,"completion_tokens":5}}`, prompt) + "\n\n"
+	}
+	return s + "data: [DONE]\n\n"
+}
+
+// visionServer : un llama-server de test qui déclare la vision (/props) et
+// répond aux complétions dans l'ordre des steps, en gardant chaque corps.
+func visionServer(t *testing.T, steps ...string) func() []map[string]any {
+	t.Helper()
+	var mu sync.Mutex
+	var bodies []map[string]any
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/props" {
+			_, _ = w.Write([]byte(`{"modalities":{"vision":true}}`))
+			return
+		}
+		var body map[string]any
+		_ = json.NewDecoder(r.Body).Decode(&body)
+		mu.Lock()
+		bodies = append(bodies, body)
+		n := len(bodies) - 1
+		mu.Unlock()
+		w.Header().Set("Content-Type", "text/event-stream")
+		w.WriteHeader(200)
+		_, _ = w.Write([]byte(steps[min(n, len(steps)-1)]))
+	}))
+	t.Cleanup(srv.Close)
+	u, _ := url.Parse(srv.URL)
+	for k, v := range map[string]string{"PORT": u.Port(), "MMPROJ": "/models/mmproj.gguf"} {
+		if err := SetConfigKey(k, v); err != nil {
+			t.Fatal(err)
+		}
+	}
+	// Sonde de vision en cache 10 s : un autre test a pu conclure « non ».
+	visionProbeMu.Lock()
+	visionProbeAt = time.Time{}
+	visionProbeMu.Unlock()
+	return func() []map[string]any {
+		mu.Lock()
+		defer mu.Unlock()
+		return append([]map[string]any(nil), bodies...)
+	}
+}
+
+// writeTestPNG pose img.png (petit, sous maxImageDim : octets inchangés) dans
+// le dossier de travail et renvoie la data-URL que le modèle doit recevoir.
+func writeTestPNG(t *testing.T, dir string) string {
+	t.Helper()
+	img := image.NewRGBA(image.Rect(0, 0, 8, 8))
+	for i := 0; i < 8; i++ {
+		img.Set(i, i, color.RGBA{R: 200, A: 255})
+	}
+	var buf bytes.Buffer
+	if err := png.Encode(&buf, img); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "img.png"), buf.Bytes(), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	part := imageURLPart(buf.Bytes(), "image/png")
+	return part["image_url"].(map[string]any)["url"].(string)
+}
+
+func mainCtx(t *testing.T) context.Context {
+	return withPerf(t.Context(), perfMain, "conv-test")
+}
+
+// relayOf : le message de relais d'une requête (celui qui porte l'image).
+func relayOf(t *testing.T, body map[string]any) map[string]any {
+	t.Helper()
+	for _, m := range body["messages"].([]any) {
+		mm := m.(map[string]any)
+		if parts, ok := mm["content"].([]any); ok && len(parts) == 2 {
+			return mm
+		}
+	}
+	t.Fatal("aucun relais d'image dans la requête")
+	return nil
+}
+
+// Sans la clé : image éphémère, relais en base64, aucune marque — et, avec la
+// clé, la requête qui montre l'image est la MÊME à l'octet près.
+func TestKeepImagesSansCleRequeteIdentique(t *testing.T) {
+	dir := withWorkspace(t)
+	want := writeTestPNG(t, dir)
+
+	reqs := visionServer(t, sseSeeImage(1000), sseAnswer("vu", 1331))
+	extra, err := runChat(mainCtx(t), []Message{um("regarde img.png")}, 0.7, Caps{Agent: true}, func(StreamEvent) bool { return true })
+	if err != nil {
+		t.Fatal(err)
+	}
+	off := reqs()
+	if len(off) != 2 {
+		t.Fatalf("%d requêtes, attendu 2", len(off))
+	}
+	relay := relayOf(t, off[1])
+	if _, tagged := relay["img_relay"]; tagged {
+		t.Fatal("marque img_relay envoyée sans la clé")
+	}
+	part := relay["content"].([]any)[1].(map[string]any)
+	if got := part["image_url"].(map[string]any)["url"]; got != want {
+		t.Fatal("image du relais différente de celle du fichier")
+	}
+	if len(extra) != 2 {
+		t.Fatalf("sans la clé, l'image doit rester éphémère : %+v", extra)
+	}
+	for _, m := range extra {
+		if m.ImgRelay || m.imgTokens != 0 {
+			t.Fatalf("message marqué sans la clé : %+v", m)
+		}
+	}
+
+	if err := SetConfigKey("KEEP_TURN_IMAGES", "on"); err != nil {
+		t.Fatal(err)
+	}
+	reqs = visionServer(t, sseSeeImage(1000), sseAnswer("vu", 1331))
+	if _, err := runChat(mainCtx(t), []Message{um("regarde img.png")}, 0.7, Caps{Agent: true}, func(StreamEvent) bool { return true }); err != nil {
+		t.Fatal(err)
+	}
+	on := reqs()
+	if len(on) != 2 {
+		t.Fatalf("%d requêtes avec la clé, attendu 2", len(on))
+	}
+	for i := range on {
+		if !reflect.DeepEqual(on[i], off[i]) {
+			a, _ := json.Marshal(off[i])
+			b, _ := json.Marshal(on[i])
+			t.Fatalf("requête %d différente avec la clé :\n%s\n%s", i, a, b)
+		}
+	}
+}
+
+// Avec la clé : l'image est gardée par référence, son coût est celui que le
+// moteur a mesuré (écart de prompt moins le texte ajouté), et le tour suivant
+// renvoie exactement les mêmes octets.
+func TestKeepImagesGardeeEtMesuree(t *testing.T) {
+	dir := withWorkspace(t)
+	want := writeTestPNG(t, dir)
+	if err := SetConfigKey("KEEP_TURN_IMAGES", "on"); err != nil {
+		t.Fatal(err)
+	}
+	toolMsg := Message{Role: "tool", ToolCallID: "v1", Content: "[ok] image chargée : img.png"}
+	// ctxAfter de la 1re complétion = 1000 + 20 ; + résultat d'outil ; + 300
+	// pour l'image.
+	prompt2 := 1020 + msgTokens(toolMsg) + 300
+	visionServer(t, sseSeeImage(1000), sseAnswer("vu", prompt2))
+	extra, err := runChat(mainCtx(t), []Message{um("regarde img.png")}, 0.7, Caps{Agent: true}, func(StreamEvent) bool { return true })
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(extra) != 3 {
+		t.Fatalf("image non gardée : %+v", extra)
+	}
+	r := extra[2]
+	if !r.ImgRelay || r.imgTokens != 300 {
+		t.Fatalf("relais gardé = %+v, attendu marqué et 300 jetons", r)
+	}
+	_, u := partImageURL(contentParts(r.Content)[1])
+	if !strings.HasPrefix(u, imgRefScheme) {
+		t.Fatalf("image gardée en base64 et non par référence : %.60s", u)
+	}
+	if !isLokiInjected(r) {
+		t.Fatal("relais pris pour une demande de l'utilisateur")
+	}
+
+	// Tour suivant : l'historique renvoyé repart avec la même image, sans la
+	// marque, à l'octet près de ce que le moteur a déjà vu.
+	hist := append([]Message{um("regarde img.png")}, extra...)
+	hist = append(hist, am("vu"), um("et maintenant ?"))
+	reqs := visionServer(t, sseAnswer("ok", 0))
+	if _, err := runChat(mainCtx(t), hist, 0.7, Caps{Agent: true}, func(StreamEvent) bool { return true }); err != nil {
+		t.Fatal(err)
+	}
+	next := reqs()[0]
+	relay := relayOf(t, next)
+	if _, tagged := relay["img_relay"]; tagged {
+		t.Fatal("marque img_relay envoyée au moteur")
+	}
+	if got := relay["content"].([]any)[1].(map[string]any)["image_url"].(map[string]any)["url"]; got != want {
+		t.Fatal("le tour suivant ne renvoie pas les mêmes octets d'image")
+	}
+}
+
+// Garde : au-delà de 10 % de la fenêtre, l'image reste éphémère.
+func TestKeepImagesBudget(t *testing.T) {
+	dir := withWorkspace(t)
+	writeTestPNG(t, dir)
+	for k, v := range map[string]string{"KEEP_TURN_IMAGES": "on", "CTX": "2000"} {
+		if err := SetConfigKey(k, v); err != nil {
+			t.Fatal(err)
+		}
+	}
+	toolMsg := Message{Role: "tool", ToolCallID: "v1", Content: "[ok] image chargée : img.png"}
+	visionServer(t, sseSeeImage(1000), sseAnswer("vu", 1020+msgTokens(toolMsg)+300))
+	extra, err := runChat(mainCtx(t), []Message{um("regarde img.png")}, 0.7, Caps{Agent: true}, func(StreamEvent) bool { return true })
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(extra) != 2 {
+		t.Fatalf("image de 300 jetons gardée malgré un budget de 200 : %+v", extra)
+	}
+}
+
+// Moteur sans usage : rien à mesurer, l'image reste éphémère.
+func TestKeepImagesSansMesure(t *testing.T) {
+	dir := withWorkspace(t)
+	writeTestPNG(t, dir)
+	if err := SetConfigKey("KEEP_TURN_IMAGES", "on"); err != nil {
+		t.Fatal(err)
+	}
+	visionServer(t, sseSeeImage(0), sseAnswer("vu", 0))
+	extra, err := runChat(mainCtx(t), []Message{um("regarde img.png")}, 0.7, Caps{Agent: true}, func(StreamEvent) bool { return true })
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(extra) != 2 {
+		t.Fatalf("image gardée sans mesure : %+v", extra)
+	}
+}
+
+// Ni tâche ni sous-agent : seul le fil d'une discussion garde ses images.
+func TestKeepImagesFilPrincipalSeulement(t *testing.T) {
+	testHome(t)
+	if err := SetConfigKey("KEEP_TURN_IMAGES", "on"); err != nil {
+		t.Fatal(err)
+	}
+	if newKeepImages(ReadConfig(), perfTag{kind: perfTask, conv: "task:x"}) != nil ||
+		newKeepImages(ReadConfig(), perfTag{kind: perfMain}) != nil {
+		t.Fatal("état de KEEP_TURN_IMAGES hors d'une discussion")
+	}
+	var k *keepImages // clé absente : chaque méthode rend le comportement d'avant
+	m := []Message{um("a")}
+	got, e := k.relay(m, nil, um("img"), 1)
+	if len(got) != 2 || e != nil || got[1].ImgRelay {
+		t.Fatal("relais sans état modifié")
+	}
+	k.sending(2)
+	k.rewritten()
+	if k.observe(true, StatsEvent{}, got, nil) != nil || k.finish(nil) != nil ||
+		len(k.publishable(got)) != 2 {
+		t.Fatal("état nil qui agit")
+	}
+}
+
+func keptRelay(tokens int) Message {
+	return Message{Role: "user", ImgRelay: true, imgTokens: tokens, Content: []map[string]any{
+		{"type": "text", "text": "Voici la capture demandée."},
+		{"type": "image_url", "image_url": map[string]any{"url": imgRefScheme + "abc.png"}},
+	}}
+}
+
+// Retrait : légende + imageLostMarker, toujours un relais, coût libéré ; rien
+// à faire sans image gardée.
+func TestDropKeptImages(t *testing.T) {
+	plain := []Message{um("q"), tm("r")}
+	if out, freed := dropKeptImages(plain); freed != 0 || &out[0] != &plain[0] {
+		t.Fatal("copie ou retrait sans image gardée")
+	}
+	msgs := []Message{um("q"), atc("see_image"), tm("[ok]"), keptRelay(500), am("vu")}
+	out, freed := dropKeptImages(msgs)
+	if freed != 500 {
+		t.Fatalf("libéré %d, attendu 500", freed)
+	}
+	r := out[3]
+	if r.Content != "Voici la capture demandée."+imageLostMarker || !r.ImgRelay || r.imgTokens != 0 {
+		t.Fatalf("relais retiré = %+v", r)
+	}
+	if msgs[3].imgTokens != 500 {
+		t.Fatal("l'historique d'origine a été modifié en place")
+	}
+	if estimateTokens(msgs)-estimateTokens(out) < 400 {
+		t.Fatal("le coût mesuré de l'image n'est pas compté dans l'estimation")
+	}
+}
+
+// Toute compaction retire les images gardées d'abord, et ce retrait compte
+// comme un changement même quand rien n'est à résumer.
+func TestCompactionRetireLesImagesDAbord(t *testing.T) {
+	testHome(t)
+	msgs := []Message{{Role: "system", Content: "sys"}, um("q"), atc("see_image"), tm("[ok]"), keptRelay(5000), am("vu")}
+	out, changed, _ := compactMessagesOpt(t.Context(), msgs, Caps{}, compactOpts{})
+	if !changed || hasKeptImages(out) {
+		t.Fatalf("images gardées non retirées par la compaction : changé=%v", changed)
+	}
+	out, changed = shrinkToFit(msgs, 0)
+	if !changed || hasKeptImages(out) {
+		t.Fatal("images gardées non retirées par la réduction forcée")
+	}
+	// Sans image gardée : chemin d'avant, rien de changé sur un torse vide.
+	plain := []Message{{Role: "system", Content: "sys"}, um("q"), am("r")}
+	if _, changed, _ := compactMessagesOpt(t.Context(), plain, Caps{}, compactOpts{}); changed {
+		t.Fatal("compaction d'un fil sans torse")
+	}
+}
+
+// Un relais n'est ni une demande à réinjecter, ni la preuve qu'une demande a
+// été servie ; rouvert, il le reste (marque persistée), et la marque ne part
+// jamais au moteur.
+func TestRelaisPasPrisPourLaDemande(t *testing.T) {
+	r := keptRelay(10)
+	msgs := []Message{um("ancienne"), am("ok"), um("vraie demande"), atc("see_image"), tm("[ok]"), r}
+	if p := compactPending(msgs, msgs[:3], 3); len(p) != 1 || msgText(p[0]) != "vraie demande" {
+		t.Fatalf("demande réinjectée : %+v", p)
+	}
+	raw, _ := json.Marshal(r)
+	var back Message
+	if err := json.Unmarshal(raw, &back); err != nil {
+		t.Fatal(err)
+	}
+	back = stripImageParts([]Message{back})[0]
+	if !isLokiInjected(back) {
+		t.Fatal("relais rouvert pris pour une demande")
+	}
+	sent, _ := wireMessages(msgs, false, echoPolicy{})
+	for _, m := range sent {
+		if m.ImgRelay {
+			t.Fatal("marque de relais dans la requête")
+		}
+	}
+	if !msgs[5].ImgRelay {
+		t.Fatal("l'historique a perdu sa marque à l'envoi")
+	}
+}
+
+// Réécriture en cours de tour : une image non gardée n'entre pas dans
+// l'historique publié ; une image gardée, ou déjà retirée, si.
+func TestKeepImagesPublication(t *testing.T) {
+	k := &keepImages{}
+	eph := Message{Role: "user", ImgRelay: true, Content: []map[string]any{
+		{"type": "text", "text": "Image :"}, {"type": "image_url", "image_url": map[string]any{"url": "data:image/png;base64,AA=="}}}}
+	stub := Message{Role: "user", ImgRelay: true, Content: "Image :" + imageLostMarker}
+	msgs := []Message{um("q"), tm("a"), eph, tm("b"), keptRelay(50), stub}
+	got := k.publishable(msgs)
+	if len(got) != 5 || got[2].Content != "b" {
+		t.Fatalf("publié : %+v", got)
+	}
+	k.pend = []keepPend{{msgIdx: 2, extraIdx: 0, weight: 1}}
+	k.rewritten()
+	if !k.stopped || k.pend != nil {
+		t.Fatal("images à l'essai encore suivies après une réécriture")
+	}
+}
+
+// Début de tour : clé retirée → images gardées retirées ; clé présente et
+// vision active sans besoin de compacter → gardées.
+func TestKeptImagesDebutDeTour(t *testing.T) {
+	withWorkspace(t)
+	visionServer(t, sseStop)
+	c := newTestConv()
+	msgs := []Message{um("q"), atc("see_image"), tm("[ok]"), keptRelay(300), am("vu"), um("suite")}
+	c.Messages = append([]Message(nil), msgs...)
+	c.CtxUsed = 2000
+	out, used := c.keptImagesTurnStart(c.epoch, msgs, 2000, 0)
+	if hasKeptImages(out) || used != 1700 || hasKeptImages(c.Messages) || c.CtxUsed != 1700 {
+		t.Fatalf("clé absente : images gardées encore là (used=%d)", used)
+	}
+	if err := SetConfigKey("KEEP_TURN_IMAGES", "on"); err != nil {
+		t.Fatal(err)
+	}
+	c.Messages = append([]Message(nil), msgs...)
+	out, used = c.keptImagesTurnStart(c.epoch, msgs, 2000, 0)
+	if !hasKeptImages(out) || used != 2000 {
+		t.Fatal("images retirées alors que rien ne le demandait")
+	}
+	// Contexte au seuil : retirées d'abord.
+	out, used = c.keptImagesTurnStart(c.epoch, msgs, ctxWindow(), 0)
+	if hasKeptImages(out) || used != ctxWindow()-300 {
+		t.Fatal("images gardées malgré un contexte au seuil")
+	}
+}
+
+// NUDGE_IN_TOOL : seulement avec la clé, sur le moteur local, si la sonde a dit
+// « instable » pour CE modèle et pour la forme de CETTE requête.
+func TestNudgeInToolOn(t *testing.T) {
+	freshTplProbe(t)
+	cfg := map[string]string{"MODEL": "/models/qwen35.gguf"}
+	tools := []Tool{readTool(), grepTool()}
+	kwargs := map[string]any{"enable_thinking": true}
+	set := func(r tplProbeResult) {
+		tplProbeMu.Lock()
+		tplProbeLast = &r
+		tplProbeKeepShape(newTplShape(tools, kwargs, "").hash(), r)
+		tplProbeMu.Unlock()
+	}
+	on := func(cfg map[string]string, ep chatEndpoint) bool { return nudgeInToolOn(cfg, ep, tools, kwargs, "") }
+	set(tplProbeResult{Model: "qwen35.gguf", PrefixStable: tplNo})
+	if on(cfg, chatEndpoint{}) {
+		t.Fatal("actif sans la clé")
+	}
+	cfg["NUDGE_IN_TOOL"] = "on"
+	if !on(cfg, chatEndpoint{}) {
+		t.Fatal("inactif avec la clé sur un gabarit instable")
+	}
+	if on(cfg, chatEndpoint{External: true}) {
+		t.Fatal("actif sur un preset externe")
+	}
+	// Le verdict « instable » d'une forme ne vaut pas pour une autre : autres
+	// outils, autres kwargs ou autre niveau de raisonnement — inconnu, repli.
+	for name, other := range map[string]func() bool{
+		"autres outils": func() bool { return nudgeInToolOn(cfg, chatEndpoint{}, []Tool{readTool()}, kwargs, "") },
+		"autres kwargs": func() bool {
+			return nudgeInToolOn(cfg, chatEndpoint{}, tools, map[string]any{"enable_thinking": false}, "")
+		},
+		"autre effort": func() bool { return nudgeInToolOn(cfg, chatEndpoint{}, tools, kwargs, "high") },
+	} {
+		if other() {
+			t.Errorf("%s : actif sur le verdict d'une autre forme", name)
+		}
+	}
+	for _, r := range []tplProbeResult{
+		{Model: "qwen35.gguf", PrefixStable: tplUnknown},
+		{Model: "qwen35.gguf", PrefixStable: tplYes},
+		{Model: "autre.gguf", PrefixStable: tplNo},
+	} {
+		set(r)
+		if on(cfg, chatEndpoint{}) {
+			t.Fatalf("actif pour %+v", r)
+		}
+	}
+	// La dernière forme sondée (tplProbeLast) ne décide plus : une autre forme
+	// sondée « stable » ensuite ne change rien au verdict de la nôtre, et
+	// inversement.
+	set(tplProbeResult{Model: "qwen35.gguf", PrefixStable: tplNo})
+	tplProbeMu.Lock()
+	last := tplProbeResult{Model: "qwen35.gguf", PrefixStable: tplYes}
+	tplProbeLast = &last
+	tplProbeKeepShape(newTplShape(nil, kwargs, "").hash(), last)
+	tplProbeMu.Unlock()
+	if !on(cfg, chatEndpoint{}) {
+		t.Error("verdict de notre forme écrasé par la dernière forme sondée")
+	}
+}
+
+func TestNudgeIntoTool(t *testing.T) {
+	msgs := []Message{um("q"), atc("glob"), tm("res")}
+	extra := []Message{atc("glob"), tm("res")}
+	m2, e2, ok := nudgeIntoTool(msgs, extra, "[system] stop")
+	if !ok || m2[2].Content != "res\n\n[system] stop" || !reflect.DeepEqual(m2[2], e2[1]) {
+		t.Fatalf("rappel mal posé : %+v / %+v", m2, e2)
+	}
+	if msgs[2].Content != "res" || extra[1].Content != "res" {
+		t.Fatal("messages modifiés en place")
+	}
+	// Dernier message qui n'est pas un résultat d'outil, ou historique réécrit.
+	if _, _, ok := nudgeIntoTool(append(msgs, um("img")), extra, "x"); ok {
+		t.Fatal("rappel posé derrière un message user")
+	}
+	if _, _, ok := nudgeIntoTool(msgs, nil, "x"); ok {
+		t.Fatal("rappel posé sans le résultat dans l'historique")
+	}
+}
+
+// Bout à bout : avec la clé et un gabarit instable, le rappel part au bout du
+// résultat d'outil, persisté tel qu'envoyé, sans message user à part.
+func TestRappelDeBudgetDansLeResultat(t *testing.T) {
+	withWorkspace(t)
+	freshTplProbe(t)
+	for k, v := range map[string]string{"AGENT_BUDGET": "1", "NUDGE_IN_TOOL": "on", "MODEL": "/models/qwen35.gguf"} {
+		if err := SetConfigKey(k, v); err != nil {
+			t.Fatal(err)
+		}
+	}
+	// Le verdict de la sonde pour la forme exacte de la requête du tour : mêmes
+	// outils, mêmes chat_template_kwargs, même niveau de raisonnement.
+	caps := Caps{Agent: true}
+	_, effort, _, kwargs := turnReasoning(ReadConfig())
+	tplProbeMu.Lock()
+	r := tplProbeResult{Model: "qwen35.gguf", PrefixStable: tplNo}
+	tplProbeLast = &r
+	tplProbeKeepShape(newTplShape(EnabledTools(caps), kwargs, effort).hash(), r)
+	tplProbeMu.Unlock()
+	reqs := scriptedServer(t, sseGlobCall, sseChunk("fini")+sseStop)
+	extra, err := runChat(t.Context(), []Message{um("cherche")}, 0.7, caps, func(StreamEvent) bool { return true })
+	if err != nil {
+		t.Fatal(err)
+	}
+	sent := reqMessages(t, reqs()[1])
+	last := sent[len(sent)-1]
+	if last.Role != "tool" || !strings.HasSuffix(msgText(last), "unless exactly one specific call is genuinely still missing.") {
+		t.Fatalf("rappel absent du résultat d'outil : %+v", last)
+	}
+	if len(extra) != 2 || !reflect.DeepEqual(extra[1], last) {
+		t.Fatalf("historique %+v : le résultat doit y être tel qu'envoyé", extra)
+	}
+}
+
+// Le verdict « instable » d'une AUTRE forme (dernière sondée, ici sans
+// outils) ne décide pas pour ce tour : rappel à part, comme sans la clé.
+func TestRappelDeBudgetVerdictDUneAutreForme(t *testing.T) {
+	withWorkspace(t)
+	freshTplProbe(t)
+	for k, v := range map[string]string{"AGENT_BUDGET": "1", "NUDGE_IN_TOOL": "on", "MODEL": "/models/qwen35.gguf"} {
+		if err := SetConfigKey(k, v); err != nil {
+			t.Fatal(err)
+		}
+	}
+	_, effort, _, kwargs := turnReasoning(ReadConfig())
+	tplProbeMu.Lock()
+	r := tplProbeResult{Model: "qwen35.gguf", PrefixStable: tplNo}
+	tplProbeLast = &r
+	tplProbeKeepShape(newTplShape(nil, kwargs, effort).hash(), r)
+	tplProbeMu.Unlock()
+	reqs := scriptedServer(t, sseGlobCall, sseChunk("fini")+sseStop)
+	if _, err := runChat(t.Context(), []Message{um("cherche")}, 0.7, Caps{Agent: true}, func(StreamEvent) bool { return true }); err != nil {
+		t.Fatal(err)
+	}
+	sent := reqMessages(t, reqs()[1])
+	if last := sent[len(sent)-1]; last.Role != "user" {
+		t.Fatalf("rappel glissé dans le résultat sur le verdict d'une autre forme : %+v", last)
+	}
+}
+
+// En cours de tour, au seuil : les images gardées partent d'abord, et le
+// résumé n'est pas demandé si leur retrait suffit.
+func TestKeepImagesRetireesEnCoursDeTour(t *testing.T) {
+	withWorkspace(t)
+	for k, v := range map[string]string{"KEEP_TURN_IMAGES": "on", "CTX": "2000"} {
+		if err := SetConfigKey(k, v); err != nil {
+			t.Fatal(err)
+		}
+	}
+	glob := `data: {"choices":[{"delta":{"tool_calls":[{"index":0,"id":"g1","type":"function","function":{"name":"glob","arguments":"{\"pattern\":\"*.go\"}"}}]}}]}` + "\n\n" +
+		`data: {"choices":[{"delta":{},"finish_reason":"tool_calls"}]}` + "\n\n" +
+		`data: {"choices":[],"usage":{"prompt_tokens":1600,"completion_tokens":10}}` + "\n\ndata: [DONE]\n\n"
+	reqs := visionServer(t, glob, sseAnswer("fini", 0))
+	hist := []Message{um("q"), atc("see_image"), tm("[ok]"), keptRelay(1000), am("vu"), um("suite")}
+	var published []Message
+	extra, err := runChat(mainCtx(t), hist, 0.7, Caps{Agent: true}, func(ev StreamEvent) bool {
+		if ev.NewHistory != nil {
+			published = ev.NewHistory
+		}
+		return true
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if n := len(reqs()); n != 2 {
+		t.Fatalf("%d requêtes : un résumé est parti alors que retirer l'image suffisait", n)
+	}
+	if published == nil || hasKeptImages(published) || len(published) != len(hist)+2 {
+		t.Fatalf("historique publié : %+v", published)
+	}
+	if published[3].Content != "Voici la capture demandée."+imageLostMarker {
+		t.Fatalf("relais publié : %+v", published[3])
+	}
+	if relay := reqMessages(t, reqs()[1])[3]; msgText(relay) != "Voici la capture demandée."+imageLostMarker {
+		t.Fatalf("image encore envoyée après son retrait : %+v", relay)
+	}
+	if len(extra) != 0 {
+		t.Fatalf("extra après publication : %+v", extra)
+	}
+}
+
+// Budget déjà plein : l'image suivante reste éphémère sans même être rangée.
+func TestKeepImagesBudgetPleinAvantRangement(t *testing.T) {
+	testHome(t)
+	k := &keepImages{}
+	msgs := []Message{um("q"), keptRelay(keepImgBudget())}
+	img := seeImageMessage("x.png", imageURLPart([]byte("png"), "image/png"))
+	got, extra := k.relay(msgs, nil, img, 1)
+	if len(got) != 3 || len(extra) != 0 || !k.stopped || len(k.pend) != 0 || !got[2].ImgRelay {
+		t.Fatalf("relais au budget plein : %+v / %+v", got, k)
+	}
+	if ents, _ := os.ReadDir(chatImgDir()); len(ents) != 0 {
+		t.Fatal("image rangée alors que le budget était plein")
+	}
+}
+
+// Corrections de relecture du lot 2 : prompt refusé pour débordement alors que
+// des images sont gardées — elles partent d'abord et la requête est rejouée
+// sans elles, sans résumé (avec perte) tant que ça suffit.
+func TestKeepImagesRetireesAvantLeFiletReactif(t *testing.T) {
+	withWorkspace(t)
+	for k, v := range map[string]string{"KEEP_TURN_IMAGES": "on", "CTX": "2000"} {
+		if err := SetConfigKey(k, v); err != nil {
+			t.Fatal(err)
+		}
+	}
+	var mu sync.Mutex
+	var bodies []map[string]any
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/props" {
+			_, _ = w.Write([]byte(`{"modalities":{"vision":true}}`))
+			return
+		}
+		var body map[string]any
+		_ = json.NewDecoder(r.Body).Decode(&body)
+		mu.Lock()
+		bodies = append(bodies, body)
+		n := len(bodies)
+		mu.Unlock()
+		if n == 1 {
+			w.WriteHeader(http.StatusBadRequest)
+			_, _ = w.Write([]byte(`{"error":{"code":400,"message":"request (2500 tokens) exceeds the available context size (2000 tokens), try increasing it"}}`))
+			return
+		}
+		w.Header().Set("Content-Type", "text/event-stream")
+		_, _ = w.Write([]byte(sseAnswer("fini", 0)))
+	}))
+	t.Cleanup(srv.Close)
+	u, _ := url.Parse(srv.URL)
+	for k, v := range map[string]string{"PORT": u.Port(), "MMPROJ": "/models/mmproj.gguf"} {
+		if err := SetConfigKey(k, v); err != nil {
+			t.Fatal(err)
+		}
+	}
+	visionProbeMu.Lock()
+	visionProbeAt = time.Time{}
+	visionProbeMu.Unlock()
+	hist := []Message{um("q"), atc("see_image"), tm("[ok]"), keptRelay(1000), am("vu"), um("suite")}
+	var published []Message
+	if _, err := runChat(mainCtx(t), hist, 0.7, Caps{Agent: true}, func(ev StreamEvent) bool {
+		if ev.NewHistory != nil {
+			published = ev.NewHistory
+		}
+		return true
+	}); err != nil {
+		t.Fatal(err)
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	if len(bodies) != 2 {
+		t.Fatalf("%d requêtes : un résumé est parti alors que retirer l'image suffisait", len(bodies))
+	}
+	if published == nil || hasKeptImages(published) || len(published) != len(hist) {
+		t.Fatalf("historique publié : %+v", published)
+	}
+	if relay := reqMessages(t, bodies[1])[3]; msgText(relay) != "Voici la capture demandée."+imageLostMarker {
+		t.Fatalf("image encore envoyée après son retrait : %+v", relay)
+	}
+}

internal/loki/chat_persist.go

@@ -74,6 +74,11 @@ type convPersister struct {
 	queued  uint64               // tickets délivrés
 	done    uint64               // tickets traités (écrits, abandonnés ou en échec)
 	running bool
+
+	// Résultats d'outils du lot en cours d'écriture, et ceux d'entre eux qu'une
+	// suppression a annulés depuis : l'écrivain les saute dans sa transaction.
+	inflight  map[string]bool
+	cancelled map[string]bool
 }
 
 var (
@@ -92,6 +97,9 @@ func newConvPersister() *convPersister {
 		mem:     map[string]string{},
 		written: map[string]uint64{},
 		deleted: map[string]bool{},
+
+		inflight:  map[string]bool{},
+		cancelled: map[string]bool{},
 	}
 	p.cond = sync.NewCond(&p.mu)
 	return p
@@ -157,6 +165,7 @@ func (p *convPersister) run() {
 		for _, j := range p.res {
 			if !p.deleted[toolResConv(j.key)] {
 				res = append(res, j)
+				p.inflight[j.key] = true
 			}
 		}
 		p.snaps, p.res = map[string]*convSnap{}, nil
@@ -166,6 +175,10 @@ func (p *convPersister) run() {
 		wrote, err := persistCommitByPath(snaps, res)
 
 		p.mu.Lock()
+		for _, j := range res {
+			delete(p.inflight, j.key)
+			delete(p.cancelled, j.key)
+		}
 		for _, s := range wrote {
 			if s.seq > p.written[s.id] {
 				p.written[s.id] = s.seq
@@ -225,6 +238,13 @@ func (p *convPersister) dropToolRes(prefix string) {
 }
 
 func (p *convPersister) dropToolResLocked(prefix string) {
+	// Déjà pris par l'écrivain : trop tard pour le retirer de la file, pas pour
+	// l'empêcher d'atteindre la base (voir toolResWanted).
+	for k := range p.inflight {
+		if strings.HasPrefix(k, prefix) {
+			p.cancelled[k] = true
+		}
+	}
 	for k := range p.mem {
 		if strings.HasPrefix(k, prefix) {
 			delete(p.mem, k)
@@ -239,6 +259,17 @@ func (p *convPersister) dropToolResLocked(prefix string) {
 	p.res = kept
 }
 
+// toolResWanted : ce résultat du lot en cours doit-il encore être écrit ?
+// Appelé par l'écrivain DANS sa transaction. Une suppression annule avant
+// d'ouvrir la sienne (deleteToolResultsFor) : soit l'écrivain voit
+// l'annulation et saute le résultat, soit il l'a déjà écrit et la suppression,
+// sérialisée après lui par bbolt, l'efface. Jamais de résultat qui renaît.
+func (p *convPersister) toolResWanted(key string) bool {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	return !p.cancelled[key]
+}
+
 // toolResPending relit un résultat pas encore sur disque.
 func (p *convPersister) toolResPending(key string) (string, bool) {
 	p.mu.Lock()
@@ -338,6 +369,9 @@ func commitPersistBatch(path string, snaps []*convSnap, res []toolResJob) ([]*co
 					return err
 				}
 				for _, j := range res {
+					if !persistQ.toolResWanted(j.key) {
+						continue // supprimé avec sa discussion pendant que le lot partait
+					}
 					enc, err := encode([]byte(j.plain))
 					if err != nil {
 						return err

internal/loki/chat_persist_test.go

@@ -187,6 +187,29 @@ func TestToolResultSupprimeAvantEcriture(t *testing.T) {
 	}
 }
 
+// Un résultat que l'écrivain a DÉJÀ pris dans son lot, supprimé avant que ce
+// lot n'atteigne la base, ne renaît pas après la suppression. C'était la cause
+// des échecs intermittents de TestToolResultsSaveLoadDelete : la suppression ne
+// retirait que la file d'attente, et l'écriture en vol passait après elle.
+func TestToolResultSupprimePendantEcriture(t *testing.T) {
+	testHome(t)
+	entered, release := gatePersist(t)
+	id := saveToolResult(strings.Repeat("a", 3000))
+	waitEntered(t, entered) // le lot est pris, pas encore écrit
+	deleteToolResultsFor(toolResConv(id))
+	close(release)
+	persistQ.flush()
+	if _, ok := loadToolResult(id); ok {
+		t.Fatal("un résultat supprimé pendant son écriture a été écrit quand même")
+	}
+	// L'annulation ne vaut que pour ce lot : un nouveau résultat s'écrit.
+	again := saveToolResult(strings.Repeat("b", 3000))
+	persistQ.flush()
+	if _, ok := loadToolResult(again); !ok {
+		t.Fatal("annulation restée collée : le résultat suivant n'a pas été écrit")
+	}
+}
+
 // compactLog rend exactement ce que donne la compaction de fin de tour, sans
 // toucher au journal d'origine.
 func TestCompactLogPurEgalFinDeTour(t *testing.T) {

internal/loki/chat_prewarm.go

@@ -0,0 +1,450 @@
+package loki
+
+// chat_prewarm.go — PREWARM : préparer le prochain tour pendant que
+// l'utilisateur lit.
+//
+// Pourquoi. Certains recalculs sont inévitables : le prompt réécrit par une
+// compaction (12 à 20k jetons), le dernier message assistant rendu autrement
+// au tour suivant (réflexion retirée par le gabarit, raisonnement jamais
+// renvoyé), la discussion reprise après une tâche planifiée qui a pris le slot.
+// Sans la clé, ils tombent sur le premier jeton du message suivant : des
+// secondes sur un 27B, des dizaines sur un MoE aux experts en RAM.
+//
+// Avec la clé (off par défaut), Loki envoie au moteur local, dès qu'il est
+// libre, la requête du prochain tour telle qu'elle partira — assemblée par
+// les MÊMES fonctions (turnViewDry, wireMessages, buildChatPayload), contenu
+// vivant, rien de figé ni de mémorisé pour gagner du cache — suivie d'un
+// message utilisateur sentinelle « . », avec max_tokens 1. Le moteur calcule
+// tout le préfixe et pose un point de reprise au début de ce dernier message :
+// le vrai tour ne calcule plus que son propre message. Le jeton produit et la
+// sentinelle sont jetés ; rien n'est persisté, ni dans la discussion, ni dans
+// le journal, ni dans les compteurs (CtxUsed, stats, effort appris).
+//
+// Ce que le modèle voit ne change pas : llama-server ne reprend un état que sur
+// un préfixe de jetons identique, et la vraie requête est construite à l'envoi,
+// comme toujours. Au pire, le préchauffage ne sert à rien.
+//
+// Il ne passe jamais devant un vrai travail :
+//   - moteur local seulement, un seul slot (/props total_slots = 1 : ni
+//     PARALLEL ni -np d'EXTRA_ARGS ne peuvent le contredire) — ou les deux de
+//     SIDE_SLOT en service, et il vise alors le slot de la discussion
+//     (id_slot 0, llm_sideslot.go) ;
+//   - jamais pendant un tour, une tâche, une compaction, un bench, un travail
+//     annexe, ni s'il reste une requête de Loki en vol (compteur de
+//     llm_slots.go, qu'il tient lui-même : l'isolation des slots n'efface rien
+//     pendant qu'il tourne) ;
+//   - toute requête de Loki vers le moteur l'annule à l'instant de partir —
+//     sauf un tour de chat dont la requête PROLONGE exactement le préfixe
+//     préchauffé (empreintes des messages sérialisés, des outils et des
+//     arguments du gabarit) : elle suit alors dans le même slot et réutilise
+//     ce qui vient d'être calculé, sans rien attendre d'inutile ;
+//   - un seul en vol ; un nouveau déclencheur annule l'ancien ;
+//   - aucune erreur ne remonte : 400 (contexte plein), 503 (chargement), 500
+//     (gabarit) sont lâchés, sans compaction, sans relance, sans rien apprendre.
+//
+// Déclencheurs : fin d'un tour (compaction de fin de tour comprise) quand rien
+// n'attend dans la file, fin d'une tâche planifiée (slot déjà effacé, projet
+// forcé déjà levé). PREWARM=full ajoute le changement de discussion, après 3 s
+// sans nouveau changement. Les capacités sont celles du dernier tour de la
+// discussion, gardées en mémoire ; en mode Code, le rôle est celui d'un message
+// ordinaire (builder) — une demande de plan diverge et annule.
+//
+// Limites, sans effet sur la fidélité : un moteur sans point de reprise au
+// début des messages utilisateur, ou des images juste avant (le moteur n'en
+// pose pas après un bloc d'image), retombe sur un recalcul complet et exact ;
+// changer agent, web ou mémoire avant d'envoyer rend le préchauffage inutile.
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"hash/fnv"
+	"io"
+	"net/http"
+	"os"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+// prewarmMode : « on », « full » ou "" (off). Jamais pour un preset externe.
+func prewarmMode(cfg map[string]string) string {
+	if isExternalConfig(cfg) {
+		return ""
+	}
+	switch strings.ToLower(strings.TrimSpace(cfg["PREWARM"])) {
+	case "on", "1", "true", "yes", "oui":
+		return "on"
+	case "full":
+		return "full"
+	}
+	return ""
+}
+
+// Déclencheurs (pour le journal).
+const (
+	prewarmTurnEnd   = "fin-tour"
+	prewarmAfterTask = "après-tâche"
+	prewarmSwitch    = "discussion"
+)
+
+// prewarmSentinel : le message utilisateur qui tient la place du vrai.
+const prewarmSentinel = "."
+
+// prewarmRun : un préchauffage en vol. prefix couvre ses n premiers messages
+// (sans la sentinelle), opts les champs qui façonnent le rendu.
+type prewarmRun struct {
+	n      int
+	prefix uint64
+	opts   uint64
+	cancel context.CancelFunc
+	done   chan struct{}
+}
+
+// prewarmCur : le préchauffage en vol, protégé par engineGate.mu (llm_slots.go).
+// prewarmLive le reflète sans verrou : sans préchauffage, une requête ne
+// calcule aucune empreinte.
+var (
+	prewarmCur  *prewarmRun
+	prewarmLive atomic.Bool
+)
+
+// prewarmDropLocked annule p, engineGate.mu tenu. Le client ferme la
+// connexion, et llama-server arrête la tâche (au plus un micro-lot plus tard).
+func prewarmDropLocked(p *prewarmRun) {
+	if prewarmCur == p {
+		prewarmCur = nil
+		prewarmLive.Store(false)
+	}
+	p.cancel()
+}
+
+// prewarmBegin inscrit p comme LA requête en vol, si le moteur est libre de
+// toute autre requête de Loki. end le retire (une seule fois).
+func prewarmBegin(p *prewarmRun) (end func(), ok bool) {
+	engineGate.mu.Lock()
+	defer engineGate.mu.Unlock()
+	if engineGate.inflight > 0 || prewarmCur != nil {
+		return nil, false
+	}
+	prewarmCur = p
+	prewarmLive.Store(true)
+	engineGate.inflight++
+	engineGate.seq++ // le slot ne porte plus le tour d'avant (engineSlotHolds)
+	var once sync.Once
+	return func() {
+		once.Do(func() {
+			engineGate.mu.Lock()
+			engineGate.inflight--
+			if prewarmCur == p {
+				prewarmCur = nil
+				prewarmLive.Store(false)
+			}
+			engineGate.mu.Unlock()
+		})
+	}, true
+}
+
+// prewarmStop annule le préchauffage en vol et rend celui-ci (nil sinon), pour
+// qu'on puisse attendre sa fin.
+func prewarmStop() *prewarmRun {
+	// Cas de toujours : rien en vol, et pas de verrou à prendre (l'effacement
+	// d'un slot peut le tenir deux secondes).
+	if !prewarmLive.Load() {
+		return nil
+	}
+	engineGate.mu.Lock()
+	defer engineGate.mu.Unlock()
+	p := prewarmCur
+	if p != nil {
+		prewarmDropLocked(p)
+	}
+	return p
+}
+
+// matches : la requête dont prefix est l'empreinte cumulée des messages
+// (perfPrefix) prolonge-t-elle exactement ce préchauffage ?
+func (p *prewarmRun) matches(prefix []uint64, opts uint64) bool {
+	return p.n > 0 && len(prefix) > p.n && prefix[p.n-1] == p.prefix && opts == p.opts
+}
+
+// prewarmOptsKeys : les champs du corps, hors messages, qui changent le prompt
+// rendu par le gabarit. L'échantillonnage n'y est pas : il ne touche pas au
+// prompt.
+var prewarmOptsKeys = []string{"tools", "parallel_tool_calls", "tool_choice", "chat_template_kwargs", "reasoning_effort"}
+
+func prewarmOptsHash(payload map[string]any) uint64 {
+	h := fnv.New64a()
+	for _, k := range prewarmOptsKeys {
+		h.Write([]byte(k))
+		h.Write([]byte{0})
+		if v, ok := payload[k]; ok {
+			b, _ := json.Marshal(v)
+			h.Write(b)
+		}
+		h.Write([]byte{0})
+	}
+	return h.Sum64()
+}
+
+// prewarmKeeper : pour runChat, ce qui reconnaît un préchauffage à garder. nil
+// (tout annuler) hors tour de chat, ou sans préchauffage en vol — dans ce cas,
+// le cas de toujours, rien n'est calculé.
+func prewarmKeeper(kind string, sent []Message, payload map[string]any) func(*prewarmRun) bool {
+	if kind != perfMain || !prewarmLive.Load() {
+		return nil
+	}
+	prefix, opts := perfPrefix(sent), prewarmOptsHash(payload)
+	return func(p *prewarmRun) bool { return p.matches(prefix, opts) }
+}
+
+// Capacités du dernier tour de chaque discussion, en mémoire seulement : le
+// client les envoie avec chaque message, le serveur ne les connaît pas sinon.
+var prewarmCaps struct {
+	mu sync.Mutex
+	m  map[string]Caps
+}
+
+const prewarmCapsMax = 64
+
+func prewarmNoteCaps(convID string, caps Caps) {
+	if convID == "" {
+		return
+	}
+	prewarmCaps.mu.Lock()
+	defer prewarmCaps.mu.Unlock()
+	if prewarmCaps.m == nil {
+		prewarmCaps.m = map[string]Caps{}
+	}
+	if _, ok := prewarmCaps.m[convID]; !ok && len(prewarmCaps.m) >= prewarmCapsMax {
+		for k := range prewarmCaps.m {
+			delete(prewarmCaps.m, k)
+			break
+		}
+	}
+	prewarmCaps.m[convID] = caps
+}
+
+func prewarmCapsFor(convID string) (Caps, bool) {
+	prewarmCaps.mu.Lock()
+	defer prewarmCaps.mu.Unlock()
+	c, ok := prewarmCaps.m[convID]
+	return c, ok
+}
+
+// prewarmNearMidnight : la date du jour fait partie du prompt système ; à
+// moins de 10 min de minuit, le prochain message a toutes les chances de
+// partir avec la suivante.
+func prewarmNearMidnight(now time.Time) bool {
+	y, m, d := now.Date()
+	next := time.Date(y, m, d+1, 0, 0, 0, 0, now.Location())
+	return next.Sub(now) < 10*time.Minute
+}
+
+// Points d'accroche remplaçables par les tests.
+var (
+	// prewarmAsync : false = le préchauffage tourne dans l'appelant (tests).
+	prewarmAsync = true
+	// prewarmSlots : nombre de slots du moteur local (/props total_slots).
+	prewarmSlots = func(ep chatEndpoint) int {
+		var props struct {
+			TotalSlots int `json:"total_slots"`
+		}
+		iso := slotIsolator{base: fmt.Sprintf("http://localhost:%d", LLMPort()), auth: ep.auth, client: http.DefaultClient}
+		if err := iso.get(context.Background(), "/props", &props); err != nil {
+			return 0
+		}
+		return props.TotalSlots
+	}
+	prewarmSwitchDelay = 3 * time.Second
+	// prewarmTimeout : borne d'un préchauffage (un MoE aux experts en RAM met
+	// des minutes sur 20k jetons). Toute vraie requête l'annule bien avant.
+	prewarmTimeout = 15 * time.Minute
+)
+
+// prewarmKick : un déclencheur. Sans la clé, rien — ni goroutine, ni requête.
+func (c *Conversation) prewarmKick(why string) {
+	if prewarmMode(ReadConfig()) == "" {
+		return
+	}
+	if prewarmAsync {
+		go c.prewarm(why)
+		return
+	}
+	c.prewarm(why)
+}
+
+// prewarmAfterSwitch : changement de discussion. Le préchauffage de l'ancienne
+// est annulé ; avec PREWARM=full, la nouvelle est préparée si l'utilisateur y
+// reste 3 s (cliquer d'une discussion à l'autre ne lance rien).
+func prewarmAfterSwitch() {
+	prewarmStop() // sa fin n'est pas attendue : le changement ne doit pas bloquer
+	if prewarmMode(ReadConfig()) != "full" {
+		return
+	}
+	id := convActiveID()
+	time.AfterFunc(prewarmSwitchDelay, func() {
+		if convActiveID() == id {
+			conv.prewarmKick(prewarmSwitch)
+		}
+	})
+}
+
+// prewarmBodyFor construit le corps du préchauffage de c, ou "" avec la raison
+// de s'abstenir. Lecture seule : rien n'est modifié dans la discussion.
+func (c *Conversation) prewarmBodyFor(ep chatEndpoint, cfg map[string]string) (payload map[string]any, run *prewarmRun, skip string) {
+	caps, ok := prewarmCapsFor(convActiveID())
+	if !ok {
+		return nil, nil, "capacités du dernier tour inconnues"
+	}
+	caps = withTurnRole(caps, prewarmSentinel)
+
+	c.mu.Lock()
+	if c.Generating {
+		c.mu.Unlock()
+		return nil, nil, "moteur occupé"
+	}
+	msgs := append([]Message(nil), c.Messages...)
+	ctxNow := c.ctxNowLocked(msgs, true)
+	peak := c.genPeak
+	c.mu.Unlock()
+
+	hasUser := false
+	for _, m := range msgs {
+		if m.Role == "user" {
+			hasUser = true
+			break
+		}
+	}
+	// Sans message utilisateur dans l'historique, le contexte projet irait en
+	// tête de la sentinelle (normalizeSystemMessages) : rien à préparer.
+	if !hasUser {
+		return nil, nil, "discussion vide"
+	}
+	msgs = append(msgs, Message{Role: "user", Content: prewarmSentinel})
+	// Le prochain tour compactera d'abord : son prompt ne sera pas celui-ci.
+	if compactNeeded(msgs, ctxNow, peak) {
+		return nil, nil, "compaction attendue au prochain tour"
+	}
+
+	sent, tools := c.turnViewDry(caps, msgs, caps.Agent)
+	_, effort, _, kwargs := turnReasoning(cfg)
+	wire, _ := wireMessages(sent, false, turnEchoPolicy(false))
+	n := len(wire)
+	if n < 2 || wire[n-1].Role != "user" {
+		return nil, nil, "assemblage inattendu"
+	}
+	if s, _ := wire[n-1].Content.(string); s != prewarmSentinel {
+		return nil, nil, "assemblage inattendu"
+	}
+	payload = buildChatPayload(ep, wire, 0.7, chatPayloadOpts{tools: tools, effort: effort, kwargs: kwargs})
+	// Seuls les champs de réponse changent : une réponse d'un seul jeton, non
+	// streamée (jetée de toute façon).
+	payload["stream"] = false
+	delete(payload, "stream_options")
+	payload["max_tokens"] = 1
+	return payload, &prewarmRun{n: n - 1, prefix: perfPrefix(wire)[n-2], opts: prewarmOptsHash(payload)}, ""
+}
+
+var prewarmLogged sync.Map // raison d'échec → déjà journalisée
+
+func prewarmLogOnce(key, format string, args ...any) {
+	if _, dup := prewarmLogged.LoadOrStore(key, true); dup {
+		return
+	}
+	fmt.Fprintf(os.Stderr, "[prewarm] "+format+"\n", args...)
+}
+
+// prewarm : un préchauffage complet, ou rien. Jamais d'erreur rendue.
+func (c *Conversation) prewarm(why string) {
+	cfg := ReadConfig()
+	if prewarmMode(cfg) == "" {
+		return
+	}
+	ep := resolveChatEndpoint()
+	if ep.External {
+		return
+	}
+	// Un seul en vol : le nouveau déclencheur remplace l'ancien.
+	if p := prewarmStop(); p != nil {
+		select {
+		case <-p.done:
+		case <-time.After(5 * time.Second):
+			return
+		}
+	}
+	if sideJobs.Load() > 0 || benchRunning() || tuneGuard() != nil || prewarmNearMidnight(time.Now()) {
+		return
+	}
+	if !healthCheck() {
+		return
+	}
+	// Un seul slot, ou les deux de SIDE_SLOT : le préchauffage vise alors le
+	// slot de la discussion (id_slot 0), celui où partira le vrai tour.
+	slot := -1
+	if n := prewarmSlots(ep); n != 1 {
+		if slot = engineSlotFor(ep, true); n != 2 || slot != 0 {
+			return
+		}
+	}
+	payload, run, skip := c.prewarmBodyFor(ep, cfg)
+	if skip != "" {
+		return
+	}
+	setEngineSlot(payload, slot)
+	body, err := json.Marshal(payload)
+	if err != nil {
+		return
+	}
+	// SLOT_PERSIST : l'état gardé de la discussion d'abord, s'il y en a un — le
+	// préchauffage le prolonge au lieu de tout recalculer.
+	slotPersistRestore(ep, convActiveID())
+	ctx, cancel := context.WithTimeout(context.Background(), prewarmTimeout)
+	defer cancel()
+	run.cancel, run.done = cancel, make(chan struct{})
+	defer close(run.done)
+	end, ok := prewarmBegin(run)
+	if !ok {
+		return // une requête de Loki est partie entre-temps
+	}
+	defer end()
+	ctx = withPerf(ctx, perfPrewarm, convActiveID())
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, ep.URL, bytes.NewReader(body))
+	if err != nil {
+		return
+	}
+	req.Header.Set("Content-Type", "application/json")
+	ep.auth(req.Header.Set)
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		if ctx.Err() == nil {
+			prewarmLogOnce("net", "moteur injoignable (%s) : %v", why, err)
+		}
+		return
+	}
+	defer resp.Body.Close()
+	raw, err := io.ReadAll(io.LimitReader(resp.Body, 1<<20))
+	if err != nil {
+		return
+	}
+	if resp.StatusCode != http.StatusOK {
+		prewarmLogOnce(resp.Status, "refusé par le moteur (%s) : %s %s", why, resp.Status, strings.TrimSpace(string(raw[:min(len(raw), 200)])))
+		return
+	}
+	// Télémétrie seulement (kind=prewarm) : la réponse est jetée.
+	rec := perfRecord(perfRecFromWire(perfTagOf(ctx), decodePerfWire(raw)), nil)
+	// Après une tâche, c'est lui qui retrouve (ou non) la conversation dans le
+	// cache RAM : la vérification de llm_slots.go se fait donc ici — le vrai
+	// tour, servi depuis le slot préchauffé, n'aurait plus rien à en dire. Le
+	// conseil va au journal (aucun fil où l'afficher).
+	if rec.Total > 0 {
+		cached := 0
+		if rec.Cached != nil {
+			cached = *rec.Cached
+		}
+		noteEnginePrompt(rec.Total, cached, rec.Cached != nil)
+	}
+}

internal/loki/chat_prewarm_test.go

@@ -0,0 +1,525 @@
+package loki
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"reflect"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+)
+
+// moteurPrewarm : faux llama-server qui note TOUTES les requêtes (chemin et
+// corps), sert /health et /props, et répond aux complétions streamées comme aux
+// autres.
+type moteurPrewarm struct {
+	mu    sync.Mutex
+	reqs  []prewarmReq
+	slots int
+}
+
+type prewarmReq struct{ path, body string }
+
+func (m *moteurPrewarm) start(t *testing.T) {
+	t.Helper()
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		var buf bytes.Buffer
+		_, _ = buf.ReadFrom(r.Body)
+		m.mu.Lock()
+		m.reqs = append(m.reqs, prewarmReq{r.URL.Path, buf.String()})
+		slots := m.slots
+		m.mu.Unlock()
+		switch r.URL.Path {
+		case "/health":
+			sendJSON(w, 200, map[string]any{"status": "ok"})
+		case "/props":
+			sendJSON(w, 200, map[string]any{"total_slots": slots, "build_info": "b9000-x"})
+		default:
+			if strings.Contains(buf.String(), `"stream":true`) {
+				w.Header().Set("Content-Type", "text/event-stream")
+				_, _ = w.Write([]byte(sseChunk("ok.") + sseFinal("stop", 100, 2) + "data: [DONE]\n\n"))
+				return
+			}
+			sendJSON(w, 200, map[string]any{
+				"choices": []any{map[string]any{"message": map[string]any{"content": "x"}}},
+				"usage":   map[string]any{"prompt_tokens": 120, "completion_tokens": 1},
+				"timings": map[string]any{"prompt_n": 4, "cache_n": 116, "predicted_n": 1},
+			})
+		}
+	}))
+	t.Cleanup(srv.Close)
+	u, _ := url.Parse(srv.URL)
+	if err := SetConfigKey("PORT", u.Port()); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func (m *moteurPrewarm) all() []prewarmReq {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	return append([]prewarmReq(nil), m.reqs...)
+}
+
+// completions : corps des complétions, streamées ou non.
+func (m *moteurPrewarm) completions() []string {
+	var out []string
+	for _, r := range m.all() {
+		if r.path == "/v1/chat/completions" {
+			out = append(out, r.body)
+		}
+	}
+	return out
+}
+
+// prewarmSetup : base neuve, discussion active, faux moteur à un slot,
+// préchauffage synchrone. keys : réglages posés.
+func prewarmSetup(t *testing.T, keys map[string]string) *moteurPrewarm {
+	t.Helper()
+	withWorkspace(t)
+	activeProjMu.Lock()
+	activeProjCache = ""
+	activeProjMu.Unlock()
+	setProjectOverride("")
+	t.Cleanup(func() {
+		activeProjMu.Lock()
+		activeProjCache = ""
+		activeProjMu.Unlock()
+		setProjectOverride("")
+	})
+	ensureDefaultProject()
+	freshTplProbe(t)
+	convEnsureActive()
+	prewarmAsync = false
+	prewarmCaps.mu.Lock()
+	prewarmCaps.m = nil
+	prewarmCaps.mu.Unlock()
+	t.Cleanup(func() {
+		prewarmAsync = true
+		prewarmCaps.mu.Lock()
+		prewarmCaps.m = nil
+		prewarmCaps.mu.Unlock()
+	})
+	if err := SetConfigKey("MODEL", "/models/"+echoTestModel); err != nil {
+		t.Fatal(err)
+	}
+	for k, v := range keys {
+		if err := SetConfigKey(k, v); err != nil {
+			t.Fatal(err)
+		}
+	}
+	m := &moteurPrewarm{slots: 1}
+	m.start(t)
+	return m
+}
+
+// prewarmTurn : un tour de chat comme StartTurn le lance (capacités notées pour
+// le préchauffage), joué jusqu'au bout, préchauffage éventuel compris.
+func prewarmTurn(t *testing.T, c *Conversation, caps Caps, text string) {
+	t.Helper()
+	prewarmNoteCaps(convActiveID(), caps)
+	c.mu.Lock()
+	c.Messages = append(c.Messages, um(text))
+	c.mu.Unlock()
+	c.generate(context.Background(), withTurnRole(caps, text), 0.7, c.epoch)
+}
+
+// Clé absente : pas une requête de plus au moteur — ni complétion, ni /health,
+// ni /props — et la conversation est celle d'avant.
+func TestPrewarmDefautAucuneRequete(t *testing.T) {
+	m := prewarmSetup(t, nil)
+	c := newTestConv()
+	caps := Caps{Agent: true, Mem: MemAlways}
+	prewarmTurn(t, c, caps, "bonjour")
+	prewarmTurn(t, c, caps, "et ensuite ?")
+	reqs := m.all()
+	if len(reqs) != 2 {
+		t.Fatalf("2 requêtes attendues (une par tour), %d reçues : %+v", len(reqs), reqs)
+	}
+	for _, r := range reqs {
+		if r.path != "/v1/chat/completions" || strings.Contains(r.body, `"max_tokens"`) || !strings.Contains(r.body, `"stream":true`) {
+			t.Fatalf("requête inattendue sans la clé : %s %s", r.path, r.body)
+		}
+	}
+	// La fin de tour ne lance rien non plus en direct.
+	c.prewarm(prewarmTurnEnd)
+	if n := len(m.all()); n != 2 {
+		t.Fatalf("prewarm sans la clé a parlé au moteur (%d requêtes)", n)
+	}
+}
+
+// Preset externe : la clé est sans effet.
+func TestPrewarmJamaisExterne(t *testing.T) {
+	cfg := map[string]string{"PREWARM": "on", extKeyFlag: "1", extKeyURL: "http://127.0.0.1:1"}
+	if prewarmMode(cfg) != "" {
+		t.Fatal("PREWARM actif sur un preset externe")
+	}
+	for v, want := range map[string]string{"": "", "off": "", "on": "on", "1": "on", "full": "full", "FULL": "full", "x": ""} {
+		if got := prewarmMode(map[string]string{"PREWARM": v}); got != want {
+			t.Fatalf("PREWARM=%q : %q, attendu %q", v, got, want)
+		}
+	}
+}
+
+// Avec la clé : la requête de préchauffage est celle du prochain tour, sentinelle
+// en plus — mêmes messages jusqu'au dernier, mêmes outils et arguments du
+// gabarit — avec max_tokens 1, sans flux. Rien n'en reste dans la discussion,
+// et la télémétrie la range sous kind=prewarm.
+func TestPrewarmEgalTourSuivantPlusSentinelle(t *testing.T) {
+	m := prewarmSetup(t, map[string]string{"PREWARM": "on", "REASONING_EFFORT": "high", "TOP_P": "0.9"})
+	if err := MemAdd("nas.md", "# NAS\n"); err != nil {
+		t.Fatal(err)
+	}
+	c := newTestConv()
+	caps := Caps{Agent: true, Mem: MemAlways}
+	prewarmTurn(t, c, caps, "bonjour")
+	comps := m.completions()
+	if len(comps) != 2 {
+		t.Fatalf("tour + préchauffage attendus, %d complétions", len(comps))
+	}
+	var pw map[string]any
+	if err := json.Unmarshal([]byte(comps[1]), &pw); err != nil {
+		t.Fatal(err)
+	}
+	if pw["stream"] != false || pw["max_tokens"] != float64(1) || pw["stream_options"] != nil {
+		t.Fatalf("champs de réponse du préchauffage : stream=%v max_tokens=%v stream_options=%v", pw["stream"], pw["max_tokens"], pw["stream_options"])
+	}
+	c.mu.Lock()
+	for _, msg := range c.Messages {
+		if s, _ := msg.Content.(string); s == prewarmSentinel {
+			c.mu.Unlock()
+			t.Fatal("la sentinelle a été rangée dans la discussion")
+		}
+	}
+	c.mu.Unlock()
+
+	prewarmTurn(t, c, caps, "et ensuite ?")
+	comps = m.completions()
+	var real map[string]any
+	if err := json.Unmarshal([]byte(comps[2]), &real); err != nil {
+		t.Fatal(err)
+	}
+	pm, rm := pw["messages"].([]any), real["messages"].([]any)
+	if len(pm) != len(rm) {
+		t.Fatalf("préchauffage %d messages, tour suivant %d", len(pm), len(rm))
+	}
+	if !reflect.DeepEqual(pm[:len(pm)-1], rm[:len(rm)-1]) {
+		t.Fatalf("préfixe différent du tour suivant :\npréchauffage %v\ntour         %v", pm[:len(pm)-1], rm[:len(rm)-1])
+	}
+	if last := pm[len(pm)-1].(map[string]any); last["role"] != "user" || last["content"] != prewarmSentinel {
+		t.Fatalf("dernier message du préchauffage : %v", last)
+	}
+	for _, k := range append([]string{"temperature", "top_p", "model"}, prewarmOptsKeys...) {
+		if !reflect.DeepEqual(pw[k], real[k]) {
+			t.Fatalf("champ %s : préchauffage %v, tour %v", k, pw[k], real[k])
+		}
+	}
+	found := false
+	for _, r := range perfLog.snapshot() {
+		if r.Kind == perfPrewarm {
+			found = true
+		}
+	}
+	if !found {
+		t.Fatal("aucune complétion kind=prewarm dans la télémétrie")
+	}
+}
+
+// Les garde-fous : plus d'un slot, tour en cours, capacités inconnues, travail
+// annexe — aucune complétion de préchauffage.
+func TestPrewarmGardeFous(t *testing.T) {
+	m := prewarmSetup(t, map[string]string{"PREWARM": "on"})
+	c := newTestConv()
+	caps := Caps{Agent: true}
+	c.mu.Lock()
+	c.Messages = []Message{um("bonjour"), am("salut")}
+	c.mu.Unlock()
+	count := func() int { return len(m.completions()) }
+
+	// Capacités inconnues (aucun tour joué dans cette discussion).
+	c.prewarm(prewarmTurnEnd)
+	if count() != 0 {
+		t.Fatal("préchauffage sans capacités connues")
+	}
+	prewarmNoteCaps(convActiveID(), caps)
+
+	m.mu.Lock()
+	m.slots = 2
+	m.mu.Unlock()
+	c.prewarm(prewarmTurnEnd)
+	if count() != 0 {
+		t.Fatal("préchauffage avec deux slots")
+	}
+	m.mu.Lock()
+	m.slots = 1
+	m.mu.Unlock()
+
+	c.mu.Lock()
+	c.Generating = true
+	c.mu.Unlock()
+	c.prewarm(prewarmTurnEnd)
+	c.mu.Lock()
+	c.Generating = false
+	c.mu.Unlock()
+	if count() != 0 {
+		t.Fatal("préchauffage pendant un tour")
+	}
+
+	sideJobs.Add(1)
+	c.prewarm(prewarmTurnEnd)
+	sideJobs.Add(-1)
+	if count() != 0 {
+		t.Fatal("préchauffage pendant un travail annexe")
+	}
+
+	end := engineRequestStart()
+	c.prewarm(prewarmTurnEnd)
+	end()
+	if count() != 0 {
+		t.Fatal("préchauffage avec une requête de Loki en vol")
+	}
+
+	c.prewarm(prewarmTurnEnd)
+	if count() != 1 {
+		t.Fatalf("toutes conditions réunies : 1 préchauffage attendu, %d", count())
+	}
+}
+
+// Toute requête de Loki annule le préchauffage en vol, sauf un tour de chat qui
+// prolonge exactement son préfixe.
+func TestPrewarmAnnuleSaufPrefixeExact(t *testing.T) {
+	hist := []Message{{Role: "system", Content: "sys"}, um("a"), am("b")}
+	pwMsgs := append(append([]Message(nil), hist...), um(prewarmSentinel))
+	real := append(append([]Message(nil), hist...), um("suite"))
+	payload := map[string]any{"tools": []string{"t"}, "parallel_tool_calls": false}
+	other := []Message{{Role: "system", Content: "sys"}, um("a"), am("c"), um("suite")}
+
+	// Sans préchauffage en vol, rien n'est calculé.
+	if prewarmKeeper(perfMain, real, payload) != nil {
+		t.Fatal("empreintes calculées sans préchauffage en vol")
+	}
+	cases := []struct {
+		name string
+		keep func() func(*prewarmRun) bool // construit préchauffage en vol
+		kept bool
+	}{
+		{"tour qui prolonge", func() func(*prewarmRun) bool { return prewarmKeeper(perfMain, real, payload) }, true},
+		{"autres outils", func() func(*prewarmRun) bool {
+			return prewarmKeeper(perfMain, real, map[string]any{"tools": []string{"u"}, "parallel_tool_calls": false})
+		}, false},
+		{"autre historique", func() func(*prewarmRun) bool { return prewarmKeeper(perfMain, other, payload) }, false},
+		{"préfixe seul, rien après", func() func(*prewarmRun) bool { return prewarmKeeper(perfMain, hist, payload) }, false},
+		{"compaction", func() func(*prewarmRun) bool { return prewarmKeeper(perfCompact, real, payload) }, false},
+		{"requête quelconque", func() func(*prewarmRun) bool { return nil }, false},
+	}
+	for _, tc := range cases {
+		ctx, cancel := context.WithCancel(context.Background())
+		run := &prewarmRun{n: len(pwMsgs) - 1, prefix: perfPrefix(pwMsgs)[len(pwMsgs)-2], opts: prewarmOptsHash(payload), cancel: cancel, done: make(chan struct{})}
+		end, ok := prewarmBegin(run)
+		if !ok {
+			t.Fatal("prewarmBegin refusé, moteur libre")
+		}
+		done := engineRequestStartKeep(tc.keep())
+		if kept := ctx.Err() == nil; kept != tc.kept {
+			t.Fatalf("%s : gardé=%v, attendu %v", tc.name, kept, tc.kept)
+		}
+		done()
+		end()
+		cancel()
+	}
+	// Une requête en vol interdit d'en démarrer un.
+	busy := engineRequestStart()
+	if _, ok := prewarmBegin(&prewarmRun{cancel: func() {}}); ok {
+		t.Fatal("préchauffage inscrit avec une requête en vol")
+	}
+	busy()
+	if prewarmLive.Load() {
+		t.Fatal("prewarmLive resté levé")
+	}
+}
+
+// turnViewDry ne touche à rien (instantané, mises à jour, nettoyage) et rend,
+// jusqu'au dernier message, ce que turnView enverra.
+func TestTurnViewDryNeTouchePas(t *testing.T) {
+	for _, on := range []bool{false, true} {
+		m := projSnapSetup(t, on)
+		c := newTestConv()
+		caps := Caps{Agent: true, Mem: MemAlways}
+		playTurn(t, m, c, caps, "bonjour")
+		if err := MemAdd("docker.md", "# Docker\n"); err != nil {
+			t.Fatal(err)
+		}
+		if !on {
+			// Reste d'une époque avec la clé : turnView le nettoierait.
+			c.mu.Lock()
+			c.ProjSnap = &projSnapshot{Key: "x"}
+			c.mu.Unlock()
+		}
+		c.mu.Lock()
+		before, _ := json.Marshal(c)
+		hist := append([]Message(nil), c.Messages...)
+		c.mu.Unlock()
+
+		dry, _ := c.turnViewDry(caps, append(append([]Message(nil), hist...), um(prewarmSentinel)), true)
+		c.mu.Lock()
+		after, _ := json.Marshal(c)
+		c.mu.Unlock()
+		if !bytes.Equal(before, after) {
+			t.Fatalf("on=%v : turnViewDry a modifié la discussion", on)
+		}
+		sent, _, _ := c.turnView(caps, c.epoch, append(append([]Message(nil), hist...), um("suite")), true)
+		dw, sw := normalizeSystemMessages(dry), normalizeSystemMessages(sent)
+		if len(dw) != len(sw) || !reflect.DeepEqual(jsonValue(t, dw[:len(dw)-1]), jsonValue(t, sw[:len(sw)-1])) {
+			t.Fatalf("on=%v : préfixe de turnViewDry ≠ turnView\n%v\n%v", on, jsonValue(t, dw), jsonValue(t, sw))
+		}
+	}
+}
+
+// oldChatPayload : la construction du corps dans runChat avant buildChatPayload,
+// recopiée telle quelle.
+func oldChatPayload(ep chatEndpoint, messages []Message, temperature float64, tools []Tool, disableTools, toolChoiceNone, echoOff bool, effort string, kwargs map[string]any) map[string]any {
+	sent := normalizeSystemMessages(messages)
+	if toolChoiceNone {
+		sent = withTrailingHint(sent, toolsOffHint)
+	}
+	pol := currentEchoPolicy()
+	if ep.External || echoOff {
+		pol = echoPolicy{}
+	}
+	sent, _ = echoMessages(sent, pol)
+	payload := map[string]any{
+		"model":          ep.Model,
+		"messages":       expandImageRefs(sent),
+		"stream":         true,
+		"temperature":    temperature,
+		"stream_options": map[string]any{"include_usage": true},
+	}
+	applySampling(payload)
+	if effort != "" {
+		payload["reasoning_effort"] = effort
+	}
+	if kwargs != nil && !ep.External {
+		payload["chat_template_kwargs"] = kwargs
+	}
+	if len(tools) > 0 && !disableTools {
+		payload["tools"] = tools
+		payload["parallel_tool_calls"] = false
+		if toolChoiceNone {
+			payload["tool_choice"] = "none"
+		}
+	}
+	return payload
+}
+
+// oldTurnReasoning : le calcul du raisonnement dans runChat d'avant, recopié.
+func oldTurnReasoning(cfg map[string]string) (string, string, bool, map[string]any) {
+	effortWanted := reasoningEffortValue(cfg["REASONING_EFFORT"])
+	reasoningEffort := effortResolve(effortWanted)
+	thinkOff := reasoningExplicitlyOff(cfg["REASONING"]) || effortWanted == "none"
+	return effortWanted, reasoningEffort, thinkOff, reasoningTemplateKwargs(thinkOff, reasoningEffort)
+}
+
+// Refactorisation : le corps construit par wireMessages + buildChatPayload est,
+// octet pour octet, celui d'avant — sur toute la matrice des options d'une
+// requête (outils coupés ou neutralisés, intensité, gabarit, API externe,
+// raisonnement renvoyé, images).
+func TestBuildChatPayloadIdentiqueAvant(t *testing.T) {
+	m := prewarmSetup(t, map[string]string{"TOP_P": "0.9", "TOP_K": "20", "REASONING_ECHO": "on"})
+	_ = m
+	tools := EnabledTools(Caps{Agent: true, Mem: MemAlways})
+	if len(tools) == 0 {
+		t.Fatal("aucun outil pour la matrice")
+	}
+	msgs := []Message{
+		{Role: "system", Content: "sys"},
+		projectContextMessageForTest(),
+		um("bonjour"),
+		{Role: "assistant", Content: "salut", ReasoningContent: "je pense", ReasoningModel: echoTestModel},
+		{Role: "user", Content: []any{map[string]any{"type": "text", "text": "et ça ?"}, map[string]any{"type": "image_url", "image_url": map[string]any{"url": "data:image/png;base64,AAAA"}}}},
+	}
+	eps := []chatEndpoint{{URL: "http://localhost:1/v1/chat/completions", Model: "loki"}, {URL: "https://api.example/v1/chat/completions", Model: "gpt", External: true}}
+	for _, effortCfg := range []string{"", "high", "none"} {
+		cfg := map[string]string{"REASONING_EFFORT": effortCfg, "REASONING": "on"}
+		w1, e1, o1, k1 := oldTurnReasoning(cfg)
+		w2, e2, o2, k2 := turnReasoning(cfg)
+		if w1 != w2 || e1 != e2 || o1 != o2 || !reflect.DeepEqual(k1, k2) {
+			t.Fatalf("turnReasoning(%q) différent d'avant", effortCfg)
+		}
+		for _, ep := range eps {
+			for _, tl := range [][]Tool{nil, tools} {
+				for _, disable := range []bool{false, true} {
+					for _, none := range []bool{false, true} {
+						for _, echoOff := range []bool{false, true} {
+							want := oldChatPayload(ep, msgs, 0.7, tl, disable, none, echoOff, e2, k2)
+							sent, _ := wireMessages(msgs, none, turnEchoPolicy(ep.External || echoOff))
+							got := buildChatPayload(ep, sent, 0.7, chatPayloadOpts{tools: tl, disableTools: disable, toolChoiceNone: none, effort: e2, kwargs: k2})
+							wb, _ := json.Marshal(want)
+							gb, _ := json.Marshal(got)
+							if !bytes.Equal(wb, gb) {
+								t.Fatalf("corps différent (effort=%q ext=%v outils=%d off=%v none=%v echoOff=%v)\navant %s\naprès %s",
+									effortCfg, ep.External, len(tl), disable, none, echoOff, wb, gb)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+// projectContextMessageForTest : un message projet, que normalizeSystemMessages
+// déplace en tête du premier message utilisateur.
+func projectContextMessageForTest() Message {
+	return renderProjectContext("Projet de test")
+}
+
+// Refactorisation, de bout en bout : la requête d'un tour joué par generate est
+// celle de l'assemblage et du corps d'avant, pour chaque combinaison de modes.
+func TestGenerateCorpsIdentiqueAvant(t *testing.T) {
+	m := prewarmSetup(t, map[string]string{"REASONING_EFFORT": "high", "TOP_P": "0.9"})
+	matrix := []Caps{
+		{},
+		{Agent: true},
+		{Agent: true, Mem: MemAlways},
+		{Agent: true, Mem: MemOnDemand, Internet: true},
+		{Agent: true, Code: true, Role: "builder"},
+		{Agent: true, Code: true, Role: "planner"},
+	}
+	for i, caps := range matrix {
+		c := newTestConv()
+		c.mu.Lock()
+		c.Messages = []Message{um("bonjour"), am("salut")}
+		history := append(append([]Message(nil), c.Messages...), um("suite"))
+		c.mu.Unlock()
+		_, effort, _, kwargs := oldTurnReasoning(ReadConfig())
+		final := oldAssembly(caps, history) // normalisé
+		want := oldChatPayload(resolveChatEndpoint(), final, 0.7, EnabledTools(caps), false, false, false, effort, kwargs)
+		before := len(m.completions())
+		prewarmTurn(t, c, caps, "suite")
+		comps := m.completions()
+		if len(comps) <= before {
+			t.Fatalf("cas %d : aucune requête", i)
+		}
+		var got any
+		if err := json.Unmarshal([]byte(comps[before]), &got); err != nil {
+			t.Fatal(err)
+		}
+		if !reflect.DeepEqual(got, jsonValue(t, want)) {
+			t.Fatalf("cas %d (%+v) : corps différent d'avant\nreçu    %v\nattendu %v", i, caps, got, jsonValue(t, want))
+		}
+	}
+}
+
+func TestPrewarmNearMidnight(t *testing.T) {
+	loc := time.Local
+	if !prewarmNearMidnight(time.Date(2026, 10, 4, 23, 55, 0, 0, loc)) {
+		t.Fatal("23:55 doit s'abstenir")
+	}
+	if prewarmNearMidnight(time.Date(2026, 10, 4, 23, 45, 0, 0, loc)) || prewarmNearMidnight(time.Date(2026, 10, 4, 0, 5, 0, 0, loc)) {
+		t.Fatal("23:45 et 00:05 doivent préchauffer")
+	}
+}

internal/loki/chat_projsnap.go

@@ -0,0 +1,730 @@
+package loki
+
+// chat_projsnap.go — PROJ_SNAPSHOT : le bloc projet FIGÉ par discussion, et ses
+// changements livrés en <context_update> dans le message suivant.
+//
+// Pourquoi. Le contexte du projet (description, index mémoire, trackers,
+// consignes du dépôt) part en tête du PREMIER message utilisateur
+// (normalizeSystemMessages). Reconstruit à chaque tour, il change dès qu'une page
+// est créée ou qu'un tracker reçoit un point — et tout ce qui le suit dans le
+// prompt est recalculé : 10 à 45k tokens, des dizaines de secondes sur un 27B,
+// des minutes sur un MoE déchargé. Un modèle qui note une valeur à chaque tour
+// paie ce prix à chaque tour.
+//
+// Avec la clé (off par défaut) :
+//   - la discussion garde une copie figée du bloc (ProjSnap), envoyée à l'octet
+//     près d'un tour à l'autre. Ses en-têtes disent « à jour au <date> » et que
+//     les <context_update> de Loki les complètent ;
+//   - un changement arrive en tête du NOUVEAU message utilisateur, rangé tel quel
+//     dans l'historique (le tour suivant renvoie les mêmes octets). Le moteur
+//     pose un point de reprise au début de chaque message utilisateur : seul ce
+//     petit bloc est à calculer ;
+//   - rien n'est perdu : lignes ajoutées, modifiées, retirées pour les données
+//     faites de lignes (pages, trackers), texte COMPLET pour la prose
+//     (description, AGENTS.md). Une ligne fixe du système dit que ces blocs
+//     viennent de Loki et que le plus récent l'emporte ;
+//   - la date du jour et le dossier de travail quittent le système pour ce bloc
+//     (chat_envctx.go) : un changement de jour devient une ligne de mise à jour.
+//
+// Le bloc est rafraîchi — copie neuve, blocs <context_update> retirés de tout
+// l'historique — seulement quand le début du prompt change de toute façon :
+// compaction (début, fin de tour, manuelle, en cours de tour, réduction forcée),
+// système ou outils modifiés (réglages, mode, cible), cache froid
+// (redémarrage de Loki, changement de modèle, de preset ou de réglage moteur),
+// projet, nom, mode mémoire, mode Code ou dépôt changés, textes des en-têtes
+// changés. Et quand les mises à jour accumulées dépassent un seuil : au-delà, le
+// modèle aurait trop à recoller.
+//
+// Hors discussion : une tâche planifiée garde le bloc vivant (elle repart de zéro
+// à chaque fois), et sans agent le modèle brut ne reçoit rien du projet — ni bloc,
+// ni mise à jour.
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"hash/fnv"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+// projSnapEnabled : la clé PROJ_SNAPSHOT demande-t-elle le bloc figé ? Jamais
+// pour un preset externe (API OpenAI-compatible) : ses requêtes restent celles
+// d'avant, quel que soit le réglage.
+func projSnapEnabled(cfg map[string]string) bool {
+	if isExternalConfig(cfg) {
+		return false
+	}
+	switch strings.ToLower(strings.TrimSpace(cfg["PROJ_SNAPSHOT"])) {
+	case "on", "1", "true", "yes", "oui":
+		return true
+	}
+	return false
+}
+
+// Textes propres au bloc figé. Leur empreinte entre dans la clé de validité :
+// une mise à jour de Loki qui les reformule rafraîchit les instantanés persistés.
+const (
+	projSnapFormat     = "2"
+	memIndexFrozenTail = " Later <context_update> blocks from Loki update it."
+	trackerFrozenHead  = " — your trackers, each with its latest point at that time; later <context_update> blocks from Loki replace these lines. " +
+		"To say which trackers exist or give a latest value, use this list with those updates — do NOT call tracker with no arguments to list them. " +
+		"Call tracker(name[, when]) only to look further back in history, or with action \"add\"/\"edit\"/\"delete\" to change data.\n"
+	ctxUpdOpen  = `<context_update from="loki"`
+	ctxUpdClose = "</context_update>"
+	// projSnapSystemLine : la ligne fixe du prompt système, clé posée seulement.
+	projSnapSystemLine = "A <context_update from=\"loki\"> block at the start of a user message is written by Loki, not by the user: it updates <project_context>, and the most recent one wins.\n"
+)
+
+// projSnapBoot : identifiant de ce lancement de Loki. Après un redémarrage, le
+// cache du moteur est froid : garder un vieil instantané n'y gagnerait rien.
+var projSnapBoot = strconv.FormatInt(time.Now().UnixNano(), 36)
+
+// projSnapNow : l'horodatage « à jour au » des en-têtes et des mises à jour.
+func projSnapNow() string { return time.Now().Format("2006-01-02 15:04") }
+
+// projState : ce que le modèle sait du projet, section par section — au moment
+// de l'instantané, puis après chaque mise à jour annoncée. Structuré, jamais un
+// simple hash : c'est contre lui qu'on calcule la mise à jour suivante, y
+// compris après un redémarrage.
+type projState struct {
+	Day      string            `json:"day,omitempty"`       // date annoncée (chat_envctx.go)
+	Env      string            `json:"env,omitempty"`       // valeurs machine annoncées
+	Code     string            `json:"code,omitempty"`      // consignes du dépôt, message complet
+	Desc     string            `json:"desc,omitempty"`      // description du projet
+	MemOn    bool              `json:"mem_on,omitempty"`    // index mémoire présent
+	MemProse string            `json:"mem_prose,omitempty"` // lignes de l'index qui ne sont pas des pages
+	Mem      map[string]string `json:"mem,omitempty"`       // fichier → ligne de page
+	Trk      map[string]string `json:"trk,omitempty"`       // slug → « nom — valeur (date) »
+}
+
+// projSnapshot : le bloc figé d'une discussion. Persisté avec elle (omitempty :
+// absent tant que la clé n'a jamais servi, et ignoré d'un Loki plus ancien).
+type projSnapshot struct {
+	At       int64     `json:"at"`             // instant de l'instantané (ms)
+	Msgs     []Message `json:"msgs,omitempty"` // le bloc tel qu'il part, à l'octet près
+	State    projState `json:"state"`          // dernier état annoncé au modèle
+	Key      string    `json:"key"`            // validité : lancement, réglages, projet, mode…
+	SysHash  string    `json:"sys_hash"`       // système + outils du dernier tour
+	SnapTok  int       `json:"snap_tok,omitempty"`
+	DeltaTok int       `json:"delta_tok,omitempty"` // mises à jour livrées depuis
+}
+
+// projLive : le bloc vivant, rendu au format figé, avec son état. memOrder /
+// trkOrder : ordre d'affichage, pour des mises à jour stables.
+type projLive struct {
+	msgs     []Message
+	state    projState
+	memMsg   Message
+	trkMsg   Message
+	memOrder []string
+	trkOrder []string
+}
+
+// projSnapCapture lit le contexte projet UNE fois et en tire le bloc (même
+// ordre que l'assemblage d'un tour : consignes du dépôt, description, index
+// mémoire, trackers — précédés ici de la date et du dossier de travail, que le
+// système ne porte plus avec la clé) et son état.
+func projSnapCapture(caps Caps, asOf string) projLive {
+	var lv projLive
+	// Date et dossier de travail, sortis du système (chat_envctx.go).
+	lv.state.Day, lv.state.Env = envCapture(caps)
+	if m, ok := envContextMessage(lv.state.Day, lv.state.Env); ok {
+		lv.msgs = append(lv.msgs, m)
+	}
+	if m, ok := codeInstructionsMessage(caps); ok {
+		lv.msgs = append(lv.msgs, m)
+		lv.state.Code, _ = m.Content.(string)
+	}
+	if desc := strings.TrimSpace(projectDesc(activeProjectSlug())); desc != "" {
+		lv.msgs = append(lv.msgs, renderProjectContext(desc))
+		lv.state.Desc = desc
+	}
+	if idx, ok := memIndexText(); ok {
+		lv.memMsg = renderMemIndex(idx, asOf)
+		lv.msgs = append(lv.msgs, lv.memMsg)
+		lv.state.MemOn = true
+		lv.state.MemProse, lv.state.Mem, lv.memOrder = splitMemIndex(idx)
+	}
+	if list, ok := trackerIndexList(); ok {
+		lv.trkMsg = renderTrackerIndex(list, asOf)
+		lv.msgs = append(lv.msgs, lv.trkMsg)
+		lv.state.Trk = map[string]string{}
+		for _, m := range list {
+			lv.state.Trk[m.Slug] = trackerIndexLine(m)
+			lv.trkOrder = append(lv.trkOrder, m.Slug)
+		}
+	}
+	return lv
+}
+
+// splitMemIndex sépare les lignes de page (clé = fichier entre « ]( » et « ) »)
+// du reste de l'index. Une ligne de page en double part avec la prose : ainsi
+// tout changement la concernant fait renvoyer l'index entier, sans perte.
+func splitMemIndex(idx string) (prose string, pages map[string]string, order []string) {
+	pages = map[string]string{}
+	var other []string
+	for _, line := range strings.Split(idx, "\n") {
+		l := strings.TrimSpace(line)
+		if strings.HasPrefix(l, "- [") {
+			if i := strings.Index(l, "]("); i >= 0 {
+				if j := strings.Index(l[i+2:], ")"); j > 0 {
+					key := l[i+2 : i+2+j]
+					if _, dup := pages[key]; !dup {
+						pages[key] = l
+						order = append(order, key)
+						continue
+					}
+				}
+			}
+		}
+		other = append(other, line)
+	}
+	return strings.TrimSpace(strings.Join(other, "\n")), pages, order
+}
+
+func newProjSnapshot(lv projLive, key, sysHash string) *projSnapshot {
+	tok := 0
+	for _, m := range lv.msgs {
+		tok += len(msgText(m)) / 4
+	}
+	return &projSnapshot{At: time.Now().UnixMilli(), Msgs: lv.msgs, State: lv.state, Key: key, SysHash: sysHash, SnapTok: tok}
+}
+
+// projSnapDeltaLimit : au-delà de ce volume de mises à jour depuis l'instantané
+// (en tokens estimés), on rafraîchit plutôt que d'en empiler d'autres : environ
+// un quart du bloc, entre 400 et 1500 tokens.
+func projSnapDeltaLimit(snapTok int) int {
+	return min(1500, max(400, snapTok/4))
+}
+
+// projSnapKey : tout ce qui, en changeant, rend l'instantané faux ou inutile.
+// Les réglages pris en compte sont ceux qui touchent au moteur (modèle, preset,
+// arguments : un changement le relance, le cache est froid) ; les boutons de
+// conversation qui ne le relancent pas en sont exclus.
+func projSnapKey(caps Caps, cfg map[string]string) string {
+	h := fnv.New64a()
+	w := func(s string) {
+		h.Write([]byte(s))
+		h.Write([]byte{0})
+	}
+	w(projSnapFormat)
+	w(projSnapBoot)
+	keys := make([]string, 0, len(cfg))
+	for k := range cfg {
+		if !projSnapIgnoredKeys[k] {
+			keys = append(keys, k)
+		}
+	}
+	sort.Strings(keys)
+	for _, k := range keys {
+		w(k)
+		w(cfg[k])
+	}
+	slug := activeProjectSlug()
+	w(slug)
+	w(projectName(slug))
+	w(string(memMode()))
+	w(strconv.FormatBool(caps.Code))
+	if caps.Code {
+		d, _ := gitRepoDir("")
+		w(d)
+		w(agentCwd())
+	}
+	for _, s := range []string{envContextPrefix, nodeOfflineLine, memIndexFrozenTail, trackerFrozenHead, ctxUpdOpen, ctxUpdClose, projSnapSystemLine} {
+		w(s)
+	}
+	return fmt.Sprintf("%016x", h.Sum64())
+}
+
+// projSnapIgnoredKeys : réglages changés en cours de discussion sans relancer le
+// moteur ni toucher au bloc. Les compter rafraîchirait pour rien.
+var projSnapIgnoredKeys = map[string]bool{
+	"PROJ_SNAPSHOT": true, "PREWARM": true, "REASONING_ECHO": true, "REASONING_EFFORT": true, "TEMP": true,
+	"COMPACT": true, "COMPACT_CONTINUATION": true, "CRAWL4AI_URL": true, "CRAWL4AI_KEY": true, "WEB_ENGINE": true,
+	"KEEP_TURN_IMAGES": true, "NUDGE_IN_TOOL": true,
+}
+
+// projSnapSysHash : empreinte du bloc système commun et des outils. S'ils
+// changent, tout le prompt est recalculé de toute façon : rafraîchir est gratuit.
+func projSnapSysHash(sent []Message, tools []Tool) string {
+	h := fnv.New64a()
+	for _, m := range sent {
+		if m.Role != "system" {
+			break
+		}
+		if isProjectSystem(m) {
+			continue
+		}
+		s, _ := m.Content.(string)
+		h.Write([]byte(s))
+		h.Write([]byte{0})
+	}
+	b, _ := json.Marshal(tools)
+	h.Write(b)
+	return fmt.Sprintf("%016x", h.Sum64())
+}
+
+// projDelta : la mise à jour à annoncer entre l'état déjà connu du modèle et le
+// bloc vivant. "" = rien de changé. Les sections faites de lignes changent ligne
+// à ligne (une ligne de tracker remplace la précédente) ; la prose, ou une
+// section qui apparaît, repart en entier.
+func projDelta(old projState, lv projLive, asOf string) string {
+	cur := lv.state
+	var b strings.Builder
+	full := func(m Message) {
+		b.WriteString("Current version, replaces any earlier one — " + msgText(m) + "\n")
+	}
+	b.WriteString(envDelta(old.Day, old.Env, cur.Day, cur.Env))
+	if old.Code != cur.Code {
+		if cur.Code == "" {
+			b.WriteString("Repository instructions: removed.\n")
+		} else {
+			full(Message{Content: cur.Code})
+		}
+	}
+	if old.Desc != cur.Desc {
+		if cur.Desc == "" {
+			b.WriteString("Project description: removed.\n")
+		} else {
+			full(renderProjectContext(cur.Desc))
+		}
+	}
+	switch {
+	case !cur.MemOn && old.MemOn:
+		b.WriteString("Memory index: no pages any more.\n")
+	case cur.MemOn && (!old.MemOn || old.MemProse != cur.MemProse):
+		full(lv.memMsg)
+	case cur.MemOn:
+		var lines []string
+		for _, k := range lv.memOrder {
+			l := strings.TrimPrefix(cur.Mem[k], "- ")
+			switch prev, ok := old.Mem[k]; {
+			case !ok:
+				lines = append(lines, "+ "+l)
+			case prev != cur.Mem[k]:
+				lines = append(lines, "~ "+l)
+			}
+		}
+		for _, k := range sortedMissing(old.Mem, cur.Mem) {
+			lines = append(lines, "- "+k+" (deleted)")
+		}
+		if len(lines) > 0 {
+			b.WriteString("Memory index changes:\n" + strings.Join(lines, "\n") + "\n")
+		}
+	}
+	switch {
+	case len(cur.Trk) == 0 && len(old.Trk) > 0:
+		b.WriteString("Trackers: none left.\n")
+	case len(cur.Trk) > 0 && len(old.Trk) == 0:
+		full(lv.trkMsg)
+	case len(cur.Trk) > 0:
+		var lines []string
+		for _, k := range lv.trkOrder {
+			switch prev, ok := old.Trk[k]; {
+			case !ok:
+				lines = append(lines, "+ "+cur.Trk[k])
+			case prev != cur.Trk[k]:
+				lines = append(lines, "~ "+cur.Trk[k])
+			}
+		}
+		for _, k := range sortedMissing(old.Trk, cur.Trk) {
+			lines = append(lines, "- "+old.Trk[k]+" (deleted)")
+		}
+		if len(lines) > 0 {
+			b.WriteString("Tracker changes (latest point):\n" + strings.Join(lines, "\n") + "\n")
+		}
+	}
+	if b.Len() == 0 {
+		return ""
+	}
+	// Un titre de page qui contiendrait la balise fermante couperait le bloc au
+	// mauvais endroit au moment de le retirer.
+	body := strings.ReplaceAll(b.String(), ctxUpdClose, "</context-update>")
+	return ctxUpdOpen + ` at="` + asOf + `">` + "\n" + body + ctxUpdClose + "\n\n"
+}
+
+// sortedMissing : clés de old absentes de cur, triées.
+func sortedMissing(old, cur map[string]string) []string {
+	var out []string
+	for k := range old {
+		if _, ok := cur[k]; !ok {
+			out = append(out, k)
+		}
+	}
+	sort.Strings(out)
+	return out
+}
+
+// --- blocs <context_update> dans l'historique -----------------------------
+
+// stripCtxUpdText retire le(s) bloc(s) posé(s) en TÊTE du texte. Seulement en
+// tête : un message qui en parle plus loin reste intact.
+func stripCtxUpdText(s string) (string, bool) {
+	stripped := false
+	for strings.HasPrefix(s, ctxUpdOpen) {
+		i := strings.Index(s, ctxUpdClose)
+		if i < 0 {
+			break
+		}
+		s = strings.TrimPrefix(s[i+len(ctxUpdClose):], "\n\n")
+		stripped = true
+	}
+	return s, stripped
+}
+
+// withoutCtxUpdate : le message sans son bloc de tête, ok=false s'il n'en avait
+// pas (message rendu tel quel). Contenu texte ou multimodal ([]any, []map).
+// Seulement un message que Loki a marqué (CtxUpd) : sans la clé, aucun ne
+// l'est, et un texte tapé par l'utilisateur n'est jamais retouché.
+func withoutCtxUpdate(m Message) (Message, bool) {
+	if m.Role != "user" || !m.CtxUpd {
+		return m, false
+	}
+	m, ok := withoutCtxUpdateText(m)
+	if ok {
+		m.CtxUpd = false
+	}
+	return m, ok
+}
+
+func withoutCtxUpdateText(m Message) (Message, bool) {
+	switch c := m.Content.(type) {
+	case string:
+		if s, ok := stripCtxUpdText(c); ok {
+			m.Content = s
+			return m, true
+		}
+	case []any:
+		if len(c) > 0 {
+			if p, ok := c[0].(map[string]any); ok && p["type"] == "text" {
+				if t, _ := p["text"].(string); t != "" {
+					if s, ok := stripCtxUpdText(t); ok {
+						out := append([]any(nil), c[1:]...)
+						if s != "" {
+							q := map[string]any{}
+							for k, v := range p {
+								q[k] = v
+							}
+							q["text"] = s
+							out = append([]any{q}, out...)
+						}
+						m.Content = out
+						return m, true
+					}
+				}
+			}
+		}
+	case []map[string]any:
+		if len(c) > 0 && c[0]["type"] == "text" {
+			if t, _ := c[0]["text"].(string); t != "" {
+				if s, ok := stripCtxUpdText(t); ok {
+					out := append([]map[string]any(nil), c[1:]...)
+					if s != "" {
+						q := map[string]any{}
+						for k, v := range c[0] {
+							q[k] = v
+						}
+						q["text"] = s
+						out = append([]map[string]any{q}, out...)
+					}
+					m.Content = out
+					return m, true
+				}
+			}
+		}
+	}
+	return m, false
+}
+
+// stripContextUpdates rend l'historique sans aucun bloc <context_update>. Sans
+// bloc, c'est la MÊME tranche (rien recopié) : le cas de toutes les discussions
+// sans la clé.
+func stripContextUpdates(msgs []Message) []Message {
+	var out []Message
+	for i, m := range msgs {
+		if s, ok := withoutCtxUpdate(m); ok {
+			if out == nil {
+				out = append([]Message(nil), msgs...)
+			}
+			out[i] = s
+		}
+	}
+	if out == nil {
+		return msgs
+	}
+	return out
+}
+
+func hasContextUpdates(msgs []Message) bool {
+	for _, m := range msgs {
+		if _, ok := withoutCtxUpdate(m); ok {
+			return true
+		}
+	}
+	return false
+}
+
+// prependCtxUpdate pose le bloc en tête d'un message utilisateur, comme
+// prependToFirstUser : texte simple, ou une partie texte de plus en multimodal.
+func prependCtxUpdate(m Message, block string) (Message, bool) {
+	if m.Role != "user" {
+		return m, false
+	}
+	switch c := m.Content.(type) {
+	case string:
+		m.Content = block + c
+	case []any:
+		m.Content = append([]any{map[string]any{"type": "text", "text": block}}, c...)
+	case []map[string]any:
+		m.Content = append([]map[string]any{{"type": "text", "text": block}}, c...)
+	default:
+		return m, false
+	}
+	m.CtxUpd = true
+	return m, true
+}
+
+// replaceProjectHead remplace le bloc projet de tête (hors rappel des pages
+// lues, qui appartient à l'historique) par block, à la même place.
+func replaceProjectHead(msgs []Message, block []Message) []Message {
+	end := 0
+	for end < len(msgs) && msgs[end].Role == "system" {
+		end++
+	}
+	out := make([]Message, 0, len(msgs)+len(block))
+	inserted := false
+	for _, m := range msgs[:end] {
+		reminder := false
+		if s, ok := m.Content.(string); ok && strings.HasPrefix(s, memReminderPrefix) {
+			reminder = true
+		}
+		if isProjectSystem(m) && !reminder {
+			if !inserted {
+				out = append(out, block...)
+				inserted = true
+			}
+			continue
+		}
+		if reminder && !inserted {
+			out = append(out, block...)
+			inserted = true
+		}
+		out = append(out, m)
+	}
+	if !inserted {
+		out = append(out, block...)
+	}
+	return append(out, msgs[end:]...)
+}
+
+// --- assemblage d'un tour de la discussion --------------------------------
+
+// turnView assemble la séquence envoyée pour un tour de la discussion (generate,
+// runBuilderTurn) : prompt du preset, consignes du dépôt, contexte projet, puis
+// l'historique. inject=false : modèle brut (agent off), rien du projet.
+//
+// Sans PROJ_SNAPSHOT : exactement l'assemblage d'avant, contexte vivant. Seul
+// ajout, sans effet tant que la clé n'a jamais servi : une discussion qui porte
+// encore un instantané ou des blocs d'une époque où la clé était posée en est
+// nettoyée — un vieux <context_update> placé après le bloc vivant se lirait
+// comme plus récent que lui.
+//
+// Avec la clé : instantané pris, gardé ou rafraîchi ; mise à jour éventuelle
+// posée en tête du dernier message utilisateur, dans c.Messages ET dans msgs
+// (sous c.mu, si l'epoch n'a pas changé). pt sert au rafraîchissement en cours
+// de tour (runChatTools) ; nil sans la clé.
+func (c *Conversation) turnView(caps Caps, epoch int, msgs []Message, inject bool) (sent []Message, tools []Tool, pt *projSnapTurn) {
+	return c.assembleTurn(caps, epoch, msgs, inject, false)
+}
+
+// turnViewDry : la séquence que turnView enverrait pour msgs, SANS rien toucher
+// à la conversation — ni instantané pris, ni mise à jour rangée, ni nettoyage.
+// Pour le préchauffage (chat_prewarm.go) : contenu vivant, mêmes décisions que
+// le vrai tour. La mise à jour qu'il poserait en tête du dernier message n'y est
+// pas : ce message-là est la sentinelle, hors du préfixe préchauffé.
+func (c *Conversation) turnViewDry(caps Caps, msgs []Message, inject bool) ([]Message, []Tool) {
+	sent, tools, _ := c.assembleTurn(caps, 0, msgs, inject, true)
+	return sent, tools
+}
+
+func (c *Conversation) assembleTurn(caps Caps, epoch int, msgs []Message, inject, dry bool) (sent []Message, tools []Tool, pt *projSnapTurn) {
+	cfg := ReadConfig()
+	on := projSnapEnabled(cfg)
+	if !inject {
+		// Sans agent : ni bloc, ni mise à jour. Des blocs restés d'un tour avec
+		// agent sont retirés de la vue envoyée (l'historique les garde : l'agent
+		// revenu, le système change et le bloc est rafraîchi).
+		sent, tools = prepareTurn(stripContextUpdates(msgs), caps)
+		return sent, tools, nil
+	}
+	if !on {
+		c.mu.Lock()
+		if !dry && c.epoch == epoch && (c.ProjSnap != nil || hasContextUpdates(c.Messages)) {
+			c.ProjSnap = nil
+			c.Messages = stripContextUpdates(c.Messages)
+		}
+		c.mu.Unlock()
+		msgs = stripContextUpdates(msgs)
+		final := append(projectSystemMessages(), msgs...)
+		if m, ok := codeInstructionsMessage(caps); ok {
+			final = append([]Message{m}, final...)
+		}
+		if sp := readSysPrompt(); sp != "" {
+			final = append([]Message{{Role: "system", Content: sp}}, final...)
+		}
+		sent, tools = prepareTurn(final, caps)
+		return sent, tools, nil
+	}
+
+	// Date et dossier de travail : dans le bloc, plus dans le système
+	// (chat_envctx.go). Cette copie de caps ne sert qu'à ce tour de discussion.
+	caps.envInCtx = true
+	// Lectures (disque, base, git) hors du verrou de la conversation.
+	asOf := projSnapNow()
+	live := projSnapCapture(caps, asOf)
+	key := projSnapKey(caps, cfg)
+	// Même calcul que prepareTurn, en deux temps : l'empreinte du système et des
+	// outils décide du rafraîchissement avant l'assemblage. Les outils ne sont
+	// calculés qu'une fois (connexions MCP).
+	tools = EnabledTools(caps)
+	var spMsgs []Message
+	if sp := readSysPrompt(); sp != "" {
+		spMsgs = []Message{{Role: "system", Content: sp}}
+	}
+	sysHash := projSnapSysHash(InjectSkills(spMsgs, caps, tools), tools)
+
+	block := live.msgs
+	c.mu.Lock()
+	if dry {
+		// Même décision que projSnapApplyLocked, appliquée à la seule copie.
+		if refresh, _, _ := projSnapDecide(c.ProjSnap, live, key, sysHash, asOf); refresh {
+			msgs = stripContextUpdates(msgs)
+		} else {
+			block = c.ProjSnap.Msgs
+		}
+		c.mu.Unlock()
+		final := append(append(append([]Message(nil), spMsgs...), block...), msgs...)
+		return InjectSkills(final, caps, tools), tools, nil
+	}
+	if c.epoch == epoch {
+		refresh, delta := c.projSnapApplyLocked(live, key, sysHash, asOf)
+		if refresh {
+			msgs = stripContextUpdates(msgs)
+		}
+		if delta != "" {
+			if n := len(msgs); n > 0 {
+				if m, ok := prependCtxUpdate(msgs[n-1], delta); ok {
+					msgs = append(msgs[:n-1:n-1], m)
+				}
+			}
+		}
+		block = c.ProjSnap.Msgs
+	}
+	c.mu.Unlock()
+
+	final := append(append(append([]Message(nil), spMsgs...), block...), msgs...)
+	sent = InjectSkills(final, caps, tools)
+	return sent, tools, &projSnapTurn{caps: caps, key: key, sysHash: sysHash}
+}
+
+// projSnapApplyLocked décide pour ce tour, c.mu tenu : rafraîchir (instantané
+// neuf, blocs retirés de l'historique) ou annoncer une mise à jour, posée en tête
+// du dernier message utilisateur de c.Messages. Renvoie ce qui a été fait, pour
+// que l'appelant l'applique à sa propre copie.
+func (c *Conversation) projSnapApplyLocked(live projLive, key, sysHash, asOf string) (refresh bool, delta string) {
+	snap := c.ProjSnap
+	refresh, delta, tok := projSnapDecide(snap, live, key, sysHash, asOf)
+	if refresh {
+		c.Messages = stripContextUpdates(c.Messages)
+		c.ProjSnap = newProjSnapshot(live, key, sysHash)
+		return true, ""
+	}
+	if delta == "" {
+		return false, ""
+	}
+	n := len(c.Messages)
+	if n == 0 {
+		return false, ""
+	}
+	m, ok := prependCtxUpdate(c.Messages[n-1], delta)
+	if !ok {
+		// Pas de message utilisateur où la poser (cas théorique) : l'état
+		// annoncé ne bouge pas, elle partira au tour suivant.
+		return false, ""
+	}
+	c.Messages[n-1] = m
+	snap.State = live.state
+	snap.DeltaTok += tok
+	return false, delta
+}
+
+// projSnapDecide : rafraîchir ou non, et la mise à jour à annoncer sinon (tok :
+// sa taille estimée). Pur : projSnapApplyLocked l'applique, le préchauffage
+// (turnViewDry) s'en sert pour prévoir le tour sans rien toucher.
+func projSnapDecide(snap *projSnapshot, live projLive, key, sysHash, asOf string) (refresh bool, delta string, tok int) {
+	refresh = snap == nil || snap.Key != key || snap.SysHash != sysHash
+	if !refresh {
+		delta = projDelta(snap.State, live, asOf)
+		tok = len(delta) / 4
+		if delta != "" && snap.DeltaTok+tok > projSnapDeltaLimit(snap.SnapTok) {
+			refresh = true
+		}
+	}
+	return refresh, delta, tok
+}
+
+// --- rafraîchissement en cours de tour -------------------------------------
+
+// projSnapTurn accompagne un tour de discussion avec la clé posée. runChatTools
+// le récupère dans le contexte et s'en sert quand une compaction ou une
+// réduction réécrit l'historique en plein tour : le début du prompt change de
+// toute façon, le bloc est donc remplacé par le vivant (et les mises à jour
+// retirées), sans perdre celles qu'aurait avalées le résumé. L'appelant range
+// ensuite refreshed comme nouvel instantané : le tour suivant renvoie les mêmes
+// octets, pas de recalcul de plus.
+type projSnapTurn struct {
+	caps    Caps
+	key     string
+	sysHash string
+
+	mu        sync.Mutex
+	refreshed *projSnapshot
+}
+
+type projSnapCtxKey struct{}
+
+func withProjSnapTurn(ctx context.Context, pt *projSnapTurn) context.Context {
+	return context.WithValue(ctx, projSnapCtxKey{}, pt)
+}
+
+func projSnapTurnFrom(ctx context.Context) *projSnapTurn {
+	pt, _ := ctx.Value(projSnapCtxKey{}).(*projSnapTurn)
+	return pt
+}
+
+// refresh : historique en cours de tour, bloc vivant à la place du figé, sans
+// aucun <context_update>.
+func (pt *projSnapTurn) refresh(msgs []Message) []Message {
+	live := projSnapCapture(pt.caps, projSnapNow())
+	out := replaceProjectHead(stripContextUpdates(msgs), live.msgs)
+	pt.mu.Lock()
+	pt.refreshed = newProjSnapshot(live, pt.key, pt.sysHash)
+	pt.mu.Unlock()
+	return out
+}
+
+// takeRefreshed : l'instantané posé en cours de tour, nil s'il n'y en a pas eu.
+func (pt *projSnapTurn) takeRefreshed() *projSnapshot {
+	if pt == nil {
+		return nil
+	}
+	pt.mu.Lock()
+	defer pt.mu.Unlock()
+	s := pt.refreshed
+	pt.refreshed = nil
+	return s
+}

internal/loki/chat_projsnap_test.go

@@ -0,0 +1,627 @@
+package loki
+
+import (
+	"context"
+	"encoding/json"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// projSnapSetup : base et projet neufs, moteur de comédie qui répond « ok. ».
+// on = PROJ_SNAPSHOT posée.
+func projSnapSetup(t *testing.T, on bool) *moteurEcho {
+	t.Helper()
+	withWorkspace(t)
+	activeProjMu.Lock()
+	activeProjCache = ""
+	activeProjMu.Unlock()
+	setProjectOverride("")
+	t.Cleanup(func() {
+		activeProjMu.Lock()
+		activeProjCache = ""
+		activeProjMu.Unlock()
+		setProjectOverride("")
+	})
+	ensureDefaultProject()
+	freshTplProbe(t)
+	if err := SetConfigKey("MODEL", "/models/"+echoTestModel); err != nil {
+		t.Fatal(err)
+	}
+	if on {
+		if err := SetConfigKey("PROJ_SNAPSHOT", "on"); err != nil {
+			t.Fatal(err)
+		}
+	}
+	m := &moteurEcho{reply: func(int, string) (int, string) {
+		return 200, sseChunk("ok.") + sseFinal("stop", 100, 2)
+	}}
+	m.start(t)
+	return m
+}
+
+// playTurn joue un tour utilisateur complet sur c et rend le corps de la PREMIÈRE
+// requête de ce tour.
+func playTurn(t *testing.T, m *moteurEcho, c *Conversation, caps Caps, text string) string {
+	t.Helper()
+	before := len(m.all())
+	c.mu.Lock()
+	c.Messages = append(c.Messages, um(text))
+	c.mu.Unlock()
+	c.generate(context.Background(), caps, 0.7, c.epoch)
+	all := m.all()
+	if len(all) <= before {
+		t.Fatalf("aucune requête pour %q", text)
+	}
+	return all[before]
+}
+
+// userContents : le texte des messages user d'une requête, dans l'ordre.
+func userContents(t *testing.T, body string) []string {
+	t.Helper()
+	var out []string
+	for _, m := range requestMessages(t, body) {
+		if m["role"] == "user" {
+			s, _ := m["content"].(string)
+			out = append(out, s)
+		}
+	}
+	return out
+}
+
+func systemContent(t *testing.T, body string) string {
+	t.Helper()
+	for _, m := range requestMessages(t, body) {
+		if m["role"] == "system" {
+			s, _ := m["content"].(string)
+			return s
+		}
+	}
+	return ""
+}
+
+// oldAssembly : l'assemblage de generate d'avant PROJ_SNAPSHOT, recopié tel quel.
+func oldAssembly(caps Caps, msgs []Message) []Message {
+	final := msgs
+	if caps.Agent {
+		final = append(projectSystemMessages(), msgs...)
+		if m, ok := codeInstructionsMessage(caps); ok {
+			final = append([]Message{m}, final...)
+		}
+		if sp := readSysPrompt(); sp != "" {
+			final = append([]Message{{Role: "system", Content: sp}}, final...)
+		}
+	}
+	sent, _ := prepareTurn(final, caps)
+	return normalizeSystemMessages(sent)
+}
+
+func jsonValue(t *testing.T, v any) any {
+	t.Helper()
+	b, err := json.Marshal(v)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var out any
+	if err := json.Unmarshal(b, &out); err != nil {
+		t.Fatal(err)
+	}
+	return out
+}
+
+// Clé absente : la requête est celle d'avant, à l'octet près — bloc vivant qui
+// suit la page créée, aucune ligne système de plus, rien de persisté en plus.
+func TestProjSnapDefautRienNeChange(t *testing.T) {
+	m := projSnapSetup(t, false)
+	if err := MemAdd("nas.md", "# NAS\n"); err != nil {
+		t.Fatal(err)
+	}
+	c := newTestConv()
+	caps := Caps{Agent: true, Mem: MemAlways}
+	for i, text := range []string{"bonjour", "et ensuite ?"} {
+		if i == 1 {
+			if err := MemAdd("docker.md", "# Docker\n"); err != nil {
+				t.Fatal(err)
+			}
+		}
+		c.mu.Lock()
+		want := oldAssembly(caps, append(append([]Message(nil), c.Messages...), um(text)))
+		c.mu.Unlock()
+		body := playTurn(t, m, c, caps, text)
+		var got struct {
+			Messages any `json:"messages"`
+		}
+		if err := json.Unmarshal([]byte(body), &got); err != nil {
+			t.Fatal(err)
+		}
+		if !reflect.DeepEqual(got.Messages, jsonValue(t, want)) {
+			t.Fatalf("tour %d : requête différente de l'assemblage d'avant\nreçu  %v\nattendu %v", i, got.Messages, jsonValue(t, want))
+		}
+		if strings.Contains(body, "context_update") || strings.Contains(body, "as of") {
+			t.Fatalf("tour %d : trace du bloc figé sans la clé :\n%s", i, body)
+		}
+	}
+	if us := userContents(t, m.all()[1]); !strings.Contains(us[0], "](docker.md)") {
+		t.Fatalf("sans la clé, le bloc vivant doit montrer la nouvelle page : %q", us[0])
+	}
+	b, _ := json.Marshal(c)
+	if c.ProjSnap != nil || strings.Contains(string(b), "proj_snap") {
+		t.Fatalf("instantané persisté sans la clé : %s", b)
+	}
+}
+
+// La première page d'un projet vide arrive en mise à jour : le premier message
+// reste identique, la mise à jour est rangée dans l'historique et renvoyée telle
+// quelle ensuite, la suivante n'annonce que la page ajoutée.
+func TestProjSnapPageAjouteeEnMiseAJour(t *testing.T) {
+	m := projSnapSetup(t, true)
+	c := newTestConv()
+	caps := Caps{Agent: true, Mem: MemAlways}
+	b1 := playTurn(t, m, c, caps, "bonjour")
+	if !strings.Contains(systemContent(t, b1), projSnapSystemLine) {
+		t.Fatal("ligne fixe du système absente avec la clé")
+	}
+	if err := MemAdd("nas.md", "# NAS\n"); err != nil {
+		t.Fatal(err)
+	}
+	b2 := playTurn(t, m, c, caps, "et le NAS ?")
+	u1, u2 := userContents(t, b1), userContents(t, b2)
+	if u2[0] != u1[0] {
+		t.Fatalf("premier message changé :\navant %q\naprès %q", u1[0], u2[0])
+	}
+	last := u2[len(u2)-1]
+	if !strings.HasPrefix(last, ctxUpdOpen) || !strings.Contains(last, "](nas.md)") || !strings.HasSuffix(last, "et le NAS ?") {
+		t.Fatalf("mise à jour attendue en tête du nouveau message : %q", last)
+	}
+	if err := MemAdd("docker.md", "# Docker\n"); err != nil {
+		t.Fatal(err)
+	}
+	b3 := playTurn(t, m, c, caps, "et docker ?")
+	u3 := userContents(t, b3)
+	if u3[0] != u1[0] || u3[1] != u2[1] {
+		t.Fatalf("messages déjà envoyés modifiés :\n%q\n%q", u3[0], u3[1])
+	}
+	last = u3[len(u3)-1]
+	if !strings.Contains(last, "+ [Docker](docker.md)") || strings.Contains(last, "nas.md") {
+		t.Fatalf("seule la page ajoutée doit être annoncée : %q", last)
+	}
+	// Sans changement : rien de posé.
+	b4 := playTurn(t, m, c, caps, "merci")
+	if u4 := userContents(t, b4); u4[len(u4)-1] != "merci" {
+		t.Fatalf("mise à jour vide posée : %q", u4[len(u4)-1])
+	}
+	// Persisté et relu : l'état annoncé survit.
+	raw, _ := json.Marshal(c)
+	c2 := newTestConv()
+	c2.loadFrom("x", raw)
+	if c2.ProjSnap == nil || c2.ProjSnap.State.Mem["docker.md"] == "" {
+		t.Fatalf("instantané non relu : %+v", c2.ProjSnap)
+	}
+}
+
+// Une nouvelle valeur de tracker remplace sa ligne (« ~ ») ; un tracker supprimé
+// est annoncé comme tel.
+func TestProjSnapTrackerLigneRemplacee(t *testing.T) {
+	m := projSnapSetup(t, true)
+	if _, err := trackerAdd("poids", "2026-10-01", "72.4 kg"); err != nil {
+		t.Fatal(err)
+	}
+	c := newTestConv()
+	caps := Caps{Agent: true, Mem: MemAlways}
+	b1 := playTurn(t, m, c, caps, "salut")
+	if u := userContents(t, b1); !strings.Contains(u[0], "Trackers (tracker tool) as of ") || strings.Contains(u[0], "answer straight from this") {
+		t.Fatalf("en-tête figé attendu : %q", u[0])
+	}
+	if _, err := trackerAdd("poids", "2026-10-03", "73 kg"); err != nil {
+		t.Fatal(err)
+	}
+	b2 := playTurn(t, m, c, caps, "mon poids ?")
+	u := userContents(t, b2)
+	if u[0] != userContents(t, b1)[0] {
+		t.Fatal("premier message changé")
+	}
+	if !strings.Contains(u[len(u)-1], "~ poids — 73 kg (2026-10-03)") {
+		t.Fatalf("ligne de tracker attendue : %q", u[len(u)-1])
+	}
+}
+
+// Une compaction (début, fin, manuelle) reprend le bloc tout neuf au tour suivant
+// et retire les mises à jour de la queue gardée : une vieille valeur ne doit pas
+// suivre la fraîche.
+func TestProjSnapCompactionRafraichit(t *testing.T) {
+	m := projSnapSetup(t, true)
+	if _, err := trackerAdd("poids", "2026-10-01", "72.4 kg"); err != nil {
+		t.Fatal(err)
+	}
+	c := newTestConv()
+	caps := Caps{Agent: true, Mem: MemAlways}
+	playTurn(t, m, c, caps, "salut")
+	if _, err := trackerAdd("poids", "2026-10-02", "72.8 kg"); err != nil {
+		t.Fatal(err)
+	}
+	playTurn(t, m, c, caps, "note-le")
+	if !hasContextUpdates(c.Messages) {
+		t.Fatal("mise à jour attendue dans l'historique")
+	}
+	for i := 0; i < 10; i++ {
+		c.Messages = append(c.Messages, am("étape "+strings.Repeat("détail ", 300)), um("continue "+strings.Repeat("x", 600)))
+	}
+	// Le message avec la mise à jour en dernier : il tombe dans la queue gardée.
+	upd := um(ctxUpdOpen + ` at="x">` + "\n~ poids — 72.4 kg\n" + ctxUpdClose + "\n\nencore")
+	upd.CtxUpd = true
+	c.Messages = append(c.Messages, am("vu"), upd)
+	if _, changed := c.compactAndPublish(context.Background(), c.epoch, "test", append([]Message(nil), c.Messages...), 50000, caps, compactOpts{}); !changed {
+		t.Fatal("compaction sans effet")
+	}
+	if c.ProjSnap != nil || hasContextUpdates(c.Messages) {
+		t.Fatalf("après compaction : instantané %v, mises à jour restantes %v", c.ProjSnap != nil, hasContextUpdates(c.Messages))
+	}
+	b := playTurn(t, m, c, caps, "et maintenant ?")
+	if strings.Contains(strings.Join(userContents(t, b), " "), ctxUpdOpen) {
+		t.Fatalf("mise à jour après le bloc neuf : %s", b)
+	}
+	if u := userContents(t, b); !strings.Contains(u[0], "72.8 kg") {
+		t.Fatalf("bloc neuf attendu avec la dernière valeur : %q", u[0])
+	}
+}
+
+// Compaction EN COURS de tour : le bloc vivant remplace le figé dans la requête
+// rejouée (la mise à jour avalée par le résumé n'est pas perdue), et c'est lui
+// que le tour suivant renvoie.
+func TestProjSnapCompactionEnTour(t *testing.T) {
+	m := projSnapSetup(t, true)
+	c := newTestConv()
+	caps := Caps{Agent: true, Mem: MemAlways}
+	playTurn(t, m, c, caps, "salut")
+	if err := MemAdd("nas.md", "# NAS\n"); err != nil {
+		t.Fatal(err)
+	}
+	for i := 0; i < 12; i++ {
+		c.Messages = append(c.Messages, am("étape "+strings.Repeat("détail ", 300)), um("continue "+strings.Repeat("x", 600)))
+	}
+	c.Messages = append(c.Messages, am("vu"))
+	n := len(m.all())
+	m.mu.Lock()
+	m.reply = func(k int, _ string) (int, string) {
+		if k == n {
+			return 400, `{"error":{"code":400,"message":"request (99999 tokens) exceeds the available context size"}}`
+		}
+		return 200, sseChunk("ok.") + sseFinal("stop", 100, 2)
+	}
+	m.mu.Unlock()
+	playTurn(t, m, c, caps, "et le NAS ?")
+	all := m.all()
+	first, retry := all[n], all[n+1]
+	if uf := userContents(t, first); !strings.HasPrefix(uf[len(uf)-1], ctxUpdOpen) {
+		t.Fatal("mise à jour attendue dans la requête refusée")
+	}
+	u := userContents(t, retry)
+	if strings.Contains(strings.Join(u, " "), ctxUpdOpen) {
+		t.Fatalf("mise à jour restée après la compaction en cours de tour : %q", u)
+	}
+	if !strings.Contains(u[0], "](nas.md)") {
+		t.Fatalf("la page doit être dans le bloc rafraîchi : %q", u[0])
+	}
+	if c.ProjSnap == nil || c.ProjSnap.State.Mem["nas.md"] == "" || hasContextUpdates(c.Messages) {
+		t.Fatalf("instantané rafraîchi non rangé : %+v", c.ProjSnap)
+	}
+	next := playTurn(t, m, c, caps, "merci")
+	head := func(s string) string { return s[:strings.Index(s, "</project_context>")] }
+	if head(userContents(t, next)[0]) != head(u[0]) {
+		t.Fatal("le tour suivant doit renvoyer le bloc rafraîchi à l'identique")
+	}
+}
+
+// Changer de projet, de discussion ou repartir à zéro ne garde pas l'instantané.
+func TestProjSnapProjetEtDiscussion(t *testing.T) {
+	m := projSnapSetup(t, true)
+	c := newTestConv()
+	caps := Caps{Agent: true, Mem: MemAlways}
+	playTurn(t, m, c, caps, "salut")
+	p, err := createProject("Jardin")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := setProjectDesc(p.Slug, "Le potager."); err != nil {
+		t.Fatal(err)
+	}
+	if err := setActiveProject(p.Slug); err != nil {
+		t.Fatal(err)
+	}
+	b := playTurn(t, m, c, caps, "et le jardin ?")
+	u := userContents(t, b)
+	if !strings.Contains(u[0], "Le potager.") || strings.Contains(strings.Join(u, " "), ctxUpdOpen) {
+		t.Fatalf("changement de projet : bloc neuf attendu, sans mise à jour : %q", u[0])
+	}
+	if c.ProjSnap == nil {
+		t.Fatal("instantané attendu")
+	}
+	// loadFrom : fil neuf, ou enregistré sans le champ.
+	c.loadFrom("neuf", nil)
+	if c.ProjSnap != nil {
+		t.Fatal("fil neuf : instantané hérité")
+	}
+	c.ProjSnap = &projSnapshot{Key: "x"}
+	c.loadFrom("ancien", []byte(`{"messages":[{"role":"user","content":"vieux"}]}`))
+	if c.ProjSnap != nil {
+		t.Fatal("fil enregistré sans instantané : hérité")
+	}
+	c.ProjSnap = &projSnapshot{Key: "x"}
+	c.Reset()
+	if c.ProjSnap != nil {
+		t.Fatal("Reset garde l'instantané")
+	}
+}
+
+// Sans agent : ni bloc ni mise à jour, et les blocs restés d'avant ne partent pas.
+func TestProjSnapSansAgent(t *testing.T) {
+	m := projSnapSetup(t, true)
+	c := newTestConv()
+	playTurn(t, m, c, Caps{Agent: true, Mem: MemAlways}, "salut")
+	if err := MemAdd("nas.md", "# NAS\n"); err != nil {
+		t.Fatal(err)
+	}
+	playTurn(t, m, c, Caps{Agent: true, Mem: MemAlways}, "le NAS ?")
+	if err := MemAdd("docker.md", "# Docker\n"); err != nil {
+		t.Fatal(err)
+	}
+	before := c.ProjSnap.State
+	b := playTurn(t, m, c, Caps{}, "réponds sans outils")
+	if strings.Contains(b, "context_update") || strings.Contains(b, "project_context") {
+		t.Fatalf("agent off : contexte projet envoyé : %s", b)
+	}
+	if last := c.Messages[len(c.Messages)-2]; msgText(last) != "réponds sans outils" {
+		t.Fatalf("agent off : message modifié : %q", msgText(last))
+	}
+	if !reflect.DeepEqual(c.ProjSnap.State, before) {
+		t.Fatal("agent off : état annoncé modifié")
+	}
+}
+
+// Clé retirée après usage : l'instantané et les blocs sont nettoyés, retour au
+// bloc vivant sans vieille mise à jour derrière lui.
+func TestProjSnapCleRetiree(t *testing.T) {
+	m := projSnapSetup(t, true)
+	c := newTestConv()
+	caps := Caps{Agent: true, Mem: MemAlways}
+	playTurn(t, m, c, caps, "salut")
+	if err := MemAdd("nas.md", "# NAS\n"); err != nil {
+		t.Fatal(err)
+	}
+	playTurn(t, m, c, caps, "le NAS ?")
+	if err := SetConfigKey("PROJ_SNAPSHOT", ""); err != nil {
+		t.Fatal(err)
+	}
+	b := playTurn(t, m, c, caps, "et après ?")
+	if strings.Contains(b, "context_update") || strings.Contains(b, "as of") {
+		t.Fatalf("restes du bloc figé : %s", b)
+	}
+	if c.ProjSnap != nil || hasContextUpdates(c.Messages) {
+		t.Fatal("historique non nettoyé")
+	}
+}
+
+// Rafraîchissement : clé de validité (redémarrage, réglage moteur), système ou
+// outils changés, seuil d'accumulation.
+func TestProjSnapApplyRafraichit(t *testing.T) {
+	projSnapSetup(t, true)
+	if err := MemAdd("nas.md", "# NAS\n"); err != nil {
+		t.Fatal(err)
+	}
+	caps := Caps{Agent: true, Mem: MemAlways}
+	live := projSnapCapture(caps, "t0")
+	c := newTestConv()
+	c.Messages = []Message{um("a")}
+	if r, _ := c.projSnapApplyLocked(live, "k", "s", "t0"); !r {
+		t.Fatal("premier tour : instantané attendu")
+	}
+	if err := MemAdd("docker.md", "# Docker\n"); err != nil {
+		t.Fatal(err)
+	}
+	live2 := projSnapCapture(caps, "t1")
+	c.Messages = append(c.Messages, am("b"), um("c"))
+	if r, d := c.projSnapApplyLocked(live2, "k", "s", "t1"); r || d == "" {
+		t.Fatalf("mise à jour attendue : refresh=%v delta=%q", r, d)
+	}
+	for _, tc := range []struct{ name, key, sys string }{{"clé", "k2", "s"}, {"système", "k", "s2"}} {
+		snap := *c.ProjSnap
+		c.Messages = append(c.Messages, am("d"), um("e"))
+		if r, _ := c.projSnapApplyLocked(live, tc.key, tc.sys, "t2"); !r {
+			t.Fatalf("%s changé : rafraîchissement attendu", tc.name)
+		}
+		if hasContextUpdates(c.Messages) {
+			t.Fatalf("%s : mises à jour restées après rafraîchissement", tc.name)
+		}
+		c.ProjSnap = &snap
+	}
+	// Seuil : les mises à jour accumulées dépassent la limite.
+	c.ProjSnap.Key, c.ProjSnap.SysHash = "k", "s"
+	c.ProjSnap.DeltaTok = projSnapDeltaLimit(c.ProjSnap.SnapTok)
+	c.ProjSnap.State = live.state
+	if r, _ := c.projSnapApplyLocked(live2, "k", "s", "t3"); !r {
+		t.Fatal("seuil dépassé : rafraîchissement attendu")
+	}
+	// La clé suit le lancement de Loki.
+	k1 := projSnapKey(caps, ReadConfig())
+	old := projSnapBoot
+	projSnapBoot = "autre"
+	defer func() { projSnapBoot = old }()
+	if projSnapKey(caps, ReadConfig()) == k1 {
+		t.Fatal("redémarrage : clé inchangée")
+	}
+	projSnapBoot = old
+	if err := SetConfigKey("REASONING_EFFORT", "high"); err != nil {
+		t.Fatal(err)
+	}
+	if projSnapKey(caps, ReadConfig()) != k1 {
+		t.Fatal("un réglage de conversation ne doit pas rafraîchir")
+	}
+	if err := SetConfigKey("MODEL", "/models/autre.gguf"); err != nil {
+		t.Fatal(err)
+	}
+	if projSnapKey(caps, ReadConfig()) == k1 {
+		t.Fatal("changement de modèle : clé inchangée")
+	}
+}
+
+// La prose repart en entier ; les sections faites de lignes, ligne à ligne.
+func TestProjDeltaParType(t *testing.T) {
+	projSnapSetup(t, true)
+	old := projState{
+		Code: "Repository instructions (AGENTS.md) — follow them:\n\nmake test", Desc: "Ancienne description.",
+		MemOn: true, MemProse: "# Index", Mem: map[string]string{"a.md": "- [A](a.md)", "b.md": "- [B](b.md)"},
+		Trk: map[string]string{"poids": "poids — 72 kg (2026-10-01)", "pas": "pas — 8000 (2026-10-01)"},
+	}
+	lv := projLive{
+		state: projState{
+			Code: "Repository instructions (AGENTS.md) — follow them:\n\ngo test ./...", Desc: "Nouvelle description,\nsur deux lignes.",
+			MemOn: true, MemProse: "# Index", Mem: map[string]string{"a.md": "- [A](a.md) — accroche", "c.md": "- [C](c.md)"},
+			Trk: map[string]string{"poids": "poids — 73 kg (2026-10-03)", "eau": "eau — 2 L (2026-10-03)"},
+		},
+		memOrder: []string{"a.md", "c.md"},
+		trkOrder: []string{"poids", "eau"},
+	}
+	d := projDelta(old, lv, "2026-10-04 09:00")
+	for _, want := range []string{
+		ctxUpdOpen + ` at="2026-10-04 09:00">`,
+		"go test ./...",
+		"Nouvelle description,\nsur deux lignes.",
+		"~ [A](a.md) — accroche", "+ [C](c.md)", "- b.md (deleted)",
+		"~ poids — 73 kg (2026-10-03)", "+ eau — 2 L (2026-10-03)", "- pas — 8000 (2026-10-01) (deleted)",
+	} {
+		if !strings.Contains(d, want) {
+			t.Fatalf("manque %q dans :\n%s", want, d)
+		}
+	}
+	if strings.Contains(d, "make test") || strings.Contains(d, "Ancienne") {
+		t.Fatalf("l'ancien texte ne doit pas repartir :\n%s", d)
+	}
+	// En-tête de l'index modifié : l'index repart en entier.
+	lv.state.MemProse = "# Index (revu)"
+	lv.memMsg = Message{Content: "Project memory index … # Index (revu)"}
+	if d := projDelta(old, lv, "t"); !strings.Contains(d, "Current version, replaces any earlier one — Project memory index") {
+		t.Fatalf("prose de l'index modifiée : index complet attendu :\n%s", d)
+	}
+	if projDelta(old, projLive{state: old}, "t") != "" {
+		t.Fatal("rien de changé : mise à jour vide attendue")
+	}
+}
+
+// Les blocs sont retirés partout où le texte de l'utilisateur est lu : tâche du
+// vérificateur, titre, export, entrée du résumeur ; en texte et en multimodal.
+func TestProjSnapRetireDesLecteurs(t *testing.T) {
+	testHome(t)
+	blk := ctxUpdOpen + ` at="t">` + "\n+ [A](a.md)\n" + ctxUpdClose + "\n\n"
+	c := newTestConv()
+	first := um(blk + "corrige le build")
+	first.CtxUpd = true
+	c.Messages = []Message{first, am("ok")}
+	if got := c.lastUserText(); got != "corrige le build" {
+		t.Fatalf("tâche du vérificateur : %q", got)
+	}
+	if got := convSummary(c.Messages); got != "corrige le build" {
+		t.Fatalf("titre : %q", got)
+	}
+	out, err := c.ExportJSON(exportOpts{})
+	if err != nil || strings.Contains(string(out), "context_update") {
+		t.Fatalf("export : %v %s", err, out)
+	}
+	multi := []Message{
+		{Role: "user", CtxUpd: true, Content: []any{map[string]any{"type": "text", "text": blk}, map[string]any{"type": "text", "text": "vois l'image"}}},
+		{Role: "user", CtxUpd: true, Content: []map[string]any{{"type": "text", "text": blk + "suite"}}},
+	}
+	got := stripContextUpdates(multi)
+	if hasContextUpdates(got) || len(got[0].Content.([]any)) != 1 || got[1].Content.([]map[string]any)[0]["text"] != "suite" {
+		t.Fatalf("multimodal : %+v", got)
+	}
+	if hasContextUpdates(multi) == false {
+		t.Fatal("l'original ne doit pas être modifié")
+	}
+	// Un texte qui en parle plus loin n'est pas touché.
+	plain := []Message{{Role: "user", CtxUpd: true, Content: "explique " + blk}}
+	if s := stripContextUpdates(plain); msgText(s[0]) != msgText(plain[0]) {
+		t.Fatal("bloc hors tête retiré")
+	}
+	// Mise à jour posée puis retirée : retour exact au texte.
+	for _, m0 := range []Message{um("x"), {Role: "user", Content: []any{map[string]any{"type": "text", "text": "vois"}}}} {
+		m1, ok := prependCtxUpdate(m0, blk)
+		if !ok {
+			t.Fatal("pose refusée")
+		}
+		m2, _ := withoutCtxUpdate(m1)
+		if !reflect.DeepEqual(jsonValue(t, m2), jsonValue(t, m0)) {
+			t.Fatalf("aller-retour : %+v", m2)
+		}
+	}
+}
+
+// Valeurs de la clé ; un preset externe n'est jamais concerné.
+func TestProjSnapEnabled(t *testing.T) {
+	for v, want := range map[string]bool{"": false, "off": false, "0": false, "on": true, "1": true, "oui": true, " ON ": true} {
+		if got := projSnapEnabled(map[string]string{"PROJ_SNAPSHOT": v}); got != want {
+			t.Fatalf("%q : %v", v, got)
+		}
+	}
+	if projSnapEnabled(map[string]string{"PROJ_SNAPSHOT": "on", extKeyFlag: "1"}) {
+		t.Fatal("preset externe : jamais de bloc figé")
+	}
+}
+
+// replaceProjectHead garde le rappel des pages lues, après le bloc neuf.
+func TestReplaceProjectHead(t *testing.T) {
+	msgs := []Message{
+		{Role: "system", Content: "base"},
+		{Role: "system", Content: projectContextPrefix + " — vieux"},
+		{Role: "system", Content: memIndexPrefix + " vieux"},
+		{Role: "system", Content: memReminderPrefix + " a.md"},
+		um("q"),
+	}
+	block := []Message{{Role: "system", Content: memIndexPrefix + " neuf"}}
+	out := replaceProjectHead(msgs, block)
+	var got []string
+	for _, m := range out {
+		got = append(got, msgText(m))
+	}
+	want := []string{"base", memIndexPrefix + " neuf", memReminderPrefix + " a.md", "q"}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("%v", got)
+	}
+	// Bloc vide au départ : inséré après le système commun.
+	out = replaceProjectHead([]Message{{Role: "system", Content: "base"}, um("q")}, block)
+	if msgText(out[1]) != memIndexPrefix+" neuf" || msgText(out[2]) != "q" {
+		t.Fatalf("%+v", out)
+	}
+}
+
+// Corrections de relecture du lot 2 : seul un bloc posé par Loki (marqué) est
+// retiré. Sans la clé, un message TAPÉ qui commence par la même balise reste
+// tel quel partout — historique, envoi, titre — et la marque ne part jamais
+// au moteur.
+func TestProjSnapTexteTapeIntact(t *testing.T) {
+	testHome(t)
+	typed := um(ctxUpdOpen + ` at="x">` + "\ncollé depuis un journal\n" + ctxUpdClose + "\n\nqu'est-ce que c'est ?")
+	c := newTestConv()
+	c.Messages = []Message{typed}
+	if got := stripContextUpdates(c.Messages); msgText(got[0]) != msgText(typed) {
+		t.Fatal("texte tapé retouché")
+	}
+	sent, _, _ := c.turnView(Caps{Agent: true}, c.epoch, append([]Message(nil), c.Messages...), true)
+	if msgText(sent[len(sent)-1]) != msgText(typed) || msgText(c.Messages[0]) != msgText(typed) {
+		t.Fatalf("texte tapé retouché à l'envoi ou dans l'historique : %q", msgText(sent[len(sent)-1]))
+	}
+	if got := convSummary(c.Messages); !strings.Contains(got, "collé depuis un journal") {
+		t.Fatalf("titre : %q", got)
+	}
+	marked, ok := prependCtxUpdate(um("suite"), ctxUpdOpen+` at="t">`+"\n+ x\n"+ctxUpdClose+"\n\n")
+	if !ok || !marked.CtxUpd {
+		t.Fatal("bloc posé sans marque")
+	}
+	wire, _ := wireMessages([]Message{marked}, false, echoPolicy{})
+	b, _ := json.Marshal(wire)
+	if strings.Contains(string(b), "ctx_upd") {
+		t.Fatalf("marque envoyée au moteur : %s", b)
+	}
+	if s, ok := withoutCtxUpdate(marked); !ok || s.CtxUpd || msgText(s) != "suite" {
+		t.Fatalf("bloc marqué non retiré : %+v", s)
+	}
+}

internal/loki/chat_sessions.go

@@ -171,6 +171,9 @@ func convSummary(msgs []Message) string {
 		if m.Role != "user" || isLokiInjected(m) {
 			continue
 		}
+		// Le titre vient de ce qu'a écrit l'utilisateur, pas d'une mise à jour
+		// du projet posée en tête par Loki (PROJ_SNAPSHOT).
+		m, _ = withoutCtxUpdate(m)
 		s, _ := m.Content.(string)
 		s = strings.TrimSpace(strings.ReplaceAll(s, "\n", " "))
 		if s == "" {
@@ -217,6 +220,7 @@ func projectSwitch(slug string) error {
 	}
 	// convIndex rend la plus récemment modifiée en tête.
 	convActivate(list[0].ID, storeBytes(bkChat, convKey(list[0].ID)))
+	prewarmAfterSwitch()
 	return nil
 }
 
@@ -244,6 +248,7 @@ func convSwitch(id string) error {
 	}
 	conv.persist() // fige la discussion qu'on quitte
 	convActivate(id, storeBytes(bkChat, convKey(id)))
+	prewarmAfterSwitch()
 	return nil
 }
 

internal/loki/chat_tools.go

@@ -117,7 +117,13 @@ func baseSystemPrompt(caps Caps, tools []Tool) string {
 		year := time.Now().Format("2006")
 		b.WriteString("\nWeb: web_open first, then web_read/web_grep on it.\n")
 		b.WriteString("Your training data is stale. For ANY question about recent/latest/current things (releases, versions, news, prices, scores, 'since when') call web_search BEFORE writing any date or version, and match what you actually read.\n")
-		b.WriteString("Today is in " + year + ". If a query needs a year use ONLY " + year + ", never a remembered past year like " + prevYear(year) + " — it biases results toward stale pages; better still, omit the year. Don't hedge ('probably') about a fact a tool can verify — search instead.\n")
+		if caps.envInCtx {
+			// Même consigne, sans la valeur : l'année est dans la ligne de date du
+			// contexte (envContextMessage), qui nomme aussi l'année périmée.
+			b.WriteString("Today's date is in your context. If a query needs a year use ONLY the current year, never a remembered past year — it biases results toward stale pages; better still, omit the year. Don't hedge ('probably') about a fact a tool can verify — search instead.\n")
+		} else {
+			b.WriteString("Today is in " + year + ". If a query needs a year use ONLY " + year + ", never a remembered past year like " + prevYear(year) + " — it biases results toward stale pages; better still, omit the year. Don't hedge ('probably') about a fact a tool can verify — search instead.\n")
+		}
 	}
 	if caps.Agent && caps.ComputerUse {
 		b.WriteString(cuPromptLine())
@@ -127,6 +133,18 @@ func baseSystemPrompt(caps Caps, tools []Tool) string {
 	if caps.Agent {
 		b.WriteString(mcpPromptLine(tools))
 	}
+	// PROJ_SNAPSHOT (chat_projsnap.go) : le bloc projet est figé, ses changements
+	// arrivent en tête des messages suivants. Une ligne fixe, seulement avec la
+	// clé, pour qu'ils ne passent ni pour la parole de l'utilisateur ni pour
+	// moins récents que le bloc.
+	if caps.Agent && projSnapEnabled(ReadConfig()) {
+		b.WriteString(projSnapSystemLine)
+	}
+	// PROJ_SNAPSHOT : la date part dans le bloc projet figé (chat_envctx.go). Ici,
+	// elle changeait le système à minuit — tout le prompt recalculé.
+	if caps.envInCtx {
+		return strings.TrimRight(b.String(), "\n")
+	}
 	b.WriteString("\nDate: " + time.Now().Format("2006-01-02"))
 	return b.String()
 }
@@ -154,23 +172,33 @@ func machineSystemPrompt(caps Caps) string {
 	// l'hôte du serveur et se trompe de machine.
 	if tgt, ok := nodeTargetMetaGet(); ok {
 		var b strings.Builder
-		b.WriteString("Machine: you are operating on a REMOTE node named " + tgt.name)
-		if tgt.os != "" {
-			b.WriteString(" (" + tgt.os + ")")
+		// PROJ_SNAPSHOT (caps.envInCtx) : nom, système, dossier et état du poste
+		// sont dans le bloc projet (envMachineFacts) ; ici, les seules consignes.
+		if caps.envInCtx {
+			b.WriteString("Machine: you are operating on a REMOTE node (name, OS, working folder and status are in your context)")
+		} else {
+			b.WriteString("Machine: you are operating on a REMOTE node named " + tgt.name)
+			if tgt.os != "" {
+				b.WriteString(" (" + tgt.os + ")")
+			}
 		}
 		b.WriteString(". Your bash, write and edit tools run on THAT machine — a different computer than this server.")
 		if strings.HasPrefix(strings.ToLower(tgt.os), "windows") {
 			b.WriteString(" Its shell is cmd.exe: use cmd syntax (never bash idioms like ls, 2>nul, single quotes, or 'cmd //c'). To create a file, use the write tool, never echo/type into it.")
 		}
 		if tgt.root != "" {
-			b.WriteString(" File paths in write/edit resolve inside its working folder " + tgt.root + "; read/write are confined there.")
+			if caps.envInCtx {
+				b.WriteString(" File paths in write/edit resolve inside its working folder; read/write are confined there.")
+			} else {
+				b.WriteString(" File paths in write/edit resolve inside its working folder " + tgt.root + "; read/write are confined there.")
+			}
 		}
 		// Le poste peut tourner en compte de service (Windows: LocalSystem) : les
 		// variables d'environnement personnelles (%USERPROFILE%, $HOME) ne désignent
 		// PAS forcément l'utilisateur interactif. Utiliser des chemins absolus.
 		b.WriteString(" It may run as a background service account, so %USERPROFILE%/$HOME may not point to the interactive user — prefer absolute paths (e.g. C:\\Users\\<name>\\...).")
-		if !tgt.connected {
-			b.WriteString(" ⚠ It is currently OFFLINE: those tools will fail until it reconnects. Tell the user instead of trying repeatedly.")
+		if !tgt.connected && !caps.envInCtx {
+			b.WriteString(" " + nodeOfflineLine)
 		}
 		return b.String()
 	}
@@ -189,7 +217,10 @@ func machineSystemPrompt(caps Caps) string {
 	if who != "" {
 		b.WriteString(", user=" + who)
 	}
-	if cwd != "" {
+	// PROJ_SNAPSHOT (caps.envInCtx) : le chemin, propre à chaque discussion, est
+	// dans le bloc projet (envMachineFacts) ; hôte et compte, les mêmes pour
+	// toutes, restent ici avec les consignes.
+	if cwd != "" && !caps.envInCtx {
 		b.WriteString(", cwd=" + cwd)
 	}
 	b.WriteString(".")
@@ -198,7 +229,12 @@ func machineSystemPrompt(caps Caps) string {
 		// EST (l'endroit par défaut de tout ce que le modèle produit) marche mieux
 		// que d'interdire d'en sortir — et nommer les dossiers système coupe court
 		// aux « installations » en /usr/local/bin qui échouent faute de root.
-		b.WriteString(" This is your working folder: relative paths in write/edit/bash resolve here, and it is the DEFAULT place for scratch work — notes, outputs, a clone, a test. But it is DISPOSABLE: deleting the discussion wipes it. Any script you want to KEEP (or schedule), write it into your scripts folder " + scriptsDir() + " instead — a separate folder a workspace wipe won't touch; you write and run scripts there normally. Do NOT install or write files into system directories such as /usr/local/bin, /usr, /bin or /etc: those need root and are not yours. Only use an absolute path outside this folder (except your scripts folder) when the user explicitly named that location.")
+		if caps.envInCtx {
+			b.WriteString(" Your working folder (cwd) is given in your context: relative paths in write/edit/bash resolve there")
+		} else {
+			b.WriteString(" This is your working folder: relative paths in write/edit/bash resolve here")
+		}
+		b.WriteString(", and it is the DEFAULT place for scratch work — notes, outputs, a clone, a test. But it is DISPOSABLE: deleting the discussion wipes it. Any script you want to KEEP (or schedule), write it into your scripts folder " + scriptsDir() + " instead — a separate folder a workspace wipe won't touch; you write and run scripts there normally. Do NOT install or write files into system directories such as /usr/local/bin, /usr, /bin or /etc: those need root and are not yours. Only use an absolute path outside this folder (except your scripts folder) when the user explicitly named that location.")
 	}
 	return b.String()
 }

internal/loki/chat_tplprobe.go

@@ -0,0 +1,686 @@
+package loki
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"hash/fnv"
+	"io"
+	"maps"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+	"unicode/utf8"
+)
+
+// Sonde de gabarit : que fait le gabarit de chat du modèle chargé de ce qu'on
+// lui envoie ? Deux questions, celles dont dépendent les pistes de réutilisation
+// du cache :
+//
+//   - preservesHistory : le raisonnement d'un message assistant PASSÉ (avant le
+//     dernier message utilisateur) est-il encore rendu ? Les gabarits Qwen3 le
+//     retirent, d'autres le gardent.
+//   - prefixStable : quand un message utilisateur s'ajoute après un tour
+//     d'outil, le rendu précédent reste-t-il un préfixe exact du nouveau ? Sinon
+//     le moteur recalcule depuis l'endroit où les deux divergent, quoi que fasse
+//     son cache.
+//
+// Plus une troisième, déduite des mêmes rendus : rendersReasoning, le gabarit
+// rend-il reasoning_content quelque part ?
+//
+// DIAGNOSTIQUE d'abord. Rien ici ne construit un prompt : preservesHistory
+// décrit le gabarit, pas ce que Loki fait. Seul consommateur : REASONING_ECHO
+// (llm_reasoning_echo.go, opt-in), qui s'abstient de renvoyer un raisonnement
+// que le gabarit ne rend jamais, et ne compte celui d'avant la dernière
+// question que si le gabarit le garde. Jamais pour AJOUTER quoi que ce soit :
+// « unknown » y laisse la décision à la clé, avec ses filets.
+//
+// Règles de conduite, toutes là pour qu'une sonde ne coûte jamais rien au vrai
+// travail :
+//
+//   - moteur LOCAL seulement : un preset externe n'a pas de /apply-template, et
+//     sonder une API tierce n'apprendrait rien de son gabarit ;
+//   - POST /apply-template et rien d'autre. Ce rendu est sans état (ni file de
+//     tâches ni slot), donc il ne peut pas évincer le cache de la conversation.
+//     Jamais de repli sur une complétion : avec un seul slot, elle effacerait
+//     précisément le KV qu'on cherche à préserver ;
+//   - lancée APRÈS une complétion terminée, en tâche de fond, une fois /health à
+//     200 : jamais sur le chemin du premier jeton ;
+//   - les mêmes outils et chat_template_kwargs que la complétion qui l'a
+//     déclenchée : les gabarits Qwen bifurquent sur enable_thinking, sur
+//     reasoning_effort et sur la présence d'outils ;
+//   - add_generation_prompt=false demandé au moteur, plutôt que de deviner à la
+//     main où commence l'amorce de réponse ;
+//   - tout échec (404 d'un moteur ancien ou d'un fork, 401, exception du
+//     gabarit, délai) donne « unknown », jamais un oui ou un non.
+
+type tplTri string
+
+const (
+	tplYes     tplTri = "yes"
+	tplNo      tplTri = "no"
+	tplUnknown tplTri = "unknown"
+)
+
+// tplProbeResult : ce que la sonde a conclu pour un moteur, un modèle, un
+// gabarit et une forme de requête donnés. Aucun texte de conversation : les
+// messages rendus sont synthétiques, et seuls des verdicts sont gardés.
+type tplProbeResult struct {
+	PreservesHistory tplTri `json:"preserves_history"`
+	PrefixStable     tplTri `json:"prefix_stable"`
+	// RendersReasoning : reasoning_content apparaît-il dans un rendu, au moins
+	// juste après la dernière question ? « no » = le gabarit (ou le moteur)
+	// l'ignore toujours.
+	RendersReasoning tplTri `json:"renders_reasoning"`
+	Build            string `json:"build,omitempty"`
+	Model            string `json:"model,omitempty"` // nom du fichier, pas le chemin
+	TemplateHash     string `json:"template_hash,omitempty"`
+	Tools            int    `json:"tools"`
+	// Kwargs : chat_template_kwargs avec lesquels les rendus ont été faits.
+	Kwargs map[string]any `json:"chat_template_kwargs,omitempty"`
+	Effort string         `json:"reasoning_effort,omitempty"`
+	Note   string         `json:"note,omitempty"`
+	At     time.Time      `json:"at"`
+	// cacheable : la réponse ne changera pas tant que le moteur, le modèle et le
+	// gabarit restent les mêmes (rendu obtenu, 404, exception du gabarit). Un
+	// délai, un 503 ou un 401 se retentent plus tard.
+	cacheable bool
+}
+
+func tplUnknownResult(note string) tplProbeResult {
+	return tplProbeResult{PreservesHistory: tplUnknown, PrefixStable: tplUnknown, RendersReasoning: tplUnknown, Note: note, At: time.Now()}
+}
+
+// tplShape : la forme de la requête à reproduire. Les outils sont figés en JSON
+// dès la prise de forme : la goroutine de sonde ne partage rien avec runChat.
+type tplShape struct {
+	tools  json.RawMessage // nil = aucun outil envoyé
+	nTools int
+	first  string // nom du premier outil, pour un appel vraisemblable
+	kwargs map[string]any
+	effort string
+}
+
+func newTplShape(tools []Tool, kwargs map[string]any, effort string) tplShape {
+	s := tplShape{nTools: len(tools), effort: effort}
+	if len(tools) > 0 {
+		s.tools, _ = json.Marshal(tools)
+		s.first = tools[0].Function.Name
+	}
+	if kwargs != nil {
+		s.kwargs = maps.Clone(kwargs)
+	}
+	return s
+}
+
+func (s tplShape) hash() string {
+	h := fnv.New64a()
+	h.Write(s.tools)
+	kw, _ := json.Marshal(s.kwargs) // clés triées : stable
+	h.Write([]byte{0})
+	h.Write(kw)
+	h.Write([]byte{0})
+	h.Write([]byte(s.effort))
+	return fmt.Sprintf("%016x", h.Sum64())
+}
+
+// Messages synthétiques. Des marqueurs qu'aucun gabarit ne produit de lui-même,
+// cherchés tels quels dans le rendu.
+const (
+	tplMarkSys = "loki-sonde-systeme"
+	tplMarkA   = "loki-sonde-question-a"
+	tplMarkR1  = "loki-sonde-raisonnement-r1"
+	tplMarkC1  = "loki-sonde-reponse-c1"
+	tplMarkT1  = "loki-sonde-resultat-t1"
+	tplMarkB   = "loki-sonde-question-b"
+	// Identifiant d'appel : 9 caractères alphanumériques, la forme qu'exigent les
+	// gabarits stricts (Mistral) sous peine de raise_exception.
+	tplCallID = "a1B2c3D4e"
+)
+
+type tplMsg struct {
+	Role             string     `json:"role"`
+	Content          string     `json:"content"`
+	ReasoningContent string     `json:"reasoning_content,omitempty"`
+	ToolCalls        []ToolCall `json:"tool_calls,omitempty"`
+	ToolCallID       string     `json:"tool_call_id,omitempty"`
+}
+
+const (
+	tplProbeTimeout  = 3 * time.Second // par requête
+	tplProbeEvery    = time.Minute     // au plus une vérification par minute
+	tplProbeCacheMax = 16
+	tplProbe503Tries = 3
+)
+
+var (
+	// tplProbeAuto : déclenchement automatique après les complétions. Coupé par
+	// les tests du paquet (TestMain), dont les faux moteurs ne répondent pas
+	// tous en JSON : la sonde y est appelée explicitement.
+	tplProbeAuto = true
+	// Attente entre deux essais sur un 503 (modèle en chargement).
+	tplProbeBackoff = time.Second
+
+	tplProbeMu    sync.Mutex
+	tplProbeCache = map[string]tplProbeResult{}
+	tplProbeLast  *tplProbeResult
+	// tplProbeByShape : le dernier verdict de chaque forme de requête
+	// (tplShape.hash). tplProbeLast est celui de la dernière forme sondée,
+	// quelle qu'elle soit : bon pour l'affichage, pas pour décider d'une
+	// requête d'une autre forme (tplCapsFor).
+	tplProbeByShape = map[string]tplProbeResult{}
+	tplProbeRunning bool
+	tplProbeTried   time.Time
+	tplProbeLogged  string
+	// tplProbeShapeLast : la forme de la dernière requête sondée. C'est elle
+	// que rejoue la vérification du rendu autour d'une mise à jour du moteur
+	// (web_engine_reco.go) : mêmes outils, mêmes chat_template_kwargs que les
+	// vraies requêtes, sans rien garder de leur texte.
+	tplProbeShapeLast *tplShape
+)
+
+// tplLastShape : la forme de la dernière requête sondée, ou une requête nue
+// (sans outils ni kwargs) si aucune complétion n'a encore eu lieu.
+func tplLastShape() tplShape {
+	tplProbeMu.Lock()
+	defer tplProbeMu.Unlock()
+	if tplProbeShapeLast != nil {
+		return *tplProbeShapeLast
+	}
+	return newTplShape(nil, nil, "")
+}
+
+// tplLocalProber : le prober du moteur local, comme celui de la sonde.
+func tplLocalProber() tplProber {
+	return tplProber{
+		base:   fmt.Sprintf("http://localhost:%d", LLMPort()),
+		auth:   authHeader,
+		client: &http.Client{Timeout: tplProbeTimeout},
+	}
+}
+
+// tplProbeKick : appelé par runChat après une complétion COMPLÈTE du fil
+// principal, sur le moteur local, avec ce qu'elle a envoyé. Ne bloque jamais :
+// au plus une sonde en vol, au plus une vérification par minute (la plupart se
+// résument à un GET /props qui retrouve la réponse en cache).
+func tplProbeKick(tools []Tool, kwargs map[string]any, effort string) {
+	if !tplProbeAuto {
+		return
+	}
+	tplProbeMu.Lock()
+	if tplProbeRunning || time.Since(tplProbeTried) < tplProbeEvery {
+		tplProbeMu.Unlock()
+		return
+	}
+	tplProbeRunning, tplProbeTried = true, time.Now()
+	tplProbeMu.Unlock()
+	shape := newTplShape(tools, kwargs, effort)
+	go func() {
+		defer func() {
+			tplProbeMu.Lock()
+			tplProbeRunning = false
+			tplProbeMu.Unlock()
+		}()
+		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+		defer cancel()
+		tplProbeEnsure(ctx, shape)
+	}()
+}
+
+// tplCapsCurrent : le dernier verdict connu, pour l'affichage. Rien pour un
+// preset externe : un verdict du moteur local n'y dirait rien de vrai.
+func tplCapsCurrent() (tplProbeResult, bool) {
+	if externalActive() {
+		return tplProbeResult{}, false
+	}
+	tplProbeMu.Lock()
+	defer tplProbeMu.Unlock()
+	if tplProbeLast == nil {
+		return tplProbeResult{}, false
+	}
+	return *tplProbeLast, true
+}
+
+// tplCapsFor : le dernier verdict pour CETTE forme de requête (mêmes outils,
+// mêmes chat_template_kwargs, même reasoning_effort). Pas de verdict pour elle
+// — jamais sondée, ou sortie du cache — : rien, et l'appelant se replie comme
+// sur « inconnu ». Rien non plus pour un preset externe.
+func tplCapsFor(shape tplShape) (tplProbeResult, bool) {
+	if externalActive() {
+		return tplProbeResult{}, false
+	}
+	tplProbeMu.Lock()
+	defer tplProbeMu.Unlock()
+	r, ok := tplProbeByShape[shape.hash()]
+	return r, ok
+}
+
+// tplProbeEnsure : verdict pour la forme donnée, depuis le cache ou une sonde.
+func tplProbeEnsure(ctx context.Context, shape tplShape) tplProbeResult {
+	if resolveChatEndpoint().External {
+		return tplUnknownResult("preset externe : pas de sonde")
+	}
+	tplProbeMu.Lock()
+	s := shape
+	tplProbeShapeLast = &s
+	tplProbeMu.Unlock()
+	p := tplLocalProber()
+	if !p.healthy(ctx) {
+		// Moteur absent ou en chargement : rien à conclure, rien à ranger.
+		return tplUnknownResult("moteur pas prêt (/health)")
+	}
+	props, err := p.props(ctx)
+	if err != nil {
+		r := tplUnknownResult("/props illisible : " + err.Error())
+		tplProbeStore("", shape.hash(), r)
+		return r
+	}
+	h := fnv.New64a()
+	h.Write([]byte(props.ChatTemplate))
+	tmplHash := fmt.Sprintf("%016x", h.Sum64())
+	// Clé : le binaire, le modèle ET le gabarit effectivement chargé — un
+	// --chat-template d'EXTRA_ARGS change le dernier sans toucher aux deux
+	// autres. Plus la forme de la requête, dont le rendu dépend.
+	key := props.BuildInfo + "\x00" + props.ModelPath + "\x00" + tmplHash + "\x00" + shape.hash()
+	tplProbeMu.Lock()
+	if r, ok := tplProbeCache[key]; ok {
+		tplProbeLast = &r
+		tplProbeKeepShape(shape.hash(), r)
+		tplProbeMu.Unlock()
+		return r
+	}
+	tplProbeMu.Unlock()
+
+	r := p.probe(ctx, shape)
+	r.Build, r.TemplateHash, r.Tools, r.Kwargs, r.Effort = props.BuildInfo, tmplHash, shape.nTools, shape.kwargs, shape.effort
+	if props.ModelPath != "" {
+		r.Model = filepath.Base(props.ModelPath)
+	}
+	// Une ligne par verdict nouveau : un échec passager qui se répète chaque
+	// minute à l'identique n'inonde pas le journal.
+	line := tplProbeLine(r)
+	tplProbeMu.Lock()
+	fresh := line != tplProbeLogged
+	tplProbeLogged = line
+	tplProbeMu.Unlock()
+	if fresh {
+		fmt.Fprintln(os.Stderr, line)
+	}
+	tplProbeStore(key, shape.hash(), r)
+	return r
+}
+
+// tplProbeKeepShape note le verdict d'une forme (tplProbeMu tenu). Au plus
+// tplProbeCacheMax formes : la plus ancienne cède sa place.
+func tplProbeKeepShape(shape string, r tplProbeResult) {
+	if _, ok := tplProbeByShape[shape]; !ok && len(tplProbeByShape) >= tplProbeCacheMax {
+		oldest := ""
+		for k, v := range tplProbeByShape {
+			if oldest == "" || v.At.Before(tplProbeByShape[oldest].At) {
+				oldest = k
+			}
+		}
+		delete(tplProbeByShape, oldest)
+	}
+	tplProbeByShape[shape] = r
+}
+
+func tplProbeStore(key, shape string, r tplProbeResult) {
+	tplProbeMu.Lock()
+	defer tplProbeMu.Unlock()
+	tplProbeLast = &r
+	tplProbeKeepShape(shape, r)
+	if key == "" || !r.cacheable {
+		return
+	}
+	if len(tplProbeCache) >= tplProbeCacheMax {
+		oldest := ""
+		for k, v := range tplProbeCache {
+			if oldest == "" || v.At.Before(tplProbeCache[oldest].At) {
+				oldest = k
+			}
+		}
+		delete(tplProbeCache, oldest)
+	}
+	tplProbeCache[key] = r
+}
+
+func tplProbeLine(r tplProbeResult) string {
+	s := fmt.Sprintf("[tplprobe] build=%s modèle=%s gabarit=%s outils=%d historique_raisonnement=%s préfixe_stable=%s raisonnement_rendu=%s",
+		orDash(r.Build), orDash(r.Model), orDash(r.TemplateHash), r.Tools, r.PreservesHistory, r.PrefixStable, r.RendersReasoning)
+	if r.Note != "" {
+		s += " (" + r.Note + ")"
+	}
+	return s
+}
+
+func orDash(s string) string {
+	if s == "" {
+		return "-"
+	}
+	return s
+}
+
+type tplProber struct {
+	base   string
+	auth   func(*http.Request)
+	client *http.Client
+}
+
+// tplHTTPError : réponse non-200 du moteur.
+type tplHTTPError struct {
+	status int
+	body   string
+}
+
+func (e *tplHTTPError) Error() string {
+	if e.body != "" {
+		return fmt.Sprintf("HTTP %d : %s", e.status, e.body)
+	}
+	return fmt.Sprintf("HTTP %d", e.status)
+}
+
+// tplDefinitive : l'échec se reproduira à l'identique tant que moteur, modèle
+// et gabarit ne changent pas (route absente, gabarit qui lève une exception,
+// requête refusée). Un 401/403 dépend de la clé, un 503 du chargement, un
+// délai de la charge : ceux-là se retentent.
+func tplDefinitive(err error) bool {
+	var he *tplHTTPError
+	if !errors.As(err, &he) {
+		return false
+	}
+	switch he.status {
+	case http.StatusUnauthorized, http.StatusForbidden, http.StatusServiceUnavailable, http.StatusTooManyRequests:
+		return false
+	}
+	return he.status >= 400 && he.status < 600
+}
+
+func (p tplProber) do(ctx context.Context, method, path string, body []byte) ([]byte, error) {
+	ctx, cancel := context.WithTimeout(ctx, tplProbeTimeout)
+	defer cancel()
+	var rd io.Reader
+	if body != nil {
+		rd = bytes.NewReader(body)
+	}
+	req, err := http.NewRequestWithContext(ctx, method, p.base+path, rd)
+	if err != nil {
+		return nil, err
+	}
+	if body != nil {
+		req.Header.Set("Content-Type", "application/json")
+	}
+	// Un moteur protégé par API_KEY répond 401 sans la clé (le piège déjà
+	// payé par la sonde de vision, chat_screenshot.go).
+	if p.auth != nil {
+		p.auth(req)
+	}
+	resp, err := p.client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	data, err := io.ReadAll(io.LimitReader(resp.Body, 8<<20))
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode != http.StatusOK {
+		msg := strings.TrimSpace(string(data))
+		if rs := []rune(msg); len(rs) > 160 {
+			msg = string(rs[:160]) + "…"
+		}
+		return nil, &tplHTTPError{status: resp.StatusCode, body: msg}
+	}
+	return data, nil
+}
+
+func (p tplProber) healthy(ctx context.Context) bool {
+	_, err := p.do(ctx, http.MethodGet, "/health", nil)
+	return err == nil
+}
+
+type tplProps struct {
+	BuildInfo    string `json:"build_info"`
+	ModelPath    string `json:"model_path"`
+	ChatTemplate string `json:"chat_template"`
+}
+
+func (p tplProber) props(ctx context.Context) (tplProps, error) {
+	var out tplProps
+	data, err := p.do(ctx, http.MethodGet, "/props", nil)
+	if err != nil {
+		return out, err
+	}
+	if err := json.Unmarshal(data, &out); err != nil {
+		return out, fmt.Errorf("réponse non JSON")
+	}
+	return out, nil
+}
+
+// render : POST /apply-template, relancé sur 503 (modèle en chargement).
+func (p tplProber) render(ctx context.Context, shape tplShape, msgs []tplMsg, genPrompt bool) (string, error) {
+	body := map[string]any{"messages": msgs, "add_generation_prompt": genPrompt}
+	// Mêmes clés que runChat, et seulement celles qui atteignent le gabarit.
+	if shape.tools != nil {
+		body["tools"] = shape.tools
+		body["parallel_tool_calls"] = false
+	}
+	if shape.kwargs != nil {
+		body["chat_template_kwargs"] = shape.kwargs
+	}
+	if shape.effort != "" {
+		body["reasoning_effort"] = shape.effort
+	}
+	raw, err := json.Marshal(body)
+	if err != nil {
+		return "", err
+	}
+	for try := 1; ; try++ {
+		data, err := p.do(ctx, http.MethodPost, "/apply-template", raw)
+		var he *tplHTTPError
+		if err != nil && errors.As(err, &he) && he.status == http.StatusServiceUnavailable && try < tplProbe503Tries {
+			select {
+			case <-ctx.Done():
+				return "", ctx.Err()
+			case <-time.After(time.Duration(try) * tplProbeBackoff):
+			}
+			continue
+		}
+		if err != nil {
+			return "", err
+		}
+		var out struct {
+			Prompt *string `json:"prompt"`
+		}
+		if json.Unmarshal(data, &out) != nil || out.Prompt == nil {
+			return "", &tplHTTPError{status: http.StatusOK, body: "réponse sans prompt"}
+		}
+		return *out.Prompt, nil
+	}
+}
+
+// probe : les rendus et leurs verdicts. Chaque verdict ne vaut que si ses
+// propres rendus ont abouti ; l'autre peut rester inconnu.
+func (p tplProber) probe(ctx context.Context, shape tplShape) tplProbeResult {
+	r := tplUnknownResult("")
+	definitive := true
+	var notes []string
+	fail := func(what string, err error) {
+		if !tplDefinitive(err) {
+			definitive = false
+		}
+		notes = append(notes, what+" : "+err.Error())
+	}
+
+	sys := tplMsg{Role: "system", Content: tplMarkSys}
+	userA := tplMsg{Role: "user", Content: tplMarkA}
+	userB := tplMsg{Role: "user", Content: tplMarkB}
+
+	// 1) Raisonnement d'un tour passé : [système, A, assistant{R1, C1}, B].
+	hist, err := p.render(ctx, shape, []tplMsg{sys, userA,
+		{Role: "assistant", Content: tplMarkC1, ReasoningContent: tplMarkR1}, userB}, false)
+	switch {
+	case err != nil:
+		fail("historique", err)
+	case !strings.Contains(hist, tplMarkC1) || !strings.Contains(hist, tplMarkB):
+		notes = append(notes, "historique : rendu incohérent")
+	case strings.Contains(hist, tplMarkR1):
+		r.PreservesHistory = tplYes
+	default:
+		r.PreservesHistory = tplNo
+	}
+
+	// 2) Stabilité du préfixe à travers un tour d'outil bien formé : un appel
+	// avec identifiant, puis son résultat, puis un nouveau message utilisateur.
+	name := shape.first
+	if name == "" {
+		name = "lookup"
+	}
+	call := tplMsg{Role: "assistant", Content: tplMarkC1, ReasoningContent: tplMarkR1,
+		ToolCalls: []ToolCall{{ID: tplCallID, Type: "function", Function: ToolCallFunc{Name: name, Arguments: "{}"}}}}
+	result := tplMsg{Role: "tool", Content: tplMarkT1, ToolCallID: tplCallID}
+	before := []tplMsg{sys, userA, call, result}
+	after := append(append([]tplMsg{}, before...), userB)
+
+	r1, err1 := p.render(ctx, shape, before, false)
+	var r1g, r2 string
+	var err2, err3 error
+	if err1 == nil {
+		r1g, err2 = p.render(ctx, shape, before, true)
+	}
+	if err1 == nil && err2 == nil {
+		r2, err3 = p.render(ctx, shape, after, false)
+	}
+	switch {
+	case err1 != nil:
+		fail("préfixe", err1)
+	case err2 != nil:
+		fail("préfixe", err2)
+	case err3 != nil:
+		fail("préfixe", err3)
+	case r1 == r1g:
+		// Un moteur qui ignore add_generation_prompt rend l'amorce de réponse
+		// dans les deux cas : la comparaison conclurait à tort « instable ».
+		notes = append(notes, "add_generation_prompt ignoré par le moteur")
+	case !strings.Contains(r1, tplMarkT1) || !strings.Contains(r2, tplMarkB):
+		notes = append(notes, "préfixe : rendu incohérent")
+	case strings.HasPrefix(r2, r1):
+		r.PrefixStable = tplYes
+	default:
+		r.PrefixStable = tplNo
+	}
+	switch {
+	case r.PreservesHistory == tplYes || (err1 == nil && strings.Contains(r1, tplMarkR1)):
+		r.RendersReasoning = tplYes
+	case err1 == nil && strings.Contains(r1, tplMarkT1) && r.PreservesHistory == tplNo:
+		// Même au dernier tour le raisonnement n'apparaît pas : c'est le moteur
+		// (ou le gabarit) qui ignore reasoning_content, pas un tri par position.
+		r.RendersReasoning = tplNo
+		notes = append(notes, "reasoning_content jamais rendu")
+	}
+	r.Note = strings.Join(notes, " ; ")
+	r.cacheable = definitive
+	return r
+}
+
+// --- Rendu comparé d'un moteur à l'autre ----------------------------------------
+//
+// Une mise à jour du moteur peut changer le prompt rendu sans qu'aucun réglage
+// de Loki ne bouge : depuis b10763, llama-server active preserve_reasoning par
+// défaut, et un gabarit qui ne gardait pas la réflexion des tours passés
+// (Qwen3.6) se met à la rendre — vide, puisque Loki ne la renvoie pas sans
+// REASONING_ECHO. Le modèle relirait alors un historique où il n'a jamais
+// réfléchi. tplRenderPrint fige le rendu de quelques conversations
+// synthétiques ; le même relevé avant et après la bascule dit si le prompt a
+// changé, et où.
+
+// tplRenderSep sépare les rendus dans l'empreinte ; le nom qui suit dit de
+// quelle conversation vient un écart.
+const tplRenderSep = "\n\x00--- "
+
+// tplRenderPrint : les rendus, concaténés, de trois conversations synthétiques
+// sur la forme donnée — l'historique tel que Loki l'envoie par défaut (sans
+// reasoning_content), le même avec reasoning_content (REASONING_ECHO), et un
+// tour d'outil suivi d'une question, amorce de réponse comprise. Seul
+// /apply-template est appelé : sans état, sans slot, sans effet sur le cache.
+func tplRenderPrint(ctx context.Context, p tplProber, shape tplShape) (string, error) {
+	sys := tplMsg{Role: "system", Content: tplMarkSys}
+	userA := tplMsg{Role: "user", Content: tplMarkA}
+	userB := tplMsg{Role: "user", Content: tplMarkB}
+	name := shape.first
+	if name == "" {
+		name = "lookup"
+	}
+	convs := []struct {
+		name string
+		msgs []tplMsg
+		gen  bool
+	}{
+		{"historique sans raisonnement", []tplMsg{sys, userA, {Role: "assistant", Content: tplMarkC1}, userB}, true},
+		{"historique avec raisonnement", []tplMsg{sys, userA,
+			{Role: "assistant", Content: tplMarkC1, ReasoningContent: tplMarkR1}, userB}, true},
+		{"tour d'outil", []tplMsg{sys, userA,
+			{Role: "assistant", Content: tplMarkC1,
+				ToolCalls: []ToolCall{{ID: tplCallID, Type: "function", Function: ToolCallFunc{Name: name, Arguments: "{}"}}}},
+			{Role: "tool", Content: tplMarkT1, ToolCallID: tplCallID}, userB}, true},
+	}
+	var b strings.Builder
+	for _, c := range convs {
+		out, err := p.render(ctx, shape, c.msgs, c.gen)
+		if err != nil {
+			return "", fmt.Errorf("%s : %w", c.name, err)
+		}
+		b.WriteString(tplRenderSep + c.name + " ---\n")
+		b.WriteString(out)
+	}
+	return b.String(), nil
+}
+
+// tplRenderDiff compare deux empreintes de tplRenderPrint. Identiques : true.
+// Sinon, la conversation où elles divergent et un court extrait de part et
+// d'autre du premier écart (texte synthétique : aucun contenu de discussion).
+func tplRenderDiff(before, after string) (bool, string) {
+	if before == after {
+		return true, ""
+	}
+	i := 0
+	for i < len(before) && i < len(after) && before[i] == after[i] {
+		i++
+	}
+	section := ""
+	if k := strings.LastIndex(before[:i], tplRenderSep); k >= 0 {
+		rest := before[k+len(tplRenderSep):]
+		if e := strings.Index(rest, " ---"); e >= 0 {
+			section = rest[:e]
+		}
+	}
+	excerpt := func(s string) string {
+		from := max(0, i-40)
+		to := min(len(s), i+60)
+		// Bornes sur des débuts de caractère : un extrait ne coupe pas un rune.
+		for from > 0 && !utf8.RuneStart(s[from]) {
+			from--
+		}
+		for to < len(s) && !utf8.RuneStart(s[to]) {
+			to++
+		}
+		x := strings.NewReplacer("\n", "⏎", "\x00", "").Replace(s[from:to])
+		if from > 0 {
+			x = "…" + x
+		}
+		if to < len(s) {
+			x += "…"
+		}
+		return x
+	}
+	d := fmt.Sprintf("avant « %s » / après « %s »", excerpt(before), excerpt(after))
+	if section != "" {
+		d = section + " : " + d
+	}
+	return false, d
+}

internal/loki/chat_tplprobe_test.go

@@ -0,0 +1,491 @@
+package loki
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"os"
+	"regexp"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+)
+
+// Les faux moteurs des autres tests ne répondent pas tous en JSON sur /props :
+// la sonde automatique (lancée après chaque complétion du fil principal) y est
+// coupée, et appelée explicitement ici.
+func TestMain(m *testing.M) {
+	tplProbeAuto = false
+	os.Exit(m.Run())
+}
+
+func freshTplProbe(t *testing.T) {
+	t.Helper()
+	reset := func() {
+		tplProbeMu.Lock()
+		tplProbeCache = map[string]tplProbeResult{}
+		tplProbeLast = nil
+		tplProbeByShape = map[string]tplProbeResult{}
+		tplProbeRunning = false
+		tplProbeTried = time.Time{}
+		tplProbeLogged = ""
+		tplProbeShapeLast = nil
+		tplProbeMu.Unlock()
+	}
+	reset()
+	old := tplProbeBackoff
+	tplProbeBackoff = time.Millisecond
+	t.Cleanup(func() { reset(); tplProbeBackoff = old })
+}
+
+// fakeTpl : un llama-server réduit à /health, /props et /apply-template, avec
+// un gabarit façon ChatML écrit à la main.
+//
+//	qwen3 : le raisonnement n'est rendu qu'après le dernier message utilisateur ;
+//	keep  : il est toujours rendu ;
+//	noagp : comme keep, mais add_generation_prompt est ignoré (vieux moteur) ;
+//	drop  : reasoning_content n'est jamais rendu.
+type fakeTpl struct {
+	mu          sync.Mutex
+	mode        string
+	tpl         string // texte du gabarit annoncé par /props (défaut : mode)
+	build       string // build_info annoncé par /props (défaut : b7000-abc)
+	key         string // Bearer exigé hors /health
+	applyStatus []int  // statuts imposés aux prochains /apply-template (0 = rendu)
+	applyBody   string
+	paths       []string
+	applies     []map[string]any
+}
+
+var reCallID = regexp.MustCompile(`^[A-Za-z0-9]{9}$`)
+
+func (f *fakeTpl) render(body map[string]any) (string, int) {
+	msgs, _ := body["messages"].([]any)
+	lastUser := -1
+	for i, m := range msgs {
+		if m.(map[string]any)["role"] == "user" {
+			lastUser = i
+		}
+	}
+	var b strings.Builder
+	if tools, ok := body["tools"].([]any); ok {
+		fmt.Fprintf(&b, "<tools n=%d>\n", len(tools))
+	}
+	for i, raw := range msgs {
+		m := raw.(map[string]any)
+		role, _ := m["role"].(string)
+		b.WriteString("<|im_start|>" + role + "\n")
+		if r, _ := m["reasoning_content"].(string); r != "" && role == "assistant" && f.mode != "drop" && (f.mode != "qwen3" || i > lastUser) {
+			b.WriteString("<think>" + r + "</think>")
+		}
+		c, _ := m["content"].(string)
+		b.WriteString(c)
+		calls, _ := m["tool_calls"].([]any)
+		for _, rc := range calls {
+			call := rc.(map[string]any)
+			id, _ := call["id"].(string)
+			// Gabarit strict : identifiant de 9 alphanumériques, résultat qui suit.
+			if !reCallID.MatchString(id) || i+1 >= len(msgs) || msgs[i+1].(map[string]any)["tool_call_id"] != id {
+				return `{"error":{"code":500,"message":"Jinja Exception: tool call id invalide"}}`, 500
+			}
+			fn := call["function"].(map[string]any)
+			b.WriteString("<tool_call>" + fn["name"].(string) + "</tool_call>")
+		}
+		b.WriteString("<|im_end|>\n")
+	}
+	if agp, _ := body["add_generation_prompt"].(bool); agp || f.mode == "noagp" {
+		b.WriteString("<|im_start|>assistant\n")
+	}
+	out, _ := json.Marshal(map[string]string{"prompt": b.String()})
+	return string(out), 200
+}
+
+func (f *fakeTpl) handler(w http.ResponseWriter, r *http.Request) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.paths = append(f.paths, r.URL.Path)
+	if r.URL.Path == "/health" {
+		_, _ = w.Write([]byte(`{"status":"ok"}`))
+		return
+	}
+	if f.key != "" && r.Header.Get("Authorization") != "Bearer "+f.key {
+		w.WriteHeader(http.StatusUnauthorized)
+		_, _ = w.Write([]byte(`{"error":{"code":401,"message":"Invalid API Key"}}`))
+		return
+	}
+	switch r.URL.Path {
+	case "/props":
+		tpl := f.tpl
+		if tpl == "" {
+			tpl = f.mode
+		}
+		build := f.build
+		if build == "" {
+			build = "b7000-abc"
+		}
+		fmt.Fprintf(w, `{"build_info":%q,"model_path":"/models/Qwen3-8B-Q8_0.gguf","chat_template":%q}`, build, tpl)
+	case "/apply-template":
+		var body map[string]any
+		_ = json.NewDecoder(r.Body).Decode(&body)
+		f.applies = append(f.applies, body)
+		if len(f.applyStatus) > 0 {
+			s := f.applyStatus[0]
+			f.applyStatus = f.applyStatus[1:]
+			if s != 0 {
+				w.WriteHeader(s)
+				_, _ = w.Write([]byte(f.applyBody))
+				return
+			}
+		}
+		out, status := f.render(body)
+		w.WriteHeader(status)
+		_, _ = w.Write([]byte(out))
+	default:
+		w.WriteHeader(http.StatusNotFound)
+	}
+}
+
+func (f *fakeTpl) start(t *testing.T) {
+	t.Helper()
+	srv := httptest.NewServer(http.HandlerFunc(f.handler))
+	t.Cleanup(srv.Close)
+	u, _ := url.Parse(srv.URL)
+	if err := SetConfigKey("PORT", u.Port()); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func (f *fakeTpl) count(path string) int {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	n := 0
+	for _, p := range f.paths {
+		if p == path {
+			n++
+		}
+	}
+	return n
+}
+
+// Jamais de complétion : avec un seul slot, elle évincerait le cache de la
+// conversation que la sonde est censée servir.
+func (f *fakeTpl) assertNoCompletion(t *testing.T) {
+	t.Helper()
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	for _, p := range f.paths {
+		if strings.Contains(p, "completion") {
+			t.Fatalf("la sonde a appelé %s", p)
+		}
+	}
+}
+
+func probeTools() []Tool {
+	return []Tool{{Type: "function", Function: ToolFunction{Name: "bash", Description: "d", Parameters: map[string]any{"type": "object"}}}}
+}
+
+func TestSondeGabaritQwen3(t *testing.T) {
+	testHome(t)
+	freshTplProbe(t)
+	f := &fakeTpl{mode: "qwen3"}
+	f.start(t)
+	kw := map[string]any{"enable_thinking": false}
+	r := tplProbeEnsure(context.Background(), newTplShape(probeTools(), kw, ""))
+	if r.PreservesHistory != tplNo || r.PrefixStable != tplNo || r.RendersReasoning != tplYes {
+		t.Fatalf("Qwen3 retire le raisonnement passé : %+v", r)
+	}
+	if r.Build != "b7000-abc" || r.Model != "Qwen3-8B-Q8_0.gguf" || r.Tools != 1 || !r.cacheable {
+		t.Fatalf("métadonnées : %+v", r)
+	}
+	f.assertNoCompletion(t)
+	// Mêmes outils et chat_template_kwargs que la complétion ; jamais
+	// d'amorce de réponse, sauf le rendu qui vérifie que le moteur l'honore.
+	gen := 0
+	for _, a := range f.applies {
+		if tools, _ := a["tools"].([]any); len(tools) != 1 {
+			t.Fatalf("outils non transmis : %v", a["tools"])
+		}
+		if k, _ := a["chat_template_kwargs"].(map[string]any); k["enable_thinking"] != false {
+			t.Fatalf("chat_template_kwargs : %v", a["chat_template_kwargs"])
+		}
+		if a["add_generation_prompt"] == true {
+			gen++
+		}
+	}
+	if len(f.applies) != 4 || gen != 1 {
+		t.Fatalf("%d rendus dont %d avec amorce", len(f.applies), gen)
+	}
+	// Même moteur, même modèle, même gabarit, même forme : réponse en cache.
+	tplProbeEnsure(context.Background(), newTplShape(probeTools(), kw, ""))
+	if n := f.count("/apply-template"); n != 4 {
+		t.Fatalf("cache ignoré : %d rendus", n)
+	}
+	// Autre forme (raisonnement non coupé) : nouvelle sonde.
+	tplProbeEnsure(context.Background(), newTplShape(probeTools(), nil, ""))
+	if n := f.count("/apply-template"); n != 8 {
+		t.Fatalf("forme différente non resondée : %d rendus", n)
+	}
+	// Exposé dans /api/perf/summary.
+	rec := httptest.NewRecorder()
+	handlePerfSummary(rec, httptest.NewRequest(http.MethodGet, "/api/perf/summary", nil))
+	var sum struct {
+		Template *struct {
+			PreservesHistory string `json:"preserves_history"`
+			PrefixStable     string `json:"prefix_stable"`
+		} `json:"template"`
+	}
+	if err := json.Unmarshal(rec.Body.Bytes(), &sum); err != nil || sum.Template == nil || sum.Template.PrefixStable != "no" {
+		t.Fatalf("résumé : %s", rec.Body.String())
+	}
+	if strings.Contains(rec.Body.String(), "loki-sonde") {
+		t.Fatal("un rendu a fuité dans le résumé")
+	}
+}
+
+func TestSondeGabaritConserveLHistorique(t *testing.T) {
+	testHome(t)
+	freshTplProbe(t)
+	f := &fakeTpl{mode: "keep"}
+	f.start(t)
+	r := tplProbeEnsure(context.Background(), newTplShape(nil, nil, ""))
+	if r.PreservesHistory != tplYes || r.PrefixStable != tplYes || r.RendersReasoning != tplYes {
+		t.Fatalf("gabarit qui garde tout : %+v", r)
+	}
+	for _, a := range f.applies {
+		if _, ok := a["tools"]; ok {
+			t.Fatal("outils envoyés alors que la complétion n'en avait pas")
+		}
+	}
+}
+
+// Gabarit (ou moteur) qui ignore reasoning_content partout : « jamais rendu »,
+// ce qui suffit à REASONING_ECHO pour ne rien renvoyer d'inutile.
+func TestSondeGabaritRaisonnementJamaisRendu(t *testing.T) {
+	testHome(t)
+	freshTplProbe(t)
+	f := &fakeTpl{mode: "drop"}
+	f.start(t)
+	r := tplProbeEnsure(context.Background(), newTplShape(probeTools(), nil, ""))
+	if r.RendersReasoning != tplNo || r.PreservesHistory != tplNo || !strings.Contains(r.Note, "jamais rendu") {
+		t.Fatalf("raisonnement jamais rendu : %+v", r)
+	}
+	if !strings.Contains(tplProbeLine(r), "raisonnement_rendu=no") {
+		t.Fatalf("journal : %s", tplProbeLine(r))
+	}
+}
+
+// Un moteur qui ignore add_generation_prompt ne doit pas faire conclure
+// « instable » : l'amorce rendue dans les deux cas fausserait la comparaison.
+func TestSondeGabaritAmorceIgnoree(t *testing.T) {
+	testHome(t)
+	freshTplProbe(t)
+	f := &fakeTpl{mode: "noagp"}
+	f.start(t)
+	r := tplProbeEnsure(context.Background(), newTplShape(nil, nil, ""))
+	if r.PrefixStable != tplUnknown || r.PreservesHistory != tplYes {
+		t.Fatalf("amorce ignorée : %+v", r)
+	}
+}
+
+// Moteur ancien ou fork sans la route : inconnu, rangé (ça ne changera pas
+// avant un autre binaire), et aucun repli sur une complétion.
+func TestSondeGabarit404(t *testing.T) {
+	testHome(t)
+	freshTplProbe(t)
+	f := &fakeTpl{mode: "qwen3", applyStatus: []int{404, 404, 404, 404}, applyBody: "Not Found"}
+	f.start(t)
+	r := tplProbeEnsure(context.Background(), newTplShape(probeTools(), nil, ""))
+	if r.PreservesHistory != tplUnknown || r.PrefixStable != tplUnknown || r.RendersReasoning != tplUnknown || !r.cacheable {
+		t.Fatalf("404 : %+v", r)
+	}
+	f.assertNoCompletion(t)
+	tplProbeEnsure(context.Background(), newTplShape(probeTools(), nil, ""))
+	if n := f.count("/apply-template"); n != 2 {
+		t.Fatalf("404 resondé : %d rendus", n)
+	}
+}
+
+// Gabarit qui lève une exception (raise_exception) : inconnu, jamais oui/non.
+func TestSondeGabaritExceptionDuGabarit(t *testing.T) {
+	testHome(t)
+	freshTplProbe(t)
+	f := &fakeTpl{mode: "qwen3", applyStatus: []int{500, 500, 500, 500},
+		applyBody: `{"error":{"code":500,"message":"Jinja Exception: Conversation roles must alternate"}}`}
+	f.start(t)
+	r := tplProbeEnsure(context.Background(), newTplShape(probeTools(), nil, ""))
+	if r.PreservesHistory != tplUnknown || r.PrefixStable != tplUnknown || !strings.Contains(r.Note, "500") {
+		t.Fatalf("exception du gabarit : %+v", r)
+	}
+	f.assertNoCompletion(t)
+}
+
+// Moteur protégé par API_KEY : la sonde s'authentifie comme les autres appels
+// internes. Sans clé, inconnu — et pas rangé : la clé peut arriver.
+func TestSondeGabarit401(t *testing.T) {
+	testHome(t)
+	freshTplProbe(t)
+	f := &fakeTpl{mode: "keep", key: "sk-loki-test"}
+	f.start(t)
+	r := tplProbeEnsure(context.Background(), newTplShape(nil, nil, ""))
+	if r.PreservesHistory != tplUnknown || r.PrefixStable != tplUnknown || !strings.Contains(r.Note, "401") {
+		t.Fatalf("401 : %+v", r)
+	}
+	if err := writeAPIKey("sk-loki-test"); err != nil {
+		t.Fatal(err)
+	}
+	r = tplProbeEnsure(context.Background(), newTplShape(nil, nil, ""))
+	if r.PreservesHistory != tplYes || r.PrefixStable != tplYes {
+		t.Fatalf("avec la clé : %+v", r)
+	}
+}
+
+// Modèle en chargement : les 503 sont relancés, sans rien conclure entre-temps.
+func TestSondeGabarit503Relance(t *testing.T) {
+	testHome(t)
+	freshTplProbe(t)
+	f := &fakeTpl{mode: "qwen3", applyStatus: []int{503, 503}, applyBody: `{"error":{"code":503,"message":"Loading model"}}`}
+	f.start(t)
+	r := tplProbeEnsure(context.Background(), newTplShape(nil, nil, ""))
+	if r.PreservesHistory != tplNo || r.PrefixStable != tplNo {
+		t.Fatalf("après 503 : %+v", r)
+	}
+	// 503 persistant : inconnu, non rangé.
+	freshTplProbe(t)
+	f.mu.Lock()
+	f.applyStatus = []int{503, 503, 503, 503, 503, 503, 503, 503, 503, 503, 503, 503}
+	f.mu.Unlock()
+	r = tplProbeEnsure(context.Background(), newTplShape(nil, nil, ""))
+	if r.PreservesHistory != tplUnknown || r.cacheable {
+		t.Fatalf("503 persistant : %+v", r)
+	}
+}
+
+// Preset externe : aucune requête, nulle part, et rien d'affiché.
+func TestSondeGabaritPresetExterne(t *testing.T) {
+	testHome(t)
+	freshTplProbe(t)
+	f := &fakeTpl{mode: "keep"}
+	srv := httptest.NewServer(http.HandlerFunc(f.handler))
+	t.Cleanup(srv.Close)
+	if err := WriteConfig(parseEnv(externalPresetContent(srv.URL, "gpt-4o-mini", "", "", false))); err != nil {
+		t.Fatal(err)
+	}
+	u, _ := url.Parse(srv.URL)
+	if err := SetConfigKey("PORT", u.Port()); err != nil {
+		t.Fatal(err)
+	}
+	r := tplProbeEnsure(context.Background(), newTplShape(nil, nil, ""))
+	if r.PreservesHistory != tplUnknown || r.PrefixStable != tplUnknown {
+		t.Fatalf("preset externe : %+v", r)
+	}
+	if n := len(f.paths); n != 0 {
+		t.Fatalf("preset externe sondé : %v", f.paths)
+	}
+	if _, ok := tplCapsCurrent(); ok {
+		t.Fatal("verdict affiché pour un preset externe")
+	}
+}
+
+// Bout en bout : une complétion du fil principal déclenche la sonde en tâche
+// de fond, avec les outils et kwargs de CETTE requête, sans rien ajouter à la
+// requête de complétion.
+func TestSondeGabaritDeclencheeParRunChat(t *testing.T) {
+	testHome(t)
+	freshTplProbe(t)
+	freshPerf(t)
+	tplProbeAuto = true
+	t.Cleanup(func() { tplProbeAuto = false })
+	if err := SetConfigKey("REASONING", "off"); err != nil {
+		t.Fatal(err)
+	}
+	f := &fakeTpl{mode: "qwen3"}
+	var mu sync.Mutex
+	var chat map[string]any
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/v1/chat/completions" {
+			mu.Lock()
+			_ = json.NewDecoder(r.Body).Decode(&chat)
+			mu.Unlock()
+			w.Header().Set("Content-Type", "text/event-stream")
+			_, _ = w.Write([]byte(sseChunk("ok") +
+				`data: {"choices":[{"delta":{},"finish_reason":"stop"}],"usage":{"prompt_tokens":50,"completion_tokens":1},"timings":{"prompt_n":50,"cache_n":0}}` + "\n\n" +
+				"data: [DONE]\n\n"))
+			return
+		}
+		f.handler(w, r)
+	}))
+	t.Cleanup(srv.Close)
+	u, _ := url.Parse(srv.URL)
+	if err := SetConfigKey("PORT", u.Port()); err != nil {
+		t.Fatal(err)
+	}
+	tools := probeTools()
+	if _, err := runChatTools(context.Background(), []Message{{Role: "user", Content: "salut"}}, tools, 0.7, Caps{}, func(StreamEvent) bool { return true }); err != nil {
+		t.Fatal(err)
+	}
+	deadline := time.Now().Add(5 * time.Second)
+	var r tplProbeResult
+	for {
+		var ok bool
+		if r, ok = tplCapsCurrent(); ok || time.Now().After(deadline) {
+			break
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+	if r.PrefixStable != tplNo || r.Tools != 1 || r.Kwargs["enable_thinking"] != false {
+		t.Fatalf("sonde après complétion : %+v", r)
+	}
+	f.mu.Lock()
+	for _, a := range f.applies {
+		mu.Lock()
+		same := fmt.Sprint(a["tools"]) == fmt.Sprint(chat["tools"]) && fmt.Sprint(a["chat_template_kwargs"]) == fmt.Sprint(chat["chat_template_kwargs"])
+		mu.Unlock()
+		if !same {
+			f.mu.Unlock()
+			t.Fatalf("forme différente de la complétion :\nsonde %v / %v\nchat  %v / %v", a["tools"], a["chat_template_kwargs"], chat["tools"], chat["chat_template_kwargs"])
+		}
+	}
+	f.mu.Unlock()
+	// La sonde ne laisse aucune trace dans la requête de complétion.
+	mu.Lock()
+	defer mu.Unlock()
+	for k := range chat {
+		if strings.Contains(k, "template") && k != "chat_template_kwargs" || k == "add_generation_prompt" {
+			t.Fatalf("clé %q ajoutée à la complétion", k)
+		}
+	}
+}
+
+// Le verdict est rangé par forme de requête : la dernière forme sondée ne
+// décide pas pour une autre (NUDGE_IN_TOOL), et une forme jamais sondée n'a
+// pas de verdict.
+func TestSondeGabaritVerdictParForme(t *testing.T) {
+	testHome(t)
+	freshTplProbe(t)
+	f := &fakeTpl{mode: "qwen3"}
+	f.start(t)
+	a := newTplShape(probeTools(), nil, "")
+	b := newTplShape(nil, nil, "")
+	if r := tplProbeEnsure(context.Background(), a); r.PrefixStable != tplNo {
+		t.Fatalf("forme A : %+v", r)
+	}
+	f.mu.Lock()
+	f.mode = "keep"
+	f.mu.Unlock()
+	if r := tplProbeEnsure(context.Background(), b); r.PrefixStable != tplYes {
+		t.Fatalf("forme B : %+v", r)
+	}
+	if r, ok := tplCapsCurrent(); !ok || r.PrefixStable != tplYes {
+		t.Errorf("affichage : la dernière sondée, B : %+v", r)
+	}
+	if r, ok := tplCapsFor(a); !ok || r.PrefixStable != tplNo {
+		t.Errorf("forme A écrasée par B : %+v %v", r, ok)
+	}
+	if _, ok := tplCapsFor(newTplShape(probeTools(), map[string]any{"enable_thinking": false}, "")); ok {
+		t.Error("verdict pour une forme jamais sondée")
+	}
+}

internal/loki/chat_web_images.go

@@ -0,0 +1,139 @@
+package loki
+
+// web_images : la recherche d'images DuckDuckGo, pendant de web_search. Sans
+// elle, « montre-moi des photos de X » obligeait le modèle à ouvrir des pages
+// dans le navigateur et à en renvoyer des captures (lent, et des images de
+// pages au lieu de photos).
+//
+// DuckDuckGo sert les images par i.js, qui exige un jeton « vqd » lu dans la
+// page de recherche. Même client HTTP que le moteur intégré, quel que soit le
+// moteur web actif : Crawl4AI n'apporterait rien à un appel JSON.
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strings"
+)
+
+func webImagesTool() Tool {
+	return Tool{Type: "function", Function: ToolFunction{
+		// Schéma minimal : le préambule a un budget (chat_prompt_size_test.go).
+		// limit n'est pas annoncé ; toolWebImages l'accepte encore (6 par défaut).
+		Name:        "web_images",
+		Description: "Find images.",
+		Parameters: map[string]any{
+			"type": "object",
+			"properties": map[string]any{
+				"query": map[string]any{"type": "string"},
+			},
+			"required": []string{"query"},
+		},
+	}}
+}
+
+type imageResult struct {
+	Image  string `json:"image"`
+	Title  string `json:"title"`
+	URL    string `json:"url"`
+	Width  int    `json:"width"`
+	Height int    `json:"height"`
+}
+
+var ddgVqdRe = regexp.MustCompile(`vqd=["']?([0-9-]+)`)
+
+func ddgGet(ctx context.Context, target, referer string) ([]byte, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, target, nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("User-Agent", goFetchUA)
+	req.Header.Set("Accept-Language", "fr-FR,fr;q=0.9,en;q=0.8")
+	if referer != "" {
+		req.Header.Set("Referer", referer)
+		req.Header.Set("Accept", "application/json, text/javascript, */*; q=0.01")
+	}
+	resp, err := goHTTPClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("échec de la requête : %v", err)
+	}
+	defer resp.Body.Close()
+	b, err := io.ReadAll(io.LimitReader(resp.Body, goFetchMaxBytes))
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode >= 400 {
+		return nil, fmt.Errorf("HTTP %d", resp.StatusCode)
+	}
+	return b, nil
+}
+
+func duckduckgoImages(query string, limit int) ([]imageResult, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), goFetchTimeout)
+	defer cancel()
+	page := "https://duckduckgo.com/?q=" + url.QueryEscape(query) + "&iax=images&ia=images"
+	body, err := ddgGet(ctx, page, "")
+	if err != nil {
+		return nil, err
+	}
+	m := ddgVqdRe.FindSubmatch(body)
+	if m == nil {
+		return nil, fmt.Errorf("jeton DuckDuckGo introuvable (défi anti-bot ?)")
+	}
+	api := "https://duckduckgo.com/i.js?l=fr-fr&o=json&f=,,,,,&p=1&q=" + url.QueryEscape(query) + "&vqd=" + string(m[1])
+	body, err = ddgGet(ctx, api, "https://duckduckgo.com/")
+	if err != nil {
+		return nil, err
+	}
+	var r struct {
+		Results []imageResult `json:"results"`
+	}
+	if err := json.Unmarshal(body, &r); err != nil {
+		return nil, fmt.Errorf("réponse illisible : %v", err)
+	}
+	var out []imageResult
+	seen := map[string]bool{}
+	for _, it := range r.Results {
+		if it.Image == "" || seen[it.Image] || !strings.HasPrefix(it.Image, "http") {
+			continue
+		}
+		seen[it.Image] = true
+		out = append(out, it)
+		if len(out) >= limit {
+			break
+		}
+	}
+	return out, nil
+}
+
+func toolWebImages(args map[string]any) string {
+	query, _ := args["query"].(string)
+	limit := 6
+	if v, ok := args["limit"].(float64); ok {
+		limit = int(v)
+	}
+	if limit < 1 {
+		limit = 1
+	}
+	if limit > 20 {
+		limit = 20
+	}
+	results, err := duckduckgoImages(query, limit)
+	if err != nil {
+		return "❌ Recherche d'images échouée : " + err.Error()
+	}
+	if len(results) == 0 {
+		return fmt.Sprintf("Aucune image pour « %s »", query)
+	}
+	var b strings.Builder
+	fmt.Fprintf(&b, "# Images : %s\n%d résultat(s) DuckDuckGo\n\n", query, len(results))
+	for i, r := range results {
+		fmt.Fprintf(&b, "%d. %s (%dx%d)\n   image : %s\n   page : %s\n\n", i+1, r.Title, r.Width, r.Height, r.Image, r.URL)
+	}
+	b.WriteString("To show an image to the user, write ![title](image URL) in your answer.")
+	return b.String()
+}

internal/loki/code_jobs.go

@@ -83,6 +83,12 @@ func toolBashBg(args map[string]any) string {
 	if reason := dangerousCommand(command); reason != "" {
 		return refusedCommandResult(reason)
 	}
+	// Un serveur de dev ou un build lancé pendant une optimisation fausserait
+	// ses mesures (CPU, disque) — et un tour de modèle n'a de toute façon pas pu
+	// démarrer : ceci ne vise qu'un tour lancé juste avant.
+	if err := tuneGuard(); err != nil {
+		return "[erreur] " + err.Error()
+	}
 	ws := agentCwd()
 	logDir := filepath.Join(ws, ".loki", "jobs")
 	if err := os.MkdirAll(logDir, 0o755); err != nil {
@@ -171,6 +177,23 @@ func toolBashTail(args map[string]any) string {
 	return out + "\n" + tailRunes(tail, toolMaxOutput)
 }
 
+// bgJobsRunning : jobs d'arrière-plan encore en vie. L'optimiseur refuse de
+// mesurer à côté d'eux : un build ou un serveur de dev prend le CPU et le
+// disque que mesurent ses essais.
+func bgJobsRunning() int {
+	jobsMu.Lock()
+	defer jobsMu.Unlock()
+	n := 0
+	for _, j := range jobs {
+		j.mu.Lock()
+		if !j.done {
+			n++
+		}
+		j.mu.Unlock()
+	}
+	return n
+}
+
 // stopConvJobs tue les jobs d'une discussion (suppression / vidage de la
 // discussion : ses fichiers partent, ses process aussi).
 func stopConvJobs(convID string) {

internal/loki/code_roles.go

@@ -42,3 +42,17 @@ func wantsPlan(text string) bool {
 	}
 	return false
 }
+
+// withTurnRole fige le rôle d'un tour du mode Code d'après son message : plan
+// demandé → planner, sinon builder. Un rôle déjà choisi par le client est gardé.
+// Partagé par StartTurn et le préchauffage (chat_prewarm.go), qui prévoit le
+// rôle le plus probable du prochain message.
+func withTurnRole(caps Caps, text string) Caps {
+	if caps.Code && caps.Role == "" {
+		caps.Role = "builder"
+		if wantsPlan(text) {
+			caps.Role = "planner"
+		}
+	}
+	return caps
+}

internal/loki/code_verify.go

@@ -156,21 +156,35 @@ func (c *Conversation) runBuilderTurn(ctx context.Context, caps Caps, temperatur
 
 	// Même contexte que le tour de build : projet (description, index mémoire,
 	// trackers) et consignes du dépôt. Sans eux, la reprise changeait le début
-	// du premier message utilisateur — tout le cache de prompt à refaire.
-	final := append(projectSystemMessages(), msgs...)
-	if m, ok := codeInstructionsMessage(caps); ok {
-		final = append([]Message{m}, final...)
-	}
-	if sp := readSysPrompt(); sp != "" {
-		final = append([]Message{{Role: "system", Content: sp}}, final...)
+	// du premier message utilisateur — tout le cache de prompt à refaire. Même
+	// assemblage aussi (turnView) : avec PROJ_SNAPSHOT, le bloc figé de la
+	// discussion, et ses changements en tête de la consigne.
+	sent, tools, snapTurn := c.turnView(caps, epoch, msgs, true)
+	runCtx := ctx
+	if snapTurn != nil {
+		runCtx = withProjSnapTurn(ctx, snapTurn)
 	}
 	var content strings.Builder
 	sawUsage := false
-	sent, tools := prepareTurn(final, caps)
-	extra, _ := runChatTools(ctx, sent, tools, temperature, caps, func(ev StreamEvent) bool {
+	// newBase / echo : comme generate — vue modèle publiée par une compaction
+	// survenue pendant la passe (elle REMPLACE l'historique, tour compris), et
+	// raisonnement de la réponse finale (REASONING_ECHO).
+	var newBase []Message
+	var echo *ReasoningEcho
+	extra, _ := runChatTools(runCtx, sent, tools, temperature, caps, func(ev StreamEvent) bool {
 		if ev.Stats != nil && ev.Stats.PromptTokensTotal > 0 {
 			sawUsage = true
 		}
+		if ev.NewHistory != nil {
+			// Préfixe système injecté retiré, comme dans generate : il n'appartient
+			// pas à l'historique persisté (le rappel des pages lues, si). Ignorer
+			// cet événement laissait la compaction perdue et c.Messages incohérent
+			// (fil complet + tour).
+			newBase = historyFromView(ev.NewHistory, msgs)
+		}
+		if ev.Echo != nil {
+			echo = ev.Echo
+		}
 		if ev.Content != "" {
 			content.WriteString(ev.Content)
 		}
@@ -185,9 +199,15 @@ func (c *Conversation) runBuilderTurn(ctx context.Context, caps Caps, temperatur
 	})
 	c.mu.Lock()
 	if c.epoch == epoch {
+		if newBase != nil {
+			c.Messages = newBase
+		}
+		if s := snapTurn.takeRefreshed(); s != nil {
+			c.ProjSnap = s // même règle que generate
+		}
 		c.Messages = append(c.Messages, extra...)
 		if s := content.String(); strings.TrimSpace(s) != "" {
-			c.Messages = append(c.Messages, Message{Role: "assistant", Content: s})
+			c.Messages = append(c.Messages, withEcho(Message{Role: "assistant", Content: s}, echo))
 		}
 		c.Messages = dropStrayNudges(c.Messages) // même règle que generate
 		if sawUsage {
@@ -202,8 +222,10 @@ func (c *Conversation) runBuilderTurn(ctx context.Context, caps Caps, temperatur
 }
 
 // forwardStream relaie les événements d'un runChat secondaire (vérification,
-// correction) vers le journal d'affichage — même mapping que generate(), sans
-// la gestion de compaction (ces passes n'en déclenchent pas : contexte court).
+// correction) vers le journal d'affichage — même mapping que generate(). Ce
+// qui touche à l'HISTORIQUE (NewHistory, Echo) n'a rien à afficher : c'est
+// l'appelant qui le range (runBuilderTurn), ou l'ignore pour une passe isolée
+// sur sa propre trace (vérificateur).
 //
 // isolated : la passe tourne sur sa propre trace (vérificateur), PAS sur
 // l'historique de la discussion. Ses comptes ne disent rien du contexte de
@@ -212,6 +234,14 @@ func (c *Conversation) runBuilderTurn(ctx context.Context, caps Caps, temperatur
 // chiffre-là. La jauge de l'UI ne doit pas bouger non plus (ctx_isolated).
 func (c *Conversation) forwardStream(ev StreamEvent, epoch int, isolated bool) {
 	switch {
+	case ev.NewHistory != nil, ev.Echo != nil:
+		// Rangés par l'appelant, voir plus haut.
+	case ev.Compacting != nil:
+		// Même bannière que generate. Pas pour une passe isolée : ce n'est pas
+		// la discussion qu'elle compacte.
+		if !isolated {
+			c.appendDelta(epoch, map[string]any{"compacting": *ev.Compacting})
+		}
 	case ev.Err != nil:
 		c.appendDelta(epoch, map[string]any{"error": ev.Err.Error()})
 	case ev.ToolUsed != nil:
@@ -269,7 +299,9 @@ func (c *Conversation) forwardStream(ev StreamEvent, epoch int, isolated bool) {
 	}
 }
 
-// lastUserText retrouve le dernier message utilisateur du fil (la tâche).
+// lastUserText retrouve le dernier message utilisateur du fil (la tâche), sans
+// la mise à jour du projet que Loki a pu poser en tête (PROJ_SNAPSHOT) : le
+// vérificateur la prendrait pour une partie de la demande.
 func (c *Conversation) lastUserText() string {
 	c.mu.Lock()
 	defer c.mu.Unlock()
@@ -278,7 +310,8 @@ func (c *Conversation) lastUserText() string {
 		if c.Messages[i].Role != "user" || isLokiInjected(c.Messages[i]) {
 			continue
 		}
-		if s, ok := c.Messages[i].Content.(string); ok {
+		m, _ := withoutCtxUpdate(c.Messages[i])
+		if s, ok := m.Content.(string); ok {
 			return s
 		}
 	}

internal/loki/computer_cdp.go

@@ -225,6 +225,7 @@ func cdpLaunch() (*cdpSession, error) {
 		args = append([]string{"--headless=new"}, args...)
 	}
 	cmd := exec.Command(bin, args...)
+	prepareBoundChild(cmd) // tué avec Loki, même brutalement (sys_childbind_*.go)
 	if err := cmd.Start(); err != nil {
 		os.RemoveAll(userDir)
 		return nil, err

internal/loki/cu_autoshot.go

@@ -0,0 +1,92 @@
+package loki
+
+// cu_autoshot.go — aperçu EN DIRECT du navigateur piloté (computer use). Après
+// chaque action browser_*, on capture la page pour que l'UTILISATEUR voie ce que
+// fait l'IA. C'est de l'interface seulement :
+//   - jamais envoyé au modèle (zéro token, vision non requise) ;
+//   - jamais écrit sur le disque : un petit anneau en mémoire vive ;
+//   - retiré du journal en fin de tour (compactLogLocked), et l'UI efface la carte
+//     à la fin du tour. Une capture à GARDER passe toujours par
+//     browser_screenshot, qui l'enregistre dans le dossier de travail.
+
+import (
+	"bytes"
+	"encoding/base64"
+	"fmt"
+	"image"
+	"image/jpeg"
+	_ "image/png"
+	"net/http"
+	"os"
+	"strings"
+	"sync"
+	"time"
+)
+
+const cuShotRing = 8 // captures gardées en RAM (l'UI n'affiche que la dernière)
+
+var (
+	cuShotMu   sync.Mutex
+	cuShotData = map[string][]byte{}
+	cuShotIDs  []string
+)
+
+// cuAutoShotTool : outils après lesquels on capture (ceux qui changent la page).
+func cuAutoShotTool(name string) bool {
+	switch name {
+	case "browser_open", "browser_click", "browser_click_xy", "browser_type", "browser_key", "browser_scroll", "browser_find":
+		return true
+	}
+	return false
+}
+
+func cuLog(format string, a ...any) { fmt.Fprintf(os.Stderr, "[cu] "+format+"\n", a...) }
+
+// cuAutoShot capture la page en pleine résolution (JPEG de bonne qualité) et
+// renvoie l'identifiant de la capture en mémoire ("" si impossible : jamais
+// bloquant pour l'outil).
+func cuAutoShot() string {
+	s, err := cdpGet()
+	if err != nil {
+		cuLog("aperçu : navigateur indisponible : %v", err)
+		return ""
+	}
+	raw, err := s.screenshot()
+	if err != nil {
+		cuLog("aperçu : capture impossible : %v", err)
+		return ""
+	}
+	img, _, err := image.Decode(bytes.NewReader(raw))
+	if err != nil {
+		cuLog("aperçu : image illisible (%d octets) : %v", len(raw), err)
+		return ""
+	}
+	var buf bytes.Buffer
+	if err := jpeg.Encode(&buf, img, &jpeg.Options{Quality: 90}); err != nil {
+		return ""
+	}
+	id := fmt.Sprintf("%x", time.Now().UnixNano())
+	cuShotMu.Lock()
+	cuShotData[id] = buf.Bytes()
+	cuShotIDs = append(cuShotIDs, id)
+	for len(cuShotIDs) > cuShotRing {
+		delete(cuShotData, cuShotIDs[0])
+		cuShotIDs = cuShotIDs[1:]
+	}
+	cuShotMu.Unlock()
+	return id
+}
+
+// handleCUShot (GET ?id=) : une capture en base64 (JSON, pour traverser aussi le
+// tunnel chiffré du relais). 404 si elle est déjà sortie de l'anneau.
+func handleCUShot(w http.ResponseWriter, r *http.Request) {
+	id := strings.TrimSpace(r.URL.Query().Get("id"))
+	cuShotMu.Lock()
+	b := cuShotData[id]
+	cuShotMu.Unlock()
+	if b == nil {
+		sendJSON(w, 404, map[string]any{"ok": false, "error": "capture expirée"})
+		return
+	}
+	sendJSON(w, 200, map[string]any{"ok": true, "mime": "image/jpeg", "data": base64.StdEncoding.EncodeToString(b)})
+}

internal/loki/cu_autoshot_log_test.go

@@ -0,0 +1,39 @@
+package loki
+
+import "testing"
+
+// L'aperçu du navigateur (shot) n'est que du direct : la compaction de fin de
+// tour le retire du journal, le reste de l'événement d'outil est gardé.
+func TestCompactLogRetireLAperçuNavigateur(t *testing.T) {
+	log := []LogEvent{
+		{Seq: 1, Delta: map[string]any{"tool_used": map[string]any{"name": "browser_click", "done": false}}},
+		{Seq: 2, Delta: map[string]any{"tool_used": map[string]any{"name": "browser_click", "done": true, "result": "ok", "shot": "abc"}}},
+	}
+	out := compactLog(log)
+	if len(out) != 1 {
+		t.Fatalf("un seul événement d'outil attendu, %d", len(out))
+	}
+	tu := out[0].Delta["tool_used"].(map[string]any)
+	if _, has := tu["shot"]; has {
+		t.Fatal("l'aperçu aurait dû quitter le journal")
+	}
+	if tu["result"] != "ok" || tu["name"] != "browser_click" {
+		t.Fatalf("événement abîmé : %v", tu)
+	}
+	if _, has := log[1].Delta["tool_used"].(map[string]any)["shot"]; !has {
+		t.Fatal("le journal d'origine ne doit pas être modifié en place")
+	}
+}
+
+func TestCUAutoShotTool(t *testing.T) {
+	for _, n := range []string{"browser_open", "browser_click", "browser_type", "browser_scroll"} {
+		if !cuAutoShotTool(n) {
+			t.Errorf("%s devrait déclencher l'aperçu", n)
+		}
+	}
+	for _, n := range []string{"browser_screenshot", "browser_snapshot", "bash", "web_images"} {
+		if cuAutoShotTool(n) {
+			t.Errorf("%s ne devrait pas déclencher l'aperçu", n)
+		}
+	}
+}

internal/loki/engine_cmdline.go

@@ -0,0 +1,87 @@
+package loki
+
+// engine_cmdline.go — ce que l'interface montre du dernier lancement du moteur
+// (repris d'AJEAN, #108 et #43) :
+//
+//	/api/engine/cmdline  la commande exacte lancée par `loki serve` (variables
+//	                     d'environnement posées par Loki comprises), copiable
+//	                     pour la vérifier ou la partager ; clé API masquée
+//	/api/model/layers    le nombre de couches du modèle, lu dans l'en-tête
+//	                     GGUF : la valeur de NGL qui met tout sur le GPU
+
+import (
+	"net/http"
+	"sort"
+	"strings"
+)
+
+// engineCmdlineKey : dernière commande du moteur (bkState), lue par l'UI.
+const engineCmdlineKey = "engine_cmdline"
+
+// engineCmdline met les arguments sous forme copiable dans un terminal :
+// variables d'environnement en tête (KEY=VAL, triées), guillemets autour de ce
+// qui contient un espace, clé API masquée.
+func engineCmdline(env map[string]string, args []string) string {
+	quote := func(a string) string {
+		if a == "" || strings.ContainsAny(a, " \t\"'") {
+			return `"` + strings.ReplaceAll(a, `"`, `\"`) + `"`
+		}
+		return a
+	}
+	var out []string
+	keys := make([]string, 0, len(env))
+	for k := range env {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	for _, k := range keys {
+		out = append(out, k+"="+quote(env[k]))
+	}
+	for i, a := range args {
+		if i > 0 && (args[i-1] == "--api-key" || args[i-1] == "--api-key-file") {
+			a = "<clé masquée>"
+		}
+		out = append(out, quote(a))
+	}
+	return strings.Join(out, " ")
+}
+
+// recordEngineCmdline garde la commande du lancement en cours. Jamais pour un
+// essai de l'optimiseur : il écraserait celle du vrai moteur.
+func recordEngineCmdline(env map[string]string, args []string) {
+	_ = putBytes(bkState, engineCmdlineKey, []byte(engineCmdline(env, args)))
+}
+
+// handleEngineCmdline (GET) : la commande du dernier lancement du moteur local.
+func handleEngineCmdline(w http.ResponseWriter, r *http.Request) {
+	sendJSON(w, 200, map[string]any{"ok": true, "cmdline": string(getBytes(bkState, engineCmdlineKey))})
+}
+
+// handleModelLayers (GET ?model=…, sinon MODEL de la config) : nombre de blocs
+// du modèle. llama.cpp en offloade block_count + 1 (la couche de sortie en
+// plus) : c'est la valeur de -ngl qui met tout le modèle sur le GPU.
+func handleModelLayers(w http.ResponseWriter, r *http.Request) {
+	model := strings.TrimSpace(r.URL.Query().Get("model"))
+	if model == "" {
+		model = strings.TrimSpace(ReadConfig()["MODEL"])
+	}
+	if model == "" {
+		sendJSON(w, 200, map[string]any{"ok": false, "error": "aucun modèle"})
+		return
+	}
+	path, err := resolveServeModelPath(model)
+	if err != nil {
+		sendJSON(w, 200, map[string]any{"ok": false, "error": err.Error()})
+		return
+	}
+	info, err := ggufMeta(path)
+	if err != nil || info.BlockCount <= 0 {
+		msg := "nombre de couches absent de l'en-tête"
+		if err != nil {
+			msg = err.Error()
+		}
+		sendJSON(w, 200, map[string]any{"ok": false, "error": msg})
+		return
+	}
+	sendJSON(w, 200, map[string]any{"ok": true, "layers": info.BlockCount, "ngl_max": info.BlockCount + 1})
+}

internal/loki/llm_bench.go

@@ -159,6 +159,9 @@ type benchOpts struct {
 	Mode    string
 	Prompt  int // jetons de la ligne courte
 	Predict int // jetons générés par la ligne courte
+	// Depth : profondeur imposée — l'optimiseur (backend_tune_run.go) compare
+	// ses essais à la MÊME profondeur ; 0 = choisie selon le contexte.
+	Depth int
 }
 
 func (o benchOpts) full() bool { return o.Mode == benchModeFull }
@@ -228,7 +231,14 @@ func (e benchEngine) do(ctx context.Context, method, path string, payload any) (
 	}
 	// Requête en vol jusqu'à la lecture complète du corps : l'isolation des
 	// travaux annexes n'efface jamais le slot pendant ce temps (llm_slots.go).
-	defer engineRequestStart()()
+	// Une requête du second slot (SIDE_SLOT) ne touche pas au slot de la
+	// discussion.
+	side := false
+	if m, ok := payload.(map[string]any); ok {
+		side = payloadOnSideSlot(m)
+	}
+	end, _ := engineRequestBeginSide(nil, side)
+	defer end()
 	resp, err := e.client.Do(req)
 	if err != nil {
 		return nil, err
@@ -422,6 +432,9 @@ type benchSetup struct {
 	kv        string
 	kvQuant   bool
 	gpus      string
+	// sideSlot : SIDE_SLOT en service, le bench passe par le second slot
+	// (id_slot 1) et laisse la conversation en place (llm_sideslot.go).
+	sideSlot bool
 }
 
 func benchSetupFrom(cfg map[string]string, argEnv map[string]string) benchSetup {
@@ -492,6 +505,9 @@ func (s benchSetup) payload(msgs []Message, maxTokens int, cache bool) map[strin
 	if s.kwargs != nil {
 		p["chat_template_kwargs"] = s.kwargs
 	}
+	if s.sideSlot {
+		setEngineSlot(p, 1)
+	}
 	return p
 }
 
@@ -662,6 +678,9 @@ func benchRun(ctx context.Context, e benchEngine, opts benchOpts, s benchSetup,
 
 	// 3. La profondeur.
 	d, why := benchDepthFor(nCtx, s.cpuPlaced, warm)
+	if opts.Depth > 0 {
+		d, why = opts.Depth, ""
+	}
 	depth := &benchDepth{Ctx: nCtx, Target: d, Reuse: -1}
 	res.Depth = depth
 	if why != "" {
@@ -809,6 +828,15 @@ func runBench(ctx context.Context, opts benchOpts, progress benchProgress) (*ben
 	if externalActive() {
 		return nil, fmt.Errorf("benchmark indisponible : le preset actif est une API externe")
 	}
+	// Le protocole s'appuie sur /tokenize et sur la reprise du cache de
+	// llama-server ; Strata n'a pas le premier et garde sa conversation en cache
+	// malgré cache_prompt:false (la lecture serait comptée deux fois trop vite).
+	if strataActive() {
+		return nil, fmt.Errorf("benchmark indisponible : le preset actif tourne sur Strata (le débit s'affiche sous chaque réponse)")
+	}
+	if err := tuneGuard(); err != nil {
+		return nil, err
+	}
 	port := LLMPort()
 	if !healthCheck() {
 		return nil, fmt.Errorf("serveur injoignable sur :%d", port)
@@ -825,6 +853,7 @@ func runBench(ctx context.Context, opts benchOpts, progress benchProgress) (*ben
 		effortRemember(want, got)
 		logEffortFallback(want, got)
 	}
+	setup.sideSlot = engineSlotFor(resolveChatEndpoint(), false) == 1
 	eng := benchEngine{base: fmt.Sprintf("http://localhost:%d", port), auth: resolveChatEndpoint().auth, client: http.DefaultClient}
 	// Le bench prend le slot de la conversation : une fois fini (erreur et
 	// annulation comprises), on l'efface si c'est sans risque, pour que son état

internal/loki/llm_bench_job.go

@@ -38,18 +38,25 @@ var errBenchBusy = errors.New("un benchmark occupe le moteur — attends sa fin
 // qui a pu démarrer depuis ne doit pas être déclaré libre. L'epoch ne suffit
 // pas : changer de discussion le bumpe SANS arrêter le bench (loadFrom).
 func (c *Conversation) benchLease(cancel context.CancelFunc) (func(), error) {
+	return c.measureLease(cancel, errBenchBusy)
+}
+
+// measureLease : le verrou de génération pour une mesure du moteur — bench,
+// ou optimiseur (backend_tune_job.go) — why étant le refus que reçoivent les
+// autres pendant ce temps.
+func (c *Conversation) measureLease(cancel context.CancelFunc, why error) (func(), error) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 	if c.Generating {
 		return nil, ErrBusy
 	}
-	c.Generating, c.benching, c.cancel = true, true, cancel
+	c.Generating, c.benching, c.cancel, c.leaseWhy = true, true, cancel, why
 	var once sync.Once
 	return func() {
 		once.Do(func() {
 			c.mu.Lock()
 			if c.benching {
-				c.Generating, c.benching, c.cancel = false, false, nil
+				c.Generating, c.benching, c.cancel, c.leaseWhy = false, false, nil, nil
 			}
 			c.mu.Unlock()
 		})
@@ -92,6 +99,9 @@ func benchStart(opts benchOpts) (id string, code int, err error) {
 	if externalActive() {
 		return "", http.StatusBadRequest, errors.New("benchmark indisponible : le preset actif est une API externe")
 	}
+	if err := tuneGuard(); err != nil {
+		return "", http.StatusConflict, err
+	}
 	if !healthCheck() {
 		return "", http.StatusServiceUnavailable, errModelLoading
 	}

internal/loki/llm_client.go

@@ -25,6 +25,29 @@ type Message struct {
 	Content    any        `json:"content,omitempty"`
 	ToolCalls  []ToolCall `json:"tool_calls,omitempty"`
 	ToolCallID string     `json:"tool_call_id,omitempty"`
+	// ReasoningContent : raisonnement que le moteur a séparé pour ce message
+	// assistant, gardé seulement avec REASONING_ECHO=on (llm_reasoning_echo.go).
+	// ReasoningModel : le modèle qui l'a produit. Les deux sont persistés avec la
+	// discussion ; à l'envoi, echoMessages retire toujours l'étiquette, et le
+	// raisonnement quand il ne doit pas partir. Vides : JSON inchangé.
+	ReasoningContent string `json:"reasoning_content,omitempty"`
+	ReasoningModel   string `json:"reasoning_model,omitempty"`
+	// ImgRelay : message `user` qui relaie l'image d'un outil (capture,
+	// see_image) sous KEEP_TURN_IMAGES (chat_keep_images.go) — jamais posé sans
+	// la clé. Persisté pour qu'un fil rouvert le reconnaisse encore comme un
+	// relais et non comme une demande (isLokiInjected) ; retiré à l'envoi
+	// (wireMessages). Faux : JSON inchangé.
+	ImgRelay bool `json:"img_relay,omitempty"`
+	// CtxUpd : Loki a posé un bloc <context_update> en tête de ce message
+	// utilisateur (PROJ_SNAPSHOT, chat_projsnap.go) — jamais sans la clé. Seuls
+	// les messages marqués sont nettoyés : un texte TAPÉ qui commencerait par la
+	// même balise reste tel quel. Persisté, retiré à l'envoi (wireMessages).
+	CtxUpd bool `json:"ctx_upd,omitempty"`
+	// imgTokens : coût mesuré par le moteur de l'image d'un relais GARDÉ dans
+	// l'historique (KEEP_TURN_IMAGES) ; 0 = image non gardée, ou déjà retirée.
+	// En mémoire seulement : un fil rechargé a de toute façon perdu ses images
+	// (stripImageParts).
+	imgTokens int
 }
 
 type ToolCall struct {
@@ -210,6 +233,11 @@ type Caps struct {
 	// ComputerUse = pilotage du navigateur du conteneur (outils browser_*).
 	// Requiert aussi Agent (mêmes actions réelles que bash). Voir computer_use.go.
 	ComputerUse bool
+	// envInCtx : la date et le dossier de travail partent dans le bloc projet
+	// figé (PROJ_SNAPSHOT, chat_envctx.go), pas dans le système. Posé par le seul
+	// assemblage d'un tour de discussion avec la clé ; jamais pour une tâche, un
+	// sous-agent ou la vérification, qui gardent le système d'avant.
+	envInCtx bool
 }
 
 // globalCaps reads the machine-wide config — the default when a request doesn't
@@ -361,9 +389,9 @@ func normalizeSystemMessages(msgs []Message) []Message {
 
 // isProjectSystem : message système propre au projet actif (description, index
 // mémoire, trackers) ou à la conversation (rappel des pages mémoire lues, posé
-// au compactage), à sortir du bloc système commun (voir
-// normalizeSystemMessages) : ce bloc doit rester identique partout pour rester
-// en cache.
+// au compactage ; date et dossier de travail avec PROJ_SNAPSHOT), à sortir
+// du bloc système commun (voir normalizeSystemMessages) : ce bloc doit rester
+// identique partout pour rester en cache.
 func isProjectSystem(m Message) bool {
 	s, ok := m.Content.(string)
 	if !ok || m.Role != "system" {
@@ -373,7 +401,8 @@ func isProjectSystem(m Message) bool {
 		strings.HasPrefix(s, memIndexPrefix) ||
 		strings.HasPrefix(s, trackerIndexPrefix) ||
 		strings.HasPrefix(s, memReminderPrefix) ||
-		strings.HasPrefix(s, codeInstructionsPrefix)
+		strings.HasPrefix(s, codeInstructionsPrefix) ||
+		strings.HasPrefix(s, envContextPrefix)
 }
 
 // prependToFirstUser place ctx en tête du premier message user de msgs (modifié
@@ -465,7 +494,7 @@ func EnabledTools(caps Caps) []Tool {
 	// caps.Internet intègre déjà la joignabilité (globalCaps / override web_server.go),
 	// donc prompt et outils restent cohérents — pas de web_search halluciné.
 	if caps.Agent && caps.Internet {
-		tools = append(tools, webSearchTool(), webOpenTool(), webReadTool(), webGrepTool())
+		tools = append(tools, webSearchTool(), webImagesTool(), webOpenTool(), webReadTool(), webGrepTool())
 	}
 	// Capture d'écran : seulement si Playwright est réellement présent dans
 	// l'image (annoncer un outil absent enverrait le modèle en boucle de
@@ -506,8 +535,8 @@ func EnabledTools(caps Caps) []Tool {
 }
 
 // StreamEvent is what a ChatCallback receives for each piece of streamed output.
-// Exactly one of {Content, Reasoning, ToolUsed, Stats, Err, DropReasoning} is set
-// per call.
+// Exactly one of {Content, Reasoning, ToolUsed, Stats, Err, DropReasoning, Echo}
+// is set per call.
 type StreamEvent struct {
 	Content   string
 	Reasoning string
@@ -532,6 +561,11 @@ type StreamEvent struct {
 	// REMPLACER son historique par elle (préfixe système injecté retiré), pas l'y
 	// ajouter.
 	NewHistory []Message
+	// Echo : raisonnement séparé de la complétion qui porte la réponse finale,
+	// à ranger avec elle (withEcho). Émis une fois, en fin de tour, et seulement
+	// avec REASONING_ECHO=on sur le moteur local : les autres tours n'en voient
+	// jamais. Les messages tool_calls du tour portent déjà le leur (extra).
+	Echo *ReasoningEcho
 }
 
 // AskEvent : l'outil ask — question structurée posée à l'utilisateur, rendue
@@ -568,6 +602,10 @@ type ToolUsedEvent struct {
 	// pensait à recopier la ligne markdown rendue par l'outil : un petit modèle
 	// l'oublie, et l'utilisateur ne voyait jamais l'image qu'il avait demandée.
 	Image string
+	// Shot : identifiant de la capture du navigateur prise après une action
+	// browser_* (cu_autoshot.go). Aperçu EN DIRECT seulement : gardé en RAM,
+	// jamais envoyé au modèle, retiré du journal en fin de tour.
+	Shot string
 	// ResultChars : taille RÉELLE du résultat (en runes), même quand Result n'en
 	// porte qu'un APERÇU. Sert au compteur « ~N tok » de la bulle.
 	ResultChars int
@@ -902,12 +940,15 @@ type StatsEvent struct {
 	// `usage.prompt_tokens`. 0 si le backend ne renvoie pas d'usage.
 	PromptTokensTotal int `json:"prompt_tokens_total,omitempty"`
 	// Morceaux de raisonnement reçus SÉPARÉS par le moteur (reasoning_content),
-	// llama-server local seulement. Loki ne renvoie jamais ce raisonnement au
-	// modèle (Message n'a pas de champ pour lui) : ces jetons font partie de
-	// GenTokens mais pas de la requête suivante. Un morceau vaut au plus un
-	// jeton, donc ce compte ne peut que sous-estimer — le sens sans danger : on
-	// compacte au pire comme avant, jamais trop tard. Voir ctxAfter.
+	// llama-server local seulement. Sans REASONING_ECHO, Loki ne renvoie jamais
+	// ce raisonnement au modèle : ces jetons font partie de GenTokens mais pas de
+	// la requête suivante. Un morceau vaut au plus un jeton, donc ce compte ne
+	// peut que sous-estimer — le sens sans danger : on compacte au pire comme
+	// avant, jamais trop tard. Voir ctxAfter.
 	ReasoningTokens int `json:"reasoning_tokens,omitempty"`
+	// echoed : ce raisonnement-là repart dans la requête suivante
+	// (REASONING_ECHO) — ctxAfter ne le retire alors pas. Jamais sérialisé.
+	echoed bool
 	// Conseil ponctuel quand le cache de prompts n'a pas tenu après un travail
 	// annexe (voir noteEnginePrompt). Vide la plupart du temps.
 	CacheHint string `json:"cache_hint,omitempty"`
@@ -932,7 +973,12 @@ type StatsEvent struct {
 // raisonnement, jamais renvoyé. Compter ce raisonnement gonflait le contexte de
 // 1 à 8 k jetons par étape, et la compaction (avec perte) partait trop tôt.
 // Borné par GenTokens : le compte de morceaux ne retire jamais plus que généré.
+// Raisonnement renvoyé (echoed) : il fait partie de la requête suivante, il
+// reste compté.
 func (s StatsEvent) ctxAfter() int {
+	if s.echoed {
+		return s.PromptTokensTotal + s.GenTokens
+	}
 	return s.PromptTokensTotal + s.GenTokens - min(s.GenTokens, s.ReasoningTokens)
 }
 
@@ -1061,7 +1107,7 @@ func isNetTimeout(err error) bool {
 func toolCallLabel(name string, args map[string]any) string {
 	label := ""
 	switch name {
-	case "mem_search", "web_search", "recall_search":
+	case "mem_search", "web_search", "web_images", "recall_search":
 		label, _ = args["query"].(string)
 	case "mem_read", "mem_add", "mem_edit", "edit", "write", "read", "git_diff", "see_image":
 		label, _ = args["file"].(string)
@@ -1097,6 +1143,112 @@ func toolCallLabel(name string, args map[string]any) string {
 	return label
 }
 
+// turnReasoning : ce que la requête dit du raisonnement, tiré de la
+// configuration. Partagé par runChat et le préchauffage (chat_prewarm.go).
+func turnReasoning(cfg map[string]string) (effortWanted, effort string, thinkOff bool, kwargs map[string]any) {
+	// Intensité du raisonnement, passée telle quelle au gabarit du modèle. Vide
+	// = on n'envoie rien. Réglage par preset, donc de fait par modèle.
+	effortWanted = reasoningEffortValue(cfg["REASONING_EFFORT"])
+	// …sauf si le gabarit de CE modèle a déjà refusé ce niveau (llm_effort.go) :
+	// on part alors directement sur la traduction apprise, sans repayer le 500.
+	effort = effortResolve(effortWanted)
+	// Le raisonnement est-il interdit pour ce tour ? « aucune » compte comme une
+	// interdiction, y compris quand le repli ci-dessus a retiré le niveau : c'est
+	// `enable_thinking` qui porte alors la consigne, seul.
+	thinkOff = reasoningExplicitlyOff(cfg["REASONING"]) || effortWanted == "none"
+	// Ce que le gabarit du modèle doit savoir, dans SA langue : `reasoning_effort`
+	// ne parle qu'aux gabarits qui le lisent, `enable_thinking` parle aux modèles
+	// hybrides (Qwen3 & co). Sans ça, « aucune » n'avait aucun effet sur eux : le
+	// modèle réfléchissait pendant que l'interface annonçait le contraire.
+	kwargs = reasoningTemplateKwargs(thinkOff, effort)
+	return effortWanted, effort, thinkOff, kwargs
+}
+
+// turnEchoPolicy : la politique de REASONING_ECHO d'une requête ; off = preset
+// externe ou repli en cours, rien ne repart.
+func turnEchoPolicy(off bool) echoPolicy {
+	if off {
+		return echoPolicy{}
+	}
+	return currentEchoPolicy()
+}
+
+// wireMessages : les messages tels qu'ils partent au moteur — un seul système
+// en tête, la consigne de fin si les outils sont neutralisés, le raisonnement
+// renvoyé selon pol — et le nombre de raisonnements renvoyés.
+func wireMessages(messages []Message, toolChoiceNone bool, pol echoPolicy) ([]Message, int) {
+	sent := normalizeSystemMessages(messages)
+	// Marque de relais d'image (KEEP_TURN_IMAGES) : propre à Loki, jamais au
+	// moteur. Sans la clé, aucune : la tranche repart telle quelle.
+	sent = stripRelayTags(sent)
+	if toolChoiceNone {
+		sent = withTrailingHint(sent, toolsOffHint)
+	}
+	return echoMessages(sent, pol)
+}
+
+// chatPayloadOpts : ce qui, en plus des messages, façonne une requête de chat.
+type chatPayloadOpts struct {
+	tools          []Tool
+	disableTools   bool
+	toolChoiceNone bool
+	effort         string
+	kwargs         map[string]any
+	// noSampling : sans l'échantillonnage du preset. Pour le résumé en
+	// continuation (COMPACT_CONTINUATION, chat_compact_cont.go), qui garde celui
+	// du résumeur d'aujourd'hui — température 0.2 seule : une pénalité de
+	// répétition jouerait contre la reprise fidèle des noms, chemins et chiffres.
+	// L'échantillonnage ne touche pas au prompt : le cache n'y perd rien.
+	noSampling bool
+}
+
+// buildChatPayload : le corps d'une requête de complétion de chat, à partir des
+// messages déjà passés par wireMessages. UN seul endroit le construit : le
+// préchauffage (chat_prewarm.go) envoie ce même corps, aux seuls champs de
+// réponse près (stream, max_tokens), et ne peut donc pas en dériver.
+func buildChatPayload(ep chatEndpoint, sent []Message, temperature float64, o chatPayloadOpts) map[string]any {
+	payload := map[string]any{
+		"model": ep.Model,
+		// Les images de l'historique y sont rangées par référence
+		// (chat_images.go) : on remet leurs octets juste avant l'envoi.
+		"messages":    expandImageRefs(sent),
+		"stream":      true,
+		"temperature": temperature,
+		// include_usage → chunk final avec `usage.prompt_tokens` = taille TOTALE
+		// du prompt (préfixe caché compris), contrairement à timings.prompt_n qui
+		// ne compte que les tokens nouvellement traités. Sert au comptage exact du
+		// contexte (sinon le system prompt déjà en cache n'est pas recompté).
+		"stream_options": map[string]any{"include_usage": true},
+	}
+	// Échantillonnage du preset (top_p/top_k/min_p/pénalités, et TEMP qui
+	// l'emporte sur la température ci-dessus). Posé AVANT le raisonnement : les
+	// deux blocs écrivent des clés disjointes, mais l'ordre rend explicite que
+	// c'est bien loki qui a le dernier mot sur `chat_template_kwargs`.
+	if !o.noSampling {
+		applySampling(payload)
+	}
+	if o.effort != "" {
+		payload["reasoning_effort"] = o.effort
+	}
+	// chat_template_kwargs est propre à llama.cpp (--jinja) : une API
+	// distante stricte (OpenAI) refuse un argument inconnu (400).
+	if o.kwargs != nil && !ep.External {
+		payload["chat_template_kwargs"] = o.kwargs
+	}
+	if len(o.tools) > 0 && !o.disableTools {
+		payload["tools"] = o.tools
+		// The model sometimes emits parallel tool calls, which this llama.cpp
+		// build serialises as two concatenated JSON objects in one arguments
+		// string ("{...}{...}") and then fails to parse (HTTP 500). Forcing a
+		// single tool call per turn avoids that.
+		payload["parallel_tool_calls"] = false
+		if o.toolChoiceNone {
+			payload["tool_choice"] = "none"
+		}
+	}
+	return payload
+}
+
 // injectQueued (optionnel, variadique pour ne pas toucher aux appels hors chat)
 // est consulté à CHAQUE frontière d'étape de la boucle d'outils : il renvoie les
 // messages utilisateur mis en file PENDANT la génération, pour que le modèle les
@@ -1109,7 +1261,41 @@ func runChat(ctx context.Context, messages []Message, temperature float64, caps
 // runChatTools est runChat avec les outils déjà calculés par prepareTurn : ceux
 // que décrit le préambule, à l'octet près.
 func runChatTools(ctx context.Context, messages []Message, tools []Tool, temperature float64, caps Caps, cb ChatCallback, injectQueued ...func() []Message) ([]Message, error) {
+	// KEEP_TURN_IMAGES (chat_keep_images.go) : nil sans la clé, et tout se
+	// passe alors comme avant. En fin de tour, une image gardée à l'essai mais
+	// jamais mesurée redevient éphémère, quelle que soit la sortie de la boucle.
+	kt := newKeepImages(ReadConfig(), perfTagOf(ctx))
+	extra, err := runChatLoop(ctx, kt, messages, tools, temperature, caps, cb, injectQueued...)
+	return kt.finish(extra), err
+}
+
+// runChatLoop : la boucle de runChatTools.
+func runChatLoop(ctx context.Context, kt *keepImages, messages []Message, tools []Tool, temperature float64, caps Caps, cb ChatCallback, injectQueued ...func() []Message) ([]Message, error) {
 	var extra []Message
+	// Bloc projet figé de la discussion (PROJ_SNAPSHOT, chat_projsnap.go) : nil
+	// hors tour de discussion avec la clé. Masqué pour la suite du contexte —
+	// un sous-agent lancé par un outil a son propre fil, pas ce bloc.
+	snapTurn := projSnapTurnFrom(ctx)
+	if snapTurn != nil {
+		ctx = withProjSnapTurn(ctx, nil)
+	}
+	// newHistory publie l'historique réécrit en cours de tour (compaction,
+	// réduction). Le début du prompt change de toute façon : avec la clé, le
+	// bloc figé y est remplacé par le vivant et les mises à jour retirées.
+	// publishHistory : la même publication, sans rafraîchir le bloc projet —
+	// pour un retrait d'images gardées (KEEP_TURN_IMAGES), qui ne touche pas au
+	// début du prompt. KEEP_TURN_IMAGES : une image non gardée n'entre pas dans
+	// l'historique par ce chemin non plus. Sans la clé, publication telle quelle.
+	publishHistory := func() {
+		kt.rewritten()
+		cb(StreamEvent{NewHistory: kt.publishable(append([]Message(nil), messages...))})
+	}
+	newHistory := func() {
+		if snapTurn != nil {
+			messages = snapTurn.refresh(messages)
+		}
+		publishHistory()
+	}
 	// Some backends (vanilla llama.cpp builds) don't populate `reasoning_content`
 	// in streaming mode: the model's <think> block (opened by the chat template)
 	// arrives inline in `content`, terminated by a literal </think>. When
@@ -1121,21 +1307,7 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 	// (perf_log.go) : rien de tout ça ne part dans la requête.
 	ptag, perfIter := perfTagOf(ctx), 0
 	reasoningOn := reasoningActive(chatCfg["REASONING"])
-	// Intensité du raisonnement, passée telle quelle au gabarit du modèle. Vide
-	// = on n'envoie rien. Réglage par preset, donc de fait par modèle.
-	effortWanted := reasoningEffortValue(chatCfg["REASONING_EFFORT"])
-	// …sauf si le gabarit de CE modèle a déjà refusé ce niveau (llm_effort.go) :
-	// on part alors directement sur la traduction apprise, sans repayer le 500.
-	reasoningEffort := effortResolve(effortWanted)
-	// Le raisonnement est-il interdit pour ce tour ? « aucune » compte comme une
-	// interdiction, y compris quand le repli ci-dessus a retiré le niveau : c'est
-	// `enable_thinking` qui porte alors la consigne, seul.
-	thinkOff := reasoningExplicitlyOff(chatCfg["REASONING"]) || effortWanted == "none"
-	// Ce que le gabarit du modèle doit savoir, dans SA langue : `reasoning_effort`
-	// ne parle qu'aux gabarits qui le lisent, `enable_thinking` parle aux modèles
-	// hybrides (Qwen3 & co). Sans ça, « aucune » n'avait aucun effet sur eux : le
-	// modèle réfléchissait pendant que l'interface annonçait le contraire.
-	reasoningKwargs := reasoningTemplateKwargs(thinkOff, reasoningEffort)
+	effortWanted, reasoningEffort, thinkOff, reasoningKwargs := turnReasoning(chatCfg)
 	// When llama.cpp fails to parse a model-generated tool call (HTTP 500), we
 	// retry the same turn once with tools removed so the model answers in plain
 	// text from the tool results already gathered, instead of dying mid-chat.
@@ -1155,6 +1327,8 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 	compactedRetry := false
 	// Réductions forcées (shrinkToFit) quand le compactage n'a pas suffi.
 	shrinkRetries := 0
+	// Rejeux à l'identique après un cache KV plein en plein calcul (SIDE_SLOT).
+	poolRetries := 0
 	// Repli d'intensité de raisonnement (llm_effort.go) : une seule tentative par
 	// tour, comme les autres filets.
 	effortRetried := false
@@ -1199,6 +1373,12 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 	// entier.
 	const maxStreamRetries = 5
 	streamRetries := 0
+	// REASONING_ECHO (llm_reasoning_echo.go). echoOffTurn : plus aucun
+	// raisonnement ne part de ce tour (prompt trop long, ou gabarit qui l'a
+	// refusé) — retour exact à la requête d'avant la clé. echoTplRetry : relance
+	// en cours après une erreur de gabarit ; si elle passe, c'était bien le
+	// raisonnement, et le refus est retenu pour ce modèle.
+	echoOffTurn, echoTplRetry := false, false
 	// Destination des complétions : llama-server local, ou une API OpenAI-compatible
 	// externe si le preset actif en est un (backend_external.go). Résolu UNE FOIS
 	// par tour — une bascule de preset en plein tour est rare, et se rejoue de
@@ -1238,7 +1418,18 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 		if msg := budgetNudge(toolRuns, budget, budgetNudges); msg != "" {
 			budgetNudges++
 			logBudget(toolRuns, budget, budgetNudges)
-			messages, extra = appendNudge(messages, extra, msg)
+			// NUDGE_IN_TOOL (opt-in, gabarits dont le rendu bouge quand un message
+			// user s'ajoute) : au bout du dernier résultat d'outil. Sinon, ou si
+			// la forme ne s'y prête pas, un message à part comme toujours.
+			// La sonde ne connaît que la forme normale (outils annoncés, ni coupés
+			// ni neutralisés) : une relance d'une autre forme se replie.
+			placed := false
+			if !disableTools && !toolChoiceNone && nudgeInToolOn(chatCfg, ep, tools, reasoningKwargs, reasoningEffort) {
+				messages, extra, placed = nudgeIntoTool(messages, extra, msg)
+			}
+			if !placed {
+				messages, extra = appendNudge(messages, extra, msg)
+			}
 		}
 		// Appels d'outils exécutables pour cette complétion : outils annoncés,
 		// et ni coupés ni neutralisés par tool_choice « none ».
@@ -1247,52 +1438,26 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 		// stricts (Qwen3.x) refusent un système ailleurs qu'en position 0.
 		// Gardé à part : la télémétrie compare ces messages-là d'une requête à
 		// l'autre (perfPrefix).
-		sent := normalizeSystemMessages(messages)
-		if toolChoiceNone {
-			sent = withTrailingHint(sent, toolsOffHint)
-		}
-		payload := map[string]any{
-			"model": ep.Model,
-			// Les images de l'historique y sont rangées par référence
-			// (chat_images.go) : on remet leurs octets juste avant l'envoi.
-			"messages":    expandImageRefs(sent),
-			"stream":      true,
-			"temperature": temperature,
-			// include_usage → chunk final avec `usage.prompt_tokens` = taille TOTALE
-			// du prompt (préfixe caché compris), contrairement à timings.prompt_n qui
-			// ne compte que les tokens nouvellement traités. Sert au comptage exact du
-			// contexte (sinon le system prompt déjà en cache n'est pas recompté).
-			"stream_options": map[string]any{"include_usage": true},
-		}
-		// Échantillonnage du preset (top_p/top_k/min_p/pénalités, et TEMP qui
-		// l'emporte sur la température ci-dessus). Posé AVANT le raisonnement : les
-		// deux blocs écrivent des clés disjointes, mais l'ordre rend explicite que
-		// c'est bien loki qui a le dernier mot sur `chat_template_kwargs`.
-		applySampling(payload)
-		if reasoningEffort != "" {
-			payload["reasoning_effort"] = reasoningEffort
-		}
-		// chat_template_kwargs est propre à llama.cpp (--jinja) : une API
-		// distante stricte (OpenAI) refuse un argument inconnu (400).
-		if reasoningKwargs != nil && !ep.External {
-			payload["chat_template_kwargs"] = reasoningKwargs
-		}
-		if len(tools) > 0 && !disableTools {
-			payload["tools"] = tools
-			// The model sometimes emits parallel tool calls, which this llama.cpp
-			// build serialises as two concatenated JSON objects in one arguments
-			// string ("{...}{...}") and then fails to parse (HTTP 500). Forcing a
-			// single tool call per turn avoids that.
-			payload["parallel_tool_calls"] = false
-			if toolChoiceNone {
-				payload["tool_choice"] = "none"
-			}
-		}
+		// Raisonnement renvoyé : décidé au point de sortie unique, pour chaque
+		// requête. Clé absente (ou preset externe, ou repli en cours) :
+		// echoMessages rend la tranche telle quelle, requête inchangée.
+		// Assemblage partagé avec le préchauffage (chat_prewarm.go) : les deux ne
+		// peuvent pas diverger.
+		pol := turnEchoPolicy(ep.External || echoOffTurn)
+		sent, echoSent := wireMessages(messages, toolChoiceNone, pol)
+		payload := buildChatPayload(ep, sent, temperature, chatPayloadOpts{
+			tools: tools, disableTools: disableTools, toolChoiceNone: toolChoiceNone,
+			effort: reasoningEffort, kwargs: reasoningKwargs,
+		})
+		// SIDE_SLOT (llm_sideslot.go) : le fil de la discussion sur le slot 0,
+		// le reste sur le 1. Sans second slot en service, aucun id_slot.
+		setEngineSlot(payload, engineSlotFor(ep, slotIsMain(ptag.kind)))
 		body, _ := json.Marshal(payload)
 		req, err := http.NewRequestWithContext(ctx, "POST", ep.URL, bytes.NewReader(body))
 		if err != nil {
 			return extra, err
 		}
+		kt.sending(len(messages)) // KEEP_TURN_IMAGES : rien sans la clé
 		req.Header.Set("Content-Type", "application/json")
 		// ⚠️ Surtout pas authHeader : celui-ci pose la clé du serveur LOCAL, et
 		// l'envoyer à api.openai.com serait fuiter un secret chez un tiers en même
@@ -1302,9 +1467,18 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 		// Requête en vol vers le moteur local, jusqu'à la lecture complète du corps :
 		// l'isolation des travaux annexes n'efface jamais le slot pendant ce temps
 		// (llm_slots.go). Rien à compter pour une API externe.
+		// Un préchauffage en vol (PREWARM, chat_prewarm.go) est annulé ici, sauf
+		// s'il prépare exactement le début de CETTE requête d'un tour de chat.
 		endReq := func() {}
+		var reqSeq uint64
+		// SLOT_PERSIST (llm_slotpersist.go) : l'état gardé à la dernière bascule
+		// de preset est rechargé avant la première requête de la discussion,
+		// si tout concorde. Sans la clé, rien.
+		if !ep.External && ptag.kind == perfMain {
+			slotPersistRestore(ep, ptag.conv)
+		}
 		if !ep.External {
-			endReq = engineRequestStart()
+			endReq, reqSeq = engineRequestBeginSide(prewarmKeeper(ptag.kind, sent, payload), payloadOnSideSlot(payload))
 		}
 		resp, err := http.DefaultClient.Do(req)
 		if err != nil {
@@ -1336,6 +1510,9 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 			if msg == "" {
 				msg = resp.Status
 			}
+			// La relance sans raisonnement est refusée à son tour : il n'y était
+			// pour rien, aucun refus à retenir pour ce modèle.
+			echoTplRetry = false
 			// Refus du niveau de raisonnement par le gabarit du modèle (Qwen3.8 ne
 			// connaît pas « high », gpt-oss ne connaît pas « xhigh »…). C'est un
 			// refus DÉFINITIF, pas une question de taille de prompt : à traiter
@@ -1352,12 +1529,66 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 					continue
 				}
 			}
+			// SIDE_SLOT : un cache KV à court de place en plein calcul n'est pas un
+			// prompt trop long (llm_sideslot.go). Rejouée telle quelle, sans
+			// compaction ni réduction — deux fois au plus, le temps que l'autre
+			// slot finisse, puis l'erreur telle quelle : la conversation tenait
+			// dans sa fenêtre, rien ne justifie d'en perdre un morceau. Sans
+			// second slot en service, ce filet ne joue pas.
+			if !ep.External && sideSlotPoolError(msg) && sideSlotLive(ep) {
+				if poolRetries < 2 {
+					poolRetries++
+					logCtx("cache KV plein pendant le calcul (deux slots) : requête rejouée telle quelle, sans compaction")
+					if werr := llmNetBackoff(ctx, poolRetries-1); werr == nil {
+						continue
+					}
+				}
+				err := fmt.Errorf("llama-server a renvoyé %d : %s", resp.StatusCode, msg)
+				cb(StreamEvent{Err: err})
+				return extra, err
+			}
+			// Gabarit qui refuse le raisonnement renvoyé (gpt-oss : « Cannot pass
+			// both content and thinking », message assistant jugé invalide…) :
+			// rejoué UNE fois sans lui, AVANT la coupure des outils et la consigne
+			// système, qui casseraient le tour et tout le cache de prompt.
+			if echoSent > 0 && echoTemplateError(resp.StatusCode, msg) {
+				echoOffTurn, echoTplRetry = true, true
+				logCtx("erreur de gabarit avec le raisonnement renvoyé (%d) : relance sans lui", resp.StatusCode)
+				continue
+			}
+			// Prompt trop long alors que du raisonnement est parti : on retente
+			// d'abord sans lui — exactement la requête d'avant REASONING_ECHO —,
+			// avant toute compaction ou réduction, qui perdent de l'information.
+			if echoSent > 0 && contextOverflow(msg, messages) {
+				echoOffTurn = true
+				logCtx("prompt trop long avec le raisonnement renvoyé : relance sans lui avant toute compaction")
+				continue
+			}
 			// Le prompt a peut-être dépassé la fenêtre de contexte : on tente une
 			// compaction en vol et on rejoue le tour (une seule fois) avant tout le
 			// reste. C'est le filet de secours à la Hermes.
 			// ⚠️ Seulement si l'erreur est VRAIMENT un débordement de contexte : avant,
 			// n'importe quel refus (appel d'outil mal formé, modèle en chargement,
 			// erreur de template…) résumait ~75 % de la conversation, même courte.
+			// Raisonnement déjà retiré de ce tour (repli ci-dessus) : la réduction
+			// travaille sur ce qui part vraiment. Sinon elle compterait — puis
+			// « retirerait » — du raisonnement qui ne partait plus, et gâcherait
+			// une relance sur une requête identique.
+			if echoOffTurn {
+				messages = stripReasoning(messages)
+			}
+			// KEEP_TURN_IMAGES : les images gardées partent d'abord, et la requête
+			// est rejouée sans elles ; le résumé (avec perte) ne vient qu'ensuite,
+			// s'il le faut encore. Sans la clé, aucune image gardée.
+			if contextOverflow(msg, messages) && hasKeptImages(messages) {
+				if s, freed := dropKeptImages(messages); freed > 0 {
+					logKeptImagesDropped("réactif", freed)
+					messages = s
+					extra = nil
+					publishHistory()
+					continue
+				}
+			}
 			if compactEnabled() && !compactedRetry && contextOverflow(msg, messages) {
 				if c, changed := compactMessages(ctx, messages, caps); changed {
 					compactedRetry = true
@@ -1370,7 +1601,7 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 					// secours ne survit pas à la fin du tour et le prompt re-déborde au
 					// message suivant.
 					extra = nil
-					cb(StreamEvent{NewHistory: append([]Message(nil), messages...)})
+					newHistory()
 					continue
 				}
 			}
@@ -1383,7 +1614,7 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 					logCompact("réduction", overflowTokens(msg), messages, c, changed)
 					messages = c
 					extra = nil
-					cb(StreamEvent{NewHistory: append([]Message(nil), messages...)})
+					newHistory()
 					continue
 				}
 			}
@@ -1439,8 +1670,21 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 		// Une réponse est arrivée : le budget de reprise réseau repart à neuf pour
 		// la suite de la boucle d'outils.
 		netRetries = 0
+		// La relance sans raisonnement passe : c'était bien lui que le gabarit
+		// refusait. Retenu pour ce modèle, plus de 500 à repayer à chaque tour.
+		if echoTplRetry {
+			echoTplRetry = false
+			echoRefuse(reasoningEchoModel(ReadConfig()))
+		}
 		if !ep.External {
 			engineServed() // le slot porte désormais cette requête (llm_slots.go)
+			// Étape d'un tour de discussion : une compaction en continuation
+			// pourra la prolonger (chat_compact_cont.go). Sans la clé, rien.
+			// SLOT_PERSIST s'en sert aussi : seul un slot qui porte un tour de
+			// discussion est gardé à la bascule de preset.
+			if ptag.kind == perfMain && (compactContinuationOn(chatCfg) || slotPersistOn(chatCfg)) {
+				engineMarkMain(reqSeq, ptag.conv)
+			}
 		}
 		toolCalls := map[int]*ToolCall{}
 		// argBufs : arguments de chaque appel, accumulés sans recopie. `+=` sur la
@@ -1492,6 +1736,10 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 		}
 		// Per-completion reasoning-split state (see reasoningOn comment above).
 		sawReasoningField := false
+		// Raisonnement séparé PAR LE SERVEUR, gardé pour être renvoyé
+		// (REASONING_ECHO). Jamais celui découpé chez nous sur « </think> » : il
+		// reste dans le contenu, où le gabarit le redécoupe lui-même.
+		var echoBuf strings.Builder
 		thinkOpen := reasoningOn
 		var thinkTail strings.Builder
 		// Scanner à gros tampon : un chunk peut porter un gros JSON d'arguments
@@ -1632,7 +1880,7 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 				if cur := toolCalls[0]; cur != nil {
 					key := "command"
 					switch cur.Function.Name {
-					case "mem_search", "web_search", "recall_search":
+					case "mem_search", "web_search", "web_images", "recall_search":
 						key = "query"
 					case "mem_read", "mem_add", "mem_edit", "edit", "write", "read", "git_diff":
 						key = "file"
@@ -1719,6 +1967,9 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 				if !ep.External {
 					stats.ReasoningTokens++
 				}
+				if pol.on {
+					echoBuf.WriteString(ch.Delta.ReasoningContent)
+				}
 				if !scb(StreamEvent{Reasoning: ch.Delta.ReasoningContent}) {
 					aborted = true
 					break
@@ -1824,6 +2075,17 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 		scanErr := sc.Err()
 		resp.Body.Close()
 		endReq()
+		// Raisonnement de cette complétion à renvoyer, s'il y a lieu. Il repart
+		// dans la requête suivante quand elle continue ce tour (appel d'outil),
+		// ou au tour suivant si le gabarit garde le passé : ctxAfter le compte —
+		// posé avant toute émission de stats de cette complétion.
+		echoText := ""
+		if pol.on && sawReasoningField {
+			echoText = echoBuf.String()
+		}
+		if echoText != "" && (len(toolCalls) > 0 || pol.keepsPast) {
+			stats.echoed = true
+		}
 		// Premier jeton, de quelque nature qu'il soit (raisonnement, texte ou
 		// appel d'outil). tReq est repris à chaque tentative.
 		if !tFirst.IsZero() {
@@ -1869,6 +2131,15 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 				s.LostAlert = perfAlert(rec, perfLostAlertAt(chatCfg))
 			}
 			cb(StreamEvent{Stats: &s})
+			// Sonde de gabarit (chat_tplprobe.go), en tâche de fond et après coup :
+			// la complétion est déjà lue, la sonde ne retarde aucun jeton. Fil
+			// principal seulement, sur une requête de forme normale (pas une
+			// relance outils coupés ou neutralisés), pour reproduire exactement
+			// les outils et chat_template_kwargs d'un vrai tour. Rien n'en revient
+			// dans la requête suivante.
+			if !ep.External && ptag.kind == perfMain && !disableTools && !toolChoiceNone {
+				tplProbeKick(tools, reasoningKwargs, reasoningEffort)
+			}
 			if !ep.External {
 				peakGen = max(peakGen, stats.GenTokens)
 				if lastEst > 0 && stats.PromptTokensTotal > 0 {
@@ -1877,6 +2148,9 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 			}
 			lastEst = 0
 		}
+		// KEEP_TURN_IMAGES : coût des images de l'étape précédente, mesuré sur
+		// cette complétion ; gardées ou rendues éphémères. Rien sans la clé.
+		extra = kt.observe(complete, stats, messages, extra)
 		if finishReason == "length" {
 			logCtx("finish=length prompt=%d généré=%d raisonnement=%d fenêtre=%d", stats.PromptTokensTotal, stats.GenTokens, stats.ReasoningTokens, ctxWindow())
 		}
@@ -1962,6 +2236,9 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 			if s := assistantContent.String(); s != "" {
 				assistant.Content = s
 			}
+			if echoText != "" {
+				assistant.ReasoningContent, assistant.ReasoningModel = echoText, pol.model
+			}
 			result := preflight.msg + " (écriture interrompue avant la fin : rien n'a été modifié)"
 			cb(StreamEvent{ToolUsed: &ToolUsedEvent{Name: preflight.name, Label: preflight.file, Done: true, Result: result}})
 			toolMsg := Message{Role: "tool", ToolCallID: id, Content: result}
@@ -2016,6 +2293,9 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 			if s := assistantContent.String(); s != "" {
 				assistant.Content = s
 			}
+			if echoText != "" {
+				assistant.ReasoningContent, assistant.ReasoningModel = echoText, pol.model
+			}
 			messages = append(messages, assistant)
 			extra = append(extra, assistant)
 			// Début des résultats de CETTE étape, que le moteur n'a pas encore
@@ -2218,6 +2498,8 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 					}
 				case "web_search":
 					result = capWebOutput(toolWebSearch(args))
+				case "web_images":
+					result = capWebOutput(toolWebImages(args))
 				case "web_open":
 					result = capWebOutput(toolWebOpen(args))
 				case "web_read":
@@ -2259,8 +2541,14 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 						result = "[erreur] outil inconnu: " + tc.Function.Name
 					}
 				}
+				// Aperçu en direct du navigateur piloté (repris d'AJEAN) : une
+				// capture après chaque action qui change la page, pour l'UI seule.
+				liveShot := ""
 				if !strings.HasPrefix(result, "[erreur]") {
 					doneCalls[callKey] = result
+					if cuAutoShotTool(tc.Function.Name) {
+						liveShot = cuAutoShot()
+					}
 				}
 				// Capture d'écran : l'image part avec l'événement pour être
 				// affichée dans la bulle, quoi que le modèle en fasse ensuite.
@@ -2268,7 +2556,7 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 				if tc.Function.Name == "web_screenshot" {
 					shot = capturedRelPath(result)
 				}
-				cb(StreamEvent{ToolUsed: fillToolResult(&ToolUsedEvent{Name: tc.Function.Name, Label: label, Done: true, Diff: diff, Added: diffAdd, Removed: diffDel, Image: shot}, result)})
+				cb(StreamEvent{ToolUsed: fillToolResult(&ToolUsedEvent{Name: tc.Function.Name, Label: label, Done: true, Diff: diff, Added: diffAdd, Removed: diffDel, Image: shot, Shot: liveShot}, result)})
 				// Plafond pour le MODÈLE seulement : l'UI vient de recevoir le
 				// résultat complet (aperçu + « voir plus »).
 				toolMsg := Message{Role: "tool", ToolCallID: tc.ID, Content: capToolResult(result)}
@@ -2287,10 +2575,14 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 				// contexte (vu en production : requêtes de 55 000 tokens pour une
 				// fenêtre de 32 768, plus aucun tour ne passait). Le modèle regarde
 				// l'image MAINTENANT et sa description textuelle, elle, reste.
+				//
+				// KEEP_TURN_IMAGES (opt-in, chat_keep_images.go) : gardée dans
+				// l'historique, par référence, sous un budget mesuré — kt.relay.
+				// Sans la clé, kt est nil et relay fait exactement l'ajout d'avant.
 				if tc.Function.Name == "web_screenshot" {
 					if rel := capturedRelPath(result); rel != "" {
 						if imgMsg, ok := screenshotImageMessage(rel); ok {
-							messages = append(messages, imgMsg)
+							messages, extra = kt.relay(messages, extra, imgMsg, stepStart)
 						}
 					}
 				}
@@ -2301,7 +2593,7 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 				// dépasser la fenêtre pour de bon. Le modèle regarde l'image
 				// maintenant ; ce qu'il en dit, lui, reste.
 				if visionImg != nil {
-					messages = append(messages, seeImageMessage(label, visionImg))
+					messages, extra = kt.relay(messages, extra, seeImageMessage(label, visionImg), stepStart)
 				}
 			}
 			// Compaction EN COURS DE TOUR. Le seuil n'était testé qu'AU DÉBUT du tour :
@@ -2320,10 +2612,33 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 				used = base + estimateTokens(messages[stepStart:])
 				lastEst = used
 			}
-			if compactNeeded(messages, used, peakGen) {
+			// COMPACT_CONTINUATION (chat_compact_cont.go) : tour de discussion
+			// seulement, ni tâche ni sous-agent. Sans la clé, rien ne change.
+			mainConv := ""
+			if ptag.kind == perfMain {
+				mainConv = ptag.conv
+			}
+			// KEEP_TURN_IMAGES : les images gardées partent AVANT tout résumé ;
+			// la compaction ne suit que si elle reste nécessaire. Sans la clé,
+			// aucune image gardée : rien ne change.
+			if hasKeptImages(messages) && compactNeeded(messages, used, peakGen) {
+				if s, freed := dropKeptImages(messages); freed > 0 {
+					logKeptImagesDropped("en-tour", freed)
+					messages = s
+					if used > 0 {
+						used = max(used-freed, 1)
+						lastEst = used
+					}
+					extra = nil
+					publishHistory()
+				}
+			}
+			if compactNeeded(messages, used, peakGen) && !compactRefusedSkip(mainConv, used, messages) {
+				opt := compactOptsMid(chatCfg, ep, mainConv, messages, used, tools, reasoningEffort, reasoningKwargs, pol,
+					disableTools || toolChoiceNone)
 				yes, no := true, false
 				cb(StreamEvent{Compacting: &yes})
-				c, changed := compactMessages(ctx, messages, caps)
+				c, changed := compactMessagesNoted(ctx, messages, caps, opt)
 				cb(StreamEvent{Compacting: &no})
 				logCompact("en-tour", used, messages, c, changed)
 				if changed {
@@ -2333,7 +2648,7 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 					// repart d'un `extra` vide, sinon l'appelant la ré-empilerait avec
 					// les messages du tour et dupliquerait tout.
 					extra = nil
-					cb(StreamEvent{NewHistory: append([]Message(nil), messages...)})
+					newHistory()
 				}
 			}
 			continue
@@ -2346,7 +2661,7 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 		if snippet := textualToolCallSnippet(assistantContent.String()); snippet != "" &&
 			patternRetries < maxPatternRetries && callsOn {
 			patternRetries++
-			bad := Message{Role: "assistant", Content: assistantContent.String()}
+			bad := withEcho(Message{Role: "assistant", Content: assistantContent.String()}, &ReasoningEcho{Text: echoText, Model: pol.model})
 			fix := Message{Role: "user", Content: retryCorrective(snippet)}
 			messages = append(messages, bad, fix)
 			extra = append(extra, bad, fix)
@@ -2368,6 +2683,18 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 			if finishReason == "length" && !ep.External && lengthReplays < 1 &&
 				compactWouldTrigger(messages, stats.PromptTokensTotal+stats.GenTokens) {
 				lengthReplays++
+				// KEEP_TURN_IMAGES : les images gardées d'abord ; le résumé ne suit
+				// que s'il reste nécessaire. Sans la clé, rien à retirer.
+				if s, freed := dropKeptImages(messages); freed > 0 {
+					logKeptImagesDropped("fenêtre-pleine", freed)
+					messages = s
+					extra = nil
+					publishHistory()
+					if !compactWouldTrigger(messages, max(stats.PromptTokensTotal+stats.GenTokens-freed, 1)) {
+						cb(StreamEvent{DropReasoning: true})
+						continue
+					}
+				}
 				yes, no := true, false
 				cb(StreamEvent{Compacting: &yes})
 				c, changed := compactMessages(ctx, messages, caps)
@@ -2377,7 +2704,7 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 					cb(StreamEvent{DropReasoning: true})
 					messages = c
 					extra = nil
-					cb(StreamEvent{NewHistory: append([]Message(nil), messages...)})
+					newHistory()
 					continue
 				}
 			}
@@ -2403,6 +2730,12 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 			}
 			cb(StreamEvent{Content: "_(le modèle n'a pas produit de réponse — finish: " + finishReason + ")_"})
 		}
+		// Raisonnement de la réponse finale : l'appelant le range avec elle.
+		// Jamais sans texte (un message assistant de pur raisonnement serait
+		// refusé par llama.cpp).
+		if echoText != "" && strings.TrimSpace(assistantContent.String()) != "" {
+			cb(StreamEvent{Echo: &ReasoningEcho{Text: echoText, Model: pol.model}})
+		}
 		return extra, nil
 	}
 }

internal/loki/llm_injected.go

@@ -55,6 +55,11 @@ func isLokiInjected(m Message) bool {
 	if m.Role != "user" {
 		return false
 	}
+	// Relais d'image d'un outil gardé dans l'historique (KEEP_TURN_IMAGES) :
+	// une image montrée par loki, pas une demande. Jamais posé sans la clé.
+	if m.ImgRelay {
+		return true
+	}
 	s, ok := m.Content.(string)
 	if !ok {
 		return false
@@ -156,3 +161,56 @@ func withTrailingHint(msgs []Message, hint string) []Message {
 	// Dernier message d'une autre forme (cas théorique) : un message à part.
 	return append(out, Message{Role: "user", Content: lokiNotePrefix + hint})
 }
+
+// nudgeInToolOn : NUDGE_IN_TOOL (opt-in, off par défaut, ZONE GRISE). Sur un
+// gabarit dont le rendu d'un tour d'outil change dès qu'un message `user`
+// s'ajoute (Qwen3.5 : le nouveau message devient la « dernière question », et
+// tous les messages assistant du tour sont rendus autrement), le rappel de
+// budget en message à part fait recalculer toute la boucle d'outils du tour.
+// Posé au bout du dernier résultat d'outil, il ne coûte que lui-même.
+//
+// Le prix : une consigne glissée dans une sortie d'outil, que les modèles
+// entraînés contre l'injection de prompt peuvent suivre moins bien — d'où
+// l'opt-in, à n'activer qu'après avoir comparé l'obéissance aux rappels.
+//
+// Moteur local seulement, et seulement si la sonde de gabarit
+// (chat_tplprobe.go) a conclu « préfixe instable » pour CE modèle et pour la
+// forme de CETTE requête (outils, chat_template_kwargs, reasoning_effort : le
+// rendu en dépend). « inconnu », un autre modèle ou une forme jamais sondée
+// laissent le message à part.
+func nudgeInToolOn(cfg map[string]string, ep chatEndpoint, tools []Tool, kwargs map[string]any, effort string) bool {
+	switch strings.ToLower(strings.TrimSpace(cfg["NUDGE_IN_TOOL"])) {
+	case "on", "1", "true", "yes", "oui":
+	default:
+		return false
+	}
+	if ep.External {
+		return false
+	}
+	r, ok := tplCapsFor(newTplShape(tools, kwargs, effort))
+	return ok && r.PrefixStable == tplNo && r.Model != "" && r.Model == reasoningEchoModel(cfg)
+}
+
+// nudgeIntoTool ajoute le rappel au bout du dernier résultat d'outil, dans la
+// vue du modèle ET dans l'historique — le même message, modifié des deux côtés
+// à l'identique, pour que le tour suivant rejoue les mêmes octets. Ce résultat
+// n'est pas encore parti au moteur : rien de ce qu'il a en cache ne bouge.
+// ok=false (dernier message d'une autre forme, historique réécrit entre-temps
+// par une compaction) : l'appelant passe par appendNudge. Copies, jamais de
+// modification en place.
+func nudgeIntoTool(messages, extra []Message, text string) ([]Message, []Message, bool) {
+	n, e := len(messages), len(extra)
+	if n == 0 || e == 0 {
+		return messages, extra, false
+	}
+	last, kept := messages[n-1], extra[e-1]
+	s, ok := last.Content.(string)
+	ks, kok := kept.Content.(string)
+	if !ok || !kok || s != ks || last.Role != "tool" || kept.Role != "tool" || last.ToolCallID != kept.ToolCallID {
+		return messages, extra, false
+	}
+	last.Content = s + "\n\n" + text
+	messages = append(messages[:n-1:n-1], last)
+	extra = append(extra[:e-1:e-1], last)
+	return messages, extra, true
+}

internal/loki/llm_oai.go

@@ -96,6 +96,11 @@ func oaiHandler() http.Handler {
 		Rewrite: func(pr *httputil.ProxyRequest) {
 			pr.SetURL(&url.URL{Scheme: "http", Host: fmt.Sprintf("127.0.0.1:%d", LLMPort())})
 			pr.Out.Host = pr.In.Host
+			// Strata refuse (403) un Host qu'il ne connaît pas (protection contre
+			// le DNS rebinding) : il se voit appelé sous son propre nom.
+			if strataActive() {
+				pr.Out.Host = pr.Out.URL.Host
+			}
 		},
 		ErrorHandler: func(w http.ResponseWriter, r *http.Request, e error) {
 			sendOAIError(w, http.StatusBadGateway,
@@ -112,10 +117,18 @@ func oaiHandler() http.Handler {
 			return
 		}
 		if strings.HasPrefix(p, "/v1") || p == "/health" || p == "/props" || p == "/metrics" || strings.HasPrefix(p, "/slots") {
+			// SIDE_SLOT : la complétion d'un client passe par le second slot,
+			// jamais par celui de la discussion (llm_sideslot.go). Sans second
+			// slot en service, le corps n'est pas lu.
+			side, status, msg := sideSlotProxyRewrite(r)
+			if status != 0 {
+				sendOAIError(w, status, msg, "invalid_request_error", "side_slot")
+				return
+			}
 			// Requête en vol vers le moteur : l'isolation des travaux annexes
 			// n'efface pas le slot pendant ce temps. Différé : ReverseProxy panique
 			// (ErrAbortHandler) quand le client coupe en plein flux.
-			defer engineRequestStart()()
+			defer engineProxyBegin(r, side)()
 			// Complétion d'un client externe : elle prend le slot sous le nez de
 			// la conversation. Notée pour nommer la perte de cache qui suit.
 			if r.Method == http.MethodPost && strings.HasPrefix(p, "/v1/") {
@@ -127,6 +140,13 @@ func oaiHandler() http.Handler {
 						"benchmark en cours sur ce moteur — réessaie dans un moment", "server_error", "benchmark_running")
 					return
 				}
+				// Optimisation : le vrai moteur est arrêté, un moteur d'essai tient la carte.
+				if tuneGuard() != nil {
+					w.Header().Set("Retry-After", "60")
+					sendOAIError(w, http.StatusServiceUnavailable,
+						"optimisation du moteur en cours — réessaie dans quelques minutes", "server_error", "tuning_running")
+					return
+				}
 				perfNoteForeign()
 			}
 			lp.ServeHTTP(w, r)

internal/loki/llm_reasoning_echo.go

@@ -0,0 +1,276 @@
+package loki
+
+// llm_reasoning_echo.go — REASONING_ECHO : renvoyer au moteur LOCAL le
+// raisonnement que le modèle a lui-même produit (reasoning_content), au lieu de
+// lui montrer ses étapes passées avec des blocs de réflexion vides.
+//
+// Pourquoi c'est utile. Les gabarits Qwen3.5/3.6 (et d'autres) rendent
+// `<think>…</think>` pour chaque message assistant situé après la dernière
+// question de l'utilisateur : c'est le format entrelacé sur lequel ils ont été
+// entraînés. Loki ne gardait que le texte et les appels d'outils, donc à chaque
+// étape d'une boucle d'outils le modèle relisait ses étapes précédentes sans leur
+// raisonnement, et le moteur recalculait le dernier message assistant (le rendu
+// ne correspondait plus à ce qu'il avait généré). Avec un gabarit qui sait
+// conserver la réflexion des tours passés (REASONING_PRESERVE=on, Qwen3.6), le
+// préfixe reste en plus stable d'un message utilisateur à l'autre. Qwen3.5 n'a
+// pas ce réglage : le gain y reste interne au tour.
+//
+// Pourquoi c'est OPT-IN (off par défaut). Le raisonnement renvoyé occupe du
+// contexte : une longue boucle d'outils atteint la compaction (avec perte) plus
+// tôt, même sans REASONING_PRESERVE. Et certains gabarits le refusent (gpt-oss
+// sur un moteur ancien lève « Cannot pass both content and thinking »). Sans la
+// clé, rien ne change : rien n'est capturé, rien n'est envoyé, à l'octet près.
+//
+// Les règles, chacune contre un piège précis :
+//   - moteur local seulement : une API externe (OpenAI, DeepSeek) refuserait ou
+//     interpréterait le champ à sa façon ;
+//   - seulement le raisonnement que le SERVEUR a séparé (reasoning_content du
+//     flux). Le découpage « </think> » fait chez nous reste dans le contenu, où
+//     le gabarit le redécoupe lui-même : poser aussi ReasoningContent le ferait
+//     rendre deux fois ;
+//   - chaque raisonnement porte le nom du modèle qui l'a produit, et ne repart
+//     que vers ce modèle-là : après un changement de modèle, un gabarit qui rend
+//     les anciens raisonnements (DeepSeek-V4 avec outils, MiniMax) présenterait
+//     sinon la réflexion d'une autre famille comme la sienne ;
+//   - jamais de message assistant qui ne porterait que du raisonnement (llama.cpp
+//     répond « Expected 'content' or 'tool_calls' ») ;
+//   - un seul point de sortie (echoMessages, appelé par runChat juste avant le
+//     marshal) : c'est là que tout est retiré quand la règle ne s'applique pas,
+//     y compris l'étiquette du modèle, qui ne quitte jamais Loki ;
+//   - si le gabarit refuse (exception), le tour est rejoué UNE fois sans
+//     raisonnement, et le refus est retenu pour ce modèle jusqu'au redémarrage,
+//     avant toute coupure d'outils ;
+//   - si le prompt déborde, on retente d'abord sans raisonnement — exactement la
+//     requête d'avant cette clé — avant toute compaction.
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+)
+
+// reasoningEchoEnabled : la clé REASONING_ECHO demande-t-elle l'écho ?
+func reasoningEchoEnabled(cfg map[string]string) bool {
+	switch strings.ToLower(strings.TrimSpace(cfg["REASONING_ECHO"])) {
+	case "on", "1", "true", "yes", "oui":
+		return true
+	}
+	return false
+}
+
+// reasoningEchoModel : l'étiquette du modèle chargé, posée sur chaque
+// raisonnement capturé. Le nom du fichier, pas le chemin : le même modèle
+// déplacé ou monté ailleurs reste le même. Vide = inconnu, rien ne part.
+func reasoningEchoModel(cfg map[string]string) string {
+	m := strings.TrimSpace(cfg["MODEL"])
+	if m == "" {
+		return ""
+	}
+	return filepath.Base(m)
+}
+
+// echoRefused : modèles dont le gabarit a refusé un raisonnement renvoyé, pour
+// toute la vie du processus (même principe que effortFallbacks).
+var echoRefused sync.Map
+
+func echoRefuse(model string) {
+	if model == "" {
+		return
+	}
+	if _, loaded := echoRefused.LoadOrStore(model, true); !loaded {
+		fmt.Fprintf(os.Stderr, "[reasoning] gabarit de %s : raisonnement renvoyé refusé — REASONING_ECHO suspendu pour ce modèle jusqu'au redémarrage\n", model)
+	}
+}
+
+func echoIsRefused(model string) bool {
+	_, ok := echoRefused.Load(model)
+	return ok
+}
+
+// echoPolicy : ce qui part au moteur pour cette requête.
+//   - on : renvoyer le raisonnement (clé posée, moteur local, modèle connu, pas
+//     refusé par le gabarit, et la sonde ne dit pas qu'il n'est jamais rendu) ;
+//   - model : seul le raisonnement étiqueté de ce modèle repart ;
+//   - keepsPast : le gabarit rend aussi le raisonnement des messages d'AVANT la
+//     dernière question (sonde « oui » ou inconnue). Ne sert qu'au comptage :
+//     un raisonnement que le gabarit écarte ne coûte rien au prompt.
+type echoPolicy struct {
+	on        bool
+	model     string
+	keepsPast bool
+}
+
+// currentEchoPolicy lit la configuration, la mémoire des refus et le dernier
+// verdict de la sonde de gabarit (chat_tplprobe.go).
+func currentEchoPolicy() echoPolicy {
+	return echoPolicyFor(ReadConfig())
+}
+
+func echoPolicyFor(cfg map[string]string) echoPolicy {
+	p := echoPolicy{model: reasoningEchoModel(cfg), keepsPast: true}
+	if !reasoningEchoEnabled(cfg) || isExternalConfig(cfg) || p.model == "" || echoIsRefused(p.model) {
+		return echoPolicy{}
+	}
+	p.on = true
+	// Verdict de la sonde, s'il concerne bien CE modèle. « jamais rendu » :
+	// renvoyer ne servirait à rien, on s'abstient. Inconnu : l'utilisateur a
+	// demandé l'écho, on envoie (le filet d'erreur de gabarit reste là).
+	if r, ok := tplCapsCurrent(); ok && r.Model == p.model {
+		if r.RendersReasoning == tplNo {
+			p.on = false
+		}
+		if r.PreservesHistory == tplNo {
+			p.keepsPast = false
+		}
+	}
+	return p
+}
+
+// hasBody : le message assistant porte du texte ou des appels d'outils — ce
+// sans quoi llama.cpp refuse un message assistant.
+func hasBody(m Message) bool {
+	if len(m.ToolCalls) > 0 {
+		return true
+	}
+	switch v := m.Content.(type) {
+	case nil:
+		return false
+	case string:
+		return v != ""
+	}
+	return true
+}
+
+// echoable : ce raisonnement-là peut-il partir sous cette politique ?
+func echoable(m Message, p echoPolicy) bool {
+	return p.on && m.Role == "assistant" && m.ReasoningContent != "" &&
+		m.ReasoningModel == p.model && hasBody(m)
+}
+
+// echoMessages : LE point de sortie. Rend les messages tels qu'ils partent au
+// moteur, et le nombre de raisonnements renvoyés. Aucun message ne porte de
+// raisonnement (cas de toujours, clé absente) : la tranche est rendue telle
+// quelle, sans copie — la requête est identique à l'octet près. Sinon, copie :
+// l'étiquette du modèle est toujours retirée, le raisonnement l'est quand il
+// ne doit pas partir.
+func echoMessages(msgs []Message, p echoPolicy) ([]Message, int) {
+	has := false
+	for i := range msgs {
+		if msgs[i].ReasoningContent != "" || msgs[i].ReasoningModel != "" {
+			has = true
+			break
+		}
+	}
+	if !has {
+		return msgs, 0
+	}
+	out := make([]Message, len(msgs))
+	n := 0
+	for i, m := range msgs {
+		keep := echoable(m, p)
+		m.ReasoningModel = ""
+		if keep {
+			n++
+		} else {
+			m.ReasoningContent = ""
+		}
+		out[i] = m
+	}
+	return out, n
+}
+
+// echoTokens : jetons que le raisonnement renvoyé ajoute au prompt, message par
+// message (nil = aucun). Compte ce qui part ET que le gabarit rend : après la
+// dernière question toujours (rendu au sein du tour par tous les gabarits
+// entrelacés), avant elle seulement si le gabarit conserve le passé ou qu'on ne
+// le sait pas — dans le doute on compte, le sens sans danger.
+func echoTokens(msgs []Message) []int {
+	found := false
+	for i := range msgs {
+		if msgs[i].ReasoningContent != "" {
+			found = true
+			break
+		}
+	}
+	if !found {
+		return nil // cas de toujours : pas même une lecture de configuration
+	}
+	return echoTokensFor(msgs, currentEchoPolicy())
+}
+
+func echoTokensFor(msgs []Message, p echoPolicy) []int {
+	if !p.on {
+		return nil
+	}
+	lastUser := -1
+	for i, m := range msgs {
+		if m.Role == "user" {
+			lastUser = i
+		}
+	}
+	var out []int
+	for i, m := range msgs {
+		if !echoable(m, p) || (i < lastUser && !p.keepsPast) {
+			continue
+		}
+		if out == nil {
+			out = make([]int, len(msgs))
+		}
+		out[i] = len(m.ReasoningContent) / 4
+	}
+	return out
+}
+
+// stripReasoning : copie des messages sans aucun raisonnement (étiquette
+// comprise) — ce que Loki envoyait avant REASONING_ECHO.
+func stripReasoning(msgs []Message) []Message {
+	out, _ := echoMessages(msgs, echoPolicy{})
+	return out
+}
+
+// echoTemplateError : le moteur a-t-il refusé la requête à cause du gabarit,
+// d'une façon que le raisonnement renvoyé peut expliquer ? Exception levée par
+// le gabarit (raise_exception, « Cannot pass both content and thinking » de
+// gpt-oss), message assistant jugé invalide, messages illisibles. Le refus du
+// niveau de raisonnement, lui aussi levé par le gabarit, a son propre filet
+// (llm_effort.go) et n'est pas concerné.
+func echoTemplateError(status int, body string) bool {
+	if status != 500 && status != 400 {
+		return false
+	}
+	if _, isEffort := effortRejection(body); isEffort {
+		return false
+	}
+	low := strings.ToLower(body)
+	// Appel d'outil mal formé (« Failed to parse input at pos N: … ») : le
+	// texte du modèle y est cité, il peut dire « thinking » sans que le gabarit
+	// y soit pour rien. Le filet des outils s'en charge, pas celui-ci — sinon
+	// une relance chanceuse ferait couper la clé pour ce modèle à tort.
+	if strings.Contains(low, "failed to parse input") {
+		return false
+	}
+	for _, k := range []string{"raise_exception", "expected 'content' or 'tool_calls'", "failed to parse messages"} {
+		if strings.Contains(low, k) {
+			return true
+		}
+	}
+	// « thinking » seul ne dit rien : seulement dans une erreur du gabarit.
+	return strings.Contains(low, "thinking") && (strings.Contains(low, "jinja") || strings.Contains(low, "template"))
+}
+
+// ReasoningEcho : raisonnement séparé de la complétion qui porte la réponse
+// finale, et le modèle qui l'a produit. L'appelant le range avec cette réponse.
+type ReasoningEcho struct {
+	Text  string
+	Model string
+}
+
+// withEcho pose le raisonnement final sur le message de réponse.
+func withEcho(m Message, e *ReasoningEcho) Message {
+	if e != nil && e.Text != "" && hasBody(m) {
+		m.ReasoningContent, m.ReasoningModel = e.Text, e.Model
+	}
+	return m
+}

internal/loki/llm_reasoning_echo_test.go

@@ -0,0 +1,618 @@
+package loki
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+	"sync"
+	"testing"
+)
+
+const echoTestModel = "Qwen3.6-27B-Q8_0.gguf"
+
+// echoTestSetup : base de test, modèle connu, sonde vierge, mémoire des refus
+// nettoyée. on = REASONING_ECHO posé.
+func echoTestSetup(t *testing.T, on bool) {
+	t.Helper()
+	withWorkspace(t)
+	freshTplProbe(t)
+	if err := SetConfigKey("MODEL", "/models/"+echoTestModel); err != nil {
+		t.Fatal(err)
+	}
+	if on {
+		if err := SetConfigKey("REASONING_ECHO", "on"); err != nil {
+			t.Fatal(err)
+		}
+	}
+	echoRefused.Delete(echoTestModel)
+	t.Cleanup(func() { echoRefused.Delete(echoTestModel) })
+}
+
+// moteurEcho : llama-server de comédie. Chaque requête de complétion reçoit
+// la réponse de reply (statut, corps SSE ou erreur) ; les corps bruts sont
+// gardés pour être comparés. Les requêtes non streamées (résumé de compaction)
+// reçoivent un résumé.
+type moteurEcho struct {
+	mu      sync.Mutex
+	bodies  []string
+	summary int
+	reply   func(n int, body string) (int, string)
+}
+
+func (m *moteurEcho) start(t *testing.T) {
+	t.Helper()
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		var buf bytes.Buffer
+		_, _ = buf.ReadFrom(r.Body)
+		body := buf.String()
+		if !strings.Contains(body, `"stream":true`) {
+			m.mu.Lock()
+			m.summary++
+			m.mu.Unlock()
+			sendJSON(w, 200, map[string]any{"choices": []any{map[string]any{"message": map[string]any{"content": "- résumé des étapes précédentes, avec les faits trouvés"}}}})
+			return
+		}
+		m.mu.Lock()
+		n := len(m.bodies)
+		m.bodies = append(m.bodies, body)
+		m.mu.Unlock()
+		status, out := m.reply(n, body)
+		if status != 200 {
+			w.WriteHeader(status)
+			_, _ = w.Write([]byte(out))
+			return
+		}
+		w.Header().Set("Content-Type", "text/event-stream")
+		_, _ = w.Write([]byte(out + "data: [DONE]\n\n"))
+	}))
+	t.Cleanup(srv.Close)
+	u, _ := url.Parse(srv.URL)
+	if err := SetConfigKey("PORT", u.Port()); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func (m *moteurEcho) all() []string {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	return append([]string(nil), m.bodies...)
+}
+
+const sseGlobStep = `data: {"choices":[{"delta":{"tool_calls":[{"index":0,"id":"g1","type":"function","function":{"name":"glob","arguments":"{\"pattern\":\"*.go\"}"}}]}}]}` + "\n\n" +
+	`data: {"choices":[{"delta":{},"finish_reason":"tool_calls"}]}` + "\n\n"
+
+// Une boucle d'outils : raisonnement séparé + appel, puis raisonnement + réponse.
+func scriptBoucle(n int, _ string) (int, string) {
+	if n == 0 {
+		return 200, sseReasoning("je cherche ") + sseReasoning("les fichiers") + sseGlobStep
+	}
+	return 200, sseReasoning("j'ai trouvé") + sseChunk("Voilà.") + sseFinal("stop", 120, 5)
+}
+
+// requestMessages décode les messages d'un corps de requête.
+func requestMessages(t *testing.T, body string) []map[string]any {
+	t.Helper()
+	var p struct {
+		Messages []map[string]any `json:"messages"`
+	}
+	if err := json.Unmarshal([]byte(body), &p); err != nil {
+		t.Fatal(err)
+	}
+	return p.Messages
+}
+
+// Clé absente : rien n'est capturé ni renvoyé, aucun événement nouveau. La
+// requête est celle d'avant la clé.
+func TestEchoDefautRienNeChange(t *testing.T) {
+	echoTestSetup(t, false)
+	m := &moteurEcho{reply: scriptBoucle}
+	m.start(t)
+	var echoes int
+	extra, err := runChat(context.Background(), []Message{um("liste les fichiers")}, 0.7, Caps{Agent: true}, func(ev StreamEvent) bool {
+		if ev.Echo != nil {
+			echoes++
+		}
+		return true
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	bodies := m.all()
+	if len(bodies) != 2 {
+		t.Fatalf("%d requêtes, attendu 2", len(bodies))
+	}
+	for i, b := range bodies {
+		if strings.Contains(b, "reasoning_content") || strings.Contains(b, "reasoning_model") {
+			t.Fatalf("requête %d : raisonnement envoyé sans la clé : %s", i, b)
+		}
+	}
+	for _, e := range extra {
+		if e.ReasoningContent != "" || e.ReasoningModel != "" {
+			t.Fatalf("raisonnement capturé sans la clé : %+v", e)
+		}
+	}
+	if echoes != 0 {
+		t.Fatalf("%d événements Echo sans la clé", echoes)
+	}
+}
+
+// Point de sortie : sans raisonnement nulle part, la tranche ressort telle
+// quelle ; avec du raisonnement stocké mais une politique éteinte, le JSON est
+// octet pour octet celui d'avant le champ.
+func TestEchoMessagesOctetPourOctet(t *testing.T) {
+	plain := []Message{
+		{Role: "system", Content: "sys"},
+		um("question"),
+		{Role: "assistant", Content: "je regarde", ToolCalls: []ToolCall{{ID: "c1", Type: "function", Function: ToolCallFunc{Name: "bash", Arguments: "{}"}}}},
+		tm("sortie"),
+		am("réponse"),
+	}
+	out, n := echoMessages(plain, echoPolicy{on: true, model: echoTestModel, keepsPast: true})
+	if n != 0 || &out[0] != &plain[0] {
+		t.Fatal("aucun raisonnement : la tranche doit ressortir sans copie")
+	}
+	want, _ := json.Marshal(plain)
+	stored := append([]Message(nil), plain...)
+	stored[2].ReasoningContent, stored[2].ReasoningModel = "raisonnement", echoTestModel
+	stored[4].ReasoningContent, stored[4].ReasoningModel = "autre", echoTestModel
+	for _, p := range []echoPolicy{{}, {on: true, model: "autre-modele.gguf", keepsPast: true}} {
+		got, n := echoMessages(stored, p)
+		b, _ := json.Marshal(got)
+		if n != 0 || !bytes.Equal(b, want) {
+			t.Fatalf("politique %+v : %s\nattendu %s", p, b, want)
+		}
+	}
+	if stored[2].ReasoningContent == "" {
+		t.Fatal("echoMessages a modifié l'historique d'origine")
+	}
+}
+
+// Ce qui part : seulement le raisonnement du même modèle, jamais l'étiquette,
+// jamais sur un message assistant sans texte ni appel.
+func TestEchoMessagesPolitique(t *testing.T) {
+	p := echoPolicy{on: true, model: echoTestModel, keepsPast: true}
+	msgs := []Message{
+		um("q"),
+		{Role: "assistant", Content: "a", ReasoningContent: "r1", ReasoningModel: echoTestModel},
+		{Role: "assistant", Content: "b", ReasoningContent: "r2", ReasoningModel: "Llama-3.gguf"},
+		{Role: "assistant", ReasoningContent: "r3", ReasoningModel: echoTestModel}, // ni texte ni appel
+		{Role: "assistant", ToolCalls: []ToolCall{{ID: "c1", Type: "function", Function: ToolCallFunc{Name: "bash", Arguments: "{}"}}}, ReasoningContent: "r4", ReasoningModel: echoTestModel},
+		{Role: "user", Content: "x", ReasoningContent: "r5", ReasoningModel: echoTestModel},
+	}
+	out, n := echoMessages(msgs, p)
+	if n != 2 || out[1].ReasoningContent != "r1" || out[4].ReasoningContent != "r4" {
+		t.Fatalf("renvoyés : %d, %+v", n, out)
+	}
+	for i, m := range out {
+		if m.ReasoningModel != "" {
+			t.Fatalf("étiquette du modèle envoyée (message %d)", i)
+		}
+		if m.Role == "assistant" && m.ReasoningContent != "" && !hasBody(m) {
+			t.Fatalf("message assistant de pur raisonnement envoyé (message %d)", i)
+		}
+	}
+	if out[2].ReasoningContent != "" || out[3].ReasoningContent != "" || out[5].ReasoningContent != "" {
+		t.Fatalf("raisonnement envoyé à tort : %+v", out)
+	}
+}
+
+func TestEchoPolicyFor(t *testing.T) {
+	echoTestSetup(t, false)
+	base := map[string]string{"REASONING_ECHO": "on", "MODEL": "/models/" + echoTestModel}
+	with := func(k, v string) map[string]string {
+		c := map[string]string{}
+		for a, b := range base {
+			c[a] = b
+		}
+		c[k] = v
+		return c
+	}
+	if p := echoPolicyFor(base); !p.on || p.model != echoTestModel || !p.keepsPast {
+		t.Fatalf("clé posée : %+v", p)
+	}
+	if p := echoPolicyFor(with("REASONING_ECHO", "")); p.on {
+		t.Fatal("clé absente : écho actif")
+	}
+	if p := echoPolicyFor(with(extKeyFlag, "1")); p.on {
+		t.Fatal("preset externe : écho actif")
+	}
+	if p := echoPolicyFor(with("MODEL", "")); p.on {
+		t.Fatal("modèle inconnu : écho actif")
+	}
+	echoRefuse(echoTestModel)
+	if p := echoPolicyFor(base); p.on {
+		t.Fatal("gabarit qui a refusé : écho actif")
+	}
+	echoRefused.Delete(echoTestModel)
+	// Verdicts de la sonde, seulement pour CE modèle.
+	set := func(r tplProbeResult) {
+		tplProbeMu.Lock()
+		tplProbeLast = &r
+		tplProbeMu.Unlock()
+	}
+	set(tplProbeResult{Model: echoTestModel, RendersReasoning: tplNo, PreservesHistory: tplNo})
+	if p := echoPolicyFor(base); p.on {
+		t.Fatal("gabarit qui ne rend jamais le raisonnement : écho actif")
+	}
+	set(tplProbeResult{Model: echoTestModel, RendersReasoning: tplYes, PreservesHistory: tplNo})
+	if p := echoPolicyFor(base); !p.on || p.keepsPast {
+		t.Fatalf("gabarit façon Qwen3.5 : %+v", p)
+	}
+	set(tplProbeResult{Model: "autre.gguf", RendersReasoning: tplNo, PreservesHistory: tplNo})
+	if p := echoPolicyFor(base); !p.on || !p.keepsPast {
+		t.Fatalf("verdict d'un autre modèle appliqué : %+v", p)
+	}
+}
+
+// Comptage : le raisonnement d'après la dernière question compte toujours,
+// celui d'avant seulement si le gabarit garde le passé (ou qu'on l'ignore).
+func TestEchoTokensSuitLeRendu(t *testing.T) {
+	r := strings.Repeat("r", 400) // 100 jetons
+	msgs := []Message{
+		um("q1"),
+		{Role: "assistant", Content: "a", ReasoningContent: r, ReasoningModel: echoTestModel},
+		um("q2"),
+		{Role: "assistant", Content: "b", ReasoningContent: r, ReasoningModel: echoTestModel},
+	}
+	sum := func(v []int) int {
+		s := 0
+		for _, n := range v {
+			s += n
+		}
+		return s
+	}
+	if got := sum(echoTokensFor(msgs, echoPolicy{on: true, model: echoTestModel, keepsPast: true})); got != 200 {
+		t.Fatalf("gabarit qui garde le passé : %d, attendu 200", got)
+	}
+	if got := sum(echoTokensFor(msgs, echoPolicy{on: true, model: echoTestModel})); got != 100 {
+		t.Fatalf("gabarit qui retire le passé : %d, attendu 100", got)
+	}
+	if got := echoTokensFor(msgs, echoPolicy{}); got != nil {
+		t.Fatalf("écho coupé : %v", got)
+	}
+	// estimateTokens suit la configuration réelle.
+	echoTestSetup(t, false)
+	without := estimateTokens(msgs)
+	if err := SetConfigKey("REASONING_ECHO", "on"); err != nil {
+		t.Fatal(err)
+	}
+	if got := estimateTokens(msgs); got != without+200 {
+		t.Fatalf("estimateTokens avec l'écho = %d, attendu %d", got, without+200)
+	}
+}
+
+// shrinkToFit retire d'abord le raisonnement, du plus ancien au plus récent,
+// même dans un seul long tour sans frontière utilisateur.
+func TestShrinkRetireDAbordLeRaisonnement(t *testing.T) {
+	echoTestSetup(t, true)
+	if err := SetConfigKey("CTX", "8192"); err != nil {
+		t.Fatal(err)
+	}
+	r := strings.Repeat("r", 8000) // 2000 jetons chacun
+	msgs := []Message{um("corrige le build")}
+	for i := 0; i < 4; i++ {
+		msgs = append(msgs,
+			Message{Role: "assistant", ToolCalls: []ToolCall{{ID: "c1", Type: "function", Function: ToolCallFunc{Name: "bash", Arguments: "{}"}}}, ReasoningContent: r, ReasoningModel: echoTestModel},
+			tm("sortie courte"))
+	}
+	out, changed := shrinkToFit(msgs, 0)
+	if !changed {
+		t.Fatal("rien retiré")
+	}
+	if len(out) != len(msgs) {
+		t.Fatalf("des messages ont été retirés (%d → %d) alors que le raisonnement suffisait", len(msgs), len(out))
+	}
+	if out[1].ReasoningContent != "" || out[len(out)-2].ReasoningContent == "" {
+		t.Fatal("ordre : le plus ancien raisonnement doit partir en premier, le plus récent rester")
+	}
+	for i, m := range out {
+		if m.Role == "tool" && msgText(m) != "sortie courte" {
+			t.Fatalf("résultat d'outil %d tronqué avant le raisonnement", i)
+		}
+	}
+	if msgs[1].ReasoningContent == "" {
+		t.Fatal("shrinkToFit a modifié l'historique d'origine")
+	}
+}
+
+// Clé posée : le raisonnement séparé de l'étape d'outil repart avec elle, sans
+// étiquette ; celui de la réponse finale est rendu à l'appelant.
+func TestEchoRenvoieLeRaisonnementSepare(t *testing.T) {
+	echoTestSetup(t, true)
+	m := &moteurEcho{reply: scriptBoucle}
+	m.start(t)
+	var echo *ReasoningEcho
+	extra, err := runChat(context.Background(), []Message{um("liste les fichiers")}, 0.7, Caps{Agent: true}, func(ev StreamEvent) bool {
+		if ev.Echo != nil {
+			echo = ev.Echo
+		}
+		return true
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(extra) < 1 || extra[0].ReasoningContent != "je cherche les fichiers" || extra[0].ReasoningModel != echoTestModel {
+		t.Fatalf("message tool_calls : %+v", extra)
+	}
+	bodies := m.all()
+	if len(bodies) != 2 {
+		t.Fatalf("%d requêtes", len(bodies))
+	}
+	if strings.Contains(bodies[1], "reasoning_model") {
+		t.Fatal("étiquette du modèle envoyée au moteur")
+	}
+	msgs := requestMessages(t, bodies[1])
+	var found bool
+	for _, mm := range msgs {
+		if mm["role"] == "assistant" && mm["reasoning_content"] == "je cherche les fichiers" {
+			found = true
+		}
+	}
+	if !found {
+		t.Fatalf("raisonnement de l'étape non renvoyé : %s", bodies[1])
+	}
+	if echo == nil || echo.Text != "j'ai trouvé" || echo.Model != echoTestModel {
+		t.Fatalf("raisonnement final : %+v", echo)
+	}
+}
+
+// Découpage « </think> » fait chez nous : jamais copié dans ReasoningContent
+// (le gabarit le redécouperait, rendu en double).
+func TestEchoJamaisDepuisLeDecoupageClient(t *testing.T) {
+	echoTestSetup(t, true)
+	if err := SetConfigKey("REASONING", "on"); err != nil {
+		t.Fatal(err)
+	}
+	m := &moteurEcho{reply: func(n int, _ string) (int, string) {
+		if n == 0 {
+			return 200, sseChunk("je pense") + sseChunk("</think>") + sseChunk("je regarde") + sseGlobStep
+		}
+		return 200, sseChunk("pensée</think>") + sseChunk("Voilà.") + sseFinal("stop", 100, 4)
+	}}
+	m.start(t)
+	var echo *ReasoningEcho
+	extra, err := runChat(context.Background(), []Message{um("liste")}, 0.7, Caps{Agent: true}, func(ev StreamEvent) bool {
+		if ev.Echo != nil {
+			echo = ev.Echo
+		}
+		return true
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, b := range m.all() {
+		if strings.Contains(b, "reasoning_content") {
+			t.Fatalf("raisonnement découpé chez nous renvoyé à part : %s", b)
+		}
+	}
+	if len(extra) < 1 || extra[0].ReasoningContent != "" || msgText(extra[0]) != "je pense</think>je regarde" {
+		t.Fatalf("message tool_calls : %+v", extra)
+	}
+	if echo != nil {
+		t.Fatalf("raisonnement final tiré du découpage client : %+v", echo)
+	}
+}
+
+// Une relance « pensé sans agir » (DropReasoning) : seul le raisonnement de la
+// complétion retenue accompagne la réponse.
+func TestEchoApresDropReasoning(t *testing.T) {
+	echoTestSetup(t, true)
+	m := &moteurEcho{reply: func(n int, _ string) (int, string) {
+		if n == 0 {
+			return 200, sseReasoning("mort-né") + sseFinal("stop", 100, 3)
+		}
+		return 200, sseReasoning("retenu") + sseChunk("Fait.") + sseFinal("stop", 110, 3)
+	}}
+	m.start(t)
+	var echo *ReasoningEcho
+	var dropped bool
+	if _, err := runChat(context.Background(), []Message{um("fais-le")}, 0.7, Caps{Agent: true}, func(ev StreamEvent) bool {
+		if ev.Echo != nil {
+			echo = ev.Echo
+		}
+		if ev.DropReasoning {
+			dropped = true
+		}
+		return true
+	}); err != nil {
+		t.Fatal(err)
+	}
+	if !dropped || echo == nil || echo.Text != "retenu" {
+		t.Fatalf("après relance : dropped=%v echo=%+v", dropped, echo)
+	}
+}
+
+// generate range le raisonnement final avec la réponse, et rien sans la clé.
+func TestGenerateRangeLeRaisonnement(t *testing.T) {
+	for _, on := range []bool{false, true} {
+		echoTestSetup(t, on)
+		m := &moteurEcho{reply: func(int, string) (int, string) {
+			return 200, sseReasoning("réflexion") + sseChunk("Bonjour.") + sseFinal("stop", 50, 3)
+		}}
+		m.start(t)
+		c := newTestConv()
+		c.Messages = []Message{um("salut")}
+		c.generate(context.Background(), Caps{}, 0.7, c.epoch)
+		last := c.Messages[len(c.Messages)-1]
+		if msgText(last) != "Bonjour." {
+			t.Fatalf("on=%v : dernier message %+v", on, last)
+		}
+		if on && (last.ReasoningContent != "réflexion" || last.ReasoningModel != echoTestModel) {
+			t.Fatalf("clé posée : raisonnement non rangé : %+v", last)
+		}
+		if !on && (last.ReasoningContent != "" || last.ReasoningModel != "") {
+			t.Fatalf("clé absente : raisonnement rangé : %+v", last)
+		}
+	}
+}
+
+// Historique qui porte un raisonnement de ce modèle.
+func echoHistory() []Message {
+	return []Message{
+		um("question"),
+		{Role: "assistant", Content: "préambule", ToolCalls: []ToolCall{{ID: "c1", Type: "function", Function: ToolCallFunc{Name: "glob", Arguments: `{"pattern":"*"}`}}},
+			ReasoningContent: "réflexion passée", ReasoningModel: echoTestModel},
+		tm("a.go"),
+	}
+}
+
+// Gabarit qui refuse (gpt-oss sur un moteur ancien) : rejoué une fois sans
+// raisonnement, outils et prompt intacts, et le refus est retenu.
+func TestEchoErreurDeGabaritRelanceSansRaisonnement(t *testing.T) {
+	echoTestSetup(t, true)
+	m := &moteurEcho{reply: func(_ int, body string) (int, string) {
+		if strings.Contains(body, "reasoning_content") {
+			return 500, `{"error":{"code":500,"message":"Jinja Exception: raise_exception('Cannot pass both content and thinking in an assistant message with tool calls')"}}`
+		}
+		return 200, sseChunk("Réponse.") + sseFinal("stop", 80, 2)
+	}}
+	m.start(t)
+	var content strings.Builder
+	if _, err := runChat(context.Background(), echoHistory(), 0.7, Caps{Agent: true}, func(ev StreamEvent) bool {
+		content.WriteString(ev.Content)
+		return true
+	}); err != nil {
+		t.Fatal(err)
+	}
+	bodies := m.all()
+	if len(bodies) != 2 || content.String() != "Réponse." {
+		t.Fatalf("%d requêtes, réponse %q", len(bodies), content.String())
+	}
+	if strings.Contains(bodies[1], "reasoning_content") || strings.Contains(bodies[1], `"tool_choice"`) ||
+		!strings.Contains(bodies[1], `"tools"`) {
+		t.Fatalf("relance : raisonnement retiré, outils intacts attendus : %s", bodies[1])
+	}
+	if !echoIsRefused(echoTestModel) {
+		t.Fatal("refus du gabarit non retenu")
+	}
+	if p := currentEchoPolicy(); p.on {
+		t.Fatal("écho encore actif après le refus")
+	}
+}
+
+// Erreur de gabarit qui n'a rien à voir avec le raisonnement : la relance
+// échoue aussi, et rien n'est retenu contre l'écho.
+func TestEchoErreurDeGabaritSansRapport(t *testing.T) {
+	echoTestSetup(t, true)
+	m := &moteurEcho{reply: func(int, string) (int, string) {
+		return 500, `{"error":{"code":500,"message":"Jinja Exception: raise_exception('Conversation roles must alternate')"}}`
+	}}
+	m.start(t)
+	if _, err := runChat(context.Background(), echoHistory(), 0.7, Caps{}, func(StreamEvent) bool { return true }); err == nil {
+		t.Fatal("erreur attendue")
+	}
+	bodies := m.all()
+	if len(bodies) < 2 || !strings.Contains(bodies[0], "reasoning_content") {
+		t.Fatalf("%d requêtes ; la première doit porter le raisonnement", len(bodies))
+	}
+	// Ensuite, les filets habituels (tool_choice none, outils coupés) partent
+	// sans raisonnement : il n'est plus envoyé de ce tour.
+	for i, b := range bodies[1:] {
+		if strings.Contains(b, "reasoning_content") {
+			t.Fatalf("requête %d : raisonnement renvoyé après le repli", i+1)
+		}
+	}
+	if echoIsRefused(echoTestModel) {
+		t.Fatal("refus retenu alors que le raisonnement n'y était pour rien")
+	}
+}
+
+// Prompt trop long avec du raisonnement : relance sans lui AVANT toute
+// compaction (aucune perte d'information).
+func TestEchoDebordementRelanceSansRaisonnementAvantCompaction(t *testing.T) {
+	echoTestSetup(t, true)
+	m := &moteurEcho{reply: func(_ int, body string) (int, string) {
+		if strings.Contains(body, "reasoning_content") {
+			return 400, `{"error":{"code":400,"message":"the request exceeds the available context size, try increasing it","type":"exceed_context_size_error"}}`
+		}
+		return 200, sseChunk("Réponse.") + sseFinal("stop", 80, 2)
+	}}
+	m.start(t)
+	var compacted bool
+	if _, err := runChat(context.Background(), echoHistory(), 0.7, Caps{Agent: true}, func(ev StreamEvent) bool {
+		if ev.NewHistory != nil {
+			compacted = true
+		}
+		return true
+	}); err != nil {
+		t.Fatal(err)
+	}
+	bodies := m.all()
+	if len(bodies) != 2 || strings.Contains(bodies[1], "reasoning_content") {
+		t.Fatalf("%d requêtes ; relance sans raisonnement attendue", len(bodies))
+	}
+	m.mu.Lock()
+	summaries := m.summary
+	m.mu.Unlock()
+	if compacted || summaries != 0 {
+		t.Fatalf("compaction avant la relance sans raisonnement (résumés=%d)", summaries)
+	}
+	if echoIsRefused(echoTestModel) {
+		t.Fatal("un débordement n'est pas un refus du gabarit")
+	}
+}
+
+// Passe de correction du mode Code : une compaction survenue pendant la passe
+// REMPLACE l'historique, comme dans generate, au lieu d'être perdue.
+func TestBuilderAppliqueNewHistory(t *testing.T) {
+	echoTestSetup(t, false)
+	convEnsureActive()
+	m := &moteurEcho{reply: func(n int, _ string) (int, string) {
+		if n == 0 {
+			return 400, `{"error":{"code":400,"message":"request (99999 tokens) exceeds the available context size"}}`
+		}
+		return 200, sseChunk("Corrigé.") + sseFinal("stop", 80, 2)
+	}}
+	m.start(t)
+	c := newTestConv()
+	c.Messages = []Message{um("fais le build")}
+	for i := 0; i < 12; i++ {
+		c.Messages = append(c.Messages, am("étape "+strings.Repeat("détail ", 300)), um("continue "+strings.Repeat("x", 600)))
+	}
+	before := len(c.Messages)
+	c.runBuilderTurn(context.Background(), Caps{Agent: true, Code: true}, 0.2, c.epoch, "Fix the failing test.")
+	if len(c.Messages) >= before {
+		t.Fatalf("compaction perdue : %d messages (avant %d)", len(c.Messages), before)
+	}
+	if !strings.HasPrefix(msgText(c.Messages[0]), compactSummaryPrefix) {
+		t.Fatalf("premier message : %q", msgText(c.Messages[0]))
+	}
+	if c.Messages[0].Role == "system" {
+		t.Fatal("préfixe système injecté persisté")
+	}
+	fix := 0
+	for _, mm := range c.Messages {
+		if msgText(mm) == "Fix the failing test." {
+			fix++
+		}
+	}
+	if fix != 1 || msgText(c.Messages[len(c.Messages)-1]) != "Corrigé." {
+		t.Fatalf("consigne présente %d fois, dernier message %q", fix, msgText(c.Messages[len(c.Messages)-1]))
+	}
+}
+
+// Corrections de relecture du lot 2 : un refus de gabarit est reconnu, une
+// erreur d'analyse d'appel d'outil qui cite le mot « thinking » ne l'est pas.
+func TestEchoTemplateErrorEtroit(t *testing.T) {
+	cases := []struct {
+		status int
+		body   string
+		want   bool
+	}{
+		{500, `{"error":{"message":"Jinja Exception: raise_exception('Cannot pass both content and thinking')"}}`, true},
+		{500, `{"error":{"message":"Error in template: thinking blocks not allowed here"}}`, true},
+		{400, `{"error":{"message":"Expected 'content' or 'tool_calls'"}}`, true},
+		{500, `{"error":{"message":"Failed to parse input at pos 12: <tool_call>{\"thinking\": 1}"}}`, false},
+		{500, `{"error":{"message":"the model kept thinking forever"}}`, false},
+		{502, `{"error":{"message":"raise_exception"}}`, false},
+	}
+	for _, c := range cases {
+		if got := echoTemplateError(c.status, c.body); got != c.want {
+			t.Errorf("%d %s : %v", c.status, c.body, got)
+		}
+	}
+}

internal/loki/llm_sideslot.go

@@ -0,0 +1,175 @@
+package loki
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"regexp"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+// Routage des requêtes entre les deux slots de SIDE_SLOT (backend_serve_side.go).
+//
+// Sans id_slot, llama-server choisit le slot par similarité de prompt ou, à
+// défaut, le moins récemment servi : un vérificateur peut alors tomber sur le
+// slot 0 et écraser la conversation — exactement ce que la clé doit empêcher.
+// Tant que le second slot est en service, CHAQUE requête de Loki porte donc son
+// id_slot : 0 pour le fil de la discussion (tour, étapes d'outils,
+// préchauffage, résumé en continuation, qui prolonge le prompt du slot 0), 1
+// pour tout le reste (vérification, sous-agent, tâche, bench, résumé sur
+// transcription, clients /v1).
+//
+// « En service » se lit sur le moteur, pas dans la configuration : /props doit
+// annoncer 2 slots d'au moins CTX jetons chacun, ce que seul un lancement
+// SIDE_SLOT accepté produit. Un moteur relancé sans la clé, refusé ou pas encore
+// prêt : aucun id_slot, la requête est celle d'avant. Et sur un seul slot, un
+// id_slot explicite ferait même sauter le rechargement depuis le cache RAM
+// (f_keep indéfini sur un slot vide) : il ne doit jamais y partir.
+
+// sideSlotProbeTTL : durée pendant laquelle la lecture de /props vaut. Un
+// moteur relancé entre-temps sur un seul slot recevrait au pire un id_slot 1,
+// que llama.cpp ramène au slot 0 : le comportement d'avant la clé.
+const sideSlotProbeTTL = 10 * time.Second
+
+var sideSlotProbe struct {
+	mu   sync.Mutex
+	key  string
+	at   time.Time
+	live bool
+}
+
+// sideSlotProps lit /props du moteur local : nombre de slots et fenêtre d'un
+// slot. Remplaçable par les tests.
+var sideSlotProps = func(ep chatEndpoint) (slots, nCtx int, ok bool) {
+	var props struct {
+		TotalSlots int `json:"total_slots"`
+		Default    struct {
+			NCtx int `json:"n_ctx"`
+		} `json:"default_generation_settings"`
+	}
+	iso := slotIsolator{base: fmt.Sprintf("http://localhost:%d", LLMPort()), auth: ep.auth, client: http.DefaultClient}
+	if err := iso.get(context.Background(), "/props", &props); err != nil {
+		return 0, 0, false
+	}
+	return props.TotalSlots, props.Default.NCtx, true
+}
+
+// sideSlotLive : le second slot est-il en service sur le moteur local ? Sans la
+// clé, ni lecture ni requête : faux tout de suite.
+func sideSlotLive(ep chatEndpoint) bool {
+	if ep.External {
+		return false
+	}
+	cfg := ReadConfig()
+	if !sideSlotOn(cfg) || isExternalConfig(cfg) {
+		return false
+	}
+	win := ctxWindow()
+	key := fmt.Sprintf("%d|%d", LLMPort(), win)
+	sideSlotProbe.mu.Lock()
+	defer sideSlotProbe.mu.Unlock()
+	if sideSlotProbe.key == key && time.Since(sideSlotProbe.at) < sideSlotProbeTTL {
+		return sideSlotProbe.live
+	}
+	slots, nCtx, ok := sideSlotProps(ep)
+	if !ok {
+		// Moteur injoignable (relance en cours) : rien de retenu, la prochaine
+		// requête redemande.
+		return false
+	}
+	// llama.cpp arrondit la fenêtre d'un slot au multiple de 256 supérieur.
+	live := slots == 2 && nCtx >= win
+	sideSlotProbe.key, sideSlotProbe.at, sideSlotProbe.live = key, time.Now(), live
+	return live
+}
+
+// engineSlotFor : l'id_slot d'une requête vers ep, -1 = aucun (la requête part
+// telle qu'avant la clé). main : fil de la discussion.
+func engineSlotFor(ep chatEndpoint, main bool) int {
+	if !sideSlotLive(ep) {
+		return -1
+	}
+	if main {
+		return 0
+	}
+	return 1
+}
+
+// slotIsMain : les complétions de cette nature restent sur le slot de la
+// discussion. Toutes les autres (vérification, sous-agent, tâche, bench,
+// résumé) passent par le second.
+func slotIsMain(kind string) bool {
+	return kind == perfMain || kind == perfPrewarm
+}
+
+// setEngineSlot pose id_slot dans payload ; slot < 0 : rien.
+func setEngineSlot(payload map[string]any, slot int) {
+	if slot >= 0 {
+		payload["id_slot"] = slot
+	}
+}
+
+// payloadOnSideSlot : la requête part-elle sur le second slot ? Elle ne touche
+// alors pas au slot de la discussion (engineRequestBeginSide).
+func payloadOnSideSlot(payload map[string]any) bool {
+	s, ok := payload["id_slot"].(int)
+	return ok && s == 1
+}
+
+// sideSlotProxyMaxBody : au-delà, un corps de client /v1 n'est pas réécrit mais
+// refusé — le laisser passer sans id_slot, c'est risquer le slot 0.
+const sideSlotProxyMaxBody = 128 << 20
+
+// sideSlotProxyRewrite pose id_slot 1 dans le corps JSON d'une requête POST
+// /v1/* d'un client externe, quel que soit l'id_slot qu'il demandait : seul
+// Loki parle au slot de la discussion. Sans second slot en service, rien n'est
+// lu ni touché (side=false). Un corps qui n'est pas un objet JSON passe tel
+// quel : le moteur le refusera de lui-même. status != 0 : refuser la requête
+// avec ce code et ce message.
+func sideSlotProxyRewrite(r *http.Request) (side bool, status int, msg string) {
+	if r.Method != http.MethodPost || !strings.HasPrefix(r.URL.Path, "/v1/") || r.Body == nil {
+		return false, 0, ""
+	}
+	if !sideSlotLive(resolveChatEndpoint()) {
+		return false, 0, ""
+	}
+	raw, err := io.ReadAll(io.LimitReader(r.Body, sideSlotProxyMaxBody+1))
+	r.Body.Close()
+	if err != nil {
+		return false, http.StatusBadRequest, "corps illisible : " + err.Error()
+	}
+	if len(raw) > sideSlotProxyMaxBody {
+		return false, http.StatusRequestEntityTooLarge, "corps trop gros pour être routé vers le slot des clients"
+	}
+	var obj map[string]json.RawMessage
+	if json.Unmarshal(raw, &obj) == nil && obj != nil {
+		obj["id_slot"] = json.RawMessage("1")
+		if b, err := json.Marshal(obj); err == nil {
+			raw, side = b, true
+		}
+	}
+	r.Body = io.NopCloser(bytes.NewReader(raw))
+	r.ContentLength = int64(len(raw))
+	r.Header.Set("Content-Length", strconv.Itoa(len(raw)))
+	return side, 0, ""
+}
+
+// reqExceedsCtx : le libellé de llama.cpp pour un prompt plus long que la
+// fenêtre d'un slot.
+var reqExceedsCtx = regexp.MustCompile(`(?i)exceeds the available context size|request \(\d+ tokens\)`)
+
+// sideSlotPoolError : « Context size has been exceeded. » sans le nombre de
+// jetons de la requête n'est pas un prompt trop long, c'est le cache KV qui a
+// manqué de place pendant le calcul. Avec deux slots, ce serait la faute du
+// voisin, pas de la conversation : la compacter ou la tronquer perdrait de
+// l'information pour rien. Avec des flux séparés (--no-kv-unified) ça ne doit
+// pas arriver ; le filet ne joue que si le second slot est en service.
+func sideSlotPoolError(msg string) bool {
+	return strings.Contains(strings.ToLower(msg), "context size has been exceeded") && !reqExceedsCtx.MatchString(msg)
+}

internal/loki/llm_sideslot_test.go

@@ -0,0 +1,230 @@
+package loki
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync"
+	"testing"
+)
+
+// stubSideProps remplace la lecture de /props : slots, fenêtre d'un slot.
+func stubSideProps(t *testing.T, slots, nCtx int) {
+	t.Helper()
+	prev := sideSlotProps
+	sideSlotProps = func(chatEndpoint) (int, int, bool) { return slots, nCtx, true }
+	reset := func() {
+		sideSlotProbe.mu.Lock()
+		sideSlotProbe.key, sideSlotProbe.live = "", false
+		sideSlotProbe.mu.Unlock()
+	}
+	reset()
+	t.Cleanup(func() { sideSlotProps = prev; reset() })
+}
+
+// slotOf : l'id_slot d'un corps de requête ; -1 = absent.
+func slotOf(t *testing.T, body string) int {
+	t.Helper()
+	var p map[string]any
+	if err := json.Unmarshal([]byte(body), &p); err != nil {
+		t.Fatalf("corps illisible : %v", err)
+	}
+	v, ok := p["id_slot"]
+	if !ok {
+		return -1
+	}
+	return int(v.(float64))
+}
+
+// Le tour, une vérification puis un résumé sur transcription : un corps par
+// requête, dans l'ordre.
+func sideSlotScenario(t *testing.T, m *moteurCont) []string {
+	t.Helper()
+	ctx := withPerf(context.Background(), perfMain, convActiveID())
+	if _, err := runChat(ctx, []Message{um("bonjour")}, 0.2, Caps{}, func(StreamEvent) bool { return true }); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := runChat(withPerfKind(ctx, perfVerify), []Message{um("vérifie")}, 0.2, Caps{}, func(StreamEvent) bool { return true }); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := summarizeTranscriptFor(ctx, "user: a\nassistant: b", false); err != nil {
+		t.Fatal(err)
+	}
+	b := m.all()
+	if len(b) != 3 {
+		t.Fatalf("%d requêtes, attendu 3", len(b))
+	}
+	return b
+}
+
+// Sans la clé : aucun id_slot, et /props n'est même pas lu.
+func TestSideSlotRoutageDefaut(t *testing.T) {
+	m := contSetup(t, nil)
+	prev := sideSlotProps
+	sideSlotProps = func(chatEndpoint) (int, int, bool) { t.Fatal("/props lu sans la clé"); return 0, 0, false }
+	t.Cleanup(func() { sideSlotProps = prev })
+	for _, b := range sideSlotScenario(t, m) {
+		if strings.Contains(b, "id_slot") {
+			t.Fatalf("id_slot sans la clé : %s", b)
+		}
+	}
+}
+
+// Avec deux slots en service : le tour sur le 0, la vérification et la
+// transcription sur le 1 — et le slot 0 porte toujours le tour après elles.
+func TestSideSlotRoutage(t *testing.T) {
+	m := contSetup(t, map[string]string{"SIDE_SLOT": "on", "COMPACT_CONTINUATION": "on"})
+	stubSideProps(t, 2, 8192)
+	b := sideSlotScenario(t, m)
+	for i, want := range []int{0, 1, 1} {
+		if got := slotOf(t, b[i]); got != want {
+			t.Errorf("requête %d : id_slot %d, attendu %d", i, got, want)
+		}
+	}
+	if !engineSlotHolds(convActiveID()) {
+		t.Fatal("le slot 0 n'a pas bougé : le tampon du tour doit tenir après le second slot")
+	}
+}
+
+// Un seul slot, une fenêtre trop petite (lancement refusé, PARALLEL=2 seul) ou
+// un preset externe : aucun id_slot.
+func TestSideSlotPasEnService(t *testing.T) {
+	testHome(t)
+	if err := SetConfigKey("SIDE_SLOT", "on"); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetConfigKey("CTX", "8192"); err != nil {
+		t.Fatal(err)
+	}
+	for _, c := range []struct{ slots, nCtx int }{{1, 8192}, {2, 4096}, {4, 8192}} {
+		stubSideProps(t, c.slots, c.nCtx)
+		if s := engineSlotFor(chatEndpoint{}, false); s != -1 {
+			t.Errorf("%d slots de %d : id_slot %d", c.slots, c.nCtx, s)
+		}
+	}
+	stubSideProps(t, 2, 8448) // arrondi de llama.cpp au multiple de 256
+	if engineSlotFor(chatEndpoint{}, true) != 0 || engineSlotFor(chatEndpoint{}, false) != 1 {
+		t.Fatal("deux slots de CTX jetons : routage attendu")
+	}
+	if s := engineSlotFor(chatEndpoint{External: true}, false); s != -1 {
+		t.Fatalf("preset externe : id_slot %d", s)
+	}
+}
+
+func TestSideSlotPoolError(t *testing.T) {
+	for msg, want := range map[string]bool{
+		`{"error":{"code":500,"message":"Context size has been exceeded.","type":"server_error"}}`:                                                               true,
+		`{"error":{"message":"request (40000 tokens) exceeds the available context size (32768 tokens), try increasing it","type":"exceed_context_size_error"}}`: false,
+		`the request exceeds the available context size`:                                                                                                         false,
+		`failed to parse tool call`: false,
+	} {
+		if got := sideSlotPoolError(msg); got != want {
+			t.Errorf("%q : %v", msg, got)
+		}
+	}
+}
+
+// Cache KV plein en plein calcul, deux slots en service : la requête est
+// rejouée telle quelle, sans compaction ni réduction.
+func TestSideSlotPoolErrorRejoue(t *testing.T) {
+	testHome(t)
+	var mu sync.Mutex
+	var bodies []string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		b, _ := io.ReadAll(r.Body)
+		mu.Lock()
+		bodies = append(bodies, string(b))
+		n := len(bodies)
+		mu.Unlock()
+		if n == 1 {
+			sendJSON(w, 500, map[string]any{"error": map[string]any{"message": "Context size has been exceeded."}})
+			return
+		}
+		w.Header().Set("Content-Type", "text/event-stream")
+		_, _ = w.Write([]byte(sseChunk("ok") + sseFinal("stop", 50, 1) + "data: [DONE]\n\n"))
+	}))
+	t.Cleanup(srv.Close)
+	_, port, _ := strings.Cut(strings.TrimPrefix(srv.URL, "http://"), ":")
+	for k, v := range map[string]string{"PORT": port, "SIDE_SLOT": "on", "CTX": "8192"} {
+		if err := SetConfigKey(k, v); err != nil {
+			t.Fatal(err)
+		}
+	}
+	stubSideProps(t, 2, 8192)
+	msgs := []Message{um(strings.Repeat("x", 30000))} // près de la fenêtre : l'estimation crierait au débordement
+	if _, err := runChat(withPerf(context.Background(), perfMain, "c"), msgs, 0.2, Caps{}, func(StreamEvent) bool { return true }); err != nil {
+		t.Fatal(err)
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	if len(bodies) != 2 || bodies[0] != bodies[1] {
+		t.Fatalf("%d requêtes ; rejeu identique attendu", len(bodies))
+	}
+}
+
+// Client /v1 : son corps part avec id_slot 1, quoi qu'il demande. Sans la clé,
+// il passe octet pour octet.
+func TestSideSlotProxyForceLeSecondSlot(t *testing.T) {
+	testHome(t)
+	var got []byte
+	fauxMoteur(t, func(w http.ResponseWriter, r *http.Request) {
+		got, _ = io.ReadAll(r.Body)
+		if r.ContentLength != int64(len(got)) {
+			t.Errorf("Content-Length %d pour %d octets", r.ContentLength, len(got))
+		}
+		sendJSON(w, 200, map[string]any{"ok": true})
+	})
+	in := `{"model":"x","id_slot":0,"seed":12345678901234567890,"messages":[{"role":"user","content":"a"}]}`
+	call := func() {
+		req := httptest.NewRequest(http.MethodPost, "/v1/chat/completions", bytes.NewReader([]byte(in)))
+		rec := httptest.NewRecorder()
+		oaiHandler().ServeHTTP(rec, req)
+		if rec.Code != 200 {
+			t.Fatalf("statut %d : %s", rec.Code, rec.Body.String())
+		}
+	}
+	call()
+	if string(got) != in {
+		t.Fatalf("corps réécrit sans la clé : %s", got)
+	}
+	if err := SetConfigKey("SIDE_SLOT", "on"); err != nil {
+		t.Fatal(err)
+	}
+	stubSideProps(t, 2, 32768)
+	call()
+	if slotOf(t, string(got)) != 1 || !strings.Contains(string(got), "12345678901234567890") {
+		t.Fatalf("corps routé : %s", got)
+	}
+}
+
+// Deux slots de SIDE_SLOT : le préchauffage vise le slot de la discussion.
+// Deux slots sans la clé : toujours rien.
+func TestSideSlotPrewarmSurLeSlot0(t *testing.T) {
+	m := prewarmSetup(t, map[string]string{"PREWARM": "on", "SIDE_SLOT": "on", "CTX": "8192"})
+	c := newTestConv()
+	prewarmNoteCaps(convActiveID(), Caps{Agent: true})
+	c.mu.Lock()
+	c.Messages = []Message{um("bonjour"), am("salut")}
+	c.mu.Unlock()
+	m.mu.Lock()
+	m.slots = 2
+	m.mu.Unlock()
+	stubSideProps(t, 2, 4096) // lancement refusé : fenêtre partagée
+	c.prewarm(prewarmTurnEnd)
+	if n := len(m.completions()); n != 0 {
+		t.Fatalf("%d préchauffage(s) sans second slot en service", n)
+	}
+	stubSideProps(t, 2, 8192)
+	c.prewarm(prewarmTurnEnd)
+	got := m.completions()
+	if len(got) != 1 {
+		t.Fatalf("%d préchauffage(s), attendu 1", len(got))
+	}
+	if s := slotOf(t, got[0]); s != 0 {
+		t.Fatalf("id_slot = %d, attendu 0", s)
+	}
+}

internal/loki/llm_slotpersist.go

@@ -0,0 +1,322 @@
+package loki
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"hash/fnv"
+	"io"
+	"math"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+)
+
+// SLOT_PERSIST, côté process web : garder l'état du slot de la discussion
+// avant une bascule de preset, le recharger au retour (backend_serve_persist.go
+// pour la clé et les refus au lancement).
+//
+// Sauver : seulement si la dernière requête de Loki passée par le slot 0 était
+// une étape d'un tour de la discussion (le tampon d'engineMarkMain) — un
+// vérificateur, une tâche, un titre ou un client /v1 passés depuis, et le slot
+// ne porte plus ce qu'on croit. Ni brouillon spéculatif actif, ni état trop
+// gros (plafond fixe, place libre vérifiée), ni contexte trop court pour valoir
+// une écriture. Le fichier est écrit sous un nom provisoire et ne prend son
+// nom définitif que si aucune requête n'est partie pendant l'écriture.
+//
+// Recharger : avant la première requête de la discussion sur le moteur relancé,
+// et seulement si le fichier porte la clé de CE moteur (même modèle, même
+// build, mêmes réglages — tout ce qui touche au cache) et l'empreinte de CETTE
+// discussion, que le slot 0 n'a encore servi aucune tâche (/slots sans
+// id_task) et qu'aucun brouillon spéculatif n'y tourne. Une seule chance : le
+// fichier est retiré après la tentative, réussie ou non. Toute erreur retombe
+// en silence sur un calcul normal — llama.cpp vide lui-même le slot sur un
+// rechargement raté.
+//
+// Sur un modèle hybride (Qwen3.5/3.6), le fichier n'a pas de points de reprise
+// : il ne sert que si la requête suivante prolonge exactement les jetons
+// gardés, ce qui suppose un gabarit qui rend le dernier tour à l'identique.
+
+// slotPersistMaxBytes : au-delà, l'état n'est pas gardé. Un 27B dense en f16 à
+// 32k jetons pèse 8 Gio ; plus gros, l'écriture et la relecture coûtent autant
+// que le recalcul sur un disque lent.
+const slotPersistMaxBytes = 8 << 30
+
+// slotPersistMinTokens : en dessous, le recalcul est trop court pour valoir une
+// écriture.
+const slotPersistMinTokens = 4096
+
+// Bornes des appels au moteur : écrire ou relire 8 Gio sur un disque lent.
+var (
+	slotPersistSaveTimeout    = 3 * time.Minute
+	slotPersistRestoreTimeout = 2 * time.Minute
+)
+
+// slotPersistName : le fichier d'une discussion sous une clé de moteur.
+func slotPersistName(key, conv string) string {
+	h := fnv.New64a()
+	h.Write([]byte(conv))
+	return fmt.Sprintf("persist-%s-%012x.bin", key, h.Sum64()&0xffffffffffff)
+}
+
+func slotPersistDir() string { return filepath.Join(LokiHome(), "slots") }
+
+func slotPersistLog(format string, args ...any) {
+	fmt.Fprintf(os.Stderr, "[slot] "+format+"\n", args...)
+}
+
+// engineMainConv : la discussion dont le slot porte plausiblement le tour
+// (engineSlotHolds), et le numéro de cette requête ; vide = aucune.
+func engineMainConv() (conv string, seq uint64) {
+	model, window := engineMainNow()
+	engineGate.mu.Lock()
+	defer engineGate.mu.Unlock()
+	m := engineGate.main
+	if m.seq == 0 || m.seq != engineGate.seq || m.model != model || m.window != window {
+		return "", 0
+	}
+	return m.conv, m.seq
+}
+
+// slotPersistSnap : ce qu'une bascule doit savoir du moteur EN SERVICE, relevé
+// avant que la configuration ne change (le modèle et la fenêtre du tampon se
+// lisent dans la configuration).
+type slotPersistSnap struct {
+	conv, key string
+	seq       uint64
+	cfg       map[string]string
+	iso       slotIsolator // port et clé d'API du moteur en service
+}
+
+// slotPersistPrepare : nil = rien à garder (clé absente, moteur sans clé de
+// persistance, slot qui ne porte pas un tour de discussion).
+func slotPersistPrepare() *slotPersistSnap {
+	cfg := ReadConfig()
+	if !slotPersistOn(cfg) || isExternalConfig(cfg) {
+		return nil
+	}
+	key := readSlotPersistMarker(LokiHome())
+	if key == "" {
+		return nil
+	}
+	conv, seq := engineMainConv()
+	if conv == "" {
+		return nil
+	}
+	return &slotPersistSnap{conv: conv, key: key, seq: seq, cfg: cfg, iso: localSlotIsolator(resolveChatEndpoint())}
+}
+
+// slotState : ce que /slots dit du slot 0.
+type slotState struct {
+	found, processing, speculative, used bool
+	tokens                               int
+}
+
+func (s slotIsolator) slot0(ctx context.Context) (slotState, error) {
+	var slots []map[string]json.RawMessage
+	if err := s.get(ctx, "/slots", &slots); err != nil {
+		return slotState{}, err
+	}
+	for _, sl := range slots {
+		var id int
+		if json.Unmarshal(sl["id"], &id) != nil || id != 0 {
+			continue
+		}
+		st := slotState{found: true}
+		_ = json.Unmarshal(sl["is_processing"], &st.processing)
+		_ = json.Unmarshal(sl["speculative"], &st.speculative)
+		_ = json.Unmarshal(sl["n_prompt_tokens"], &st.tokens)
+		_, st.used = sl["id_task"]
+		return st, nil
+	}
+	return slotState{}, nil
+}
+
+// action : POST /slots/0?action=…, borné par timeout. Rend le nombre d'octets
+// écrits ou lus d'après la réponse (0 = non dit).
+func (s slotIsolator) action(ctx context.Context, action, filename string, timeout time.Duration) (int64, error) {
+	ctx, cancel := context.WithTimeout(ctx, timeout)
+	defer cancel()
+	body, _ := json.Marshal(map[string]string{"filename": filename})
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, s.base+"/slots/0?action="+action, bytes.NewReader(body))
+	if err != nil {
+		return 0, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	s.auth(req.Header.Set)
+	resp, err := s.client.Do(req)
+	if err != nil {
+		return 0, err
+	}
+	defer resp.Body.Close()
+	raw, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<16))
+	if resp.StatusCode != http.StatusOK {
+		return 0, fmt.Errorf("%s : %s %s", action, resp.Status, strings.TrimSpace(string(raw[:min(len(raw), 300)])))
+	}
+	var out struct {
+		Written int64 `json:"n_written"`
+		Read    int64 `json:"n_read"`
+	}
+	_ = json.Unmarshal(raw, &out)
+	return max(out.Written, out.Read), nil
+}
+
+func localSlotIsolator(ep chatEndpoint) slotIsolator {
+	return slotIsolator{base: fmt.Sprintf("http://localhost:%d", LLMPort()), auth: ep.auth, client: http.DefaultClient}
+}
+
+// slotPersistSize : slotPersistEstimate, remplaçable par les tests.
+var slotPersistSize = slotPersistEstimate
+
+// slotPersistEstimate : octets de l'état de tokens jetons sous cfg ; 0 =
+// inconnu (et l'état n'est alors pas gardé : on ne borne pas l'inconnu).
+func slotPersistEstimate(cfg map[string]string, tokens int) int64 {
+	p, err := resolveServeModelPath(strings.TrimSpace(cfg["MODEL"]))
+	if err != nil {
+		return 0
+	}
+	g, err := ggufMeta(p)
+	if err != nil {
+		return 0
+	}
+	argEnv := map[string]string{}
+	for _, k := range fidelityArgEnv {
+		if v := os.Getenv(k); v != "" {
+			argEnv[k] = v
+		}
+	}
+	kt, vt, _ := effectiveKVTypes(cfg, splitArgs(cfg["EXTRA_ARGS"]), argEnv)
+	perTok, rec := ggufStateBytes(g, kt, vt)
+	if perTok <= 0 {
+		return 0
+	}
+	return int64(math.Ceil(perTok*float64(tokens))) + rec
+}
+
+// save garde l'état du slot de la discussion, juste avant l'arrêt du moteur.
+// Jamais d'erreur rendue : au pire, rien n'est gardé.
+func (s *slotPersistSnap) save() {
+	if s == nil {
+		return
+	}
+	iso := s.iso
+	ctx := context.Background()
+	st, err := iso.slot0(ctx)
+	switch {
+	case err != nil:
+		slotPersistLog("état non gardé : /slots illisible (%v)", err)
+		return
+	case !st.found || st.processing:
+		return
+	case st.speculative:
+		slotPersistLog("état non gardé : décodage spéculatif actif (le brouillon ne serait pas sauvé)")
+		return
+	case st.tokens < slotPersistMinTokens:
+		return
+	}
+	est := slotPersistSize(s.cfg, st.tokens)
+	if est <= 0 || est > slotPersistMaxBytes {
+		slotPersistLog("état non gardé : %d jetons, taille estimée %d Mio (plafond %d Mio)", st.tokens, est>>20, slotPersistMaxBytes>>20)
+		return
+	}
+	dir := slotPersistDir()
+	if free := diskFree(dir); free < 2*est+(1<<30) {
+		slotPersistLog("état non gardé : place libre insuffisante ou inconnue dans %s", dir)
+		return
+	}
+	name := slotPersistName(s.key, s.conv)
+	tmp := "tmp-" + name
+	end, seq := engineRequestBegin(nil)
+	t0 := time.Now()
+	n, err := iso.action(ctx, "save", tmp, slotPersistSaveTimeout)
+	end()
+	engineGate.mu.Lock()
+	moved := seq != s.seq+1 || engineGate.seq != seq
+	engineGate.mu.Unlock()
+	if err != nil || moved {
+		_ = os.Remove(filepath.Join(dir, tmp))
+		if err != nil {
+			slotPersistLog("état non gardé : %v", err)
+		}
+		return
+	}
+	if err := os.Rename(filepath.Join(dir, tmp), filepath.Join(dir, name)); err != nil {
+		_ = os.Remove(filepath.Join(dir, tmp))
+		slotPersistLog("état non gardé : %v", err)
+		return
+	}
+	slotPersistPrune(dir)
+	slotPersistLog("état de la discussion gardé : %d jetons, %d Mio en %s", st.tokens, n>>20, time.Since(t0).Round(time.Millisecond))
+}
+
+// slotPersistTried : fichiers déjà tentés (nom et date), pour qu'un fichier
+// qu'on n'aurait pas pu retirer ne soit pas relu à chaque requête.
+var slotPersistTried struct {
+	mu sync.Mutex
+	m  map[string]bool
+}
+
+// slotPersistRestore recharge l'état gardé de conv dans le slot 0, si tout
+// concorde. Appelée juste avant une requête de la discussion vers le moteur
+// local ; sans la clé, une lecture de configuration et rien d'autre.
+func slotPersistRestore(ep chatEndpoint, conv string) {
+	if ep.External || conv == "" {
+		return
+	}
+	cfg := ReadConfig()
+	if !slotPersistOn(cfg) || isExternalConfig(cfg) {
+		return
+	}
+	key := readSlotPersistMarker(LokiHome())
+	if key == "" {
+		return
+	}
+	name := slotPersistName(key, conv)
+	path := filepath.Join(slotPersistDir(), name)
+	fi, err := os.Stat(path)
+	if err != nil {
+		return
+	}
+	// Un fichier, une tentative : le même nom réécrit par une bascule suivante
+	// (A→B→A→B→A) est un autre fichier.
+	once := fmt.Sprintf("%s|%d", name, fi.ModTime().UnixNano())
+	iso := localSlotIsolator(ep)
+	ctx := context.Background()
+	st, err := iso.slot0(ctx)
+	if err != nil || !st.found {
+		return // moteur pas encore prêt : la requête suivante retentera
+	}
+	slotPersistTried.mu.Lock()
+	if slotPersistTried.m == nil {
+		slotPersistTried.m = map[string]bool{}
+	}
+	tried := slotPersistTried.m[once]
+	slotPersistTried.m[once] = true
+	slotPersistTried.mu.Unlock()
+	if tried {
+		return
+	}
+	// Une seule chance, quoi qu'il arrive.
+	defer os.Remove(path)
+	switch {
+	case st.used || st.processing:
+		slotPersistLog("état gardé ignoré : le slot a déjà servi depuis le lancement")
+		return
+	case st.speculative:
+		slotPersistLog("état gardé ignoré : décodage spéculatif actif")
+		return
+	}
+	end, _ := engineRequestBegin(nil)
+	t0 := time.Now()
+	n, err := iso.action(ctx, "restore", name, slotPersistRestoreTimeout)
+	end()
+	if err != nil {
+		slotPersistLog("état gardé non rechargé, calcul normal : %v", err)
+		return
+	}
+	slotPersistLog("état de la discussion rechargé : %d Mio en %s", n>>20, time.Since(t0).Round(time.Millisecond))
+}

internal/loki/llm_slotpersist_test.go

@@ -0,0 +1,442 @@
+package loki
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+)
+
+// persistSI : moteur qui connaît --slot-save-path, dossier prêt, boucle locale.
+func persistSI() serveSysInfo {
+	si := denseGPU()
+	si.SlotDir = "/data/slots"
+	return si
+}
+
+func TestSlotPersistPlan(t *testing.T) {
+	loop := map[string]string{"SLOT_PERSIST": "on", "HOST": "127.0.0.1"}
+	with := func(kv ...string) map[string]string {
+		m := map[string]string{}
+		for k, v := range loop {
+			m[k] = v
+		}
+		for i := 0; i+1 < len(kv); i += 2 {
+			m[kv[i]] = kv[i+1]
+		}
+		return m
+	}
+	cases := []struct {
+		name  string
+		cfg   map[string]string
+		extra []string
+		si    func(*serveSysInfo)
+		ok    bool
+		why   string
+	}{
+		{name: "clé absente", cfg: map[string]string{"HOST": "127.0.0.1"}},
+		{name: "boucle locale", cfg: loop, ok: true},
+		{name: "0.0.0.0 avec clé d'API", cfg: with("HOST", "0.0.0.0"), si: func(s *serveSysInfo) { s.APIKey = "k" }, ok: true},
+		{name: "0.0.0.0 sans clé", cfg: with("HOST", ""), why: "sans clé"},
+		{name: "SPEC=auto", cfg: with("SPEC", "auto"), why: "spéculatif"},
+		{name: "brouillon dans EXTRA_ARGS", cfg: loop, extra: []string{"-md", "d.gguf"}, why: "spéculatif"},
+		{name: "--slot-save-path à la main", cfg: loop, extra: []string{"--slot-save-path", "/x"}, why: "à la main"},
+		{name: "variable LLAMA_ARG_SLOT_SAVE_PATH", cfg: loop, si: func(s *serveSysInfo) { s.ArgEnv["LLAMA_ARG_SLOT_SAVE_PATH"] = "/x" }, why: "à la main"},
+		{name: "experts sur CPU", cfg: loop, extra: []string{"--n-cpu-moe", "30"}, why: "CPU"},
+		{name: "moteur sans le drapeau", cfg: loop, si: func(s *serveSysInfo) { s.Help = helpRecent }, why: "--slot-save-path"},
+		{name: "dossier indisponible", cfg: loop, si: func(s *serveSysInfo) { s.SlotDir = "" }, why: "dossier"},
+		{name: "preset externe", cfg: with(extKeyFlag, "1"), why: "externe"},
+	}
+	for _, c := range cases {
+		si := persistSI()
+		if c.si != nil {
+			c.si(&si)
+		}
+		ok, why := slotPersistPlan(c.cfg, c.extra, si)
+		if ok != c.ok || !strings.Contains(why, c.why) {
+			t.Errorf("%s : ok=%v why=%q", c.name, ok, why)
+		}
+	}
+}
+
+// --slot-save-path : posé pour SLOT_PERSIST même quand l'isolation n'en veut
+// pas (cache coupé) ; sans la clé, la règle du lot 1 inchangée.
+func TestSlotPersistSlotSaveArgs(t *testing.T) {
+	si := serveSysInfo{Help: helpCacheRAM, SlotDir: "/data/slots", ArgEnv: map[string]string{}}
+	base := map[string]string{"HOST": "127.0.0.1", "CACHE_RAM": "0"}
+	if got := slotSaveArgs(base, nil, si); got != nil {
+		t.Fatalf("sans la clé : %v", got)
+	}
+	on := map[string]string{"HOST": "127.0.0.1", "CACHE_RAM": "0", "SLOT_PERSIST": "on"}
+	if got := slotSaveArgs(on, nil, si); !reflect.DeepEqual(got, []string{"--slot-save-path", "/data/slots"}) {
+		t.Fatalf("avec la clé : %v", got)
+	}
+	open := map[string]string{"CACHE_RAM": "0", "SLOT_PERSIST": "on"}
+	if got := slotSaveArgs(open, nil, si); got != nil {
+		t.Fatalf("0.0.0.0 sans clé : %v", got)
+	}
+}
+
+// Refus : la ligne est celle sans la clé, une note de plus.
+func TestSlotPersistRefusLigneInchangee(t *testing.T) {
+	si := persistSI()
+	cfg := map[string]string{"CTX": "32768", "SPEC": "auto"}
+	want, _, wantNotes := buildServeArgs(cfg, nil, "/bin/llama-server", si)
+	cfg["SLOT_PERSIST"] = "on"
+	got, _, notes := buildServeArgs(cfg, nil, "/bin/llama-server", si)
+	if !reflect.DeepEqual(got, want) || len(notes) != len(wantNotes)+1 {
+		t.Fatalf("refus :\n%v\n%v\n%q", got, want, notes)
+	}
+}
+
+func TestSlotPersistKey(t *testing.T) {
+	dir := t.TempDir()
+	bin := filepath.Join(dir, "llama-server")
+	lib := filepath.Join(dir, "libggml-cuda.so")
+	model := filepath.Join(dir, "m.gguf")
+	for _, p := range []string{bin, lib, model} {
+		if err := os.WriteFile(p, []byte("x"), 0o600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	si := serveSysInfo{Model: model}
+	args := []string{bin, "-m", model, "-c", "32768", "--api-key", "secret"}
+	k0 := slotPersistKey(args, nil, si, bin)
+	if len(k0) != 16 || k0 != slotPersistKey(args, nil, si, bin) {
+		t.Fatalf("clé instable : %q", k0)
+	}
+	if slotPersistKey([]string{bin, "-m", model, "-c", "32768", "--api-key", "autre"}, nil, si, bin) != k0 {
+		t.Fatal("la clé d'API ne doit pas entrer dans l'empreinte")
+	}
+	if slotPersistKey([]string{bin, "-m", model, "-c", "65536"}, nil, si, bin) == k0 {
+		t.Fatal("CTX ignoré")
+	}
+	if slotPersistKey(args, map[string]string{"GGML_CUDA_GRAPH_OPT": "1"}, si, bin) == k0 {
+		t.Fatal("environnement ignoré")
+	}
+	later := time.Now().Add(time.Hour)
+	for _, p := range []string{lib, model, bin} {
+		if err := os.Chtimes(p, later, later); err != nil {
+			t.Fatal(err)
+		}
+		k := slotPersistKey(args, nil, si, bin)
+		if k == k0 {
+			t.Fatalf("%s modifié, clé inchangée", filepath.Base(p))
+		}
+		k0 = k
+	}
+}
+
+func TestSlotPersistFichiers(t *testing.T) {
+	home := t.TempDir()
+	dir := prepareSlotDir(home, true)
+	names := []string{"persist-0123456789abcdef-000000000001.bin", "persist-0123456789abcdef-000000000002.bin",
+		"persist-fedcba9876543210-000000000003.bin"}
+	for i, n := range append(append([]string{}, names...), "tmp-"+names[0], "autre.bin") {
+		p := filepath.Join(dir, n)
+		if err := os.WriteFile(p, []byte("x"), 0o600); err != nil {
+			t.Fatal(err)
+		}
+		at := time.Now().Add(time.Duration(i) * time.Minute)
+		_ = os.Chtimes(p, at, at)
+	}
+	prepareSlotDir(home, true)
+	slotPersistPrune(dir)
+	left, _ := os.ReadDir(dir)
+	var got []string
+	for _, e := range left {
+		got = append(got, e.Name())
+	}
+	if !reflect.DeepEqual(got, names[1:]) {
+		t.Fatalf("restent %v, attendu les deux plus récents %v", got, names[1:])
+	}
+	prepareSlotDir(home, false)
+	if left, _ := os.ReadDir(dir); len(left) != 0 {
+		t.Fatalf("clé retirée : %d fichier(s) gardé(s)", len(left))
+	}
+	if readSlotPersistMarker(home) != "" {
+		t.Fatal("marqueur absent : clé vide attendue")
+	}
+	writeSlotPersistMarker(home, "0123456789abcdef")
+	if readSlotPersistMarker(home) != "0123456789abcdef" {
+		t.Fatal("marqueur illisible")
+	}
+	writeSlotPersistMarker(home, "")
+	if readSlotPersistMarker(home) != "" {
+		t.Fatal("marqueur non retiré")
+	}
+}
+
+// moteurSlots : faux llama-server pour /slots, save et restore. Un save écrit
+// le fichier dans le dossier des slots, comme le vrai.
+type moteurSlots struct {
+	mu          sync.Mutex
+	actions     []string
+	used, spec  bool
+	restoreFail bool
+	tokens      int
+}
+
+func (m *moteurSlots) start(t *testing.T, home string) {
+	t.Helper()
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		m.mu.Lock()
+		defer m.mu.Unlock()
+		switch {
+		case r.URL.Path == "/slots" && r.Method == http.MethodGet:
+			s := map[string]any{"id": 0, "is_processing": false, "speculative": m.spec, "n_prompt_tokens": m.tokens}
+			if m.used {
+				s["id_task"] = 7
+			}
+			sendJSON(w, 200, []any{s})
+		case r.URL.Path == "/slots/0" && r.Method == http.MethodPost:
+			var body struct {
+				Filename string `json:"filename"`
+			}
+			b, _ := io.ReadAll(r.Body)
+			_ = json.Unmarshal(b, &body)
+			act := r.URL.Query().Get("action")
+			m.actions = append(m.actions, act+" "+body.Filename)
+			if act == "save" {
+				_ = os.WriteFile(filepath.Join(home, "slots", body.Filename), []byte("kv"), 0o600)
+				sendJSON(w, 200, map[string]any{"n_saved": m.tokens, "n_written": 2 << 20})
+				return
+			}
+			if m.restoreFail {
+				sendJSON(w, 400, map[string]any{"error": map[string]any{"message": "Unable to restore slot"}})
+				return
+			}
+			sendJSON(w, 200, map[string]any{"n_restored": m.tokens, "n_read": 2 << 20})
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	t.Cleanup(srv.Close)
+	_, port, _ := strings.Cut(strings.TrimPrefix(srv.URL, "http://"), ":")
+	if err := SetConfigKey("PORT", port); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func (m *moteurSlots) got() []string {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	return append([]string(nil), m.actions...)
+}
+
+const persistTestKey = "0123456789abcdef"
+
+// persistSetup : discussion « c1 » dont le tour vient de passer par le slot.
+func persistSetup(t *testing.T, on bool) (*moteurSlots, string) {
+	t.Helper()
+	home := testHome(t)
+	if err := os.MkdirAll(filepath.Join(home, "slots"), 0o700); err != nil {
+		t.Fatal(err)
+	}
+	for k, v := range map[string]string{"MODEL": "m.gguf", "CTX": "32768"} {
+		if err := SetConfigKey(k, v); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if on {
+		if err := SetConfigKey("SLOT_PERSIST", "on"); err != nil {
+			t.Fatal(err)
+		}
+	}
+	writeSlotPersistMarker(home, persistTestKey)
+	prev := slotPersistSize
+	slotPersistSize = func(map[string]string, int) int64 { return 1 << 20 }
+	reset := func() {
+		engineGate.mu.Lock()
+		engineGate.main = engineMainStamp{}
+		engineGate.mu.Unlock()
+	}
+	reset()
+	t.Cleanup(func() { slotPersistSize = prev; reset() })
+	m := &moteurSlots{tokens: 20000}
+	m.start(t, home)
+	end, seq := engineRequestBegin(nil)
+	end()
+	engineMarkMain(seq, "c1")
+	return m, home
+}
+
+// Bascule puis retour : gardé sous la clé du moteur, rechargé une fois avant
+// la première requête de la discussion, puis retiré.
+func TestSlotPersistSauveEtRecharge(t *testing.T) {
+	m, home := persistSetup(t, true)
+	snap := slotPersistPrepare()
+	if snap == nil {
+		t.Fatal("rien à garder")
+	}
+	snap.save()
+	name := slotPersistName(persistTestKey, "c1")
+	path := filepath.Join(home, "slots", name)
+	if _, err := os.Stat(path); err != nil {
+		t.Fatalf("état non gardé : %v (%v)", err, m.got())
+	}
+	if _, err := os.Stat(filepath.Join(home, "slots", "tmp-"+name)); !os.IsNotExist(err) {
+		t.Fatal("fichier provisoire resté")
+	}
+	ep := resolveChatEndpoint()
+	slotPersistRestore(ep, "autre") // autre discussion : rien
+	slotPersistRestore(ep, "c1")
+	slotPersistRestore(ep, "c1") // une seule fois
+	want := []string{"save tmp-" + name, "restore " + name}
+	if got := m.got(); !reflect.DeepEqual(got, want) {
+		t.Fatalf("appels %v, attendu %v", got, want)
+	}
+	if _, err := os.Stat(path); !os.IsNotExist(err) {
+		t.Fatal("fichier gardé après la tentative")
+	}
+}
+
+// Sans la clé : ni relevé, ni appel au moteur.
+func TestSlotPersistDefautRien(t *testing.T) {
+	m, home := persistSetup(t, false)
+	if snap := slotPersistPrepare(); snap != nil {
+		t.Fatal("relevé sans la clé")
+	}
+	var snap *slotPersistSnap
+	snap.save()
+	name := slotPersistName(persistTestKey, "c1")
+	if err := os.WriteFile(filepath.Join(home, "slots", name), []byte("x"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	slotPersistRestore(resolveChatEndpoint(), "c1")
+	if got := m.got(); len(got) != 0 {
+		t.Fatalf("appels sans la clé : %v", got)
+	}
+}
+
+// Rien n'est gardé si le slot ne porte plus le tour, si un brouillon tourne,
+// si l'état est trop court ou trop gros, ou si une requête part pendant
+// l'écriture.
+func TestSlotPersistSauvegardeRefusee(t *testing.T) {
+	m, home := persistSetup(t, true)
+	end := engineRequestStart() // une autre requête est passée par le slot
+	end()
+	if slotPersistPrepare() != nil {
+		t.Fatal("relevé alors que le slot ne porte plus le tour")
+	}
+	for _, c := range []struct {
+		name string
+		set  func()
+	}{
+		{"brouillon spéculatif", func() { m.spec = true }},
+		{"contexte court", func() { m.tokens = 100 }},
+		{"état trop gros", func() { slotPersistSize = func(map[string]string, int) int64 { return slotPersistMaxBytes + 1 } }},
+	} {
+		m.mu.Lock()
+		m.spec, m.tokens = false, 20000
+		m.mu.Unlock()
+		slotPersistSize = func(map[string]string, int) int64 { return 1 << 20 }
+		e, seq := engineRequestBegin(nil)
+		e()
+		engineMarkMain(seq, "c1")
+		snap := slotPersistPrepare()
+		m.mu.Lock()
+		c.set()
+		m.mu.Unlock()
+		snap.save()
+		if got := m.got(); len(got) != 0 {
+			t.Fatalf("%s : appels %v", c.name, got)
+		}
+	}
+	// Une requête entre le relevé et l'écriture : fichier jeté.
+	slotPersistSize = func(map[string]string, int) int64 { return 1 << 20 }
+	m.mu.Lock()
+	m.spec, m.tokens = false, 20000
+	m.mu.Unlock()
+	e, seq := engineRequestBegin(nil)
+	e()
+	engineMarkMain(seq, "c1")
+	snap := slotPersistPrepare()
+	e2 := engineRequestStart()
+	e2()
+	snap.save()
+	left, _ := os.ReadDir(filepath.Join(home, "slots"))
+	if len(left) != 0 {
+		t.Fatalf("fichier gardé malgré une requête pendant l'écriture : %v", left[0].Name())
+	}
+}
+
+// Rechargement refusé (slot déjà servi, brouillon) ou raté : calcul normal,
+// fichier retiré, aucune erreur.
+func TestSlotPersistRechargementPrudent(t *testing.T) {
+	for _, c := range []struct {
+		name    string
+		set     func(*moteurSlots)
+		restore bool
+	}{
+		{"slot déjà servi", func(m *moteurSlots) { m.used = true }, false},
+		{"brouillon spéculatif", func(m *moteurSlots) { m.spec = true }, false},
+		{"échec du moteur", func(m *moteurSlots) { m.restoreFail = true }, true},
+	} {
+		t.Run(c.name, func(t *testing.T) {
+			m, home := persistSetup(t, true)
+			name := slotPersistName(persistTestKey, "c1")
+			path := filepath.Join(home, "slots", name)
+			if err := os.WriteFile(path, []byte("x"), 0o600); err != nil {
+				t.Fatal(err)
+			}
+			c.set(m)
+			slotPersistRestore(resolveChatEndpoint(), "c1")
+			if got := m.got(); (len(got) == 1) != c.restore {
+				t.Fatalf("appels %v", got)
+			}
+			if _, err := os.Stat(path); !os.IsNotExist(err) {
+				t.Fatal("fichier gardé après la tentative")
+			}
+		})
+	}
+}
+
+// Clé du moteur différente (autre build, autres réglages) : le fichier n'est
+// même pas cherché.
+func TestSlotPersistAutreMoteur(t *testing.T) {
+	m, home := persistSetup(t, true)
+	name := slotPersistName(persistTestKey, "c1")
+	if err := os.WriteFile(filepath.Join(home, "slots", name), []byte("x"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	writeSlotPersistMarker(home, "fedcba9876543210")
+	slotPersistRestore(resolveChatEndpoint(), "c1")
+	if got := m.got(); len(got) != 0 {
+		t.Fatalf("rechargé sous une autre clé : %v", got)
+	}
+}
+
+// SLOT_PERSIST survit à la bascule (A → B sans la clé → A) : sans ça, le
+// lancement de B effacerait l'état gardé de A. Un preset qui la pose gagne.
+func TestSlotPersistSurvitALaBascule(t *testing.T) {
+	home := testHome(t)
+	setConfig(t, "MODEL=a.gguf\nSLOT_PERSIST=on\n")
+	b := filepath.Join(home, "b.env")
+	if err := os.WriteFile(b, []byte("MODEL=b.gguf\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if err := applyPresetFile(b); err != nil {
+		t.Fatal(err)
+	}
+	if got := ReadConfig()["SLOT_PERSIST"]; got != "on" {
+		t.Fatalf("SLOT_PERSIST = %q après bascule", got)
+	}
+	c := filepath.Join(home, "c.env")
+	if err := os.WriteFile(c, []byte("MODEL=c.gguf\nSLOT_PERSIST=off\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if err := applyPresetFile(c); err != nil {
+		t.Fatal(err)
+	}
+	if got := ReadConfig()["SLOT_PERSIST"]; got != "off" {
+		t.Fatalf("le preset qui pose la clé doit gagner : %q", got)
+	}
+}

internal/loki/llm_slots.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"net/http"
 	"os"
+	"path/filepath"
 	"regexp"
 	"strconv"
 	"strings"
@@ -46,6 +47,12 @@ import (
 //     repos d'après /slots ;
 //   - appel synchrone, borné à 2 s, sous le verrou du compteur : aucune
 //     requête de Loki ne peut partir entre la vérification et l'effacement.
+//
+// Avec SIDE_SLOT (deux slots, llm_sideslot.go), rien n'est jamais effacé : le
+// garde-fou du slot unique s'abstient, et les travaux annexes ne passent de
+// toute façon plus par le slot de la discussion. Pour la même raison, leurs
+// requêtes n'avancent pas le numéro qui dit si le slot 0 porte encore le tour
+// (engineSlotHolds) : COMPACT_CONTINUATION reste possible après eux.
 
 // slotEraseMinBuild : premier build de llama.cpp qui recharge un slot vide
 // depuis le cache de prompts (PR #20993, 50e0ad08fb).
@@ -58,6 +65,57 @@ var engineGate struct {
 	mu       sync.Mutex
 	inflight int
 	served   uint64 // réponses 200 du moteur obtenues par runChat ou le bench
+	// seq numérote les requêtes de Loki vers le moteur local, préchauffage
+	// compris. main : la dernière, quand c'était une étape d'un tour de
+	// discussion acceptée par le moteur — le slot porte alors, selon toute
+	// vraisemblance, le prompt de cette discussion (COMPACT_CONTINUATION).
+	seq  uint64
+	main engineMainStamp
+}
+
+// engineMainStamp : la requête d'un tour de discussion que le slot porte.
+// Modèle et fenêtre en font partie : un moteur relancé sur un autre modèle ou
+// une autre fenêtre a un slot vide.
+type engineMainStamp struct {
+	seq         uint64
+	conv, model string
+	window      int
+}
+
+// engineMainNow : modèle et fenêtre du moteur, pour le tampon.
+func engineMainNow() (model string, window int) {
+	return filepath.Base(strings.TrimSpace(ReadConfig()["MODEL"])), ctxWindow()
+}
+
+// engineMarkMain : la requête seq, étape d'un tour de la discussion conv, a été
+// acceptée par le moteur. Sans effet si une autre requête est partie depuis.
+func engineMarkMain(seq uint64, conv string) {
+	if conv == "" {
+		return
+	}
+	model, window := engineMainNow()
+	engineGate.mu.Lock()
+	defer engineGate.mu.Unlock()
+	if engineGate.seq == seq {
+		engineGate.main = engineMainStamp{seq: seq, conv: conv, model: model, window: window}
+	}
+}
+
+// engineSlotHolds : le slot porte-t-il plausiblement le prompt de conv ? Oui si
+// la dernière requête de Loki vers le moteur était une étape d'un de ses tours,
+// acceptée, sur le même modèle et la même fenêtre. Un vérificateur, un
+// sous-agent, une tâche, un préchauffage, un résumé, un bench, un client /v1 ou
+// une autre discussion passés depuis : non. Un client qui parlerait au moteur
+// sans passer par Loki échappe à ce compte — au pire, un recalcul.
+func engineSlotHolds(conv string) bool {
+	if conv == "" {
+		return false
+	}
+	model, window := engineMainNow()
+	engineGate.mu.Lock()
+	defer engineGate.mu.Unlock()
+	m := engineGate.main
+	return m.seq != 0 && m.seq == engineGate.seq && m.conv == conv && m.model == model && m.window == window
 }
 
 // engineServed note qu'une requête de Loki a été acceptée par le moteur local :
@@ -82,10 +140,40 @@ var sideJobs atomic.Int32
 
 // engineRequestStart marque une requête vers le moteur local ; la fonction
 // rendue la clôt (une seule fois, quel que soit le nombre d'appels), une fois
-// le corps de la réponse lu.
-func engineRequestStart() func() {
+// le corps de la réponse lu. Un préchauffage en vol (PREWARM, chat_prewarm.go)
+// est annulé d'abord : il ne passe jamais devant un vrai travail.
+func engineRequestStart() func() { return engineRequestStartKeep(nil) }
+
+// engineRequestStartKeep : engineRequestStart, sauf pour le préchauffage en vol
+// que keep reconnaît comme le début exact de cette requête — il continue, et la
+// requête le suit dans le même slot sur le préfixe qu'il vient de calculer.
+// Décidé sous le verrou du compteur : aucun préchauffage ne peut démarrer entre
+// la décision et le compte.
+func engineRequestStartKeep(keep func(*prewarmRun) bool) func() {
+	end, _ := engineRequestBegin(keep)
+	return end
+}
+
+// engineRequestBegin : engineRequestStartKeep, avec le numéro de la requête
+// (engineMarkMain).
+func engineRequestBegin(keep func(*prewarmRun) bool) (func(), uint64) {
+	return engineRequestBeginSide(keep, false)
+}
+
+// engineRequestBeginSide : engineRequestBegin pour une requête qui part, si
+// side, sur le second slot de SIDE_SLOT (id_slot 1). Elle ne touche pas au slot
+// de la discussion : le numéro n'avance pas, et engineSlotHolds dit toujours
+// vrai après elle. Comptée en vol comme les autres.
+func engineRequestBeginSide(keep func(*prewarmRun) bool, side bool) (func(), uint64) {
 	engineGate.mu.Lock()
+	if p := prewarmCur; p != nil && (keep == nil || !keep(p)) {
+		prewarmDropLocked(p)
+	}
 	engineGate.inflight++
+	if !side {
+		engineGate.seq++
+	}
+	seq := engineGate.seq
 	engineGate.mu.Unlock()
 	var once sync.Once
 	return func() {
@@ -94,7 +182,23 @@ func engineRequestStart() func() {
 			engineGate.inflight--
 			engineGate.mu.Unlock()
 		})
+	}, seq
+}
+
+// engineProxyBegin : engineRequestBeginSide pour une requête d'un client passée
+// par les proxys de Loki (/v1, /health, /props, /metrics, /slots). Comptée en
+// vol dans tous les cas, comme avant. Une lecture (GET, HEAD : /v1/models, une
+// sonde /health d'Open WebUI…) ne calcule rien dans aucun slot : elle ne doit
+// ni annuler un préchauffage (PREWARM), ni dire que le slot ne porte plus la
+// discussion (COMPACT_CONTINUATION, SLOT_PERSIST). Sans ces clés, aucune
+// différence.
+func engineProxyBegin(r *http.Request, side bool) func() {
+	if r.Method == http.MethodGet || r.Method == http.MethodHead {
+		end, _ := engineRequestBeginSide(func(*prewarmRun) bool { return true }, true)
+		return end
 	}
+	end, _ := engineRequestBeginSide(nil, side)
+	return end
 }
 
 // slotsWrite : une action sur /slots (save, restore, erase) plutôt qu'une

internal/loki/mem_index.go

@@ -33,20 +33,42 @@ const memIndexPrefix = "Project memory index"
 // proactif ou si l'index est vide. On n'injecte que l'INDEX (titres + accroches),
 // jamais le contenu des pages — l'IA fait mem_read pour lire une page.
 func memIndexMessage() (Message, bool) {
-	if memMode() != MemAlways {
+	idx, ok := memIndexText()
+	if !ok {
 		return Message{}, false
 	}
+	return renderMemIndex(idx, ""), true
+}
+
+// memIndexText lit l'index à injecter : ok=false hors mode mémoire proactif ou
+// sans aucune page. Séparé du rendu pour que le bloc figé (chat_projsnap.go)
+// déduise son état de la MÊME lecture que le texte qu'il envoie.
+func memIndexText() (string, bool) {
+	if memMode() != MemAlways {
+		return "", false
+	}
 	idx := strings.TrimSpace(MemContent(memIndexFile))
 	// Un index qui n'a que son en-tête ne dit rien au modèle et coûte du contexte
 	// à chaque tour : on attend au moins une VRAIE ligne de page. Le test est fait
 	// sur le début de ligne, parce que l'en-tête cite le format `- [titre](…)` en
 	// exemple — une simple recherche du motif le prendrait pour une page.
 	if idx == "" || !hasIndexedPage(idx) {
-		return Message{}, false
+		return "", false
 	}
-	content := memIndexPrefix + " for project \"" + projectName(activeProjectSlug()) +
-		"\" — the pages you can open with mem_read (only titles/hooks here, not their content). Auto-maintained.\n\n" + idx
-	return Message{Role: "system", Content: content}, true
+	return idx, true
+}
+
+// renderMemIndex : le message d'index. asOf vide = la forme vivante, à jour à
+// chaque tour (texte d'avant PROJ_SNAPSHOT, à l'octet près) ; sinon la copie
+// figée, datée, que les <context_update> de Loki complètent ensuite.
+func renderMemIndex(idx, asOf string) Message {
+	head := memIndexPrefix + " for project \"" + projectName(activeProjectSlug()) + "\""
+	tail := " — the pages you can open with mem_read (only titles/hooks here, not their content). Auto-maintained."
+	if asOf != "" {
+		head += " as of " + asOf
+		tail += memIndexFrozenTail
+	}
+	return Message{Role: "system", Content: head + tail + "\n\n" + idx}
 }
 
 // projectContextPrefix marque le message de contexte projet injecté (description),
@@ -59,14 +81,18 @@ const projectContextPrefix = "Project context"
 // dans quel projet elle est via l'index mémoire, sans laïus. Indépendant du mode
 // mémoire — une description reste utile même mémoire coupée.
 func projectContextMessage() (Message, bool) {
-	slug := activeProjectSlug()
-	desc := strings.TrimSpace(projectDesc(slug))
+	desc := strings.TrimSpace(projectDesc(activeProjectSlug()))
 	if desc == "" {
 		return Message{}, false
 	}
+	return renderProjectContext(desc), true
+}
+
+// renderProjectContext : le message de description, pour une description non vide.
+func renderProjectContext(desc string) Message {
 	content := projectContextPrefix + " — you are working within the project \"" +
-		projectName(slug) + "\". What this project is about (set by the user):\n\n" + desc
-	return Message{Role: "system", Content: content}, true
+		projectName(activeProjectSlug()) + "\". What this project is about (set by the user):\n\n" + desc
+	return Message{Role: "system", Content: content}
 }
 
 // projectSystemMessages renvoie, dans l'ordre, tout ce qui situe l'IA dans son
@@ -82,7 +108,8 @@ func projectContextMessage() (Message, bool) {
 //
 // Le prix est une invalidation du cache de prompt quand l'index change, c'est-à-
 // dire quand une page est créée ou supprimée : exactement les moments où le
-// modèle DOIT voir la nouvelle liste.
+// modèle DOIT voir la nouvelle liste. PROJ_SNAPSHOT=on (chat_projsnap.go) évite
+// ce prix pour la discussion : bloc figé, changements livrés en <context_update>.
 func projectSystemMessages() []Message {
 	var out []Message
 	if m, ok := projectContextMessage(); ok {

internal/loki/mem_migrate.go

@@ -259,52 +259,158 @@ func DisableMemEncryption() error {
 	// page, et on ne baisse le drapeau qu'à la toute fin. Ainsi une interruption
 	// laisse un état parfaitement lisible et RE-JOUABLE (le drapeau est encore
 	// levé, donc DisableMemEncryption peut être relancé).
-	if err := decryptAllPages(); err != nil {
+	return finishDecryption()
+}
+
+// finishDecryption : fichiers (pages, images des conversations), puis
+// conversations, puis retrait de la clé, dans cet ordre et seulement si tout ce
+// qui précède a réussi. Sûr à rejouer. Partagé avec la reprise au démarrage, qui
+// retirait la clé après les seules pages : les conversations restaient
+// chiffrées sans plus aucun moyen de les rouvrir (amont cac0cda).
+func finishDecryption() error {
+	bad, err := decryptAllPagesSkipping()
+	if err != nil {
 		return err
 	}
-	if err := decryptChatStores(); err != nil {
+	badKV, err := decryptChatStoresSkipping()
+	if err != nil {
 		return err
 	}
-	// Toutes les pages sont en clair et vérifiées : on peut baisser le drapeau,
-	// retirer le keyvault et purger la DEK.
+	bad = append(bad, badKV...)
+	if len(bad) > 0 {
+		// Valeurs illisibles avec la clé actuelle : déjà inaccessibles avant ce
+		// déchiffrement. On les met en quarantaine (toujours chiffrées) avec une
+		// copie du keyvault, pour pouvoir encore les rouvrir plus tard, puis on
+		// les retire de la base pour que le reste fonctionne en clair.
+		if err := quarantineUnreadable(bad); err != nil {
+			return fmt.Errorf("mise en quarantaine des valeurs illisibles impossible, déchiffrement interrompu (rien n'est perdu, il peut être relancé) : %w", err)
+		}
+		for _, u := range bad {
+			if u.Bucket != "fichier" { // un fichier reste en place, sa copie est en quarantaine
+				_ = putBytes(u.Bucket, u.Key, nil)
+			}
+		}
+	}
+	// Tout est en clair et vérifié : on peut baisser le drapeau, retirer le
+	// keyvault et purger la DEK.
 	if err := SetConfigKey("MEM_ENCRYPTED", ""); err != nil {
 		return err
 	}
 	removeVault()
 	clearMemDEK()
 	clearMigrationJournal()
+	if n := scrubEncryptedResidue(); n > 0 {
+		fmt.Fprintf(os.Stderr, "[mémoire] %d copie(s) .bak chiffrée(s), illisibles sans la clé, retirée(s)\n", n)
+	}
 	return nil
 }
 
-// decryptAllPages réécrit en clair toutes les pages encore chiffrées, DANS TOUS LES
-// PROJETS, en vérifiant chacune. Exige la DEK en RAM. Sûr à rejouer (idempotent).
-func decryptAllPages() error {
-	for _, p := range allMemPageFiles() {
+// decryptAllPagesSkipping réécrit en clair tous les fichiers encore chiffrés de
+// la mémoire (tous projets) et des images de conversation, en vérifiant chacun.
+// Exige la DEK en RAM. Sûr à rejouer. Un fichier indéchiffrable est laissé tel
+// quel et renvoyé au lieu de tout arrêter.
+func decryptAllPagesSkipping() ([]unreadableValue, error) {
+	var bad []unreadableValue
+	for _, p := range allMemFilesForDecrypt() {
 		raw, err := os.ReadFile(p)
 		if err != nil {
-			return fmt.Errorf("lecture %s : %w", p, err)
+			return bad, fmt.Errorf("lecture %s : %w", p, err)
 		}
 		if !looksEncrypted(raw) {
 			continue // déjà en clair
 		}
 		plain, err := decodeMemContent(raw)
 		if err != nil {
-			return fmt.Errorf("déchiffrement %s impossible, on n'écrase rien : %w", p, err)
+			bad = append(bad, unreadableValue{Bucket: "fichier", Key: p, Blob: raw, Error: err.Error()})
+			continue // on n'écrase rien
 		}
 		if old, err := os.ReadFile(p); err == nil {
 			_ = memWriteFileAtomic(p+".bak", old, 0o600)
 		}
 		if err := memWriteFileVerified(p, plain, 0o600); err != nil {
-			return fmt.Errorf("écriture claire %s : %w", p, err)
+			return bad, fmt.Errorf("écriture claire %s : %w", p, err)
 		}
 		back, err := os.ReadFile(p)
 		if err != nil || looksEncrypted(back) || string(back) != string(plain) {
-			return fmt.Errorf("vérification post-déchiffrement de %s échouée", p)
+			return bad, fmt.Errorf("vérification post-déchiffrement de %s échouée", p)
 		}
 	}
+	return bad, nil
+}
+
+// allMemFilesForDecrypt : TOUS les fichiers de la mémoire, sous-dossiers compris,
+// et les images de conversation (chatimg/, chiffrées comme le fil), sauf les
+// copies .bak et les écritures en cours (.tmp). Ne déchiffrer que les pages .md
+// laissait le reste chiffré sans plus aucune clé une fois le keyvault retiré.
+func allMemFilesForDecrypt() []string {
+	var out []string
+	for _, root := range []string{projectsRoot(), chatImgDir()} {
+		_ = filepath.WalkDir(root, func(p string, d os.DirEntry, err error) error {
+			if err != nil || d.IsDir() || strings.HasSuffix(d.Name(), ".bak") || strings.HasSuffix(d.Name(), ".tmp") {
+				return nil
+			}
+			out = append(out, p)
+			return nil
+		})
+	}
+	return out
+}
+
+// quarantineUnreadable écrit les valeurs indéchiffrables, encore chiffrées, dans
+// un dossier daté de LOKI_HOME, avec une copie du keyvault à côté : elles
+// restent récupérables si l'ancienne clé est retrouvée.
+func quarantineUnreadable(bad []unreadableValue) error {
+	dir := filepath.Join(LokiHome(), "chiffre-illisible-"+time.Now().Format("20060102-150405"))
+	if err := os.MkdirAll(dir, 0o700); err != nil {
+		return err
+	}
+	raw, err := json.MarshalIndent(bad, "", " ")
+	if err != nil {
+		return err
+	}
+	if err := memWriteFileAtomic(filepath.Join(dir, "valeurs.json"), raw, 0o600); err != nil {
+		return err
+	}
+	for _, p := range []string{vaultPathPrimary(), vaultPathBackup()} {
+		if b, err := os.ReadFile(p); err == nil {
+			_ = memWriteFileAtomic(filepath.Join(dir, filepath.Base(p)), b, 0o600)
+		}
+	}
+	if b := getBytes(bkState, vaultDBKey); len(b) > 0 {
+		_ = memWriteFileAtomic(filepath.Join(dir, "keyvault-base.json"), b, 0o600)
+	}
+	for _, u := range bad {
+		fmt.Fprintf(os.Stderr, "[mémoire] illisible avec la clé actuelle, mis en quarantaine : %s / %s (%s)\n", u.Bucket, u.Key, u.Error)
+	}
+	fmt.Fprintf(os.Stderr, "[mémoire] %d valeur(s) en quarantaine dans %s\n", len(bad), dir)
 	return nil
 }
 
+// scrubEncryptedResidue retire les .bak encore CHIFFRÉS de la mémoire une fois
+// le chiffrement désactivé : la clé est partie avec le keyvault, ils ne pourront
+// plus jamais être lus, et ce sont des copies de pages qui viennent d'être
+// remises en clair. Pendant symétrique de scrubPlaintextResidue. Les valeurs en
+// quarantaine et les snapshots vivent hors de memory/ : jamais touchés. Rien
+// n'est fait tant que le chiffrement est actif.
+func scrubEncryptedResidue() int {
+	if memEncActive() {
+		return 0
+	}
+	n := 0
+	for _, root := range []string{projectsRoot(), chatImgDir()} {
+		_ = filepath.WalkDir(root, func(p string, d os.DirEntry, err error) error {
+			if err != nil || d.IsDir() || !strings.HasSuffix(d.Name(), ".bak") {
+				return nil
+			}
+			if b, err := os.ReadFile(p); err == nil && looksEncrypted(b) && os.Remove(p) == nil {
+				n++
+			}
+			return nil
+		})
+	}
+	return n
+}
+
 // resumeMemMigration reprend une migration interrompue au démarrage. Pour une
 // migration "encrypt", si la DEK est déjà en RAM (déverrouillée), on rejoue le
 // (re)chiffrement des pages claires ; sinon on laisse le journal en place pour un
@@ -328,12 +434,12 @@ func resumeMemMigration() {
 		// encore levé, on termine proprement (écrit le clair restant), puis on
 		// baisse le drapeau. Sans DEK, on laisse le journal : l'état reste lisible
 		// et l'écran de santé signalera le mélange.
+		// Même chemin complet que DisableMemEncryption : la reprise retirait la clé
+		// après les seules pages, en laissant les conversations chiffrées sans
+		// plus aucun moyen de les rouvrir.
 		if memEncActive() && memUnlocked() {
-			if err := decryptAllPages(); err == nil {
-				_ = SetConfigKey("MEM_ENCRYPTED", "")
-				removeVault()
-				clearMemDEK()
-				clearMigrationJournal()
+			if err := finishDecryption(); err != nil {
+				fmt.Fprintf(os.Stderr, "[mémoire] reprise du déchiffrement : %v\n", err)
 			}
 		}
 	}

internal/loki/mem_migrate_test.go

@@ -2,6 +2,7 @@ package loki
 
 import (
 	"os"
+	"path/filepath"
 	"strings"
 	"testing"
 )
@@ -261,3 +262,84 @@ func TestChiffrementGardeLesPointeursLisibles(t *testing.T) {
 		t.Fatalf("pointeur chiffré non réparé : %q", got)
 	}
 }
+
+// Une seule valeur indéchiffrable bloquait toute la désactivation, et les images
+// de conversation (chatimg/) restaient chiffrées sans clé une fois le keyvault
+// retiré. Désormais : tout ce qui se lit est déchiffré, l'illisible part en
+// quarantaine, et la désactivation aboutit.
+func TestDisableMemEncryptionSurvitAuxValeursIllisibles(t *testing.T) {
+	testHome(t)
+	clearMemDEK()
+	seedPages(t)
+	if _, err := EnableMemEncryption("pass-de-test-1234"); err != nil {
+		t.Fatal(err)
+	}
+	img := []byte("\x89PNG octets d'image de test")
+	ref, err := storeChatImage(img, "image/png")
+	if err != nil {
+		t.Fatal(err)
+	}
+	imgPath := filepath.Join(chatImgDir(), strings.TrimPrefix(ref, imgRefScheme))
+	if raw, _ := os.ReadFile(imgPath); !looksEncrypted(raw) {
+		t.Fatal("l'image devrait être chiffrée")
+	}
+	other := make([]byte, 32)
+	other[0] = 7
+	alien, err := encPage(other, []byte("conversation chiffrée avec une autre clé"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := putBytes(bkChat, "vieille", alien); err != nil {
+		t.Fatal(err)
+	}
+	if err := DisableMemEncryption(); err != nil {
+		t.Fatalf("la désactivation aurait dû aboutir : %v", err)
+	}
+	if memEncActive() {
+		t.Fatal("le chiffrement devrait être désactivé")
+	}
+	if b, _ := os.ReadFile(imgPath); string(b) != string(img) {
+		t.Fatalf("image pas déchiffrée : %q", b)
+	}
+	if v := getBytes(bkChat, "vieille"); len(v) != 0 {
+		t.Fatal("la valeur illisible aurait dû quitter la base")
+	}
+	q, _ := filepath.Glob(filepath.Join(LokiHome(), "chiffre-illisible-*", "valeurs.json"))
+	if len(q) != 1 {
+		t.Fatalf("quarantaine attendue, trouvée : %v", q)
+	}
+	if qb, _ := os.ReadFile(q[0]); !strings.Contains(string(qb), "vieille") {
+		t.Fatal("la quarantaine doit contenir la valeur illisible")
+	}
+	if baks, _ := filepath.Glob(filepath.Join(chatImgDir(), "*.bak")); len(baks) != 0 {
+		t.Fatalf(".bak chiffrés restés derrière : %v", baks)
+	}
+}
+
+// Déchiffrement interrompu puis repris au démarrage : la reprise retirait la clé
+// après les seules pages, et les conversations restaient chiffrées pour toujours.
+func TestResumeInterruptedDecryptDechiffreLesConversations(t *testing.T) {
+	testHome(t)
+	clearMemDEK()
+	seedPages(t)
+	if _, err := EnableMemEncryption("pw"); err != nil {
+		t.Fatal(err)
+	}
+	enc, err := encodeMemContent([]byte(`{"titre":"conversation"}`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := putBytes(bkChat, "conv:x", enc); err != nil {
+		t.Fatal(err)
+	}
+	if err := writeMigrationJournal("decrypt"); err != nil {
+		t.Fatal(err)
+	}
+	resumeMemMigration()
+	if memEncActive() {
+		t.Fatal("la reprise aurait dû terminer le déchiffrement")
+	}
+	if v := getBytes(bkChat, "conv:x"); string(v) != `{"titre":"conversation"}` {
+		t.Fatalf("conversation restée chiffrée après la reprise : %q", v)
+	}
+}

internal/loki/mem_store.go

@@ -186,20 +186,38 @@ func reencryptChatStores() error {
 	return nil
 }
 
-// decryptChatStores remet en clair les buckets de conversation. Exige la DEK.
-func decryptChatStores() error {
+// unreadableValue : une valeur chiffrée qui ne se déchiffre pas avec la clé
+// actuelle (écrite avec une autre clé, ou abîmée). Gardée telle quelle.
+type unreadableValue struct {
+	Bucket string `json:"bucket"`
+	Key    string `json:"key"`
+	Blob   []byte `json:"blob"` // base64 en JSON
+	Error  string `json:"error"`
+}
+
+// decryptChatStoresSkipping remet en clair les buckets de conversation (exige
+// la DEK) : déchiffre tout ce qui peut l'être et RENVOIE ce qui
+// ne le peut pas, au lieu de s'arrêter au premier échec : une seule valeur
+// illisible bloquait toute la désactivation du chiffrement, sans dire laquelle
+// (amont, 2026-10-03).
+func decryptChatStoresSkipping() ([]unreadableValue, error) {
 	persistQ.flush() // même raison que reencryptChatStores
+	var bad []unreadableValue
 	for _, b := range encryptedBuckets {
-		if err := decryptBucket(b); err != nil {
-			return err
+		u, err := decryptBucket(b)
+		if err != nil {
+			return bad, err
 		}
+		bad = append(bad, u...)
 	}
-	return nil
+	return bad, nil
 }
 
 // decryptBucket remet en clair toutes les valeurs chiffrées d'un bucket. Exige
-// la DEK en RAM. Sûr à rejouer.
-func decryptBucket(bucket string) error {
+// la DEK en RAM. Sûr à rejouer. Une valeur indéchiffrable est laissée telle
+// quelle et renvoyée ; seule une erreur d'écriture est fatale.
+func decryptBucket(bucket string) ([]unreadableValue, error) {
+	var bad []unreadableValue
 	for k, v := range allKV(bucket) {
 		raw := []byte(v)
 		if !looksEncrypted(raw) {
@@ -207,11 +225,12 @@ func decryptBucket(bucket string) error {
 		}
 		plain, err := decodeMemContent(raw)
 		if err != nil {
-			return err
+			bad = append(bad, unreadableValue{Bucket: bucket, Key: k, Blob: raw, Error: err.Error()})
+			continue
 		}
 		if err := putBytes(bucket, k, plain); err != nil {
-			return err
+			return bad, err
 		}
 	}
-	return nil
+	return bad, nil
 }

internal/loki/perf_log.go

@@ -37,6 +37,7 @@ const (
 	perfCompact  = "compact"  // résumé de compaction
 	perfBench    = "bench"    // mesure du moteur (cache_prompt:false)
 	perfForeign  = "foreign"  // client externe passé par /v1 : vu, pas mesuré
+	perfPrewarm  = "prewarm"  // préchauffage du cache (PREWARM) : réponse jetée
 )
 
 type perfCtxKey struct{}
@@ -452,6 +453,12 @@ type perfKindSum struct {
 	LostEvents        int      `json:"lost_events"`
 	LostTokens        int      `json:"lost_tokens"`
 	TTFTMedianMs      *float64 `json:"ttft_median_ms,omitempty"`
+	// Acceptation du brouillon par nature : un n-gramme paie en mode code
+	// (chemins, diffs recopiés) et presque pas en prose — le taux global
+	// mélangerait les deux. Absent = moteur muet ou spéculation coupée.
+	DraftN        int      `json:"draft_n,omitempty"`
+	DraftAccepted int      `json:"draft_accepted,omitempty"`
+	DraftRate     *float64 `json:"draft_rate,omitempty"`
 }
 
 type perfDepthSum struct {
@@ -472,6 +479,9 @@ type perfSummary struct {
 	DraftN        int                     `json:"draft_n"`
 	DraftAccepted int                     `json:"draft_accepted"`
 	DraftRate     *float64                `json:"draft_rate,omitempty"`
+	// Template : dernier verdict de la sonde de gabarit (chat_tplprobe.go),
+	// absent tant qu'aucune n'a tourné ou sur un preset externe.
+	Template *tplProbeResult `json:"template,omitempty"`
 }
 
 var perfDepthBuckets = []struct {
@@ -546,8 +556,10 @@ func perfSummarize(recs []perfRec) perfSummary {
 		}
 		if r.DraftN != nil {
 			s.DraftN += *r.DraftN
+			k.DraftN += *r.DraftN
 			if r.DraftAcc != nil {
 				s.DraftAccepted += *r.DraftAcc
+				k.DraftAccepted += *r.DraftAcc
 			}
 		}
 	}
@@ -557,6 +569,10 @@ func perfSummarize(recs []perfRec) perfSummary {
 			k.PrefillSecPerTurn = k.PrefillSec / float64(k.Turns)
 		}
 		k.TTFTMedianMs = perfMedian(ttft[kind])
+		if k.DraftN > 0 {
+			r := float64(k.DraftAccepted) / float64(k.DraftN)
+			k.DraftRate = &r
+		}
 	}
 	if sumTotal > 0 {
 		r := float64(sumCached) / float64(sumTotal)
@@ -580,5 +596,9 @@ func handlePerfSummary(w http.ResponseWriter, r *http.Request) {
 		sendJSON(w, http.StatusMethodNotAllowed, map[string]any{"error": "GET seulement"})
 		return
 	}
-	sendJSON(w, http.StatusOK, perfSummarize(perfLog.snapshot()))
+	s := perfSummarize(perfLog.snapshot())
+	if r, ok := tplCapsCurrent(); ok {
+		s.Template = &r
+	}
+	sendJSON(w, http.StatusOK, s)
 }

internal/loki/perf_log_test.go

@@ -249,6 +249,13 @@ func TestPerfSummarize(t *testing.T) {
 	if s.DraftRate == nil || *s.DraftRate != 0.75 {
 		t.Fatalf("acceptation : %v", s.DraftRate)
 	}
+	// Par nature aussi : le sous-agent sans brouillon n'a pas de taux inventé.
+	if m.DraftRate == nil || *m.DraftRate != 0.75 || m.DraftN != 40 || m.DraftAccepted != 30 {
+		t.Fatalf("acceptation main : %+v", m)
+	}
+	if sa := s.Kinds[perfSubagent]; sa.DraftRate != nil || sa.DraftN != 0 {
+		t.Fatalf("acceptation sous-agent : %+v", sa)
+	}
 	if len(s.Depth) != 4 || s.Depth[0].PPMedianTPS == nil || *s.Depth[0].PPMedianTPS != 500 || s.Depth[2].TGMedianTPS == nil || *s.Depth[2].TGMedianTPS != 30 || s.Depth[3].N != 0 {
 		t.Fatalf("profondeurs : %+v", s.Depth)
 	}

internal/loki/relay_link.go

@@ -472,6 +472,9 @@ func newLinkHandler(mux *http.ServeMux) http.Handler {
 	base := lp.Director
 	lp.Director = func(req *http.Request) {
 		base(req)
+		// Le moteur se voit appelé sous son propre nom, pas sous celui du relais :
+		// Strata refuse (403) un Host inconnu (protection DNS rebinding).
+		req.Host = llama.Host
 		// Le client distant n'a pas la clé API de llama-server ; on l'injecte ici
 		// (l'auth réelle est faite par le relais via la clé de liaison du compte).
 		if apiKey != "" {
@@ -525,7 +528,12 @@ func newLinkHandler(mux *http.ServeMux) http.Handler {
 				http.Error(w, "/slots est en lecture seule via le relais", http.StatusMethodNotAllowed)
 				return
 			}
-			defer engineRequestStart()() // voir oaiHandler
+			side, status, msg := sideSlotProxyRewrite(r) // voir oaiHandler
+			if status != 0 {
+				http.Error(w, msg, status)
+				return
+			}
+			defer engineProxyBegin(r, side)() // voir oaiHandler
 			lp.ServeHTTP(w, r)
 			return
 		}

internal/loki/run.go

@@ -4,13 +4,14 @@
 package loki
 
 import (
+	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
 )
 
-const Version = "0.14.0"
+const Version = "0.15.0"
 
 // Main est le vrai main() du binaire (cmd/loki ne fait que l'appeler).
 func Main() {
@@ -96,6 +97,8 @@ func Main() {
 		mustExit(cmdTest(args))
 	case "bench":
 		mustExit(cmdBench(args))
+	case "tune":
+		mustExit(cmdTune(args))
 	case "llamacpp":
 		mustExit(cmdLlamacpp(args))
 	case "update":
@@ -136,6 +139,14 @@ Moteur (loki-engine) :
   edit                          éditer la configuration dans $EDITOR
   switch [N]                    activer un preset de presets/ (interactif ou par numéro)
   test | bench [N] [--full]     vérifier que l'IA répond / mesurer prefill + decode (--full : en profondeur)
+  tune [--placement] [--opt-in] [--budget MIN] [--stages lots,threads…]
+                                optimiseur sans perte : essais (lots, threads, marges --fit…)
+                                sur un moteur privé, mesurés au bench complet ; rien n'est
+                                écrit sans ta réponse (copie du preset ou preset actuel,
+                                vérifié puis rétabli en cas d'échec). --placement : --fit à la
+                                place des experts / --tensor-split placés à la main (réécrit
+                                EXTRA_ARGS) ; --opt-in : SPEC, CUDA_GRAPH_OPT, --backend-sampling
+                                --stages : marges,lots,delestage,threads,files (défaut : toutes)
   vram                          utilisation GPU/VRAM (nvidia-smi)
   gpu [index…]                  liste les GPU / choisit le(s)quel(s) utiliser (gpu all = tous)
   set-api-key [clé]             protéger llama-server (clé Bearer); vide = générer, "" = retirer
@@ -192,10 +203,30 @@ Env:
 func mustExit(err error) {
 	if err != nil {
 		fmt.Fprintln(os.Stderr, "[err]", err)
-		os.Exit(1)
+		os.Exit(exitStatusOf(err))
 	}
 }
 
+// exitStatusError : une erreur qui choisit son code de sortie. Seul usage :
+// le refus de LOAD_GUARD, que le superviseur du moteur ne doit pas relancer
+// (voir loadGuardExitStatus).
+type exitStatusError struct {
+	code int
+	err  error
+}
+
+func (e *exitStatusError) Error() string { return e.err.Error() }
+func (e *exitStatusError) Unwrap() error { return e.err }
+
+// exitStatusOf : le code choisi par l'erreur, 1 sinon — comme toujours.
+func exitStatusOf(err error) int {
+	var es *exitStatusError
+	if errors.As(err, &es) {
+		return es.code
+	}
+	return 1
+}
+
 // LokiHome resolves the Loki data directory.
 // Précédence : $LOKI_HOME → /etc/default/loki (unix) → défaut plateforme.
 func LokiHome() string {

internal/loki/sys_childbind_linux.go

@@ -0,0 +1,20 @@
+//go:build linux
+
+package loki
+
+// Lier le Chrome du computer use à la vie de Loki (repris d'AJEAN) : le noyau
+// lui envoie SIGKILL quand Loki meurt, même tué brutalement. Sans ça, un Chrome
+// orphelin restait dans le conteneur après un redémarrage de l'UI. Ses
+// sous-processus suivent la mort du processus principal de Chrome.
+
+import (
+	"os/exec"
+	"syscall"
+)
+
+func prepareBoundChild(cmd *exec.Cmd) {
+	if cmd.SysProcAttr == nil {
+		cmd.SysProcAttr = &syscall.SysProcAttr{}
+	}
+	cmd.SysProcAttr.Pdeathsig = syscall.SIGKILL
+}

internal/loki/sys_childbind_other.go

@@ -0,0 +1,9 @@
+//go:build !linux
+
+package loki
+
+import "os/exec"
+
+// Hors Linux, pas d'équivalent simple à Pdeathsig : le navigateur est fermé à
+// l'arrêt propre de Loki. (AJEAN passe par un job object sous Windows.)
+func prepareBoundChild(cmd *exec.Cmd) {}

internal/loki/sys_install_darwin.go

@@ -48,6 +48,15 @@ func unitArgs() map[string]string {
 	return map[string]string{serviceName(): "serve", uiUnitName: "web"}
 }
 
+// supervisorRestartsRefusal : sous launchd (le LaunchDaemon du moteur, que
+// launchd désigne par XPC_SERVICE_NAME), KeepAlive/SuccessfulExit=false relance
+// TOUTE sortie non nulle — aucune exception par code n'existe. Un refus de
+// LOAD_GUARD y sort donc sans erreur (voir loadGuardRefusal). L'app de bureau
+// lance le moteur elle-même et ne le relance pas : code normal.
+func supervisorRestartsRefusal() (bool, string) {
+	return os.Getenv("XPC_SERVICE_NAME") == "com.loki."+serviceName(), ""
+}
+
 func installServices(targetUser, lokiHome string) error {
 	exe := installedExePath()
 	for name, arg := range unitArgs() {

internal/loki/sys_install_linux.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
+	"path/filepath"
 )
 
 // sys_install_linux.go — la part systemd de l'installation. Le parcours commun
@@ -31,6 +32,12 @@ WorkingDirectory=%s
 ExecStart=%s
 Restart=on-failure
 RestartSec=3
+# llama-server ignore SIGTERM en pleine génération : sans borne, une bascule de
+# preset restait bloquée 90 s (défaut systemd) avant le SIGKILL.
+TimeoutStopSec=5
+# Lancement refusé d'avance par LOAD_GUARD (le mode de chargement ne tient pas
+# en RAM) : relancer n'y changerait rien.
+RestartPreventExitStatus=78
 
 # Priorité CPU : on remonte le process pour qu'il ne soit pas dépriorisé face
 # aux tâches de fond (sampling/orchestration côté CPU pèsent sur le débit même
@@ -63,6 +70,40 @@ RestartSec=5
 WantedBy=multi-user.target
 `
 
+// engineUnitPath : l'unité du moteur telle que « loki install » l'écrit.
+func engineUnitPath() string { return "/etc/systemd/system/" + serviceName() + ".service" }
+
+// supervisorRestartsRefusal : « loki serve » tourne-t-il sous une unité
+// systemd qui le relancerait sur loadGuardExitStatus ? C'est le cas d'une unité
+// écrite avant que Loki ne pose RestartPreventExitStatus : « loki update » ne
+// réécrit pas les unités (il tourne sans droits root), seul « loki install »
+// le fait. Reconnu à coup sûr : systemd pour parent, INVOCATION_ID posé par
+// systemd, et notre unité lisible sans la directive. Dans le doute, non : le
+// code de sortie reste celui d'une erreur.
+func supervisorRestartsRefusal() (bool, string) {
+	if !systemdAvailable() || os.Getenv("INVOCATION_ID") == "" || os.Getppid() != 1 {
+		return false, ""
+	}
+	b, err := os.ReadFile(engineUnitPath())
+	if err != nil {
+		return false, ""
+	}
+	// Les compléments (« systemctl edit ») comptent aussi.
+	unit := string(b)
+	drops, _ := filepath.Glob(engineUnitPath() + ".d/*.conf")
+	for _, p := range drops {
+		if d, err := os.ReadFile(p); err == nil {
+			unit += "\n" + string(d)
+		}
+	}
+	if unitPreventsRefusalRestart(unit) {
+		return false, ""
+	}
+	return true, fmt.Sprintf("unité %s d'une version précédente : sortie sans erreur pour que systemd ne relance pas "+
+		"en boucle — « sudo systemctl edit %s », section [Service], RestartPreventExitStatus=%d (ou « sudo loki install ») "+
+		"la met à jour", serviceName(), serviceName(), loadGuardExitStatus)
+}
+
 func installServices(targetUser, lokiHome string) error {
 	svc, exe := serviceName(), installedExePath()
 	units := map[string]string{

internal/loki/sys_install_linux_test.go

@@ -0,0 +1,19 @@
+//go:build linux
+
+package loki
+
+import (
+	"strings"
+	"testing"
+)
+
+// L'unité du moteur écrite par « loki install » ne relance pas un refus de
+// LOAD_GUARD : sinon systemd le relançait toutes les trois secondes, sans fin.
+func TestEngineUnitPreventsRefusalRestart(t *testing.T) {
+	if !unitPreventsRefusalRestart(engineUnitTemplate) {
+		t.Fatal("RestartPreventExitStatus absent de l'unité du moteur")
+	}
+	if !strings.Contains(engineUnitTemplate, "Restart=on-failure") {
+		t.Fatal("les autres échecs doivent toujours être relancés")
+	}
+}

internal/loki/sys_install_windows.go

@@ -16,6 +16,10 @@ import (
 // service itself is managed by the PID-file supervisor in sys_service_windows.go
 // (loki start / stop / status), which needs no admin rights.
 
+// supervisorRestartsRefusal : aucun superviseur ne relance le moteur sous
+// Windows (fichier PID, voir sys_service_windows.go) — code de sortie normal.
+func supervisorRestartsRefusal() (bool, string) { return false, "" }
+
 func cmdInstall(args []string) error {
 	lokiHome := LokiHome()
 

internal/loki/sys_procid_linux.go

@@ -0,0 +1,52 @@
+//go:build linux
+
+package loki
+
+import (
+	"os"
+	"strconv"
+	"strings"
+)
+
+// procIdentity : instant de démarrage (en tops d'horloge depuis le boot, champ
+// 22 de /proc/<pid>/stat) et binaire d'un processus vivant. Un PID recyclé
+// après un redémarrage de Loki a un autre instant de démarrage : l'optimiseur ne
+// tue un essai orphelin que si les deux concordent (backend_tune_lock.go).
+//
+// L'instant est relatif au boot : après une coupure de courant, un service
+// lancé au même moment du démarrage peut retrouver le même PID ET le même top,
+// et un verrou laissé par l'ancien passerait pour vivant — tout serait refusé
+// jusqu'à son retrait à la main. L'identifiant du boot le préfixe donc.
+func procIdentity(pid int) (start, exe string, ok bool) {
+	if pid <= 0 {
+		return "", "", false
+	}
+	b, err := os.ReadFile("/proc/" + strconv.Itoa(pid) + "/stat")
+	if err != nil {
+		return "", "", false
+	}
+	// Le nom du processus (champ 2, entre parenthèses) peut contenir des blancs
+	// et des parenthèses : on repart de la DERNIÈRE parenthèse fermante.
+	s := string(b)
+	i := strings.LastIndexByte(s, ')')
+	if i < 0 {
+		return "", "", false
+	}
+	f := strings.Fields(s[i+1:])
+	// f[0] est le champ 3 (état) : le champ 22 est donc f[19]. Un zombie a fini
+	// de tourner, il ne compte plus comme vivant.
+	if len(f) < 20 || f[0] == "Z" {
+		return "", "", false
+	}
+	exe, _ = os.Readlink("/proc/" + strconv.Itoa(pid) + "/exe")
+	// Binaire remplacé par une mise à jour pendant que le processus tourne : le
+	// lien porte « (deleted) », c'est pourtant bien le même processus.
+	exe = strings.TrimSuffix(exe, " (deleted)")
+	start = f[19]
+	if b, err := os.ReadFile("/proc/sys/kernel/random/boot_id"); err == nil {
+		if id := strings.TrimSpace(string(b)); id != "" {
+			start = id + "/" + start
+		}
+	}
+	return start, exe, true
+}

internal/loki/sys_procid_other.go

@@ -0,0 +1,37 @@
+//go:build !linux && !windows
+
+package loki
+
+import (
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+)
+
+// procIdentity : instant de démarrage et binaire d'un processus vivant, lus par
+// ps (macOS, BSD). Voir la version Linux pour le pourquoi.
+func procIdentity(pid int) (start, exe string, ok bool) {
+	if pid <= 0 || !processAlive(pid) {
+		return "", "", false
+	}
+	p := strconv.Itoa(pid)
+	// lstart passe par strftime(%c) dans la langue et le fuseau de l'appelant :
+	// le processus web (launchd, sans LANG) et un terminal en français ne liraient
+	// pas la même chaîne pour le même processus, et un verrou vivant passerait
+	// pour périmé. Langue et fuseau fixés.
+	cmd := exec.Command("ps", "-o", "lstart=", "-p", p)
+	cmd.Env = append(os.Environ(), "LC_ALL=C", "LANG=C", "TZ=UTC")
+	out, err := cmd.Output()
+	if err != nil {
+		return "", "", false
+	}
+	start = strings.Join(strings.Fields(string(out)), " ")
+	if start == "" {
+		return "", "", false
+	}
+	if out, err := exec.Command("ps", "-o", "comm=", "-p", p).Output(); err == nil {
+		exe = strings.TrimSpace(string(out))
+	}
+	return start, exe, true
+}

internal/loki/sys_service.go

@@ -17,6 +17,23 @@ import (
 //
 // editConfig and showVram live here because they work the same everywhere.
 
+// serviceAction : le seul passage vers serviceActionOS pour le reste de Loki.
+// Pendant une optimisation (backend_tune_lock.go), le moteur d'essai tient la
+// VRAM : démarrer le vrai moteur à côté — bascule de preset, GPU, mise à jour,
+// rechargement… — chargerait deux modèles. Refus, quel que soit l'appelant et la
+// plateforme ; l'optimiseur, lui, appelle serviceActionOS directement. Un verrou
+// périmé (optimisation tuée) est écarté AVANT tout démarrage, son essai
+// orphelin arrêté : sinon le moteur relancé partagerait la carte avec lui.
+func serviceAction(action string) error {
+	if action == "start" || action == "restart" {
+		if err := tuneGuard(); err != nil {
+			return err
+		}
+		tuneReapStale()
+	}
+	return serviceActionOS(action)
+}
+
 // preflightEngine vérifie ce sans quoi le moteur ne PEUT pas démarrer, avant de
 // lancer le service. Sinon llama-server sortait en erreur, systemd le relançait
 // toutes les 3 s, et `loki start` affichait un « activating » rassurant pendant
@@ -24,6 +41,16 @@ import (
 // visible que dans le journal.
 func preflightEngine() error {
 	cfg := ReadConfig()
+	// Preset externe : aucun llama-server local à lancer. Exiger BIN/MODEL
+	// refusait `loki start` et `loki restart` avec un message invitant à
+	// réinstaller llama.cpp (amont #95) ; cmdServe sort déjà proprement.
+	if isExternalConfig(cfg) {
+		return nil
+	}
+	// Strata n'a ni BIN ni MODEL : son installeur a tout rangé (backend_strata.go).
+	if isStrataConfig(cfg) {
+		return strataPreflight(cfg)
+	}
 	bin := strings.TrimSpace(cfg["BIN"])
 	if bin == "" {
 		return fmt.Errorf("BIN non défini — installe un moteur : %s (ou renseigne BIN avec %s)",
@@ -74,8 +101,17 @@ var configTemplate = []struct{ key, help string }{
 	{"THREADS_BATCH", "threads CPU du prefill et de la vérification spéculative (MTP) ; vide ou 0 = comme THREADS"},
 	{"FIT_TARGET", "Mio laissés libres par carte par le placement auto (--fit-target), ex. 1024,3072 dans l'ordre des cartes ; " +
 		"vide = 1024, minimum 1024 ; sans effet si NGL chiffré, --tensor-split, -ot ou --n-cpu-moe"},
+	{"LOAD_GUARD", "off = lancer quand même un --load-mode none/mlock/dio/mmap+mlock (ou --no-mmap, --mlock) dont les poids " +
+		"restés en RAM dépassent à coup sûr 90 % de la RAM (limite du conteneur comprise) ; vide (défaut) = refus clair au " +
+		"lancement dans ce cas, simple avertissement au-delà de 80 % estimés"},
 	{"OP_OFFLOAD_MIN_BATCH", "experts MoE sur CPU : taille de lot à partir de laquelle ils sont recopiés vers le GPU ; " +
 		"vide = défaut du moteur (32) ; plus haut = lots courts sur CPU, à mesurer"},
+	{"SPLIT_MODE", "tensor = parallélisme de tenseurs entre cartes CUDA (-sm tensor, expérimental) : décodage plus rapide, " +
+		"prefill plus lent, à mesurer par tour. Loki pose -ngl all, -ts au prorata de la VRAM, -fa on (sauf réglés à la main) " +
+		"et GGML_CUDA_ALLREDUCE=internal (NCCL compresse en BF16, avec perte). Refusé sans la liste {none,layer,row,tensor} " +
+		"dans l'aide du moteur, avec un cache KV autre que f16/bf16/f32, des poids ou le KV sur CPU, --backend-sampling, " +
+		"-fa off, -sm à la main, SPEC, SIDE_SLOT, CTX non chiffré, une seule carte ou une VRAM estimée insuffisante. " +
+		"Vide/off (défaut) = découpe par couches"},
 	{"CUDA_GRAPH_OPT", "on = GGML_CUDA_GRAPH_OPT=1, branches Q/K/V en parallèle au décodage (expérimental, " +
 		"sortie identique, gain de 0 à quelques %) ; off puis redémarrage s'il plante"},
 	{"KV_TYPE", "quantization du cache KV ; vide = f16, sorties de référence ; q8_0 les modifie légèrement, " +
@@ -83,19 +119,55 @@ var configTemplate = []struct{ key, help string }{
 	{"CACHE_RAM", "cache de prompts en RAM hôte (--cache-ram, Mio), copie exacte des conversations quittées, jamais la VRAM ; " +
 		"vide = auto (agrandi seulement pour un modèle tout-GPU), -1 = sans limite, 0 = coupé"},
 	{"CACHE_ISOLATE", "off = ne plus effacer le slot après un sous-agent, une vérification, une tâche ou un bench"},
+	{"SIDE_SLOT", "on = second slot pour les travaux annexes : le moteur ouvre 2 slots de CTX jetons chacun (-c 2×CTX, " +
+		"--parallel 2, cache KV non unifié : aucun slot ne déborde sur l'autre), la discussion garde le slot 0, vérification, " +
+		"sous-agents, tâches, bench, résumé sur transcription et clients /v1 passent par le 1 (id_slot) — l'état de la " +
+		"discussion ne bouge plus. Cache KV et état récurrent en double en VRAM : refusé si le compte ne tient pas, si des " +
+		"poids sont sur CPU, ou si PARALLEL≠2, -c, -np, -kvu, --cache-idle-slots… sont réglés à la main. Vide/off (défaut) = un slot"},
+	{"SLOT_PERSIST", "on = garder sur disque (LOKI_HOME/slots, 2 fichiers au plus, 8 Gio chacun au plus) l'état du slot de " +
+		"la discussion à la bascule de preset, et le recharger au retour avant son premier message : moteur, modèle et réglages " +
+		"identiques à l'octet près (empreinte), slot encore vierge, sinon calcul normal. Refusé avec le décodage spéculatif, " +
+		"des poids sur CPU, ou un moteur joignable sans clé d'API hors 127.0.0.1. Jamais à travers une mise à jour du moteur. " +
+		"Réglage de machine, gardé à la bascule. Vide/off (défaut) = rien n'est écrit"},
 	{"CTX_CHECKPOINTS", "points de reprise par slot d'un modèle hybride (--ctx-checkpoints) ; vide = défaut du moteur (32) ; " +
 		"chacun pèse 70 à 200 Mio de RAM hôte : 8 à 16 si le modèle remplit déjà la RAM"},
 	{"CKPT_MIN_STEP", "espacement minimal en jetons entre deux points de reprise (--checkpoint-min-step), > 0 ; " +
 		"vide = défaut du moteur, ou 2048 d'office sur un hybride avec un moteur officiel antérieur à b10864"},
 	{"SPEC", "décodage spéculatif, sortie inchangée : off (défaut) / auto = tête MTP du modèle ou MODEL_DRAFT si --fit place " +
-		"tout et qu'aucun essai n'a échoué / mtp = imposé ; ~1-2 Go de VRAM en plus"},
-	{"MODEL_DRAFT", "tête MTP publiée à part (mtp-*.gguf) ou petit modèle brouillon, nom ou chemin comme MODEL ; utilisé si SPEC≠off"},
+		"tout et qu'aucun essai n'a échoué / mtp = imposé ; ~1-2 Go de VRAM en plus / ngram = n-grammes du contexte " +
+		"(ngram-mod 24/48/64, sans brouillon, utile en mode code, à mesurer ; refusé avec des poids sur CPU sauf " +
+		"OP_OFFLOAD_MIN_BATCH ≥ 66) / mtp+ngram = les deux, n-grammes seuls si pas de tête MTP"},
+	{"MODEL_DRAFT", "tête MTP publiée à part (mtp-*.gguf) ou petit modèle brouillon, nom ou chemin comme MODEL ; utilisé avec SPEC=auto, mtp ou mtp+ngram"},
 	{"SPEC_N_MAX", "jetons anticipés par étape (--spec-draft-n-max) ; vide = défaut du moteur (3)"},
-	{"SPEC_SAMPLING", "tirage du brouillon : greedy (défaut, exact) ; probabilistic seulement avec SPEC=mtp"},
+	{"SPEC_SAMPLING", "tirage du brouillon : greedy (défaut, exact) ; probabilistic seulement avec SPEC=mtp ou mtp+ngram"},
 	{"REASONING", "passthrough du mode raisonnement (on/auto/deepseek)"},
 	{"REASONING_PRESERVE", "on/off = garder ou non la réflexion des tours passés dans le gabarit (--reasoning-preserve) ; " +
-		"vide = défaut du moteur (on depuis b10763). Loki ne renvoie pas cette réflexion : off rend l'ancien historique " +
-		"aux gabarits type Qwen3.6, mais change celui des gabarits qui la gardent d'eux-mêmes (Qwen3.8)"},
+		"vide = défaut du moteur (on depuis b10763). Sans REASONING_ECHO, Loki ne renvoie pas cette réflexion : off rend " +
+		"l'ancien historique aux gabarits type Qwen3.6, mais change celui des gabarits qui la gardent d'eux-mêmes (Qwen3.8). " +
+		"Avec REASONING_ECHO=on, on = préfixe stable d'un message à l'autre (mode entraîné mais optionnel selon la fiche " +
+		"Qwen3.6), au prix de plus de contexte par tour, donc d'une compaction plus tôt"},
+	{"REASONING_ECHO", "on = renvoyer au moteur local le raisonnement du modèle (reasoning_content), au format entraîné : " +
+		"les étapes d'une boucle d'outils se relisent avec leur réflexion au lieu de blocs vides, et le moteur ne recalcule " +
+		"plus le dernier message ; plus de contexte par tour, compaction plus tôt. Vide/off (défaut) = rien n'est renvoyé. " +
+		"Jamais vers une API externe ni vers un autre modèle ; suspendu de lui-même si le gabarit le refuse"},
+	{"PROJ_SNAPSHOT", "on = figer le bloc projet (description, index mémoire, trackers, AGENTS.md) par discussion et livrer " +
+		"ses changements en <context_update> en tête du message suivant : une page créée ou une valeur de tracker ne fait plus " +
+		"recalculer toute la conversation. Repris tout neuf à chaque compaction, redémarrage ou changement de modèle/projet. " +
+		"Vide/off (défaut) = bloc reconstruit à chaque tour ; sans effet sur un preset externe"},
+	{"PREWARM", "on = préparer le prochain tour pendant que tu lis : après un tour (compaction comprise) ou une tâche, " +
+		"Loki envoie au moteur local la requête suivante avec un message « . » et 1 jeton de réponse, jetés ; le vrai message " +
+		"ne calcule plus que lui-même. Annulé dès qu'une autre requête part, sauf si elle prolonge exactement ce préfixe ; " +
+		"jamais avec plus d'un slot (sauf les deux de SIDE_SLOT : slot de la discussion). full = aussi au changement de discussion " +
+		"(après 3 s). Vide/off (défaut) = aucune requête de plus"},
+	{"KEEP_TURN_IMAGES", "zone grise — on = garder dans l'historique les images montrées par les outils (captures, see_image), " +
+		"rangées par référence, au lieu de les oublier en fin de tour : le tour suivant ne recalcule plus la boucle d'outils " +
+		"depuis la première capture. Coût mesuré par le moteur, total borné à 10 % de la fenêtre, retirées d'abord à toute " +
+		"compaction (qui arrive donc plus tôt) ; vision active seulement, preset externe s'il déclare la vision (images " +
+		"refacturées à chaque tour). Vide/off (défaut) = images éphémères, requête inchangée"},
+	{"NUDGE_IN_TOOL", "zone grise — on = le rappel de budget d'outils part au bout du dernier résultat d'outil au lieu d'un " +
+		"message à part, sur le moteur local et seulement si la sonde de gabarit dit que le rendu bouge quand un message " +
+		"s'ajoute (Qwen3.5) : la boucle d'outils du tour n'est plus recalculée. Un modèle peut moins bien suivre une consigne " +
+		"lue dans une sortie d'outil : à comparer avant de l'adopter. Vide/off (défaut) = message à part"},
 	{"REASONING_BUDGET", "plafond de tokens de réflexion ; -1 = illimité"},
 	{"REASONING_EFFORT", "intensité du raisonnement : vide (auto) / none / low / medium / high / xhigh"},
 	{"TEMP", "température d'échantillonnage ; vide = défaut du moteur"},
@@ -105,6 +177,10 @@ var configTemplate = []struct{ key, help string }{
 	{"PRESENCE_PENALTY", "pénalité de présence ; vide = défaut du moteur"},
 	{"REPEAT_PENALTY", "pénalité de répétition (1 = neutre) ; vide = défaut du moteur"},
 	{"COMPACT", "compactage automatique du contexte (off pour couper)"},
+	{"COMPACT_CONTINUATION", "on = le résumé d'une compaction prolonge la requête du tour que le moteur local a en cache " +
+		"(mêmes messages, outils et réglages du gabarit, plus une demande de résumé) au lieu d'une transcription calculée à froid ; " +
+		"repli sur la transcription au moindre écart (autre requête passée par le slot, marge, refus, appel d'outil, résumé vide). " +
+		"Ne redemande pas un résumé voué au refus. Vide/off (défaut) = compaction d'avant ; sans effet sur un preset externe"},
 	{"MEM_MODE", "mémoire de l'IA : off / ondemand / always"},
 	{"EXTRA_ARGS", "ajouté tel quel à la ligne de commande de llama-server"},
 }

internal/loki/sys_service_container.go

@@ -65,6 +65,12 @@ func userSvcAction(action string) error {
 }
 
 func userSvcStart() error {
+	// Preset externe : `loki serve` sortirait aussitôt (rien à lancer), et
+	// userCheckStarted le prendrait pour un plantage.
+	if isExternalConfig(ReadConfig()) {
+		fmt.Printf("%s preset externe actif : pas de moteur local à démarrer\n", dim("[info]"))
+		return nil
+	}
 	if pid := readServicePID(); pid > 0 && processAlive(pid) {
 		fmt.Printf("%s déjà démarré (PID %d)\n", yellow("[info]"), pid)
 		return nil

internal/loki/sys_service_darwin.go

@@ -48,9 +48,9 @@ func launchdPlistPath(svc string) string {
 // en écriture par l'utilisateur du service après le chown de l'installation).
 func launchdLogPath() string { return filepath.Join(LokiHome(), serviceName()+".log") }
 
-// serviceAction mappe start/stop/restart/enable/disable sur launchctl. `load -w`
+// serviceActionOS mappe start/stop/restart/enable/disable sur launchctl. `load -w`
 // (re)active le service ET le rend persistant au boot ; `unload -w` le désactive.
-func serviceAction(action string) error {
+func serviceActionOS(action string) error {
 	svc := serviceName()
 	plist := launchdPlistPath(svc)
 	// Pas de LaunchDaemon installé — cas normal d'un Mac de bureau, où Loki tourne