Nom du modèle affiché à côté de « Loki » sur chaque réponse

Le nom du modèle (fichier .gguf, sans dossier ni extension) est journalisé
avec la borne de tour côté serveur : chaque réponse garde le modèle qui l'a
réellement produite, y compris après un rechargement de page (rejeu du
journal) et même si un autre modèle est chargé depuis.

Côté UI, une pastille discrète s'affiche dans l'étiquette de la bulle de
réponse. Elle vit dans dataset.model pour survivre au repeint des libellés
lors d'un changement d'identité (applyIdentity).

Vérifié en conditions réelles (moteur simulé, rechargement en pleine
génération) : badge, tok/s des bulles et chrono « en cours » sont bien
rejoués après un refresh.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

.gitignore

@@ -13,3 +13,12 @@
 Thumbs.db
 .idea/
 .vscode/
+
+# Ancienne application Python/React (fork pré-Go), plus utilisée : elle traîne
+# encore sur certains postes de développement et ne doit JAMAIS revenir dans le
+# dépôt — un « git add -A » distrait y a déjà versé 94 Mo de node_modules.
+/backend/
+/frontend/
+.pytest_cache/
+__pycache__/
+node_modules/

Dockerfile

@@ -23,6 +23,13 @@ COPY cmd/ cmd/
 COPY internal/ internal/
 COPY tools/ tools/
 RUN CGO_ENABLED=0 go build -trimpath -ldflags "-s -w" -o /out/loki ./cmd/loki
+# gopls : serveur LSP Go, consommé par le vérificateur de code du mode code
+# (lsp.go). Compilé ici parce que l'image finale n'a pas de toolchain Go.
+# GOTOOLCHAIN=auto : gopls@latest exige régulièrement un Go plus récent que
+# celui de l'image (v0.23 veut ≥ 1.26 quand l'image est en 1.25) ; en local,
+# l'installation échouait net. Auto télécharge le toolchain requis — coût
+# limité à cette étape de build.
+RUN GOBIN=/out GOTOOLCHAIN=auto go install golang.org/x/tools/gopls@latest
 
 # ── Étape 2 : runtime sur l'image serveur CUDA officielle ───────────────
 FROM ${LLAMACPP_IMAGE} AS runtime
@@ -43,6 +50,16 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     && apt-get install -y --no-install-recommends nodejs \
     && rm -rf /var/lib/apt/lists/*
 
+# Serveurs LSP du mode code (lsp.go) : TypeScript/JavaScript et Python via
+# npm, Go via gopls compilé à l'étape 1. Un serveur absent désactive juste son
+# langage — mais autant livrer l'image complète.
+RUN npm install -g --no-audit --no-fund typescript typescript-language-server pyright     && npm cache clean --force
+
+# uv/uvx : lanceur des serveurs MCP écrits en Python (mcp-server-git, -fetch,
+# -time, sqlite, docker…). Sans lui, une bonne partie du catalogue embarqué
+# s'affiche mais ne peut pas démarrer. Deux binaires statiques, ~35 Mo.
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /usr/local/bin/
+
 # Playwright + Chromium : l'outil web_screenshot capture une page RENDUE
 # (JavaScript exécuté), ce que le moteur web intégré ne sait pas faire.
 # Coût assumé : ~500 Mo à 1 Go d'image. Mettre PLAYWRIGHT=0 pour bâtir une image
@@ -66,6 +83,7 @@ RUN if [ "$PLAYWRIGHT" = "1" ]; then \
     fi
 
 COPY --from=gobuild /out/loki /usr/local/bin/loki
+COPY --from=gobuild /out/gopls /usr/local/bin/gopls
 COPY docker-entrypoint.sh /usr/local/bin/docker-entrypoint.sh
 RUN chmod +x /usr/local/bin/docker-entrypoint.sh && mkdir -p /data /models
 

NOTICE.md

@@ -19,6 +19,14 @@ La licence d'origine est conservée à l'identique dans [`LICENSE`](LICENSE).
   pour que l'UI puisse redémarrer le moteur (changement de modèle).
 - **`loki config get/set`** : lecture/écriture non interactive de la
   configuration, utilisée par l'entrypoint Docker.
+- **Mode code** (`internal/loki/code_*.go`, `lsp.go`, `agents/`) : agent de
+  code avec critères d'acceptation, passe de vérification indépendante,
+  outils read/grep/glob, politique d'exécution, diagnostics LSP, outils git,
+  jobs d'arrière-plan et relance sur appel d'outil textuel. La conception
+  (contrat builder/verifier, tracker « lu avant d'écrire », auto-retry
+  patterns, table languages.json) est reprise
+  d'**[OpenFox](https://github.com/co-l/openfox)** (MIT) et réécrite en Go
+  pour ce fork ; les prompts de rôles sont des réécritures originales.
 
 ## Services externes
 

README.md

@@ -22,7 +22,7 @@ seule image.
 │                        ▲ modèles .gguf             │
 │  chromium (Playwright) — captures de pages web     │
 │  /data (config, bbolt, presets, mémoire,           │
-│         workspace + captures, modèles installés)   │
+│         workspace par discussion, modèles)         │
 │  /models (GGUF déposés à la main)                  │
 └────────────────────────────────────────────────────┘
 ```
@@ -77,6 +77,22 @@ Le champ **Télécharger un modèle** reste disponible pour coller un lien direc
 (dépôt privé, fichier hors des conventions). Un dépôt à accès restreint demande
 la variable d'environnement `HF_TOKEN`.
 
+Certains dépôts sont **à accès restreint** (« gated ») : leur arborescence se lit
+sans rien, mais chaque `.gguf` répond `401` tant que les conditions du dépôt
+n'ont pas été acceptées sur huggingface.co **et** qu'un jeton n'est pas fourni.
+Loki les marque « accès restreint » dès la liste des résultats et rappelle le
+geste à faire, plutôt que de laisser choisir une quantification pour échouer au
+lancement du transfert.
+
+Le jeton se règle **dans l'interface** : éditeur de preset → *Modèle* → **Jeton
+Hugging Face**. Il est vérifié auprès de Hugging Face avant d'être enregistré
+(le compte associé s'affiche), rangé avec les autres secrets sous `/data` — donc
+il survit aux redémarrages et aux changements de preset — et il sert aussi bien à
+la recherche qu'au téléchargement. À défaut, la variable d'environnement
+`HF_TOKEN` reste lue comme avant ; le jeton enregistré dans l'interface a la
+priorité. Un jeton en **lecture** suffit (huggingface.co/settings/tokens), et il
+n'est envoyé qu'aux adresses Hugging Face.
+
 ## Installation sur Unraid
 
 L'image est construite et publiée par GitHub Actions sur GHCR
@@ -105,7 +121,7 @@ redémarrages (volume `/data`). Variables d'environnement du conteneur :
 | `LOKI_NGL` | couches GPU initiales | `999` (tout) |
 | `LOKI_HOME` | données (volume) | `/data` |
 | `LOKI_MODEL_DIRS` | dossiers .gguf additionnels | `/models` |
-| `HF_TOKEN` | jeton Hugging Face, pour les dépôts à accès restreint | — |
+| `HF_TOKEN` | jeton Hugging Face, pour les dépôts à accès restreint (repli : le jeton réglé dans l'UI prime) | — |
 
 En CLI dans le conteneur : `docker exec -it loki loki status` (aussi :
 `logs`, `restart`, `config`, `bench`, `test`…).
@@ -122,8 +138,8 @@ et modèles compris.
 | `/data/presets/` | un `.env` par preset (modèle, contexte, NGL, vision…) |
 | `/data/models/` | modèles téléchargés depuis l'interface |
 | `/data/memory/` | pages de mémoire persistante (`.md`) |
-| `/data/workspace/` | dossier de travail de l'agent |
-| `/data/workspace/captures/<id>/` | captures d'écran, un dossier par discussion |
+| `/data/workspace/` | racine du dossier de travail de l'agent |
+| `/data/workspace/discussions/<id>/` | fichiers d'UNE discussion : dépôts, captures, ce que l'agent y écrit |
 | `/data/loki-engine.log` | journal de `llama-server` (aussi via `loki logs`) |
 | `/models` | GGUF déposés à la main depuis l'hôte (volume séparé, `LOKI_MODEL_DIRS`) |
 
@@ -138,6 +154,16 @@ Sur Unraid, garde le **même** chemin hôte d'un lancement à l'autre : `/mnt/us
 emplacements différents dès que le partage n'est pas en cache-only ou que le
 *mover* est passé. Le compose fourni utilise `/mnt/user/appdata/loki/…`.
 
+**Tu perds modèles, discussions et fichiers à chaque redémarrage ?** C'est le
+signe que `/data` n'est **pas monté** : le conteneur écrit alors dans sa couche
+éphémère, détruite à chaque recréation (mise à jour d'image, `compose down`,
+redémarrage de l'array). Vérifie avec la commande `docker inspect` ci-dessus :
+il doit y avoir une ligne `… → /data` **et** une `… → /models`. S'il n'y en a
+pas, ton conteneur a été lancé sans mapping (template Docker Unraid incomplet,
+`docker run` sans `-v`) — recrée-le avec les volumes du compose fourni. Depuis
+cette version, Loki le détecte au démarrage : bandeau rouge dans l'UI et
+avertissement en tête du journal du conteneur.
+
 Autre piège au redémarrage du serveur : Docker relance les conteneurs
 `restart: unless-stopped` **avant** que le plugin Nvidia Driver ait chargé ses
 modules. Le journal montre alors des `ERROR: init … result=11` et le moteur
@@ -154,16 +180,88 @@ Héritées d'AJEAN :
 - **Accès internet** : recherche + lecture de pages, moteur Go intégré ou
   [Crawl4AI](https://github.com/unclecode/crawl4ai) pour les pages JS.
 - **Agent** : shell, fichiers, workspace (`agent on`).
-- **Serveurs MCP** : Node.js est inclus dans l'image pour les serveurs `npx`.
+- **Serveurs MCP** : Node.js (`npx`) et uv (`uvx`) sont inclus dans l'image, pour
+  les serveurs écrits en JavaScript comme en Python. Au **premier** lancement,
+  `npx`/`uvx` téléchargent le paquet du serveur — Loki attend jusqu'à 3 minutes
+  ce coup-là (au lieu d'échouer sur « context deadline exceeded ») ; les
+  lancements suivants partent du cache en quelques secondes.
+- **Tâches planifiées** : une consigne que l'IA exécute **toute seule**, sur une
+  fréquence réglable (« toutes les 2 h », « tous les jours à 9 h », ou une
+  expression cron). Chaque tâche tourne **isolée des discussions** — elle n'écrit
+  pas dans le fil, travaille dans son propre dossier (`workspace/tasks/<id>/`) et
+  livre son résultat par les outils de l'IA (mail via MCP, shell, fichiers…) ; le
+  compte-rendu du dernier passage est visible dans sa fiche, et **réinjecté** au
+  passage suivant pour la continuité. Réglages par tâche : preset (donc modèle) à
+  activer avant l'exécution, accès mémoire et web. Un **interrupteur maître**
+  suspend tout d'un coup. Sans **mode agent**, une tâche s'exécute mais n'a aucun
+  outil pour agir — l'interface le dit. Une seule inférence tourne à la fois : une
+  tâche attend son tour, et le bouton stop du chat l'interrompt.
 - **Presets** de configuration par modèle, bench, auto-détection GPU.
-- **API OpenAI-compatible** exposable (`network on`, protégée par clé).
+- **Échantillonnage réglable par preset** : température, `top_p`, `top_k`,
+  `min_p`, pénalités de présence et de répétition, dans l'éditeur de preset. Ces
+  valeurs partent dans **chaque requête** au moteur, pas sur sa ligne de commande :
+  les changer ne demande donc aucun redémarrage. Un champ laissé vide n'envoie
+  rien et llama-server garde son défaut — utile parce que le défaut de llama.cpp
+  (top_k 40, min_p 0.05) est rarement celui que recommande le modèle (Qwen3.8 en
+  réflexion veut top_k 20, min_p 0, temp 1.0, top_p 0.95).
+- **API OpenAI-compatible** exposable, protégée par clé (voir ci-dessous — ce
+  fork la sert autrement que l'amont).
 
 Ajoutées par ce fork :
 
+- **Mode Code** : chaque discussion a un sélecteur **Chat | Code** dans le pied
+  de la carte de saisie. En mode Code, Loki devient un agent de code : outils
+  `read`/`grep`/`glob` (lecture bornée, numéros de ligne — et un fichier doit
+  avoir été LU avant d'être modifié), outils git (`git_status`, `git_diff`,
+  `git_clone` — le clone atterrit dans le dossier de la discussion), jobs
+  d'arrière-plan (`bash_bg`/`bash_tail` pour un serveur de dev ou un build
+  long), et **critères d'acceptation** : le modèle pose le contrat (2-6
+  critères testables, éditables dans le panneau au-dessus de la saisie), puis
+  une **passe de vérification indépendante** — même modèle, contexte isolé,
+  seule habilitée à marquer un critère « passé » — contrôle le diff et relance
+  la correction jusqu'à ce que tout passe (2 corrections max). Les fichiers
+  modifiés passent au **LSP** (gopls, typescript-language-server, pyright —
+  inclus dans l'image) : les erreurs de compilation reviennent dans le résultat
+  de l'outil, sans lancer de build. Sécurité : commandes catastrophiques
+  refusées (rm -rf /, mkfs, reboot…), chemins bornés au dossier de la
+  discussion en mode Code. En mode Chat, un message qui ressemble à une tâche
+  de code fait apparaître une puce « passer en mode Code ? » — suggestion,
+  jamais bascule automatique. Conception reprise
+  d'[OpenFox](https://github.com/co-l/openfox) (MIT), réécrite en Go — voir
+  `NOTICE.md`.
+- **Catalogue MCP** : le panneau *Serveurs MCP* offre un bouton **catalogue** —
+  une vingtaine de serveurs connus (filesystem, git, fetch, memory, sqlite,
+  playwright, context7, github…) avec leur commande déjà renseignée, classés par
+  catégorie. Choisir une entrée **n'installe rien** : ça remplit le formulaire
+  d'ajout, tu relis la commande — qui s'exécutera sur cette machine — puis tu
+  enregistres. Le catalogue est un JSON **embarqué dans le binaire**
+  (`internal/loki/mcp_catalog.json`), donc aucun appel à un annuaire distant :
+  pour en proposer d'autres, édite ce fichier et recompile. Une entrée dont le
+  runtime manque (`npx`/`uvx` absent) le signale au lieu d'échouer plus tard, et
+  celles qui réclament une clé d'API la rappellent avant l'enregistrement.
+- **Intensité du raisonnement** : un niveau — auto / aucune / basse / moyenne /
+  haute / maximale — envoyé à `llama-server` comme `reasoning_effort`. Réglable
+  **dans la barre de saisie**, parce que ça se décide en écrivant le message : le
+  changement s'applique au message suivant, sans redémarrer le moteur. L'éditeur
+  de preset garde le même réglage comme **défaut du modèle** ; appliquer un
+  preset reprend donc la main sur le choix fait à la volée. `none` coupe le
+  raisonnement ; les autres valeurs sont passées au gabarit jinja du modèle, ce
+  qui ne change le comportement que des modèles qui les lisent (gpt-oss et
+  apparentés) — ailleurs c'est ignoré sans erreur, et l'interface le dit plutôt
+  que de promettre un effet. Aucun gabarit ne les connaît toutes (gpt-oss :
+  basse/moyenne/haute ; Qwen3.8 : basse/moyenne/maximale) et certains **refusent**
+  celles qu'ils ne connaissent pas, avec une erreur 500 qui tuait le tour : loki
+  lit alors les niveaux annoncés par le refus, **repli sur le plus proche** (haute
+  → 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.
 - **Discussions multiples** : historique complet dans la barre latérale, titre
-  repris du premier message (renommable), suppression. Supprimer une discussion
-  efface aussi ses captures d'écran (`workspace/captures/<id>/`), pour que le
-  disque ne se remplisse pas en silence.
+  repris du premier message (renommable), suppression. **Chaque discussion a son
+  dossier de fichiers** (`workspace/discussions/<id>/`) : les pièces jointes
+  déposées, les captures et ce que l'agent écrit y atterrissent, le shell et les
+  chemins relatifs du modèle y sont résolus. Changer de discussion change donc
+  les fichiers ; supprimer (ou vider) une discussion emporte les siens, pour que
+  le disque ne se remplisse pas en silence.
 - **Recherche Hugging Face** intégrée avec verdict mémoire et installation liée
   du projecteur vision (voir [Installer un modèle](#installer-un-modèle)).
 - **Captures de pages web** : l'agent dispose de l'outil `web_screenshot`
@@ -174,12 +272,52 @@ Ajoutées par ce fork :
   lui promettre des yeux qu'il n'a pas — il peut toujours prendre la capture et
   la montrer, sans prétendre la décrire. L'image relayée au moteur reste
   éphémère : la persister gonflait le contexte jusqu'à le faire déborder.
-- **Panneau Fichiers** (bouton dossier du pied de carte) : ce que l'agent a
-  écrit dans son dossier de travail, avec navigation dans les sous-dossiers,
-  téléchargement et suppression. Un dossier affiche la taille de **tout** son
-  contenu — c'est ce qu'on libère en le supprimant. Le pied donne l'occupation
-  disque totale de l'agent. Les chemins sont bornés au dossier de travail, liens
-  symboliques résolus des deux côtés : rien du reste du disque n'est atteignable.
+- **Panneau Fichiers** (bouton dossier de la barre de saisie) : les fichiers de la
+  discussion ouverte — dépôts, captures, ce que l'agent y a écrit — avec
+  navigation dans les sous-dossiers, téléchargement et suppression. Un dossier
+  affiche la taille de **tout** son contenu, c'est ce qu'on libère en le
+  supprimant, et le pied donne l'occupation disque de la discussion. Les chemins
+  sont bornés à son dossier, liens symboliques résolus des deux côtés : ni le
+  reste du disque ni les autres discussions ne sont atteignables. Les fichiers
+  d'avant ce rangement que la migration n'a pas su rattacher restent joignables
+  par le bouton **hors discussion**, qui disparaît une fois le ménage fait.
+- **Interface « Sober Tech »** : ardoise et sauge, typographie Inter (interface)
+  et JetBrains Mono (code, chiffres, chemins) — embarquées dans le binaire, donc
+  aucune requête vers un service de polices. Deux variantes : claire par défaut,
+  **Deep Dark** (fond `#0F172A`, cartes `#1E293B`) d'un clic depuis l'en-tête.
+  L'en-tête porte le titre de la discussion et le **sélecteur de modèle** (le
+  changement de preset ne demande plus d'ouvrir les réglages) ; la barre
+  latérale s'escamote pour rendre toute la largeur au fil ; les discussions s'y
+  cherchent au clavier et les jauges **GPU / VRAM / mémoire vive** restent
+  visibles en pied de colonne.
+- **API OpenAI servie par Loki** : `/v1/*` est exposé **sur le port de
+  l'interface** (8090) et relayé vers llama-server, au lieu d'annoncer l'adresse
+  du moteur. Conséquence directe : l'API est joignable partout où l'interface
+  l'est — par l'IP du réseau local comme par un nom de domaine — sans publier de
+  second port ni ouvrir le moteur. L'amont annonçait `http://<ip>:8080/v1`, une
+  adresse injoignable en conteneur (le port 8080 n'y est pas publié, et l'IP
+  détectée est celle du bridge Docker).
+  - Authentification par la **clé API** du panneau (`Authorization: Bearer …`),
+    vérifiée par Loki **et** par le moteur. Sans clé, l'endpoint est ouvert et
+    l'interface le dit en rouge.
+  - **Adresse publique** : un champ où saisir son domaine, pour le cas du
+    reverse proxy où Loki ne voit qu'un appel interne. Laissé vide, l'adresse
+    affichée suit celle du navigateur.
+  - **TLS** : mettre un reverse proxy devant (Caddy, Nginx, Traefik). Loki
+    honore `X-Forwarded-Proto` pour annoncer une adresse en `https`.
+  - L'ancienne exposition publique via le relais de l'amont
+    (`<machine>.oai.ajean.link`) est retirée de l'interface : elle exigeait un
+    jeton de relais que ce fork ne permet plus d'obtenir, l'interrupteur ne
+    pouvait donc qu'échouer.
+- **Budget d'appels d'outils** : un tour d'agent n'a aucun plafond — couper une
+  recherche légitime est pire que la laisser durer — mais au-delà de 24 appels
+  sur un même tour, Loki rappelle au modèle combien il en a déjà faits et lui
+  demande de conclure. Le rappel revient tous les 24 appels, en durcissant le
+  ton ; il ne coupe jamais le tour, c'est de la pression, pas une barrière.
+  Sans lui, un petit modèle qui tourne en rond n'avait rien en face de lui sauf
+  le bouton stop (vu en production : 50 appels, 55 minutes, à relire cinq fois
+  les mêmes fichiers). Réglable par `AGENT_BUDGET` dans `config.env` —
+  `AGENT_BUDGET=off` le désactive complètement.
 - **Identité** : ton prénom et un avatar emoji pour toi et pour Loki, affichés
   dans le fil.
 - **Paramètres** : les réglages d'application (identité, apparence, accès
@@ -206,12 +344,14 @@ Retirées par ce fork :
 |---|---|---|
 | Installation | binaire + `sudo ajean install` (systemd) | `docker compose up` |
 | Moteur llama.cpp | compilé sur la machine (`ajean llamacpp install`) | image officielle llama.cpp (`server-cuda`), précompilée |
-| Panneau « Moteur » | propose d'installer/compiler | annonce le moteur fourni par l'image, sans proposer d'install |
+| Panneau « Moteur » | propose d'installer/compiler | affiche la version qui tourne et la met à jour en un clic (sans rebuild) |
 | Supervision moteur | systemd / launchd / PID (Windows) | fichier PID (`LOKI_CONTAINER=1`) |
 | Configuration initiale | `ajean edit` ($EDITOR) | entrypoint + `loki config set` |
 | Choix du modèle | lien Hugging Face collé à la main | recherche intégrée + verdict VRAM + projecteur lié |
 | Historique de tchat | conversation unique | discussions multiples, titrées et persistées |
+| Agent de code | — | mode Code : critères d'acceptation, passe de vérification, LSP, outils git |
 | Accès distant | relais chiffré ajean.link | retiré de l'interface |
+| Endpoint OpenAI | `:8080/v1` du moteur, ouvert par `network on` | `/v1` servi par Loki sur le port de l'interface, protégé par la clé API |
 | Mise à jour | `ajean update` (binaire GitHub) | `docker compose pull` |
 
 Le reste — mémoire, outils, protocole, moteur d'inférence — est celui d'AJEAN.
@@ -238,6 +378,44 @@ docker build --build-arg LLAMACPP_IMAGE=ghcr.io/ggml-org/llama.cpp:server-cuda-b
 Aucune compilation de llama.cpp n'a lieu : le moteur est maintenu et
 précompilé par l'équipe amont (toutes architectures GPU courantes).
 
+## Mettre à jour llama.cpp sans reconstruire l'image
+
+llama.cpp publie plusieurs versions par jour ; l'image de Loki, elle, ne se
+reconstruit qu'à une mise à jour de Loki. Le moteur y était donc figé à la date
+du dernier build, et le rattraper imposait un rebuild complet (2,6 Go) pour un
+composant de 170 Mo.
+
+**Réglages → Moteur** affiche désormais la version de llama.cpp qui tourne
+(`b10450`, avec son commit) et deux boutons :
+
+- **vérifier la version** — interroge le registre et dit s'il existe plus récent ;
+- **mettre à jour le moteur** — télécharge `llama-server` et ses bibliothèques
+  depuis l'image officielle, `ghcr.io/ggml-org/llama.cpp:server-cuda`.
+
+Ce qui est téléchargé n'est **pas l'image** : un manifeste OCI liste ses couches,
+et seules celles qui portent `/app` sont récupérées (~170 Mo). Le runtime CUDA
+(2 Go) et la base système sont déjà dans l'image de Loki. Le moteur atterrit dans
+`/data/engine/<version>/`, donc sur le volume de données : il survit à un
+`docker compose pull`.
+
+La variante est déduite du moteur en place (CUDA, Vulkan, SYCL, MUSA ou CPU) :
+une installation Vulkan ne se verra jamais proposer une image CUDA.
+
+**Le garde-fou.** La mise à jour apporte llama.cpp, pas le runtime CUDA, qui
+reste celui de l'image. Un llama.cpp compilé pour un CUDA plus récent ne
+chargerait pas son backend GPU ici — et le symptôme serait silencieux : tout
+fonctionne, mais sur le processeur. Le nouveau moteur est donc lancé à blanc
+avant toute bascule ; s'il ne démarre pas, ou s'il ne voit plus aucune carte
+alors que le moteur courant en voyait, la mise à jour est refusée et le moteur
+courant n'est pas touché. Le moteur livré par l'image reste par ailleurs intact :
+**revenir au moteur de l'image** y ramène en un clic, sans réseau.
+
+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.
+
+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.
+
 ## Licence
 
 MIT — © les contributeurs d'AJEAN (« Jean contributors ») pour le code amont,

docker-entrypoint.sh

@@ -4,8 +4,17 @@
 set -eu
 
 : "${LOKI_HOME:=/data}"
+export LOKI_HOME   # les sous-commandes loki doivent voir le MEME dossier
 mkdir -p "$LOKI_HOME"
 
+# Garde-fou persistance : si /data n'est pas un point de montage, tout ce que
+# l'utilisateur fera (modèles, discussions, fichiers) mourra avec le conteneur.
+# On le dit au premier écran du journal — l'UI l'affiche aussi en bandeau.
+if ! grep -qs " $LOKI_HOME " /proc/self/mountinfo; then
+    echo "[entrypoint] ⚠️  $LOKI_HOME n'est pas un volume monté : les données seront PERDUES à la recréation du conteneur."
+    echo "[entrypoint]     Ajoute « -v /chemin/hote/data:/data » (docker run) ou le mapping volumes du docker-compose."
+fi
+
 # Le chemin du moteur est imposé par l'image (llama-server précompilé de
 # l'image officielle llama.cpp, dans /app) : on le (re)pose à chaque boot,
 # une mise à jour de l'image ne doit pas laisser un BIN obsolète en base.

internal/loki/agents/builder.md

@@ -0,0 +1,15 @@
+You are in CODE MODE: an autonomous coding agent working in this discussion's folder.
+
+Method — in this order:
+1. If the task has no acceptance criteria yet, set them FIRST with the criteria tool (action=add): 2-6 short, testable statements of what DONE means. For a trivial task (one obvious change), skip criteria and just do it.
+2. Explore before you change: read the relevant files (read, grep, glob, git_status). Never edit a file you have not read.
+3. Implement with edit (small patches) or write (new files). Match the style of the surrounding code.
+4. Prove it: run the build/tests with bash. A change that was never run is not done. For a web page or UI, start the dev server with bash_bg then use web_screenshot on its localhost URL — a headless Chromium is ALREADY installed, so NEVER install puppeteer, playwright or a browser.
+5. Report briefly what changed and how you verified it.
+
+Rules:
+- PLAN ONCE. If the task needs a plan, write it to PLAN.md in ONE short write, then follow it. Between tool calls, think one or two sentences at most — NEVER restate or re-derive the plan: it is in PLAN.md and in your criteria, read them instead.
+- Write each file COMPLETE in a single write call. Many small writes waste turns.
+- You may NOT mark a criterion passed — the verification pass does that.
+- If a command fails, read the error and fix the cause; do not retry the same command unchanged.
+- Ask the user (ask tool) only for decisions that are genuinely theirs; decide the rest yourself.

internal/loki/agents/code-reviewer.md

@@ -0,0 +1,5 @@
+You are the CODE REVIEW pass of code mode. Review the current changes (git_diff) for real defects.
+
+Look for, in this order: correctness bugs (wrong logic, unhandled errors, races), security issues (injection, path traversal, secrets), then significant simplifications. Ignore style and taste.
+
+For each finding: file:line, one-line problem, one-line fix. If the diff is sound, say so in one sentence. Do not modify anything.

internal/loki/agents/explorer.md

@@ -0,0 +1,3 @@
+You are the EXPLORATION pass of code mode. Answer questions about the codebase without modifying anything.
+
+Use read, grep, glob and git tools to locate and understand code. Cite files as path:line. Be concise: report what you found and where, not everything you read. If the answer spans several places, list them with one line each.

internal/loki/agents/planner.md

@@ -0,0 +1,8 @@
+You are the PLANNING pass of code mode. Break the user's task down BEFORE any code is written.
+
+Produce:
+1. A short restatement of the goal (one sentence).
+2. Acceptance criteria via the criteria tool (action=add): 2-6 short, testable statements of what DONE means.
+3. The implementation steps, ordered, with the files each step touches.
+
+Explore the code (read, grep, glob, git_status) as needed to make the plan concrete — real file paths, real function names. Do not modify anything. End by asking the user to confirm the plan or amend it.

internal/loki/agents/verifier.md

@@ -0,0 +1,12 @@
+You are the VERIFICATION pass of code mode. You independently check the acceptance criteria against the actual code — you did not write it, trust nothing.
+
+For each criterion still pending or failed:
+1. Understand what it actually requires.
+2. Check the real changes: git_diff, read the touched files, run the relevant build/test command with bash when applicable.
+3. Record the verdict with the criteria tool: action=set, status=passed (satisfied) or failed (with a note saying exactly what is missing — actionable, one line).
+
+Rules:
+- Trivial or non-code criteria that are plainly satisfied: pass them without exploring.
+- Only fail a criterion that genuinely misses its requirement; a different-but-valid implementation passes.
+- Do NOT fix anything yourself. You only verify and report.
+- Be fast: check the diff first, read only what the criteria require.

internal/loki/backend_build.go

@@ -134,7 +134,7 @@ func detectBuildPlan() buildPlan {
 	}
 
 	// Vulkan (GPU générique) — utile sur Intel/AMD sans ROCm.
-	if hasTool("glslc") && (isFile("/usr/lib/x86_64-linux-gnu/libvulkan.so.1") || hasTool("vulkaninfo")) {
+	if hasTool("glslc") && (hasVulkanLib() || hasTool("vulkaninfo")) {
 		p.backend = "vulkan"
 		p.flags = append(p.flags, "-DGGML_VULKAN=ON")
 		return p
@@ -457,6 +457,33 @@ func hasTool(name string) bool {
 	return err == nil
 }
 
+// hasVulkanLib détecte le chargeur Vulkan (libvulkan) sans supposer un unique
+// chemin de distribution. Repris de l'amont AJEAN (issues #28, #29) : l'ancienne
+// détection testait en dur le chemin Debian multiarch
+// (/usr/lib/x86_64-linux-gnu/libvulkan.so.1), invisible sur Fedora/RHEL/Atomic où
+// la bibliothèque vit dans /usr/lib64 — le plan de build retombait alors sur le
+// CPU sur une machine parfaitement capable. On interroge d'abord ldconfig (la
+// source de vérité du linker dynamique), puis une liste de chemins connus.
+func hasVulkanLib() bool {
+	// ldconfig -p liste les bibliothèques du cache, tous chemins confondus.
+	if out, err := exec.Command("ldconfig", "-p").Output(); err == nil {
+		if strings.Contains(string(out), "libvulkan.so") {
+			return true
+		}
+	}
+	for _, p := range []string{
+		"/usr/lib/x86_64-linux-gnu/libvulkan.so.1", // Debian/Ubuntu multiarch
+		"/usr/lib64/libvulkan.so.1",                // Fedora/RHEL/Bazzite
+		"/usr/lib/libvulkan.so.1",                  // Arch et divers
+		"/lib64/libvulkan.so.1",
+	} {
+		if isFile(p) {
+			return true
+		}
+	}
+	return false
+}
+
 func requireTools(tools ...string) error {
 	missing := missingTools(tools)
 	if len(missing) == 0 {

internal/loki/backend_config.go

@@ -12,10 +12,41 @@ import (
 	"strings"
 )
 
+// readAPIKeyErr renvoie la clé Bearer des complétions en distinguant « aucune
+// clé » d'une LECTURE RATÉE — même nuance que readWebKeyErr, et pour la même
+// raison : sans clé, l'endpoint est OUVERT. Confondre les deux, c'est ouvrir
+// l'accès aux complétions parce que la base était momentanément verrouillée par
+// une commande CLI. requireCompletionKey refuse donc plutôt que d'ouvrir.
+func readAPIKeyErr() (string, error) {
+	b, err := getBytesErr(bkState, "api_key")
+	return string(b), err
+}
+
 // readAPIKey renvoie la clé Bearer de llama-server, ou "" si aucune n'est
-// définie. Elle est rangée hors de la configuration pour survivre aux
-// changements de preset, qui remplacent la configuration en bloc.
-func readAPIKey() string { return getStr(bkState, "api_key") }
+// définie (ou illisible). Elle est rangée hors de la configuration pour survivre
+// aux changements de preset, qui remplacent la configuration en bloc. Réservé à
+// l'affichage et aux appels internes ; toute décision d'accès passe par
+// effectiveAPIKeyErr.
+func readAPIKey() string { k, _ := readAPIKeyErr(); return k }
+
+// effectiveAPIKeyErr renvoie la clé que llama-server exige RÉELLEMENT : celle
+// rangée en base, sinon la clé résiduelle de config.env (repli rétro-compatible,
+// cf. backend_serve.go).
+//
+// Une seule source pour les deux côtés du relais. Quand la garde de Loki ne
+// regardait que la clé en base, un API_KEY oublié dans config.env donnait un
+// endpoint « ouvert » côté Loki et un 401 côté moteur — le client voyait un
+// refus sans jamais comprendre quelle clé fournir.
+func effectiveAPIKeyErr() (string, error) {
+	k, err := readAPIKeyErr()
+	if err != nil {
+		return "", err
+	}
+	if k != "" {
+		return k, nil
+	}
+	return strings.TrimSpace(ReadConfig()["API_KEY"]), nil
+}
 
 // authHeader sets the Authorization: Bearer header on req when an API key is
 // configured, so Loki's own internal calls (chat/web/bench/test) authenticate
@@ -203,6 +234,61 @@ func splitArgs(s string) []string {
 	return out
 }
 
+// samplingKeys : les paramètres d'échantillonnage réglables par preset. Repris
+// de l'amont AJEAN (v0.9.5/v0.9.6).
+//
+// Ils sont injectés dans CHAQUE requête de complétion (applySampling) et non
+// passés à llama-server au lancement : une valeur présente dans la requête
+// l'emporte de toute façon sur le défaut du serveur, donc c'est le seul endroit
+// où le réglage prend vraiment effet. Sans ça, seule la température voyageait, et
+// top_k/min_p/… retombaient sur les défauts de llama.cpp — rarement ceux que
+// recommande le modèle (Qwen3.8 veut top_k 20 / min_p 0, pas 40 / 0.05).
+//
+// Correspondance clé de config → champ du corps OpenAI. Une valeur vide vaut
+// « clé absente » : llama-server garde alors son propre défaut pour ce champ.
+var samplingKeys = []struct {
+	cfg, field string
+	integer    bool
+}{
+	{"TEMP", "temperature", false},
+	{"TOP_P", "top_p", false},
+	{"TOP_K", "top_k", true},
+	{"MIN_P", "min_p", false},
+	{"PRESENCE_PENALTY", "presence_penalty", false},
+	{"REPEAT_PENALTY", "repeat_penalty", false},
+}
+
+// applySampling superpose les paramètres d'échantillonnage du preset au corps
+// d'une requête de complétion. Les clés vides sont ignorées (le serveur garde son
+// défaut) ; TEMP, s'il est défini, l'emporte sur la température déjà posée dans le
+// payload — c'est le réglage recommandé du modèle, et l'interface n'a pas de
+// curseur de température qui pourrait le contredire.
+//
+// Contrairement à l'amont, REASONING_EFFORT n'est PAS traité ici : loki lui
+// réserve un chemin plus riche (llm_client.go + llm_effort.go — champ de haut
+// niveau, kwargs du gabarit, repli quand le gabarit refuse le niveau). L'écrire
+// depuis ici écraserait `chat_template_kwargs`, donc la consigne « aucune » avec.
+func applySampling(payload map[string]any) { applySamplingFrom(payload, ReadConfig()) }
+
+// applySamplingFrom est la partie pure d'applySampling : testable sans base.
+func applySamplingFrom(payload map[string]any, cfg map[string]string) {
+	for _, s := range samplingKeys {
+		v := strings.TrimSpace(cfg[s.cfg])
+		if v == "" {
+			continue
+		}
+		if s.integer {
+			if n, err := strconv.Atoi(v); err == nil {
+				payload[s.field] = n
+			}
+			continue
+		}
+		if f, err := strconv.ParseFloat(v, 64); err == nil {
+			payload[s.field] = f
+		}
+	}
+}
+
 // Le plafond d'appels d'outils par tour (TOOL_LIMIT) et l'anti-boucle ont été
 // retirés : ils coupaient surtout des tours légitimes. Le bouton stop est le
 // seul frein.

internal/loki/backend_engine_oci.go

@@ -0,0 +1,650 @@
+// backend_engine_oci.go — mise à jour du moteur llama.cpp SANS reconstruire
+// l'image et sans compiler : on va chercher le moteur là où l'équipe llama.cpp
+// le publie déjà tout compilé — dans son image de conteneur officielle — et on
+// en extrait le seul dossier qui nous intéresse, /app.
+//
+// Pourquoi ce détour plutôt que les releases GitHub (backend_prebuilt.go) :
+// llama.cpp ne publie AUCUN binaire CUDA pour Linux dans ses releases. La seule
+// distribution CUDA/Linux officielle et précompilée, ce sont ces images
+// (ghcr.io/ggml-org/llama.cpp:server-cuda-b#####). C'est aussi exactement ce
+// dont l'image de Loki hérite : mettre à jour par ce chemin, c'est obtenir le
+// même moteur qu'une reconstruction complète de l'image, en ~170 Mo au lieu de
+// 2,6 Go et sans passer par un rebuild.
+//
+// Ce qu'on télécharge : PAS l'image. Un manifeste OCI liste ses couches ; le
+// runtime CUDA (2 Go) et les paquets système sont déjà présents dans l'image de
+// Loki, donc inutiles. Seules les couches du haut portent /app (llama-server et
+// ses .so, ~170 Mo). On les prend en partant du sommet et on s'arrête dès qu'on
+// tient un moteur complet.
+//
+// Ce que ça NE remplace PAS : le runtime CUDA, lui, vient de l'image. Un
+// llama.cpp compilé pour un CUDA majeur plus récent que celui de l'image ne
+// démarrera pas — d'où le test à blanc (--list-devices) avant toute bascule, et
+// la possibilité de revenir au moteur d'origine en un clic.
+package loki
+
+import (
+	"archive/tar"
+	"compress/gzip"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// ociBase est une variable et non une constante pour que les tests puissent la
+// pointer sur un faux registre : tout ce qui suit se joue dans le dialogue avec
+// le registre, et le vérifier en frappant ghcr.io rendrait la CI dépendante du
+// réseau.
+// LOKI_OCI_REGISTRY le remplace : c'est la porte de sortie pour un réseau qui
+// n'atteint pas ghcr.io directement — miroir d'entreprise, cache local — sans
+// quoi la mise à jour du moteur y serait tout simplement impossible.
+var ociBase = "https://ghcr.io"
+
+func init() {
+	if v := strings.TrimRight(strings.TrimSpace(os.Getenv("LOKI_OCI_REGISTRY")), "/"); v != "" {
+		if !strings.Contains(v, "://") {
+			v = "https://" + v
+		}
+		ociBase = v
+	}
+}
+
+// ociHost : l'hôte seul, tel que l'attend le paramètre `service` du jeton.
+func ociHost() string {
+	h := strings.TrimPrefix(strings.TrimPrefix(ociBase, "https://"), "http://")
+	return strings.TrimSuffix(h, "/")
+}
+
+const (
+	ociEngineRepo = "ggml-org/llama.cpp"
+
+	// Au-delà de cette taille, une couche n'est plus une couche « applicative » :
+	// c'est le runtime CUDA (2 Go) ou une base système, qu'on ne veut à aucun
+	// prix télécharger. On descend les couches du sommet vers la base ; croiser
+	// une couche de cette taille signifie qu'on a dépassé /app.
+	ociLayerCap = 600 << 20
+)
+
+// ociLayer : une couche du manifeste (on n'a besoin que de ça).
+type ociLayer struct {
+	MediaType string `json:"mediaType"`
+	Digest    string `json:"digest"`
+	Size      int64  `json:"size"`
+}
+
+// ociDoc couvre à la fois un index multi-architecture et un manifeste d'image :
+// les deux arrivent sur la même URL, distingués par le champ qui est rempli.
+type ociDoc struct {
+	MediaType string `json:"mediaType"`
+	Manifests []struct {
+		Digest   string `json:"digest"`
+		Platform struct {
+			Architecture string `json:"architecture"`
+			OS           string `json:"os"`
+		} `json:"platform"`
+	} `json:"manifests"`
+	Layers      []ociLayer        `json:"layers"`
+	Annotations map[string]string `json:"annotations"`
+}
+
+// ociAccept : tous les types de manifeste qu'on sait lire. Sans cet en-tête, le
+// registre répond en schéma 1 (obsolète) et la lecture échoue sans expliquer.
+const ociAccept = "application/vnd.oci.image.index.v1+json," +
+	"application/vnd.docker.distribution.manifest.list.v2+json," +
+	"application/vnd.oci.image.manifest.v1+json," +
+	"application/vnd.docker.distribution.manifest.v2+json"
+
+// ociToken obtient un jeton de lecture ANONYME. Les images publiques de ghcr.io
+// sont lisibles sans compte, mais le registre exige quand même un jeton porteur.
+func ociToken(repo string) (string, error) {
+	u := fmt.Sprintf("%s/token?scope=repository:%s:pull&service=%s", ociBase, repo, ociHost())
+	resp, err := (&http.Client{Timeout: 30 * time.Second}).Get(u)
+	if err != nil {
+		return "", fmt.Errorf("registre %s injoignable : %w", ociHost(), err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != 200 {
+		return "", fmt.Errorf("%s/token : HTTP %d", ociHost(), resp.StatusCode)
+	}
+	var out struct {
+		Token string `json:"token"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil || out.Token == "" {
+		return "", fmt.Errorf("jeton de lecture illisible")
+	}
+	return out.Token, nil
+}
+
+// ociFetch fait un GET authentifié sur le registre.
+func ociFetch(url, token, accept string) (*http.Response, error) {
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Authorization", "Bearer "+token)
+	if accept != "" {
+		req.Header.Set("Accept", accept)
+	}
+	return (&http.Client{Timeout: 0}).Do(req)
+}
+
+// ociArch traduit GOARCH vers le nom de plateforme OCI.
+func ociArch() string {
+	if runtime.GOARCH == "arm64" {
+		return "arm64"
+	}
+	return "amd64"
+}
+
+// ociResolve lit le manifeste d'un tag et renvoie les couches de l'image pour
+// CETTE architecture, plus le numéro de build annoncé par l'image
+// (org.opencontainers.image.version, ex. « b10450 »).
+func ociResolve(repo, tag string) (layers []ociLayer, version string, err error) {
+	token, err := ociToken(repo)
+	if err != nil {
+		return nil, "", err
+	}
+	get := func(ref string) (*ociDoc, error) {
+		resp, err := ociFetch(fmt.Sprintf("%s/v2/%s/manifests/%s", ociBase, repo, ref), token, ociAccept)
+		if err != nil {
+			return nil, err
+		}
+		defer resp.Body.Close()
+		if resp.StatusCode == 404 {
+			return nil, fmt.Errorf("version inconnue dans le registre : %s", ref)
+		}
+		if resp.StatusCode != 200 {
+			return nil, fmt.Errorf("manifeste %s : HTTP %d", ref, resp.StatusCode)
+		}
+		var d ociDoc
+		if err := json.NewDecoder(resp.Body).Decode(&d); err != nil {
+			return nil, fmt.Errorf("manifeste %s illisible : %w", ref, err)
+		}
+		return &d, nil
+	}
+
+	doc, err := get(tag)
+	if err != nil {
+		return nil, "", err
+	}
+	version = doc.Annotations["org.opencontainers.image.version"]
+	if len(doc.Manifests) > 0 {
+		want := ociArch()
+		digest := ""
+		for _, m := range doc.Manifests {
+			if m.Platform.OS == "linux" && m.Platform.Architecture == want {
+				digest = m.Digest
+				break
+			}
+		}
+		if digest == "" {
+			return nil, "", fmt.Errorf("aucune image linux/%s pour %s", want, tag)
+		}
+		if doc, err = get(digest); err != nil {
+			return nil, "", err
+		}
+		if v := doc.Annotations["org.opencontainers.image.version"]; v != "" {
+			version = v
+		}
+	}
+	if len(doc.Layers) == 0 {
+		return nil, "", fmt.Errorf("manifeste %s sans couche", tag)
+	}
+	return doc.Layers, version, nil
+}
+
+// ---------------------------------------------------------------------------
+// Variante, version et emplacement du moteur
+// ---------------------------------------------------------------------------
+
+// engineOCISupported : ce mécanisme n'a de sens que là où ces images tournent.
+// Les images llama.cpp sont linux/amd64 et linux/arm64, rien d'autre.
+func engineOCISupported() bool {
+	return runtime.GOOS == "linux" && (runtime.GOARCH == "amd64" || runtime.GOARCH == "arm64")
+}
+
+// engineVariant déduit la variante d'image correspondant au moteur COURANT, en
+// regardant les backends ggml posés à côté du binaire. C'est la seule source
+// fiable : le conteneur ne sait pas de quelle image il a été bâti, et demander
+// à l'utilisateur de retenir « server-cuda » serait un piège à erreur.
+//
+// Renvoie un préfixe de tag : "server-cuda", "server-vulkan", "server-intel",
+// "server-musa", ou "server" (CPU) par défaut.
+func engineVariant() string {
+	dir := ""
+	if bin := currentEngineBin(); bin != "" {
+		dir = filepath.Dir(bin)
+	}
+	if dir == "" {
+		return "server"
+	}
+	has := func(prefix string) bool {
+		m, _ := filepath.Glob(filepath.Join(dir, prefix+"*"))
+		return len(m) > 0
+	}
+	switch {
+	case has("libggml-cuda.so"):
+		return "server-cuda"
+	case has("libggml-musa.so"):
+		return "server-musa"
+	case has("libggml-sycl.so"):
+		return "server-intel"
+	case has("libggml-vulkan.so"):
+		return "server-vulkan"
+	}
+	return "server"
+}
+
+// currentEngineBin : le binaire réellement utilisé (BIN de la configuration,
+// avec le repli sur le moteur de l'image quand BIN n'est pas encore posé).
+func currentEngineBin() string {
+	bin := prebuiltResolveBin(ReadConfig()["BIN"])
+	if bin != "" && isFile(bin) {
+		return bin
+	}
+	return providedEngineBin()
+}
+
+// La bannière de version de llama.cpp a changé de forme plusieurs fois, et un
+// binaire ancien reste parfaitement utilisable : on lit les trois formes.
+//
+//	version: 0.1.0-dev (build 10450, commit ece963f41)   ← actuelle
+//	version: 10450 (ece963f)                             ← précédente
+//	build: 4589 (a1b2c3d)                                ← plus ancienne
+//
+// C'est le NUMÉRO DE BUILD qui compte : c'est lui qui figure dans les tags
+// d'image (server-cuda-b10450) et donc la seule chose comparable entre ce qui
+// tourne et ce qui est publié.
+var reEngineBuildLong = regexp.MustCompile(`build\s+(\d+),\s*commit\s+([0-9a-fA-F]+)`)
+var reEngineBuildShort = regexp.MustCompile(`(?m)^\s*(?:version|build)\s*:\s*(\d+)\s*\(([0-9a-fA-F]+)\)`)
+
+func parseEngineBuild(out string) (build int, commit string) {
+	for _, re := range []*regexp.Regexp{reEngineBuildLong, reEngineBuildShort} {
+		if m := re.FindStringSubmatch(out); m != nil {
+			n, _ := strconv.Atoi(m[1])
+			return n, m[2]
+		}
+	}
+	return 0, ""
+}
+
+// engineBuildOf interroge un llama-server pour son numéro de build. Renvoie
+// (0, "") si le binaire ne répond pas — un moteur cassé ne doit pas empêcher
+// d'en installer un autre.
+func engineBuildOf(bin string) (int, string) {
+	if bin == "" || !isFile(bin) {
+		return 0, ""
+	}
+	cmd := hideCmd(exec.Command(bin, "--version"))
+	cmd.Env = libraryPathEnv(filepath.Dir(bin))
+	out, _ := cmd.CombinedOutput() // --version sort parfois en code non nul
+	return parseEngineBuild(string(out))
+}
+
+// engineDir : racine des moteurs installés par ce mécanisme, sous LOKI_HOME —
+// c'est-à-dire sur le volume /data en conteneur, donc conservés d'un
+// redémarrage (et d'une mise à jour d'image) à l'autre.
+func engineDir() string { return filepath.Join(LokiHome(), "engine") }
+
+// engineOwns dit si un chemin désigne un moteur installé ici.
+func engineOwns(p string) bool {
+	if p == "" {
+		return false
+	}
+	norm := func(s string) string { return strings.ToLower(filepath.ToSlash(filepath.Clean(s))) }
+	return strings.HasPrefix(norm(p), norm(engineDir())+"/")
+}
+
+// engineInstalled liste les moteurs présents sous engineDir(), du plus ancien
+// au plus récent (ordre des numéros de build).
+func engineInstalled() []string {
+	entries, err := os.ReadDir(engineDir())
+	if err != nil {
+		return nil
+	}
+	var tags []string
+	for _, e := range entries {
+		if e.IsDir() && isFile(filepath.Join(engineDir(), e.Name(), "llama-server")) {
+			tags = append(tags, e.Name())
+		}
+	}
+	sort.Slice(tags, func(i, j int) bool { return engineTagBuild(tags[i]) < engineTagBuild(tags[j]) })
+	return tags
+}
+
+var reTagBuild = regexp.MustCompile(`-b(\d+)$`)
+
+// engineTagBuild extrait le numéro de build d'un tag (« server-cuda-b10450 » →
+// 10450), 0 si le tag n'en porte pas (tag mouvant « server-cuda »).
+func engineTagBuild(tag string) int {
+	m := reTagBuild.FindStringSubmatch(tag)
+	if m == nil {
+		return 0
+	}
+	n, _ := strconv.Atoi(m[1])
+	return n
+}
+
+// engineTagOf : le tag d'un moteur téléchargé ici (« server-cuda-b10450 »), ""
+// pour tout autre chemin.
+func engineTagOf(bin string) string {
+	if !engineOwns(bin) {
+		return ""
+	}
+	return filepath.Base(filepath.Dir(bin))
+}
+
+// engineBinFor : chemin du llama-server d'une version installée.
+func engineBinFor(tag string) string {
+	p := filepath.Join(engineDir(), filepath.Base(tag), "llama-server")
+	if isFile(p) {
+		return p
+	}
+	return ""
+}
+
+// enginePrune supprime les versions installées autres que celles à garder.
+// Chaque version pèse ~450 Mo une fois décompressée : en laisser traîner cinq
+// remplit le volume /data sans rien apporter.
+func enginePrune(keep map[string]bool, logf func(string)) {
+	for _, tag := range engineInstalled() {
+		if keep[tag] {
+			continue
+		}
+		if err := os.RemoveAll(filepath.Join(engineDir(), tag)); err == nil && logf != nil {
+			logf("ancienne version supprimée : " + tag)
+		}
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Installation
+// ---------------------------------------------------------------------------
+
+// engineOCIInstall télécharge le moteur du tag demandé et l'installe dans
+// engineDir()/<tag>. Renvoie le chemin du llama-server installé.
+//
+// Réentrant : une version déjà installée est renvoyée telle quelle, et une
+// installation interrompue laisse un dossier « .part » qui est repris de zéro.
+func engineOCIInstall(tag string, logf, phasef func(string)) (string, error) {
+	tag = filepath.Base(strings.TrimSpace(tag)) // jamais de séparateur dans un nom de dossier
+	if tag == "" || tag == "." {
+		return "", fmt.Errorf("version du moteur non précisée")
+	}
+	if bin := engineBinFor(tag); bin != "" {
+		logf("déjà installé : " + tag)
+		return bin, nil
+	}
+
+	phasef("lecture du manifeste " + tag + "…")
+	layers, version, err := ociResolve(ociEngineRepo, tag)
+	if err != nil {
+		return "", err
+	}
+	if version != "" {
+		logf(fmt.Sprintf("image %s:%s — llama.cpp %s, %d couches", ociEngineRepo, tag, version, len(layers)))
+	}
+
+	dest := filepath.Join(engineDir(), tag)
+	tmp := dest + ".part"
+	if err := os.RemoveAll(tmp); err != nil {
+		return "", err
+	}
+	if err := os.MkdirAll(tmp, 0o755); err != nil {
+		return "", err
+	}
+	defer os.RemoveAll(tmp) // no-op après le rename final
+
+	token, err := ociToken(ociEngineRepo)
+	if err != nil {
+		return "", err
+	}
+
+	// On descend du SOMMET vers la base : /app est ajouté en dernier dans le
+	// Dockerfile amont, et les couches du bas sont le runtime CUDA et le système,
+	// déjà présents ici. Une couche du haut peut masquer un fichier d'une couche
+	// plus basse : le premier extrait gagne, comme le ferait un runtime OCI.
+	seen := map[string]bool{}
+	var links []archiveLink
+	for i := len(layers) - 1; i >= 0; i-- {
+		l := layers[i]
+		if l.Size > ociLayerCap {
+			logf(fmt.Sprintf("couche %d ignorée (%d Mo) : c'est le runtime de l'image, pas le moteur", i, l.Size/1_000_000))
+			break
+		}
+		part := filepath.Join(tmp, "layer.tgz")
+		if l.Size > 4<<20 {
+			phasef(fmt.Sprintf("téléchargement du moteur (%d Mo)…", l.Size/1_000_000))
+		}
+		if err := ociDownloadBlob(ociEngineRepo, l.Digest, token, part, l.Size, logf); err != nil {
+			return "", fmt.Errorf("téléchargement de la couche %d : %w", i, err)
+		}
+		n, err := extractAppLayer(part, tmp, seen, &links)
+		_ = os.Remove(part)
+		if err != nil {
+			return "", fmt.Errorf("extraction de la couche %d : %w", i, err)
+		}
+		if n > 0 {
+			logf(fmt.Sprintf("couche %d : %d fichiers du moteur", i, n))
+		}
+		if engineSetComplete(seen) {
+			break
+		}
+	}
+	if err := applyLinks(links); err != nil {
+		return "", err
+	}
+	if !seen["llama-server"] {
+		return "", fmt.Errorf("llama-server absent de l'image %s — variante inattendue ?", tag)
+	}
+
+	if err := os.RemoveAll(dest); err != nil {
+		return "", err
+	}
+	if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil {
+		return "", err
+	}
+	if err := os.Rename(tmp, dest); err != nil {
+		return "", err
+	}
+	bin := filepath.Join(dest, "llama-server")
+	if err := os.Chmod(bin, 0o755); err != nil {
+		return "", err
+	}
+	logf("moteur installé : " + bin)
+	return bin, nil
+}
+
+// engineSetComplete : a-t-on de quoi lancer le moteur ? Le binaire seul ne
+// suffit pas — depuis que llama.cpp éclate son code en bibliothèques, l'exécutable
+// tient dans une couche et ses .so dans la précédente. S'arrêter au binaire
+// donnait un moteur qui meurt sur « libllama.so: cannot open shared object ».
+func engineSetComplete(seen map[string]bool) bool {
+	if !seen["llama-server"] {
+		return false
+	}
+	base, llama := false, false
+	for name := range seen {
+		switch {
+		case strings.HasPrefix(name, "libggml-base.so"):
+			base = true
+		case strings.HasPrefix(name, "libllama.so"):
+			llama = true
+		}
+	}
+	return base && llama
+}
+
+// ociDownloadBlob télécharge une couche vers dest, avec la progression du
+// téléchargement dans le journal du job.
+func ociDownloadBlob(repo, digest, token, dest string, size int64, logf func(string)) error {
+	req, err := http.NewRequest("GET", fmt.Sprintf("%s/v2/%s/blobs/%s", ociBase, repo, digest), nil)
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Authorization", "Bearer "+token)
+	return downloadRequest(req, dest, size, logf)
+}
+
+// extractAppLayer extrait les entrées « app/… » d'une couche (tar.gz) à PLAT
+// dans dir, en ignorant celles déjà vues (une couche supérieure fait foi) et
+// les marqueurs de suppression OCI (.wh.*). Renvoie le nombre de fichiers
+// extraits. Les liens sont accumulés dans links : leur cible n'est pas
+// forcément déjà extraite au moment où on croise l'entrée.
+func extractAppLayer(archive, dir string, seen map[string]bool, links *[]archiveLink) (int, error) {
+	f, err := os.Open(archive)
+	if err != nil {
+		return 0, err
+	}
+	defer f.Close()
+	gz, err := gzip.NewReader(f)
+	if err != nil {
+		return 0, err
+	}
+	defer gz.Close()
+
+	count := 0
+	tr := tar.NewReader(gz)
+	for {
+		h, err := tr.Next()
+		if err == io.EOF {
+			return count, nil
+		}
+		if err != nil {
+			return count, err
+		}
+		name, ok := appEntryName(h.Name)
+		if !ok || seen[name] {
+			continue
+		}
+		p := filepath.Join(dir, name)
+		switch h.Typeflag {
+		case tar.TypeReg:
+			w, err := os.Create(p)
+			if err != nil {
+				return count, err
+			}
+			if _, err := io.Copy(w, tr); err != nil {
+				w.Close()
+				return count, err
+			}
+			w.Close()
+			_ = os.Chmod(p, os.FileMode(h.Mode)&0o777)
+			seen[name] = true
+			count++
+		case tar.TypeSymlink, tar.TypeLink:
+			// Indispensable : les .so sont livrés sous leur nom versionné
+			// (libllama.so.0.1.0) plus deux liens (libllama.so.0, libllama.so) —
+			// c'est le nom court que l'éditeur de liens cherche au lancement.
+			target, ok := appEntryName(h.Linkname)
+			if !ok {
+				target = filepath.Base(h.Linkname) // lien relatif au sein de /app
+			}
+			*links = append(*links, archiveLink{path: p, target: target})
+			seen[name] = true
+			count++
+		}
+	}
+}
+
+// appEntryName ramène « app/libllama.so » à « libllama.so ». Renvoie ok=false
+// pour tout ce qui n'est pas un fichier direct de /app : autres dossiers,
+// sous-dossiers, et marqueurs de suppression OCI.
+func appEntryName(raw string) (string, bool) {
+	p := strings.TrimPrefix(filepath.ToSlash(strings.TrimSpace(raw)), "./")
+	rest, ok := strings.CutPrefix(p, "app/")
+	if !ok || rest == "" || strings.Contains(rest, "/") {
+		return "", false
+	}
+	if strings.HasPrefix(rest, ".wh.") {
+		return "", false
+	}
+	return rest, true
+}
+
+// ---------------------------------------------------------------------------
+// Vérification et bascule
+// ---------------------------------------------------------------------------
+
+// engineOCILatest renvoie le dernier build publié pour la variante (numéro et
+// tag figé correspondant). On lit le tag MOUVANT (« server-cuda ») et son
+// annotation de version plutôt que de lister les 1000 tags du dépôt : une seule
+// requête, et c'est l'amont qui dit ce qu'est « la dernière ».
+func engineOCILatest(variant string) (build int, tag string, err error) {
+	_, version, err := ociResolve(ociEngineRepo, variant)
+	if err != nil {
+		return 0, "", err
+	}
+	if version == "" {
+		// Pas d'annotation : on retombe sur le tag mouvant lui-même, qui pointe
+		// bien sur la dernière image — on ne saura juste pas dire son numéro.
+		return 0, variant, nil
+	}
+	// L'annotation vaut « b10450 » : le tag figé est « server-cuda-b10450 ».
+	n, _ := strconv.Atoi(strings.TrimPrefix(version, "b"))
+	return n, variant + "-" + version, nil
+}
+
+// engineSmokeTest lance à blanc le moteur fraîchement installé — c'est là que
+// se joue le seul vrai risque de ce mécanisme. La mise à jour apporte llama.cpp,
+// PAS le runtime CUDA, qui reste celui de l'image : un llama.cpp compilé pour un
+// CUDA plus récent ne chargera pas son backend GPU ici.
+//
+// Deux échecs distincts, et le second est le sournois :
+//
+//  1. le binaire ne démarre pas du tout (bibliothèque manquante) — bruyant ;
+//  2. il démarre mais ne voit plus AUCUNE carte, alors que le moteur courant en
+//     voyait. Rien ne casse : le modèle se charge, tourne sur le processeur, et
+//     on ne s'en aperçoit qu'au débit. C'est le pire résultat possible, donc on
+//     le traite comme un échec de mise à jour.
+//
+// Ne voir aucune carte n'est un échec que si le moteur courant en voyait :
+// sur une machine sans GPU, « aucune carte » est le résultat normal.
+func engineSmokeTest(bin, ancien string) error {
+	devs, err := engineListDevices(bin)
+	if err != nil {
+		return err
+	}
+	if len(devs) > 0 {
+		return nil
+	}
+	if ancien == "" || ancien == bin {
+		return nil
+	}
+	avant, err := engineListDevices(ancien)
+	if err != nil || len(avant) == 0 {
+		return nil // le moteur courant n'en voyait pas plus : rien à reprocher au nouveau
+	}
+	return fmt.Errorf("le moteur téléchargé ne voit aucune carte graphique, alors que le moteur actuel en voit %d — "+
+		"il tournerait sur le processeur, beaucoup plus lentement", len(avant))
+}
+
+// engineListDevices lance `llama-server --list-devices` sur un binaire donné.
+func engineListDevices(bin string) ([]map[string]any, error) {
+	cmd := hideCmd(exec.Command(bin, "--list-devices"))
+	cmd.Env = libraryPathEnv(filepath.Dir(bin))
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		return nil, fmt.Errorf("le moteur ne démarre pas ici : %v\n%s", err, tailLines(string(out), 12))
+	}
+	return parseListDevices(string(out)), nil
+}
+
+// tailLines garde les n dernières lignes non vides d'une sortie.
+func tailLines(s string, n int) string {
+	lines := strings.Split(strings.TrimRight(s, "\n"), "\n")
+	if len(lines) > n {
+		lines = lines[len(lines)-n:]
+	}
+	return strings.Join(lines, "\n")
+}

internal/loki/backend_engine_oci_net_test.go

@@ -0,0 +1,53 @@
+package loki
+
+// Vérification contre le VRAI registre. Ignoré par défaut (la CI ne doit pas
+// dépendre du réseau ni télécharger 170 Mo) :
+//
+//	LOKI_NET_TEST=1 go test ./internal/loki -run TestMoteurReelDepuisGhcr -v
+//
+// Ce test existe parce que le faux registre ne peut pas garantir une chose : que
+// la DISPOSITION de l'image amont est toujours celle qu'on suppose. Si llama.cpp
+// range un jour son moteur autrement — sous-dossier, couche gigantesque, autre
+// jeu de bibliothèques — c'est ici qu'on le verra, et pas chez l'utilisateur.
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestMoteurReelDepuisGhcr(t *testing.T) {
+	if os.Getenv("LOKI_NET_TEST") == "" {
+		t.Skip("test réseau — LOKI_NET_TEST=1 pour l'exécuter")
+	}
+	if os.Getenv("LOKI_HOME") == "" {
+		t.Setenv("LOKI_HOME", t.TempDir())
+	}
+
+	build, tag, err := engineOCILatest("server-cuda")
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("dernier build publié : %d → %s", build, tag)
+	if build == 0 {
+		t.Error("numéro de build absent de l'annotation de l'image")
+	}
+
+	bin, err := engineOCIInstall(tag, func(s string) { t.Log(s) }, func(s string) { t.Log("▶ " + s) })
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := filepath.Dir(bin)
+	// Ce que l'éditeur de liens réclamera au lancement. Un seul manquant et le
+	// moteur meurt sur « cannot open shared object file ».
+	for _, n := range []string{"libllama.so", "libggml.so", "libggml-base.so", "libggml-cuda.so", "libmtmd.so"} {
+		if _, err := os.Stat(filepath.Join(dir, n)); err != nil {
+			t.Errorf("%s : %v", n, err)
+		}
+	}
+	// Et le binaire doit savoir dire sa version : c'est ce qui pilote la
+	// comparaison « installé vs publié » de tout le panneau.
+	if got, commit := engineBuildOf(bin); got != build {
+		t.Errorf("le moteur installé annonce le build %d (%s), attendu %d", got, commit, build)
+	}
+}

internal/loki/backend_engine_oci_test.go

@@ -0,0 +1,394 @@
+package loki
+
+// Mise à jour du moteur depuis l'image officielle llama.cpp.
+//
+// Ce qui se joue ici n'est pas « est-ce qu'on télécharge » mais « est-ce qu'on
+// télécharge le MINIMUM et est-ce que ce qu'on pose est LANÇABLE ». Deux pièges
+// concrets, tous deux invisibles sans test :
+//
+//   - l'image officielle range llama-server dans une couche et ses .so dans la
+//     précédente ; s'arrêter au binaire donne un moteur qui meurt sur
+//     « libllama.so: cannot open shared object file » ;
+//   - la couche du dessous est le runtime CUDA (2 Go). La descendre par erreur,
+//     c'est transformer une mise à jour de 170 Mo en un téléchargement de 2 Go.
+
+import (
+	"archive/tar"
+	"bytes"
+	"compress/gzip"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// --- Faux registre OCI ------------------------------------------------------
+
+// fauxCouche fabrique une couche tar.gz. Les entrées sont décrites par leur nom
+// complet dans l'archive ; une valeur préfixée par « -> » crée un lien.
+func fauxCouche(t *testing.T, entrees map[string]string) []byte {
+	t.Helper()
+	var buf bytes.Buffer
+	gz := gzip.NewWriter(&buf)
+	tw := tar.NewWriter(gz)
+	for nom, contenu := range entrees {
+		if cible, ok := strings.CutPrefix(contenu, "-> "); ok {
+			if err := tw.WriteHeader(&tar.Header{Name: nom, Typeflag: tar.TypeSymlink, Linkname: cible, Mode: 0o777}); err != nil {
+				t.Fatal(err)
+			}
+			continue
+		}
+		if err := tw.WriteHeader(&tar.Header{Name: nom, Typeflag: tar.TypeReg, Size: int64(len(contenu)), Mode: 0o755}); err != nil {
+			t.Fatal(err)
+		}
+		if _, err := tw.Write([]byte(contenu)); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := tw.Close(); err != nil {
+		t.Fatal(err)
+	}
+	if err := gz.Close(); err != nil {
+		t.Fatal(err)
+	}
+	return buf.Bytes()
+}
+
+// fauxRegistre sert un index multi-architecture, le manifeste amd64 et les
+// blobs. `tailles` permet d'annoncer une taille différente de la taille réelle
+// (c'est ce que lit le garde-fou des grosses couches). Renvoie le compteur des
+// blobs réellement téléchargés.
+func fauxRegistre(t *testing.T, version string, couches [][]byte, tailles []int64) (servis map[string]int) {
+	t.Helper()
+	servis = map[string]int{}
+	digests := make([]string, len(couches))
+	blobs := map[string][]byte{}
+	for i, c := range couches {
+		sum := sha256.Sum256(c)
+		digests[i] = "sha256:" + hex.EncodeToString(sum[:])
+		blobs[digests[i]] = c
+	}
+	manifeste := map[string]any{
+		"schemaVersion": 2,
+		"mediaType":     "application/vnd.oci.image.manifest.v1+json",
+		"layers": func() []map[string]any {
+			var out []map[string]any
+			for i := range couches {
+				taille := int64(len(couches[i]))
+				if tailles != nil && tailles[i] > 0 {
+					taille = tailles[i]
+				}
+				out = append(out, map[string]any{
+					"mediaType": "application/vnd.oci.image.layer.v1.tar+gzip",
+					"digest":    digests[i], "size": taille,
+				})
+			}
+			return out
+		}(),
+	}
+	manBytes, _ := json.Marshal(manifeste)
+	manSum := sha256.Sum256(manBytes)
+	manDigest := "sha256:" + hex.EncodeToString(manSum[:])
+
+	index := map[string]any{
+		"schemaVersion": 2,
+		"mediaType":     "application/vnd.oci.image.index.v1+json",
+		"manifests": []map[string]any{
+			// L'architecture qui ne nous concerne pas vient EN PREMIER : choisir
+			// « le premier manifeste » au lieu de filtrer sur la plateforme
+			// installerait un moteur d'une autre architecture.
+			{"digest": "sha256:mauvaise", "platform": map[string]string{"os": "linux", "architecture": "ppc64le"}},
+			{"digest": manDigest, "platform": map[string]string{"os": "linux", "architecture": ociArch()}},
+		},
+		"annotations": map[string]string{"org.opencontainers.image.version": version},
+	}
+	indexBytes, _ := json.Marshal(index)
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case strings.HasPrefix(r.URL.Path, "/token"):
+			_, _ = w.Write([]byte(`{"token":"jeton-de-test"}`))
+		case strings.Contains(r.URL.Path, "/manifests/"):
+			if r.Header.Get("Authorization") != "Bearer jeton-de-test" {
+				w.WriteHeader(401)
+				return
+			}
+			ref := r.URL.Path[strings.LastIndex(r.URL.Path, "/")+1:]
+			if ref == manDigest {
+				_, _ = w.Write(manBytes)
+				return
+			}
+			_, _ = w.Write(indexBytes)
+		case strings.Contains(r.URL.Path, "/blobs/"):
+			ref := r.URL.Path[strings.LastIndex(r.URL.Path, "/")+1:]
+			b, ok := blobs[ref]
+			if !ok {
+				w.WriteHeader(404)
+				return
+			}
+			servis[ref]++
+			_, _ = w.Write(b)
+		default:
+			w.WriteHeader(404)
+		}
+	}))
+	t.Cleanup(srv.Close)
+
+	ancien := ociBase
+	ociBase = srv.URL
+	t.Cleanup(func() { ociBase = ancien })
+	return servis
+}
+
+// --- Tests ------------------------------------------------------------------
+
+// Le cas réel : trois couches utiles au-dessus d'un runtime de 2 Go. On doit
+// prendre le binaire ET les bibliothèques, résoudre les liens de version, et
+// ne JAMAIS descendre jusqu'au runtime.
+func TestInstallationMoteurDepuisImage(t *testing.T) {
+	testHome(t)
+	couches := [][]byte{
+		fauxCouche(t, map[string]string{"usr/local/cuda/lib64/libcudart.so": "runtime CUDA"}), // 2 Go annoncés
+		fauxCouche(t, map[string]string{
+			"app/libggml-base.so":        "-> libggml-base.so.0",
+			"app/libggml-base.so.0":      "-> libggml-base.so.0.20.0",
+			"app/libggml-base.so.0.20.0": "binaire ELF",
+			"app/libllama.so":            "-> libllama.so.0",
+			"app/libllama.so.0":          "-> libllama.so.0.1.0",
+			"app/libllama.so.0.1.0":      "binaire ELF",
+			"app/libggml-cuda.so":        "binaire ELF",
+		}),
+		fauxCouche(t, map[string]string{"app/llama-server": "#!/bin/true\n", "app/llama": "#!/bin/true\n"}),
+		fauxCouche(t, map[string]string{"etc/passwd": "sans rapport"}),
+	}
+	servis := fauxRegistre(t, "b10450", couches, []int64{2 << 30, 0, 0, 0})
+
+	bin, err := engineOCIInstall("server-cuda-b10450", func(string) {}, func(string) {})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if veut := filepath.Join(engineDir(), "server-cuda-b10450", "llama-server"); bin != veut {
+		t.Errorf("binaire installé en %s, attendu %s", bin, veut)
+	}
+
+	// La couche du runtime CUDA ne doit pas avoir été demandée : c'est tout
+	// l'intérêt (170 Mo au lieu de 2,6 Go).
+	sum := sha256.Sum256(couches[0])
+	if n := servis["sha256:"+hex.EncodeToString(sum[:])]; n != 0 {
+		t.Errorf("la couche du runtime CUDA a été téléchargée %d fois", n)
+	}
+
+	dir := filepath.Dir(bin)
+	for _, nom := range []string{"llama-server", "llama", "libggml-cuda.so", "libggml-base.so.0.20.0", "libllama.so.0.1.0"} {
+		if !isFile(filepath.Join(dir, nom)) {
+			t.Errorf("%s manquant", nom)
+		}
+	}
+	// Les noms courts sont ceux que l'éditeur de liens cherche au lancement :
+	// sans eux le moteur ne démarre pas, alors que tout « a l'air » installé.
+	for _, lien := range []string{"libggml-base.so", "libggml-base.so.0", "libllama.so", "libllama.so.0"} {
+		p := filepath.Join(dir, lien)
+		if _, err := os.Stat(p); err != nil { // Stat suit le lien : vérifie aussi qu'il ne pend pas
+			t.Errorf("%s : %v", lien, err)
+		}
+	}
+	// /app à plat, et rien d'autre que /app.
+	if isDir(filepath.Join(dir, "etc")) || isDir(filepath.Join(dir, "usr")) {
+		t.Error("des fichiers hors /app ont été extraits")
+	}
+	// Windows n'a pas de bit exécutable : Stat y renvoie 0666/0444 quoi qu'il
+	// arrive, et l'assertion échouait toujours — alors que l'installation, elle,
+	// est correcte (le bit est bien posé côté Linux, là où le moteur tourne).
+	if st, err := os.Stat(bin); err != nil || (runtime.GOOS != "windows" && st.Mode()&0o100 == 0) {
+		t.Errorf("llama-server non exécutable : %v", err)
+	}
+
+	// Réinstaller la même version ne redemande RIEN au registre : le job de mise
+	// à jour repasse par là à chaque vérification.
+	total := func() int {
+		n := 0
+		for _, v := range servis {
+			n += v
+		}
+		return n
+	}
+	avant := total()
+	if _, err := engineOCIInstall("server-cuda-b10450", func(string) {}, func(string) {}); err != nil {
+		t.Fatal(err)
+	}
+	if total() != avant {
+		t.Errorf("une version déjà installée a été re-téléchargée (%d → %d couches)", avant, total())
+	}
+
+	// Et la version se retrouve dans la liste des moteurs installés.
+	if got := engineInstalled(); len(got) != 1 || got[0] != "server-cuda-b10450" {
+		t.Errorf("versions installées = %v", got)
+	}
+	if engineTagBuild("server-cuda-b10450") != 10450 {
+		t.Error("numéro de build mal extrait du tag")
+	}
+	if !engineOwns(bin) {
+		t.Error("le binaire installé n'est pas reconnu comme géré par Loki")
+	}
+}
+
+// Une variante dont l'image ne contient pas de llama-server (mauvais tag, image
+// « full » sans serveur) doit échouer CLAIREMENT, et ne rien laisser derrière
+// elle qui ressemblerait à un moteur installé.
+func TestInstallationRefuseUneImageSansMoteur(t *testing.T) {
+	testHome(t)
+	fauxRegistre(t, "b10450", [][]byte{
+		fauxCouche(t, map[string]string{"app/README": "pas de moteur ici"}),
+	}, nil)
+
+	if _, err := engineOCIInstall("server-b1", func(string) {}, func(string) {}); err == nil {
+		t.Fatal("installation acceptée sans llama-server")
+	}
+	if got := engineInstalled(); len(got) != 0 {
+		t.Errorf("versions installées après échec = %v", got)
+	}
+}
+
+// engineOCILatest lit le numéro de build dans l'annotation de l'image, et en
+// déduit le tag figé — c'est lui qu'on installe, pour que « mis à jour vers »
+// désigne une version précise et reproductible plutôt qu'un tag mouvant.
+func TestDerniereVersionPubliee(t *testing.T) {
+	fauxRegistre(t, "b10450", [][]byte{fauxCouche(t, map[string]string{"app/llama-server": "x"})}, nil)
+	build, tag, err := engineOCILatest("server-cuda")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if build != 10450 || tag != "server-cuda-b10450" {
+		t.Errorf("build=%d tag=%q", build, tag)
+	}
+}
+
+// La bannière du moteur est la seule source de vérité sur la version qui tourne
+// vraiment — le tag de l'image, lui, ment dès qu'on a basculé de moteur.
+func TestLectureVersionMoteur(t *testing.T) {
+	for _, c := range []struct {
+		nom, sortie string
+		build       int
+		commit      string
+	}{
+		// Relevée sur le binaire réel de l'image server-cuda-b10450.
+		{"forme actuelle", "version: 0.1.0-dev (build 10450, commit ece963f41)\nbuilt with GNU 14.2.0 for Linux x86_64\n", 10450, "ece963f41"},
+		{"forme précédente", "version: 10450 (ece963f)\nbuilt with cc\n", 10450, "ece963f"},
+		{"forme ancienne", "build: 4589 (a1b2c3d)\n", 4589, "a1b2c3d"},
+		{"bannière de démarrage", "ggml_cuda_init: found 1 device\nversion: 9001 (deadbee)\n", 9001, "deadbee"},
+		{"rien d'exploitable", "usage: llama-server [options]\n", 0, ""},
+	} {
+		t.Run(c.nom, func(t *testing.T) {
+			build, commit := parseEngineBuild(c.sortie)
+			if build != c.build || commit != c.commit {
+				t.Errorf("= (%d, %q), attendu (%d, %q)", build, commit, c.build, c.commit)
+			}
+		})
+	}
+}
+
+// Le filtre des entrées d'archive : on ne veut QUE les fichiers directs de /app.
+// Un sous-dossier ou un marqueur de suppression OCI recopié à plat produirait
+// des fichiers parasites à côté du binaire.
+func TestFiltreDesEntreesApp(t *testing.T) {
+	for _, c := range []struct {
+		entree, veut string
+		ok           bool
+	}{
+		{"app/llama-server", "llama-server", true},
+		{"./app/libllama.so", "libllama.so", true},
+		{"app/", "", false},
+		{"app/tools/quantize", "", false},
+		{"app/.wh.libggml-cuda.so", "", false},
+		{"usr/local/cuda/lib64/libcudart.so", "", false},
+		{"apparence/piege", "", false},
+	} {
+		got, ok := appEntryName(c.entree)
+		if ok != c.ok || got != c.veut {
+			t.Errorf("%q → (%q, %v), attendu (%q, %v)", c.entree, got, ok, c.veut, c.ok)
+		}
+	}
+}
+
+// Le binaire seul ne fait pas un moteur : c'est la règle d'arrêt de la descente
+// des couches.
+func TestMoteurCompletExigeLesBibliotheques(t *testing.T) {
+	vu := func(noms ...string) map[string]bool {
+		m := map[string]bool{}
+		for _, n := range noms {
+			m[n] = true
+		}
+		return m
+	}
+	if engineSetComplete(vu("llama-server")) {
+		t.Error("binaire seul accepté comme moteur complet")
+	}
+	if engineSetComplete(vu("llama-server", "libggml-base.so.0.20.0")) {
+		t.Error("moteur sans libllama accepté")
+	}
+	if !engineSetComplete(vu("llama-server", "libggml-base.so.0.20.0", "libllama.so.0.1.0")) {
+		t.Error("moteur complet refusé")
+	}
+}
+
+// La variante se déduit des backends posés à côté du binaire : c'est ce qui
+// évite de proposer une image CUDA à une installation Vulkan (et l'inverse).
+func TestVarianteDeduiteDesBackends(t *testing.T) {
+	for _, c := range []struct{ backend, veut string }{
+		{"libggml-cuda.so", "server-cuda"},
+		{"libggml-vulkan.so", "server-vulkan"},
+		{"libggml-sycl.so", "server-intel"},
+		{"libggml-musa.so", "server-musa"},
+		{"", "server"},
+	} {
+		t.Run(c.veut, func(t *testing.T) {
+			home := testHome(t)
+			dir := filepath.Join(home, "faux-moteur")
+			if err := os.MkdirAll(dir, 0o755); err != nil {
+				t.Fatal(err)
+			}
+			bin := filepath.Join(dir, "llama-server")
+			if err := os.WriteFile(bin, []byte("x"), 0o755); err != nil {
+				t.Fatal(err)
+			}
+			if c.backend != "" {
+				if err := os.WriteFile(filepath.Join(dir, c.backend), []byte("x"), 0o644); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if err := SetConfigKey("BIN", bin); err != nil {
+				t.Fatal(err)
+			}
+			if got := engineVariant(); got != c.veut {
+				t.Errorf("variante = %q, attendu %q", got, c.veut)
+			}
+		})
+	}
+}
+
+// Le ménage garde la version demandée et efface les autres : sans lui, chaque
+// mise à jour laisse ~450 Mo sur le volume de données.
+func TestMenageDesAnciennesVersions(t *testing.T) {
+	testHome(t)
+	for _, tag := range []string{"server-cuda-b1", "server-cuda-b2", "server-cuda-b3"} {
+		d := filepath.Join(engineDir(), tag)
+		if err := os.MkdirAll(d, 0o755); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filepath.Join(d, "llama-server"), []byte("x"), 0o755); err != nil {
+			t.Fatal(err)
+		}
+	}
+	enginePrune(map[string]bool{"server-cuda-b3": true}, nil)
+	got := engineInstalled()
+	if fmt.Sprint(got) != "[server-cuda-b3]" {
+		t.Errorf("après ménage : %v", got)
+	}
+}

internal/loki/backend_hf.go

@@ -67,6 +67,11 @@ type hfRepo struct {
 	ID        string `json:"id"`
 	Downloads int    `json:"downloads"`
 	Likes     int    `json:"likes"`
+	// Gated : le dépôt exige d'avoir accepté ses conditions ET un jeton. Il se
+	// LIT pourtant sans rien (arborescence en 200), et ne refuse qu'au moment du
+	// transfert : sans cette pastille, l'interface propose des quants avec leur
+	// verdict mémoire et le téléchargement échoue en 401 sans prévenir.
+	Gated bool `json:"gated"`
 }
 
 // hfEntry — un .gguf installable. Shards > 1 signale une famille de tranches :
@@ -85,6 +90,7 @@ type hfEntry struct {
 // hfListing — le contenu utile d'un dépôt, trié.
 type hfListing struct {
 	Repo       string    `json:"repo"`
+	Gated      bool      `json:"gated"`
 	Models     []hfEntry `json:"models"`
 	Projectors []hfEntry `json:"projectors"`
 	Drafts     []hfEntry `json:"drafts"`
@@ -95,13 +101,115 @@ type hfListing struct {
 // transfert : sans lui un dépôt gated répond 401 et Loki afficherait « aucun
 // résultat » là où il faudrait dire « dépôt à accès restreint ».
 func hfAuth(req *http.Request) {
-	if k := os.Getenv("HF_TOKEN"); k != "" {
+	if k := hfToken(); k != "" {
 		req.Header.Set("Authorization", "Bearer "+k)
 	}
 	req.Header.Set("User-Agent", "loki/"+Version)
 	req.Header.Set("Accept", "application/json")
 }
 
+// ---- Jeton Hugging Face -----------------------------------------------------
+//
+// Le jeton vivait UNIQUEMENT dans la variable d'environnement HF_TOKEN. En
+// conteneur, c'était l'exiger au mauvais moment : on découvre qu'un dépôt est
+// verrouillé depuis l'interface, et il faudrait éditer un docker-compose puis
+// recréer le conteneur pour y répondre. Il se règle donc aussi dans l'interface,
+// et se range là où sont déjà les secrets (base d'état) — pas dans config.env,
+// que le changement de preset réécrit en bloc.
+//
+// Priorité : le jeton enregistré d'abord, la variable d'environnement ensuite.
+// Rien d'enregistré = comportement d'avant, à l'octet près.
+
+// hfToken renvoie le jeton effectivement utilisé, ou "".
+func hfToken() string {
+	if t := strings.TrimSpace(getStr(bkState, "hf_token")); t != "" {
+		return t
+	}
+	return strings.TrimSpace(os.Getenv("HF_TOKEN"))
+}
+
+// hfTokenSource dit D'OÙ vient le jeton : « config » (enregistré ici), « env »
+// (HF_TOKEN du conteneur) ou "" (aucun). L'interface en a besoin pour ne pas
+// proposer d'effacer un jeton qu'elle ne peut pas effacer.
+func hfTokenSource() string {
+	switch {
+	case strings.TrimSpace(getStr(bkState, "hf_token")) != "":
+		return "config"
+	case strings.TrimSpace(os.Getenv("HF_TOKEN")) != "":
+		return "env"
+	}
+	return ""
+}
+
+// hfTokenSet dit si un jeton est disponible, pour que l'interface distingue
+// « il faut en poser un » de « celui qui est posé ne suffit pas ».
+func hfTokenSet() bool { return hfToken() != "" }
+
+// writeHFToken enregistre (ou efface, tok == "") le jeton. Le cache des réponses
+// Hugging Face est vidé au passage : il contient des listes obtenues SANS jeton,
+// où un dépôt verrouillé peut manquer ou paraître illisible.
+func writeHFToken(tok string) error {
+	if err := putStr(bkState, "hf_token", strings.TrimSpace(tok)); err != nil {
+		return err
+	}
+	hfCacheMu.Lock()
+	hfCache = map[string]hfCacheItem{}
+	hfCacheMu.Unlock()
+	return nil
+}
+
+// maskHFToken n'affiche qu'assez de caractères pour reconnaître le jeton posé.
+// Il n'est jamais renvoyé en clair : contrairement à la clé API du serveur,
+// personne n'a besoin de le recopier depuis Loki.
+func maskHFToken(t string) string {
+	t = strings.TrimSpace(t)
+	if t == "" {
+		return ""
+	}
+	if len(t) <= 8 {
+		return "…" + t[len(t)-2:]
+	}
+	return t[:3] + "…" + t[len(t)-4:]
+}
+
+// hfWhoAmI vérifie un jeton auprès de Hugging Face et renvoie le nom du compte.
+// Enregistrer un jeton sans le vérifier, c'est déplacer l'échec : on croirait le
+// problème réglé jusqu'au prochain 401, quinze minutes de téléchargement plus
+// tard.
+func hfWhoAmI(ctx context.Context, tok string) (string, error) {
+	ctx, cancel := context.WithTimeout(ctx, hfTimeout)
+	defer cancel()
+	req, err := http.NewRequestWithContext(ctx, "GET", hfHost+"/api/whoami-v2", nil)
+	if err != nil {
+		return "", err
+	}
+	req.Header.Set("Authorization", "Bearer "+strings.TrimSpace(tok))
+	req.Header.Set("User-Agent", "loki/"+Version)
+	req.Header.Set("Accept", "application/json")
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("Hugging Face injoignable : %v", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode == 401 || resp.StatusCode == 403 {
+		return "", fmt.Errorf("jeton refusé par Hugging Face (expiré, révoqué ou mal copié)")
+	}
+	if resp.StatusCode != 200 {
+		return "", fmt.Errorf("Hugging Face a répondu %d", resp.StatusCode)
+	}
+	var who struct {
+		Name string `json:"name"`
+	}
+	raw, err := io.ReadAll(io.LimitReader(resp.Body, 1<<20))
+	if err != nil {
+		return "", err
+	}
+	if err := json.Unmarshal(raw, &who); err != nil {
+		return "", err
+	}
+	return who.Name, nil
+}
+
 // hfCache : mémo commun à la recherche et aux arborescences, clé = l'URL
 // appelée. Sans lui, chaque frappe au clavier dans le champ de recherche
 // produit une requête sortante.
@@ -172,29 +280,99 @@ func hfSearch(ctx context.Context, q string) ([]hfRepo, error) {
 	if len(q) > hfMaxQuery {
 		q = q[:hfMaxQuery]
 	}
+	// `expand[]` remplace les champs par défaut de la réponse : `gated` s'y
+	// ajoute, mais downloads et likes doivent alors être redemandés
+	// explicitement, sinon ils disparaissent et la liste perd son classement
+	// lisible.
 	endpoint := hfHost + "/api/models?" + url.Values{
 		"search":    {q},
 		"filter":    {"gguf"},
 		"limit":     {fmt.Sprint(hfMaxRepos)},
 		"sort":      {"downloads"},
 		"direction": {"-1"},
+		"expand[]":  {"gated", "downloads", "likes"},
 	}.Encode()
 
 	var raw []struct {
 		ID        string `json:"id"`
 		Downloads int    `json:"downloads"`
 		Likes     int    `json:"likes"`
+		Gated     any    `json:"gated"`
 	}
 	if err := hfGetJSON(ctx, endpoint, hfSearchTTL, &raw); err != nil {
 		return nil, err
 	}
 	out := make([]hfRepo, 0, len(raw))
 	for _, r := range raw {
-		out = append(out, hfRepo{ID: r.ID, Downloads: r.Downloads, Likes: r.Likes})
+		out = append(out, hfRepo{ID: r.ID, Downloads: r.Downloads, Likes: r.Likes, Gated: hfGatedFlag(r.Gated)})
 	}
 	return out, nil
 }
 
+// hfGatedFlag lit le champ `gated` de l'API, qui n'est PAS un booléen : il vaut
+// false, "auto" (accepter les conditions suffit) ou "manual" (l'auteur valide
+// chaque demande). Les deux dernières valeurs verrouillent le téléchargement de
+// la même façon ; seule la présence d'un verrou nous intéresse ici.
+func hfGatedFlag(v any) bool {
+	switch g := v.(type) {
+	case bool:
+		return g
+	case string:
+		switch strings.ToLower(strings.TrimSpace(g)) {
+		case "", "false", "none", "no":
+			return false
+		}
+		return true
+	}
+	return false
+}
+
+// hfRepoGated dit si un dépôt est verrouillé. L'arborescence (hfFiles) ne porte
+// pas l'information : elle se lit sur la fiche du dépôt, en un appel séparé et
+// mis en cache comme elle. Une erreur ici ne doit RIEN casser — au pire on
+// n'affiche pas l'avertissement, et le téléchargement dira lui-même pourquoi il
+// a été refusé.
+func hfRepoGated(ctx context.Context, repo string) bool {
+	var info struct {
+		Gated any `json:"gated"`
+	}
+	endpoint := hfHost + "/api/models/" + repo + "?" + url.Values{"expand[]": {"gated"}}.Encode()
+	if err := hfGetJSON(ctx, endpoint, hfFilesTTL, &info); err != nil {
+		return false
+	}
+	return hfGatedFlag(info.Gated)
+}
+
+// isHFHost dit si un hôte appartient à Hugging Face. Sert à décider qui a le
+// droit de recevoir le jeton.
+func isHFHost(host string) bool {
+	h := strings.ToLower(host)
+	if i := strings.IndexByte(h, ':'); i >= 0 {
+		h = h[:i]
+	}
+	return h == "huggingface.co" || strings.HasSuffix(h, ".huggingface.co") ||
+		h == "hf.co" || strings.HasSuffix(h, ".hf.co")
+}
+
+// hfRepoFromURL retrouve « auteur/dépôt » dans un lien de téléchargement
+// Hugging Face, pour pouvoir le nommer dans un message d'erreur. Renvoie "" si
+// le lien pointe ailleurs.
+func hfRepoFromURL(raw string) string {
+	u, err := url.Parse(raw)
+	if err != nil || !strings.Contains(u.Host, "huggingface.co") {
+		return ""
+	}
+	segs := strings.Split(strings.Trim(u.Path, "/"), "/")
+	if len(segs) < 4 || (segs[2] != "resolve" && segs[2] != "blob") {
+		return ""
+	}
+	repo := segs[0] + "/" + segs[1]
+	if !hfRepoRe.MatchString(repo) {
+		return ""
+	}
+	return repo
+}
+
 // hfFiles liste les .gguf d'un dépôt et les range par famille.
 //
 // `recursive=1` n'est pas un confort : les quants volumineux vivent dans des
@@ -229,7 +407,9 @@ func hfFiles(ctx context.Context, repo string) (hfListing, error) {
 		}
 		files = append(files, hfFile{Path: f.Path, Size: n})
 	}
-	return hfClassify(repo, files), nil
+	out := hfClassify(repo, files)
+	out.Gated = hfRepoGated(ctx, repo)
+	return out, nil
 }
 
 // hfFile — une entrée d'arborescence, réduite à ce dont le classement a besoin.

internal/loki/backend_hf_test.go

@@ -1,6 +1,10 @@
 package loki
 
 import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http/httptest"
 	"strings"
 	"testing"
 )
@@ -205,3 +209,151 @@ func TestFitVerdict(t *testing.T) {
 		t.Errorf("le contexte ne change rien au verdict (%q dans les deux cas)", court)
 	}
 }
+
+// Le champ `gated` de l'API n'est pas un booléen : false, "auto" ou "manual".
+// Le lire comme un bool laissait passer les deux valeurs qui verrouillent
+// vraiment le téléchargement.
+func TestHFGatedFlag(t *testing.T) {
+	for _, c := range []struct {
+		in   any
+		want bool
+	}{
+		{nil, false},
+		{false, false},
+		{true, true},
+		{"auto", true},
+		{"manual", true},
+		{"false", false},
+		{"", false},
+	} {
+		if got := hfGatedFlag(c.in); got != c.want {
+			t.Errorf("hfGatedFlag(%#v) = %v, attendu %v", c.in, got, c.want)
+		}
+	}
+}
+
+// hfRepoFromURL sert à NOMMER le dépôt dans le message d'erreur : un lien qui
+// ne vient pas de Hugging Face ne doit rien produire plutôt qu'un nom inventé.
+func TestHFRepoFromURL(t *testing.T) {
+	for _, c := range []struct{ in, want string }{
+		{"https://huggingface.co/orcarouter/Qwen3.8-27B-Uncensored-GGUF/resolve/main/m.gguf", "orcarouter/Qwen3.8-27B-Uncensored-GGUF"},
+		{"https://huggingface.co/ggml-org/Qwen3.8-27B-GGUF/blob/main/sub/dir/m.gguf", "ggml-org/Qwen3.8-27B-GGUF"},
+		{"https://example.com/ggml-org/Qwen3.8-27B-GGUF/resolve/main/m.gguf", ""},
+		{"https://huggingface.co/ggml-org/Qwen3.8-27B-GGUF", ""},
+		{"pas une url", ""},
+	} {
+		if got := hfRepoFromURL(c.in); got != c.want {
+			t.Errorf("hfRepoFromURL(%q) = %q, attendu %q", c.in, got, c.want)
+		}
+	}
+}
+
+// Le jeton enregistré dans l'interface prime sur HF_TOKEN, et son absence
+// rend exactement le comportement d'avant : la variable d'environnement.
+func TestHFTokenPrecedence(t *testing.T) {
+	testHome(t)
+	t.Setenv("HF_TOKEN", "")
+	if hfToken() != "" || hfTokenSource() != "" || hfTokenSet() {
+		t.Fatalf("sans rien : jeton=%q source=%q", hfToken(), hfTokenSource())
+	}
+	t.Setenv("HF_TOKEN", "hf_env")
+	if hfToken() != "hf_env" || hfTokenSource() != "env" {
+		t.Fatalf("HF_TOKEN seul : jeton=%q source=%q", hfToken(), hfTokenSource())
+	}
+	if err := writeHFToken("  hf_enregistre  "); err != nil {
+		t.Fatal(err)
+	}
+	if hfToken() != "hf_enregistre" || hfTokenSource() != "config" {
+		t.Fatalf("jeton enregistré : jeton=%q source=%q", hfToken(), hfTokenSource())
+	}
+	// Retiré ici, la variable du conteneur reprend la main plutôt que de laisser
+	// Loki sans jeton alors que l'environnement en fournit un.
+	if err := writeHFToken(""); err != nil {
+		t.Fatal(err)
+	}
+	if hfToken() != "hf_env" || hfTokenSource() != "env" {
+		t.Fatalf("après retrait : jeton=%q source=%q", hfToken(), hfTokenSource())
+	}
+}
+
+// Le jeton ne doit jamais ressortir en clair de l'interface.
+func TestMaskHFToken(t *testing.T) {
+	if got := maskHFToken("hf_abcdefghijklmnop"); got != "hf_…mnop" {
+		t.Errorf("masque = %q", got)
+	}
+	if got := maskHFToken(""); got != "" {
+		t.Errorf("masque d'un jeton absent = %q", got)
+	}
+	if strings.Contains(maskHFToken("hf_abcdefghijklmnop"), "efghij") {
+		t.Error("le masque laisse voir le milieu du jeton")
+	}
+}
+
+// Un secret ne part QUE vers Hugging Face : un lien collé vers un autre
+// hébergeur ne doit pas recevoir le jeton du compte.
+func TestDLRequestTokenOnlyToHuggingFace(t *testing.T) {
+	testHome(t)
+	t.Setenv("HF_TOKEN", "hf_secret")
+	for _, c := range []struct {
+		url  string
+		want bool
+	}{
+		{"https://huggingface.co/a/b/resolve/main/m.gguf", true},
+		{"https://cdn-lfs.huggingface.co/a/b/m.gguf", true},
+		{"https://hf.co/a/b/resolve/main/m.gguf", true},
+		{"https://example.com/m.gguf", false},
+		{"https://huggingface.co.evil.example/m.gguf", false},
+	} {
+		req, err := dlRequest(context.Background(), c.url, "")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got := req.Header.Get("Authorization") != ""; got != c.want {
+			t.Errorf("%s : en-tête Authorization présent=%v, attendu %v", c.url, got, c.want)
+		}
+	}
+}
+
+// La route décrit le jeton sans jamais le rendre, et l'efface sans appeler
+// Hugging Face (un jeton vide n'a rien à vérifier).
+func TestHandleHFTokenGetAndClear(t *testing.T) {
+	testHome(t)
+	t.Setenv("HF_TOKEN", "")
+	if err := writeHFToken("hf_abcdefghijklmnop"); err != nil {
+		t.Fatal(err)
+	}
+
+	call := func(method, body string) map[string]any {
+		t.Helper()
+		r := httptest.NewRequest(method, "http://placeholder/api/hf/token", strings.NewReader(body))
+		w := httptest.NewRecorder()
+		handleHFToken(w, r)
+		if w.Code != 200 {
+			t.Fatalf("%s → HTTP %d : %s", method, w.Code, w.Body.String())
+		}
+		var out map[string]any
+		if err := json.Unmarshal(w.Body.Bytes(), &out); err != nil {
+			t.Fatal(err)
+		}
+		return out
+	}
+
+	got := call("GET", "")
+	if got["set"] != true || got["source"] != "config" {
+		t.Fatalf("état lu = %v", got)
+	}
+	if s, _ := got["masked"].(string); s == "" || strings.Contains(s, "efghij") {
+		t.Fatalf("masque inattendu : %q", s)
+	}
+	if strings.Contains(fmt.Sprint(got), "hf_abcdefghijklmnop") {
+		t.Fatalf("le jeton ressort en clair : %v", got)
+	}
+
+	got = call("POST", `{"token":""}`)
+	if got["set"] != false || got["source"] != "" {
+		t.Fatalf("après effacement = %v", got)
+	}
+	if hfToken() != "" {
+		t.Fatalf("jeton toujours présent : %q", hfToken())
+	}
+}

internal/loki/backend_model_dirs.go

@@ -264,10 +264,12 @@ func handleModelDirs(w http.ResponseWriter, r *http.Request) {
 		sendJSON(w, 200, map[string]any{"ok": true})
 		return
 	}
-	out := []map[string]any{{"path": modelsDir(), "home": true, "count": modelDirCount(modelsDir()), "exists": true, "free": diskFree(modelsDir())}}
+	out := []map[string]any{{"path": modelsDir(), "home": true, "count": modelDirCount(modelsDir()), "exists": true,
+		"free": diskFree(modelsDir()), "free_exact": diskFreeReliable(modelsDir())}}
 	for _, d := range extraModelDirs() {
 		n := modelDirCount(d)
-		out = append(out, map[string]any{"path": d, "home": false, "count": n, "exists": n >= 0, "free": diskFree(d)})
+		out = append(out, map[string]any{"path": d, "home": false, "count": n, "exists": n >= 0,
+			"free": diskFree(d), "free_exact": diskFreeReliable(d)})
 	}
 	sendJSON(w, 200, map[string]any{"ok": true, "dirs": out, "env": os.Getenv("LOKI_MODEL_DIRS") != ""})
 }

internal/loki/backend_models.go

@@ -70,6 +70,79 @@ func reasoningActive(v string) bool {
 	return true
 }
 
+// ReasoningEfforts liste les valeurs proposées par l'UI pour REASONING_EFFORT.
+// "" (auto) n'y figure pas : c'est l'absence de réglage.
+//
+// Aucun gabarit ne les connaît toutes — gpt-oss lit low/medium/high, Qwen3.8 lit
+// low/medium/xhigh — et certains REFUSENT celles qu'ils ne connaissent pas (voir
+// llm_effort.go, qui traduit alors vers le niveau accepté le plus proche). La
+// liste reste donc l'union des niveaux courants plutôt que le plus petit
+// dénominateur commun, sinon le maximum d'un modèle est hors d'atteinte.
+var ReasoningEfforts = []string{"none", "low", "medium", "high", "xhigh"}
+
+// reasoningEffortValue normalise REASONING_EFFORT en une valeur envoyable telle
+// quelle à llama-server, ou "" pour ne rien envoyer du tout.
+//
+// llama-server accepte `reasoning_effort` dans /v1/chat/completions : la valeur
+// `none` coupe le raisonnement, toute autre valeur est simplement passée au
+// gabarit jinja du modèle. Un gabarit qui ne la lit pas l'ignore sans erreur ;
+// un gabarit qui la VALIDE, lui, peut lever une exception jinja et faire
+// répondre 500 à llama-server (Qwen3.8 sur « high »). Le repli n'est pas ici —
+// on ne sait pas d'avance ce que le gabarit accepte — mais dans llm_effort.go,
+// qui apprend la réponse du refus lui-même et rejoue le tour.
+func reasoningEffortValue(v string) string {
+	switch s := strings.ToLower(strings.TrimSpace(v)); s {
+	case "", "auto", "default":
+		return "" // rien envoyé : le gabarit garde son comportement
+	case "off", "false", "0", "no", "disable", "disabled", "none":
+		return "none"
+	case "low", "medium", "high":
+		return s
+	default:
+		// Valeur inconnue (éditée à la main) : on ne l'invente pas, on la laisse
+		// passer au gabarit, qui l'ignorera s'il ne la connaît pas.
+		return s
+	}
+}
+
+// reasoningTemplateKwargs construit les `chat_template_kwargs` à joindre à une
+// requête de chat pour que « aucune » coupe VRAIMENT le raisonnement.
+//
+// Pourquoi ce doublon avec `reasoning_effort` : ce champ n'agit que sur les
+// gabarits qui le LISENT (gpt-oss et apparentés). Un modèle hybride à la Qwen3
+// ne connaît que `enable_thinking` — on lui envoie `reasoning_effort: none`, son
+// gabarit l'ignore, et il continue de réfléchir alors que l'interface affiche
+// « aucune ». Les llama-server récents traduisent eux-mêmes `none` en
+// `enable_thinking=false`, mais pas les binaires plus anciens, qui laissent
+// simplement tomber le champ.
+//
+// D'où la règle : quand le raisonnement doit être coupé, on le dit dans la
+// langue que TOUS les gabarits comprennent. `chat_template_kwargs` est passé tel
+// quel au gabarit jinja ; une clé qu'il n'utilise pas est ignorée sans erreur.
+// Même procédé que la compaction (chat_compact.go), qui coupe déjà la réflexion
+// de cette façon.
+//
+// off = REASONING explicitement à off. Clé absente ≠ off : sans consigne on ne
+// touche à rien, le gabarit garde son défaut.
+// Renvoie nil quand il n'y a rien à imposer.
+func reasoningTemplateKwargs(off bool, effort string) map[string]any {
+	if off || effort == "none" {
+		return map[string]any{"enable_thinking": false}
+	}
+	if effort != "" {
+		// Niveau explicite : les vieux binaires ne relaient pas le champ de haut
+		// niveau au gabarit, celui-ci passe toujours.
+		return map[string]any{"reasoning_effort": effort}
+	}
+	return nil
+}
+
+// reasoningExplicitlyOff dit si REASONING interdit le raisonnement. Une clé
+// absente ou vide n'est PAS une interdiction : c'est l'absence de consigne.
+func reasoningExplicitlyOff(v string) bool {
+	return strings.TrimSpace(v) != "" && !reasoningActive(v)
+}
+
 // detectQuant returns the quantization tag for a preset: an explicit QUANT= line
 // (manual override, with or without a leading '#') wins; otherwise it is
 // auto-detected from the MODEL= filename. Returns "" when unknown.
@@ -337,6 +410,13 @@ func checkDiskSpace(dir string, size int64) error {
 	if size <= 0 || free < 0 {
 		return nil
 	}
+	// Système de fichiers dont statfs approxime (FUSE/shfs d'Unraid, overlay,
+	// réseau) : le chiffre reste affiché, mais il ne peut plus REFUSER un
+	// téléchargement. Vécu : « 11,9 Go libres » annoncés sur un partage Unraid
+	// qui en avait des centaines, et l'installation du modèle bloquée.
+	if !diskFreeReliable(dir) {
+		return nil
+	}
 	if free < size+dlSpaceMargin {
 		return fmt.Errorf("espace insuffisant sur %s : %s libres, %s nécessaires", dir, humanBytes(free), humanBytes(size+dlSpaceMargin))
 	}
@@ -393,7 +473,8 @@ func handleModelDownloadProbe(w http.ResponseWriter, r *http.Request) {
 		}
 		total += n
 	}
-	out := map[string]any{"ok": true, "filename": name, "dir": dir, "size": total, "free": diskFree(dir), "enough": true, "parts": len(urls)}
+	out := map[string]any{"ok": true, "filename": name, "dir": dir, "size": total,
+		"free": diskFree(dir), "free_exact": diskFreeReliable(dir), "enough": true, "parts": len(urls)}
 	if err := checkDiskSpace(dir, total); err != nil {
 		out["enough"] = false
 		out["error"] = err.Error()
@@ -408,8 +489,12 @@ func dlRequest(ctx context.Context, dlURL, rng string) (*http.Request, error) {
 	if err != nil {
 		return nil, err
 	}
-	// HF gated/private repos may need a token; reuse the same key store if set.
-	if k := os.Getenv("HF_TOKEN"); k != "" {
+	// Dépôt gated/privé : le jeton (réglage de l'interface, sinon HF_TOKEN) est
+	// ce qui débloque le transfert. Il n'accompagne QUE les liens Hugging Face :
+	// un lien collé vers un autre hébergeur n'a aucune raison de recevoir un
+	// secret, et le CDN vers lequel HF redirige est signé, donc n'en a pas besoin
+	// non plus (Go retire l'en-tête au changement de domaine).
+	if k := hfToken(); k != "" && isHFHost(req.URL.Host) {
 		req.Header.Set("Authorization", "Bearer "+k)
 	}
 	req.Header.Set("User-Agent", "loki/"+Version)
@@ -433,6 +518,75 @@ func contentRangeTotal(v string) int64 {
 	return n
 }
 
+// dlSourceError traduit un refus HTTP en phrase qui dit quoi faire.
+//
+// Vécu : un dépôt Hugging Face « gated » (conditions à accepter avant de
+// télécharger) répond 200 sur son arborescence — Loki liste donc tous ses
+// quants, avec leur verdict mémoire — puis 401 sur CHAQUE .gguf. « HTTP 401
+// depuis la source » ne dit alors ni que le dépôt est verrouillé, ni qu'il faut
+// un jeton, ni où l'accepter : l'utilisateur voit un modèle proposé comme
+// installable qui échoue sans raison.
+//
+// Hugging Face, lui, le dit — dans l'en-tête X-Error-Code (GatedRepo,
+// RepoNotFound, EntryNotFound…). On le traduit plutôt que de le recopier :
+// l'interface est en français, et le message d'origine (« Please log in »)
+// parle d'une session de navigateur qui n'existe pas ici.
+func dlSourceError(resp *http.Response, dlURL string) error {
+	code := resp.Header.Get("X-Error-Code")
+	switch resp.StatusCode {
+	case 401, 403:
+		return fmt.Errorf("%s%s", dlAccessReason(code, hfRepoFromURL(dlURL)), dlTokenHint())
+	case 404:
+		switch code {
+		case "EntryNotFound":
+			return fmt.Errorf("fichier absent du dépôt (HTTP 404) — la révision a pu être réécrite depuis que le lien a été copié")
+		case "RevisionNotFound":
+			return fmt.Errorf("révision introuvable dans le dépôt (HTTP 404)")
+		}
+		return fmt.Errorf("lien introuvable (HTTP 404)")
+	case 416:
+		return fmt.Errorf("la source refuse la plage d'octets demandée (HTTP 416) — fichier modifié pendant le transfert ?")
+	case 429:
+		return fmt.Errorf("trop de requêtes vers la source (HTTP 429) — réessaie dans quelques minutes")
+	}
+	if resp.StatusCode >= 500 {
+		return fmt.Errorf("la source est en panne (HTTP %d) — réessaie plus tard", resp.StatusCode)
+	}
+	return fmt.Errorf("HTTP %d depuis la source", resp.StatusCode)
+}
+
+// dlAccessReason nomme la raison du refus. repo vide = source hors Hugging Face
+// (lien direct vers un autre hébergeur) : on ne parle alors pas de conditions à
+// accepter, qui n'existent que là-bas.
+func dlAccessReason(code, repo string) string {
+	switch code {
+	case "GatedRepo":
+		if repo == "" {
+			return "dépôt à accès restreint : ses conditions doivent être acceptées sur huggingface.co"
+		}
+		return "dépôt à accès restreint : accepte ses conditions sur huggingface.co/" + repo
+	case "RepoNotFound":
+		if repo == "" {
+			return "dépôt privé ou inexistant"
+		}
+		return "dépôt privé ou inexistant : " + repo
+	}
+	if repo != "" {
+		return "accès refusé par Hugging Face sur " + repo
+	}
+	return "accès refusé par la source"
+}
+
+// dlTokenHint complète la raison par l'état du jeton. Deux situations opposées
+// se cachent derrière le même 401 : pas de jeton du tout, ou un jeton qui n'a
+// pas accès à CE dépôt — et le geste à faire n'est pas le même.
+func dlTokenHint() string {
+	if !hfTokenSet() {
+		return " — puis renseigne le jeton Hugging Face (réglage « Jeton Hugging Face », ou variable d'environnement HF_TOKEN)"
+	}
+	return " — le jeton Hugging Face enregistré n'y donne pas accès (expiré, ou conditions non acceptées avec ce compte)"
+}
+
 // dlProbe asks the server for the first byte to learn the total size and
 // whether ranges are supported (206 + Content-Range).
 func dlProbe(ctx context.Context, dlURL string) (total int64, ranged bool, err error) {
@@ -456,7 +610,7 @@ func dlProbe(ctx context.Context, dlURL string) (total int64, ranged bool, err e
 		// Server ignored the Range: single stream, ContentLength is the size.
 		return resp.ContentLength, false, nil
 	default:
-		return 0, false, fmt.Errorf("HTTP %d depuis la source", resp.StatusCode)
+		return 0, false, dlSourceError(resp, dlURL)
 	}
 }
 
@@ -682,8 +836,9 @@ func dlChunk(ctx context.Context, f *os.File, dlURL string, start, end int64, wh
 			continue
 		}
 		if resp.StatusCode != 200 && resp.StatusCode != 206 {
+			err := dlSourceError(resp, dlURL)
 			resp.Body.Close()
-			return fmt.Errorf("HTTP %d depuis la source", resp.StatusCode)
+			return err
 		}
 		if resp.StatusCode == 200 && pos > start {
 			// Resume refused: the body restarts from 0, rewind our bookkeeping.

internal/loki/backend_models_dl_test.go

@@ -9,6 +9,7 @@ import (
 	"os"
 	"path/filepath"
 	"strconv"
+	"strings"
 	"testing"
 	"time"
 )
@@ -135,3 +136,90 @@ func TestRunDownloadParallelAndFallback(t *testing.T) {
 		}
 	}
 }
+
+// Un dépôt Hugging Face verrouillé répond 401 sur le .gguf alors que son
+// arborescence se lit sans jeton. « HTTP 401 depuis la source » n'apprenait
+// rien : le message doit nommer le verrou, le dépôt, et le geste à faire.
+func TestDLSourceErrorExplainsGatedRepo(t *testing.T) {
+	const gated = "https://huggingface.co/orcarouter/Qwen3.8-27B-Uncensored-GGUF/resolve/main/m.gguf"
+	resp := func(status int, code string) *http.Response {
+		r := &http.Response{StatusCode: status, Header: http.Header{}}
+		if code != "" {
+			r.Header.Set("X-Error-Code", code)
+		}
+		return r
+	}
+	for _, c := range []struct {
+		name   string
+		token  string
+		resp   *http.Response
+		url    string
+		want   []string
+		absent []string
+	}{
+		{
+			name: "gated sans jeton", resp: resp(401, "GatedRepo"), url: gated,
+			want: []string{"accès restreint", "orcarouter/Qwen3.8-27B-Uncensored-GGUF", "HF_TOKEN"},
+		},
+		{
+			name: "gated avec jeton refusé", token: "hf_xxx", resp: resp(401, "GatedRepo"), url: gated,
+			want:   []string{"accès restreint", "n'y donne pas accès"},
+			absent: []string{"renseigne le jeton"},
+		},
+		{
+			name: "dépôt privé ou absent", resp: resp(401, "RepoNotFound"), url: gated,
+			want: []string{"privé ou inexistant", "HF_TOKEN"},
+		},
+		{
+			name: "fichier absent", resp: resp(404, "EntryNotFound"), url: gated,
+			want: []string{"absent du dépôt", "404"},
+		},
+		{
+			name: "source hors Hugging Face", resp: resp(403, ""), url: "https://example.com/m.gguf",
+			want:   []string{"accès refusé par la source"},
+			absent: []string{"huggingface.co"},
+		},
+		{
+			name: "panne de la source", resp: resp(503, ""), url: gated,
+			want: []string{"en panne", "503"},
+		},
+		{
+			name: "code inconnu", resp: resp(418, ""), url: gated,
+			want: []string{"HTTP 418 depuis la source"},
+		},
+	} {
+		t.Run(c.name, func(t *testing.T) {
+			t.Setenv("HF_TOKEN", c.token)
+			got := dlSourceError(c.resp, c.url).Error()
+			for _, w := range c.want {
+				if !strings.Contains(got, w) {
+					t.Errorf("message %q ne contient pas %q", got, w)
+				}
+			}
+			for _, a := range c.absent {
+				if strings.Contains(got, a) {
+					t.Errorf("message %q contient %q alors qu'il ne devrait pas", got, a)
+				}
+			}
+		})
+	}
+}
+
+// La sonde est le premier appel réseau d'une installation : c'est elle qui doit
+// remonter le refus expliqué, pas un code HTTP nu.
+func TestDLProbeSurfacesExplainedError(t *testing.T) {
+	t.Setenv("HF_TOKEN", "")
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("X-Error-Code", "GatedRepo")
+		w.WriteHeader(401)
+	}))
+	defer srv.Close()
+
+	_, _, err := dlProbe(context.Background(), srv.URL+"/m.gguf")
+	if err == nil {
+		t.Fatal("un 401 doit faire échouer la sonde")
+	}
+	if !strings.Contains(err.Error(), "HF_TOKEN") {
+		t.Errorf("message %q sans indication sur le jeton", err)
+	}
+}

internal/loki/backend_prebuilt.go

@@ -440,8 +440,18 @@ func prebuiltInstall(logf, phasef func(string)) (string, error) {
 // downloadWithProgress télécharge url vers dest en journalisant la progression
 // par tranches de ~25 Mo.
 func downloadWithProgress(url, dest string, total int64, logf func(string)) error {
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return err
+	}
+	return downloadRequest(req, dest, total, logf)
+}
+
+// downloadRequest est la même chose pour une requête déjà construite — un
+// registre OCI exige un en-tête d'autorisation, même en lecture anonyme.
+func downloadRequest(req *http.Request, dest string, total int64, logf func(string)) error {
 	client := &http.Client{Timeout: 0}
-	resp, err := client.Get(url)
+	resp, err := client.Do(req)
 	if err != nil {
 		return err
 	}

internal/loki/backend_sampling_test.go

@@ -0,0 +1,56 @@
+package loki
+
+import "testing"
+
+// Le sampling du preset doit se retrouver dans le corps de la requête, avec les
+// bons types (top_k entier, le reste flottant), et TEMP écrase la température
+// déjà posée. Une clé vide n'ajoute rien : le serveur garde son défaut.
+func TestApplySamplingFrom(t *testing.T) {
+	payload := map[string]any{"temperature": 0.7}
+	applySamplingFrom(payload, map[string]string{
+		"TEMP":             "1.0",
+		"TOP_P":            "0.95",
+		"TOP_K":            "20",
+		"MIN_P":            "0",
+		"REPEAT_PENALTY":   "1.05",
+		"PRESENCE_PENALTY": "", // vide → ignoré
+	})
+	if payload["temperature"] != 1.0 {
+		t.Errorf("TEMP doit écraser la température : %v", payload["temperature"])
+	}
+	if payload["top_p"] != 0.95 || payload["min_p"] != 0.0 || payload["repeat_penalty"] != 1.05 {
+		t.Errorf("flottants attendus : %v %v %v", payload["top_p"], payload["min_p"], payload["repeat_penalty"])
+	}
+	if payload["top_k"] != 20 {
+		t.Errorf("top_k doit être un entier 20, pas %#v", payload["top_k"])
+	}
+	if _, ok := payload["presence_penalty"]; ok {
+		t.Error("une clé vide ne doit rien envoyer")
+	}
+}
+
+// L'échantillonnage ne touche PAS au raisonnement : ce chemin appartient à
+// llm_client.go/llm_effort.go, qui y met aussi `enable_thinking`. L'amont écrit
+// `chat_template_kwargs` ici ; le faire chez nous effacerait la consigne
+// « aucune » — donc le modèle réfléchirait alors que l'interface dit l'inverse.
+func TestApplySamplingNeTouchePasAuRaisonnement(t *testing.T) {
+	payload := map[string]any{"chat_template_kwargs": map[string]any{"enable_thinking": false}}
+	applySamplingFrom(payload, map[string]string{"REASONING_EFFORT": "medium", "TOP_K": "20"})
+	kw, ok := payload["chat_template_kwargs"].(map[string]any)
+	if !ok || kw["enable_thinking"] != false || len(kw) != 1 {
+		t.Errorf("chat_template_kwargs modifié : %v", payload["chat_template_kwargs"])
+	}
+	if _, ok := payload["reasoning_effort"]; ok {
+		t.Error("reasoning_effort ne doit pas être posé par l'échantillonnage")
+	}
+}
+
+// Sans aucune clé de sampling, le payload n'est pas modifié : on ne force pas de
+// valeurs qui contrediraient le défaut du modèle.
+func TestApplySamplingEmpty(t *testing.T) {
+	payload := map[string]any{"temperature": 0.7}
+	applySamplingFrom(payload, map[string]string{})
+	if len(payload) != 1 || payload["temperature"] != 0.7 {
+		t.Errorf("payload modifié à tort : %v", payload)
+	}
+}

internal/loki/backend_serve.go

@@ -108,6 +108,14 @@ func cmdServe(args []string) error {
 		"-ub", get("UBATCH", "512"),
 		"--host", get("HOST", "0.0.0.0"),
 		"--port", get("PORT", "8080"),
+		// --parallel 1 EXPLICITE : les llama-server récents ouvrent 4 slots par
+		// défaut, soit des tampons de calcul GPU ×4 — pour un serveur mono-
+		// utilisateur comme Loki, c'est de la VRAM brûlée pour rien. Vécu : une
+		// config 27B/60k ctx qui tournait très bien est morte en « cudaMalloc
+		// failed: out of memory » après une mise à jour du moteur, uniquement à
+		// cause de ce nouveau défaut. PARALLEL=n dans le preset pour qui veut
+		// vraiment servir plusieurs requêtes à la fois.
+		"--parallel", get("PARALLEL", "1"),
 	}
 	// NGL=auto : on n'envoie PAS -ngl, et llama.cpp choisit lui-même combien de
 	// couches tiennent dans la VRAM libre (common_fit_params). Il s'en abstient
@@ -176,9 +184,7 @@ func cmdServe(args []string) error {
 	// exige alors l'en-tête "Authorization: Bearer <clé>". La clé est lue depuis
 	// $LOKI_HOME/.api_key en priorité (elle survit ainsi aux changements de preset
 	// qui réécrivent config.env), avec config.env comme repli rétro-compatible.
-	if k := readAPIKey(); k != "" {
-		llmArgs = append(llmArgs, "--api-key", k)
-	} else if k := cfg["API_KEY"]; k != "" {
+	if k, _ := effectiveAPIKeyErr(); k != "" {
 		llmArgs = append(llmArgs, "--api-key", k)
 	}
 	// EXTRA_ARGS is appended verbatim, split like the shell would — quotes kept

internal/loki/chat_conversation.go

@@ -56,6 +56,12 @@ type Conversation struct {
 	Generating bool               `json:"-"`
 	cancel     context.CancelFunc // annule la génération en cours (/stop)
 	epoch      int                // incrémenté à chaque reset → invalide les abonnés
+	// Tâche planifiée en cours (tasks_run.go). Le verrou de génération est le
+	// SEUL point partagé entre une tâche de fond et le chat : ces deux champs
+	// disent à l'interface POURQUOI elle est occupée, au lieu de laisser croire
+	// à une génération fantôme dans la discussion ouverte.
+	runningTaskID   string
+	runningTaskName string
 }
 
 var conv = func() *Conversation {
@@ -286,12 +292,42 @@ func (c *Conversation) state() map[string]any {
 			turns++
 		}
 	}
-	return map[string]any{"seq": c.Seq, "generating": c.Generating, "ctx_used": c.CtxUsed, "turns": turns}
+	st := map[string]any{"seq": c.Seq, "generating": c.Generating, "ctx_used": c.CtxUsed, "turns": turns}
+	// Occupé PAR UNE TÂCHE : l'interface l'annonce (« tâche en cours ») plutôt que
+	// d'afficher un tour qui n'apparaîtra jamais dans le fil.
+	if c.runningTaskID != "" {
+		st["task_id"] = c.runningTaskID
+		st["task_name"] = c.runningTaskName
+	}
+	return st
+}
+
+// isGenerating dit si un tour est en cours. Sert à la LISTE des discussions :
+// elle doit pouvoir montrer laquelle travaille dès le chargement de la page,
+// sans attendre que le rejeu du flux SSE ait rattrapé son retard.
+func (c *Conversation) isGenerating() bool {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return c.Generating
 }
 
 // ErrBusy : une génération est déjà en cours (un seul tour à la fois).
 var ErrBusy = fmt.Errorf("génération en cours")
 
+// busyReason explique le refus à l'utilisateur. Sans ça, un message envoyé
+// pendant qu'une TÂCHE planifiée tourne renvoyait « génération en cours » alors
+// que le fil est vide et que rien ne bouge à l'écran — incompréhensible. On
+// nomme la tâche et on dit comment reprendre la main.
+func (c *Conversation) busyReason() error {
+	c.mu.Lock()
+	name := c.runningTaskName
+	c.mu.Unlock()
+	if name == "" {
+		return ErrBusy
+	}
+	return fmt.Errorf("la tâche planifiée « %s » occupe le modèle — attends la fin ou arrête-la (bouton stop)", name)
+}
+
 // errModelLoading est renvoyée telle quelle à l'utilisateur, dans le chat : ce
 // n'est pas un défaut mais une attente, et le message doit le dire.
 var errModelLoading = fmt.Errorf("⏳ Le modèle est encore en train de charger — réessaie dans quelques secondes.")
@@ -321,6 +357,15 @@ func (c *Conversation) StartTurn(text string, files []attachInfo, caps Caps, tem
 	if strings.TrimSpace(prompt) == "" {
 		prompt = "Prends-en connaissance."
 	}
+	// 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"
+		}
+	}
 	// 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)})
@@ -331,10 +376,22 @@ func (c *Conversation) StartTurn(text string, files []attachInfo, caps Caps, tem
 	// si le process meurt en pleine génération (crash, restart après MAJ), le
 	// message de l'utilisateur survit au lieu de disparaître avec le tour.
 	delta := map[string]any{"user": text}
+	// Nom du modèle qui va produire la réponse : journalisé avec la borne de
+	// tour, donc rejoué au chargement — la carte de réponse garde son modèle
+	// après un rafraîchissement, et un vieux tour garde le modèle de l'époque,
+	// pas celui chargé aujourd'hui.
+	if m := chatModelName(); m != "" {
+		delta["model"] = m
+	}
 	if len(files) > 0 {
 		delta["files"] = files
 	}
 	c.appendDelta(epoch, delta)
+	// En mode chat, un message qui ressemble à une tâche de code fait
+	// apparaître la puce « passer en mode Code ? » (une fois par discussion).
+	if !caps.Code {
+		maybeCodeHint(c, epoch, text)
+	}
 	c.persist()
 	if temperature == 0 {
 		temperature = 0.7
@@ -343,6 +400,22 @@ func (c *Conversation) StartTurn(text string, files []attachInfo, caps Caps, tem
 	return nil
 }
 
+// chatModelName renvoie le nom lisible du modèle configuré : fichier sans
+// dossier ni extension .gguf (même règle que modelLabel côté UI), "" si aucun.
+func chatModelName() string {
+	m := strings.TrimSpace(ReadConfig()["MODEL"])
+	if m == "" {
+		return ""
+	}
+	if i := strings.LastIndexAny(m, "/\\"); i >= 0 {
+		m = m[i+1:]
+	}
+	if strings.HasSuffix(strings.ToLower(m), ".gguf") {
+		m = m[:len(m)-len(".gguf")]
+	}
+	return m
+}
+
 // generate exécute un tour complet et journalise chaque événement. Détaché : la
 // fermeture du navigateur n'a aucun effet ici, seul /stop (cancel) l'interrompt.
 // epoch est capturé au StartTurn : si un Reset survient pendant la génération,
@@ -400,6 +473,13 @@ func (c *Conversation) generate(ctx context.Context, caps Caps, temperature floa
 	// Non-nil = elle remplace l'historique (elle contient déjà le tour en cours).
 	var newBase []Message
 	var content strings.Builder
+	// 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
+	// discussions de plusieurs dizaines de milliers de tokens. On note donc si
+	// l'usage est arrivé ; sinon on retombe sur l'estimation (celle qui pilote
+	// déjà la compaction), approximative mais jamais absente.
+	sawUsage := false
 	extra, _ := runChat(ctx, InjectSkills(final, caps), temperature, caps, func(ev StreamEvent) bool {
 		switch {
 		case ev.Err != nil:
@@ -419,6 +499,9 @@ func (c *Conversation) generate(ctx context.Context, caps Caps, temperature floa
 			if len(ev.ToolUsed.Diff) > 0 {
 				tu["diff"] = ev.ToolUsed.Diff
 			}
+			if ev.ToolUsed.Image != "" {
+				tu["image"] = ev.ToolUsed.Image
+			}
 			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
@@ -439,6 +522,7 @@ func (c *Conversation) generate(ctx context.Context, caps Caps, temperature floa
 			// Taille réelle du contexte (usage.prompt_tokens + généré) pour le compteur
 			// et la décision de compactage au tour suivant.
 			if ev.Stats.PromptTokensTotal > 0 {
+				sawUsage = true
 				c.mu.Lock()
 				if c.epoch == epoch {
 					c.CtxUsed = ev.Stats.PromptTokensTotal + ev.Stats.GenTokens
@@ -446,6 +530,9 @@ func (c *Conversation) generate(ctx context.Context, caps Caps, temperature floa
 				c.mu.Unlock()
 			}
 			c.appendDelta(epoch, map[string]any{"stats": ev.Stats})
+		case ev.Ask != nil:
+			// Question structurée (outil ask) : carte à boutons dans l'UI.
+			c.appendDelta(epoch, map[string]any{"ask": ev.Ask})
 		case ev.DropReasoning:
 			c.appendDelta(epoch, map[string]any{"drop_reasoning": true})
 		case ev.Reasoning != "":
@@ -476,6 +563,32 @@ func (c *Conversation) generate(ctx context.Context, caps Caps, temperature floa
 	stale := c.epoch != epoch
 	c.mu.Unlock()
 
+	// Moteur muet sur l'usage : on publie l'estimation, sinon la jauge reste à
+	// zéro et l'utilisateur ne voit jamais son contexte se remplir — ni la
+	// compaction arriver.
+	if !stale && !sawUsage {
+		est := estimateTokens(msgs)
+		c.mu.Lock()
+		if c.epoch == epoch {
+			c.CtxUsed = est
+		}
+		c.mu.Unlock()
+		c.appendDelta(epoch, map[string]any{"ctx_used": est})
+		ctxUsed = est
+	}
+
+	// Boucle du contrat (mode code) : vérification indépendante des critères,
+	// corrections, re-vérification — AVANT de rendre la main. Voir
+	// code_verify.go. No-op hors mode code ou sans critères.
+	if !stale && ctx.Err() == nil {
+		c.codeVerifyLoop(ctx, caps, temperature, epoch)
+		c.mu.Lock()
+		msgs = append([]Message(nil), c.Messages...)
+		ctxUsed = c.CtxUsed
+		stale = c.epoch != epoch
+		c.mu.Unlock()
+	}
+
 	// Compaction de FIN DE TOUR. C'était LE trou : le seuil n'était testé qu'au
 	// DÉBUT d'un tour, avec le contexte du tour précédent. Le tour qui fait
 	// franchir le seuil se termine donc à 81% et… rien. La jauge reste haute, seul
@@ -557,9 +670,11 @@ func (c *Conversation) Stop() {
 // le bump d'epoch réduit de toute façon au silence.
 func (c *Conversation) Reset() {
 	c.Stop()
-	// Vider la discussion efface aussi ses captures : les messages qui les
-	// affichaient disparaissent, les fichiers n'auraient plus aucun lecteur.
-	dropConvCaptures(convEnsureActive())
+	// Vider la discussion efface aussi ses fichiers (dépôts, captures, ce que
+	// l'agent y a écrit) : les messages qui les mentionnaient disparaissent, plus
+	// rien ne les rattacherait à quoi que ce soit. L'UI le dit avant de demander
+	// confirmation.
+	dropConvFiles(convEnsureActive())
 	c.mu.Lock()
 	c.Messages = nil
 	c.Log = nil
@@ -752,6 +867,16 @@ func (c *Conversation) Subscribe(ctx context.Context, from int, emit func(map[st
 	if !emit(map[string]any{"caught_up": true}) {
 		return
 	}
+	// Taille du contexte connue MAINTENANT : le journal ne rejoue que les
+	// événements du fil, et `ctx_used` n'y figure qu'aux tours où il a changé —
+	// souvent hors de la fenêtre rejouée. Sans cet envoi, toute page rechargée
+	// affichait « 0 / N (0 %) » sur une discussion pourtant bien remplie.
+	c.mu.Lock()
+	used := c.CtxUsed
+	c.mu.Unlock()
+	if used > 0 && !emit(map[string]any{"ctx_used": used}) {
+		return
+	}
 	// Le padding doit venir APRÈS caught_up, pas dessus. Un proxy (Cloudflare) garde
 	// toujours le DERNIER bout de flux en tampon jusqu'au prochain flush (~2-3 s). En
 	// envoyant un gros pad juste après, ce sont ses octets — et non le dernier vrai

internal/loki/chat_convfiles.go

@@ -0,0 +1,304 @@
+package loki
+
+// chat_convfiles.go — les fichiers rangés PAR DISCUSSION.
+//
+// Avant, tout ce qui passait par le chat — pièces jointes déposées, rapports
+// écrits par l'agent, captures de pages — atterrissait dans UN seul dossier de
+// travail partagé par toutes les discussions. Changer de discussion ne changeait
+// rien au panneau Fichiers (on revoyait les mêmes), et supprimer une discussion
+// laissait ses fichiers derrière elle — seules ses captures, déjà rangées par
+// identifiant, partaient avec.
+//
+// Désormais chaque discussion a son dossier :
+//
+//	<workspace>/discussions/<id>/           ← dossier courant de l'agent
+//	<workspace>/discussions/<id>/uploads/   ← pièces jointes de CETTE discussion
+//	<workspace>/discussions/<id>/captures/  ← captures de CETTE discussion
+//
+// Supprimer une discussion (ou la vider) emporte tout le dossier, et le panneau
+// Fichiers n'ouvre que celui de la discussion active.
+//
+// La racine du dossier de travail reste la BORNE de sécurité : les liens écrits
+// dans les anciens messages (`uploads/x.pdf`, `captures/<id>/y.jpg`) pointent
+// encore vers elle et doivent continuer de marcher — c'est le rôle de
+// workspaceFile, qui cherche d'abord dans la discussion puis retombe sur les
+// emplacements d'avant.
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"unicode"
+)
+
+const (
+	// convFilesRoot : le sous-dossier qui contient un dossier par discussion.
+	// Nommé, plutôt que d'éparpiller les identifiants à la racine, pour que le
+	// dossier de travail reste lisible quand on l'ouvre depuis l'hôte.
+	convFilesRoot = "discussions"
+
+	// uploadsSub : les dépôts de l'utilisateur, à l'intérieur de la discussion.
+	uploadsSub = "uploads"
+)
+
+// safeConvID refuse tout identifiant qui ne soit pas un simple nom : c'est lui
+// qui devient un segment de chemin, et il arrive parfois du client (paramètre de
+// requête, ancien lien de message). Renvoie "" si l'identifiant est douteux.
+func safeConvID(id string) string {
+	id = strings.TrimSpace(id)
+	if id == "" || len(id) > 64 {
+		return ""
+	}
+	for _, r := range id {
+		if r == '-' || r == '_' || unicode.IsDigit(r) || (r < unicode.MaxASCII && unicode.IsLetter(r)) {
+			continue
+		}
+		return ""
+	}
+	return id
+}
+
+// convDirFor renvoie le dossier (absolu) d'une discussion, sans le créer. Un
+// identifiant vide ou douteux retombe sur la racine du dossier de travail :
+// mieux vaut écrire au mauvais endroit que refuser d'écrire.
+func convDirFor(convID string) string {
+	id := safeConvID(convID)
+	if id == "" {
+		return agentWorkspace()
+	}
+	return filepath.Join(agentWorkspace(), convFilesRoot, id)
+}
+
+// convWorkspace est le dossier de travail COURANT : celui de la discussion
+// active, créé au besoin. C'est là que résolvent les chemins relatifs du modèle
+// (resolveAgentPath), que démarre son shell, et que se déposent les fichiers.
+//
+// Si la création échoue (disque plein, droits), on retombe sur la racine du
+// dossier de travail : l'agent doit continuer d'écrire quelque part.
+func convWorkspace() string {
+	dir := convDirFor(convEnsureActive())
+	if dir == agentWorkspace() {
+		return dir
+	}
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		return agentWorkspace()
+	}
+	return dir
+}
+
+// dropConvFiles efface TOUT le dossier d'une discussion (dépôts, captures,
+// fichiers écrits par l'agent). Appelé quand la discussion est supprimée ou
+// vidée : plus un message ne les mentionne, personne ne les retrouverait.
+// Best-effort — un échec ne doit rien interrompre.
+func dropConvFiles(convID string) {
+	dir := convDirFor(convID)
+	if dir == agentWorkspace() {
+		return // identifiant douteux : surtout pas la racine
+	}
+	_ = os.RemoveAll(dir)
+}
+
+// relWithin dit si `abs` se trouve DANS `root` et, si oui, renvoie son chemin
+// relatif en séparateurs '/'.
+//
+// EvalSymlinks des deux côtés : sans ça, un lien posé dans le dossier passerait
+// le test de préfixe tout en pointant ailleurs sur le disque.
+func relWithin(root, abs string) (string, bool) {
+	if root == "" {
+		return "", false
+	}
+	if r, err := filepath.EvalSymlinks(root); err == nil {
+		root = r
+	}
+	if a, err := filepath.EvalSymlinks(abs); err == nil {
+		abs = a
+	}
+	rel, err := filepath.Rel(root, abs)
+	if err != nil || rel == "." || rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
+		return "", false
+	}
+	return filepath.ToSlash(rel), true
+}
+
+// workspaceFile résout un chemin RELATIF venu d'un client ou d'un message
+// (`uploads/rapport.pdf`, `captures/xxx.jpg`) en fichier du disque.
+//
+// Ordre de recherche :
+//  1. le dossier de la discussion active — le cas normal ;
+//  2. les emplacements d'AVANT le rangement par discussion, pour que les liens
+//     des anciens messages continuent d'ouvrir leur fichier.
+//
+// ok=false signale une sortie du périmètre (« .. »), pas une absence : un
+// fichier introuvable revient avec le chemin attendu, pour que l'appelant
+// réponde « introuvable » et non « hors du dossier de travail ».
+func workspaceFile(rel string) (string, bool) {
+	rel = strings.TrimPrefix(strings.ReplaceAll(strings.TrimSpace(rel), "\\", "/"), "/")
+	if rel == "" {
+		return "", false
+	}
+	base := convWorkspace()
+	p := filepath.Join(base, filepath.FromSlash(rel))
+	if _, ok := relWithin(base, p); !ok {
+		return "", false
+	}
+	if _, err := os.Stat(p); err == nil {
+		return p, true
+	}
+	if legacy, ok := legacyWorkspaceFile(rel); ok {
+		return legacy, true
+	}
+	return p, true
+}
+
+// legacyWorkspaceFile retrouve un fichier désigné par un chemin d'avant le
+// rangement par discussion. Deux formes existaient :
+//
+//	captures/<id>/x.jpg → discussions/<id>/captures/x.jpg (déplacé par la migration)
+//	uploads/x.pdf       → resté à la racine si aucune discussion ne le réclamait
+func legacyWorkspaceFile(rel string) (string, bool) {
+	if parts := strings.SplitN(rel, "/", 3); len(parts) == 3 && parts[0] == captureDir && safeConvID(parts[1]) != "" {
+		p := filepath.Join(convDirFor(parts[1]), captureDir, filepath.FromSlash(parts[2]))
+		if st, err := os.Stat(p); err == nil && !st.IsDir() {
+			return p, true
+		}
+	}
+	p := filepath.Join(agentWorkspace(), filepath.FromSlash(rel))
+	if _, ok := workspaceRel(p); !ok {
+		return "", false
+	}
+	if st, err := os.Stat(p); err == nil && !st.IsDir() {
+		return p, true
+	}
+	return "", false
+}
+
+// filesRoot donne la racine du panneau Fichiers pour un `scope` de requête :
+// la discussion active par défaut, la racine du dossier de travail pour
+// `scope=legacy` — celle où dorment les fichiers d'avant le rangement par
+// discussion, que la migration n'a pas su rattacher.
+func filesRoot(scope string) (root string, legacy bool) {
+	if strings.TrimSpace(scope) == "legacy" {
+		return agentWorkspace(), true
+	}
+	return convWorkspace(), false
+}
+
+// legacyCount compte ce qui traîne à la racine du dossier de travail, hors
+// dossier des discussions. L'UI n'affiche le raccourci « hors discussion » que
+// si ce compte est non nul — il tombe à zéro une fois le ménage fait, et le
+// bouton disparaît de lui-même.
+func legacyCount() int {
+	ents, err := os.ReadDir(agentWorkspace())
+	if err != nil {
+		return 0
+	}
+	n := 0
+	for _, e := range ents {
+		if e.Name() == convFilesRoot || strings.HasPrefix(e.Name(), ".") {
+			continue
+		}
+		n++
+	}
+	return n
+}
+
+var convFilesMigrateOnce sync.Once
+
+// migrateConvFiles range les fichiers des versions précédentes dans le dossier
+// de leur discussion. Une seule fois par process, au démarrage du serveur web.
+func migrateConvFiles() { convFilesMigrateOnce.Do(migrateConvFilesNow) }
+
+func migrateConvFilesNow() {
+	root := agentWorkspace()
+	if root == "" {
+		return
+	}
+	// 1. Les captures étaient DÉJÀ par discussion : captures/<id> → discussions/<id>/captures.
+	//    Un simple renommage, donc instantané quel que soit le nombre d'images.
+	oldCaps := filepath.Join(root, captureDir)
+	if ents, err := os.ReadDir(oldCaps); err == nil {
+		for _, e := range ents {
+			id := safeConvID(e.Name())
+			if !e.IsDir() || id == "" {
+				continue
+			}
+			dst := filepath.Join(convDirFor(id), captureDir)
+			if _, err := os.Stat(dst); err == nil {
+				continue // déjà rangé (migration interrompue puis reprise)
+			}
+			if os.MkdirAll(filepath.Dir(dst), 0o755) != nil {
+				continue
+			}
+			_ = os.Rename(filepath.Join(oldCaps, e.Name()), dst)
+		}
+		_ = os.Remove(oldCaps) // ne part que s'il est vide
+	}
+	// 2. Les dépôts, eux, étaient dans un pot commun. On rend chaque fichier à la
+	//    discussion qui le mentionne — l'historique garde le nom des pièces
+	//    jointes de chaque tour. Ce qui n'est réclamé par personne reste à la
+	//    racine : toujours téléchargeable (legacyWorkspaceFile) et visible via
+	//    « hors discussion », plutôt que rattaché au hasard.
+	migrateLegacyUploads(filepath.Join(root, uploadsSub))
+}
+
+func migrateLegacyUploads(src string) {
+	ents, err := os.ReadDir(src)
+	if err != nil {
+		return
+	}
+	left := map[string]bool{}
+	for _, e := range ents {
+		if !e.IsDir() {
+			left[e.Name()] = true
+		}
+	}
+	for _, m := range convIndex() {
+		if len(left) == 0 {
+			break
+		}
+		for _, name := range convAttachNames(m.ID) {
+			if !left[name] {
+				continue
+			}
+			dst := filepath.Join(convDirFor(m.ID), uploadsSub)
+			if os.MkdirAll(dst, 0o755) != nil {
+				continue
+			}
+			if os.Rename(filepath.Join(src, name), filepath.Join(dst, name)) == nil {
+				delete(left, name)
+			}
+		}
+	}
+	_ = os.Remove(src) // ne part que s'il est vide
+}
+
+// convAttachNames relit les pièces jointes annoncées dans le journal d'affichage
+// d'une discussion (delta `files`, cf. StartTurn). C'est la seule trace qui
+// relie un fichier déposé à sa discussion.
+func convAttachNames(id string) []string {
+	b := getBytes(bkChat, convKey(id))
+	if len(b) == 0 {
+		return nil
+	}
+	var st struct {
+		Log []struct {
+			Delta struct {
+				Files []attachInfo `json:"files"`
+			} `json:"delta"`
+		} `json:"log"`
+	}
+	if json.Unmarshal(b, &st) != nil {
+		return nil
+	}
+	var out []string
+	for _, ev := range st.Log {
+		for _, f := range ev.Delta.Files {
+			if n := safeUploadName(f.Name); n != "" {
+				out = append(out, n)
+			}
+		}
+	}
+	return out
+}

internal/loki/chat_convfiles_test.go

@@ -0,0 +1,243 @@
+package loki
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"testing"
+)
+
+// Le cœur de la demande : deux discussions ne partagent pas leurs fichiers.
+// Avant, uploads/ était commun — on retrouvait les mêmes pièces jointes partout.
+func TestFichiersIsolesParDiscussion(t *testing.T) {
+	withWorkspace(t)
+
+	a := convEnsureActive()
+	dirA, err := uploadsDir()
+	if err != nil {
+		t.Fatal(err)
+	}
+	writeFile(t, filepath.Join(dirA, "note-a.txt"), "aaa")
+
+	b := convNew() // b devient active
+	if a == b {
+		t.Fatal("convNew n'a pas créé de nouvelle discussion")
+	}
+	dirB, err := uploadsDir()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if dirA == dirB {
+		t.Fatalf("les deux discussions déposent au même endroit : %s", dirA)
+	}
+	writeFile(t, filepath.Join(dirB, "note-b.txt"), "bbb")
+
+	// La discussion ouverte ne voit QUE ses propres dépôts.
+	names := listedNames(t, "uploads")
+	if names["note-a.txt"] || !names["note-b.txt"] {
+		t.Fatalf("la liste de la discussion b montre %v", names)
+	}
+	// Et le message ne peut pas joindre le fichier de l'autre discussion.
+	if got := attachFiles([]string{"uploads/note-a.txt"}); len(got) != 0 {
+		t.Fatalf("pièce jointe d'une autre discussion retenue : %+v", got)
+	}
+	if got := attachFiles([]string{"uploads/note-b.txt"}); len(got) != 1 {
+		t.Fatalf("pièce jointe de la discussion courante refusée : %+v", got)
+	}
+
+	// Retour sur a : ses fichiers sont là, ceux de b ont disparu de la vue.
+	if err := convSwitch(a); err != nil {
+		t.Fatal(err)
+	}
+	names = listedNames(t, "uploads")
+	if !names["note-a.txt"] || names["note-b.txt"] {
+		t.Fatalf("la liste de la discussion a montre %v", names)
+	}
+}
+
+// Supprimer une discussion emporte TOUS ses fichiers, pas seulement ses
+// captures — et surtout pas ceux des autres.
+func TestConvDeleteSupprimeLesFichiers(t *testing.T) {
+	ws := withWorkspace(t)
+
+	a := convEnsureActive()
+	writeFile(t, filepath.Join(ws, "uploads", "joint.pdf"), "pdf")
+	writeFile(t, filepath.Join(ws, "rapport.md"), "rapport")
+
+	b := convNew()
+	autre := convWorkspace()
+	writeFile(t, filepath.Join(autre, "garde-moi.txt"), "ok")
+
+	if err := convDelete(a); err != nil {
+		t.Fatalf("suppression : %v", err)
+	}
+	if _, err := os.Stat(ws); !os.IsNotExist(err) {
+		t.Fatalf("le dossier de la discussion supprimée est toujours là (%v)", err)
+	}
+	if _, err := os.Stat(filepath.Join(autre, "garde-moi.txt")); err != nil {
+		t.Fatalf("les fichiers d'une AUTRE discussion ont été supprimés : %v", err)
+	}
+	if convEnsureActive() != b {
+		t.Fatalf("discussion active = %q, attendu %q", convEnsureActive(), b)
+	}
+}
+
+// Vider une discussion (« clear chat ») efface aussi ses fichiers : les messages
+// qui les mentionnaient partent avec.
+func TestResetSupprimeLesFichiersDeLaDiscussion(t *testing.T) {
+	ws := withWorkspace(t)
+	writeFile(t, filepath.Join(ws, "uploads", "joint.pdf"), "pdf")
+
+	conv.Reset()
+
+	if _, err := os.Stat(filepath.Join(ws, "uploads", "joint.pdf")); !os.IsNotExist(err) {
+		t.Fatalf("le fichier de la discussion vidée a survécu (%v)", err)
+	}
+}
+
+// Un identifiant de discussion douteux ne doit JAMAIS devenir un segment de
+// chemin : dropConvFiles effacerait alors la racine du dossier de travail.
+func TestDropConvFilesRefuseUnIdDouteux(t *testing.T) {
+	ws := withWorkspace(t)
+	writeFile(t, filepath.Join(ws, "a.txt"), "a")
+	racine := agentWorkspace()
+
+	for _, bad := range []string{"", ".", "..", "../..", "c1/../..", "/etc", `..\..`} {
+		dropConvFiles(bad)
+		if _, err := os.Stat(racine); err != nil {
+			t.Fatalf("id %q a détruit le dossier de travail : %v", bad, err)
+		}
+	}
+	if _, err := os.Stat(filepath.Join(ws, "a.txt")); err != nil {
+		t.Fatalf("fichier de la discussion détruit : %v", err)
+	}
+}
+
+// Les liens des anciens messages doivent continuer d'ouvrir leur fichier : ils
+// pointent vers uploads/ et captures/<id>/ à la RACINE du dossier de travail.
+func TestTelechargementDesCheminsDAvant(t *testing.T) {
+	withWorkspace(t)
+	racine := agentWorkspace()
+	id := convEnsureActive()
+
+	writeFile(t, filepath.Join(racine, "uploads", "ancien.txt"), "avant")
+	// Capture d'avant, déplacée par la migration là où elle est désormais rangée.
+	writeFile(t, filepath.Join(convDirFor(id), captureDir, "vue.jpg"), "jpeg")
+
+	for path, want := range map[string]string{
+		"uploads/ancien.txt":               "avant",
+		captureDir + "/" + id + "/vue.jpg": "jpeg",
+		captureDir + "/vue.jpg":            "jpeg", // le chemin d'aujourd'hui
+	} {
+		rec := httptest.NewRecorder()
+		handleChatFile(rec, httptest.NewRequest("GET", "/api/chat/file?path="+url.QueryEscape(path), nil))
+		if rec.Code != 200 || rec.Body.String() != want {
+			t.Errorf("path=%q : code %d, corps %q", path, rec.Code, rec.Body.String())
+		}
+	}
+}
+
+// La migration range les fichiers des versions précédentes : les captures par
+// leur identifiant, les dépôts par la discussion qui les mentionne. Ce que
+// personne ne réclame reste à la racine, atteignable par « hors discussion ».
+func TestMigrationRangeLesFichiersDAvant(t *testing.T) {
+	withWorkspace(t)
+	racine := agentWorkspace()
+
+	a := convEnsureActive()
+	// Un tour avec pièce jointe : c'est cette trace, dans le journal de la
+	// discussion, qui rattache le fichier à elle.
+	state, _ := json.Marshal(map[string]any{
+		"log": []map[string]any{{"seq": 1, "delta": map[string]any{
+			"user":  "regarde",
+			"files": []attachInfo{{Name: "joint.pdf", Path: "uploads/joint.pdf", Size: 3}},
+		}}},
+	})
+	if err := putBytes(bkChat, convKey(a), state); err != nil {
+		t.Fatal(err)
+	}
+
+	writeFile(t, filepath.Join(racine, "uploads", "joint.pdf"), "pdf")
+	writeFile(t, filepath.Join(racine, "uploads", "orphelin.bin"), "??")
+	writeFile(t, filepath.Join(racine, captureDir, a, "vue.jpg"), "jpeg")
+
+	// La migration ne joue qu'une fois par process : on rearme le verrou pour
+	// pouvoir l'observer ici.
+	convFilesMigrateOnce = sync.Once{}
+	migrateConvFiles()
+
+	if _, err := os.Stat(filepath.Join(convDirFor(a), uploadsSub, "joint.pdf")); err != nil {
+		t.Errorf("le dépôt n'a pas rejoint sa discussion : %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(convDirFor(a), captureDir, "vue.jpg")); err != nil {
+		t.Errorf("la capture n'a pas rejoint sa discussion : %v", err)
+	}
+	// Le fichier que personne ne réclame reste lisible plutôt que rattaché au hasard.
+	if _, err := os.Stat(filepath.Join(racine, uploadsSub, "orphelin.bin")); err != nil {
+		t.Errorf("le dépôt orphelin a été perdu : %v", err)
+	}
+	if legacyCount() == 0 {
+		t.Error("le reliquat hors discussion n'est pas signalé à l'UI")
+	}
+}
+
+// La vue « hors discussion » ne doit pas devenir une porte dérobée vers les
+// fichiers des autres discussions.
+func TestScopeLegacyNeDonnePasLesDiscussions(t *testing.T) {
+	ws := withWorkspace(t)
+	racine := agentWorkspace()
+	writeFile(t, filepath.Join(ws, "secret.txt"), "x")
+	writeFile(t, filepath.Join(racine, "ancien.txt"), "y")
+
+	out := listScope(t, "", "legacy")
+	if out["ok"] != true {
+		t.Fatalf("liste refusée : %v", out)
+	}
+	for _, e := range out["entries"].([]any) {
+		if e.(map[string]any)["name"] == convFilesRoot {
+			t.Fatalf("le dossier des discussions est listé : %v", out)
+		}
+	}
+	// Et il ne se supprime pas d'un clic : ce serait toutes les discussions.
+	rec := httptest.NewRecorder()
+	handleChatFileDelete(rec, httptest.NewRequest("POST", "/api/chat/file/delete",
+		strings.NewReader(`{"path":`+jsonQuote(convFilesRoot)+`,"scope":"legacy"}`)))
+	if rec.Code == http.StatusOK {
+		t.Errorf("suppression du dossier des discussions acceptée : %s", rec.Body.String())
+	}
+	if _, err := os.Stat(filepath.Join(ws, "secret.txt")); err != nil {
+		t.Fatalf("fichier d'une discussion supprimé : %v", err)
+	}
+}
+
+// listedNames renvoie les noms listés dans un dossier du panneau.
+func listedNames(t *testing.T, dir string) map[string]bool {
+	t.Helper()
+	out := listFiles(t, dir)
+	names := map[string]bool{}
+	if out["ok"] != true {
+		return names
+	}
+	for _, e := range out["entries"].([]any) {
+		names[e.(map[string]any)["name"].(string)] = true
+	}
+	return names
+}
+
+func listScope(t *testing.T, dir, scope string) map[string]any {
+	t.Helper()
+	rec := httptest.NewRecorder()
+	handleChatFiles(rec, httptest.NewRequest("GET",
+		"/api/chat/files?dir="+url.QueryEscape(dir)+"&scope="+url.QueryEscape(scope), nil))
+	var out map[string]any
+	if err := json.Unmarshal(rec.Body.Bytes(), &out); err != nil {
+		t.Fatalf("réponse illisible (%d) : %s", rec.Code, rec.Body.String())
+	}
+	out["_code"] = rec.Code
+	return out
+}

internal/loki/chat_screenshot.go

@@ -20,6 +20,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
+	neturl "net/url"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -30,28 +31,24 @@ import (
 	"time"
 )
 
-// captureDir : sous-dossier du workspace où atterrissent les captures. Elles
-// sont rangées PAR DISCUSSION (captures/<id>/…) pour que supprimer une
-// discussion supprime aussi ses images — sinon elles s'accumulaient sur le
-// disque sans qu'aucun écran ne les mentionne plus.
+// captureDir : sous-dossier où atterrissent les captures, À L'INTÉRIEUR du
+// dossier de la discussion (discussions/<id>/captures/…) — comme les dépôts.
+// Supprimer une discussion emporte donc ses images, qui sinon s'accumulaient
+// sur le disque sans qu'aucun écran ne les mentionne plus.
 const captureDir = "captures"
 
 // captureDirFor renvoie le dossier de captures d'une discussion (chemin absolu)
-// et son préfixe relatif, celui qui sert dans les URLs d'affichage.
+// et son préfixe relatif, celui qui sert dans les URLs d'affichage. Le relatif
+// part du dossier de la DISCUSSION : /api/chat/image résout d'abord là
+// (workspaceFile), et les liens des anciens messages — en captures/<id>/… —
+// continuent d'ouvrir leur image par le chemin de repli.
 func captureDirFor(convID string) (abs, rel string) {
-	rel = captureDir + "/" + convID
-	return filepath.Join(agentWorkspace(), captureDir, convID), rel
+	return filepath.Join(convDirFor(convID), captureDir), captureDir
 }
 
-// dropConvCaptures supprime les captures d'une discussion. Appelé quand on la
-// supprime ou qu'on la vide. Best-effort : un échec ne doit rien interrompre.
-func dropConvCaptures(convID string) {
-	if convID == "" {
-		return
-	}
-	abs, _ := captureDirFor(convID)
-	_ = os.RemoveAll(abs)
-}
+// Supprimer les captures d'une discussion n'a plus de fonction à soi : elles
+// vivent dans son dossier, et dropConvFiles (chat_convfiles.go) l'emporte en
+// entier — dépôts et fichiers écrits par l'agent compris.
 
 // screenshotTimeout : une page lente ne doit pas bloquer le tour. Playwright a
 // son propre délai interne, celui-ci est le garde-fou externe.
@@ -109,6 +106,11 @@ func screenshotVisionNote() string {
 // modèle, ou avec un modèle sans vision (gpt-oss), le gabarit sérialise le
 // base64 de l'image en TEXTE — la requête vue en production pesait 55 000
 // tokens pour 32 768 de contexte, et tous les tours suivants échouaient.
+//
+// La sonde est un appel interne comme les autres : elle DOIT s'authentifier.
+// Sans l'en-tête Bearer, un moteur protégé par API_KEY répond 401 et la sonde
+// conclut « pas de vision » — le projecteur était bien chargé, les images ne
+// partaient jamais et le modèle brodait à partir du seul chemin de fichier.
 var (
 	visionProbeMu   sync.Mutex
 	visionProbeAt   time.Time
@@ -124,7 +126,12 @@ func engineSeesImages() bool {
 	visionProbeAt = time.Now()
 	visionProbeSeen = false
 	client := &http.Client{Timeout: 2 * time.Second}
-	resp, err := client.Get(fmt.Sprintf("http://localhost:%d/props", LLMPort()))
+	req, err := http.NewRequest(http.MethodGet, fmt.Sprintf("http://localhost:%d/props", LLMPort()), nil)
+	if err != nil {
+		return false
+	}
+	authHeader(req)
+	resp, err := client.Do(req)
 	if err != nil {
 		return false
 	}
@@ -188,7 +195,10 @@ func screenshotImageMessage(relPath string) (Message, bool) {
 	if !visionEnabled() || !engineSeesImages() {
 		return Message{}, false
 	}
-	abs := filepath.Join(agentWorkspace(), filepath.FromSlash(relPath))
+	abs, ok := workspaceFile(relPath)
+	if !ok {
+		return Message{}, false
+	}
 	mime := imageMime(abs)
 	if mime == "" {
 		return Message{}, false
@@ -233,7 +243,7 @@ func safeSlug(s string) string {
 	return s
 }
 
-func toolWebScreenshot(args map[string]any) string {
+func toolWebScreenshot(args map[string]any, caps Caps) string {
 	bin := playwrightBin()
 	if bin == "" {
 		return "[erreur] Playwright n'est pas installé dans cette image (bâtie avec PLAYWRIGHT=0)."
@@ -246,6 +256,13 @@ func toolWebScreenshot(args map[string]any) string {
 	if !strings.HasPrefix(url, "http://") && !strings.HasPrefix(url, "https://") {
 		return "[erreur] url invalide : elle doit commencer par http:// ou https://"
 	}
+	// Accès internet coupé : la capture reste offerte au MODE CODE, mais bornée
+	// aux adresses locales — voir sa propre page de dev, pas le web. Sans cette
+	// borne, l'outil rouvrirait par la fenêtre ce que l'interrupteur ferme.
+	if !caps.Internet && !isLocalURL(url) {
+		return "[refusé] L'accès internet est coupé : la capture ne marche que sur une adresse locale " +
+			"(localhost / 127.0.0.1), par exemple ton serveur de dev. Active l'accès internet pour le web."
+	}
 	// width n'est plus déclaré dans le schéma (budget de préambule), mais reste
 	// honoré s'il arrive quand même : un modèle qui l'invente obtient le
 	// comportement attendu plutôt qu'un paramètre ignoré en silence.
@@ -388,3 +405,19 @@ func lastLines(s string, n int) string {
 	}
 	return strings.Join(keep, " · ")
 }
+
+// isLocalURL : l'adresse désigne-t-elle cette machine ? Sert de borne quand
+// l'accès internet est coupé mais que le mode code doit pouvoir photographier
+// son propre serveur de dev.
+func isLocalURL(raw string) bool {
+	u, err := neturl.Parse(raw)
+	if err != nil {
+		return false
+	}
+	host := u.Hostname()
+	switch host {
+	case "localhost", "127.0.0.1", "::1", "0.0.0.0":
+		return true
+	}
+	return strings.HasSuffix(host, ".localhost")
+}

internal/loki/chat_sessions.go

@@ -11,6 +11,10 @@ package loki
 //	bkChat/active     → identifiant de la discussion ouverte
 //	bkChat/conv:<id>  → l'état complet d'une discussion (JSON de Conversation)
 //
+// Les FICHIERS suivent le même découpage, sur le disque cette fois :
+// <workspace>/discussions/<id>/ (chat_convfiles.go). Supprimer une discussion
+// supprime donc aussi ses fichiers.
+//
 // Basculer = enregistrer la discussion courante, charger l'autre en mémoire et
 // incrémenter l'epoch : les abonnés SSE reçoivent alors {reset:true} et
 // rejouent le nouveau fil depuis zéro. C'est le mécanisme déjà utilisé par
@@ -228,9 +232,15 @@ func convDelete(id string) error {
 	}
 	convIndexSave(next)
 	_ = putBytes(bkChat, convKey(id), nil)
-	// Les captures de cette discussion n'ont plus rien qui les référence : les
-	// garder occuperait le disque pour toujours.
-	dropConvCaptures(id)
+	// Mode code : les jobs d'arrière-plan de la discussion s'arrêtent avec
+	// elle, et ses critères/mode/puce partent avec ses messages.
+	stopConvJobs(id)
+	critDrop(id)
+	dropConvMode(id)
+	// Les fichiers de cette discussion — dépôts, captures, ce que l'agent y a
+	// écrit — n'ont plus rien qui les référence : les garder occuperait le disque
+	// pour toujours, et plus aucun écran ne permettrait de les retrouver.
+	dropConvFiles(id)
 	if id != getStr(bkChat, ckActive) {
 		return nil
 	}

internal/loki/chat_tools.go

@@ -44,6 +44,18 @@ func baseSystemPrompt(caps Caps) string {
 	// « Loki » avec une majuscule : c'est un nom propre, et le modèle recopie
 	// littéralement la casse d'ici quand il se présente (« je suis loki »).
 	b.WriteString("You are Loki, an expert assistant operating directly on this machine with real tools.")
+	// Mode code : le prompt du rôle (builder/planner/verifier…) prend la suite
+	// de l'identité. Court par construction (voir code_roles.go) — la règle
+	// « ne pas regonfler » vaut aussi pour lui.
+	if caps.Code {
+		role := caps.Role
+		if role == "" {
+			role = "builder"
+		}
+		if rp := rolePrompt(role); rp != "" {
+			b.WriteString("\n\n" + rp)
+		}
+	}
 	if caps.Mem == MemAlways {
 		b.WriteString(" You evolve with every conversation: you actively maintain a persistent memory so nothing useful is lost between sessions.")
 	}
@@ -149,7 +161,7 @@ func machineSystemPrompt(caps Caps) string {
 	if u, err := user.Current(); err == nil {
 		who = u.Username
 	}
-	cwd := agentWorkspace()
+	cwd := agentCwd()
 
 	var b strings.Builder
 	b.WriteString(fmt.Sprintf("Machine: host=%s, %s/%s", host, runtime.GOOS, runtime.GOARCH))
@@ -161,7 +173,11 @@ func machineSystemPrompt(caps Caps) string {
 	}
 	b.WriteString(".")
 	if cwd != "" {
-		b.WriteString(" Relative paths in write/edit/bash resolve inside this working folder — put scratch files there. Write outside it ONLY with an absolute path the user explicitly asked for; never scatter files into the folder loki was launched from.")
+		// Formulation reprise de l'amont AJEAN (v0.10.2) : dire ce que le dossier
+		// 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 everything you create — scripts, notes, outputs, even a command-line tool you build. Just use a relative name. 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 when the user explicitly named that location.")
 	}
 	return b.String()
 }
@@ -185,16 +201,17 @@ func runShell(parent context.Context, command string, timeoutSec int) string {
 	ctx, cancel := context.WithTimeout(parent, time.Duration(timeoutSec)*time.Second)
 	defer cancel()
 	cmd := newShellCmd(ctx, command)
-	// Le shell démarre dans le workspace, pas dans le dossier d'où loki a été
-	// lancé : un `> notes.txt` du modèle ne doit pas atterrir sur le Bureau.
+	// Le shell démarre dans le dossier de la discussion ouverte, pas dans le
+	// dossier d'où loki a été lancé : un `> notes.txt` du modèle ne doit pas
+	// atterrir sur le Bureau, ni dans une AUTRE discussion.
 	//
-	// Le dossier est résolu UNE fois par process (agentWorkspace), donc s'il
-	// disparaît ensuite — l'utilisateur fait le ménage, ou le modèle lui-même le
+	// La racine est résolue UNE fois par process (agentWorkspace), donc si elle
+	// disparaît ensuite — l'utilisateur fait le ménage, ou le modèle lui-même la
 	// supprime — toutes les commandes suivantes échouaient sur un « chdir : no
 	// such file or directory » incompréhensible, et ce jusqu'au redémarrage. On
 	// le recrée au besoin, et à défaut on démarre là où on peut plutôt que de
 	// tout refuser.
-	if ws := agentWorkspace(); ws != "" {
+	if ws := agentCwd(); ws != "" {
 		if err := os.MkdirAll(ws, 0o755); err == nil {
 			cmd.Dir = ws
 		}
@@ -257,6 +274,10 @@ func fileWrite(path, content string) string {
 		return "[erreur] chemin vide"
 	}
 	path = resolveAgentPath(path)
+	// Sérialise les écritures concurrentes sur un même fichier (code_policy.go).
+	mu := fileMu(path)
+	mu.Lock()
+	defer mu.Unlock()
 	if dir := filepath.Dir(path); dir != "" && dir != "." {
 		if err := os.MkdirAll(dir, 0o755); err != nil {
 			return "[erreur] " + err.Error()
@@ -291,16 +312,28 @@ func fileEdit(path, oldText, newText string) string {
 		return "[erreur] old vide"
 	}
 	path = resolveAgentPath(path)
+	// Sérialise les écritures concurrentes sur un même fichier (code_policy.go).
+	mu := fileMu(path)
+	mu.Lock()
+	defer mu.Unlock()
 	b, err := os.ReadFile(path)
 	if err != nil {
 		return "[erreur] " + err.Error()
 	}
 	content := string(b)
-	n := strings.Count(content, oldText)
+	// Fichier en CRLF, modèle en LF : la recherche exacte échouait toujours.
+	// On compare alors en LF normalisé, et on réécrit dans le style du fichier
+	// (préservation des fins de ligne — repris des tests line-ending d'OpenFox).
+	crlf := strings.Contains(content, "\r\n")
+	search, oldN, newN := content, oldText, newText
+	if crlf && !strings.Contains(oldText, "\r\n") {
+		search = strings.ReplaceAll(content, "\r\n", "\n")
+	}
+	n := strings.Count(search, oldN)
 	if n == 0 {
 		// Modification déjà en place : on le dit clairement plutôt que de renvoyer
 		// une erreur, sinon le modèle croit avoir échoué et recommence.
-		if newText != "" && strings.Contains(content, newText) {
+		if newN != "" && strings.Contains(search, newN) {
 			return "[ok] déjà à jour — le fichier contient déjà cette modification"
 		}
 		return "[erreur] old introuvable dans le fichier"
@@ -308,7 +341,11 @@ func fileEdit(path, oldText, newText string) string {
 	if n > 1 {
 		return fmt.Sprintf("[erreur] old apparaît %d fois — ajoute du contexte pour le rendre unique", n)
 	}
-	updated := strings.Replace(content, oldText, newText, 1)
+	updated := strings.Replace(search, oldN, newN, 1)
+	if search != content {
+		// La comparaison s'est faite en LF : on remet le fichier en CRLF.
+		updated = strings.ReplaceAll(updated, "\n", "\r\n")
+	}
 	// Préserve les permissions d'origine (un script 0755 doit rester exécutable).
 	mode := os.FileMode(0o644)
 	if fi, err := os.Stat(path); err == nil {

internal/loki/chat_workspace.go

@@ -5,6 +5,7 @@ import (
 	"path/filepath"
 	"strings"
 	"sync"
+	"sync/atomic"
 )
 
 // Dossier de travail du mode agent.
@@ -17,6 +18,12 @@ import (
 // chemins relatifs y sont résolus, et le shell y démarre. Les chemins ABSOLUS
 // restent honorés tels quels — quand l'utilisateur demande d'écrire dans un
 // dossier précis, ça doit marcher.
+//
+// agentWorkspace est la RACINE, commune à tout : le dossier de travail effectif
+// est celui de la discussion ouverte (convWorkspace, chat_convfiles.go), pour
+// qu'un fichier appartienne à la discussion où il est né et disparaisse avec
+// elle — ou celui de la tâche planifiée en cours (agentCwd, plus bas). La racine
+// reste la borne de sécurité des téléchargements.
 
 const workspaceEnv = "LOKI_WORKSPACE"
 
@@ -68,8 +75,33 @@ func workspaceCandidates() []string {
 	return c
 }
 
+// Dossier de travail imposé pendant l'exécution d'une TÂCHE planifiée
+// (tasks_run.go). Une tâche tourne hors de toute discussion : sans ça, ses
+// fichiers atterriraient dans le dossier de la discussion qui se trouve ouverte
+// — et changeraient de place en cours de route si l'utilisateur en changeait.
+//
+// La bascule est un état de processus et non de goroutine, ce que Go ne sait pas
+// faire autrement ; c'est sûr ici parce qu'une SEULE génération tourne à la fois
+// (le verrou de conv), et parce que seuls les points d'entrée des OUTILS lisent
+// agentCwd(). Ce que voit l'utilisateur — panneau Fichiers, dépôts, liens des
+// messages — continue de passer par convWorkspace() et reste donc sur sa
+// discussion, même pendant qu'une tâche écrit ailleurs.
+var taskWS atomic.Value // string
+
+func setTaskWorkspace(dir string) { taskWS.Store(dir) }
+
+// agentCwd = le dossier où l'agent travaille MAINTENANT : celui de la tâche en
+// cours s'il y en a une, sinon celui de la discussion ouverte.
+func agentCwd() string {
+	if d, _ := taskWS.Load().(string); d != "" {
+		return d
+	}
+	return convWorkspace()
+}
+
 // resolveAgentPath résout un chemin fourni par le modèle. Absolu → inchangé ;
-// "~/x" → dans le home de l'utilisateur ; relatif → dans le workspace.
+// "~/x" → dans le home de l'utilisateur ; relatif → dans le dossier de la
+// discussion ouverte.
 func resolveAgentPath(p string) string {
 	p = strings.TrimSpace(p)
 	if p == "" {
@@ -83,5 +115,5 @@ func resolveAgentPath(p string) string {
 	if filepath.IsAbs(p) {
 		return p
 	}
-	return filepath.Join(agentWorkspace(), filepath.FromSlash(p))
+	return filepath.Join(agentCwd(), filepath.FromSlash(p))
 }

internal/loki/chat_workspace_test.go

@@ -6,14 +6,19 @@ import (
 	"testing"
 )
 
-// Un chemin relatif du modèle doit atterrir dans le workspace, jamais dans le
-// répertoire courant du processus (Bureau, C:\ProgramData\loki\bin…).
+// Un chemin relatif du modèle doit atterrir dans le dossier de la DISCUSSION
+// ouverte, jamais dans le répertoire courant du processus (Bureau,
+// C:\ProgramData\loki\bin…) ni dans un dossier commun à toutes les discussions.
 func TestResolveAgentPathRelative(t *testing.T) {
+	ws := withWorkspace(t)
 	got := resolveAgentPath("meteo.json")
-	want := filepath.Join(agentWorkspace(), "meteo.json")
+	want := filepath.Join(ws, "meteo.json")
 	if got != want {
 		t.Fatalf("resolveAgentPath = %q, attendu %q", got, want)
 	}
+	if !strings.Contains(got, convFilesRoot) {
+		t.Fatalf("le fichier n'est pas rangé par discussion : %q", got)
+	}
 }
 
 // Un chemin absolu demandé explicitement reste intouché.
@@ -25,9 +30,10 @@ func TestResolveAgentPathAbsolute(t *testing.T) {
 }
 
 func TestResolveAgentPathSubdir(t *testing.T) {
+	ws := withWorkspace(t)
 	got := resolveAgentPath("notes/2026/a.txt")
-	if !strings.HasPrefix(got, agentWorkspace()) {
-		t.Fatalf("%q hors du workspace %q", got, agentWorkspace())
+	if !strings.HasPrefix(got, ws) {
+		t.Fatalf("%q hors du dossier de la discussion %q", got, ws)
 	}
 	if strings.Contains(got, "/") && filepath.Separator != '/' {
 		t.Fatalf("séparateurs non normalisés : %q", got)

internal/loki/code_criteria.go

@@ -0,0 +1,205 @@
+package loki
+
+// code_criteria.go — critères d'acceptation du mode code (contrat d'exécution,
+// repris du session-metadata/criteria d'OpenFox, réécrit en Go — voir
+// NOTICE.md). Les critères sont posés au début d'une tâche (par le modèle via
+// l'outil `criteria`, ou à la main dans l'UI), puis la passe de vérification
+// (code_verify.go) les fait passer à `passed` ou `failed`. Le tour de build ne
+// se termine « vraiment » que quand tout est passed — c'est le contrat.
+//
+// Rangés par discussion dans bbolt (bucket chat, clé crit:<id>) : ils suivent
+// la discussion, sa suppression les emporte.
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+	"time"
+)
+
+type Criterion struct {
+	ID     int    `json:"id"`
+	Text   string `json:"text"`
+	Status string `json:"status"` // pending | passed | failed
+	Note   string `json:"note,omitempty"`
+}
+
+const critMaxCount = 20
+
+func critKey(convID string) string { return "crit:" + convID }
+
+func critList(convID string) []Criterion {
+	var list []Criterion
+	if b := getBytes(bkChat, critKey(convID)); len(b) > 0 {
+		_ = json.Unmarshal(b, &list)
+	}
+	return list
+}
+
+func critSave(convID string, list []Criterion) {
+	if len(list) == 0 {
+		_ = putBytes(bkChat, critKey(convID), nil) // nil supprime la clé
+		return
+	}
+	b, err := json.Marshal(list)
+	if err != nil {
+		return
+	}
+	_ = putBytes(bkChat, critKey(convID), b)
+}
+
+func critDrop(convID string) { _ = putBytes(bkChat, critKey(convID), nil) }
+
+// critAllPassed : le contrat est rempli. Une liste vide ne compte pas comme
+// remplie — il n'y a simplement pas de contrat.
+func critAllPassed(list []Criterion) bool {
+	if len(list) == 0 {
+		return false
+	}
+	for _, c := range list {
+		if c.Status != "passed" {
+			return false
+		}
+	}
+	return true
+}
+
+func critPending(list []Criterion) int {
+	n := 0
+	for _, c := range list {
+		if c.Status != "passed" {
+			n++
+		}
+	}
+	return n
+}
+
+// critRender : la liste formatée pour un prompt (builder ou verifier).
+func critRender(list []Criterion) string {
+	var b strings.Builder
+	for _, c := range list {
+		mark := "[ ]"
+		switch c.Status {
+		case "passed":
+			mark = "[✓]"
+		case "failed":
+			mark = "[✗]"
+		}
+		fmt.Fprintf(&b, "%s #%d %s", mark, c.ID, c.Text)
+		if c.Note != "" {
+			fmt.Fprintf(&b, " — %s", c.Note)
+		}
+		b.WriteString("\n")
+	}
+	return strings.TrimRight(b.String(), "\n")
+}
+
+func criteriaTool() Tool {
+	return Tool{
+		Type: "function",
+		Function: ToolFunction{
+			Name: "criteria",
+			Description: "Manage the acceptance criteria of the current task (the contract that defines DONE). " +
+				"action=add posits new criteria (texts[]), action=set updates one (id + status passed|failed|pending, optional note), " +
+				"action=list shows them, action=clear removes them all. Set criteria BEFORE building; only the verification pass may mark passed.",
+			Parameters: map[string]any{
+				"type": "object",
+				"properties": map[string]any{
+					"action": map[string]any{"type": "string", "enum": []string{"add", "set", "list", "clear"}},
+					"texts":  map[string]any{"type": "array", "items": map[string]any{"type": "string"}, "description": "add: one entry per criterion, short and testable"},
+					"id":     map[string]any{"type": "integer", "description": "set: criterion id"},
+					"status": map[string]any{"type": "string", "enum": []string{"pending", "passed", "failed"}},
+					"note":   map[string]any{"type": "string", "description": "set: why it failed / how it was verified"},
+				},
+				"required": []string{"action"},
+			},
+		},
+	}
+}
+
+// toolCriteria exécute l'outil. allowPass : seul le passage de VÉRIFICATION a
+// le droit de marquer `passed` (sinon le builder s'auto-valide et le contrat ne
+// contraint plus rien).
+func toolCriteria(args map[string]any, allowPass bool) string {
+	convID := convEnsureActive()
+	action, _ := args["action"].(string)
+	list := critList(convID)
+	switch action {
+	case "list", "":
+		if len(list) == 0 {
+			return "[aucun critère]"
+		}
+		return critRender(list)
+	case "add":
+		raw, _ := args["texts"].([]any)
+		next := 1
+		for _, c := range list {
+			if c.ID >= next {
+				next = c.ID + 1
+			}
+		}
+		added := 0
+		for _, r := range raw {
+			s, ok := r.(string)
+			if !ok || strings.TrimSpace(s) == "" {
+				continue
+			}
+			if len(list) >= critMaxCount {
+				break
+			}
+			list = append(list, Criterion{ID: next, Text: strings.TrimSpace(s), Status: "pending"})
+			next++
+			added++
+		}
+		if added == 0 {
+			return "[erreur] aucun critère fourni (texts)"
+		}
+		critSave(convID, list)
+		critNotify(list)
+		return fmt.Sprintf("[ok] %d critère(s) ajouté(s)\n%s", added, critRender(list))
+	case "set":
+		idf, _ := args["id"].(float64)
+		id := int(idf)
+		status, _ := args["status"].(string)
+		note, _ := args["note"].(string)
+		if status == "passed" && !allowPass {
+			return "[refusé] Seule la passe de vérification peut marquer un critère passed. Termine ton implémentation ; la vérification suivra."
+		}
+		for i := range list {
+			if list[i].ID != id {
+				continue
+			}
+			if status != "" {
+				list[i].Status = status
+			}
+			if note != "" {
+				list[i].Note = strings.TrimSpace(note)
+			}
+			critSave(convID, list)
+			critNotify(list)
+			return "[ok] critère #" + fmt.Sprint(id) + " → " + list[i].Status
+		}
+		return fmt.Sprintf("[erreur] critère #%d inconnu", id)
+	case "clear":
+		critDrop(convID)
+		critNotify(nil)
+		return "[ok] critères effacés"
+	}
+	return "[erreur] action inconnue : " + action
+}
+
+// critNotify pousse la liste à l'UI (panneau critères) via le journal de la
+// conversation. Best-effort : hors génération il n'y a pas d'epoch en cours,
+// on publie sur l'epoch courant.
+func critNotify(list []Criterion) {
+	if conv == nil {
+		return
+	}
+	conv.mu.Lock()
+	epoch := conv.epoch
+	conv.mu.Unlock()
+	if list == nil {
+		list = []Criterion{}
+	}
+	conv.appendDelta(epoch, map[string]any{"criteria": list, "ts": time.Now().UnixMilli()})
+}

internal/loki/code_criteria_test.go

@@ -0,0 +1,73 @@
+package loki
+
+import (
+	"strings"
+	"testing"
+)
+
+// Cycle de vie des critères : add → set → clear, avec la garde allowPass.
+func TestCriteresCycleDeVie(t *testing.T) {
+	withWorkspace(t)
+	id := convEnsureActive()
+
+	out := toolCriteria(map[string]any{"action": "add", "texts": []any{"le test passe", "le build compile"}}, false)
+	if !strings.Contains(out, "2 critère(s)") {
+		t.Fatalf("ajout raté : %s", out)
+	}
+	list := critList(id)
+	if len(list) != 2 || list[0].ID != 1 || list[1].ID != 2 {
+		t.Fatalf("liste inattendue : %+v", list)
+	}
+	// Le builder (allowPass=false) ne peut PAS s'auto-valider.
+	out = toolCriteria(map[string]any{"action": "set", "id": float64(1), "status": "passed"}, false)
+	if !strings.Contains(out, "[refusé]") {
+		t.Fatalf("auto-validation acceptée : %s", out)
+	}
+	// Le vérificateur (allowPass=true), si.
+	out = toolCriteria(map[string]any{"action": "set", "id": float64(1), "status": "passed"}, true)
+	if !strings.Contains(out, "passed") || strings.Contains(out, "[refusé]") {
+		t.Fatalf("validation vérificateur refusée : %s", out)
+	}
+	// failed reste ouvert à tous (le builder peut constater un échec).
+	out = toolCriteria(map[string]any{"action": "set", "id": float64(2), "status": "failed", "note": "le build casse"}, false)
+	if !strings.Contains(out, "failed") {
+		t.Fatalf("échec non enregistré : %s", out)
+	}
+	list = critList(id)
+	if critAllPassed(list) {
+		t.Fatal("allPassed avec un failed")
+	}
+	if critPending(list) != 1 {
+		t.Fatalf("pending = %d, attendu 1", critPending(list))
+	}
+	// Rendu : les statuts sont visibles.
+	r := critRender(list)
+	if !strings.Contains(r, "[✓] #1") || !strings.Contains(r, "[✗] #2") || !strings.Contains(r, "le build casse") {
+		t.Fatalf("rendu incomplet :\n%s", r)
+	}
+	toolCriteria(map[string]any{"action": "clear"}, false)
+	if len(critList(id)) != 0 {
+		t.Fatal("clear sans effet")
+	}
+}
+
+// Une liste vide n'est pas un contrat rempli.
+func TestContratVide(t *testing.T) {
+	if critAllPassed(nil) {
+		t.Fatal("liste vide considérée comme remplie")
+	}
+}
+
+// Le plafond de critères tient.
+func TestCriteresPlafond(t *testing.T) {
+	withWorkspace(t)
+	id := convEnsureActive()
+	var texts []any
+	for i := 0; i < critMaxCount+10; i++ {
+		texts = append(texts, "critère")
+	}
+	toolCriteria(map[string]any{"action": "add", "texts": texts}, false)
+	if n := len(critList(id)); n != critMaxCount {
+		t.Fatalf("%d critères, plafond %d", n, critMaxCount)
+	}
+}

internal/loki/code_git.go

@@ -0,0 +1,149 @@
+package loki
+
+// code_git.go — outils git natifs du mode code : git_status, git_diff,
+// git_clone. Le modèle les avait via bash, mais des outils dédiés donnent une
+// sortie bornée, un libellé propre dans le fil, et un clone qui atterrit
+// TOUJOURS dans le dossier de la discussion (jamais ailleurs sur le disque).
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"time"
+)
+
+const gitMaxOutput = 8000
+
+func gitStatusTool() Tool {
+	return Tool{
+		Type: "function",
+		Function: ToolFunction{
+			Name:        "git_status",
+			Description: "git status of the working folder (branch + changed files, porcelain format).",
+			Parameters: map[string]any{
+				"type":       "object",
+				"properties": map[string]any{},
+			},
+		},
+	}
+}
+
+func gitDiffTool() Tool {
+	return Tool{
+		Type: "function",
+		Function: ToolFunction{
+			Name:        "git_diff",
+			Description: "git diff of the working folder (unstaged + staged). Optional file to diff a single path.",
+			Parameters: map[string]any{
+				"type": "object",
+				"properties": map[string]any{
+					"file": map[string]any{"type": "string", "description": "Limit the diff to this path"},
+				},
+			},
+		},
+	}
+}
+
+func gitCloneTool() Tool {
+	return Tool{
+		Type: "function",
+		Function: ToolFunction{
+			Name:        "git_clone",
+			Description: "Clone a git repository (https:// or git@) INTO the working folder of this discussion.",
+			Parameters: map[string]any{
+				"type": "object",
+				"properties": map[string]any{
+					"url": map[string]any{"type": "string", "description": "Repository URL"},
+					"dir": map[string]any{"type": "string", "description": "Target folder name (default: repo name)"},
+				},
+				"required": []string{"url"},
+			},
+		},
+	}
+}
+
+// runGit exécute git dans le dossier de la discussion, sortie bornée.
+func runGit(ctx context.Context, timeout time.Duration, args ...string) string {
+	if _, err := exec.LookPath("git"); err != nil {
+		return "[erreur] git n'est pas installé sur cette machine"
+	}
+	cctx, cancel := context.WithTimeout(ctx, timeout)
+	defer cancel()
+	cmd := exec.CommandContext(cctx, "git", args...)
+	cmd.Dir = agentCwd()
+	// Jamais d'invite interactive (mot de passe, hôte inconnu) : un process
+	// serveur n'a personne pour y répondre, il faut échouer vite et le dire.
+	cmd.Env = append(os.Environ(), "GIT_TERMINAL_PROMPT=0", "GIT_SSH_COMMAND=ssh -oBatchMode=yes")
+	out, err := cmd.CombinedOutput()
+	s := tailRunes(strings.TrimSpace(string(out)), gitMaxOutput)
+	if cctx.Err() == context.DeadlineExceeded {
+		return "[timeout] git " + strings.Join(args, " ")
+	}
+	if err != nil {
+		if s == "" {
+			s = err.Error()
+		}
+		return "[erreur] " + s
+	}
+	if s == "" {
+		s = "(aucune sortie)"
+	}
+	return s
+}
+
+func toolGitStatus(ctx context.Context) string {
+	return runGit(ctx, 20*time.Second, "status", "--porcelain=v1", "--branch")
+}
+
+func toolGitDiff(ctx context.Context, args map[string]any) string {
+	// Un seul appel qui montre TOUT ce qui a changé : index + arbre de travail.
+	// HEAD peut ne pas exister (dépôt tout neuf) : on retombe sur le diff simple.
+	gitArgs := []string{"diff", "HEAD"}
+	if file, _ := args["file"].(string); strings.TrimSpace(file) != "" {
+		gitArgs = append(gitArgs, "--", file)
+	}
+	out := runGit(ctx, 30*time.Second, gitArgs...)
+	if strings.HasPrefix(out, "[erreur]") && strings.Contains(out, "HEAD") {
+		fallback := []string{"diff"}
+		if file, _ := args["file"].(string); strings.TrimSpace(file) != "" {
+			fallback = append(fallback, "--", file)
+		}
+		out = runGit(ctx, 30*time.Second, fallback...)
+	}
+	return out
+}
+
+// gitURLRe : https:// ou git@hôte: — pas de chemins locaux ni de protocoles
+// exotiques (file://, ext:: qui exécute une commande arbitraire).
+var gitURLRe = regexp.MustCompile(`^(https://[\w.\-]+(:\d+)?/|git@[\w.\-]+:)[\w.\-~/]+$`)
+
+func toolGitClone(ctx context.Context, args map[string]any) string {
+	url, _ := args["url"].(string)
+	url = strings.TrimSpace(strings.TrimSuffix(strings.TrimSpace(url), ".git")) + ".git"
+	if !gitURLRe.MatchString(strings.TrimSuffix(url, ".git")) && !gitURLRe.MatchString(url) {
+		return "[erreur] URL refusée — seuls https:// et git@hôte: sont acceptés"
+	}
+	dir, _ := args["dir"].(string)
+	dir = strings.TrimSpace(dir)
+	if dir == "" {
+		base := filepath.Base(strings.TrimSuffix(url, ".git"))
+		dir = base
+	}
+	// Le clone atterrit DANS la discussion, quoi qu'il arrive.
+	if strings.Contains(dir, "..") || filepath.IsAbs(dir) {
+		return "[erreur] dossier cible invalide"
+	}
+	target := filepath.Join(agentCwd(), dir)
+	if _, err := os.Stat(target); err == nil {
+		return "[erreur] le dossier " + dir + " existe déjà"
+	}
+	out := runGit(ctx, 5*time.Minute, "clone", "--", url, target)
+	if strings.HasPrefix(out, "[erreur]") || strings.HasPrefix(out, "[timeout]") {
+		return out
+	}
+	return fmt.Sprintf("[ok] cloné dans %s/\n%s", dir, out)
+}

internal/loki/code_jobs.go

@@ -0,0 +1,191 @@
+package loki
+
+// code_jobs.go — commandes shell d'ARRIÈRE-PLAN pour le mode code : bash_bg
+// lance un process détaché (serveur de dev, watcher, build long) et rend la
+// main tout de suite ; bash_tail relit sa sortie et son état. Sans ça, le
+// modèle lance `./serveur &` dans bash et le tour reste suspendu aux tubes
+// (voir le commentaire WaitDelay de runShell).
+//
+// La sortie va dans un fichier du dossier de la discussion
+// (.loki/jobs/<id>.log) : elle survit au tour, et le panneau Fichiers la montre.
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+)
+
+type bgJob struct {
+	ID      string
+	Command string
+	LogPath string
+	Cmd     *exec.Cmd
+	Started time.Time
+
+	mu   sync.Mutex
+	done bool
+	exit int
+}
+
+var (
+	jobsMu sync.Mutex
+	jobs   = map[string]*bgJob{}
+	jobSeq int
+)
+
+func bashBgTool() Tool {
+	return Tool{
+		Type: "function",
+		Function: ToolFunction{
+			Name:        "bash_bg",
+			Description: "Start a shell command in the BACKGROUND (dev server, watcher, long build) and return immediately with a job id. Output goes to a log file; check it with bash_tail. Use this instead of appending '&' in bash.",
+			Parameters: map[string]any{
+				"type": "object",
+				"properties": map[string]any{
+					"command": map[string]any{"type": "string", "description": "The command"},
+				},
+				"required": []string{"command"},
+			},
+		},
+	}
+}
+
+func bashTailTool() Tool {
+	return Tool{
+		Type: "function",
+		Function: ToolFunction{
+			Name:        "bash_tail",
+			Description: "Read the last lines of a background job's output and its status (running/exited). kill:true stops the job.",
+			Parameters: map[string]any{
+				"type": "object",
+				"properties": map[string]any{
+					"id":    map[string]any{"type": "string", "description": "Job id from bash_bg"},
+					"lines": map[string]any{"type": "integer", "description": "Lines to show (default 40, max 200)"},
+					"kill":  map[string]any{"type": "boolean", "description": "Stop the job"},
+				},
+				"required": []string{"id"},
+			},
+		},
+	}
+}
+
+// toolBashBg lance la commande détachée. Même politique que bash (commandes
+// dangereuses refusées), même dossier de départ (discussion courante).
+func toolBashBg(args map[string]any) string {
+	command, _ := args["command"].(string)
+	if strings.TrimSpace(command) == "" {
+		return "[erreur] commande vide"
+	}
+	if reason := dangerousCommand(command); reason != "" {
+		return refusedCommandResult(reason)
+	}
+	ws := agentCwd()
+	logDir := filepath.Join(ws, ".loki", "jobs")
+	if err := os.MkdirAll(logDir, 0o755); err != nil {
+		return "[erreur] " + err.Error()
+	}
+	jobsMu.Lock()
+	jobSeq++
+	id := fmt.Sprintf("job%d", jobSeq)
+	jobsMu.Unlock()
+	logPath := filepath.Join(logDir, id+".log")
+	logFile, err := os.Create(logPath)
+	if err != nil {
+		return "[erreur] " + err.Error()
+	}
+	// Contexte de FOND, pas celui du tour : le job doit survivre à la fin du
+	// tour — c'est sa raison d'être. Il s'arrête par bash_tail kill:true, ou
+	// avec le conteneur.
+	cmd := newShellCmdDetached(command)
+	cmd.Dir = ws
+	cmd.Stdout = logFile
+	cmd.Stderr = logFile
+	if err := cmd.Start(); err != nil {
+		logFile.Close()
+		return "[erreur] " + err.Error()
+	}
+	j := &bgJob{ID: id, Command: command, LogPath: logPath, Cmd: cmd, Started: time.Now()}
+	jobsMu.Lock()
+	jobs[id] = j
+	jobsMu.Unlock()
+	go func() {
+		err := cmd.Wait()
+		logFile.Close()
+		j.mu.Lock()
+		j.done = true
+		if ee, ok := err.(*exec.ExitError); ok {
+			j.exit = ee.ExitCode()
+		}
+		j.mu.Unlock()
+	}()
+	return fmt.Sprintf("[ok] job %s lancé (pid %d) — sortie dans .loki/jobs/%s.log, suis-la avec bash_tail", id, cmd.Process.Pid, id)
+}
+
+// toolBashTail relit la fin du journal d'un job et son état.
+func toolBashTail(args map[string]any) string {
+	id, _ := args["id"].(string)
+	jobsMu.Lock()
+	j := jobs[id]
+	jobsMu.Unlock()
+	if j == nil {
+		return "[erreur] job inconnu : " + id
+	}
+	if kill, _ := args["kill"].(bool); kill {
+		j.mu.Lock()
+		running := !j.done
+		j.mu.Unlock()
+		if running && j.Cmd.Process != nil {
+			_ = j.Cmd.Process.Kill()
+		}
+	}
+	lines := 40
+	if v, ok := args["lines"].(float64); ok && int(v) > 0 {
+		lines = int(v)
+	}
+	if lines > 200 {
+		lines = 200
+	}
+	b, err := os.ReadFile(j.LogPath)
+	if err != nil {
+		return "[erreur] " + err.Error()
+	}
+	all := strings.Split(strings.TrimRight(string(b), "\n"), "\n")
+	if len(all) > lines {
+		all = all[len(all)-lines:]
+	}
+	j.mu.Lock()
+	status := "en cours"
+	if j.done {
+		status = fmt.Sprintf("terminé (exit %d)", j.exit)
+	}
+	j.mu.Unlock()
+	out := fmt.Sprintf("job %s — %s — depuis %s\ncommande : %s\n", j.ID, status, time.Since(j.Started).Round(time.Second), j.Command)
+	tail := strings.Join(all, "\n")
+	if strings.TrimSpace(tail) == "" {
+		tail = "(aucune sortie pour l'instant)"
+	}
+	return out + "\n" + tailRunes(tail, toolMaxOutput)
+}
+
+// stopConvJobs tue les jobs d'une discussion (suppression / vidage de la
+// discussion : ses fichiers partent, ses process aussi).
+func stopConvJobs(convID string) {
+	prefix := filepath.Join(agentWorkspace(), convFilesRoot, safeConvID(convID))
+	jobsMu.Lock()
+	defer jobsMu.Unlock()
+	for id, j := range jobs {
+		if strings.HasPrefix(j.LogPath, prefix) {
+			j.mu.Lock()
+			running := !j.done
+			j.mu.Unlock()
+			if running && j.Cmd.Process != nil {
+				_ = j.Cmd.Process.Kill()
+			}
+			delete(jobs, id)
+		}
+	}
+}

internal/loki/code_mode.go

@@ -0,0 +1,181 @@
+package loki
+
+// code_mode.go — le mode Chat/Code d'une discussion. Bascule EXPLICITE
+// (sélecteur dans le pied du composeur), persistée par discussion ; en mode
+// chat, une détection côté serveur peut SUGGÉRER la bascule (puce ignorable
+// dans l'UI) mais ne l'impose jamais — un faux positif coûterait des tours de
+// planification/vérification sur un simple bonjour.
+
+import (
+	"encoding/json"
+	"net/http"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+func modeKey(convID string) string { return "mode:" + convID }
+func hintKey(convID string) string { return "hinted:" + convID }
+
+// convCodeMode : la discussion active est-elle en mode code ?
+func convCodeMode() bool { return getStr(bkChat, modeKey(convEnsureActive())) == "code" }
+
+func setConvMode(convID, mode string) error {
+	if mode != "code" {
+		mode = "" // chat = défaut = clé absente
+	}
+	return putStr(bkChat, modeKey(convID), mode)
+}
+
+// dropConvMode : appelé à la suppression d'une discussion.
+func dropConvMode(convID string) {
+	_ = putStr(bkChat, modeKey(convID), "")
+	_ = putStr(bkChat, hintKey(convID), "")
+}
+
+// --- Détection « ça ressemble à du code » ------------------------------------
+// Côté serveur, AUCUN token : ni consigne dans le prompt, ni appel modèle.
+// Un indice suffit ; la puce de l'UI est gratuite à ignorer.
+
+var codeHintRes = []*regexp.Regexp{
+	// Un bloc de code clôturé.
+	regexp.MustCompile("```"),
+	// Un chemin de fichier source.
+	regexp.MustCompile(`(?i)\b[\w./\\-]+\.(go|py|js|jsx|ts|tsx|rs|java|kt|c|h|cpp|hpp|cs|rb|php|swift|sh|ps1|sql|html|css|scss|vue|svelte|toml|yaml|yml|json|dockerfile|makefile)\b`),
+	// Verbes / vocabulaire de tâche de code.
+	regexp.MustCompile(`(?i)\b(corrige|implémente|implemente|refactor|refactorise|débogue|debug|compile|stack ?trace|segfault|exception|traceback|unit ?test|pull ?request|merge|commit|clone)\b`),
+	regexp.MustCompile(`(?i)\b(bug|erreur de compilation|tests? (échoue|cassé)|fonction|classe|module|api rest|endpoint)\b`),
+}
+
+// looksLikeCode dit si un message utilisateur ressemble à une tâche de code.
+// Le dépôt git déjà cloné dans la discussion est aussi un indice fort.
+func looksLikeCode(text string) bool {
+	if strings.TrimSpace(text) == "" {
+		return false
+	}
+	for _, re := range codeHintRes {
+		if re.MatchString(text) {
+			return true
+		}
+	}
+	return false
+}
+
+// convHasRepo : un dépôt git vit déjà dans le dossier de la discussion.
+func convHasRepo() bool {
+	ws := agentCwd()
+	if _, err := os.Stat(filepath.Join(ws, ".git")); err == nil {
+		return true
+	}
+	entries, err := os.ReadDir(ws)
+	if err != nil {
+		return false
+	}
+	for _, e := range entries {
+		if !e.IsDir() {
+			continue
+		}
+		if _, err := os.Stat(filepath.Join(ws, e.Name(), ".git")); err == nil {
+			return true
+		}
+	}
+	return false
+}
+
+// maybeCodeHint émet la puce « passer en mode Code ? » si le message s'y
+// prête. Une seule fois par discussion : une suggestion répétée est du bruit.
+func maybeCodeHint(c *Conversation, epoch int, text string) {
+	if convCodeMode() || !agentEnabled() {
+		return
+	}
+	id := convEnsureActive()
+	if getBool(bkChat, hintKey(id)) {
+		return
+	}
+	if !looksLikeCode(text) && !convHasRepo() {
+		return
+	}
+	_ = putBool(bkChat, hintKey(id), true)
+	c.appendDelta(epoch, map[string]any{"code_hint": true})
+}
+
+// --- API ---------------------------------------------------------------------
+
+// handleChatMode — GET : {mode, criteria} de la discussion active ;
+// POST {"mode":"code"|"chat"} : bascule (et pousse le nouvel état aux abonnés).
+func handleChatMode(w http.ResponseWriter, r *http.Request) {
+	if r.Method == http.MethodPost {
+		var body struct {
+			Mode string `json:"mode"`
+		}
+		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+			sendJSON(w, 400, map[string]any{"ok": false, "error": err.Error()})
+			return
+		}
+		if body.Mode != "code" && body.Mode != "chat" {
+			sendJSON(w, 400, map[string]any{"ok": false, "error": "mode inconnu (chat|code)"})
+			return
+		}
+		id := convEnsureActive()
+		if err := setConvMode(id, body.Mode); err != nil {
+			sendJSON(w, 500, map[string]any{"ok": false, "error": err.Error()})
+			return
+		}
+		// Pousse la bascule à tous les appareils abonnés (le sélecteur doit
+		// suivre, comme le fil lui-même).
+		conv.mu.Lock()
+		epoch := conv.epoch
+		conv.mu.Unlock()
+		conv.appendDelta(epoch, map[string]any{"mode": body.Mode})
+		sendJSON(w, 200, map[string]any{"ok": true, "mode": body.Mode})
+		return
+	}
+	mode := "chat"
+	if convCodeMode() {
+		mode = "code"
+	}
+	sendJSON(w, 200, map[string]any{
+		"ok":       true,
+		"mode":     mode,
+		"criteria": critList(convEnsureActive()),
+	})
+}
+
+// handleChatCriteria — POST : édition manuelle des critères depuis l'UI.
+// {"criteria":[{"id":1,"text":"…","status":"pending"},…]} remplace la liste.
+func handleChatCriteria(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		sendJSON(w, 405, map[string]any{"ok": false, "error": "POST attendu"})
+		return
+	}
+	var body struct {
+		Criteria []Criterion `json:"criteria"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		sendJSON(w, 400, map[string]any{"ok": false, "error": err.Error()})
+		return
+	}
+	var clean []Criterion
+	next := 1
+	for _, c := range body.Criteria {
+		if strings.TrimSpace(c.Text) == "" || len(clean) >= critMaxCount {
+			continue
+		}
+		if c.ID <= 0 {
+			c.ID = next
+		}
+		if c.ID >= next {
+			next = c.ID + 1
+		}
+		switch c.Status {
+		case "pending", "passed", "failed":
+		default:
+			c.Status = "pending"
+		}
+		clean = append(clean, c)
+	}
+	critSave(convEnsureActive(), clean)
+	critNotify(clean)
+	sendJSON(w, 200, map[string]any{"ok": true, "criteria": clean})
+}

internal/loki/code_mode_test.go

@@ -0,0 +1,74 @@
+package loki
+
+import "testing"
+
+// La bascule est persistée par discussion et retombe sur chat par défaut.
+func TestModeParDiscussion(t *testing.T) {
+	withWorkspace(t)
+	id := convEnsureActive()
+	if convCodeMode() {
+		t.Fatal("mode code par défaut")
+	}
+	if err := setConvMode(id, "code"); err != nil {
+		t.Fatal(err)
+	}
+	if !convCodeMode() {
+		t.Fatal("bascule sans effet")
+	}
+	dropConvMode(id)
+	if convCodeMode() {
+		t.Fatal("mode code après nettoyage")
+	}
+}
+
+// La détection reconnaît une tâche de code, pas la conversation ordinaire.
+func TestDetectionCode(t *testing.T) {
+	for _, s := range []string{
+		"corrige le bug dans main.go",
+		"j'ai une stack trace : Exception in thread",
+		"```python\nprint('x')\n```",
+		"implémente la fonction de tri",
+		"le build casse avec une erreur de compilation",
+	} {
+		if !looksLikeCode(s) {
+			t.Errorf("non détecté : %q", s)
+		}
+	}
+	for _, s := range []string{
+		"quelle est la capitale de l'Australie ?",
+		"raconte-moi une histoire",
+		"quel temps fait-il demain ?",
+		"",
+	} {
+		if looksLikeCode(s) {
+			t.Errorf("détecté à tort : %q", s)
+		}
+	}
+}
+
+// Les rôles embarqués existent tous, et le prompt du builder est court —
+// la règle « ne pas regonfler » de baseSystemPrompt s'applique aussi ici.
+func TestRolesEmbarques(t *testing.T) {
+	for _, r := range roleNames {
+		p := rolePrompt(r)
+		if p == "" {
+			t.Errorf("rôle %s : prompt vide", r)
+		}
+		if len(p) > 2500 {
+			t.Errorf("rôle %s : prompt trop long (%d octets)", r, len(p))
+		}
+	}
+	if rolePrompt("inexistant") != "" {
+		t.Error("rôle inconnu devrait rendre vide")
+	}
+}
+
+// wantsPlan : demande de plan reconnue, implémentation directe non.
+func TestWantsPlan(t *testing.T) {
+	if !wantsPlan("Fais un plan avant de coder") {
+		t.Error("plan non reconnu")
+	}
+	if wantsPlan("corrige le bug maintenant") {
+		t.Error("plan détecté à tort")
+	}
+}

internal/loki/code_policy.go

@@ -0,0 +1,160 @@
+package loki
+
+// code_policy.go — politique d'exécution des outils de l'agent (repris dans
+// l'esprit de tool-policy/path-security d'OpenFox, réécrit en Go — voir
+// NOTICE.md).
+//
+// Deux gardes indépendantes :
+//   - dangerousCommand : liste courte de commandes CATASTROPHIQUES (effacement
+//     de disque, arrêt machine, fork bomb). Toujours active, mode chat compris :
+//     aucune de ces commandes n'a d'usage légitime lancée par un modèle. Le
+//     refus explique quoi faire (l'utilisateur la lance lui-même).
+//   - codePathAllowed : en MODE CODE, tous les chemins des outils fichiers sont
+//     bornés au dossier de la discussion — liens symboliques résolus des deux
+//     côtés, comme le panneau Fichiers (relWithin). Le mode chat garde le
+//     comportement historique (chemins absolus honorés) : c'est le mode code
+//     qui promet un bac à sable, pas l'agent généraliste.
+
+import (
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"sync"
+)
+
+// dangerousPatterns : motifs (insensibles à la casse) de commandes refusées.
+// Volontairement ÉTROIT : viser la perte de données irréversible et l'arrêt de
+// la machine, pas la moindre écriture. Un motif trop large rend l'agent
+// inutilisable et pousse à tout désactiver.
+var dangerousPatterns = []struct {
+	re     *regexp.Regexp
+	reason string
+}{
+	// rm -rf / (ou ~, ou une racine de lecteur) — pas un rm -rf d'un sous-dossier.
+	{regexp.MustCompile(`(?i)\brm\s+(-[a-z]*r[a-z]*f[a-z]*|-[a-z]*f[a-z]*r[a-z]*)\s+("?/"?|~/?|/\*|[a-z]:\\?)\s*$`), "efface la racine du disque ou le home"},
+	{regexp.MustCompile(`(?i)\brm\s+(-[a-z]*r[a-z]*f[a-z]*|-[a-z]*f[a-z]*r[a-z]*)\s+("?/"?|~/?|/\*|[a-z]:\\?)\s`), "efface la racine du disque ou le home"},
+	// Écriture directe sur un périphérique bloc / formatage.
+	{regexp.MustCompile(`(?i)\bmkfs(\.[a-z0-9]+)?\b`), "formate un système de fichiers"},
+	{regexp.MustCompile(`(?i)\bdd\b[^\n]*\bof=/dev/`), "écrit directement sur un périphérique disque"},
+	{regexp.MustCompile(`(?i)>\s*/dev/sd[a-z]\b`), "écrit directement sur un périphérique disque"},
+	// Arrêt / redémarrage de la machine (ici : le conteneur, donc tout Loki).
+	// Ancré en position de COMMANDE (début, après ; && | ou sudo) : le mot
+	// « reboot » dans un grep ou un texte n'est pas une commande.
+	{regexp.MustCompile(`(?i)(^|[;&|]\s*|\bsudo\s+)(shutdown|poweroff|reboot|halt)\b`), "arrête ou redémarre la machine"},
+	// Fork bomb classique.
+	{regexp.MustCompile(`:\(\)\s*\{\s*:\|:`), "fork bomb"},
+	// chmod/chown récursif sur la racine.
+	{regexp.MustCompile(`(?i)\bch(mod|own)\b[^\n]*-[a-z]*R[a-z]*\s+[^\s]+\s+/\s*$`), "change récursivement les droits de la racine"},
+	// Windows : suppression récursive de la racine d'un lecteur, format.
+	{regexp.MustCompile(`(?i)\b(rd|rmdir)\s+/s\b[^\n]*\s[a-z]:\\?\s*$`), "efface la racine d'un lecteur"},
+	{regexp.MustCompile(`(?i)\bdel\s+(/[fsq]\s+)*[a-z]:\\\*`), "efface la racine d'un lecteur"},
+	{regexp.MustCompile(`(?i)\bformat\s+[a-z]:`), "formate un lecteur"},
+}
+
+// dangerousCommand renvoie la raison du refus si la commande correspond à un
+// motif interdit, "" sinon.
+func dangerousCommand(cmd string) string {
+	for _, p := range dangerousPatterns {
+		if p.re.MatchString(cmd) {
+			return p.reason
+		}
+	}
+	return ""
+}
+
+// refusedCommandResult formate le refus renvoyé au modèle : dire POURQUOI et
+// QUOI FAIRE, sinon il réessaie en boucle avec des variantes.
+func refusedCommandResult(reason string) string {
+	return "[refusé] Commande bloquée par la politique de sécurité : " + reason + ". " +
+		"Ne la réessaie pas, même reformulée. Si l'utilisateur la veut vraiment, dis-lui de la lancer lui-même dans un terminal."
+}
+
+// codePathAllowed dit si un chemin (déjà résolu par resolveAgentPath) est DANS
+// le dossier de la discussion courante. Utilisé par les outils fichiers en mode
+// code uniquement.
+func codePathAllowed(abs string) bool {
+	ws := agentCwd()
+	if ws == "" {
+		return false
+	}
+	abs = filepath.Clean(abs)
+	// Le fichier peut ne pas exister encore (write) : EvalSymlinks échouerait.
+	// On teste alors son ancêtre le plus proche existant — c'est LUI qui doit
+	// être dans le workspace, liens symboliques résolus.
+	probe := abs
+	for {
+		if _, err := os.Stat(probe); err == nil {
+			break
+		}
+		parent := filepath.Dir(probe)
+		if parent == probe {
+			break
+		}
+		probe = parent
+	}
+	if !sameOrWithin(ws, probe) {
+		return false
+	}
+	// L'ancêtre est dans le workspace ; le chemin FINAL ne doit pas en
+	// ressortir par des ".." lexicaux non encore résolus.
+	rel, err := filepath.Rel(ws, abs)
+	if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
+		return false
+	}
+	return true
+}
+
+// sameOrWithin : p est root lui-même, ou dedans — liens symboliques résolus
+// des deux côtés (relWithin refuse « . », d'où ce cousin qui l'accepte : la
+// racine du workspace est un chemin légitime pour grep/glob).
+func sameOrWithin(root, p string) bool {
+	if r, err := filepath.EvalSymlinks(root); err == nil {
+		root = r
+	}
+	if q, err := filepath.EvalSymlinks(p); err == nil {
+		p = q
+	}
+	rel, err := filepath.Rel(root, p)
+	if err != nil {
+		return false
+	}
+	return rel == "." || (rel != ".." && !strings.HasPrefix(rel, ".."+string(filepath.Separator)))
+}
+
+// refusedPathResult : refus de chemin hors du bac à sable du mode code.
+func refusedPathResult(path string) string {
+	return "[refusé] " + path + " est hors du dossier de cette discussion. " +
+		"En mode code, tous les fichiers vivent dans le dossier de travail — utilise des chemins relatifs."
+}
+
+// codeWriteGuard regroupe les gardes du mode code AVANT une écriture locale
+// (write/edit) : borne de chemin, puis tracker « lu avant d'écrire ».
+// Renvoie "" si tout est bon, sinon le message de refus pour le modèle.
+// En mode chat, aucune garde : comportement historique de l'agent.
+func codeWriteGuard(caps Caps, file string, forWrite bool) string {
+	if !caps.Code {
+		return ""
+	}
+	path := resolveAgentPath(file)
+	if !codePathAllowed(path) {
+		return refusedPathResult(file)
+	}
+	return trackerCheck(path, forWrite)
+}
+
+// --- Mutex par fichier -------------------------------------------------------
+// Sérialise les écritures concurrentes sur un même fichier (write/edit). Sans
+// parallélisme d'outils aujourd'hui le coût est nul, mais le jour où deux tours
+// ou un job d'arrière-plan écrivent le même fichier, la corruption est évitée.
+
+var fileMuMap sync.Map // clé : chemin nettoyé → *sync.Mutex
+
+func fileMu(path string) *sync.Mutex {
+	key := filepath.Clean(path)
+	if m, ok := fileMuMap.Load(key); ok {
+		return m.(*sync.Mutex)
+	}
+	m, _ := fileMuMap.LoadOrStore(key, &sync.Mutex{})
+	return m.(*sync.Mutex)
+}

internal/loki/code_policy_test.go

@@ -0,0 +1,101 @@
+package loki
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// La politique doit bloquer les commandes catastrophiques…
+func TestCommandesDangereusesBloquees(t *testing.T) {
+	for _, cmd := range []string{
+		"rm -rf /",
+		"rm -fr / --no-preserve-root",
+		"sudo rm -rf /*",
+		"mkfs.ext4 /dev/sda1",
+		"dd if=/dev/zero of=/dev/sda",
+		"echo pwned > /dev/sda",
+		"shutdown -h now",
+		"reboot",
+		":(){ :|:& };:",
+		"format c:",
+		"rd /s /q C:\\",
+	} {
+		if dangerousCommand(cmd) == "" {
+			t.Errorf("aurait dû être bloquée : %q", cmd)
+		}
+	}
+}
+
+// … et laisser passer le travail normal, y compris les rm ciblés.
+func TestCommandesNormalesAutorisees(t *testing.T) {
+	for _, cmd := range []string{
+		"ls -la",
+		"go test ./...",
+		"rm -rf node_modules",
+		"rm -rf ./dist",
+		"git rm --cached fichier.txt",
+		"grep -r 'reboot the router' docs/",
+		"npm run build",
+		"dd if=disque.img of=copie.img",
+		"echo bonjour > notes.txt",
+	} {
+		if r := dangerousCommand(cmd); r != "" {
+			t.Errorf("bloquée à tort (%s) : %q", r, cmd)
+		}
+	}
+}
+
+// En mode code, les chemins sont bornés au dossier de la discussion :
+// dedans OK, dehors refusé, y compris par remontée de ../.
+func TestCodePathBorne(t *testing.T) {
+	ws := withWorkspace(t)
+	inside := filepath.Join(ws, "src", "main.go")
+	if !codePathAllowed(inside) {
+		t.Error("chemin intérieur refusé")
+	}
+	if !codePathAllowed(filepath.Join(ws, "nouveau.txt")) {
+		t.Error("fichier à créer (inexistant) refusé")
+	}
+	outside := filepath.Join(filepath.Dir(ws), "ailleurs.txt")
+	if codePathAllowed(outside) {
+		t.Error("chemin extérieur accepté")
+	}
+	if codePathAllowed(filepath.Join(ws, "..", "..", "etc", "passwd")) {
+		t.Error("remontée ../ acceptée")
+	}
+}
+
+// codeWriteGuard : inactif en mode chat, actif en mode code (borne + tracker).
+func TestCodeWriteGuard(t *testing.T) {
+	ws := withWorkspace(t)
+	chat := Caps{Agent: true}
+	code := Caps{Agent: true, Code: true}
+
+	// Mode chat : aucune garde, même hors workspace.
+	if msg := codeWriteGuard(chat, "/tmp/hors-discussion.txt", true); msg != "" {
+		t.Errorf("mode chat gardé à tort : %s", msg)
+	}
+	// Mode code : hors workspace refusé.
+	if msg := codeWriteGuard(code, filepath.Join(filepath.Dir(ws), "x.txt"), true); msg == "" {
+		t.Error("écriture hors workspace acceptée en mode code")
+	}
+	// Fichier existant jamais lu : write refusé (tracker).
+	target := filepath.Join(ws, "present.txt")
+	if err := os.WriteFile(target, []byte("v1"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if msg := codeWriteGuard(code, "present.txt", true); !strings.Contains(msg, "pas lu") {
+		t.Errorf("écrasement sans lecture accepté : %q", msg)
+	}
+	// Après lecture : autorisé.
+	trackerNoteRead(target)
+	if msg := codeWriteGuard(code, "present.txt", true); msg != "" {
+		t.Errorf("refusé après lecture : %s", msg)
+	}
+	// Création d'un fichier neuf : pas de lecture préalable exigée.
+	if msg := codeWriteGuard(code, "neuf.txt", true); msg != "" {
+		t.Errorf("création refusée : %s", msg)
+	}
+}

internal/loki/code_retry.go

@@ -0,0 +1,84 @@
+package loki
+
+// code_retry.go — filets « auto-retry » (repris des auto-retry patterns
+// d'OpenFox, réécrits en Go — voir NOTICE.md) : quand le modèle termine son
+// tour sur un texte qui contient un APPEL D'OUTIL TEXTUEL (halluciné, donc
+// jamais exécuté), on relance le tour UNE fois avec une consigne corrective au
+// lieu de laisser l'utilisateur lire un pseudo-JSON d'appel d'outil.
+//
+// Typique des petits modèles très quantifiés : `default_api:bash`,
+// `<tool_call>{...}</tool_call>`, un bloc ```tool_code```… Le modèle VOULAIT
+// agir ; il a juste raté la syntaxe du protocole. Le nudge « pensé sans agir »
+// existant ne les attrapait pas : le tour a bien produit du contenu.
+
+import (
+	"encoding/json"
+	"regexp"
+	"sync"
+)
+
+// defaultRetryPatterns : motifs d'appels d'outils textuels. Volontairement
+// serrés — un faux positif relancerait un tour parfaitement bon.
+var defaultRetryPatterns = []string{
+	`<tool_call>`,
+	`</tool_call>`,
+	`<\|tool_call\|>`,
+	"```tool_code",
+	"```tool_call",
+	`\bdefault_api[.:]\w+`,
+	`\bfunctions\.\w+\s*\(`,
+	`^\s*\{"name":\s*"(bash|read|grep|glob|edit|write|mem_\w+|web_\w+|git_\w+|criteria|ask)"`,
+	`\[TOOL_REQUEST\]`,
+}
+
+// Compilés à la première utilisation, pas à l'init du package : la surcharge
+// vit dans la base bbolt, qu'on ne veut pas ouvrir avant que le process ait
+// choisi son rôle (CLI, serveur…).
+var (
+	retryOnce sync.Once
+	retryRes  []*regexp.Regexp
+)
+
+func retryPatterns() []*regexp.Regexp {
+	retryOnce.Do(func() { retryRes = compileRetryPatterns() })
+	return retryRes
+}
+
+func compileRetryPatterns() []*regexp.Regexp {
+	pats := defaultRetryPatterns
+	// Surcharge optionnelle : clé d'état `retry_patterns` = tableau JSON de
+	// regex. Pas d'UI dédiée — c'est un réglage d'expert, posé via
+	// `loki config` ou l'API ; l'embarqué couvre les cas connus.
+	if raw := getStr(bkState, "retry_patterns"); raw != "" {
+		var custom []string
+		if json.Unmarshal([]byte(raw), &custom) == nil && len(custom) > 0 {
+			pats = custom
+		}
+	}
+	var out []*regexp.Regexp
+	for _, p := range pats {
+		if re, err := regexp.Compile("(?mi)" + p); err == nil {
+			out = append(out, re)
+		}
+	}
+	return out
+}
+
+// textualToolCall dit si le texte final du tour contient un appel d'outil
+// écrit en toutes lettres au lieu d'être émis par le protocole.
+func textualToolCall(content string) bool {
+	if content == "" {
+		return false
+	}
+	for _, re := range retryPatterns() {
+		if re.MatchString(content) {
+			return true
+		}
+	}
+	return false
+}
+
+// retryCorrective : le message réinjecté pour relancer le tour.
+const retryCorrective = "Your last answer contained a TOOL CALL WRITTEN AS TEXT — it was never executed. " +
+	"Tool calls must go through the tool-call protocol, never in the answer text. " +
+	"Redo it now: emit the real tool call, or answer directly without pretending to call a tool."

internal/loki/code_retry_test.go

@@ -0,0 +1,34 @@
+package loki
+
+import "testing"
+
+// Les appels d'outils écrits en texte doivent être détectés…
+func TestAppelOutilTextuelDetecte(t *testing.T) {
+	for _, s := range []string{
+		"<tool_call>{\"name\":\"bash\"}</tool_call>",
+		"Je vais lancer default_api:bash pour vérifier.",
+		"default_api.run_shell(command='ls')",
+		"functions.bash({\"command\": \"ls\"})",
+		"```tool_code\nprint('x')\n```",
+		"{\"name\": \"bash\", \"arguments\": {\"command\": \"ls\"}}",
+	} {
+		if !textualToolCall(s) {
+			t.Errorf("non détecté : %q", s)
+		}
+	}
+}
+
+// … sans jamais relancer un tour normal (code cité, JSON quelconque).
+func TestReponseNormaleNonRelancee(t *testing.T) {
+	for _, s := range []string{
+		"Voici la réponse : le fichier contient trois fonctions.",
+		"```go\nfunc main() {}\n```",
+		"Le JSON de config : {\"name\": \"loki\", \"port\": 8090}",
+		"La fonction bash() de ce script accepte un paramètre.",
+		"",
+	} {
+		if textualToolCall(s) {
+			t.Errorf("relance à tort : %q", s)
+		}
+	}
+}

internal/loki/code_roles.go

@@ -0,0 +1,44 @@
+package loki
+
+// code_roles.go — registre des rôles du mode code. Chaque rôle est un prompt
+// Markdown EMBARQUÉ dans le binaire (agents/*.md), comme le catalogue MCP :
+// pas d'appel réseau, pour en changer on édite le fichier et on recompile.
+// Démarche reprise du registre d'agents d'OpenFox (builder/planner/explorer/
+// verifier/code-reviewer — voir NOTICE.md), prompts réécrits COURTS : un
+// préambule verbeux fait sur-raisonner les modèles locaux (voir le commentaire
+// de baseSystemPrompt).
+
+import (
+	"embed"
+	"strings"
+)
+
+//go:embed agents/*.md
+var rolesFS embed.FS
+
+// roleNames : les rôles connus. builder et verifier sont pilotés par la boucle
+// du mode code (code_verify.go) ; planner s'active quand l'utilisateur demande
+// un plan ; explorer et code-reviewer sont disponibles pour des passes
+// manuelles futures.
+var roleNames = []string{"builder", "planner", "explorer", "verifier", "code-reviewer"}
+
+// rolePrompt renvoie le prompt d'un rôle, "" si inconnu.
+func rolePrompt(name string) string {
+	b, err := rolesFS.ReadFile("agents/" + name + ".md")
+	if err != nil {
+		return ""
+	}
+	return strings.TrimSpace(string(b))
+}
+
+// planIntentRe-like : l'utilisateur demande-t-il un PLAN plutôt qu'une
+// implémentation ? Heuristique simple sur le début du message.
+func wantsPlan(text string) bool {
+	low := strings.ToLower(text)
+	for _, kw := range []string{"fais un plan", "fait un plan", "propose un plan", "planifie", "plan d'implémentation", "plan d'action", "make a plan", "plan first"} {
+		if strings.Contains(low, kw) {
+			return true
+		}
+	}
+	return false
+}

internal/loki/code_tools.go

@@ -0,0 +1,373 @@
+package loki
+
+// code_tools.go — outils fichiers du MODE CODE : read, grep, glob, ask.
+// Inspirés des outils d'OpenFox (read/grep/ask — voir NOTICE.md), réécrits en
+// Go. Sans eux, le modèle lit les fichiers au `cat` via bash : sortie non
+// bornée, pas de numéros de ligne, et aucun moyen de savoir ce qu'il a lu
+// (voir code_tracker.go).
+
+import (
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+	"unicode/utf8"
+)
+
+const (
+	readMaxLines   = 1000 // lignes par appel (offset/limit pour la suite)
+	readDefLines   = 400
+	readMaxLineLen = 500 // une ligne minifiée ne doit pas manger le contexte
+	grepMaxHits    = 60
+	globMaxHits    = 200
+)
+
+// skipDirs : dossiers ignorés par grep/glob — dépendances et artefacts, jamais
+// du code à lire. `.git` compris : son contenu binaire pollue toute recherche.
+var skipDirs = map[string]bool{
+	".git": true, "node_modules": true, "vendor": true, "dist": true,
+	"build": true, "target": true, "__pycache__": true, ".venv": true,
+	"venv": true, ".next": true, ".cache": true,
+}
+
+func readTool() Tool {
+	return Tool{
+		Type: "function",
+		Function: ToolFunction{
+			Name:        "read",
+			Description: "Read a file with 1-indexed line numbers (offset/limit for long files). ALWAYS use this instead of cat/type: output is bounded and reading a file is REQUIRED before you may edit or overwrite it.",
+			Parameters: map[string]any{
+				"type": "object",
+				"properties": map[string]any{
+					"file":   map[string]any{"type": "string", "description": "Path (relative to the working folder)"},
+					"offset": map[string]any{"type": "integer", "description": "Start line (default 1)"},
+					"limit":  map[string]any{"type": "integer", "description": fmt.Sprintf("Lines (default %d, max %d)", readDefLines, readMaxLines)},
+				},
+				"required": []string{"file"},
+			},
+		},
+	}
+}
+
+func grepTool() Tool {
+	return Tool{
+		Type: "function",
+		Function: ToolFunction{
+			Name:        "grep",
+			Description: "Search file contents with a Go regular expression. Returns path:line: text matches (bounded). path may be a file or a directory (default: whole working folder).",
+			Parameters: map[string]any{
+				"type": "object",
+				"properties": map[string]any{
+					"pattern": map[string]any{"type": "string", "description": "Go regexp"},
+					"path":    map[string]any{"type": "string", "description": "File or directory to search (default .)"},
+					"glob":    map[string]any{"type": "string", "description": "Only files matching this glob (e.g. *.go)"},
+				},
+				"required": []string{"pattern"},
+			},
+		},
+	}
+}
+
+func globTool() Tool {
+	return Tool{
+		Type: "function",
+		Function: ToolFunction{
+			Name:        "glob",
+			Description: "List files matching a glob pattern (** supported, e.g. **/*.go), most recently modified first.",
+			Parameters: map[string]any{
+				"type": "object",
+				"properties": map[string]any{
+					"pattern": map[string]any{"type": "string", "description": "Glob, e.g. src/**/*.ts"},
+				},
+				"required": []string{"pattern"},
+			},
+		},
+	}
+}
+
+func askTool() Tool {
+	return Tool{
+		Type: "function",
+		Function: ToolFunction{
+			Name:        "ask",
+			Description: "Ask the user a clarifying question with 2-4 short options, then END your turn. Their answer arrives as the next user message. Use when a decision is genuinely theirs (scope, destructive change, ambiguous requirement) — not for things you can check yourself.",
+			Parameters: map[string]any{
+				"type": "object",
+				"properties": map[string]any{
+					"question": map[string]any{"type": "string", "description": "The question"},
+					"options":  map[string]any{"type": "array", "items": map[string]any{"type": "string"}, "description": "2-4 short answer options"},
+				},
+				"required": []string{"question"},
+			},
+		},
+	}
+}
+
+// toolRead lit un fichier avec numéros de ligne. Enregistre la lecture dans le
+// tracker (code_tracker.go) — c'est ce qui autorise edit/write ensuite.
+func toolRead(args map[string]any, codeMode bool) string {
+	file, _ := args["file"].(string)
+	if strings.TrimSpace(file) == "" {
+		return "[erreur] chemin vide"
+	}
+	path := resolveAgentPath(file)
+	if codeMode && !codePathAllowed(path) {
+		return refusedPathResult(file)
+	}
+	offset, limit := 1, readDefLines
+	if v, ok := args["offset"].(float64); ok && int(v) > 0 {
+		offset = int(v)
+	}
+	if v, ok := args["limit"].(float64); ok && int(v) > 0 {
+		limit = int(v)
+	}
+	if limit > readMaxLines {
+		limit = readMaxLines
+	}
+	b, err := os.ReadFile(path)
+	if err != nil {
+		return "[erreur] " + err.Error()
+	}
+	if isBinary(b) {
+		fi, _ := os.Stat(path)
+		size := int64(len(b))
+		if fi != nil {
+			size = fi.Size()
+		}
+		return fmt.Sprintf("[binaire] %s (%d octets) — pas un fichier texte", file, size)
+	}
+	lines := strings.Split(string(b), "\n")
+	total := len(lines)
+	// Fichier fini par \n : Split laisse une dernière entrée vide, pas une ligne.
+	if total > 0 && lines[total-1] == "" {
+		total--
+	}
+	if offset > total {
+		return fmt.Sprintf("[erreur] offset %d > %d lignes", offset, total)
+	}
+	end := offset - 1 + limit
+	if end > total {
+		end = total
+	}
+	var out strings.Builder
+	for i := offset - 1; i < end; i++ {
+		l := lines[i]
+		if utf8.RuneCountInString(l) > readMaxLineLen {
+			r := []rune(l)
+			l = string(r[:readMaxLineLen]) + "…"
+		}
+		fmt.Fprintf(&out, "%d: %s\n", i+1, l)
+	}
+	if end < total {
+		fmt.Fprintf(&out, "… (%d lignes restantes — relis avec offset=%d)\n", total-end, end+1)
+	}
+	trackerNoteRead(path)
+	return strings.TrimRight(out.String(), "\n")
+}
+
+// toolGrep cherche un motif regexp dans les fichiers.
+func toolGrep(args map[string]any, codeMode bool) string {
+	pattern, _ := args["pattern"].(string)
+	if strings.TrimSpace(pattern) == "" {
+		return "[erreur] motif vide"
+	}
+	re, err := regexp.Compile(pattern)
+	if err != nil {
+		return "[erreur] motif invalide : " + err.Error()
+	}
+	root := agentCwd()
+	if p, _ := args["path"].(string); strings.TrimSpace(p) != "" && p != "." {
+		root = resolveAgentPath(p)
+	}
+	if codeMode && !codePathAllowed(root) {
+		return refusedPathResult(root)
+	}
+	globPat, _ := args["glob"].(string)
+	var hits []string
+	walkErr := filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return nil // dossier illisible : on continue ailleurs
+		}
+		if d.IsDir() {
+			if skipDirs[d.Name()] {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+		if globPat != "" {
+			if ok, _ := filepath.Match(globPat, d.Name()); !ok {
+				return nil
+			}
+		}
+		if len(hits) >= grepMaxHits {
+			return filepath.SkipAll
+		}
+		b, rerr := os.ReadFile(path)
+		if rerr != nil || isBinary(b) {
+			return nil
+		}
+		rel, rrr := filepath.Rel(root, path)
+		if rrr != nil {
+			rel = path
+		}
+		for i, line := range strings.Split(string(b), "\n") {
+			if re.MatchString(line) {
+				if utf8.RuneCountInString(line) > readMaxLineLen {
+					r := []rune(line)
+					line = string(r[:readMaxLineLen]) + "…"
+				}
+				hits = append(hits, fmt.Sprintf("%s:%d: %s", filepath.ToSlash(rel), i+1, strings.TrimSpace(line)))
+				if len(hits) >= grepMaxHits {
+					return filepath.SkipAll
+				}
+			}
+		}
+		return nil
+	})
+	if walkErr != nil && len(hits) == 0 {
+		return "[erreur] " + walkErr.Error()
+	}
+	if len(hits) == 0 {
+		return "[aucun résultat]"
+	}
+	out := strings.Join(hits, "\n")
+	if len(hits) >= grepMaxHits {
+		out += fmt.Sprintf("\n… (plafond de %d résultats atteint — affine le motif)", grepMaxHits)
+	}
+	return out
+}
+
+// toolGlob liste les fichiers correspondant à un motif, plus récents d'abord.
+func toolGlob(args map[string]any, codeMode bool) string {
+	pattern, _ := args["pattern"].(string)
+	if strings.TrimSpace(pattern) == "" {
+		return "[erreur] motif vide"
+	}
+	root := agentCwd()
+	re, err := globToRegexp(pattern)
+	if err != nil {
+		return "[erreur] motif invalide : " + err.Error()
+	}
+	type hit struct {
+		rel string
+		mod int64
+	}
+	var hits []hit
+	filepath.WalkDir(root, func(path string, d fs.DirEntry, werr error) error {
+		if werr != nil {
+			return nil
+		}
+		if d.IsDir() {
+			if skipDirs[d.Name()] {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+		rel, rerr := filepath.Rel(root, path)
+		if rerr != nil {
+			return nil
+		}
+		rel = filepath.ToSlash(rel)
+		if !re.MatchString(rel) {
+			return nil
+		}
+		info, ierr := d.Info()
+		mod := int64(0)
+		if ierr == nil {
+			mod = info.ModTime().UnixNano()
+		}
+		hits = append(hits, hit{rel, mod})
+		return nil
+	})
+	if len(hits) == 0 {
+		return "[aucun fichier]"
+	}
+	sort.Slice(hits, func(i, j int) bool { return hits[i].mod > hits[j].mod })
+	if len(hits) > globMaxHits {
+		hits = hits[:globMaxHits]
+	}
+	var out strings.Builder
+	for _, h := range hits {
+		out.WriteString(h.rel + "\n")
+	}
+	return strings.TrimRight(out.String(), "\n")
+}
+
+// globToRegexp convertit un glob (avec **) en expression régulière sur des
+// chemins en séparateurs '/'. `**` = n'importe quelle profondeur, `*` = tout
+// sauf '/', `?` = un caractère sauf '/'.
+func globToRegexp(pattern string) (*regexp.Regexp, error) {
+	pattern = strings.TrimPrefix(filepath.ToSlash(pattern), "./")
+	var b strings.Builder
+	b.WriteString("^")
+	i := 0
+	for i < len(pattern) {
+		c := pattern[i]
+		switch c {
+		case '*':
+			if strings.HasPrefix(pattern[i:], "**/") {
+				b.WriteString(`(?:[^/]+/)*`)
+				i += 3
+				continue
+			}
+			if strings.HasPrefix(pattern[i:], "**") {
+				b.WriteString(`.*`)
+				i += 2
+				continue
+			}
+			b.WriteString(`[^/]*`)
+		case '?':
+			b.WriteString(`[^/]`)
+		case '.', '+', '(', ')', '|', '[', ']', '{', '}', '^', '$', '\\':
+			b.WriteString(`\` + string(c))
+		default:
+			b.WriteByte(c)
+		}
+		i++
+	}
+	b.WriteString("$")
+	return regexp.Compile(b.String())
+}
+
+// isBinary : heuristique simple — un NUL dans les premiers 8 Kio.
+func isBinary(b []byte) bool {
+	n := len(b)
+	if n > 8192 {
+		n = 8192
+	}
+	for i := 0; i < n; i++ {
+		if b[i] == 0 {
+			return true
+		}
+	}
+	return false
+}
+
+// toolAsk formate la « réponse » de l'outil ask : la question part vers l'UI
+// via un événement dédié (voir runChat) ; ici on dit au modèle de clore son
+// tour et d'attendre.
+func toolAsk(args map[string]any) string {
+	q, _ := args["question"].(string)
+	if strings.TrimSpace(q) == "" {
+		return "[erreur] question vide"
+	}
+	return "[question posée à l'utilisateur] Termine ton tour MAINTENANT sans appeler d'autre outil : sa réponse arrivera comme prochain message."
+}
+
+// askOptions extrait les options (chaînes) des arguments de l'outil ask.
+func askOptions(args map[string]any) []string {
+	raw, _ := args["options"].([]any)
+	var opts []string
+	for _, o := range raw {
+		if s, ok := o.(string); ok && strings.TrimSpace(s) != "" {
+			opts = append(opts, s)
+		}
+	}
+	if len(opts) > 4 {
+		opts = opts[:4]
+	}
+	return opts
+}

internal/loki/code_tools_test.go

@@ -0,0 +1,159 @@
+package loki
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+// read numérote depuis 1, respecte offset/limit et annonce le reste.
+func TestReadOffsetLimit(t *testing.T) {
+	ws := withWorkspace(t)
+	var lines []string
+	for i := 1; i <= 10; i++ {
+		lines = append(lines, "ligne")
+	}
+	if err := os.WriteFile(filepath.Join(ws, "f.txt"), []byte(strings.Join(lines, "\n")+"\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	out := toolRead(map[string]any{"file": "f.txt", "offset": float64(3), "limit": float64(2)}, true)
+	if !strings.Contains(out, "3: ligne") || !strings.Contains(out, "4: ligne") {
+		t.Fatalf("lignes 3-4 attendues :\n%s", out)
+	}
+	if strings.Contains(out, "5: ligne") {
+		t.Fatalf("limite ignorée :\n%s", out)
+	}
+	if !strings.Contains(out, "restantes") {
+		t.Fatalf("suite non annoncée :\n%s", out)
+	}
+}
+
+// read refuse un binaire et le dit, au lieu de déverser du bruit.
+func TestReadBinaire(t *testing.T) {
+	ws := withWorkspace(t)
+	if err := os.WriteFile(filepath.Join(ws, "bin.dat"), []byte{0x00, 0x01, 0x02}, 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if out := toolRead(map[string]any{"file": "bin.dat"}, true); !strings.Contains(out, "[binaire]") {
+		t.Fatalf("binaire non détecté : %s", out)
+	}
+}
+
+// read enregistre la lecture : le tracker doit ensuite autoriser l'écriture.
+func TestReadNourritLeTracker(t *testing.T) {
+	ws := withWorkspace(t)
+	path := filepath.Join(ws, "suivi.txt")
+	if err := os.WriteFile(path, []byte("contenu"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if msg := trackerCheck(path, true); msg == "" {
+		t.Fatal("écriture acceptée avant lecture")
+	}
+	toolRead(map[string]any{"file": "suivi.txt"}, true)
+	if msg := trackerCheck(path, true); msg != "" {
+		t.Fatalf("écriture refusée après lecture : %s", msg)
+	}
+	// Fichier modifié APRÈS la lecture : refus (lecture périmée).
+	future := time.Now().Add(2 * time.Second)
+	if err := os.Chtimes(path, future, future); err != nil {
+		t.Fatal(err)
+	}
+	if msg := trackerCheck(path, true); !strings.Contains(msg, "changé") {
+		t.Fatalf("lecture périmée non détectée : %q", msg)
+	}
+}
+
+// grep trouve, borne et ignore les dossiers de dépendances.
+func TestGrep(t *testing.T) {
+	ws := withWorkspace(t)
+	writeFile(t, filepath.Join(ws, "a.go"), "package main\nfunc Cible() {}\n")
+	writeFile(t, filepath.Join(ws, "node_modules", "x.js"), "Cible aussi\n")
+	out := toolGrep(map[string]any{"pattern": "Cible"}, true)
+	if !strings.Contains(out, "a.go:2") {
+		t.Fatalf("correspondance manquée :\n%s", out)
+	}
+	if strings.Contains(out, "node_modules") {
+		t.Fatalf("node_modules aurait dû être ignoré :\n%s", out)
+	}
+	if out := toolGrep(map[string]any{"pattern": "IntrouvableXYZ"}, true); !strings.Contains(out, "aucun résultat") {
+		t.Fatalf("absence non signalée : %s", out)
+	}
+}
+
+// glob : ** traverse les dossiers, tri par modification décroissante.
+func TestGlob(t *testing.T) {
+	ws := withWorkspace(t)
+	writeFile(t, filepath.Join(ws, "src", "a.ts"), "a")
+	writeFile(t, filepath.Join(ws, "src", "sub", "b.ts"), "b")
+	writeFile(t, filepath.Join(ws, "autre.txt"), "c")
+	out := toolGlob(map[string]any{"pattern": "**/*.ts"}, true)
+	if !strings.Contains(out, "src/a.ts") || !strings.Contains(out, "src/sub/b.ts") {
+		t.Fatalf("fichiers .ts manquants :\n%s", out)
+	}
+	if strings.Contains(out, "autre.txt") {
+		t.Fatalf("autre.txt ne matche pas **/*.ts :\n%s", out)
+	}
+}
+
+// globToRegexp : cas aux limites du **.
+func TestGlobToRegexp(t *testing.T) {
+	cases := []struct {
+		pattern, path string
+		want          bool
+	}{
+		{"*.go", "main.go", true},
+		{"*.go", "src/main.go", false},
+		{"**/*.go", "src/deep/main.go", true},
+		{"**/*.go", "main.go", true}, // **/ = zéro dossier ou plus
+		{"src/**", "src/a/b/c.txt", true},
+		{"src/*.ts", "src/a.ts", true},
+		{"src/*.ts", "src/sub/a.ts", false},
+	}
+	for _, c := range cases {
+		re, err := globToRegexp(c.pattern)
+		if err != nil {
+			t.Fatalf("%s : %v", c.pattern, err)
+		}
+		if got := re.MatchString(c.path); got != c.want {
+			t.Errorf("%s sur %s : %v, attendu %v", c.pattern, c.path, got, c.want)
+		}
+	}
+}
+
+// fileEdit préserve les fins de ligne CRLF d'un fichier quand le modèle
+// envoie du LF (et n'introduit jamais de mélange).
+func TestEditPreserveCRLF(t *testing.T) {
+	ws := withWorkspace(t)
+	path := filepath.Join(ws, "w.txt")
+	if err := os.WriteFile(path, []byte("un\r\ndeux\r\ntrois\r\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	out := fileEdit(path, "deux", "DEUX")
+	if !strings.HasPrefix(out, "[ok]") {
+		t.Fatalf("édition refusée : %s", out)
+	}
+	b, _ := os.ReadFile(path)
+	if string(b) != "un\r\nDEUX\r\ntrois\r\n" {
+		t.Fatalf("fins de ligne perdues : %q", b)
+	}
+}
+
+// fileEdit multi-lignes en LF sur un fichier CRLF : la normalisation couvre
+// aussi le old qui contient des sauts de ligne.
+func TestEditCRLFMultiligne(t *testing.T) {
+	ws := withWorkspace(t)
+	path := filepath.Join(ws, "m.txt")
+	if err := os.WriteFile(path, []byte("a\r\nb\r\nc\r\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	out := fileEdit(path, "a\nb", "a\nB")
+	if !strings.HasPrefix(out, "[ok]") {
+		t.Fatalf("édition refusée : %s", out)
+	}
+	b, _ := os.ReadFile(path)
+	if string(b) != "a\r\nB\r\nc\r\n" {
+		t.Fatalf("résultat inattendu : %q", b)
+	}
+}

internal/loki/code_tracker.go

@@ -0,0 +1,67 @@
+package loki
+
+// code_tracker.go — suivi « lu avant d'écrire » (file-tracker d'OpenFox, réécrit
+// en Go — voir NOTICE.md). Le modèle doit avoir LU un fichier (outil read) avant
+// de le modifier (edit) ou de l'écraser (write sur un fichier existant), et sa
+// lecture doit être plus récente que la dernière modification du fichier sur le
+// disque. Ça bloque les deux corruptions silencieuses classiques :
+//   - réécrire un fichier jamais ouvert (le modèle « devine » son contenu) ;
+//   - éditer d'après une lecture périmée (le fichier a changé entre-temps —
+//     autre outil, job d'arrière-plan, utilisateur).
+//
+// L'état est en mémoire, par discussion : un redémarrage oublie tout, et le
+// modèle relit — c'est le comportement voulu, pas un bug.
+
+import (
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+)
+
+var (
+	trackerMu    sync.Mutex
+	trackerReads = map[string]time.Time{} // conv + chemin → instant de la lecture
+)
+
+func trackerKey(path string) string {
+	return convEnsureActive() + "\x00" + filepath.Clean(path)
+}
+
+// trackerNoteRead enregistre qu'un fichier vient d'être lu (outil read).
+func trackerNoteRead(path string) {
+	trackerMu.Lock()
+	trackerReads[trackerKey(path)] = time.Now()
+	trackerMu.Unlock()
+}
+
+// trackerNoteWrite : après une écriture réussie, la version sur disque est celle
+// que le modèle vient de produire — il la « connaît ». Sans cette note, éditer
+// un fichier qu'on vient soi-même d'écrire serait refusé.
+func trackerNoteWrite(path string) {
+	trackerNoteRead(path)
+}
+
+// trackerCheck vérifie qu'une modification est sûre. forWrite distingue write
+// (autorisé sur un fichier INEXISTANT sans lecture préalable — création) de
+// edit (le fichier doit exister ET avoir été lu).
+// Renvoie "" si c'est bon, sinon le message de refus pour le modèle.
+func trackerCheck(path string, forWrite bool) string {
+	fi, statErr := os.Stat(path)
+	if statErr != nil {
+		if forWrite {
+			return "" // création d'un fichier neuf : rien à relire
+		}
+		return "" // edit sur fichier absent : fileEdit renverra sa propre erreur claire
+	}
+	trackerMu.Lock()
+	readAt, seen := trackerReads[trackerKey(path)]
+	trackerMu.Unlock()
+	if !seen {
+		return "[refusé] " + path + " existe mais tu ne l'as pas lu dans cette discussion. Lis-le d'abord (outil read), puis modifie-le."
+	}
+	if fi.ModTime().After(readAt) {
+		return "[refusé] " + path + " a changé sur le disque depuis ta lecture. Relis-le (outil read) avant de le modifier."
+	}
+	return ""
+}

internal/loki/code_verify.go

@@ -0,0 +1,195 @@
+package loki
+
+// code_verify.go — la boucle du contrat en mode code : build → VÉRIFICATION →
+// correction → re-vérification, jusqu'à ce que tous les critères passent ou
+// que le plafond de cycles soit atteint. Reprise de la boucle
+// builder/verifier d'OpenFox (voir NOTICE.md), adaptée au fil unique de Loki :
+//
+//   - la passe de vérification tourne sur un CONTEXTE ISOLÉ (prompt du rôle +
+//     critères + tâche), pas sur l'historique complet — même modèle, mais il
+//     n'a pas « écrit » le code sous les yeux, et surtout ça ne gonfle pas le
+//     contexte de la discussion ;
+//   - seule cette passe a le droit de marquer un critère `passed`
+//     (toolCriteria, allowPass) ;
+//   - les corrections, elles, repartent dans l'historique NORMAL du fil : le
+//     builder doit se souvenir de ce qu'il a fait.
+
+import (
+	"context"
+	"fmt"
+	"strings"
+)
+
+// codeMaxFixTurns : nombre de tours de CORRECTION après échec de vérification.
+// Au-delà, on s'arrête et on dit ce qui manque — un modèle qui n'y arrive pas
+// en 2 corrections tourne en rond, l'utilisateur doit reprendre la main.
+const codeMaxFixTurns = 2
+
+// codeVerifyLoop est appelé par generate() à la FIN d'un tour de build en mode
+// code. Il ne fait rien s'il n'y a pas de contrat (aucun critère).
+func (c *Conversation) codeVerifyLoop(ctx context.Context, caps Caps, temperature float64, epoch int) {
+	if !caps.Code || caps.Role == "verifier" || ctx.Err() != nil {
+		return
+	}
+	convID := convEnsureActive()
+	list := critList(convID)
+	if len(list) == 0 || critAllPassed(list) {
+		return
+	}
+	// En phase de PLAN, on ne vérifie pas : rien n'a été construit.
+	if caps.Role == "planner" {
+		return
+	}
+	for fix := 0; ; fix++ {
+		if ctx.Err() != nil {
+			return
+		}
+		c.runVerifyPass(ctx, caps, temperature, epoch)
+		list = critList(convID)
+		if critAllPassed(list) {
+			c.appendDelta(epoch, map[string]any{"verify_done": "passed"})
+			return
+		}
+		if fix >= codeMaxFixTurns {
+			c.appendDelta(epoch, map[string]any{"verify_done": "gave_up"})
+			// Le fil doit dire où on en est — sinon l'utilisateur voit une
+			// vérification échouée et aucun mot dessus.
+			c.appendDelta(epoch, map[string]any{"content": "\n\n_(vérification : " +
+				fmt.Sprint(critPending(list)) + " critère(s) non satisfaits après " +
+				fmt.Sprint(codeMaxFixTurns) + " corrections — voir le panneau des critères)_"})
+			return
+		}
+		c.runFixTurn(ctx, caps, temperature, epoch, list)
+	}
+}
+
+// runVerifyPass lance la passe de vérification sur un contexte ISOLÉ.
+func (c *Conversation) runVerifyPass(ctx context.Context, caps Caps, temperature float64, epoch int) {
+	vcaps := caps
+	vcaps.Role = "verifier"
+	// Marqueur de rôle pour l'UI : les bulles qui suivent portent le badge.
+	c.appendDelta(epoch, map[string]any{"role": "verifier"})
+	defer c.appendDelta(epoch, map[string]any{"role": ""})
+
+	convID := convEnsureActive()
+	list := critList(convID)
+	task := c.lastUserText()
+	var user strings.Builder
+	user.WriteString("Task:\n" + task + "\n\nAcceptance criteria:\n" + critRender(list))
+	user.WriteString("\n\nVerify each non-passed criterion now (git_diff first), and record every verdict with the criteria tool.")
+
+	msgs := []Message{
+		{Role: "system", Content: rolePrompt("verifier") + "\n\n" + machineSystemPrompt(vcaps)},
+		{Role: "user", Content: user.String()},
+	}
+	// Trace ISOLÉE : ni persistée dans c.Messages, ni compactée — elle vit et
+	// meurt dans cette passe. Seuls les deltas d'affichage sortent.
+	_, _ = runChat(ctx, msgs, temperature, vcaps, func(ev StreamEvent) bool {
+		c.forwardStream(ev, epoch)
+		return true
+	})
+}
+
+// runFixTurn relance le BUILDER sur l'historique normal avec la liste des
+// critères en échec. Sa trace est persistée comme un tour ordinaire.
+func (c *Conversation) runFixTurn(ctx context.Context, caps Caps, temperature float64, epoch int, list []Criterion) {
+	var failed []Criterion
+	for _, cr := range list {
+		if cr.Status != "passed" {
+			failed = append(failed, cr)
+		}
+	}
+	c.appendDelta(epoch, map[string]any{"role": "builder"})
+	defer c.appendDelta(epoch, map[string]any{"role": ""})
+
+	fixMsg := Message{Role: "user", Content: "Verification failed on these criteria:\n" + critRender(failed) +
+		"\n\nFix the code so they pass. Address the notes precisely; do not touch what already passed."}
+
+	c.mu.Lock()
+	if c.epoch != epoch {
+		c.mu.Unlock()
+		return
+	}
+	c.Messages = append(c.Messages, fixMsg)
+	msgs := append([]Message(nil), c.Messages...)
+	c.mu.Unlock()
+
+	final := msgs
+	if sp := readSysPrompt(); sp != "" {
+		final = append([]Message{{Role: "system", Content: sp}}, msgs...)
+	}
+	var content strings.Builder
+	extra, _ := runChat(ctx, InjectSkills(final, caps), temperature, caps, func(ev StreamEvent) bool {
+		if ev.Content != "" {
+			content.WriteString(ev.Content)
+		}
+		c.forwardStream(ev, epoch)
+		return true
+	})
+	c.mu.Lock()
+	if c.epoch == epoch {
+		c.Messages = append(c.Messages, extra...)
+		if s := content.String(); strings.TrimSpace(s) != "" {
+			c.Messages = append(c.Messages, Message{Role: "assistant", Content: s})
+		}
+	}
+	c.mu.Unlock()
+	c.persist()
+}
+
+// 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).
+func (c *Conversation) forwardStream(ev StreamEvent, epoch int) {
+	switch {
+	case ev.Err != nil:
+		c.appendDelta(epoch, map[string]any{"error": ev.Err.Error()})
+	case ev.ToolUsed != nil:
+		tu := map[string]any{
+			"name": ev.ToolUsed.Name, "label": ev.ToolUsed.Label,
+			"result": ev.ToolUsed.Result, "done": ev.ToolUsed.Done, "typing": ev.ToolUsed.Typing,
+		}
+		if ev.ToolUsed.Body != "" {
+			tu["body"] = ev.ToolUsed.Body
+		}
+		if len(ev.ToolUsed.Diff) > 0 {
+			tu["diff"] = ev.ToolUsed.Diff
+		}
+		if ev.ToolUsed.Image != "" {
+			tu["image"] = ev.ToolUsed.Image
+		}
+		c.appendDelta(epoch, map[string]any{"tool_used": tu})
+	case ev.Ask != nil:
+		c.appendDelta(epoch, map[string]any{"ask": ev.Ask})
+	case ev.Stats != nil:
+		if ev.Stats.PromptTokensTotal > 0 {
+			c.mu.Lock()
+			if c.epoch == epoch {
+				c.CtxUsed = ev.Stats.PromptTokensTotal + ev.Stats.GenTokens
+			}
+			c.mu.Unlock()
+		}
+		c.appendDelta(epoch, map[string]any{"stats": ev.Stats})
+	case ev.DropReasoning:
+		c.appendDelta(epoch, map[string]any{"drop_reasoning": true})
+	case ev.Reasoning != "":
+		c.appendDelta(epoch, map[string]any{"reasoning_content": ev.Reasoning})
+	case ev.Content != "":
+		c.appendDelta(epoch, map[string]any{"content": ev.Content})
+	}
+}
+
+// lastUserText retrouve le dernier message utilisateur du fil (la tâche).
+func (c *Conversation) lastUserText() string {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	for i := len(c.Messages) - 1; i >= 0; i-- {
+		if c.Messages[i].Role != "user" {
+			continue
+		}
+		if s, ok := c.Messages[i].Content.(string); ok {
+			return s
+		}
+	}
+	return "(tâche non retrouvée — vérifie d'après le diff)"
+}

internal/loki/llm_budget.go

@@ -0,0 +1,91 @@
+package loki
+
+// llm_budget.go — budget SOUPLE d'appels d'outils par tour.
+//
+// Le plafond dur (TOOL_LIMIT) et l'anti-boucle ont été retirés en v0.6.3 : ils
+// coupaient des tours parfaitement légitimes, une recherche enchaînant sans
+// problème des dizaines d'appels. Mais il ne restait plus RIEN entre « le
+// modèle converge » et « le modèle tourne en rond pendant une heure » — vu en
+// production : ~50 appels d'outil, 55 minutes, le modèle relisant cinq fois les
+// mêmes fonctions pour re-dériver une conclusion qu'il avait déjà écrite.
+//
+// La déduplication d'appels identiques (repeatedCallResult) ne rattrape pas ce
+// cas : sa clé est « nom + arguments bruts », et relire le même fichier par
+// tranches (`sed -n '1,80p'` puis `sed -n '80,160p'`) produit des clés
+// différentes. Élargir cette clé à la CIBLE serait pire que le mal — deux
+// tranches d'un même fichier renvoient un contenu différent, les confondre
+// casserait toute lecture paginée légitime.
+//
+// D'où un budget qui ne coupe rien : au-delà d'un palier, on RAPPELLE au modèle
+// combien d'appels il a déjà faits et on lui demande de conclure. Le tour reste
+// entièrement sous son contrôle — c'est de la pression, pas une barrière.
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+)
+
+// agentBudgetDefault : nombre d'appels d'outils au-delà duquel un tour cesse
+// d'être une recherche et commence à ressembler à du sur-place. Assez haut pour
+// qu'une vraie enquête (lire dix fichiers, croiser trois pages web) passe sans
+// jamais voir le rappel.
+const agentBudgetDefault = 24
+
+// agentBudget lit le palier dans config.env (AGENT_BUDGET). 0 — ou une valeur
+// off/false/no/non — désactive complètement le mécanisme.
+func agentBudget() int {
+	v := strings.ToLower(strings.TrimSpace(ReadConfig()["AGENT_BUDGET"]))
+	switch v {
+	case "":
+		return agentBudgetDefault
+	case "off", "false", "no", "non", "disable", "disabled":
+		return 0
+	}
+	if n, err := strconv.Atoi(v); err == nil && n >= 0 {
+		return n
+	}
+	return agentBudgetDefault
+}
+
+// budgetNudge renvoie le rappel à injecter quand le tour vient de franchir un
+// palier, ou "" s'il n'y a rien à dire.
+//
+//	calls  : appels d'outils exécutés depuis le début du tour
+//	budget : taille d'un palier (0 = mécanisme désactivé)
+//	sent   : rappels déjà envoyés dans ce tour
+//
+// Les paliers sont à budget, 2×budget, 3×budget… : la pression revient donc
+// régulièrement au lieu de s'éteindre après un avertissement ignoré. Le coût en
+// contexte est négligeable (une phrase toutes les 24 requêtes) et le message est
+// AJOUTÉ EN FIN d'historique, ce qui laisse intact le préfixe déjà en cache côté
+// llama-server.
+//
+// Le texte est en anglais comme le reste du protocole d'outils : c'est la langue
+// dans laquelle les modèles suivent le mieux une consigne impérative, quelle que
+// soit celle de la conversation.
+func budgetNudge(calls, budget, sent int) string {
+	if budget <= 0 || calls < budget*(sent+1) {
+		return ""
+	}
+	n := fmt.Sprintf("%d tool calls", calls)
+	switch sent {
+	case 0:
+		return "[system] You have made " + n + " in this single turn. That is a lot: you almost certainly have enough to answer already. " +
+			"Stop exploring and write your final answer now, unless exactly one specific call is genuinely still missing."
+	case 1:
+		return "[system] " + n + " now, and you are going in circles. Re-reading a file you have already read, or re-deriving a conclusion you have already written, adds nothing. " +
+			"Answer NOW with what you have. If something remains uncertain, say so in the answer instead of investigating further."
+	default:
+		return "[system] " + n + ". Stop. Write your final answer in this message. Do not call another tool."
+	}
+}
+
+// logBudget trace UNE ligne par rappel sur la sortie d'erreur (donc dans
+// `journalctl -u loki-ui`), comme logCompact. Sans ça, un tour qui part en
+// vrille est invisible côté serveur : on ne voit qu'une génération qui dure.
+func logBudget(calls, budget, sent int) {
+	fmt.Fprintf(os.Stderr, "[agent] %d appels d'outils sur ce tour (palier=%d) — rappel n°%d envoyé au modèle\n",
+		calls, budget, sent)
+}

internal/loki/llm_budget_test.go

@@ -0,0 +1,93 @@
+package loki
+
+import "testing"
+
+// Le budget ne se déclenche pas avant son palier, et il revient à chaque
+// palier suivant : un modèle qui ignore le premier rappel doit en recevoir un
+// second, plus ferme.
+func TestBudgetNudgePaliers(t *testing.T) {
+	const budget = 24
+	cases := []struct {
+		calls, sent int
+		want        bool
+	}{
+		{0, 0, false},
+		{1, 0, false},
+		{23, 0, false},
+		{24, 0, true},  // 1er palier
+		{40, 1, false}, // rappel déjà envoyé, palier suivant pas atteint
+		{48, 1, true},  // 2e palier
+		{72, 2, true},  // 3e palier
+		{95, 3, false},
+		{96, 3, true}, // 4e palier : la pression ne s'éteint pas
+	}
+	for _, c := range cases {
+		got := budgetNudge(c.calls, budget, c.sent) != ""
+		if got != c.want {
+			t.Errorf("budgetNudge(calls=%d, sent=%d) = %v, attendu %v", c.calls, c.sent, got, c.want)
+		}
+	}
+}
+
+// Le message durcit à chaque rappel : trois textes distincts, tous porteurs du
+// nombre d'appels (c'est LUI qui informe le modèle, pas le ton).
+func TestBudgetNudgeEscalade(t *testing.T) {
+	const budget = 10
+	seen := map[string]bool{}
+	for sent := 0; sent < 3; sent++ {
+		m := budgetNudge(budget*(sent+1), budget, sent)
+		if m == "" {
+			t.Fatalf("rappel n°%d vide", sent+1)
+		}
+		if seen[m] {
+			t.Errorf("rappel n°%d identique à un précédent : %q", sent+1, m)
+		}
+		seen[m] = true
+	}
+	// Au-delà, on réutilise le texte le plus ferme plutôt que d'en inventer un
+	// nouveau à chaque palier (à nombre d'appels égal, le message est le même).
+	if a, b := budgetNudge(50, budget, 3), budgetNudge(50, budget, 4); a != b {
+		t.Errorf("les rappels tardifs devraient partager le même texte :\n%q\n%q", a, b)
+	}
+}
+
+// budget=0 (AGENT_BUDGET=off) : plus aucun rappel, quel que soit le nombre
+// d'appels — le mécanisme doit pouvoir être totalement coupé.
+func TestBudgetNudgeDesactive(t *testing.T) {
+	for _, calls := range []int{0, 24, 500, 10000} {
+		if m := budgetNudge(calls, 0, 0); m != "" {
+			t.Errorf("budget désactivé mais rappel émis à %d appels : %q", calls, m)
+		}
+	}
+	if m := budgetNudge(100, -5, 0); m != "" {
+		t.Errorf("budget négatif devrait être inerte, obtenu %q", m)
+	}
+}
+
+func TestAgentBudgetConfig(t *testing.T) {
+	testHome(t)
+	set := func(v string) {
+		cfg := ReadConfig()
+		cfg["AGENT_BUDGET"] = v
+		if err := WriteConfig(cfg); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, c := range []struct {
+		val  string
+		want int
+	}{
+		{"", agentBudgetDefault},
+		{"40", 40},
+		{"0", 0},
+		{"off", 0},
+		{"NON", 0},
+		{"n'importe quoi", agentBudgetDefault}, // valeur illisible : on ne l'invente pas
+		{"-3", agentBudgetDefault},
+	} {
+		set(c.val)
+		if got := agentBudget(); got != c.want {
+			t.Errorf("AGENT_BUDGET=%q → %d, attendu %d", c.val, got, c.want)
+		}
+	}
+}

internal/loki/llm_client.go

@@ -194,6 +194,14 @@ type Caps struct {
 	// Mem = mode d'accès à la mémoire persistante (off / ondemand / always),
 	// indépendant du mode agent. Voir MemMode.
 	Mem MemMode
+	// Code = mode code actif pour cette discussion (sélecteur Chat/Code) :
+	// ajoute les outils codeur (read/grep/glob, git, critères, jobs) et le
+	// prompt de rôle. Requiert Agent.
+	Code bool
+	// Role = rôle du tour en mode code : "" ou "builder" (défaut), "planner",
+	// "verifier" (passe de vérification, seule autorisée à marquer un critère
+	// passed), "explorer", "code-reviewer". Voir code_roles.go.
+	Role string
 }
 
 // globalCaps reads the machine-wide config — the default when a request doesn't
@@ -261,12 +269,71 @@ func steerSystem(msgs []Message, hint string) []Message {
 	return append([]Message{{Role: "system", Content: hint}}, msgs...)
 }
 
+// normalizeSystemMessages garantit un UNIQUE message système, en tête, dans la
+// séquence ENVOYÉE au moteur. Repris de l'amont AJEAN (v0.9.8, issue #26).
+//
+// steerSystem (ci-dessus) empêche déjà loki d'en poser un en cours de route, mais
+// il ne couvre que SES propres consignes : un historique venu d'ailleurs (import,
+// preset, conversation migrée, agent de code qui compose sa propre séquence) peut
+// encore porter deux systèmes, ou un système ailleurs qu'en position 0. Les
+// gabarits stricts — Qwen3.x en --jinja — répondent alors « System message must
+// be at the beginning », un 500 qui tue le tour sans rien expliquer.
+//
+// La séquence renvoyée est une COPIE : l'historique d'origine garde sa forme pour
+// l'affichage, la persistance et la compaction. Un modèle qui accepte le système
+// n'importe où n'est pas gêné de le recevoir en tête — la normalisation est donc
+// sans risque pour tous, et sans effet sur une conversation déjà normale (payload
+// identique, garanti par test).
+func normalizeSystemMessages(msgs []Message) []Message {
+	var sys []string
+	sawSystem := false
+	rest := make([]Message, 0, len(msgs))
+	for _, m := range msgs {
+		if m.Role == "system" {
+			if s, ok := m.Content.(string); ok {
+				sawSystem = true
+				if strings.TrimSpace(s) != "" {
+					sys = append(sys, s)
+				}
+				continue
+			}
+			// Contenu système non textuel (cas théorique) : on le préserve tel quel
+			// plutôt que de le perdre.
+		}
+		rest = append(rest, m)
+	}
+	// Aucun message système : rien à réordonner, on rend l'entrée telle quelle —
+	// pas de copie inutile sur le chemin le plus fréquent.
+	if !sawSystem {
+		return msgs
+	}
+	// Des systèmes existaient mais tous vides : on les a retirés (un système vide
+	// hors position 0 casserait tout autant), sans en réinsérer.
+	if len(sys) == 0 {
+		return rest
+	}
+	out := make([]Message, 0, len(rest)+1)
+	out = append(out, Message{Role: "system", Content: strings.Join(sys, "\n\n")})
+	return append(out, rest...)
+}
+
 // EnabledTools returns the tools to advertise on the next inference call.
 func EnabledTools(caps Caps) []Tool {
 	tools := []Tool{}
+	// Passe de VÉRIFICATION du mode code : jeu d'outils fermé, en lecture
+	// seule + bash (lancer les tests) + critères. Ni write/edit (elle ne
+	// corrige pas), ni mémoire ni web (hors sujet, et chaque schéma coûte du
+	// contexte).
+	if caps.Code && caps.Role == "verifier" {
+		return []Tool{bashTool(), readTool(), grepTool(), globTool(), gitStatusTool(), gitDiffTool(), criteriaTool()}
+	}
 	if caps.Agent {
 		tools = append(tools, bashTool(), writeTool(), editTool())
 	}
+	if caps.Code {
+		tools = append(tools, readTool(), grepTool(), globTool(), askTool(),
+			bashBgTool(), bashTailTool(), gitStatusTool(), gitDiffTool(), gitCloneTool(), criteriaTool())
+	}
 	// Mémoire = axe indépendant du mode agent : les outils mem_* sont fournis dès
 	// que le mode mémoire n'est pas « off » (que l'agent soit actif ou non).
 	if caps.Mem != MemOff {
@@ -277,12 +344,16 @@ func EnabledTools(caps Caps) []Tool {
 	// donc prompt et outils restent cohérents — pas de web_search halluciné.
 	if caps.Agent && caps.Internet {
 		tools = append(tools, webSearchTool(), 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
-		// réessai sur un échec systématique.
-		if screenshotAvailable() {
-			tools = append(tools, webScreenshotTool())
-		}
+	}
+	// 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
+	// réessai). Offerte aussi SANS accès internet quand le mode code est actif :
+	// photographier son propre serveur de dev est une vérification locale, pas
+	// une sortie sur le web — et sans elle, le modèle croyait n'avoir aucun
+	// navigateur et perdait des minutes à installer puppeteer. La borne aux
+	// adresses locales vit dans toolWebScreenshot.
+	if caps.Agent && (caps.Internet || caps.Code) && screenshotAvailable() {
+		tools = append(tools, webScreenshotTool())
 	}
 	// Outils MCP : serveurs tiers configurés par le propriétaire de la machine.
 	// Comme bash, ils exécutent du code arbitraire côté hôte → réservés au mode
@@ -305,6 +376,7 @@ type StreamEvent struct {
 	Reasoning string
 	ToolUsed  *ToolUsedEvent
 	Stats     *StatsEvent
+	Ask       *AskEvent
 	Err       error
 	// DropReasoning demande à l'UI de retirer la dernière bulle de raisonnement :
 	// le modèle a « pensé sans agir » et on relance le tour, ce raisonnement-là
@@ -324,6 +396,14 @@ type StreamEvent struct {
 	// ajouter.
 	NewHistory []Message
 }
+
+// AskEvent : l'outil ask — question structurée posée à l'utilisateur, rendue
+// par l'UI comme une carte à boutons. Le tour se termine juste après.
+type AskEvent struct {
+	Question string   `json:"question"`
+	Options  []string `json:"options,omitempty"`
+}
+
 type ToolUsedEvent struct {
 	Name   string
 	Label  string // user-visible summary (skill name or the command)
@@ -338,6 +418,12 @@ type ToolUsedEvent struct {
 	// Diff : lignes ajoutées/retirées quand l'outil a MODIFIÉ quelque chose
 	// (edit, mem_add, mem_edit). L'UI les affiche en vert (+) et rouge (-).
 	Diff []DiffLine
+	// Image : chemin (relatif au dossier de travail) d'une image PRODUITE par
+	// l'outil — aujourd'hui la capture de web_screenshot. L'UI l'affiche dans la
+	// bulle de l'outil. Sans ça, la capture n'apparaissait QUE si le modèle
+	// 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
 }
 
 // shownDisplayMax borne ce qu'un résultat d'outil occupe dans le FLUX vers l'UI.
@@ -574,7 +660,23 @@ func runChat(ctx context.Context, messages []Message, temperature float64, caps
 	// reasoning is enabled we split that out ourselves so the UI's reasoning
 	// bubble works regardless of backend. The ik_llama.cpp fork already sends
 	// reasoning_content, in which case we leave content untouched.
-	reasoningOn := reasoningActive(ReadConfig()["REASONING"])
+	chatCfg := ReadConfig()
+	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)
 	// 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.
@@ -583,6 +685,9 @@ func runChat(ctx context.Context, messages []Message, temperature float64, caps
 	// dépassement de la fenêtre de contexte après de gros résultats d'outils), on
 	// compacte l'historique en vol et on rejoue le tour — une seule fois.
 	compactedRetry := false
+	// Repli d'intensité de raisonnement (llm_effort.go) : une seule tentative par
+	// tour, comme les autres filets.
+	effortRetried := false
 	// Appels d'outil déjà exécutés (clé = nom + arguments bruts) : sert à ne pas
 	// rejouer deux fois exactement la même écriture dans un même échange.
 	doneCalls := map[string]string{}
@@ -595,14 +700,28 @@ func runChat(ctx context.Context, messages []Message, temperature float64, caps
 	// (ni réponse, ni tool_call). On relance alors UNE fois le tour avec un nudge
 	// explicite au lieu d'afficher « pas de réponse ».
 	nudged := false
-	// Pas de plafond d'itérations ni d'anti-boucle : ils coupaient des tours
-	// parfaitement légitimes (une recherche enchaîne facilement des dizaines
-	// d'appels, parfois identiques). Le seul frein est le bouton stop, qui annule
-	// le contexte — c'est un choix assumé.
+	// Garde-fou « appel d'outil écrit en texte » (code_retry.go) : une seule
+	// relance par tour, comme le nudge.
+	patternRetried := false
+	// Budget SOUPLE d'appels d'outils (llm_budget.go). Toujours pas de plafond
+	// d'itérations : couper un tour cassait des recherches légitimes. Mais au-delà
+	// d'un palier on RAPPELLE au modèle combien d'appels il a déjà faits et on lui
+	// demande de conclure — de la pression, pas une barrière. Sans ça, un modèle
+	// qui tourne en rond n'avait rien en face de lui sauf le bouton stop.
+	toolRuns, budgetNudges, budget := 0, 0, agentBudget()
 	for iter := 0; ; iter++ {
+		// Rappel injecté EN FIN d'historique : le préfixe déjà en cache côté
+		// llama-server reste valide, seul le nouveau message est à traiter.
+		if msg := budgetNudge(toolRuns, budget, budgetNudges); msg != "" {
+			budgetNudges++
+			logBudget(toolRuns, budget, budgetNudges)
+			messages = append(messages, Message{Role: "user", Content: msg})
+		}
 		payload := map[string]any{
-			"model":       "loki",
-			"messages":    messages,
+			"model": "loki",
+			// Normalisé juste avant l'envoi : un seul système, en tête. Les gabarits
+			// stricts (Qwen3.x) refusent un système ailleurs qu'en position 0.
+			"messages":    normalizeSystemMessages(messages),
 			"stream":      true,
 			"temperature": temperature,
 			// include_usage → chunk final avec `usage.prompt_tokens` = taille TOTALE
@@ -611,6 +730,17 @@ func runChat(ctx context.Context, messages []Message, temperature float64, caps
 			// 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
+		}
+		if reasoningKwargs != nil {
+			payload["chat_template_kwargs"] = reasoningKwargs
+		}
 		if len(tools) > 0 && !disableTools {
 			payload["tools"] = tools
 			// The model sometimes emits parallel tool calls, which this llama.cpp
@@ -644,6 +774,22 @@ func runChat(ctx context.Context, messages []Message, temperature float64, caps
 			if msg == "" {
 				msg = resp.Status
 			}
+			// 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
+			// avant la compaction, qui sinon taillait l'historique pour rien puis
+			// échouait quand même. On rejoue le tour avec le niveau accepté (ou
+			// sans le champ), l'historique intact.
+			if !effortRetried && effortWanted != "" {
+				if fixed, ok := effortFromRejection(msg, effortWanted); ok {
+					effortRetried = true
+					effortRemember(effortWanted, fixed)
+					logEffortFallback(effortWanted, fixed)
+					reasoningEffort = fixed
+					reasoningKwargs = reasoningTemplateKwargs(thinkOff, fixed)
+					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.
@@ -775,10 +921,20 @@ func runChat(ctx context.Context, messages []Message, temperature float64, caps
 					switch cur.Function.Name {
 					case "mem_search", "web_search":
 						key = "query"
-					case "mem_read", "mem_add", "mem_edit", "edit", "write":
+					case "mem_read", "mem_add", "mem_edit", "edit", "write", "read", "git_diff":
 						key = "file"
 					case "web_open", "web_read", "web_grep":
 						key = "url"
+					case "grep", "glob":
+						key = "pattern"
+					case "ask":
+						key = "question"
+					case "criteria":
+						key = "action"
+					case "bash_tail":
+						key = "id"
+					case "git_clone":
+						key = "url"
 					}
 					p := previewArg(cur.Function.Arguments, key)
 					// Corps en cours de frappe pour les outils d'écriture : on le diffuse
@@ -939,6 +1095,7 @@ func runChat(ctx context.Context, messages []Message, temperature float64, caps
 				if ctx.Err() != nil {
 					return extra, nil
 				}
+				toolRuns++ // alimente le budget souple (voir budgetNudge)
 				var args map[string]any
 				_ = json.Unmarshal([]byte(tc.Function.Arguments), &args)
 				// Derive the human label (command / skill name) up front so we can
@@ -948,10 +1105,20 @@ func runChat(ctx context.Context, messages []Message, temperature float64, caps
 				switch tc.Function.Name {
 				case "mem_search", "web_search":
 					label, _ = args["query"].(string)
-				case "mem_read", "mem_add", "mem_edit", "edit", "write":
+				case "mem_read", "mem_add", "mem_edit", "edit", "write", "read", "git_diff":
 					label, _ = args["file"].(string)
-				case "bash":
+				case "bash", "bash_bg":
 					label, _ = args["command"].(string)
+				case "grep", "glob":
+					label, _ = args["pattern"].(string)
+				case "ask":
+					label, _ = args["question"].(string)
+				case "criteria":
+					label, _ = args["action"].(string)
+				case "bash_tail":
+					label, _ = args["id"].(string)
+				case "git_clone":
+					label, _ = args["url"].(string)
 				case "web_open", "web_read":
 					label, _ = args["url"].(string)
 				case "web_grep":
@@ -1038,10 +1205,14 @@ func runChat(ctx context.Context, messages []Message, temperature float64, caps
 						// Cible = un poste distant : on écrit LÀ-BAS. Pas de diff (on
 						// n'a pas l'ancien contenu du fichier distant).
 						result = nodeCall(tgt, nodeCapWrite, map[string]any{"path": label, "content": content})
+					} else if msg := codeWriteGuard(caps, label, true); msg != "" {
+						result = msg
 					} else {
 						result = fileWrite(label, content)
 						if !strings.HasPrefix(result, "[erreur]") {
 							diff = addedDiff(content)
+							trackerNoteWrite(resolveAgentPath(label))
+							result += lspDiagBlock(resolveAgentPath(label), caps)
 						}
 					}
 				case "edit":
@@ -1049,13 +1220,41 @@ func runChat(ctx context.Context, messages []Message, temperature float64, caps
 					newText, _ := args["new"].(string)
 					if tgt := agentTargetSlug(); tgt != "" {
 						result = nodeEditRemote(tgt, label, oldText, newText)
+					} else if msg := codeWriteGuard(caps, label, false); msg != "" {
+						result = msg
 					} else {
 						result = fileEdit(label, oldText, newText)
 						// Diff seulement si l'édition a réussi (sinon le fichier n'a pas bougé).
 						if !strings.HasPrefix(result, "[erreur]") {
 							diff = lineDiff(oldText, newText)
+							trackerNoteWrite(resolveAgentPath(label))
+							result += lspDiagBlock(resolveAgentPath(label), caps)
 						}
 					}
+				case "read":
+					result = toolRead(args, caps.Code)
+				case "grep":
+					result = toolGrep(args, caps.Code)
+				case "glob":
+					result = toolGlob(args, caps.Code)
+				case "ask":
+					result = toolAsk(args)
+					if !strings.HasPrefix(result, "[erreur]") {
+						q, _ := args["question"].(string)
+						cb(StreamEvent{Ask: &AskEvent{Question: q, Options: askOptions(args)}})
+					}
+				case "bash_bg":
+					result = toolBashBg(args)
+				case "bash_tail":
+					result = toolBashTail(args)
+				case "git_status":
+					result = toolGitStatus(ctx)
+				case "git_diff":
+					result = toolGitDiff(ctx, args)
+				case "git_clone":
+					result = toolGitClone(ctx, args)
+				case "criteria":
+					result = toolCriteria(args, caps.Role == "verifier")
 				case "bash":
 					to := 0
 					switch v := args["timeout"].(type) {
@@ -1064,6 +1263,12 @@ func runChat(ctx context.Context, messages []Message, temperature float64, caps
 					case int:
 						to = v
 					}
+					// Politique de sécurité : les commandes catastrophiques sont
+					// refusées AVANT toute exécution, cible distante comprise.
+					if reason := dangerousCommand(label); reason != "" {
+						result = refusedCommandResult(reason)
+						break
+					}
 					if tgt := agentTargetSlug(); tgt != "" {
 						// Cible = un poste distant : la commande s'exécute LÀ-BAS via le
 						// canal du poste (fail-closed : nodeCall renvoie une erreur si le
@@ -1081,7 +1286,7 @@ func runChat(ctx context.Context, messages []Message, temperature float64, caps
 				case "web_grep":
 					result = capWebOutput(toolWebGrep(args))
 				case "web_screenshot":
-					result = toolWebScreenshot(args)
+					result = toolWebScreenshot(args, caps)
 				default:
 					if isMCPTool(tc.Function.Name) {
 						result = mcpCall(tc.Function.Name, args)
@@ -1092,7 +1297,13 @@ func runChat(ctx context.Context, messages []Message, temperature float64, caps
 				if !strings.HasPrefix(result, "[erreur]") {
 					doneCalls[callKey] = result
 				}
-				cb(StreamEvent{ToolUsed: &ToolUsedEvent{Name: tc.Function.Name, Label: label, Result: shownResult(result), Done: true, Diff: diff}})
+				// 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.
+				shot := ""
+				if tc.Function.Name == "web_screenshot" {
+					shot = capturedRelPath(result)
+				}
+				cb(StreamEvent{ToolUsed: &ToolUsedEvent{Name: tc.Function.Name, Label: label, Result: shownResult(result), Done: true, Diff: diff, Image: shot}})
 				toolMsg := Message{Role: "tool", ToolCallID: tc.ID, Content: result}
 				messages = append(messages, toolMsg)
 				extra = append(extra, toolMsg)
@@ -1139,6 +1350,19 @@ func runChat(ctx context.Context, messages []Message, temperature float64, caps
 			}
 			continue
 		}
+		// Appel d'outil TEXTUEL (halluciné, jamais exécuté) dans la réponse
+		// finale : on relance le tour UNE fois avec la consigne corrective
+		// (code_retry.go). Le texte fautif reste affiché — le remplacer serait
+		// mentir sur ce qui s'est passé — mais l'historique du modèle garde la
+		// trace ET la correction, donc la vraie réponse suit immédiatement.
+		if !patternRetried && len(tools) > 0 && !disableTools && textualToolCall(assistantContent.String()) {
+			patternRetried = true
+			bad := Message{Role: "assistant", Content: assistantContent.String()}
+			fix := Message{Role: "user", Content: retryCorrective}
+			messages = append(messages, bad, fix)
+			extra = append(extra, bad, fix)
+			continue
+		}
 		// Normal end of turn. If the model produced no visible answer at all
 		// (empty content, e.g. it stopped right after a tool result), say so
 		// instead of leaving the user staring at a silent, finished chat.

internal/loki/llm_effort.go

@@ -0,0 +1,195 @@
+package loki
+
+// llm_effort.go — repli quand le gabarit du modèle REFUSE la valeur de
+// `reasoning_effort`.
+//
+// L'hypothèse d'origine (backend_models.go) était : un gabarit jinja qui ne lit
+// pas `reasoning_effort` l'ignore sans erreur, donc rien à prévoir côté loki.
+// Elle tombe dès qu'un gabarit VALIDE la valeur au lieu de la subir. Vu en
+// production sur Qwen3.8-27B :
+//
+//	{"error":{"code":500,"message":"... raise_exception('Unexpected reasoning
+//	effort ' ~ reasoning_effort) ... Unexpected reasoning effort high. Supported
+//	types are xhigh (default), medium, and low."}}
+//
+// Ce gabarit connaît xhigh/medium/low mais PAS « high » — le niveau que
+// l'interface propose et enregistre par défaut. Résultat : chaque message part
+// en 500, le tour meurt, et le message d'erreur affiché est une trace jinja.
+// Pire, le 500 arrivait dans la branche « prompt trop long » de runChat, donc
+// loki compactait l'historique pour rien avant d'abandonner.
+//
+// D'où ce fichier : reconnaître ce refus, traduire le niveau demandé vers celui
+// que le gabarit accepte (le plus proche sur l'échelle), rejouer le tour SANS
+// toucher à l'historique, et retenir la traduction pour ce modèle afin de ne
+// pas repayer l'aller-retour à chaque message.
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"sync"
+)
+
+// effortLadder : les niveaux connus, du plus faible au plus fort. Sert à choisir
+// un remplaçant PROCHE quand le gabarit refuse la valeur demandée — « high »
+// devient « xhigh » (voisin immédiat) plutôt que « low ».
+//
+// La liste vaut pour tous les gabarits croisés jusqu'ici : gpt-oss lit
+// low/medium/high, Qwen3.8 lit low/medium/xhigh, certains ajoutent « minimal ».
+// Une valeur hors échelle n'est pas classable : on retire alors le champ plutôt
+// que d'inventer un niveau.
+var effortLadder = []string{"none", "minimal", "low", "medium", "high", "xhigh"}
+
+// effortRank renvoie la position d'un niveau sur l'échelle, ou -1 s'il est
+// inconnu.
+func effortRank(v string) int {
+	v = strings.ToLower(strings.TrimSpace(v))
+	for i, s := range effortLadder {
+		if s == v {
+			return i
+		}
+	}
+	return -1
+}
+
+// effortWords capte les niveaux cités dans un message d'erreur. Les bornes de
+// mot évitent de lire « high » à l'intérieur de « xhigh ».
+var effortWords = regexp.MustCompile(`\b(none|minimal|low|medium|high|xhigh)\b`)
+
+// effortRejection dit si le corps d'erreur renvoyé par llama-server est un refus
+// de la valeur de `reasoning_effort` par le gabarit, et renvoie les niveaux que
+// ce gabarit déclare accepter (éventuellement vide : tous ne les listent pas).
+//
+// La détection reste volontairement large — le texte vient du gabarit du modèle,
+// pas de llama.cpp, donc sa formulation change d'un modèle à l'autre. Le seul
+// invariant : il parle de reasoning effort et dit que la valeur ne va pas.
+func effortRejection(body string) (supported []string, ok bool) {
+	low := strings.ToLower(body)
+	if !strings.Contains(low, "reasoning effort") && !strings.Contains(low, "reasoning_effort") {
+		return nil, false
+	}
+	refus := false
+	for _, w := range []string{"unexpected", "unsupported", "not supported", "invalid", "unknown"} {
+		if strings.Contains(low, w) {
+			refus = true
+			break
+		}
+	}
+	if !refus {
+		return nil, false
+	}
+	// Les niveaux acceptés sont annoncés APRÈS « supported » (« Supported types
+	// are xhigh (default), medium, and low. »). Ne lire que cette fin de message
+	// évite de prendre pour une liste le niveau refusé, cité juste avant.
+	if i := strings.LastIndex(low, "supported"); i >= 0 {
+		for _, m := range effortWords.FindAllString(low[i:], -1) {
+			if effortRank(m) >= 0 && !slicesHas(supported, m) {
+				supported = append(supported, m)
+			}
+		}
+	}
+	return supported, true
+}
+
+func slicesHas(list []string, v string) bool {
+	for _, s := range list {
+		if s == v {
+			return true
+		}
+	}
+	return false
+}
+
+// nearestEffort traduit le niveau demandé vers le plus proche parmi ceux que le
+// gabarit accepte. Renvoie "" quand il n'y a rien de sensé à envoyer : le champ
+// est alors simplement retiré de la requête, et le gabarit reprend son défaut.
+//
+// À égalité de distance on prend le niveau le PLUS FORT : demander « haute » et
+// se retrouver avec « moyenne » dégrade la réponse en silence, alors qu'un cran
+// au-dessus ne coûte que du temps de génération.
+//
+// « none » n'est jamais traduit : c'est une consigne de couper le raisonnement,
+// pas une intensité. Un gabarit qui la refuse reçoit déjà `enable_thinking:
+// false` par chat_template_kwargs (backend_models.go), qui dit la même chose
+// dans une langue que tous comprennent.
+func nearestEffort(want string, supported []string) string {
+	want = strings.ToLower(strings.TrimSpace(want))
+	if want == "" || want == "none" {
+		return ""
+	}
+	rank := effortRank(want)
+	if rank < 0 {
+		return ""
+	}
+	best, bestRank := "", -1
+	for _, s := range supported {
+		r := effortRank(s)
+		if r < 0 || s == want {
+			continue // s == want : le gabarit ne peut pas à la fois refuser et accepter
+		}
+		if best == "" || abs(r-rank) < abs(bestRank-rank) || (abs(r-rank) == abs(bestRank-rank) && r > bestRank) {
+			best, bestRank = s, r
+		}
+	}
+	return best
+}
+
+func abs(n int) int {
+	if n < 0 {
+		return -n
+	}
+	return n
+}
+
+// effortFromRejection combine les deux : à partir du corps d'erreur et du niveau
+// demandé, renvoie le niveau à réessayer ("" = ne rien envoyer) et true si le
+// refus a bien été reconnu.
+func effortFromRejection(body, want string) (string, bool) {
+	supported, ok := effortRejection(body)
+	if !ok {
+		return "", false
+	}
+	return nearestEffort(want, supported), true
+}
+
+// effortFallbacks retient les traductions apprises, par modèle : sans ça chaque
+// message repaierait un aller-retour 500 avant de tomber sur la bonne valeur.
+// Clé = fichier de modèle + niveau demandé ; la valeur "" est significative
+// (= ne rien envoyer), d'où sync.Map plutôt qu'une map avec test de zéro.
+var effortFallbacks sync.Map
+
+func effortKey(want string) string {
+	return filepath.Base(strings.TrimSpace(ReadConfig()["MODEL"])) + "\x00" + want
+}
+
+// effortResolve renvoie le niveau réellement envoyable pour la valeur demandée,
+// c'est-à-dire la traduction déjà apprise pour ce modèle s'il y en a une.
+func effortResolve(want string) string {
+	if want == "" {
+		return ""
+	}
+	if v, ok := effortFallbacks.Load(effortKey(want)); ok {
+		return v.(string)
+	}
+	return want
+}
+
+// effortRemember enregistre la traduction pour les messages suivants.
+func effortRemember(want, got string) {
+	if want == "" {
+		return
+	}
+	effortFallbacks.Store(effortKey(want), got)
+}
+
+// logEffortFallback trace le repli sur stderr : sinon l'intensité choisie dans
+// l'interface n'est pas celle qui part au moteur, sans que rien ne le dise.
+func logEffortFallback(want, got string) {
+	if got == "" {
+		fmt.Fprintf(os.Stderr, "[reasoning] gabarit du modèle : intensité %q refusée — champ retiré pour ce modèle\n", want)
+		return
+	}
+	fmt.Fprintf(os.Stderr, "[reasoning] gabarit du modèle : intensité %q refusée — repli sur %q pour ce modèle\n", want, got)
+}

internal/loki/llm_effort_test.go

@@ -0,0 +1,119 @@
+package loki
+
+import "testing"
+
+// Le message qui a motivé tout ce fichier : Qwen3.8-27B refuse « high », le
+// niveau que l'interface enregistre par défaut, et llama-server répond 500.
+const qwenRefus = `{"error":{"code":500,"message":"\n------------\nWhile executing CallExpression at line 49, column 28 in source:\n...', 'low') %}\n {{- raise_exception('Unexpected reasoning effort ' ~ reason...\n ^\nError: Jinja Exception: Unexpected reasoning effort high. Supported types are xhigh (default), medium, and low.","type":"server_error"}}`
+
+func TestEffortRejection(t *testing.T) {
+	sup, ok := effortRejection(qwenRefus)
+	if !ok {
+		t.Fatal("refus de reasoning_effort non reconnu")
+	}
+	// « high » est cité AVANT la liste (c'est la valeur refusée) : le lire comme
+	// une valeur acceptée renverrait loki sur la même erreur en boucle.
+	want := map[string]bool{"xhigh": true, "medium": true, "low": true}
+	if len(sup) != len(want) {
+		t.Fatalf("niveaux acceptés = %v, attendu %v", sup, want)
+	}
+	for _, s := range sup {
+		if !want[s] {
+			t.Errorf("niveau %q lu à tort comme accepté (%v)", s, sup)
+		}
+	}
+	// Les autres 500 (prompt trop long, appel d'outil illisible) ne doivent pas
+	// passer par ce filet : ils ont le leur.
+	for _, body := range []string{
+		"",
+		`{"error":{"code":500,"message":"the request exceeds the available context size"}}`,
+		`{"error":{"code":500,"message":"Failed to parse tool call"}}`,
+		// Parle bien de reasoning_effort mais ne le refuse pas.
+		`{"error":{"code":500,"message":"reasoning_effort applied"}}`,
+	} {
+		if _, ok := effortRejection(body); ok {
+			t.Errorf("corps %q pris à tort pour un refus d'intensité", body)
+		}
+	}
+}
+
+// Sans liste de niveaux acceptés, il n'y a rien à deviner : on retire le champ.
+func TestEffortRejectionSansListe(t *testing.T) {
+	sup, ok := effortRejection("Error: Unknown reasoning effort 'xhigh'")
+	if !ok {
+		t.Fatal("refus non reconnu")
+	}
+	if len(sup) != 0 {
+		t.Fatalf("niveaux acceptés = %v, attendu aucun", sup)
+	}
+	if got := nearestEffort("xhigh", sup); got != "" {
+		t.Errorf("nearestEffort sans liste = %q, attendu \"\"", got)
+	}
+}
+
+func TestNearestEffort(t *testing.T) {
+	qwen := []string{"xhigh", "medium", "low"}
+	oss := []string{"low", "medium", "high"}
+	cases := []struct {
+		want      string
+		supported []string
+		expect    string
+	}{
+		{"high", qwen, "xhigh"}, // voisin immédiat vers le haut
+		{"xhigh", oss, "high"},  // voisin immédiat vers le bas
+		{"medium", qwen, "low"}, // « medium » refusé quand même : on ne le renvoie pas
+		{"low", []string{"medium", "high"}, "medium"},
+		{"high", nil, ""},     // rien d'annoncé : on retire le champ
+		{"", qwen, ""},        // auto : il n'y avait rien à envoyer
+		{"none", qwen, ""},    // consigne de coupure, pas une intensité
+		{"maximum", qwen, ""}, // hors échelle : on n'invente pas
+	}
+	for _, c := range cases {
+		if got := nearestEffort(c.want, c.supported); got != c.expect {
+			t.Errorf("nearestEffort(%q, %v) = %q, attendu %q", c.want, c.supported, got, c.expect)
+		}
+	}
+	// À égalité de distance, le niveau le plus FORT : dégrader en silence est
+	// pire que générer un peu plus longtemps.
+	if got := nearestEffort("medium", []string{"low", "high"}); got != "high" {
+		t.Errorf("égalité de distance = %q, attendu high", got)
+	}
+}
+
+func TestEffortFromRejection(t *testing.T) {
+	got, ok := effortFromRejection(qwenRefus, "high")
+	if !ok || got != "xhigh" {
+		t.Fatalf("effortFromRejection = %q, %v ; attendu xhigh, true", got, ok)
+	}
+	if _, ok := effortFromRejection("boom", "high"); ok {
+		t.Error("un 500 quelconque ne doit pas déclencher le repli d'intensité")
+	}
+}
+
+// La traduction apprise doit valoir pour les messages SUIVANTS (sinon chaque
+// message repaie un aller-retour 500) et rester attachée au modèle : un autre
+// modèle a un autre gabarit, donc d'autres niveaux.
+func TestEffortMemoire(t *testing.T) {
+	testHome(t)
+	if err := WriteConfig(map[string]string{"MODEL": "/data/models/qwen.gguf"}); err != nil {
+		t.Fatal(err)
+	}
+	if got := effortResolve("high"); got != "high" {
+		t.Fatalf("sans refus connu : %q, attendu high", got)
+	}
+	effortRemember("high", "xhigh")
+	if got := effortResolve("high"); got != "xhigh" {
+		t.Errorf("après apprentissage : %q, attendu xhigh", got)
+	}
+	if err := WriteConfig(map[string]string{"MODEL": "/data/models/gpt-oss.gguf"}); err != nil {
+		t.Fatal(err)
+	}
+	if got := effortResolve("high"); got != "high" {
+		t.Errorf("autre modèle : %q, attendu high (gabarit inconnu)", got)
+	}
+	// Champ retiré ("") : c'est une réponse apprise, pas une absence de réponse.
+	effortRemember("high", "")
+	if got := effortResolve("high"); got != "" {
+		t.Errorf("repli « champ retiré » : %q, attendu \"\"", got)
+	}
+}

internal/loki/llm_oai.go

@@ -40,15 +40,67 @@ import (
 // oaiSuffix est le domaine sous lequel on autorise l'émission de certificats.
 const oaiSuffix = ".oai.ajean.link"
 
+// viaTunnelHeader marque une requête arrivée par le tunnel du relais (posé par
+// withLocalAuth, qui l'efface d'abord — un client ne peut donc pas le forger).
+// Il sert à garder la promesse du tunnel : hors du front TLS dédié, la surface
+// des complétions y reste fermée tant que oaiPublicEnabled() est faux.
+const viaTunnelHeader = "X-Loki-Via"
+
+// sendOAIError répond au format d'erreur d'OpenAI. Les SDK officiels lisent
+// body.error.message ; un {"error":"…"} plat leur fait afficher un message vide,
+// et certains clients (LiteLLM, LangChain) échouent carrément au décodage.
+func sendOAIError(w http.ResponseWriter, status int, msg, typ, code string) {
+	sendJSON(w, status, map[string]any{"error": map[string]any{
+		"message": msg, "type": typ, "param": nil, "code": code,
+	}})
+}
+
+// mountOAI branche la surface compatible OpenAI sur le mux de Loki, protégée par
+// la clé des complétions (web_auth.go).
+//
+// C'est ce qui rend l'API joignable par le nom de domaine ou l'IP de
+// L'INTERFACE, sans publier de second port : le moteur peut rester sur la boucle
+// locale, et un reverse proxy devant Loki suffit pour le TLS. L'adresse annoncée
+// auparavant (celle du moteur, port 8080) n'était joignable dans aucun
+// déploiement en conteneur, où ce port n'est pas publié.
+//
+// ⚠️ On ne monte QUE /v1/. Surtout pas /health, /props, /metrics ni /slots — que
+// oaiHandler autorise pour le tunnel : ils divulgueraient le modèle chargé, la
+// taille de contexte et l'état des slots, sans authentification quand aucune clé
+// n'est définie. Le filtre interne d'oaiHandler reste en seconde barrière.
+func mountOAI(mux *http.ServeMux) {
+	mux.Handle("/v1/", requireCompletionKey(oaiHandler()))
+}
+
 // oaiHandler construit le reverse-proxy vers llama-server, restreint à la surface
-// compatible OpenAI. On NE touche PAS à l'en-tête Authorization : le SaaS envoie
-// la vraie clé (.api_key), que llama-server valide lui-même (--api-key).
+// compatible OpenAI. On NE touche PAS à l'en-tête Authorization : le client
+// envoie la vraie clé, que llama-server valide lui-même (--api-key). Elle est
+// donc vérifiée deux fois — par Loki puis par le moteur — et c'est voulu : le
+// moteur reste protégé même si on l'expose un jour en direct.
 func oaiHandler() http.Handler {
-	llama := &url.URL{Scheme: "http", Host: fmt.Sprintf("127.0.0.1:%d", LLMPort())}
-	lp := httputil.NewSingleHostReverseProxy(llama)
-	lp.FlushInterval = -1 // streaming SSE des complétions
-	lp.ErrorHandler = func(w http.ResponseWriter, r *http.Request, e error) {
-		http.Error(w, "llama-server injoignable: "+e.Error(), http.StatusBadGateway)
+	lp := &httputil.ReverseProxy{
+		// FlushInterval négatif = on vide le tampon à chaque écriture : c'est ce
+		// qui fait arriver les tokens un par un chez le client au lieu d'un bloc
+		// en fin de génération.
+		// ⚠️ Ne JAMAIS envelopper le ResponseWriter sur ce chemin (compteur,
+		// journalisation…) : un wrapper qui n'implémente pas http.Flusher
+		// retransforme le flux en réponse bufferisée, sans autre symptôme qu'une
+		// attente inexplicable.
+		FlushInterval: -1,
+		// Rewrite (et non Director) : le port du moteur est relu À CHAQUE
+		// REQUÊTE. Capturé à la construction, il figeait l'ancienne valeur dès
+		// qu'on changeait PORT depuis l'interface, et le proxy visait dans le
+		// vide jusqu'au redémarrage de Loki. Rewrite n'hérite pas non plus des
+		// X-Forwarded-* entrants : un client ne peut pas les forger vers le
+		// moteur.
+		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
+		},
+		ErrorHandler: func(w http.ResponseWriter, r *http.Request, e error) {
+			sendOAIError(w, http.StatusBadGateway,
+				"moteur injoignable : "+e.Error(), "api_error", "upstream_unavailable")
+		},
 	}
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		p := r.URL.Path
@@ -56,7 +108,8 @@ func oaiHandler() http.Handler {
 			lp.ServeHTTP(w, r)
 			return
 		}
-		http.Error(w, "not found (endpoint OpenAI: /v1/*)", http.StatusNotFound)
+		sendOAIError(w, http.StatusNotFound,
+			"chemin inconnu — l'endpoint compatible OpenAI est /v1/*", "invalid_request_error", "not_found")
 	})
 }
 
@@ -72,14 +125,14 @@ func runOAIFront(rawLn net.Listener, tlsCfg *tls.Config) error {
 	return srv.Serve(tls.NewListener(rawLn, tlsCfg))
 }
 
-// oaiPublicEnabled indique si l'accès OpenAI public est activé pour cette
-// machine. Piloté par l'UI et lu en direct → activable/coupable sans redémarrer
-// le service de lien.
+// oaiPublicEnabled indique si le front TLS du tunnel doit servir la surface
+// OpenAI. Drapeau désormais en LECTURE SEULE : plus aucune interface ne
+// l'allume, depuis que l'endpoint est servi par Loki sur son propre port (voir
+// mountOAI). Il ne subsiste que pour les installations migrées depuis AJEAN dont
+// le tunnel sert encore ce front — et pour son défaut, qui est le refus :
+// demuxTunnelStream ferme le flux quand il est absent.
 func oaiPublicEnabled() bool { return getBool(bkState, "oai_public") }
 
-// setOAIPublic active (on) ou coupe (off) l'accès OpenAI public.
-func setOAIPublic(on bool) error { return putBool(bkState, "oai_public", on) }
-
 // oaiTLSConfig renvoie une config TLS qui, à la demande, obtient/renouvelle via
 // Let's Encrypt (TLS-ALPN-01) le certificat de tout nom en *.oai.ajean.link, et
 // répond elle-même aux challenges ACME. La clé privée est stockée dans

internal/loki/llm_oai_test.go

@@ -0,0 +1,251 @@
+package loki
+
+// Tests de la surface compatible OpenAI servie par Loki (mountOAI).
+//
+// Elle est joignable partout où l'interface l'est : c'est tout l'intérêt, et
+// c'est aussi ce qui rend sa garde d'accès critique. Ces tests verrouillent les
+// quatre promesses : la clé est exigée quand elle existe, l'amont n'est jamais
+// appelé quand elle manque, l'en-tête du client arrive INTACT au moteur (qui la
+// revalide), et rien d'autre que /v1 n'est monté.
+
+import (
+	"bufio"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+)
+
+// fauxMoteur monte un llama-server de comédie et pointe la configuration
+// dessus : le proxy vise 127.0.0.1:LLMPort(), c'est donc tout ce qu'il faut.
+// Renvoie le serveur et un pointeur sur les en-têtes de la dernière requête
+// reçue (nil tant qu'il n'a rien reçu).
+func fauxMoteur(t *testing.T, h http.HandlerFunc) (*httptest.Server, func() http.Header) {
+	t.Helper()
+	var vues http.Header
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		vues = r.Header.Clone()
+		if h != nil {
+			h(w, r)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte(`{"object":"list","data":[{"id":"loki"}]}`))
+	}))
+	t.Cleanup(srv.Close)
+	port := srv.URL[strings.LastIndexByte(srv.URL, ':')+1:]
+	if _, err := strconv.Atoi(port); err != nil {
+		t.Fatalf("port du faux moteur illisible : %q", srv.URL)
+	}
+	if err := SetConfigKey("PORT", port); err != nil {
+		t.Fatal(err)
+	}
+	return srv, func() http.Header { return vues }
+}
+
+// appelOAI joue une requête à travers la garde + le proxy, sans monter tout le
+// serveur web (newWebMux a des effets de bord : MCP, migrations, conversation).
+func appelOAI(t *testing.T, méthode, chemin, clé string) *httptest.ResponseRecorder {
+	t.Helper()
+	req := httptest.NewRequest(méthode, chemin, nil)
+	if clé != "" {
+		req.Header.Set("Authorization", "Bearer "+clé)
+	}
+	rec := httptest.NewRecorder()
+	requireCompletionKey(oaiHandler()).ServeHTTP(rec, req)
+	return rec
+}
+
+// erreurOAI décode le corps au format d'erreur d'OpenAI — celui que les SDK
+// savent présenter à l'utilisateur.
+func erreurOAI(t *testing.T, rec *httptest.ResponseRecorder) (message, code string) {
+	t.Helper()
+	var body struct {
+		Error struct {
+			Message string `json:"message"`
+			Code    string `json:"code"`
+		} `json:"error"`
+	}
+	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
+		t.Fatalf("corps illisible (%d) : %s", rec.Code, rec.Body.String())
+	}
+	return body.Error.Message, body.Error.Code
+}
+
+// Sans clé configurée, l'endpoint est ouvert — comme llama-server sans
+// --api-key. Le panneau et le démarrage le disent en rouge ; ici on vérifie
+// seulement que le comportement est bien celui-là, et pas un refus silencieux.
+func TestOAISansCleLaissePasser(t *testing.T) {
+	testHome(t)
+	_, vues := fauxMoteur(t, nil)
+	rec := appelOAI(t, "GET", "/v1/models", "")
+	if rec.Code != 200 {
+		t.Fatalf("code %d, corps %s", rec.Code, rec.Body.String())
+	}
+	if !strings.Contains(rec.Body.String(), `"loki"`) {
+		t.Errorf("réponse du moteur non relayée : %s", rec.Body.String())
+	}
+	if vues() == nil {
+		t.Error("le moteur n'a pas été appelé")
+	}
+}
+
+// La bonne clé passe, ET l'en-tête arrive INTACT au moteur : c'est le contrat.
+// llama-server la valide lui aussi (--api-key), il reste donc protégé même si
+// on l'expose un jour en direct.
+func TestOAIBonneCleEtEnTeteRelayee(t *testing.T) {
+	testHome(t)
+	_, vues := fauxMoteur(t, nil)
+	if err := writeAPIKey("sk-loki-test"); err != nil {
+		t.Fatal(err)
+	}
+	rec := appelOAI(t, "GET", "/v1/models", "sk-loki-test")
+	if rec.Code != 200 {
+		t.Fatalf("code %d, corps %s", rec.Code, rec.Body.String())
+	}
+	if got := vues().Get("Authorization"); got != "Bearer sk-loki-test" {
+		t.Errorf("en-tête transmis au moteur = %q, attendu la clé du client", got)
+	}
+}
+
+// Mauvaise clé, et clé absente : 401 au format OpenAI, et le moteur n'est JAMAIS
+// appelé — une garde qui laisse passer la requête avant de refuser ne protège
+// rien.
+func TestOAICleRefusee(t *testing.T) {
+	for _, cas := range []struct{ nom, envoyée string }{
+		{"mauvaise clé", "sk-loki-pasbonne"},
+		{"aucune clé", ""},
+	} {
+		t.Run(cas.nom, func(t *testing.T) {
+			testHome(t)
+			_, vues := fauxMoteur(t, nil)
+			if err := writeAPIKey("sk-loki-test"); err != nil {
+				t.Fatal(err)
+			}
+			rec := appelOAI(t, "POST", "/v1/chat/completions", cas.envoyée)
+			if rec.Code != 401 {
+				t.Fatalf("code %d, attendu 401 — corps %s", rec.Code, rec.Body.String())
+			}
+			if rec.Header().Get("WWW-Authenticate") == "" {
+				t.Error("en-tête WWW-Authenticate absent")
+			}
+			msg, code := erreurOAI(t, rec)
+			if code != "invalid_api_key" || msg == "" {
+				t.Errorf("erreur = {code:%q, message:%q}", code, msg)
+			}
+			if vues() != nil {
+				t.Error("le moteur a été appelé malgré le refus")
+			}
+		})
+	}
+}
+
+// La clé résiduelle de config.env fait foi quand la base n'en a pas : c'est
+// celle que le moteur exige (backend_serve.go). Sans ce miroir, Loki laissait
+// passer et llama refusait — un 401 que rien n'expliquait.
+func TestOAICleResiduelleDeConfig(t *testing.T) {
+	testHome(t)
+	_, vues := fauxMoteur(t, nil)
+	if err := SetConfigKey("API_KEY", "sk-ancienne"); err != nil {
+		t.Fatal(err)
+	}
+	if rec := appelOAI(t, "GET", "/v1/models", ""); rec.Code != 401 {
+		t.Fatalf("sans clé : code %d, attendu 401", rec.Code)
+	}
+	if vues() != nil {
+		t.Fatal("le moteur a été appelé malgré le refus")
+	}
+	if rec := appelOAI(t, "GET", "/v1/models", "sk-ancienne"); rec.Code != 200 {
+		t.Fatalf("avec la clé de config.env : code %d, attendu 200", rec.Code)
+	}
+}
+
+// Un préflight CORS ne porte jamais d'Authorization. Le refuser casserait tout
+// client tiers qui tourne dans un navigateur.
+func TestOAIPreflightPasseSansCle(t *testing.T) {
+	testHome(t)
+	_, vues := fauxMoteur(t, nil)
+	if err := writeAPIKey("sk-loki-test"); err != nil {
+		t.Fatal(err)
+	}
+	if rec := appelOAI(t, "OPTIONS", "/v1/chat/completions", ""); rec.Code == 401 {
+		t.Fatalf("préflight refusé : %s", rec.Body.String())
+	}
+	if vues() == nil {
+		t.Error("le préflight n'a pas atteint le moteur, qui répond ses en-têtes CORS")
+	}
+}
+
+// Seul /v1/ est monté. /metrics, /props et /slots divulgueraient le modèle
+// chargé et l'état du moteur — sans clé, à qui joint l'adresse.
+func TestOAIMonteSeulementV1(t *testing.T) {
+	testHome(t)
+	mux := http.NewServeMux()
+	mountOAI(mux)
+	témoin := false
+	mux.HandleFunc("/", func(http.ResponseWriter, *http.Request) { témoin = true })
+
+	for _, chemin := range []string{"/metrics", "/props", "/slots", "/api/ping", "/"} {
+		témoin = false
+		rec := httptest.NewRecorder()
+		mux.ServeHTTP(rec, httptest.NewRequest("GET", chemin, nil))
+		if !témoin {
+			t.Errorf("%s n'a pas été servi par le handler racine — il est passé à l'endpoint OpenAI", chemin)
+		}
+	}
+	// …et /v1/, lui, ne va PAS au handler racine.
+	témoin = false
+	rec := httptest.NewRecorder()
+	mux.ServeHTTP(rec, httptest.NewRequest("GET", "/v1/models", nil))
+	if témoin {
+		t.Error("/v1/models a été servi par le handler racine")
+	}
+}
+
+// Le streaming doit arriver en morceaux. Si FlushInterval régresse, le premier
+// événement n'arrive qu'à la fin de la génération — invisible en test unitaire
+// classique, d'où ce test qui bloque l'amont entre deux écritures.
+func TestOAIStreamingArriveEnMorceaux(t *testing.T) {
+	testHome(t)
+	débloque := make(chan struct{})
+	fauxMoteur(t, func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "text/event-stream")
+		fl, ok := w.(http.Flusher)
+		if !ok {
+			t.Error("le faux moteur ne sait pas vider son tampon")
+			return
+		}
+		_, _ = w.Write([]byte("data: un\n\n"))
+		fl.Flush()
+		<-débloque
+		_, _ = w.Write([]byte("data: deux\n\n"))
+		fl.Flush()
+	})
+
+	front := httptest.NewServer(requireCompletionKey(oaiHandler()))
+	defer front.Close()
+	defer close(débloque)
+
+	resp, err := http.Get(front.URL + "/v1/chat/completions")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer resp.Body.Close()
+
+	lu := make(chan string, 1)
+	go func() {
+		ligne, _ := bufio.NewReader(resp.Body).ReadString('\n')
+		lu <- ligne
+	}()
+	select {
+	case ligne := <-lu:
+		if !strings.Contains(ligne, "un") {
+			t.Fatalf("première ligne = %q", ligne)
+		}
+	case <-time.After(3 * time.Second):
+		t.Fatal("rien reçu avant la fin de la génération : le flux est bufferisé")
+	}
+}

internal/loki/lsp.go

@@ -0,0 +1,416 @@
+package loki
+
+// lsp.go — client LSP minimal pour le VÉRIFICATEUR DE CODE : après chaque
+// write/edit en mode code, les diagnostics du serveur de langage (erreurs de
+// compilation, types, imports) sont ajoutés AU RÉSULTAT DE L'OUTIL — le modèle
+// apprend immédiatement que son code ne compile pas, sans lancer de build.
+// Repris de l'intégration LSP d'OpenFox (manager + languages.json — voir
+// NOTICE.md), réécrit en Go réduit à l'essentiel : initialize, didOpen/
+// didChange, publishDiagnostics. Pas de complétion, pas de hover — Loki n'est
+// pas un éditeur.
+//
+// La table langage → serveur vit dans lsp_languages.json (embarquée). Un
+// serveur absent du PATH désactive silencieusement son langage : le mode code
+// marche sans LSP, il vérifie juste moins tôt.
+
+import (
+	"bufio"
+	_ "embed"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+)
+
+//go:embed lsp_languages.json
+var lspLanguagesJSON []byte
+
+type lspLanguage struct {
+	ID         string   `json:"id"`
+	Command    []string `json:"command"`
+	Extensions []string `json:"extensions"`
+}
+
+var (
+	lspLangsOnce sync.Once
+	lspLangs     []lspLanguage
+)
+
+func lspLanguages() []lspLanguage {
+	lspLangsOnce.Do(func() {
+		_ = json.Unmarshal(lspLanguagesJSON, &lspLangs)
+	})
+	return lspLangs
+}
+
+// lspLangFor renvoie la config du langage d'un fichier, nil si aucun.
+func lspLangFor(path string) *lspLanguage {
+	ext := strings.ToLower(filepath.Ext(path))
+	if ext == "" {
+		return nil
+	}
+	for i := range lspLanguages() {
+		for _, e := range lspLangs[i].Extensions {
+			if e == ext {
+				return &lspLangs[i]
+			}
+		}
+	}
+	return nil
+}
+
+// --- Serveur -----------------------------------------------------------------
+
+const (
+	lspDiagWait    = 2500 * time.Millisecond // attente max des diagnostics
+	lspIdleTimeout = 5 * time.Minute         // arrêt d'un serveur inactif
+	lspMaxDiags    = 10                      // diagnostics montrés au modèle
+)
+
+type lspServer struct {
+	lang    string
+	root    string
+	cmd     *exec.Cmd
+	stdin   io.WriteCloser
+	mu      sync.Mutex // sérialise les requêtes (un didOpen+attente à la fois)
+	nextID  int
+	version map[string]int // uri → version de document
+	// diags : dernier publishDiagnostics reçu par uri, et signal d'arrivée.
+	diagMu   sync.Mutex
+	diags    map[string][]lspDiagnostic
+	diagCh   chan string // uri fraîchement publié
+	lastUsed time.Time
+	dead     bool
+}
+
+type lspDiagnostic struct {
+	Range struct {
+		Start struct {
+			Line      int `json:"line"`
+			Character int `json:"character"`
+		} `json:"start"`
+	} `json:"range"`
+	Severity int    `json:"severity"`
+	Message  string `json:"message"`
+	Source   string `json:"source"`
+}
+
+var (
+	lspMu      sync.Mutex
+	lspServers = map[string]*lspServer{} // clé : lang + racine
+)
+
+// lspDiagBlock : le bloc à AJOUTER au résultat d'un write/edit réussi.
+// "" si pas de mode code, pas de serveur pour ce langage, ou aucun diagnostic.
+func lspDiagBlock(absPath string, caps Caps) string {
+	if !caps.Code {
+		return ""
+	}
+	diags := lspDiagnosticsFor(absPath)
+	if diags == "" {
+		return ""
+	}
+	return "\n\n[diagnostics LSP]\n" + diags
+}
+
+// lspDiagnosticsFor ouvre (ou met à jour) le document auprès du serveur de son
+// langage et attend ses diagnostics. Best-effort borné : au pire lspDiagWait.
+func lspDiagnosticsFor(absPath string) string {
+	lang := lspLangFor(absPath)
+	if lang == nil {
+		return ""
+	}
+	if _, err := exec.LookPath(lang.Command[0]); err != nil {
+		return "" // serveur non installé : le mode code marche sans
+	}
+	root := agentCwd()
+	// Le dépôt cloné est la vraie racine projet quand le fichier est dedans :
+	// gopls a besoin du go.mod, tsserver du tsconfig.
+	if r := projectRootFor(absPath, root); r != "" {
+		root = r
+	}
+	srv, err := lspGet(lang, root)
+	if err != nil {
+		return ""
+	}
+	diags, ok := srv.check(absPath)
+	if !ok {
+		return ""
+	}
+	if len(diags) == 0 {
+		return ""
+	}
+	if len(diags) > lspMaxDiags {
+		diags = diags[:lspMaxDiags]
+	}
+	var b strings.Builder
+	for _, d := range diags {
+		sev := "info"
+		switch d.Severity {
+		case 1:
+			sev = "error"
+		case 2:
+			sev = "warning"
+		}
+		fmt.Fprintf(&b, "%d:%d [%s] %s\n", d.Range.Start.Line+1, d.Range.Start.Character+1, sev, strings.TrimSpace(d.Message))
+	}
+	return strings.TrimRight(b.String(), "\n")
+}
+
+// projectRootFor remonte du fichier vers ws en cherchant un marqueur de racine
+// de projet. Renvoie "" si rien trouvé au-dessus du fichier (dans la borne ws).
+func projectRootFor(absPath, ws string) string {
+	dir := filepath.Dir(absPath)
+	for {
+		for _, marker := range []string{"go.mod", "package.json", "pyproject.toml", ".git"} {
+			if _, err := os.Stat(filepath.Join(dir, marker)); err == nil {
+				return dir
+			}
+		}
+		if rel, ok := relWithin(ws, dir); !ok || rel == "" || rel == "." {
+			return ""
+		}
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			return ""
+		}
+		dir = parent
+	}
+}
+
+// lspGet renvoie le serveur (lang, racine), démarré au besoin.
+func lspGet(lang *lspLanguage, root string) (*lspServer, error) {
+	key := lang.ID + "\x00" + root
+	lspMu.Lock()
+	defer lspMu.Unlock()
+	if s := lspServers[key]; s != nil && !s.dead {
+		return s, nil
+	}
+	s, err := lspStart(lang, root)
+	if err != nil {
+		return nil, err
+	}
+	lspServers[key] = s
+	return s, nil
+}
+
+func lspStart(lang *lspLanguage, root string) (*lspServer, error) {
+	cmd := exec.Command(lang.Command[0], lang.Command[1:]...)
+	cmd.Dir = root
+	stdin, err := cmd.StdinPipe()
+	if err != nil {
+		return nil, err
+	}
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		return nil, err
+	}
+	cmd.Stderr = io.Discard
+	if err := cmd.Start(); err != nil {
+		return nil, err
+	}
+	s := &lspServer{
+		lang: lang.ID, root: root, cmd: cmd, stdin: stdin,
+		version: map[string]int{}, diags: map[string][]lspDiagnostic{},
+		diagCh: make(chan string, 16), lastUsed: time.Now(),
+	}
+	go s.readLoop(stdout)
+	go s.idleWatch()
+	// initialize / initialized. La réponse est consommée par readLoop ; on
+	// n'attend pas les capacités — on n'utilise que les diagnostics.
+	s.send("initialize", map[string]any{
+		"processId": nil,
+		"rootUri":   fileURI(root),
+		"capabilities": map[string]any{
+			"textDocument": map[string]any{
+				"publishDiagnostics": map[string]any{},
+				"synchronization":    map[string]any{"didSave": false},
+			},
+		},
+		"workspaceFolders": []map[string]any{{"uri": fileURI(root), "name": filepath.Base(root)}},
+	}, true)
+	s.notify("initialized", map[string]any{})
+	return s, nil
+}
+
+// check ouvre (ou met à jour) le document et attend ses diagnostics.
+func (s *lspServer) check(absPath string) ([]lspDiagnostic, bool) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if s.dead {
+		return nil, false
+	}
+	s.lastUsed = time.Now()
+	content, err := os.ReadFile(absPath)
+	if err != nil {
+		return nil, false
+	}
+	uri := fileURI(absPath)
+	// Vide les publications en attente pour cet uri : on veut la PROCHAINE.
+	s.diagMu.Lock()
+	delete(s.diags, uri)
+	s.diagMu.Unlock()
+	v, open := s.version[uri]
+	if !open {
+		s.version[uri] = 1
+		s.notify("textDocument/didOpen", map[string]any{
+			"textDocument": map[string]any{
+				"uri": uri, "languageId": s.lang, "version": 1, "text": string(content),
+			},
+		})
+	} else {
+		v++
+		s.version[uri] = v
+		s.notify("textDocument/didChange", map[string]any{
+			"textDocument":   map[string]any{"uri": uri, "version": v},
+			"contentChanges": []map[string]any{{"text": string(content)}},
+		})
+	}
+	// Attend la publication pour CET uri, bornée.
+	deadline := time.After(lspDiagWait)
+	for {
+		select {
+		case got := <-s.diagCh:
+			if got != uri {
+				continue
+			}
+			s.diagMu.Lock()
+			d := s.diags[uri]
+			s.diagMu.Unlock()
+			return d, true
+		case <-deadline:
+			// Pas de publication à temps : certains serveurs ne publient rien
+			// quand il n'y a AUCUN diagnostic. On rend « rien », pas un échec.
+			s.diagMu.Lock()
+			d := s.diags[uri]
+			s.diagMu.Unlock()
+			return d, true
+		}
+	}
+}
+
+// readLoop parse les messages LSP (en-têtes Content-Length) et garde les
+// publishDiagnostics ; tout le reste est ignoré.
+func (s *lspServer) readLoop(r io.Reader) {
+	br := bufio.NewReaderSize(r, 1<<20)
+	for {
+		length := 0
+		for {
+			line, err := br.ReadString('\n')
+			if err != nil {
+				s.markDead()
+				return
+			}
+			line = strings.TrimSpace(line)
+			if line == "" {
+				break
+			}
+			if v, ok := strings.CutPrefix(line, "Content-Length:"); ok {
+				fmt.Sscanf(strings.TrimSpace(v), "%d", &length)
+			}
+		}
+		if length <= 0 || length > 32<<20 {
+			s.markDead()
+			return
+		}
+		buf := make([]byte, length)
+		if _, err := io.ReadFull(br, buf); err != nil {
+			s.markDead()
+			return
+		}
+		var msg struct {
+			Method string `json:"method"`
+			Params struct {
+				URI         string          `json:"uri"`
+				Diagnostics []lspDiagnostic `json:"diagnostics"`
+			} `json:"params"`
+		}
+		if json.Unmarshal(buf, &msg) != nil {
+			continue
+		}
+		if msg.Method == "textDocument/publishDiagnostics" {
+			s.diagMu.Lock()
+			s.diags[msg.Params.URI] = msg.Params.Diagnostics
+			s.diagMu.Unlock()
+			select {
+			case s.diagCh <- msg.Params.URI:
+			default: // personne n'attend : la publication reste dans s.diags
+			}
+		}
+	}
+}
+
+func (s *lspServer) idleWatch() {
+	t := time.NewTicker(time.Minute)
+	defer t.Stop()
+	for range t.C {
+		s.mu.Lock()
+		idle := time.Since(s.lastUsed) > lspIdleTimeout
+		dead := s.dead
+		s.mu.Unlock()
+		if dead {
+			return
+		}
+		if idle {
+			s.shutdown()
+			return
+		}
+	}
+}
+
+func (s *lspServer) shutdown() {
+	s.markDead()
+	if s.cmd.Process != nil {
+		// shutdown/exit protocolaires seraient plus polis, mais le process peut
+		// être déjà figé — kill borné est fiable et le serveur n'a pas d'état.
+		_ = s.cmd.Process.Kill()
+	}
+	lspMu.Lock()
+	delete(lspServers, s.lang+"\x00"+s.root)
+	lspMu.Unlock()
+}
+
+func (s *lspServer) markDead() {
+	s.mu.Lock()
+	s.dead = true
+	s.mu.Unlock()
+}
+
+func (s *lspServer) send(method string, params any, isRequest bool) {
+	s.nextID++
+	msg := map[string]any{"jsonrpc": "2.0", "method": method, "params": params}
+	if isRequest {
+		msg["id"] = s.nextID
+	}
+	s.writeMsg(msg)
+}
+
+func (s *lspServer) notify(method string, params any) { s.send(method, params, false) }
+
+func (s *lspServer) writeMsg(msg map[string]any) {
+	b, err := json.Marshal(msg)
+	if err != nil {
+		return
+	}
+	_, err = fmt.Fprintf(s.stdin, "Content-Length: %d\r\n\r\n%s", len(b), b)
+	if err != nil {
+		s.markDead()
+	}
+}
+
+// fileURI convertit un chemin absolu en URI file://.
+func fileURI(path string) string {
+	p := filepath.ToSlash(path)
+	if !strings.HasPrefix(p, "/") {
+		p = "/" + p // Windows : C:\x → /C:/x
+	}
+	return "file://" + p
+}
+
+// Pas d'arrêt global : les serveurs LSP sont des enfants du process loki et
+// meurent avec lui (et l'inactivité de 5 min couvre le reste — idleWatch).

internal/loki/lsp_languages.json

@@ -0,0 +1,17 @@
+[
+  {
+    "id": "go",
+    "command": ["gopls", "serve"],
+    "extensions": [".go"]
+  },
+  {
+    "id": "typescript",
+    "command": ["typescript-language-server", "--stdio"],
+    "extensions": [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]
+  },
+  {
+    "id": "python",
+    "command": ["pyright-langserver", "--stdio"],
+    "extensions": [".py"]
+  }
+]

internal/loki/mcp_catalog.go

@@ -0,0 +1,157 @@
+package loki
+
+// Catalogue MCP embarqué.
+//
+// Ajouter un serveur MCP demandait jusqu'ici d'écrire soi-même la commande et
+// ses arguments (`npx -y @scope/paquet …`) dans la modale. Le catalogue fournit
+// une liste de serveurs connus, déjà renseignés : un clic préremplit la modale,
+// l'utilisateur relit la commande et enregistre.
+//
+// Le catalogue est un JSON EMBARQUÉ dans le binaire (go:embed), pas un appel à
+// un annuaire distant : cohérent avec un Loki qui tourne hors ligne, et rien de
+// ce qui s'exécute sur la machine ne vient du réseau. Pour proposer un serveur
+// de plus : éditer mcp_catalog.json et recompiler.
+//
+// SÉCURITÉ : le catalogue ne fait qu'AFFICHER une commande. Il n'installe ni
+// n'exécute rien tout seul — c'est l'enregistrement du serveur par
+// l'utilisateur, via la modale existante, qui décide. Même niveau de confiance
+// que l'outil `bash` du mode agent (voir l'en-tête de mcp_config.go).
+
+import (
+	_ "embed"
+	"encoding/json"
+	"fmt"
+	"os/exec"
+	"strings"
+	"sync"
+)
+
+//go:embed mcp_catalog.json
+var mcpCatalogRaw []byte
+
+// MCPCatalogEntry décrit un serveur proposé par le catalogue. Les champs de
+// transport reprennent ceux de MCPServerConfig : l'UI peut les recopier tels
+// quels dans la modale d'ajout.
+type MCPCatalogEntry struct {
+	ID          string `json:"id"`
+	Name        string `json:"name"`
+	Category    string `json:"category"`
+	Description string `json:"description"`
+	Homepage    string `json:"homepage,omitempty"`
+
+	// Runtime : binaire nécessaire pour lancer le serveur ("node" → npx,
+	// "python" → uvx). Sert à signaler une entrée non installable ici.
+	Runtime string            `json:"runtime,omitempty"`
+	Command string            `json:"command"`
+	Args    []string          `json:"args,omitempty"`
+	Env     map[string]string `json:"env,omitempty"`
+
+	// Secrets : variables d'environnement que l'utilisateur DOIT renseigner
+	// (jetons, clés d'API). L'UI les met en évidence ; elles sont volontairement
+	// vides dans le catalogue.
+	Secrets []string `json:"secrets,omitempty"`
+
+	// Renseignés à la lecture, pas dans le fichier.
+	Installed bool `json:"installed"`
+	RuntimeOK bool `json:"runtimeOk"`
+}
+
+type mcpCatalogFile struct {
+	Version int               `json:"version"`
+	Servers []MCPCatalogEntry `json:"servers"`
+}
+
+var (
+	mcpCatalogOnce    sync.Once
+	mcpCatalogParsed  []MCPCatalogEntry
+	mcpCatalogParseEr error
+)
+
+// mcpCatalogEntries décode le JSON embarqué une seule fois. Le contenu est figé
+// dans le binaire : inutile de le relire à chaque appel.
+func mcpCatalogEntries() ([]MCPCatalogEntry, error) {
+	mcpCatalogOnce.Do(func() {
+		var f mcpCatalogFile
+		if err := json.Unmarshal(mcpCatalogRaw, &f); err != nil {
+			mcpCatalogParseEr = fmt.Errorf("catalogue MCP illisible : %w", err)
+			return
+		}
+		mcpCatalogParsed = f.Servers
+	})
+	return mcpCatalogParsed, mcpCatalogParseEr
+}
+
+// mcpRuntimeAvailable indique si le binaire qui lance ce type de serveur est
+// présent. L'image conteneur embarque Node ; uv/uvx peut manquer.
+func mcpRuntimeAvailable(runtime string) bool {
+	switch runtime {
+	case "node":
+		return lookPathOK("npx")
+	case "python":
+		return lookPathOK("uvx")
+	default:
+		return true
+	}
+}
+
+func lookPathOK(bin string) bool {
+	_, err := exec.LookPath(bin)
+	return err == nil
+}
+
+// MCPCatalog renvoie les entrées du catalogue, chemins résolus et marquées
+// « déjà installée » (un serveur configuré porte le même nom que l'entrée).
+func MCPCatalog() ([]MCPCatalogEntry, error) {
+	entries, err := mcpCatalogEntries()
+	if err != nil {
+		return nil, err
+	}
+	configured, err := LoadMCPConfig()
+	if err != nil {
+		// Une config MCP illisible ne doit pas vider le catalogue : on affiche
+		// les entrées sans savoir lesquelles sont déjà là.
+		configured = map[string]MCPServerConfig{}
+	}
+
+	out := make([]MCPCatalogEntry, 0, len(entries))
+	for _, e := range entries {
+		e.Args = expandCatalogSlice(e.Args)
+		e.Env = expandCatalogMap(e.Env)
+		_, e.Installed = configured[e.ID]
+		e.RuntimeOK = mcpRuntimeAvailable(e.Runtime)
+		out = append(out, e)
+	}
+	return out, nil
+}
+
+// expandCatalogToken remplace les jetons de chemin du catalogue. Seul
+// {workspace} existe : c'est le dossier de travail de l'agent, le seul chemin
+// qu'un serveur du catalogue a une raison légitime de recevoir par défaut.
+func expandCatalogToken(s string) string {
+	if !strings.Contains(s, "{workspace}") {
+		return s
+	}
+	return strings.ReplaceAll(s, "{workspace}", workspaceDir())
+}
+
+func expandCatalogSlice(in []string) []string {
+	if len(in) == 0 {
+		return in
+	}
+	out := make([]string, len(in))
+	for i, s := range in {
+		out[i] = expandCatalogToken(s)
+	}
+	return out
+}
+
+func expandCatalogMap(in map[string]string) map[string]string {
+	if len(in) == 0 {
+		return in
+	}
+	out := make(map[string]string, len(in))
+	for k, v := range in {
+		out[k] = expandCatalogToken(v)
+	}
+	return out
+}

internal/loki/mcp_catalog.json

@@ -0,0 +1,262 @@
+{
+  "version": 1,
+  "note": "Catalogue MCP embarqué (hors ligne, aucun annuaire distant). Éditable à la main : ajoute une entrée pour la proposer dans l'interface, puis relance le build. Le jeton {workspace} est remplacé par le dossier de travail de l'agent. Les entrées « uvx --with mcp<2 … » visent des serveurs publiés avant le SDK MCP 2.0 : sans cet épinglage, ils plantent au démarrage (ImportError McpError).",
+  "servers": [
+    {
+      "id": "filesystem",
+      "name": "Filesystem",
+      "category": "Fichiers",
+      "description": "Lecture, écriture et recherche de fichiers, limitées aux dossiers passés en argument.",
+      "homepage": "https://github.com/modelcontextprotocol/servers/tree/main/src/filesystem",
+      "runtime": "node",
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "{workspace}"],
+      "env": {},
+      "secrets": []
+    },
+    {
+      "id": "git",
+      "name": "Git",
+      "category": "Code",
+      "description": "Historique, diff et statut d'un dépôt Git ; commits et branches.",
+      "homepage": "https://github.com/modelcontextprotocol/servers/tree/main/src/git",
+      "runtime": "python",
+      "command": "uvx",
+      "args": ["mcp-server-git", "--repository", "{workspace}"],
+      "env": {},
+      "secrets": []
+    },
+    {
+      "id": "fetch",
+      "name": "Fetch",
+      "category": "Web",
+      "description": "Télécharge une URL et la convertit en Markdown pour le modèle.",
+      "homepage": "https://github.com/modelcontextprotocol/servers/tree/main/src/fetch",
+      "runtime": "python",
+      "command": "uvx",
+      "args": ["--with", "mcp<2", "mcp-server-fetch"],
+      "env": {},
+      "secrets": []
+    },
+    {
+      "id": "memory",
+      "name": "Memory",
+      "category": "Agent",
+      "description": "Mémoire sous forme de graphe de connaissances (entités, relations, observations).",
+      "homepage": "https://github.com/modelcontextprotocol/servers/tree/main/src/memory",
+      "runtime": "node",
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-memory"],
+      "env": { "MEMORY_FILE_PATH": "{workspace}/mcp-memory.json" },
+      "secrets": []
+    },
+    {
+      "id": "sequential-thinking",
+      "name": "Sequential Thinking",
+      "category": "Agent",
+      "description": "Structure le raisonnement en étapes révisables. Utile aux petits modèles locaux.",
+      "homepage": "https://github.com/modelcontextprotocol/servers/tree/main/src/sequentialthinking",
+      "runtime": "node",
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"],
+      "env": {},
+      "secrets": []
+    },
+    {
+      "id": "time",
+      "name": "Time",
+      "category": "Utilitaires",
+      "description": "Heure courante et conversions de fuseaux horaires.",
+      "homepage": "https://github.com/modelcontextprotocol/servers/tree/main/src/time",
+      "runtime": "python",
+      "command": "uvx",
+      "args": ["--with", "mcp<2", "mcp-server-time"],
+      "env": {},
+      "secrets": []
+    },
+    {
+      "id": "sqlite",
+      "name": "SQLite",
+      "category": "Données",
+      "description": "Interroge et modifie une base SQLite locale.",
+      "homepage": "https://github.com/modelcontextprotocol/servers-archived/tree/main/src/sqlite",
+      "runtime": "python",
+      "command": "uvx",
+      "args": ["--with", "mcp<2", "mcp-server-sqlite", "--db-path", "{workspace}/agent.db"],
+      "env": {},
+      "secrets": []
+    },
+    {
+      "id": "everything",
+      "name": "Everything (test)",
+      "category": "Utilitaires",
+      "description": "Serveur de référence exposant toutes les primitives MCP. Sert à vérifier l'intégration.",
+      "homepage": "https://github.com/modelcontextprotocol/servers/tree/main/src/everything",
+      "runtime": "node",
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-everything"],
+      "env": {},
+      "secrets": []
+    },
+    {
+      "id": "duckduckgo",
+      "name": "DuckDuckGo",
+      "category": "Web",
+      "description": "Recherche web via DuckDuckGo, sans clé d'API.",
+      "homepage": "https://pypi.org/project/duckduckgo-mcp-server/",
+      "runtime": "python",
+      "command": "uvx",
+      "args": ["duckduckgo-mcp-server"],
+      "env": {},
+      "secrets": []
+    },
+    {
+      "id": "playwright",
+      "name": "Playwright",
+      "category": "Web",
+      "description": "Pilote un navigateur (navigation, clics, formulaires) via l'arbre d'accessibilité.",
+      "homepage": "https://github.com/microsoft/playwright-mcp",
+      "runtime": "node",
+      "command": "npx",
+      "args": ["-y", "@playwright/mcp@latest", "--headless"],
+      "env": {},
+      "secrets": []
+    },
+    {
+      "id": "puppeteer",
+      "name": "Puppeteer",
+      "category": "Web",
+      "description": "Automatisation d'un Chrome sans interface (alternative à Playwright).",
+      "homepage": "https://github.com/modelcontextprotocol/servers-archived/tree/main/src/puppeteer",
+      "runtime": "node",
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-puppeteer"],
+      "env": {},
+      "secrets": []
+    },
+    {
+      "id": "context7",
+      "name": "Context7",
+      "category": "Code",
+      "description": "Documentation à jour des bibliothèques, injectée directement dans le contexte.",
+      "homepage": "https://github.com/upstash/context7",
+      "runtime": "node",
+      "command": "npx",
+      "args": ["-y", "@upstash/context7-mcp"],
+      "env": {},
+      "secrets": []
+    },
+    {
+      "id": "github",
+      "name": "GitHub",
+      "category": "Code",
+      "description": "Dépôts, issues et pull requests via l'API GitHub. Nécessite un jeton personnel.",
+      "homepage": "https://github.com/modelcontextprotocol/servers-archived/tree/main/src/github",
+      "runtime": "node",
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-github"],
+      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "" },
+      "secrets": ["GITHUB_PERSONAL_ACCESS_TOKEN"]
+    },
+    {
+      "id": "postgres",
+      "name": "PostgreSQL",
+      "category": "Données",
+      "description": "Requêtes SQL en lecture seule et inspection du schéma d'une base PostgreSQL.",
+      "homepage": "https://github.com/modelcontextprotocol/servers-archived/tree/main/src/postgres",
+      "runtime": "node",
+      "command": "npx",
+      "args": [
+        "-y",
+        "@modelcontextprotocol/server-postgres",
+        "postgresql://utilisateur:motdepasse@hote:5432/base"
+      ],
+      "env": {},
+      "secrets": []
+    },
+    {
+      "id": "docker",
+      "name": "Docker",
+      "category": "Infra",
+      "description": "Gère conteneurs et stacks compose. Nécessite l'accès au socket Docker.",
+      "homepage": "https://pypi.org/project/docker-mcp/",
+      "runtime": "python",
+      "command": "uvx",
+      "args": ["--with", "mcp<2", "docker-mcp"],
+      "env": {},
+      "secrets": []
+    },
+    {
+      "id": "brave-search",
+      "name": "Brave Search",
+      "category": "Web",
+      "description": "Recherche web et locale via l'API Brave. Nécessite une clé d'API.",
+      "homepage": "https://github.com/modelcontextprotocol/servers-archived/tree/main/src/brave-search",
+      "runtime": "node",
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
+      "env": { "BRAVE_API_KEY": "" },
+      "secrets": ["BRAVE_API_KEY"]
+    },
+    {
+      "id": "firecrawl",
+      "name": "Firecrawl",
+      "category": "Web",
+      "description": "Scraping et crawl de sites avec extraction structurée. Nécessite une clé d'API.",
+      "homepage": "https://github.com/firecrawl/firecrawl-mcp-server",
+      "runtime": "node",
+      "command": "npx",
+      "args": ["-y", "firecrawl-mcp"],
+      "env": { "FIRECRAWL_API_KEY": "" },
+      "secrets": ["FIRECRAWL_API_KEY"]
+    },
+    {
+      "id": "notion",
+      "name": "Notion",
+      "category": "Productivité",
+      "description": "Lecture et écriture de pages et bases Notion. Nécessite un jeton d'intégration.",
+      "homepage": "https://github.com/makenotion/notion-mcp-server",
+      "runtime": "node",
+      "command": "npx",
+      "args": ["-y", "@notionhq/notion-mcp-server"],
+      "env": { "NOTION_TOKEN": "" },
+      "secrets": ["NOTION_TOKEN"]
+    },
+    {
+      "id": "slack",
+      "name": "Slack",
+      "category": "Productivité",
+      "description": "Lecture des canaux et envoi de messages Slack. Nécessite un jeton de bot.",
+      "homepage": "https://github.com/modelcontextprotocol/servers-archived/tree/main/src/slack",
+      "runtime": "node",
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-slack"],
+      "env": { "SLACK_BOT_TOKEN": "", "SLACK_TEAM_ID": "" },
+      "secrets": ["SLACK_BOT_TOKEN"]
+    },
+    {
+      "id": "google-maps",
+      "name": "Google Maps",
+      "category": "Utilitaires",
+      "description": "Géocodage, itinéraires et recherche de lieux. Nécessite une clé d'API.",
+      "homepage": "https://github.com/modelcontextprotocol/servers-archived/tree/main/src/google-maps",
+      "runtime": "node",
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-google-maps"],
+      "env": { "GOOGLE_MAPS_API_KEY": "" },
+      "secrets": ["GOOGLE_MAPS_API_KEY"]
+    },
+    {
+      "id": "sentry",
+      "name": "Sentry",
+      "category": "Infra",
+      "description": "Récupère les issues et traces d'erreur d'un projet Sentry.",
+      "homepage": "https://pypi.org/project/mcp-server-sentry/",
+      "runtime": "python",
+      "command": "uvx",
+      "args": ["--with", "mcp<2", "mcp-server-sentry", "--auth-token", "REMPLACE_MOI"],
+      "env": {},
+      "secrets": []
+    }
+  ]
+}

internal/loki/mcp_catalog_test.go

@@ -0,0 +1,118 @@
+package loki
+
+import (
+	"strings"
+	"testing"
+)
+
+// Le catalogue est embarqué : s'il ne décode pas, le binaire livré est cassé et
+// le panneau MCP part vide. Ce test attrape une virgule en trop au build.
+func TestMCPCatalogDecodes(t *testing.T) {
+	entries, err := mcpCatalogEntries()
+	if err != nil {
+		t.Fatalf("catalogue illisible : %v", err)
+	}
+	if len(entries) == 0 {
+		t.Fatal("catalogue vide")
+	}
+
+	seen := map[string]bool{}
+	for _, e := range entries {
+		if e.ID == "" || e.Name == "" || e.Command == "" {
+			t.Errorf("entrée incomplète : %+v", e)
+		}
+		if seen[e.ID] {
+			t.Errorf("id dupliqué : %s", e.ID)
+		}
+		seen[e.ID] = true
+		if e.Description == "" {
+			t.Errorf("%s : description manquante", e.ID)
+		}
+		// Un secret annoncé doit exister comme variable d'environnement, sinon
+		// l'UI met en avant un champ que l'utilisateur ne peut pas remplir.
+		for _, s := range e.Secrets {
+			if _, ok := e.Env[s]; !ok {
+				t.Errorf("%s : secret %q absent de env", e.ID, s)
+			}
+		}
+	}
+}
+
+// Les jetons {workspace} doivent disparaître : un serveur lancé avec un chemin
+// littéral « {workspace} » démarre puis échoue à la première lecture.
+func TestMCPCatalogExpandsWorkspaceToken(t *testing.T) {
+	entries, err := MCPCatalog()
+	if err != nil {
+		t.Fatalf("MCPCatalog : %v", err)
+	}
+	for _, e := range entries {
+		for _, a := range e.Args {
+			if strings.Contains(a, "{workspace}") {
+				t.Errorf("%s : jeton non résolu dans args : %s", e.ID, a)
+			}
+		}
+		for k, v := range e.Env {
+			if strings.Contains(v, "{workspace}") {
+				t.Errorf("%s : jeton non résolu dans env[%s] : %s", e.ID, k, v)
+			}
+		}
+	}
+}
+
+func TestReasoningEffortValue(t *testing.T) {
+	cases := map[string]string{
+		"":        "",
+		"  ":      "",
+		"auto":    "",
+		"default": "",
+		"off":     "none",
+		"none":    "none",
+		"false":   "none",
+		"0":       "none",
+		"low":     "low",
+		"MEDIUM":  "medium",
+		" High ":  "high",
+	}
+	for in, want := range cases {
+		if got := reasoningEffortValue(in); got != want {
+			t.Errorf("reasoningEffortValue(%q) = %q, attendu %q", in, got, want)
+		}
+	}
+}
+
+func TestReasoningExplicitlyOff(t *testing.T) {
+	// Clé absente ou vide = pas de consigne, surtout pas une interdiction.
+	for _, v := range []string{"", "   ", "on", "auto", "deepseek"} {
+		if reasoningExplicitlyOff(v) {
+			t.Errorf("reasoningExplicitlyOff(%q) = true, attendu false", v)
+		}
+	}
+	for _, v := range []string{"off", "none", "0", "false", " Disabled "} {
+		if !reasoningExplicitlyOff(v) {
+			t.Errorf("reasoningExplicitlyOff(%q) = false, attendu true", v)
+		}
+	}
+}
+
+func TestReasoningTemplateKwargs(t *testing.T) {
+	// « aucune » doit parler aux gabarits hybrides, pas seulement à ceux qui
+	// lisent reasoning_effort : sinon le modèle réfléchit quand même.
+	if got := reasoningTemplateKwargs(false, "none"); got == nil || got["enable_thinking"] != false {
+		t.Errorf("effort none : %v, attendu enable_thinking=false", got)
+	}
+	if got := reasoningTemplateKwargs(true, ""); got == nil || got["enable_thinking"] != false {
+		t.Errorf("REASONING=off : %v, attendu enable_thinking=false", got)
+	}
+	// Un niveau explicite voyage aussi dans les kwargs : les binaires anciens ne
+	// relaient pas le champ de haut niveau au gabarit.
+	if got := reasoningTemplateKwargs(false, "high"); got == nil || got["reasoning_effort"] != "high" {
+		t.Errorf("effort high : %v, attendu reasoning_effort=high", got)
+	}
+	if _, ok := reasoningTemplateKwargs(false, "high")["enable_thinking"]; ok {
+		t.Error("un niveau explicite ne doit pas couper le raisonnement")
+	}
+	// Auto = aucune consigne : on n'écrit rien dans la requête.
+	if got := reasoningTemplateKwargs(false, ""); got != nil {
+		t.Errorf("auto : %v, attendu nil", got)
+	}
+}

internal/loki/mcp_client.go

@@ -3,10 +3,12 @@ package loki
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/http"
 	"os"
 	"os/exec"
+	"path/filepath"
 	"regexp"
 	"sort"
 	"strings"
@@ -37,6 +39,13 @@ const (
 	// mcpConnectTimeout borne l'établissement d'une session (handshake initialize
 	// + tools/list). Un serveur qui rame ne doit pas figer le tour de chat.
 	mcpConnectTimeout = 20 * time.Second
+	// mcpConnectTimeoutCold : npx et uvx TÉLÉCHARGENT le paquet du serveur au
+	// premier lancement (le catalogue les utilise tous les deux). Sur un réseau
+	// ou un disque lents, ça dépasse largement 20 s, et l'utilisateur voyait
+	// « enregistré mais connexion échouée : context deadline exceeded » pour un
+	// serveur parfaitement sain. Les lancements suivants profitent du cache et
+	// retombent dans le régime normal.
+	mcpConnectTimeoutCold = 3 * time.Minute
 	// mcpCallTimeout borne un appel d'outil MCP.
 	mcpCallTimeout = 120 * time.Second
 	// mcpMaxOutput cap la sortie renvoyée au modèle (cohérent avec toolMaxOutput).
@@ -174,11 +183,11 @@ func (m *mcpManager) ensure(name string, cfg MCPServerConfig) *mcpSession {
 	m.mu.Unlock()
 
 	// Connexion hors-lock (peut être lente).
-	ctx, cancel := context.WithTimeout(context.Background(), mcpConnectTimeout)
+	ctx, cancel := context.WithTimeout(context.Background(), mcpTimeoutFor(cfg))
 	defer cancel()
 	sess, err := mcpConnect(ctx, name, cfg)
 	if err != nil {
-		s.err = err
+		s.err = mcpFriendlyErr(err, cfg)
 	} else {
 		s.sess = sess
 		lt, lerr := sess.ListTools(ctx, nil)
@@ -509,3 +518,30 @@ func MCPStatus() ([]MCPServerStatus, error) {
 	}
 	return out, nil
 }
+
+// mcpTimeoutFor choisit le délai de connexion d'un serveur : long pour un
+// lanceur qui télécharge son paquet à la volée (npx, uvx), court sinon.
+func mcpTimeoutFor(cfg MCPServerConfig) time.Duration {
+	base := strings.ToLower(filepath.Base(cfg.Command))
+	base = strings.TrimSuffix(strings.TrimSuffix(base, ".exe"), ".cmd")
+	if base == "npx" || base == "uvx" {
+		return mcpConnectTimeoutCold
+	}
+	return mcpConnectTimeout
+}
+
+// mcpFriendlyErr habille l'erreur de connexion la plus vécue : le délai
+// dépassé d'un npx/uvx en plein téléchargement. L'erreur brute (« context
+// deadline exceeded ») envoyait l'utilisateur chercher un bug de config alors
+// qu'il suffit souvent de réessayer une fois le paquet en cache.
+func mcpFriendlyErr(err error, cfg MCPServerConfig) error {
+	if err == nil || !errors.Is(err, context.DeadlineExceeded) {
+		return err
+	}
+	base := strings.ToLower(filepath.Base(cfg.Command))
+	base = strings.TrimSuffix(strings.TrimSuffix(base, ".exe"), ".cmd")
+	if base == "npx" || base == "uvx" {
+		return fmt.Errorf("délai dépassé — %s télécharge le paquet du serveur au premier lancement, ce qui peut être long ; clique « tester » pour réessayer (le paquet reste en cache), et vérifie que le conteneur atteint le registre (npm/PyPI)", base)
+	}
+	return fmt.Errorf("délai dépassé — le serveur n'a pas répondu au handshake en %s", mcpConnectTimeout)
+}

internal/loki/normalize_system_test.go

@@ -0,0 +1,105 @@
+package loki
+
+import (
+	"reflect"
+	"testing"
+)
+
+// Repris de l'amont AJEAN (v0.9.8) avec le correctif : les tests valent tels
+// quels, la fonction étant portée à l'identique.
+//
+// LE test qui rassure : sur une conversation NORMALE (un seul system en tête,
+// suivi de user/assistant/tool, appels d'outils et contenu multimodal compris),
+// la normalisation ne doit RIEN changer — même contenu, même ordre. C'est la
+// garantie que le fix est invisible pour les 99 % de cas qui marchaient déjà.
+func TestNormalizeSystemMessagesNoOpOnNormalConversation(t *testing.T) {
+	in := []Message{
+		{Role: "system", Content: "Tu es Loki."},
+		{Role: "user", Content: "cherche la météo"},
+		{Role: "assistant", Content: "", ToolCalls: []ToolCall{{ID: "call_1", Type: "function"}}},
+		{Role: "tool", Content: "résultat brut", ToolCallID: "call_1"},
+		{Role: "assistant", Content: "Il fait beau."},
+		// contenu multimodal (image) : Content n'est pas une string
+		{Role: "user", Content: []any{map[string]any{"type": "text", "text": "et demain ?"}}},
+	}
+	// copie profonde de référence pour détecter toute mutation de l'entrée
+	ref := append([]Message(nil), in...)
+	out := normalizeSystemMessages(in)
+	if !reflect.DeepEqual(out, in) {
+		t.Errorf("séquence normale modifiée !\navant: %#v\naprès: %#v", in, out)
+	}
+	if !reflect.DeepEqual(in, ref) {
+		t.Errorf("l'entrée a été mutée (interdit) : %#v", in)
+	}
+}
+
+// L'ordre relatif de tous les messages NON-system (et le lien assistant→tool via
+// ToolCallID) doit être préservé quand on ramène un system égaré en tête.
+func TestNormalizeSystemMessagesPreservesOrderAndToolLink(t *testing.T) {
+	in := []Message{
+		{Role: "system", Content: "S1"},
+		{Role: "user", Content: "q"},
+		{Role: "assistant", Content: "", ToolCalls: []ToolCall{{ID: "call_9"}}},
+		{Role: "tool", Content: "r", ToolCallID: "call_9"},
+		{Role: "system", Content: "n'appelle plus d'outil"}, // égaré, en fin
+	}
+	out := normalizeSystemMessages(in)
+	want := []Message{
+		{Role: "system", Content: "S1\n\nn'appelle plus d'outil"},
+		{Role: "user", Content: "q"},
+		{Role: "assistant", Content: "", ToolCalls: []ToolCall{{ID: "call_9"}}},
+		{Role: "tool", Content: "r", ToolCallID: "call_9"},
+	}
+	if !reflect.DeepEqual(out, want) {
+		t.Errorf("ordre/lien outil cassé :\n%#v", out)
+	}
+}
+
+// Un system inséré en fin de séquence (relance anti-boucle) ou en double doit
+// être ramené en un seul bloc, en tête : sinon les gabarits Qwen3.x renvoient
+// « System message must be at the beginning » (issue #26).
+func TestNormalizeSystemMessages(t *testing.T) {
+	sys := func(c string) Message { return Message{Role: "system", Content: c} }
+	usr := func(c string) Message { return Message{Role: "user", Content: c} }
+
+	firstRoleSystemOnce := func(t *testing.T, out []Message) {
+		count := 0
+		for i, m := range out {
+			if m.Role == "system" {
+				count++
+				if i != 0 {
+					t.Errorf("system trouvé en position %d, doit être en 0", i)
+				}
+			}
+		}
+		if count > 1 {
+			t.Errorf("%d messages system, doit être fusionné en un seul", count)
+		}
+	}
+
+	t.Run("system en fin", func(t *testing.T) {
+		out := normalizeSystemMessages([]Message{sys("A"), usr("q"), sys("stop")})
+		firstRoleSystemOnce(t, out)
+		if out[0].Content != "A\n\nstop" {
+			t.Errorf("fusion attendue 'A\\n\\nstop', obtenu %q", out[0].Content)
+		}
+		if len(out) != 2 {
+			t.Fatalf("attendu 2 messages, obtenu %d", len(out))
+		}
+	})
+
+	t.Run("sans system, inchangé", func(t *testing.T) {
+		in := []Message{usr("a"), usr("b")}
+		out := normalizeSystemMessages(in)
+		if len(out) != 2 || out[0].Role != "user" {
+			t.Fatalf("séquence sans system ne doit pas changer : %#v", out)
+		}
+	})
+
+	t.Run("system vide ignoré", func(t *testing.T) {
+		out := normalizeSystemMessages([]Message{sys("  "), usr("q")})
+		if len(out) != 1 || out[0].Role != "user" {
+			t.Fatalf("un system vide ne doit rien ajouter : %#v", out)
+		}
+	})
+}

internal/loki/relay_link.go

@@ -541,6 +541,18 @@ func newLinkHandler(mux *http.ServeMux) http.Handler {
 // à chaque requête de l'autre côté.
 func withLocalAuth(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// ⚠️ Marquage AVANT tout : on efface d'abord, sinon un client forge
+		// l'en-tête et se fait passer pour du trafic de tunnel (ou l'inverse).
+		r.Header.Del(viaTunnelHeader)
+		r.Header.Set(viaTunnelHeader, "tunnel")
+		// La surface des complétions a SA clé (celle du moteur, fournie par le
+		// client). Y injecter la clé de PILOTAGE la ferait refuser par la garde,
+		// et surtout la relaierait à llama-server — un secret d'administration
+		// envoyé à un process qui n'en a aucun usage.
+		if strings.HasPrefix(r.URL.Path, "/v1/") {
+			next.ServeHTTP(w, r)
+			return
+		}
 		if webKey := readWebKey(); webKey != "" && r.Header.Get("Authorization") == "" {
 			r.Header.Set("Authorization", "Bearer "+webKey)
 		}

internal/loki/store.go

@@ -33,6 +33,7 @@ const (
 	bkPrefs  = "prefs"  // préférences de l'UI web
 	bkState  = "state"  // clés, jetons, drapeaux, listes de dossiers, MCP
 	bkChat   = "chat"   // conversation partagée
+	bkTasks  = "tasks"  // tâches planifiées (une entrée JSON par tâche)
 )
 
 // La base n'est PAS gardée ouverte entre deux opérations, et c'est délibéré.

internal/loki/sys_brand_icon.go

@@ -2,12 +2,15 @@ package loki
 
 // sys_brand_icon.go — l'icône de la marque Loki, rendue à la volée.
 //
-// RÉPLIQUE EXACTE du favicon de l'UI web : carré à coins arrondis NOIR + « j »
+// RÉPLIQUE EXACTE du favicon de l'UI web : carré à coins arrondis SAUGE + « j »
 // blanc (rects (6,3) (6,5) (4,7) sur une grille 12x12). Une seule source pour
 // tous les usages — zone de notification Windows, barre de menus macOS, icône du
 // .exe — pour qu'ils ne puissent plus diverger comme quand le favicon est passé
 // au noir en laissant les icônes système en bleu.
 //
+// La sauge est --accent de l'interface (#5E7F5A) : l'icône de l'onglet et celle
+// du bureau portent la couleur de l'app, pas un carré noir anonyme.
+//
 // Aucun asset binaire à committer : tout est dessiné ici, et l'icône du .exe est
 // produite par `go generate ./cmd/loki` (voir tools/gen-icon).
 
@@ -22,6 +25,8 @@ import (
 const trayIconSize = 32
 
 var (
+	// brandSage = --accent du thème clair. Le blanc du « j » s'y lit à 4,9:1.
+	brandSage  = color.RGBA{0x5e, 0x7f, 0x5a, 0xff}
 	brandBlack = color.RGBA{0x00, 0x00, 0x00, 0xff}
 	brandWhite = color.RGBA{0xff, 0xff, 0xff, 0xff}
 	brandClear = color.RGBA{0, 0, 0, 0}
@@ -80,9 +85,9 @@ func encodePNG(img *image.RGBA) []byte {
 	return buf.Bytes()
 }
 
-// BrandIconPNG rend l'icône de marque (noir + « j » blanc) en PNG de n pixels.
+// BrandIconPNG rend l'icône de marque (sauge + « j » blanc) en PNG de n pixels.
 // Exporté pour le générateur d'icône du .exe (tools/gen-icon).
-func BrandIconPNG(n int) []byte { return encodePNG(brandIconImage(n, brandBlack, brandWhite)) }
+func BrandIconPNG(n int) []byte { return encodePNG(brandIconImage(n, brandSage, brandWhite)) }
 
 // brandTemplatePNG rend la variante « template » attendue par macOS : seule la
 // couche alpha compte, le système colore la forme selon le thème de la barre de

internal/loki/sys_datavolume.go

@@ -0,0 +1,67 @@
+package loki
+
+// sys_datavolume.go — garde-fou contre la PERTE DE DONNÉES en conteneur.
+//
+// Le symptôme vécu : modèles, discussions et fichiers disparus après un
+// redémarrage du serveur. La cause, dans tous les cas observés : /data n'est
+// PAS un volume monté (template Docker sans mapping, `docker run` sans -v,
+// chemin hôte qui change d'un lancement à l'autre). Tout vit alors dans la
+// couche d'écriture du conteneur, qui meurt avec lui à la première recréation
+// (mise à jour d'image, compose down/up, redémarrage de l'array Unraid).
+//
+// Loki ne peut pas monter le volume à la place de l'utilisateur, mais il peut
+// le VOIR et le DIRE : au démarrage en conteneur, si LOKI_HOME n'est pas un
+// point de montage, on le journalise en rouge et l'UI l'affiche en bandeau.
+
+import (
+	"bufio"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// dataDirIsMounted dit si LokiHome() est un point de montage (bind mount ou
+// volume Docker). Lecture de /proc/self/mountinfo — Linux seulement, or c'est
+// le seul endroit où Loki tourne en conteneur. Hors conteneur : sans objet.
+//
+// Renvoie (monté, connu) : connu=false quand on n'a pas pu lire mountinfo —
+// on ne crie pas au loup sur une simple erreur de lecture.
+func dataDirIsMounted() (mounted, known bool) {
+	f, err := os.Open("/proc/self/mountinfo")
+	if err != nil {
+		return false, false
+	}
+	defer f.Close()
+	target := filepath.Clean(LokiHome())
+	sc := bufio.NewScanner(f)
+	for sc.Scan() {
+		// Format mountinfo : champs séparés par des espaces, le 5ᵉ (index 4)
+		// est le point de montage. Les espaces dans les chemins sont encodés
+		// \040 — décodés avant comparaison.
+		fields := strings.Fields(sc.Text())
+		if len(fields) < 5 {
+			continue
+		}
+		mp := strings.ReplaceAll(fields[4], `\040`, " ")
+		if filepath.Clean(mp) == target {
+			return true, true
+		}
+	}
+	return false, sc.Err() == nil
+}
+
+// dataVolumeWarning renvoie le message d'alerte si les données sont en périple
+// ("" si tout va bien). Évalué au démarrage du serveur web et servi par
+// /api/status pour le bandeau de l'UI.
+func dataVolumeWarning() string {
+	if os.Getenv("LOKI_CONTAINER") == "" {
+		return "" // hors conteneur : l'utilisateur gère ses chemins
+	}
+	mounted, known := dataDirIsMounted()
+	if !known || mounted {
+		return ""
+	}
+	return "⚠️ " + LokiHome() + " n'est PAS un volume monté : modèles, discussions et fichiers seront PERDUS à la recréation du conteneur (mise à jour, redémarrage du serveur). " +
+		"Ajoute un mapping de volume — compose : « - /mnt/user/appdata/loki/data:/data » (et « …/models:/models ») ; " +
+		"docker run : « -v /chemin/hote/data:/data ». Voir docker-compose.unraid.yml du dépôt."
+}

internal/loki/sys_disk_fs_linux.go

@@ -0,0 +1,50 @@
+//go:build linux
+
+package loki
+
+// sys_disk_fs_linux.go — l'espace libre annoncé par le système est-il DIGNE DE
+// FOI pour décider d'un téléchargement ?
+//
+// Sur Unraid, les partages vivent sous /mnt/user, servi par shfs — un système
+// de fichiers FUSE qui agrège plusieurs disques et le cache. statfs(2) n'y
+// renvoie pas l'espace du partage : selon la configuration, c'est celui d'UN
+// disque, ou du pool de cache. Vécu : « il ne reste que 11,9 Go » sur une
+// machine qui en a des centaines de libres, et le téléchargement du modèle
+// REFUSÉ sur cette base.
+//
+// Même problème sur les montages réseau (NFS, CIFS) et sur la couche
+// d'écriture d'un conteneur (overlayfs), qui rapporte le disque virtuel Docker
+// et non le volume monté dessous.
+//
+// On ne cherche pas à corriger le chiffre — c'est impossible depuis l'intérieur
+// du conteneur. On sait juste dire « ce chiffre est indicatif », et on cesse
+// alors de bloquer sur lui.
+
+import "syscall"
+
+// Magies de systèmes de fichiers dont statfs ment (ou approxime) sur l'espace
+// libre. Valeurs de <linux/magic.h>.
+const (
+	fuseSuperMagic    = 0x65735546 // FUSE — shfs d'Unraid, sshfs, rclone…
+	overlayfsMagic    = 0x794c7630 // couche d'écriture d'un conteneur
+	nfsSuperMagic     = 0x6969
+	smbSuperMagic     = 0x517b     // CIFS/SMB1
+	smb2MagicNumber   = 0xfe534d42 // CIFS/SMB2+
+	cephSuperMagic    = 0x00c36400
+	glusterfsSuperMag = 0x58465342
+)
+
+// diskFreeReliable dit si l'espace libre rapporté pour dir peut servir à
+// REFUSER une écriture. false = on affiche le chiffre, mais on ne bloque plus.
+func diskFreeReliable(dir string) bool {
+	var st syscall.Statfs_t
+	if err := syscall.Statfs(dir, &st); err != nil {
+		return false
+	}
+	switch uint32(st.Type) {
+	case fuseSuperMagic, overlayfsMagic, nfsSuperMagic,
+		smbSuperMagic, smb2MagicNumber, cephSuperMagic, glusterfsSuperMag:
+		return false
+	}
+	return true
+}

internal/loki/sys_disk_fs_other.go

@@ -0,0 +1,8 @@
+//go:build !linux
+
+package loki
+
+// Hors Linux, on n'a pas de table de magies de systèmes de fichiers à
+// consulter : l'espace libre rapporté est considéré comme fiable (c'est le cas
+// des volumes locaux Windows et macOS, les seules cibles concernées ici).
+func diskFreeReliable(string) bool { return true }

internal/loki/sys_loadpct_linux.go

@@ -0,0 +1,76 @@
+//go:build linux
+
+package loki
+
+// sys_loadpct_linux.go — pourcentage de CHARGEMENT du modèle, pour la pastille
+// « chargement… » de l'UI qui restait muette de longues minutes sur un gros
+// GGUF (un 27B Q4 met facilement 1 à 3 minutes à monter en VRAM).
+//
+// llama-server n'expose aucun progrès pendant le chargement (/health renvoie
+// juste 503). Mais le chargement, c'est LIRE le fichier .gguf : on mesure donc
+// les octets lus par le process moteur (/proc/<pid>/io, read_bytes — les pages
+// mmap rentrées comptent dedans) et on les rapporte à la taille du fichier.
+// Approximation honnête : monotone, ~0→100, et surtout elle BOUGE — c'est ce
+// qui distingue « ça charge » de « c'est planté ».
+
+import (
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+// engineLoadPct renvoie le pourcentage estimé de chargement du modèle, ou -1
+// quand il n'est pas mesurable (pas de PID, /proc illisible, taille inconnue).
+func engineLoadPct() int {
+	pid := readServicePID()
+	if pid <= 0 {
+		return -1
+	}
+	cfg := ReadConfig()
+	model := cfg["MODEL"]
+	if model == "" {
+		return -1
+	}
+	path, err := resolveServeModelPath(model)
+	if err != nil {
+		return -1
+	}
+	size := modelTotalSize(path)
+	if size <= 0 {
+		return -1
+	}
+	b, err := os.ReadFile("/proc/" + strconv.Itoa(pid) + "/io")
+	if err != nil {
+		return -1
+	}
+	var read int64 = -1
+	for _, line := range strings.Split(string(b), "\n") {
+		if v, ok := strings.CutPrefix(line, "read_bytes:"); ok {
+			read, _ = strconv.ParseInt(strings.TrimSpace(v), 10, 64)
+			break
+		}
+	}
+	if read < 0 {
+		return -1
+	}
+	pct := int(read * 100 / size)
+	if pct > 99 {
+		// 100 % n'existe pas ici : c'est /health qui dit « prêt ». Au-delà de 99
+		// (relectures, autres IO du process), on plafonne.
+		pct = 99
+	}
+	return pct
+}
+
+// modelTotalSize : taille du modèle, shards compris (model-00001-of-00004.gguf
+// → somme des tranches présentes — c'est tout ça qu'il faut charger).
+func modelTotalSize(path string) int64 {
+	if total := shardFamilySize(filepath.Dir(path), filepath.Base(path)); total > 0 {
+		return total
+	}
+	if st, err := os.Stat(path); err == nil {
+		return st.Size()
+	}
+	return 0
+}

internal/loki/sys_loadpct_other.go

@@ -0,0 +1,7 @@
+//go:build !linux
+
+package loki
+
+// Hors Linux, pas de /proc/<pid>/io : le pourcentage de chargement n'est pas
+// mesurable, l'UI garde « chargement… » sans chiffre.
+func engineLoadPct() int { return -1 }

internal/loki/sys_platform_unix.go

@@ -262,6 +262,12 @@ func newShellCmd(ctx context.Context, command string) *exec.Cmd {
 	return exec.CommandContext(ctx, "/bin/bash", "-c", command)
 }
 
+// newShellCmdDetached : commande shell SANS contexte, pour les jobs
+// d'arrière-plan (bash_bg) qui doivent survivre au tour qui les a lancés.
+func newShellCmdDetached(command string) *exec.Cmd {
+	return exec.Command("/bin/bash", "-c", command)
+}
+
 // ramUsageMB renvoie (utilisée, totale) en Mo pour /api/ram. Linux : /proc/meminfo.
 // macOS : sysctl pour le total, vm_stat pour ce qui est réellement libre (pages
 // free + inactive + speculative ; le reste — wired, active, compressé — est

internal/loki/sys_platform_windows.go

@@ -391,6 +391,12 @@ func newShellCmd(ctx context.Context, command string) *exec.Cmd {
 	return hideCmd(exec.CommandContext(ctx, "cmd", "/C", command))
 }
 
+// newShellCmdDetached : commande shell SANS contexte, pour les jobs
+// d'arrière-plan (bash_bg) qui doivent survivre au tour qui les a lancés.
+func newShellCmdDetached(command string) *exec.Cmd {
+	return hideCmd(exec.Command("cmd", "/C", command))
+}
+
 // ramUsageMB renvoie (utilisée, totale) en Mo pour /api/ram (GlobalMemoryStatusEx).
 func ramUsageMB() (used, total int) {
 	var m struct {

internal/loki/sys_service.go

@@ -75,6 +75,13 @@ var configTemplate = []struct{ key, help string }{
 	{"KV_TYPE", "quantization du cache KV (q8_0, q4_0…) ; KV_TYPE_K / KV_TYPE_V pour les séparer"},
 	{"REASONING", "passthrough du mode raisonnement (on/auto/deepseek)"},
 	{"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"},
+	{"TOP_P", "noyau de probabilité (top_p) ; vide = défaut du moteur"},
+	{"TOP_K", "top_k ; 0 = désactivé, vide = défaut du moteur"},
+	{"MIN_P", "seuil de probabilité (min_p) ; vide = défaut du moteur"},
+	{"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)"},
 	{"MEM_MODE", "mémoire de l'IA : off / ondemand / always"},
 	{"EXTRA_ARGS", "ajouté tel quel à la ligne de commande de llama-server"},

internal/loki/tasks.go

@@ -0,0 +1,102 @@
+package loki
+
+// tasks.go — les tâches planifiées : des consignes que l'IA exécute toute seule,
+// en arrière-plan, sur une fréquence réglable (intervalle simple ou cron). Chaque
+// tâche tourne ISOLÉE de la conversation partagée (voir RunAutonomous dans
+// tasks_run.go) : elle ne pollue pas le chat et livre son résultat via les propres
+// outils de l'IA (mail via MCP, shell, web…). L'utilisateur peut désactiver une
+// tâche, ou tout suspendre d'un coup via l'interrupteur maître (tasks_paused).
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"encoding/json"
+	"sort"
+	"time"
+
+	bolt "go.etcd.io/bbolt"
+)
+
+// Task est une tâche planifiée persistée dans le bucket bkTasks (clé = ID).
+type Task struct {
+	ID       string `json:"id"`
+	Name     string `json:"name"`
+	Prompt   string `json:"prompt"`
+	Schedule string `json:"schedule"` // "@every 2h" | "@every 1d@23:00" | expr cron 5 champs
+	TZ       string `json:"tz"`       // fuseau IANA du navigateur (ex. "Europe/Paris") pour l'heure
+	Preset   string `json:"preset"`   // id du preset à activer avant l'exécution (vide = preset actif)
+	// Accès de la tâche. On stocke la NÉGATION (« pas de… ») pour que le zéro JSON
+	// (tâches créées avant ces champs) garde le comportement historique : accès.
+	NoMem      bool   `json:"no_mem"` // true = pas d'accès à la mémoire pour cette tâche
+	NoWeb      bool   `json:"no_web"` // true = pas d'accès au web pour cette tâche
+	Enabled    bool   `json:"enabled"`
+	LastRun    int64  `json:"last_run"`    // epoch ms, 0 = jamais
+	NextRun    int64  `json:"next_run"`    // epoch ms, 0 = à (re)calculer
+	LastDurMs  int64  `json:"last_dur_ms"` // durée du dernier passage en ms
+	LastOK     bool   `json:"last_ok"`
+	LastError  string `json:"last_error"`
+	LastReport string `json:"last_report"` // dernier texte final de l'IA (compte-rendu court)
+
+	Running bool `json:"-"` // transitoire : une exécution est en cours
+}
+
+// newTaskID génère un identifiant court et unique.
+func newTaskID() string {
+	var b [6]byte
+	_, _ = rand.Read(b[:])
+	return hex.EncodeToString(b[:])
+}
+
+// listTasks renvoie toutes les tâches, triées par nom pour un affichage stable.
+func listTasks() []Task {
+	var out []Task
+	_ = view(bkTasks, func(b *bolt.Bucket) error {
+		return b.ForEach(func(_, v []byte) error {
+			var t Task
+			if json.Unmarshal(v, &t) == nil {
+				out = append(out, t)
+			}
+			return nil
+		})
+	})
+	sort.Slice(out, func(i, j int) bool {
+		if out[i].Name != out[j].Name {
+			return out[i].Name < out[j].Name
+		}
+		return out[i].ID < out[j].ID
+	})
+	return out
+}
+
+// getTask lit une tâche par ID. Renvoie false si absente.
+func getTask(id string) (Task, bool) {
+	var t Task
+	ok := getJSON(bkTasks, id, &t)
+	return t, ok
+}
+
+// saveTask enregistre (crée ou remplace) une tâche.
+func saveTask(t Task) error { return putJSON(bkTasks, t.ID, t) }
+
+// deleteTask supprime une tâche par ID.
+func deleteTask(id string) error { return putBytes(bkTasks, id, nil) }
+
+// tasksPaused indique si l'interrupteur maître suspend TOUTES les tâches. On
+// stocke « en pause » plutôt que « actif » pour que l'état par défaut (base
+// neuve) soit « actif » sans dépendre d'une écriture : c'est un frein, pas un
+// moteur.
+func tasksPaused() bool { return getBool(bkState, "tasks_paused") }
+
+func setTasksPaused(on bool) error { return putBool(bkState, "tasks_paused", on) }
+
+// computeNextRun calcule le prochain déclenchement d'une tâche à partir de son
+// Schedule (dans le fuseau tz), relatif à `from`. Renvoie 0 si le schedule est
+// invalide (la tâche ne se déclenchera alors jamais — l'UI refuse déjà un
+// schedule invalide à la sauvegarde, ceci n'est qu'un garde-fou).
+func computeNextRun(schedule, tz string, from time.Time) int64 {
+	next, err := nextAfter(schedule, tz, from)
+	if err != nil {
+		return 0
+	}
+	return next.UnixMilli()
+}

internal/loki/tasks_cron.go

@@ -0,0 +1,251 @@
+package loki
+
+// tasks_cron.go — planification des tâches, résolution à la minute. Deux formes :
+//
+//   - Intervalle : "@every <durée>" (ex. "@every 2h", "@every 30m"), parsé par
+//     time.ParseDuration, borné à ≥ 1 minute.
+//   - Cron : 5 champs "min hour dom month dow" avec *, listes a,b, plages a-b et
+//     pas */n (ex. "0 9 * * 1-5" = 9h du lundi au vendredi).
+//
+// Aucune dépendance externe : Go n'a pas de lib cron et on n'en ajoute pas pour
+// si peu. nextAfter avance minute par minute jusqu'au prochain match — largement
+// assez rapide pour une poignée de tâches évaluées une fois par minute.
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// minInterval borne la fréquence : sous la minute, le scheduler (ticker 60 s) ne
+// pourrait de toute façon pas suivre, et une tâche qui lance une inférence toutes
+// les quelques secondes n'a pas de sens.
+const minInterval = time.Minute
+
+// loc résout un fuseau IANA (ex. « Europe/Paris »). Vide ou introuvable → heure
+// locale du serveur. Nécessaire parce que le serveur tourne souvent en UTC : sans
+// ça, « tous les jours à 23h » et les expressions cron se calculeraient en UTC et
+// se déclencheraient à la mauvaise heure pour l'utilisateur.
+func loc(tz string) *time.Location {
+	if tz == "" {
+		return time.Local
+	}
+	l, err := time.LoadLocation(tz)
+	if err != nil {
+		return time.Local
+	}
+	return l
+}
+
+// nextAfter renvoie le prochain instant (strictement après `from`) où `schedule`
+// se déclenche, dans le fuseau tz. Erreur si le schedule est invalide.
+//
+// Formes acceptées :
+//   - "@every 30m" / "@every 2h" : intervalle glissant depuis `from`.
+//   - "@every 1d@23:00" : tous les N jours, ancré à une heure de la journée.
+//   - expression cron 5 champs.
+func nextAfter(schedule, tz string, from time.Time) (time.Time, error) {
+	s := strings.TrimSpace(schedule)
+	if s == "" {
+		return time.Time{}, fmt.Errorf("fréquence vide")
+	}
+	if rest, ok := cutPrefix(s, "@every"); ok {
+		return nextEvery(strings.TrimSpace(rest), tz, from)
+	}
+	return nextCron(s, tz, from)
+}
+
+// nextEvery gère les intervalles « @every … », avec ou sans ancre horaire.
+func nextEvery(spec, tz string, from time.Time) (time.Time, error) {
+	durPart, timePart, hasTime := strings.Cut(spec, "@")
+	durPart = strings.TrimSpace(durPart)
+
+	// Jours : time.ParseDuration ne connaît pas « d ». On les gère à part, ce qui
+	// permet aussi l'ancre horaire (« tous les N jours à HH:MM »).
+	if n, ok := cutSuffix(durPart, "d"); ok {
+		days, err := strconv.Atoi(n)
+		if err != nil || days < 1 {
+			return time.Time{}, fmt.Errorf("nombre de jours invalide : %q", durPart)
+		}
+		if !hasTime {
+			return from.Add(time.Duration(days) * 24 * time.Hour), nil
+		}
+		hh, mm, err := parseHHMM(timePart)
+		if err != nil {
+			return time.Time{}, err
+		}
+		l := loc(tz)
+		now := from.In(l)
+		cand := time.Date(now.Year(), now.Month(), now.Day(), hh, mm, 0, 0, l)
+		for !cand.After(now) {
+			cand = cand.AddDate(0, 0, days)
+		}
+		return cand, nil
+	}
+
+	d, err := time.ParseDuration(durPart)
+	if err != nil {
+		return time.Time{}, fmt.Errorf("intervalle invalide (ex. « 2h », « 30m ») : %w", err)
+	}
+	if d < minInterval {
+		return time.Time{}, fmt.Errorf("intervalle minimum : 1 minute")
+	}
+	return from.Add(d), nil
+}
+
+// parseHHMM lit « 23:00 » / « 9:30 » en heures/minutes.
+func parseHHMM(s string) (int, int, error) {
+	hs, ms, ok := strings.Cut(strings.TrimSpace(s), ":")
+	if !ok {
+		return 0, 0, fmt.Errorf("heure invalide (attendu HH:MM) : %q", s)
+	}
+	h, err1 := strconv.Atoi(strings.TrimSpace(hs))
+	m, err2 := strconv.Atoi(strings.TrimSpace(ms))
+	if err1 != nil || err2 != nil || h < 0 || h > 23 || m < 0 || m > 59 {
+		return 0, 0, fmt.Errorf("heure hors bornes : %q", s)
+	}
+	return h, m, nil
+}
+
+// cutSuffix : strings.CutSuffix (Go 1.20+) réécrit pour rester lisible ici.
+func cutSuffix(s, suffix string) (string, bool) {
+	if strings.HasSuffix(s, suffix) {
+		return s[:len(s)-len(suffix)], true
+	}
+	return "", false
+}
+
+// validateSchedule vérifie qu'un schedule est acceptable, sans calculer de date.
+func validateSchedule(schedule, tz string) error {
+	_, err := nextAfter(schedule, tz, time.Now())
+	return err
+}
+
+// cronSpec = les 5 champs compilés en ensembles de valeurs autorisées.
+type cronSpec struct {
+	min, hour, dom, month, dow map[int]bool
+}
+
+// nextCron parse une expression cron 5 champs et cherche le prochain match à la
+// minute, en partant de la minute qui suit `from`. Une borne (~366 j) évite une
+// boucle infinie sur une expression jamais satisfiable (ex. « 31 février »).
+func nextCron(expr, tz string, from time.Time) (time.Time, error) {
+	spec, err := parseCron(expr)
+	if err != nil {
+		return time.Time{}, err
+	}
+	// On repart de la minute suivante, dans le fuseau visé (l'heure murale de
+	// l'expression cron est celle de l'utilisateur, pas celle du serveur).
+	t := from.In(loc(tz)).Truncate(time.Minute).Add(time.Minute)
+	limit := t.Add(366 * 24 * time.Hour)
+	for ; t.Before(limit); t = t.Add(time.Minute) {
+		if spec.matches(t) {
+			return t, nil
+		}
+	}
+	return time.Time{}, fmt.Errorf("fréquence jamais satisfaite : %q", expr)
+}
+
+func (s cronSpec) matches(t time.Time) bool {
+	return s.min[t.Minute()] &&
+		s.hour[t.Hour()] &&
+		s.dom[t.Day()] &&
+		s.month[int(t.Month())] &&
+		s.dow[int(t.Weekday())]
+}
+
+func parseCron(expr string) (cronSpec, error) {
+	f := strings.Fields(expr)
+	if len(f) != 5 {
+		return cronSpec{}, fmt.Errorf("cron : 5 champs attendus « min heure jour mois jour-semaine », reçu %d", len(f))
+	}
+	var s cronSpec
+	var err error
+	if s.min, err = parseField(f[0], 0, 59); err != nil {
+		return cronSpec{}, fmt.Errorf("champ minute : %w", err)
+	}
+	if s.hour, err = parseField(f[1], 0, 23); err != nil {
+		return cronSpec{}, fmt.Errorf("champ heure : %w", err)
+	}
+	if s.dom, err = parseField(f[2], 1, 31); err != nil {
+		return cronSpec{}, fmt.Errorf("champ jour-du-mois : %w", err)
+	}
+	if s.month, err = parseField(f[3], 1, 12); err != nil {
+		return cronSpec{}, fmt.Errorf("champ mois : %w", err)
+	}
+	// Jour de la semaine : 0 ET 7 valent dimanche. On normalise 7 → 0.
+	if s.dow, err = parseField(f[4], 0, 7); err != nil {
+		return cronSpec{}, fmt.Errorf("champ jour-semaine : %w", err)
+	}
+	if s.dow[7] {
+		s.dow[0] = true
+	}
+	return s, nil
+}
+
+// parseField compile un champ cron (*, a, a-b, a,b, */n, a-b/n) en l'ensemble des
+// valeurs autorisées dans [lo, hi].
+func parseField(field string, lo, hi int) (map[int]bool, error) {
+	out := map[int]bool{}
+	for _, part := range strings.Split(field, ",") {
+		rng := part
+		step := 1
+		if base, st, ok := strings.Cut(part, "/"); ok {
+			n, err := strconv.Atoi(st)
+			if err != nil || n < 1 {
+				return nil, fmt.Errorf("pas invalide : %q", part)
+			}
+			step = n
+			rng = base
+		}
+		start, end := lo, hi
+		if rng != "*" {
+			if a, b, ok := strings.Cut(rng, "-"); ok {
+				var err error
+				if start, err = atoiRange(a, lo, hi); err != nil {
+					return nil, err
+				}
+				if end, err = atoiRange(b, lo, hi); err != nil {
+					return nil, err
+				}
+			} else {
+				v, err := atoiRange(rng, lo, hi)
+				if err != nil {
+					return nil, err
+				}
+				start, end = v, v
+			}
+		}
+		if start > end {
+			return nil, fmt.Errorf("plage inversée : %q", part)
+		}
+		for v := start; v <= end; v += step {
+			out[v] = true
+		}
+	}
+	if len(out) == 0 {
+		return nil, fmt.Errorf("champ vide")
+	}
+	return out, nil
+}
+
+func atoiRange(s string, lo, hi int) (int, error) {
+	v, err := strconv.Atoi(strings.TrimSpace(s))
+	if err != nil {
+		return 0, fmt.Errorf("valeur invalide : %q", s)
+	}
+	if v < lo || v > hi {
+		return 0, fmt.Errorf("valeur %d hors bornes [%d-%d]", v, lo, hi)
+	}
+	return v, nil
+}
+
+// cutPrefix reconnaît le préfixe "@every" (insensible à la casse) et renvoie le
+// reste. strings.CutPrefix existe (Go 1.20+) mais est sensible à la casse.
+func cutPrefix(s, prefix string) (string, bool) {
+	if len(s) >= len(prefix) && strings.EqualFold(s[:len(prefix)], prefix) {
+		return s[len(prefix):], true
+	}
+	return "", false
+}

internal/loki/tasks_cron_test.go

@@ -0,0 +1,142 @@
+package loki
+
+import (
+	"testing"
+	"time"
+)
+
+func TestNextAfterInterval(t *testing.T) {
+	from := time.Date(2026, 8, 15, 10, 0, 0, 0, time.UTC)
+	got, err := nextAfter("@every 2h", "", from)
+	if err != nil {
+		t.Fatalf("erreur inattendue : %v", err)
+	}
+	want := from.Add(2 * time.Hour)
+	if !got.Equal(want) {
+		t.Fatalf("@every 2h : got %v, want %v", got, want)
+	}
+	// Casse tolérée sur le préfixe.
+	if _, err := nextAfter("@EVERY 30m", "", from); err != nil {
+		t.Fatalf("@EVERY 30m devrait être valide : %v", err)
+	}
+	// Sous la minute → refusé.
+	if _, err := nextAfter("@every 10s", "", from); err == nil {
+		t.Fatalf("@every 10s aurait dû être refusé")
+	}
+	if _, err := nextAfter("@every pouet", "", from); err == nil {
+		t.Fatalf("durée invalide aurait dû être refusée")
+	}
+}
+
+func TestNextEveryDays(t *testing.T) {
+	from := time.Date(2026, 8, 15, 10, 0, 0, 0, time.UTC)
+	// Sans ancre horaire : intervalle glissant de N*24h.
+	got, err := nextAfter("@every 3d", "", from)
+	if err != nil {
+		t.Fatalf("erreur : %v", err)
+	}
+	if want := from.Add(72 * time.Hour); !got.Equal(want) {
+		t.Fatalf("@every 3d : got %v, want %v", got, want)
+	}
+}
+
+func TestNextEveryDayAtTime(t *testing.T) {
+	// « tous les 1 jour à 23:00 », fuseau Europe/Paris (CEST = UTC+2 en août).
+	from := time.Date(2026, 8, 15, 20, 0, 0, 0, time.UTC) // 22h à Paris
+	got, err := nextAfter("@every 1d@23:00", "Europe/Paris", from)
+	if err != nil {
+		t.Fatalf("erreur : %v", err)
+	}
+	// 23:00 Paris le 15 = 21:00 UTC.
+	want := time.Date(2026, 8, 15, 21, 0, 0, 0, time.UTC)
+	if !got.Equal(want) {
+		t.Fatalf("@every 1d@23:00 : got %v, want %v", got.UTC(), want)
+	}
+	// Après 23:00 Paris → le lendemain.
+	from2 := time.Date(2026, 8, 15, 21, 30, 0, 0, time.UTC) // 23h30 Paris
+	got2, _ := nextAfter("@every 1d@23:00", "Europe/Paris", from2)
+	want2 := time.Date(2026, 8, 16, 21, 0, 0, 0, time.UTC)
+	if !got2.Equal(want2) {
+		t.Fatalf("lendemain : got %v, want %v", got2.UTC(), want2)
+	}
+}
+
+func TestNextCronEveryQuarter(t *testing.T) {
+	from := time.Date(2026, 8, 15, 10, 7, 30, 0, time.UTC)
+	got, err := nextAfter("*/15 * * * *", "", from)
+	if err != nil {
+		t.Fatalf("erreur : %v", err)
+	}
+	want := time.Date(2026, 8, 15, 10, 15, 0, 0, time.UTC)
+	if !got.Equal(want) {
+		t.Fatalf("*/15 : got %v, want %v", got, want)
+	}
+}
+
+func TestNextCronWeekdayMorning(t *testing.T) {
+	// 2026-08-15 est un samedi. « 0 9 * * 1-5 » → lundi 17 août 09:00.
+	from := time.Date(2026, 8, 15, 12, 0, 0, 0, time.UTC)
+	got, err := nextAfter("0 9 * * 1-5", "UTC", from)
+	if err != nil {
+		t.Fatalf("erreur : %v", err)
+	}
+	want := time.Date(2026, 8, 17, 9, 0, 0, 0, time.UTC)
+	if !got.Equal(want) {
+		t.Fatalf("0 9 * * 1-5 : got %v, want %v", got, want)
+	}
+}
+
+func TestNextCronInParisTZ(t *testing.T) {
+	// « 0 9 * * * » à Paris = 07:00 UTC en été.
+	from := time.Date(2026, 8, 15, 0, 0, 0, 0, time.UTC)
+	got, err := nextAfter("0 9 * * *", "Europe/Paris", from)
+	if err != nil {
+		t.Fatalf("erreur : %v", err)
+	}
+	want := time.Date(2026, 8, 15, 7, 0, 0, 0, time.UTC)
+	if !got.Equal(want) {
+		t.Fatalf("cron TZ : got %v, want %v", got.UTC(), want)
+	}
+}
+
+func TestNextCronSundayBothForms(t *testing.T) {
+	from := time.Date(2026, 8, 15, 0, 0, 0, 0, time.UTC) // samedi
+	got, err := nextAfter("0 0 * * 7", "UTC", from)
+	if err != nil {
+		t.Fatalf("erreur : %v", err)
+	}
+	want := time.Date(2026, 8, 16, 0, 0, 0, 0, time.UTC)
+	if !got.Equal(want) {
+		t.Fatalf("dow=7 : got %v, want %v", got, want)
+	}
+}
+
+func TestParseCronInvalid(t *testing.T) {
+	cases := []string{
+		"",
+		"* * * *",         // 4 champs
+		"* * * * * *",     // 6 champs
+		"60 * * * *",      // minute hors bornes
+		"* 24 * * *",      // heure hors bornes
+		"5-1 * * * *",     // plage inversée
+		"*/0 * * * *",     // pas nul
+		"abc * * * *",     // non numérique
+		"@every",          // durée absente
+		"@every 1d@25:00", // heure hors bornes
+		"@every 0d@10:00", // zéro jour
+	}
+	for _, c := range cases {
+		if err := validateSchedule(c, ""); err == nil {
+			t.Errorf("schedule %q aurait dû être refusé", c)
+		}
+	}
+}
+
+func TestValidateScheduleOK(t *testing.T) {
+	cases := []string{"@every 1m", "@every 2h", "@every 3d", "@every 1d@23:00", "0 */2 * * *", "30 8 * * 1-5", "0 0 1 * *"}
+	for _, c := range cases {
+		if err := validateSchedule(c, "Europe/Paris"); err != nil {
+			t.Errorf("schedule %q aurait dû être valide : %v", c, err)
+		}
+	}
+}

internal/loki/tasks_run.go

@@ -0,0 +1,269 @@
+package loki
+
+// tasks_run.go — exécution d'une tâche, ISOLÉE de la discussion ouverte.
+// Repris de l'amont AJEAN (v0.9.9 → v0.10.2), adapté au fonctionnement de loki
+// (dossier de travail par discussion, modes de la machine).
+//
+// Une tâche ne doit ni apparaître dans le chat, ni casser le rejeu SSE, ni entrer
+// en collision avec un tour utilisateur. On ne partage donc qu'UN SEUL point avec
+// la conversation : son verrou de génération (conv.Generating), qui garantit
+// qu'une seule inférence tourne à la fois — llama-server est lancé en
+// --parallel 1. Tout le reste — messages, journal d'affichage — n'est jamais
+// touché : la tâche construit son propre fil éphémère et le jette à la fin, ne
+// gardant que le texte final comme compte-rendu.
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+// RunAutonomous exécute un prompt en arrière-plan, sans laisser de trace dans la
+// discussion ouverte, et renvoie le texte final produit par l'IA (le compte-rendu).
+// Prend le MÊME verrou que StartTurn : renvoie ErrBusy si un tour (utilisateur ou
+// une autre tâche) est déjà en cours, ou errModelLoading si le modèle n'est pas
+// prêt. caps gouverne l'accès aux outils (agent, mémoire, internet).
+// lastReport est le compte-rendu du passage précédent (vide au premier) : il est
+// réinjecté pour donner à l'IA une continuité d'une exécution à l'autre.
+func (c *Conversation) RunAutonomous(ctx context.Context, taskID, taskName, prompt, lastReport string, caps Caps, temperature float64) (string, error) {
+	if !healthCheck() {
+		return "", errModelLoading
+	}
+	// Contexte annulable propre à la tâche, exposé via c.cancel : le bouton stop
+	// du chat (/api/chat/stop → conv.Stop) interrompt donc VRAIMENT une tâche de
+	// fond, au lieu de l'afficher « en cours » sans pouvoir l'arrêter.
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+	c.mu.Lock()
+	if c.Generating {
+		c.mu.Unlock()
+		return "", ErrBusy
+	}
+	c.Generating = true
+	c.cancel = cancel
+	c.runningTaskID = taskID
+	c.runningTaskName = taskName
+	c.mu.Unlock()
+	// Libère le verrou quoi qu'il arrive. On ne touche NI c.Messages NI c.Log NI
+	// c.epoch : la discussion ouverte reste totalement à l'écart.
+	defer func() {
+		c.mu.Lock()
+		c.Generating = false
+		c.cancel = nil
+		c.runningTaskID = ""
+		c.runningTaskName = ""
+		c.mu.Unlock()
+	}()
+
+	// Dossier de travail de la tâche : le sien, pas celui de la discussion
+	// ouverte (chat_workspace.go). Stable d'un passage à l'autre — une tâche qui
+	// tient un fichier de suivi le retrouve la fois suivante.
+	setTaskWorkspace(taskWorkspaceDir(taskID))
+	defer setTaskWorkspace("")
+
+	if temperature == 0 {
+		temperature = 0.7
+	}
+	msgs := []Message{{Role: "user", Content: prompt}}
+	// Même préambule que la vraie génération : consigne personnelle + préambule
+	// agent + briefing machine (via InjectSkills), pour que l'IA ait le même
+	// contexte et les mêmes outils qu'en chat. On préfixe le tout d'une note de
+	// contexte (conscience du mode autonome + mémoire du passage précédent),
+	// fusionnée dans UN SEUL message système en tête — comme l'exigent les
+	// gabarits stricts (normalizeSystemMessages le garantit de toute façon).
+	final := msgs
+	sys := readSysPrompt()
+	note := taskContextNote(taskName, lastReport)
+	switch {
+	case sys != "" && note != "":
+		final = append([]Message{{Role: "system", Content: sys + "\n\n" + note}}, msgs...)
+	case sys != "":
+		final = append([]Message{{Role: "system", Content: sys}}, msgs...)
+	case note != "":
+		final = append([]Message{{Role: "system", Content: note}}, msgs...)
+	}
+
+	var content strings.Builder
+	_, err := runChat(ctx, InjectSkills(final, caps), temperature, caps, func(ev StreamEvent) bool {
+		if ev.Content != "" {
+			content.WriteString(ev.Content)
+		}
+		return true
+	})
+	// Les messages d'outils ne sont pas conservés : la tâche est éphémère, seul
+	// son compte-rendu survit.
+	return strings.TrimSpace(content.String()), err
+}
+
+// taskWorkspaceDir donne (et crée) le dossier de travail d'une tâche, sous la
+// racine du dossier de travail — jamais dans le dossier d'une discussion, dont
+// il partagerait le sort à la suppression.
+func taskWorkspaceDir(taskID string) string {
+	root := agentWorkspace()
+	if taskID == "" {
+		return root
+	}
+	dir := filepath.Join(root, "tasks", taskID)
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		return root
+	}
+	return dir
+}
+
+// taskContextNote construit la note de contexte injectée en tête du fil d'une
+// tâche : d'abord la conscience du mode (l'IA tourne seule, sans utilisateur en
+// face), puis — s'il existe — le compte-rendu du passage précédent, pour la
+// continuité.
+func taskContextNote(taskName, lastReport string) string {
+	var b strings.Builder
+	b.WriteString("[Tâche planifiée")
+	if taskName != "" {
+		b.WriteString(" « " + taskName + " »")
+	}
+	b.WriteString("] Tu es exécuté automatiquement en arrière-plan, sans utilisateur " +
+		"présent pour te répondre. Mène la tâche à son terme de façon autonome, puis " +
+		"termine par un compte-rendu clair et court de ce que tu as fait ou trouvé.")
+	if r := strings.TrimSpace(lastReport); r != "" {
+		if len(r) > reportMax {
+			r = r[:reportMax] + "…"
+		}
+		b.WriteString("\n\nCompte-rendu de ta dernière exécution (pour la continuité — " +
+			"appuie-toi dessus, ne le répète pas tel quel) :\n" + r)
+	}
+	return b.String()
+}
+
+// reportMax borne la taille du compte-rendu conservé : le texte final peut être
+// long, on n'en garde qu'un aperçu pour l'interface et pour la relance suivante.
+const reportMax = 4000
+
+// runTask exécute une tâche et met à jour son état persisté (dernier passage,
+// prochain passage, succès/échec, compte-rendu).
+func runTask(t Task) {
+	start := time.Now()
+
+	// Preset épinglé : on bascule le moteur dessus AVANT d'exécuter (rechargement
+	// du modèle). Vide = on garde le preset actif. Un échec de bascule est un vrai
+	// échec de la tâche : la faire tourner sur le mauvais modèle serait pire.
+	if err := ensureTaskPreset(t.Preset); err != nil {
+		recordTaskEnd(t.ID, start, "", fmt.Errorf("changement de preset : %w", err))
+		return
+	}
+
+	report, err := conv.RunAutonomous(context.Background(), t.ID, t.Name, t.Prompt, t.LastReport, taskCaps(t), 0)
+
+	// Occupé, ou modèle pas encore prêt : ce n'est pas un échec de la tâche, juste
+	// un mauvais moment. On ne touche pas à son état (NextRun reste dans le passé)
+	// pour qu'elle soit réessayée au tick suivant.
+	if err == ErrBusy || err == errModelLoading {
+		return
+	}
+	recordTaskEnd(t.ID, start, report, err)
+}
+
+// taskCaps dérive les capacités d'une tâche : on part du mode agent de la machine
+// (qui débloque les outils), puis on applique les réglages propres à la tâche pour
+// la mémoire et le web. Le web reste borné à ce que la machine offre réellement
+// (serveur Crawl4AI configuré et joignable) : une tâche ne peut pas l'inventer.
+//
+// Le mode code reste OFF : c'est un mode de discussion (rôles, critères,
+// vérification, puces dans le fil) qui n'a pas de sens sans personne en face.
+func taskCaps(t Task) Caps {
+	// Mem posé EXPLICITEMENT à MemOff : le zéro de MemMode est la chaîne vide,
+	// que EnabledTools ne reconnaît pas comme « coupée » (il compare à MemOff) —
+	// une tâche sans agent se serait donc vu offrir les outils mem_*.
+	c := Caps{Agent: agentEnabled(), Mem: MemOff}
+	if !c.Agent {
+		return c // agent coupé : aucun outil, mémoire et web n'ont plus de sens
+	}
+	if t.NoWeb {
+		c.Internet = false
+	} else {
+		c.Internet = internetEnabled() && crawlReachable()
+	}
+	if t.NoMem {
+		c.Mem = MemOff
+	} else if m := memMode(); m == MemOff {
+		// La tâche veut la mémoire mais la machine l'a coupée globalement : on donne
+		// au moins les outils à la demande, sans l'injection proactive.
+		c.Mem = MemOnDemand
+	} else {
+		c.Mem = m
+	}
+	return c
+}
+
+// ensureTaskPreset bascule le moteur sur le preset d'id `id` s'il n'est pas déjà
+// actif, puis attend que le modèle ait rechargé. Vide = rien à faire.
+func ensureTaskPreset(id string) error {
+	if id == "" {
+		return nil
+	}
+	list, err := ListPresets()
+	if err != nil {
+		return err
+	}
+	var target *Preset
+	for i := range list {
+		if list[i].ID == id {
+			target = &list[i]
+			break
+		}
+	}
+	if target == nil {
+		return fmt.Errorf("preset introuvable : %s", id)
+	}
+	if target.Active {
+		return nil
+	}
+	if err := SwitchToPreset(target.Path); err != nil {
+		return err
+	}
+	// Le moteur redémarre : on attend qu'il réponde à nouveau (charger un gros
+	// modèle prend un moment).
+	deadline := time.Now().Add(4 * time.Minute)
+	for time.Now().Before(deadline) {
+		if healthCheck() {
+			return nil
+		}
+		time.Sleep(3 * time.Second)
+	}
+	return fmt.Errorf("le modèle n'a pas fini de charger après le changement de preset")
+}
+
+// recordTaskEnd met à jour l'état persisté d'une tâche après une exécution :
+// durée, dernier passage, prochain passage, succès/échec, compte-rendu. Relit la
+// tâche juste avant d'écrire pour ne pas écraser une modification concurrente
+// (bascule ou édition depuis l'interface pendant l'exécution).
+func recordTaskEnd(id string, start time.Time, report string, err error) {
+	now := time.Now()
+	cur, ok := getTask(id)
+	if !ok {
+		return // supprimée entre-temps : rien à écrire
+	}
+	cur.LastDurMs = now.Sub(start).Milliseconds()
+	cur.LastRun = now.UnixMilli()
+	cur.NextRun = computeNextRun(cur.Schedule, cur.TZ, now)
+	if errors.Is(err, context.Canceled) {
+		// Arrêt volontaire (bouton stop) : ce n'est pas un échec. On garde la trace
+		// « interrompue » sans allumer l'indicateur rouge d'erreur.
+		cur.LastOK = true
+		cur.LastError = ""
+		cur.LastReport = "(interrompue manuellement)"
+	} else if err != nil {
+		cur.LastOK = false
+		cur.LastError = err.Error()
+	} else {
+		cur.LastOK = true
+		cur.LastError = ""
+		if len(report) > reportMax {
+			report = report[:reportMax] + "…"
+		}
+		cur.LastReport = report
+	}
+	_ = saveTask(cur)
+}

internal/loki/tasks_sched.go

@@ -0,0 +1,72 @@
+package loki
+
+// tasks_sched.go — la boucle de planification. Une seule goroutine, un tick par
+// minute, dans le process qui possède la conversation et l'UI (ajean-ui /
+// `ajean link`). Voir StartTaskScheduler, câblée dans newWebMux (web_server.go).
+
+import (
+	"sync"
+	"time"
+)
+
+var taskSchedOnce sync.Once
+
+// StartTaskScheduler démarre la boucle de planification (idempotent : sûr à
+// appeler à chaque construction du mux, ne lance qu'une goroutine).
+func StartTaskScheduler() {
+	taskSchedOnce.Do(func() { go taskSchedLoop() })
+}
+
+// taskSchedLoop réveille les tâches dues, une par tick (elles sont de toute façon
+// sérialisées par le gate de génération). Le tick d'une minute suffit : c'est la
+// résolution de la planification (voir tasks_cron.go).
+func taskSchedLoop() {
+	// Premier passage immédiat pour amorcer les NextRun manquants (après un
+	// redémarrage du process, ou pour une tâche fraîchement créée sans NextRun).
+	primeNextRuns()
+	t := time.NewTicker(time.Minute)
+	defer t.Stop()
+	for range t.C {
+		tickTasks(time.Now())
+	}
+}
+
+// primeNextRuns renseigne NextRun de toute tâche activée qui n'en a pas (0),
+// relativement à maintenant — sinon une tâche à NextRun=0 serait considérée « due »
+// en permanence, ou jamais planifiée selon le sens de la comparaison.
+func primeNextRuns() {
+	now := time.Now()
+	for _, t := range listTasks() {
+		if t.Enabled && t.NextRun == 0 {
+			t.NextRun = computeNextRun(t.Schedule, t.TZ, now)
+			_ = saveTask(t)
+		}
+	}
+}
+
+// tickTasks lance la première tâche due (si l'interrupteur maître n'est pas en
+// pause). Une seule par tick : lancer plusieurs inférences en parallèle est de
+// toute façon impossible (gate de génération), et étaler leur départ évite qu'une
+// rafale de tâches monopolise le modèle d'un coup.
+func tickTasks(now time.Time) {
+	if tasksPaused() {
+		return
+	}
+	nowMs := now.UnixMilli()
+	for _, t := range listTasks() {
+		if !t.Enabled {
+			continue
+		}
+		if t.NextRun == 0 {
+			// Priming raté (schedule invalide) ou tâche neuve : on tente de le poser,
+			// sans la déclencher ce tour-ci.
+			t.NextRun = computeNextRun(t.Schedule, t.TZ, now)
+			_ = saveTask(t)
+			continue
+		}
+		if t.NextRun <= nowMs {
+			runTask(t) // met à jour LastRun/NextRun/… et persiste
+			return
+		}
+	}
+}

internal/loki/tasks_test.go

@@ -0,0 +1,322 @@
+package loki
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http/httptest"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+// Aller-retour complet en base : ce qui est enregistré se relit à l'identique,
+// la liste est triée par nom (affichage stable) et la suppression efface bien.
+func TestTasksCRUD(t *testing.T) {
+	testHome(t)
+	if got := listTasks(); len(got) != 0 {
+		t.Fatalf("base neuve : %d tâches, attendu 0", len(got))
+	}
+	a := Task{ID: newTaskID(), Name: "zèbre", Prompt: "p", Schedule: "@every 2h", Enabled: true}
+	b := Task{ID: newTaskID(), Name: "abeille", Prompt: "p", Schedule: "0 9 * * 1-5"}
+	if err := saveTask(a); err != nil {
+		t.Fatal(err)
+	}
+	if err := saveTask(b); err != nil {
+		t.Fatal(err)
+	}
+	list := listTasks()
+	if len(list) != 2 || list[0].Name != "abeille" || list[1].Name != "zèbre" {
+		t.Fatalf("liste non triée par nom : %+v", list)
+	}
+	got, ok := getTask(a.ID)
+	if !ok || got.Prompt != "p" || got.Schedule != "@every 2h" || !got.Enabled {
+		t.Fatalf("relecture incorrecte : %+v (ok=%v)", got, ok)
+	}
+	if err := deleteTask(a.ID); err != nil {
+		t.Fatal(err)
+	}
+	if _, ok := getTask(a.ID); ok {
+		t.Error("tâche supprimée toujours présente")
+	}
+	if len(listTasks()) != 1 {
+		t.Error("la suppression n'a pas retiré la tâche de la liste")
+	}
+}
+
+// L'interrupteur maître est un FREIN : base neuve = tâches actives, sans
+// dépendre d'une écriture préalable.
+func TestTasksPauseDefautActif(t *testing.T) {
+	testHome(t)
+	if tasksPaused() {
+		t.Error("base neuve : les tâches devraient être actives")
+	}
+	if err := setTasksPaused(true); err != nil {
+		t.Fatal(err)
+	}
+	if !tasksPaused() {
+		t.Error("pause non enregistrée")
+	}
+	_ = setTasksPaused(false)
+	if tasksPaused() {
+		t.Error("reprise non enregistrée")
+	}
+}
+
+// Le dossier de travail d'une tâche lui appartient : jamais celui d'une
+// discussion (qui disparaît avec elle), et stable d'un passage à l'autre — une
+// tâche qui tient un fichier de suivi doit le retrouver.
+func TestTaskWorkspaceIsole(t *testing.T) {
+	testHome(t)
+	dir := taskWorkspaceDir("abc123")
+	if dir == agentWorkspace() || dir == convWorkspace() {
+		t.Fatalf("la tâche partage le dossier d'une discussion : %s", dir)
+	}
+	if filepath.Base(dir) != "abc123" || filepath.Base(filepath.Dir(dir)) != "tasks" {
+		t.Errorf("emplacement inattendu : %s", dir)
+	}
+	if again := taskWorkspaceDir("abc123"); again != dir {
+		t.Errorf("dossier instable entre deux passages : %s puis %s", dir, again)
+	}
+	// La bascule ne doit toucher QUE les outils : ce que voit l'utilisateur
+	// (panneau Fichiers, dépôts) reste sur sa discussion.
+	setTaskWorkspace(dir)
+	defer setTaskWorkspace("")
+	if agentCwd() != dir {
+		t.Errorf("agentCwd = %s, attendu %s", agentCwd(), dir)
+	}
+	if convWorkspace() == dir {
+		t.Error("convWorkspace suit la tâche : le panneau Fichiers changerait de dossier en cours de route")
+	}
+}
+
+// Les accès d'une tâche : l'agent commande tout, la tâche ne peut que RETIRER
+// (no_mem/no_web), et le mode code reste hors sujet sans personne en face.
+func TestTaskCaps(t *testing.T) {
+	testHome(t)
+	if c := taskCaps(Task{}); c.Agent || c.Internet || c.Mem != MemOff {
+		t.Errorf("agent coupé : aucun outil attendu, obtenu %+v", c)
+	}
+	if err := setAgentEnabled(true); err != nil {
+		t.Fatal(err)
+	}
+	c := taskCaps(Task{})
+	if !c.Agent {
+		t.Fatal("mode agent actif : la tâche doit avoir les outils")
+	}
+	if c.Code {
+		t.Error("le mode code n'a pas de sens pour une tâche autonome")
+	}
+	// Par défaut, la tâche suit le mode mémoire de la machine.
+	if c.Mem != memMode() {
+		t.Errorf("mémoire = %q, attendu celle de la machine (%q)", c.Mem, memMode())
+	}
+	// Machine mémoire COUPÉE mais tâche qui la demande : elle garde au moins les
+	// outils à la demande, sans l'injection proactive.
+	if err := setMemMode(MemOff); err != nil {
+		t.Fatal(err)
+	}
+	if got := taskCaps(Task{}).Mem; got != MemOnDemand {
+		t.Errorf("mémoire = %q, attendu %q", got, MemOnDemand)
+	}
+	if c := taskCaps(Task{NoMem: true, NoWeb: true}); c.Mem != MemOff || c.Internet {
+		t.Errorf("refus explicite non respecté : %+v", c)
+	}
+	// Web : borné à ce que la machine offre réellement — une tâche ne peut pas
+	// l'inventer (aucun serveur Crawl4AI joignable ici).
+	if c := taskCaps(Task{}); c.Internet {
+		t.Error("accès web accordé alors que la machine ne l'offre pas")
+	}
+}
+
+// Fin d'exécution : succès, échec et interruption volontaire n'écrivent pas la
+// même chose — et une interruption n'est PAS un échec (pas d'indicateur rouge).
+func TestRecordTaskEnd(t *testing.T) {
+	testHome(t)
+	base := Task{ID: "t1", Name: "n", Prompt: "p", Schedule: "@every 1h", Enabled: true}
+	if err := saveTask(base); err != nil {
+		t.Fatal(err)
+	}
+	start := time.Now().Add(-2 * time.Second)
+
+	recordTaskEnd("t1", start, strings.Repeat("x", reportMax+50), nil)
+	got, _ := getTask("t1")
+	if !got.LastOK || got.LastError != "" {
+		t.Errorf("succès mal enregistré : %+v", got)
+	}
+	if len(got.LastReport) != reportMax+len("…") {
+		t.Errorf("compte-rendu non borné : %d caractères", len(got.LastReport))
+	}
+	if got.LastRun == 0 || got.NextRun <= got.LastRun {
+		t.Errorf("horodatages incohérents : last=%d next=%d", got.LastRun, got.NextRun)
+	}
+	if got.LastDurMs < 1000 {
+		t.Errorf("durée non mesurée : %d ms", got.LastDurMs)
+	}
+
+	recordTaskEnd("t1", start, "", errors.New("boum"))
+	got, _ = getTask("t1")
+	if got.LastOK || got.LastError != "boum" {
+		t.Errorf("échec mal enregistré : %+v", got)
+	}
+
+	recordTaskEnd("t1", start, "", context.Canceled)
+	got, _ = getTask("t1")
+	if !got.LastOK || got.LastError != "" || !strings.Contains(got.LastReport, "interrompue") {
+		t.Errorf("interruption prise pour un échec : %+v", got)
+	}
+
+	// Tâche supprimée entre-temps : on n'en ressuscite pas une.
+	recordTaskEnd("disparue", start, "r", nil)
+	if _, ok := getTask("disparue"); ok {
+		t.Error("recordTaskEnd a recréé une tâche supprimée")
+	}
+}
+
+// Le tic ne déclenche rien quand l'interrupteur maître est en pause, et pose le
+// NextRun manquant sans lancer la tâche pour autant.
+func TestTickTasks(t *testing.T) {
+	testHome(t)
+	now := time.Now()
+	due := Task{ID: "due", Name: "due", Prompt: "p", Schedule: "@every 1h", Enabled: true,
+		NextRun: now.Add(-time.Minute).UnixMilli()}
+	if err := saveTask(due); err != nil {
+		t.Fatal(err)
+	}
+	_ = setTasksPaused(true)
+	tickTasks(now)
+	if got, _ := getTask("due"); got.LastRun != 0 {
+		t.Error("une tâche s'est exécutée alors que tout est suspendu")
+	}
+	_ = setTasksPaused(false)
+
+	// NextRun absent : le tic le pose (relatif à maintenant) sans exécuter.
+	neuve := Task{ID: "neuve", Name: "neuve", Prompt: "p", Schedule: "@every 2h", Enabled: true}
+	if err := saveTask(neuve); err != nil {
+		t.Fatal(err)
+	}
+	primeNextRuns()
+	got, _ := getTask("neuve")
+	if got.NextRun == 0 || got.LastRun != 0 {
+		t.Errorf("amorçage incorrect : next=%d last=%d", got.NextRun, got.LastRun)
+	}
+	if d := time.UnixMilli(got.NextRun).Sub(now); d < 110*time.Minute || d > 130*time.Minute {
+		t.Errorf("prochain passage à %v, attendu ~2 h", d)
+	}
+	// Tâche désactivée : jamais amorcée, jamais lancée.
+	off := Task{ID: "off", Name: "off", Prompt: "p", Schedule: "@every 1h"}
+	if err := saveTask(off); err != nil {
+		t.Fatal(err)
+	}
+	primeNextRuns()
+	if got, _ := getTask("off"); got.NextRun != 0 {
+		t.Error("une tâche désactivée a été planifiée")
+	}
+}
+
+// Une tâche épinglée sur un preset qui n'existe plus échoue PROPREMENT : elle
+// est marquée en erreur (et surtout, elle ne tourne pas sur le mauvais modèle).
+func TestRunTaskPresetIntrouvable(t *testing.T) {
+	testHome(t)
+	tk := Task{ID: "p1", Name: "n", Prompt: "p", Schedule: "@every 1h", Enabled: true, Preset: "fantome"}
+	if err := saveTask(tk); err != nil {
+		t.Fatal(err)
+	}
+	runTask(tk)
+	got, _ := getTask("p1")
+	if got.LastOK || !strings.Contains(got.LastError, "preset") {
+		t.Errorf("échec de bascule mal signalé : %+v", got)
+	}
+}
+
+// La note de contexte dit à l'IA qu'elle tourne seule, et lui redonne son
+// compte-rendu précédent — borné, pour ne pas manger le contexte.
+func TestTaskContextNote(t *testing.T) {
+	n := taskContextNote("Veille mails", "")
+	if !strings.Contains(n, "Veille mails") || !strings.Contains(n, "sans utilisateur") {
+		t.Errorf("note incomplète : %q", n)
+	}
+	if strings.Contains(n, "dernière exécution") {
+		t.Error("premier passage : il n'y a pas de compte-rendu à rappeler")
+	}
+	long := taskContextNote("t", strings.Repeat("y", reportMax+100))
+	if !strings.Contains(long, "dernière exécution") {
+		t.Error("le compte-rendu précédent doit être réinjecté")
+	}
+	if len(long) > reportMax+600 {
+		t.Errorf("note non bornée : %d caractères", len(long))
+	}
+}
+
+// L'API refuse une tâche bancale AVANT de l'enregistrer : sans ça une fréquence
+// illisible donnerait une tâche qui ne se déclenche jamais, sans rien dire.
+func TestHandleTaskSaveValide(t *testing.T) {
+	testHome(t)
+	post := func(body string) (int, map[string]any) {
+		rr := httptest.NewRecorder()
+		handleTaskSave(rr, httptest.NewRequest("POST", "/api/tasks/save", strings.NewReader(body)))
+		var out map[string]any
+		_ = json.Unmarshal(rr.Body.Bytes(), &out)
+		return rr.Code, out
+	}
+	if code, out := post(`{"name":"","prompt":"p","schedule":"@every 1h"}`); code != 400 {
+		t.Errorf("nom vide accepté : %d %v", code, out)
+	}
+	if code, out := post(`{"name":"n","prompt":"","schedule":"@every 1h"}`); code != 400 {
+		t.Errorf("consigne vide acceptée : %d %v", code, out)
+	}
+	if code, out := post(`{"name":"n","prompt":"p","schedule":"tous les jours"}`); code != 400 {
+		t.Errorf("fréquence illisible acceptée : %d %v", code, out)
+	}
+	if len(listTasks()) != 0 {
+		t.Fatal("une tâche refusée a quand même été enregistrée")
+	}
+
+	code, out := post(`{"name":"n","prompt":"p","schedule":"0 9 * * 1-5","tz":"Europe/Paris","enabled":true}`)
+	if code != 200 || out["ok"] != true {
+		t.Fatalf("création refusée : %d %v", code, out)
+	}
+	id, _ := out["id"].(string)
+	got, ok := getTask(id)
+	if !ok || got.TZ != "Europe/Paris" || got.NextRun == 0 {
+		t.Fatalf("tâche mal créée : %+v", got)
+	}
+
+	// Édition : l'historique d'exécution SURVIT (on ne repart pas de zéro parce
+	// qu'on a corrigé une faute dans la consigne).
+	got.LastRun, got.LastReport, got.LastOK = 42, "vu hier", true
+	if err := saveTask(got); err != nil {
+		t.Fatal(err)
+	}
+	if code, out := post(`{"id":"` + id + `","name":"n2","prompt":"p2","schedule":"0 9 * * 1-5","enabled":true}`); code != 200 {
+		t.Fatalf("édition refusée : %d %v", code, out)
+	}
+	after, _ := getTask(id)
+	if after.Name != "n2" || after.Prompt != "p2" {
+		t.Errorf("édition non appliquée : %+v", after)
+	}
+	if after.LastRun != 42 || after.LastReport != "vu hier" {
+		t.Errorf("historique perdu à l'édition : %+v", after)
+	}
+}
+
+// Un message envoyé pendant qu'une tâche tourne doit dire LAQUELLE occupe le
+// modèle : « génération en cours » sur un fil vide et immobile n'explique rien.
+func TestBusyReasonNommeLaTache(t *testing.T) {
+	testHome(t)
+	if err := conv.busyReason(); err != ErrBusy {
+		t.Errorf("hors tâche : %v, attendu %v", err, ErrBusy)
+	}
+	conv.mu.Lock()
+	conv.runningTaskName = "Veille mails"
+	conv.mu.Unlock()
+	defer func() {
+		conv.mu.Lock()
+		conv.runningTaskName = ""
+		conv.mu.Unlock()
+	}()
+	if err := conv.busyReason(); err == nil || !strings.Contains(err.Error(), "Veille mails") {
+		t.Errorf("la tâche n'est pas nommée : %v", err)
+	}
+}

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

@@ -12,8 +12,8 @@
 <!-- Favicon (même marque « loki » que la landing/portail) + icône PWA (écran d'accueil
      iOS). SVG inline pour le favicon, PNG 180×180 en data-URI pour apple-touch-icon
      (iOS n'accepte pas le SVG pour l'icône d'accueil). Aucun fichier externe requis. -->
-<link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 12 12'><rect width='12' height='12' rx='2' ry='2' fill='%23000'/><rect x='6' y='3' width='2' height='2' fill='%23fff'/><rect x='6' y='5' width='2' height='2' fill='%23fff'/><rect x='4' y='7' width='2' height='2' fill='%23fff'/></svg>">
-<link rel="apple-touch-icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAALQAAAC0CAIAAACyr5FlAAABBUlEQVR42u3SAQkAAAwCQfuX3lI4GNxF0E8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIArU2NbcYhDHOIQhzgQB+JAHIgDcSAOxIE4xCEOcYhDHIgDcSAOxIE4EAfiQBziEIc4xCEOcYgDcSAOxIE4EAfiQBziEIc4xCEOcYgDcSAOxIE4EAfiQByIQxziEIc4xIE4EAfiQByIA3EgDsQhDnGIQxziEIc4EAfiQByIAxciDsSBOBAH4kAc4hCHOMQhDnGIA3EgDsSBOBAH4kAc4hCHOMQhDnGIA3EgDsSBOBAH4kAciEMc4hCHOMQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADfLBHMhi4TnG6EAAAAAElFTkSuQmCC">
+<link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 12 12'><rect width='12' height='12' rx='2' ry='2' fill='%235E7F5A'/><rect x='6' y='3' width='2' height='2' fill='%23fff'/><rect x='6' y='5' width='2' height='2' fill='%23fff'/><rect x='4' y='7' width='2' height='2' fill='%23fff'/></svg>">
+<link rel="apple-touch-icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAALQAAAC0CAYAAAA9zQYyAAADD0lEQVR4nOzdW27aWgBGYag6ylZqh1I6lFZKppmjEylRLlyMsbG9+n3vsP2w8mfDC193d/Dj17ene5zDuv39/bif+4xZDhAwQ8wR+GRvKGJuMVXcN7+JkJnSrWGPfrGQmdPYsL+MeZGYmdvYxq76KxAyS7hmrQcvtJhZyjXtDQpazCxtaIMXgxYzazGkxbNBi5m1udTkyaDFzFqda3PU13awVkeDts6s3alGPwUtZrbiWKuuHKS8C9o6szUfm7XQpLwGbZ3ZqrftWmhSBE3Kc9CuG2zdS8MWmhRBkyJoUvbuz5RYaFIETYqgSRE0KYImRdCkCJoUQZMiaFIETYqgSRE0KYImRdCkCJoUQZMiaFIETYqgSbnLj9ez2/05PCxy7s/D90XOXYqFJkXQpAiaFEGTImhSBE2KoEkRNCmCJkXQpAiaFEGTImhSBE2KoEkRNCmCJkXQpAiaFEGTImhSBE2KoEkRNCmCJkXQpAiaFEGTImhSBE2KoEkRNCmCJkXQpAiaFEGTImhSBE2KoEkRNCmCJkXQpAiaFEGTImhSBE2KoEkRNCmCJkXQpAiaFEGTImhSBE2KoEkRNCmCJkXQpAialK9LP8C9/Tk8LHLuz8P3Rc7911hoUgRNiqBJETQpgiZF0KQImhRBkyJoUgRNiqBJETQpgiZF0KQImhRBkyJoUgRNiqBJETQpgiZF0KQImhRBkyJoUgRNiqBJETQpgiZl/+PXt6elHwKmYqFJETQpgiZF0KQImhRBkyJoUgRNiqBJETQpgiZF0KQImhRBkyJoUgRNiqBJETQpgibly9/fj/ulHwKm8H/LFpoUQZMiaFKeg3aPZuteGrbQpAialNegXTvYqrftWmhS3gVtpdmaj81aaFI+BW2l2YpjrR5daFGzdqcadeUg5WTQVpq1Otfm2YUWNWtzqcmLVw5RsxZDWhx0hxY1Sxva4OAPhaJmKde0NypSPwXHPYwZ0VFf21lr5ja2sZvDtNZM6daxnGxphc0tpvqvP8vVQdwMMcfV9S53YYGzu9Nnr/8CAAD//xZRk2OJYiOqAAAAAElFTkSuQmCC">
 <!-- Marque le mode PWA AVANT le rendu : la hauteur de coque et le défilement du
      document en dépendent (voir styles.css). ⚠️ On NE PEUT PAS se fier au média
      `display-mode:standalone` : WebKit l'adosse au `display` du MANIFESTE, or cette
@@ -22,35 +22,48 @@
      garde `display-mode` en second pour les PWA Android/desktop à manifeste. -->
 <script>try{var pwa=(window.navigator.standalone===true)||(window.matchMedia&&window.matchMedia('(display-mode:standalone)').matches)||(window.matchMedia&&window.matchMedia('(display-mode:fullscreen)').matches);document.documentElement.setAttribute('data-pwa',pwa?'1':'0');}catch(e){document.documentElement.setAttribute('data-pwa','0');}</script>
 <!-- Applique le thème AVANT le rendu (pas de flash) : lit le choix persisté. -->
-<script>try{var t=localStorage.getItem('loki-theme')||'light';document.documentElement.setAttribute('data-theme',(t==='dark'||t.endsWith('-dark'))?'dark':'light');['hide-reasoning','hide-tools','fold-tools','hide-side','hide-stats'].forEach(function(k){document.documentElement.setAttribute('data-'+k,localStorage.getItem('loki-'+k)==='1'?'1':'0')})}catch(e){document.documentElement.setAttribute('data-theme','light');}</script>
+<script>try{var t=localStorage.getItem('loki-theme')||'light';document.documentElement.setAttribute('data-theme',(t==='dark'||t.endsWith('-dark'))?'dark':'light');['hide-reasoning','hide-tools','fold-tools','hide-stats'].forEach(function(k){document.documentElement.setAttribute('data-'+k,localStorage.getItem('loki-'+k)==='1'?'1':'0')});
+/* Barre latérale escamotée et moniteur replié : posés AVANT le rendu, sinon la
+   barre s'affiche puis se referme sous les yeux à chaque chargement. Ouverts par
+   défaut — une valeur absente vaut « visible ». */
+document.documentElement.setAttribute('data-side',localStorage.getItem('loki-side')==='0'?'0':'1');
+}catch(e){document.documentElement.setAttribute('data-theme','light');}</script>
 <style>
 @@CSS@@
 </style></head><body>
-<button id="menubtn" onclick="toggleSide()">☰</button>
+<button id="menubtn" onclick="toggleSide()" title="menu" aria-label="ouvrir le menu"><svg viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M4 7h16"/><path d="M4 12h16"/><path d="M4 17h16"/></svg></button>
 <!-- Installation d'un moteur en cours : le détail vit dans le panneau, qui est
      fermé sur téléphone. Sans ce rappel, un rechargement de page donnait
      l'impression que l'installation avait disparu. -->
 <button id="lc-chip" onclick="lcChipOpen()" hidden></button>
 <div id="backdrop" onclick="toggleSide()"></div>
 <div class="side" id="side">
-  <!-- sidecard : regroupe la marque et la mention du fork en UNE carte (direction
-       Terre). Sans ce conteneur, les deux blocs flottaient séparément. -->
-  <div class="sidecard">
+  <!-- Trois zones : en-tête figé, contenu défilant, moniteur machine en pied.
+       C'est ce découpage qui garde les jauges visibles quel que soit le nombre
+       de discussions — elles les poussaient auparavant hors de l'écran. -->
   <div class="sidehead">
+    <div class="sidebrand">
     <h1 id="brand" aria-label="loki" title="Loki — fork d'AJEAN (github.com/nathaninline/ajean, MIT)"><span id="brand-a"><svg viewBox="0 0 4 5" shape-rendering="crispEdges" fill="currentColor"><rect x="0" y="0" width="1" height="5"/><rect x="1" y="4" width="3" height="1"/></svg></span><span id="brand-word"><svg viewBox="0 0 11 5" shape-rendering="crispEdges" fill="currentColor"><rect x="0" y="0" width="3" height="1"/><rect x="0" y="1" width="1" height="3"/><rect x="2" y="1" width="1" height="3"/><rect x="0" y="4" width="3" height="1"/><rect x="4" y="0" width="1" height="5"/><rect x="6" y="0" width="1" height="2"/><rect x="5" y="2" width="1" height="1"/><rect x="6" y="3" width="1" height="2"/><rect x="8" y="0" width="3" height="1"/><rect x="9" y="1" width="1" height="3"/><rect x="8" y="4" width="3" height="1"/></svg></span><span id="ver"></span></h1>
+    <!-- Attribution du fork (licence MIT de l'amont) : sous le nom de l'app,
+         là où elle a toujours vécu. -->
+    <div class="brand-fork">fork de <a href="https://github.com/nathaninline/ajean" target="_blank" rel="noopener noreferrer" title="AJEAN par nathaninline — licence MIT">AJEAN</a></div>
+    </div><!-- /.sidebrand -->
     <span id="status-svc" class="statuspill" onclick="toggleSvcLog()" title="voir le journal du moteur">…</span>
   </div>
-  <div class="brand-fork">fork de <a href="https://github.com/nathaninline/ajean" target="_blank" rel="noopener noreferrer" title="AJEAN par nathaninline — licence MIT">AJEAN</a></div>
-  </div><!-- /sidecard -->
+  <div id="side-scroll">
   <!-- Discussions : plusieurs fils, la liste la plus récente en tête. Le fil
        actif est partagé par tous les appareils (comme la conversation unique
-       d'origine) : basculer ici bascule partout. -->
-  <details id="conv-details" open><summary><span class="stitle">Discussions</span><button class="preset-add" onclick="event.preventDefault();event.stopPropagation();convNew()" title="nouvelle discussion">+</button></summary>
+       d'origine) : basculer ici bascule partout.
+       La recherche filtre CÔTÉ CLIENT : la liste est déjà entièrement chargée
+       (métadonnées seules, sans les messages), un aller-retour serveur par
+       frappe n'apporterait rien. -->
+  <details id="conv-details" open><summary><span class="stitle">Discussions</span><button class="preset-add" onclick="event.preventDefault();event.stopPropagation();convNew()" title="nouvelle discussion" aria-label="nouvelle discussion"><svg viewBox="0 0 24 24" width="15" height="15" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M12 5.5v13"/><path d="M5.5 12h13"/></svg></button></summary>
+    <input id="conv-search" type="search" placeholder="rechercher une discussion…" oninput="renderConversations()" aria-label="rechercher une discussion">
     <div id="conv-list" class="slist"></div>
   </details>
   <!-- Avertissement de lancement (App Translocation macOS) — masqué par défaut. -->
-  <div id="app-warn" class="muted" style="display:none;font-size:11px;line-height:1.5;margin:0 0 10px;padding:8px 10px;border-radius:8px;color:var(--warn);border:1px solid color-mix(in srgb,var(--warn) 45%,transparent);background:color-mix(in srgb,var(--warn) 12%,transparent)"></div>
-  <div id="model-err" style="display:none;font-size:11px;line-height:1.5;margin:0 0 10px;padding:8px 10px;border-radius:8px;color:var(--err);border:1px solid color-mix(in srgb,var(--err) 45%,transparent);background:color-mix(in srgb,var(--err) 12%,transparent)"></div>
+  <div id="app-warn" class="muted" style="display:none;font-size:11px;line-height:1.5;margin:0 0 10px;padding:8px 10px;border-radius:4px;color:var(--warn);border:1px solid color-mix(in srgb,var(--warn) 45%,transparent);background:color-mix(in srgb,var(--warn) 12%,transparent)"></div>
+  <div id="model-err" style="display:none;font-size:11px;line-height:1.5;margin:0 0 10px;padding:8px 10px;border-radius:4px;color:var(--err);border:1px solid color-mix(in srgb,var(--err) 45%,transparent);background:color-mix(in srgb,var(--err) 12%,transparent)"></div>
   <!-- Journal du moteur : replié par défaut, ouvert au clic sur la pastille d'état
        OU par son propre chevron — c'est une section comme les autres, sinon on ne
        trouvait pas comment la refermer.
@@ -58,10 +71,15 @@
   <!-- sidegroup : plusieurs sections dans UNE carte. Une carte par section
        empilait 11 arrondis et autant de gouttières : la barre latérale ne
        tenait plus dans un écran, alors que ces lignes sont des titres repliés. -->
+  <!-- Tout ce qui n'est pas la conversation tient sous CE repli : la barre
+       latérale par défaut, c'est les discussions et la machine. Les sections
+       ouvertes par programme (journal du moteur, installation llama.cpp)
+       passent par openDetails(), qui déplie aussi les parents. -->
+  <details id="side-settings"><summary><span class="stitle">Réglages</span></summary>
   <div class="sidegroup">
   <details id="svc-log-box" ontoggle="if(this.open){loadSvcLog();showPaths()}"><summary><span class="stitle">Journal du moteur</span></summary>
     <div class="row" style="justify-content:flex-end;align-items:center">
-      <button onclick="loadSvcLog()" title="rafraîchir">↻</button>
+      <button onclick="loadSvcLog()" title="rafraîchir" aria-label="rafraîchir le journal"><svg viewBox="0 0 24 24" width="15" height="15" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M20.5 12a8.5 8.5 0 1 1-2.5-6"/><path d="M20.5 3.5V9H15"/></svg></button>
     </div>
     <pre id="svc-log" class="muted" style="font-size:10px;line-height:1.45;max-height:220px;overflow:auto;white-space:pre-wrap;word-break:break-word;margin:6px 0 0"></pre>
     <!-- Emplacements : au même endroit que le journal, c'est le panneau où l'on
@@ -71,18 +89,10 @@
     </div>
     <div id="paths-msg" class="muted" style="font-size:10px;line-height:1.5"></div>
   </details>
-  <!-- GPU et RAM décrivent la même chose (les ressources de la machine) :
-       une seule section, deux blocs de statistique dans la même carte. -->
-  <details open><summary><span class="stitle">Machine</span></summary>
-    <div class="slist">
-      <div id="vram">…</div>
-      <div id="ram-details"><div id="ram"></div></div>
-    </div>
-  </details>
   <details open id="cfg-details"><summary><span class="stitle">Config active</span></summary>
     <div id="cfg" class="slist">…</div>
   </details>
-  <details><summary><span class="stitle">Presets</span><button class="preset-add" onclick="event.preventDefault();event.stopPropagation();openPreset('')" title="ajouter">+</button></summary>
+  <details><summary><span class="stitle">Presets</span><button class="preset-add" onclick="event.preventDefault();event.stopPropagation();openPreset('')" title="ajouter" aria-label="ajouter"><svg viewBox="0 0 24 24" width="15" height="15" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M12 5.5v13"/><path d="M5.5 12h13"/></svg></button></summary>
     <div class="slist"><div id="presets" class="rowlist"></div></div>
   </details>
   <details><summary><span class="stitle">Mode agent</span><span id="agent-badge" class="sbadge"></span></summary>
@@ -158,7 +168,10 @@
           <!-- Même texte que celui rendu après chargement quand il n'y a aucun
                serveur : sinon la carte partait vide puis grandissait d'une ligne. -->
           <div id="mcp-list" class="mcp-list"><div class="muted" style="font-size:12px">(aucun serveur — ajoute un serveur fichiers, une base de données, une API…)</div></div>
-          <button class="addbtn" style="margin-top:6px" onclick="openMcp('')">+ ajouter un serveur</button>
+          <div class="mcp-actions">
+            <button class="addbtn" onclick="openMcpCatalog()">catalogue</button>
+            <button class="addbtn" onclick="openMcp('')">+ ajouter un serveur</button>
+          </div>
         </div>
       </div>
     </div>
@@ -169,6 +182,23 @@
       </div>
     </div>
   </details>
+  <details id="tasks-details"><summary><span class="stitle">Tâches planifiées</span><span id="tasks-badge" class="sbadge"></span></summary>
+    <!-- Tâches planifiées : l'IA exécute une consigne toute seule sur une
+         fréquence réglable (voir tasks.go). Chaque tâche tourne ISOLÉE de la
+         conversation — elle livre son résultat via les outils de l'IA (mail via
+         MCP, shell…). D'où l'avertissement quand le mode agent est off : sans
+         lui, aucune tâche ne peut agir. -->
+    <div class="slist">
+      <label class="switchrow"><span class="switch"><input type="checkbox" id="tasks-pause-toggle" onchange="toggleTasksPause()"><span class="slider"></span></span> suspendre toutes les tâches<span class="help" tabindex="0" onclick="event.preventDefault();event.stopPropagation();this.classList.toggle('open')">?<span class="tip">Interrupteur maître : coche pour que plus aucune tâche ne se déclenche. Les tâches gardent leur réglage et repartent quand tu décoches.</span></span></label>
+    </div>
+    <div id="tasks-agent-warn" class="muted" style="display:none;font-size:12px;line-height:1.5;margin:8px 2px">Le <b>mode agent</b> est désactivé : les tâches s'exécuteront mais l'IA n'aura <b>aucun outil</b> pour agir (envoyer un mail, lire des fichiers…). Active le mode agent ci-dessus.</div>
+    <div class="slist">
+      <div class="rowbody">
+        <div id="tasks-list" class="mcp-list"><div class="muted" style="font-size:12px">(aucune tâche — ex. « toutes les 2 h, relève mes mails et prépare des brouillons de réponse »)</div></div>
+        <button class="addbtn" style="margin-top:6px" onclick="openTask('')">+ ajouter une tâche</button>
+      </div>
+    </div>
+  </details>
   <details><summary><span class="stitle">System prompt</span></summary>
     <div class="slist"><div class="rowbody">
       <textarea id="sysprompt" placeholder="(optionnel) ex: tu es un assistant concis en français" oninput="saveSys()" class="sctl"></textarea>
@@ -179,13 +209,26 @@
          même sujet. Les trois modes sont des LIGNES de cette carte (elles
          étaient des cartes dans une carte). -->
     <div class="slist">
-    <!-- Moteur fourni par l'image Docker : aucun des trois modes ne s'applique
-         (rien à installer, et l'image n'embarque ni cmake ni compilateur). -->
+    <!-- Moteur fourni par l'image Docker : aucun des trois modes d'installation
+         ne s'applique (rien à compiler, et l'image n'embarque ni cmake ni
+         compilateur). En revanche llama.cpp publie plusieurs versions par jour,
+         et son moteur déjà compilé est téléchargeable seul (~170 Mo) : cette
+         carte le met à jour sans reconstruire l'image. -->
     <div id="lc-provided" class="rowbody" style="display:none">
-      <div style="font-size:12px;line-height:1.5">Moteur <b>fourni par l'image Docker</b> — llama.cpp officiel, déjà compilé.
-        <div class="muted" style="margin-top:4px">Rien à installer ni à mettre à jour ici : le moteur suit l'image.
-          Pour en changer (version épinglée, CPU, Vulkan), reconstruis l'image avec le build-arg <code>LLAMACPP_IMAGE</code>.</div>
+      <div style="font-size:12px;line-height:1.5">
+        <div>Moteur <b>llama.cpp</b> <span id="eng-build" class="mcp-tag eng-ver"></span> <span id="eng-source" class="mcp-tag"></span></div>
         <div class="muted" style="margin-top:4px"><code id="lc-provided-bin" style="word-break:break-all"></code></div>
+        <div id="eng-latest" style="margin-top:6px"></div>
+        <div class="row" style="margin:8px 0 0">
+          <!-- Pas de bouton « vérifier la version » : la mise à jour fait sa
+               propre vérification et dit s'il n'y a rien de neuf. Un bouton de
+               moins pour la même information. -->
+          <button onclick="engUpdate()">mettre à jour le moteur</button>
+          <button id="eng-revert" style="display:none" onclick="engUse('image')">revenir au moteur de l'image</button>
+        </div>
+        <div class="muted" style="margin-top:6px">Télécharge llama-server et ses bibliothèques depuis l'image officielle
+          <code id="eng-repo"></code> (~170&nbsp;Mo), sans reconstruire l'image de Loki. Le nouveau moteur est essayé
+          avant d'être adopté ; celui de l'image reste intact et récupérable en un clic.</div>
       </div>
     </div>
     <!-- La pastille « conseillé » n'est PAS écrite ici : le bon choix dépend de
@@ -269,40 +312,34 @@
     <label class="switchrow"><span class="switch"><input type="checkbox" id="view-hide-reasoning" onchange="toggleView('hide-reasoning')"><span class="slider"></span></span> masquer le raisonnement</label>
     <label class="switchrow"><span class="switch"><input type="checkbox" id="view-hide-tools" onchange="toggleView('hide-tools')"><span class="slider"></span></span> masquer les appels d'outils</label>
     <label class="switchrow"><span class="switch"><input type="checkbox" id="view-fold-tools" onchange="toggleView('fold-tools')"><span class="slider"></span></span> garder les bulles repliées<span class="help" tabindex="0" onclick="event.preventDefault();event.stopPropagation();this.classList.toggle('open')">?<span class="tip">Les bulles de raisonnement et d'outil arrivent <b>déjà fermées</b> au lieu de s'ouvrir puis se refermer. Un clic sur leur étiquette les déplie.</span></span></label>
-    <label class="switchrow"><span class="switch"><input type="checkbox" id="view-hide-side" onchange="toggleView('hide-side')"><span class="slider"></span></span> barre latérale escamotable<span class="help" tabindex="0" onclick="event.preventDefault();event.stopPropagation();this.classList.toggle('open')">?<span class="tip">La barre latérale devient un tiroir <b>même sur ordinateur</b> : elle reste fermée et s'ouvre avec le bouton ☰. Toute la largeur pour la conversation.</span></span></label>
     <label class="switchrow"><span class="switch"><input type="checkbox" id="view-hide-stats" onchange="toggleView('hide-stats')"><span class="slider"></span></span> masquer la vitesse de génération<span class="help" tabindex="0" onclick="event.preventDefault();event.stopPropagation();this.classList.toggle('open')">?<span class="tip">Sous chaque réponse : <b>prefill</b> (lecture du contexte) et <b>decode</b> (écriture), en tokens et en tokens/seconde. Coche pour ne plus les afficher.</span></span></label>
     </div>
   </details>
   <details><summary><span class="stitle">Accès OpenAI</span></summary>
-    <div class="subhead">Endpoint compatible OpenAI<span class="help" tabindex="0" onclick="event.preventDefault();event.stopPropagation();this.classList.toggle('open')">?<span class="tip">Branchez n'importe quel client compatible OpenAI (OpenCode, Continue, Cursor…) sur ces adresses. Si une clé est définie, le client doit envoyer <code>Authorization: Bearer &lt;clé&gt;</code>.</span></span></div>
-    <!-- UNE carte pour tout l'endpoint : adresse locale, bascule « public » et
-         adresse publique sont un seul sujet — trois cartes accolées donnaient
-         trois îlots pour un même réglage. -->
+    <div class="subhead">Endpoint compatible OpenAI<span class="help" tabindex="0" onclick="event.preventDefault();event.stopPropagation();this.classList.toggle('open')">?<span class="tip">Branchez n'importe quel client compatible OpenAI (OpenCode, Continue, Cursor, Open WebUI…) sur cette adresse — le modèle s'y appelle <code>loki</code>. L'endpoint est servi par Loki <b>sur le port de cette interface</b> : aucun autre port à ouvrir. Si une clé est définie, le client doit envoyer <code>Authorization: Bearer &lt;clé&gt;</code>.</span></span></div>
     <div class="slist">
       <div class="rowbody">
-        <div class="muted" style="margin:0 0 6px">Adresse locale (réseau) — modèle <code>loki</code></div>
+        <div class="muted" style="margin:0 0 6px">Adresse de l'endpoint — modèle <code>loki</code></div>
         <div class="row" style="margin:0">
           <input id="oai-url" readonly class="io-input">
           <button class="iconbtn" onclick="copyText(document.getElementById('oai-url').value,'adresse copiée')" title="copier"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect x="9" y="9" width="13" height="13" rx="2.5"/><path d="M5 15H4a2 2 0 01-2-2V4a2 2 0 012-2h9a2 2 0 012 2v1"/></svg></button>
         </div>
       </div>
-      <!-- L'adresse ci-dessus ne sert à RIEN si le moteur n'écoute que sur la
-           boucle locale (le défaut sous Windows) : le chat du navigateur marche,
-           mais aucun logiciel du réseau ne peut s'y brancher. Cet interrupteur
-           règle HOST et pose la règle de pare-feu, voir sys_network.go. -->
-      <label class="switchrow"><span class="switch"><input type="checkbox" id="lan-toggle" onchange="toggleLAN()"><span class="slider"></span></span> joignable depuis le réseau local<span class="help" tabindex="0" onclick="event.preventDefault();event.stopPropagation();this.classList.toggle('open')">?<span class="tip">Éteint, le moteur n'écoute que sur <b>cette machine</b> : l'adresse ci-dessus ne répond qu'ici. Allumez-le pour brancher un logiciel depuis un autre ordinateur du réseau (sous Windows, la règle de pare-feu est posée en même temps). <b>Redémarre le moteur.</b></span></span></label>
-      <div id="lan-warn" class="rowbody" style="display:none"></div>
-      <label class="switchrow"><span class="switch"><input type="checkbox" id="oai-public-toggle" onchange="toggleOAIPublic()"><span class="slider"></span></span> exposer en public (ajean.link)<span class="help" tabindex="0" onclick="event.preventDefault();event.stopPropagation();this.classList.toggle('open')">?<span class="tip">Rend votre IA joignable depuis <b>n'importe où</b> via <code>https://&lt;machine&gt;.oai.ajean.link/v1</code> (pour brancher un SaaS). Le trafic est chiffré <b>de bout en bout</b> jusqu'à ce serveur — le relais ajean.link ne voit rien. Nécessite l'accès distant actif.</span></span></label>
-      <div id="oai-public-wrap" class="rowbody" style="display:none">
-        <div class="muted" style="margin:0 0 6px">Adresse publique — chiffrée de bout en bout, accessible partout</div>
+      <!-- Adresse publique : ce que Loki ne peut pas deviner. Vide, l'adresse
+           ci-dessus est celle par laquelle CE navigateur a ouvert l'interface —
+           déjà juste dans la plupart des cas. Renseignée, elle prend le pas :
+           c'est le cas du reverse proxy, où Loki ne voit qu'un appel interne. -->
+      <div class="rowbody">
+        <div class="muted" style="margin:0 0 6px">Adresse publique <span style="opacity:.7">— facultative</span><span class="help" tabindex="0" onclick="event.preventDefault();event.stopPropagation();this.classList.toggle('open')">?<span class="tip">Le nom de domaine ou l'IP par lesquels on atteint cette interface, par exemple <code>ia.exemple.fr</code> ou <code>192.168.1.20:8090</code>. <b>Laissez vide</b> et l'adresse affichée suit celle de votre navigateur. Renseignez-la si vous passez par un <b>reverse proxy</b> ou un nom de domaine : Loki ne voit alors qu'un appel interne et ne peut pas la deviner. Sans <code>https://</code>, il est ajouté.</span></span></div>
         <div class="row" style="margin:0">
-          <input id="oai-public-url" readonly class="io-input">
-          <button class="iconbtn" onclick="copyText(document.getElementById('oai-public-url').value,'adresse publique copiée')" title="copier"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect x="9" y="9" width="13" height="13" rx="2.5"/><path d="M5 15H4a2 2 0 01-2-2V4a2 2 0 012-2h9a2 2 0 012 2v1"/></svg></button>
+          <input id="public-addr" class="io-input" placeholder="ia.exemple.fr" onkeydown="if(event.key==='Enter')savePublicAddr()">
+          <button onclick="savePublicAddr()">enregistrer</button>
         </div>
       </div>
     </div>
-    <div class="subhead">Clé API<span class="help" tabindex="0" onclick="event.preventDefault();event.stopPropagation();this.classList.toggle('open')">?<span class="tip">Protège l'endpoint des complétions (llama-server). Indispensable avant d'exposer le serveur sur internet. Modifier la clé <b>redémarre</b> le service.</span></span></div>
+    <div class="subhead">Clé API<span class="help" tabindex="0" onclick="event.preventDefault();event.stopPropagation();this.classList.toggle('open')">?<span class="tip">Protège l'endpoint des complétions — vérifiée par Loki <b>et</b> par le moteur. Indispensable dès que l'adresse ci-dessus est joignable par d'autres. Modifier la clé <b>redémarre</b> le moteur.</span></span></div>
     <div class="slist"><div class="rowbody">
+      <div id="oai-open-warn" style="display:none;margin:0 0 8px;font-size:11.5px;line-height:1.5;color:var(--err)"></div>
       <div class="row" style="margin:0">
         <input id="oai-key" readonly class="io-input">
         <button id="oai-key-eye" onclick="toggleKeyReveal()" title="afficher / masquer">afficher</button>
@@ -328,13 +365,36 @@
       <!-- Ligne 2 : bench + clear chat (seule action destructive, gardée en dernier). -->
       <div class="row" style="margin-bottom:0">
         <button id="btn-bench" onclick="runBenchUI()">bench</button>
-        <button onclick="resetChat()">⌫ clear chat</button>
+        <button onclick="resetChat()" title="vider la discussion"><svg viewBox="0 0 24 24" width="15" height="15" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M4 7h16"/><path d="M9.5 7V4.5h5V7"/><path d="M6.5 7l1 12.5h9l1-12.5"/></svg><span>vider la discussion</span></button>
       </div>
     </div></div>
   </details>
   </div><!-- /sidegroup -->
+  </details><!-- /#side-settings -->
+  </div><!-- /#side-scroll -->
+  <!-- Moniteur machine : charge GPU, VRAM et mémoire vive. Posé en pied, en
+       jauges fines — visible en permanence sans jamais disputer la place au
+       fil. Le détail chiffré (Gio, température) vit sous chaque jauge, et le
+       bloc entier se replie d'un clic. -->
+  <div id="side-perf">
+    <div class="perf-head"><span>Performance</span></div>
+    <div class="perf-body"><div id="vram">…</div><div id="ram-details"><div id="ram"></div></div></div>
+  </div>
 </div>
 <div class="main" style="position:relative">
+  <!-- Barre d'en-tête : de quoi on parle, et avec quel modèle. Le changement de
+       modèle demandait auparavant d'ouvrir la barre latérale et de descendre
+       jusqu'aux presets — trois clics pour un geste qu'on répète. -->
+  <header id="topbar">
+    <button id="sidetoggle" class="iconbtn" onclick="toggleSideCollapse()" title="afficher/masquer la barre latérale" aria-label="afficher ou masquer la barre latérale">
+      <svg viewBox="0 0 24 24" width="17" height="17" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect x="3" y="4" width="18" height="16" rx="2"/><path d="M9 4v16"/></svg>
+    </button>
+    <div id="topbar-title">Nouvelle discussion</div>
+    <select id="model-switch" onchange="onModelSwitch(this)" title="modèle actif — changer relance le moteur" aria-label="modèle actif"></select>
+    <button id="themebtn" class="iconbtn" onclick="toggleThemeQuick()" title="thème clair / sombre" aria-label="basculer le thème">
+      <svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M21 12.8A9 9 0 1 1 11.2 3a7 7 0 0 0 9.8 9.8z"/></svg>
+    </button>
+  </header>
   <div id="chat"></div>
   <!-- Voile de chargement du fil : sans lui, une connexion lente donne un chat
        VIDE indiscernable d'une conversation vide. Masqué au signal {caught_up}. -->
@@ -349,11 +409,19 @@
          pas de civilité ni d'accord qui obligerait à deviner. -->
     <div id="ce-title">On commence par quoi ?</div>
   </div>
-  <button id="scrollbtn" onclick="jumpBottom()" title="aller en bas">↓</button>
+  <button id="scrollbtn" onclick="jumpBottom()" title="aller en bas" aria-label="aller en bas"><svg viewBox="0 0 24 24" width="17" height="17" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M12 5v14"/><path d="M6 13l6 6 6-6"/></svg></button>
   <!-- Voile de dépôt : révélé pendant qu'on survole la fenêtre avec un fichier. -->
   <div id="dropveil" aria-hidden="true"><div>Déposer pour joindre au message</div></div>
   <div id="composer">
     <div id="ctxmeta">
+      <!-- Mode de la discussion : Chat (assistant généraliste) ou Code (agent
+           de code : critères, vérification, LSP). Dans le pied de carte, pas
+           dans la barre de saisie déjà chargée — ça se règle par discussion,
+           pas par message. -->
+      <div id="mode-seg" role="group" aria-label="Mode de la discussion">
+        <button type="button" data-mode="chat" class="on" onclick="setMode('chat')">Chat</button>
+        <button type="button" data-mode="code" onclick="setMode('code')">Code</button>
+      </div>
       <div id="ctxtrack"><div id="ctx-fill"></div></div>
       <span id="status-preset" class="muted" style="font-size:10px;letter-spacing:.03em;white-space:nowrap;overflow:hidden;text-overflow:ellipsis"></span>
       <!-- Pied de carte, à droite : le décompte de contexte, compacter, puis le
@@ -361,18 +429,6 @@
       <span style="display:flex;align-items:center;gap:8px;margin-left:auto">
         <span id="ctx-text" class="muted">0 / 0</span>
         <button id="ctx-compact" onclick="compactContext()">compacter</button>
-        <!-- Fichiers produits par l'agent : ouvre le panneau de droite. Même
-             gabarit que le trombone — ce sont les deux faces du même sujet,
-             ce qui entre et ce qui sort. -->
-        <button id="files-btn" onclick="toggleFiles()" title="Fichiers du dossier de travail" aria-label="Fichiers du dossier de travail" aria-expanded="false">
-          <svg viewBox="0 0 24 24" width="13" height="13" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M3 7a2 2 0 0 1 2-2h4l2 2h8a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"/></svg>
-        </button>
-        <input type="file" id="attach-input" multiple style="display:none" onchange="onAttachPick(event)">
-        <button id="attach" onclick="document.getElementById('attach-input').click()" title="joindre un fichier" aria-label="joindre un fichier">
-          <!-- Trombone dessiné en SVG : pas de dépendance à une police d'emoji,
-               dont le rendu varie énormément d'un système à l'autre. -->
-          <svg viewBox="0 0 24 24" width="12" height="12" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M21.4 11.05 12.25 20.2a5.5 5.5 0 0 1-7.78-7.78l9.19-9.19a3.67 3.67 0 1 1 5.18 5.18l-9.2 9.2a1.83 1.83 0 1 1-2.59-2.6l8.49-8.48"/></svg>
-        </button>
       </span>
     </div>
     <!-- Pièces jointes en attente : remplie par addFiles(), vidée à l'envoi.
@@ -380,37 +436,69 @@
          qui la sépare du fil — la carte ne bouge donc pas d'un pixel. -->
     <div id="attach-list"></div>
     <div id="inputbar">
-      <textarea id="input" rows="1" placeholder="message…" onkeydown="onKey(event)" oninput="autoGrow(this)" onpaste="onPaste(event)"></textarea>
-      <button id="send" onclick="send()">send</button>
-      <button id="stop" onclick="stopGen()" style="display:none;background:var(--danger-bg);border-color:var(--err);color:var(--err)">stop</button>
+      <textarea id="input" rows="1" placeholder="Message Loki…" onkeydown="onKey(event)" oninput="autoGrow(this)" onpaste="onPaste(event)"></textarea>
+      <input type="file" id="attach-input" multiple style="display:none" onchange="onAttachPick(event)">
+      <!-- Intensité du raisonnement : réglable ici parce que ça se décide au
+           moment d'écrire le message, pas dans un éditeur de preset. -->
+      <select id="think-effort" title="Intensité du raisonnement" aria-label="Intensité du raisonnement" onchange="setThinkEffort(this.value)">
+        <option value="">auto</option>
+        <option value="none">aucune</option>
+        <option value="low">basse</option>
+        <option value="medium">moyenne</option>
+        <option value="high">haute</option>
+        <option value="xhigh">maximale</option>
+      </select>
+      <!-- Joindre un fichier. Icône dessinée en SVG : pas de dépendance à une
+           police d'emoji, dont le rendu varie énormément d'un système à l'autre. -->
+      <button id="attach" onclick="document.getElementById('attach-input').click()" title="joindre un fichier" aria-label="joindre un fichier">
+        <svg viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M12 16V4"/><path d="m7.5 8.5 4.5-4.5 4.5 4.5"/><path d="M4 15v3a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-3"/></svg>
+      </button>
+      <!-- Fichiers de la discussion : ouvre le panneau de droite. Même gabarit
+           que le dépôt — ce sont les deux faces du même sujet, ce qui entre et
+           ce qui sort. -->
+      <button id="files-btn" onclick="toggleFiles()" title="Fichiers de cette discussion" aria-label="Fichiers de cette discussion" aria-expanded="false">
+        <svg viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M3 7a2 2 0 0 1 2-2h4l2 2h8a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"/></svg>
+      </button>
+      <!-- Envoi : pastille ronde à flèche, comme la maquette. Le mot « Envoyer »
+           reste porté par aria-label et l'infobulle — l'action garde son nom
+           pour un lecteur d'écran, elle ne l'affiche simplement plus. -->
+      <button id="send" onclick="send()" title="Envoyer" aria-label="Envoyer">
+        <svg viewBox="0 0 24 24" width="18" height="18" fill="currentColor" stroke="none" aria-hidden="true"><path d="M3.4 20.4 21 12 3.4 3.6l.02 6.53L15.5 12 3.42 13.87z"/></svg>
+      </button>
+      <button id="stop" onclick="stopGen()" title="Arrêter la génération" aria-label="Arrêter la génération">
+        <svg viewBox="0 0 24 24" width="18" height="18" fill="currentColor" stroke="none" aria-hidden="true"><rect x="5" y="5" width="14" height="14" rx="3"/></svg>
+      </button>
     </div>
     <div id="sendhint" class="muted">Entrée pour envoyer · Maj+Entrée = nouvelle ligne</div>
   </div>
 </div>
-<!-- Fichiers : ce que l'agent a écrit dans son dossier de travail. Panneau de
-     DROITE, symétrique des réglages à gauche, ouvert et fermé par le bouton
-     dossier du pied de carte. Il ne se remplit qu'à l'ouverture (loadFiles) —
-     un ReadDir à chaque chargement de page pour un panneau fermé serait payé
-     par tout le monde et utile à personne. -->
+<!-- Fichiers : ce qui appartient à la DISCUSSION ouverte — pièces jointes
+     déposées, captures, ce que l'agent y a écrit. Panneau de DROITE, symétrique
+     des réglages à gauche, ouvert et fermé par le bouton dossier du pied de
+     carte. Il ne se remplit qu'à l'ouverture (loadFiles) — un ReadDir à chaque
+     chargement de page pour un panneau fermé serait payé par tout le monde et
+     utile à personne. -->
 <div id="files-backdrop" onclick="toggleFiles()"></div>
-<aside id="files" aria-label="Fichiers du dossier de travail">
+<aside id="files" aria-label="Fichiers de cette discussion">
   <div class="files-head">
+    <!-- Titre court : le panneau est déjà nommé par son contexte, et le libellé
+         complet reste porté par l'aria-label de la section. -->
     <span class="stitle">Fichiers</span>
-    <button id="files-refresh" onclick="loadFiles()" title="rafraîchir">↻</button>
-    <button id="files-close" onclick="toggleFiles()" title="fermer" aria-label="Fermer">×</button>
+    <button id="files-refresh" onclick="loadFiles()" title="rafraîchir" aria-label="rafraîchir"><svg viewBox="0 0 24 24" width="15" height="15" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M20.5 12a8.5 8.5 0 1 1-2.5-6"/><path d="M20.5 3.5V9H15"/></svg></button>
+    <button id="files-close" onclick="toggleFiles()" title="fermer" aria-label="Fermer"><svg viewBox="0 0 24 24" width="15" height="15" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M6.5 6.5l11 11"/><path d="M17.5 6.5l-11 11"/></svg></button>
   </div>
-  <!-- Fil d'Ariane : le dossier de travail contient des sous-dossiers (captures
-       par discussion), il faut pouvoir y descendre et en remonter. -->
+  <!-- Fil d'Ariane : le dossier de la discussion a des sous-dossiers (uploads,
+       captures), il faut pouvoir y descendre et en remonter. -->
   <div id="files-crumb" class="files-crumb"></div>
   <div id="files-list" class="files-list"></div>
   <div id="files-foot" class="files-foot muted"></div>
 </aside>
 <div id="toast"></div>
 <div id="bench-modal" style="display:none;position:fixed;inset:0;background:rgba(0,0,0,.45);z-index:30;align-items:center;justify-content:center;padding:20px" onclick="if(event.target===this)closeBenchModal()">
-  <div style="background:var(--bg);border:1px solid var(--border);border-radius:8px;width:100%;max-width:480px;display:flex;flex-direction:column">
+  <div style="background:var(--bg);border:1px solid var(--border);border-radius:4px;width:100%;max-width:480px;display:flex;flex-direction:column">
     <div style="padding:14px 16px;border-bottom:1px solid var(--border);display:flex;justify-content:space-between;align-items:center">
       <strong>Benchmark</strong>
-      <button onclick="closeBenchModal()" style="margin:0">×</button>
+      <button onclick="closeBenchModal()" style="margin:0" title="fermer" aria-label="Fermer"><svg viewBox="0 0 24 24" width="15" height="15" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M6.5 6.5l11 11"/><path d="M17.5 6.5l-11 11"/></svg></button>
     </div>
     <div id="bench-body" style="padding:18px 20px;display:flex;flex-direction:column;gap:12px"></div>
     <div style="padding:12px 16px;border-top:1px solid var(--border);display:flex;justify-content:flex-end;gap:6px">
@@ -427,7 +515,7 @@
   <div class="modal-card" style="max-width:460px">
     <div class="modal-head">
       <strong>Exporter la conversation</strong>
-      <button class="modal-x" onclick="closeExportModal()" title="fermer">×</button>
+      <button class="modal-x" onclick="closeExportModal()" title="fermer" aria-label="Fermer"><svg viewBox="0 0 24 24" width="15" height="15" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M6.5 6.5l11 11"/><path d="M17.5 6.5l-11 11"/></svg></button>
     </div>
     <!-- Conversation vide : pas d'options à régler, un seul message. Proposer
          des réglages pour un fichier qui ne contiendrait rien n'a aucun sens. -->
@@ -500,10 +588,10 @@
   <div class="modal-card" style="max-width:560px">
     <div class="modal-head">
       <strong>Backends personnalisés</strong>
-      <button class="modal-x" onclick="closeCustomBackends()" aria-label="Fermer">×</button>
+      <button class="modal-x" onclick="closeCustomBackends()" aria-label="Fermer"><svg viewBox="0 0 24 24" width="15" height="15" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M6.5 6.5l11 11"/><path d="M17.5 6.5l-11 11"/></svg></button>
     </div>
     <div class="modal-body mform">
-      <div class="muted" style="font-size:12px;line-height:1.5">Compile un fork de llama.cpp depuis un dépôt Git — pour les modèles qui exigent un moteur spécial (quant ternaire, etc.). Un backend personnalisé <b>ne remplace pas</b> le moteur : vous le choisissez ensuite <b>par modèle</b> (bouton ✎ → section Moteur → « backend détecté »).</div>
+      <div class="muted" style="font-size:12px;line-height:1.5">Compile un fork de llama.cpp depuis un dépôt Git — pour les modèles qui exigent un moteur spécial (quant ternaire, etc.). Un backend personnalisé <b>ne remplace pas</b> le moteur : vous le choisissez ensuite <b>par modèle</b> (bouton crayon → section Moteur → « backend détecté »).</div>
       <div class="fld">
         <label class="fld-l">Installés</label>
         <div id="lc-custom-list" class="mcp-list"></div>
@@ -526,11 +614,28 @@
     </div>
   </div>
 </div>
+<div id="mcp-catalog-modal" class="modal-ov" style="display:none" onclick="if(event.target===this)closeMcpCatalog()">
+  <div class="modal-card" style="max-width:640px">
+    <div class="modal-head">
+      <strong>Catalogue MCP</strong>
+      <button class="modal-x" onclick="closeMcpCatalog()" aria-label="Fermer"><svg viewBox="0 0 24 24" width="15" height="15" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M6.5 6.5l11 11"/><path d="M17.5 6.5l-11 11"/></svg></button>
+    </div>
+    <div class="modal-body">
+      <div class="muted" style="font-size:12px;margin-bottom:8px">
+        Serveurs connus, embarqués dans Loki — aucun appel réseau pour cette liste.
+        « Utiliser » remplit le formulaire d'ajout : la commande s'exécutera sur
+        cette machine, relis-la avant d'enregistrer.
+      </div>
+      <div id="mcp-catalog-tabs" class="mcp-cat-tabs"></div>
+      <div id="mcp-catalog-list" class="mcp-cat-list"></div>
+    </div>
+  </div>
+</div>
 <div id="mcp-modal" class="modal-ov" style="display:none" onclick="if(event.target===this)closeMcp()">
   <div class="modal-card" style="max-width:560px">
     <div class="modal-head">
       <strong id="mcp-modal-title">Serveur MCP</strong>
-      <button class="modal-x" onclick="closeMcp()" aria-label="Fermer">×</button>
+      <button class="modal-x" onclick="closeMcp()" aria-label="Fermer"><svg viewBox="0 0 24 24" width="15" height="15" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M6.5 6.5l11 11"/><path d="M17.5 6.5l-11 11"/></svg></button>
     </div>
     <div class="modal-body mform">
       <div class="fld">
@@ -585,11 +690,111 @@
     </div>
   </div>
 </div>
+<div id="task-modal" class="modal-ov" style="display:none" onclick="if(event.target===this)closeTask()">
+  <div class="modal-card">
+    <div class="modal-head">
+      <strong id="task-modal-title">Tâche planifiée</strong>
+      <button class="modal-x" onclick="closeTask()" aria-label="Fermer">×</button>
+    </div>
+    <div class="pe-body">
+      <div id="task-result-block" class="pe-group" style="display:none">
+        <div class="pe-gh">Dernier résultat <span id="task-result-when" class="pe-sub" style="display:inline;margin:0"></span></div>
+        <div id="task-result" class="task-report"></div>
+      </div>
+
+      <div class="pe-group">
+        <div class="pe-gh">Nom</div>
+        <div class="pe-list">
+          <div class="pe-row stack plain"><input id="task-name" class="pe-inp" placeholder="Nom de la tâche"></div>
+        </div>
+      </div>
+
+      <div class="pe-group">
+        <div class="pe-gh">Consigne</div>
+        <textarea id="task-prompt" class="pe-inp task-consigne" spellcheck="false" placeholder="Ce que l'IA doit faire, et comment livrer le résultat.&#10;&#10;Tu peux détailler librement : contexte, étapes, format du compte-rendu attendu…"></textarea>
+      </div>
+
+      <div class="pe-group">
+        <div class="pe-gh">Preset</div>
+        <div class="pe-list">
+          <div class="pe-row">
+            <span class="pe-row-l">Modèle utilisé</span>
+            <span class="pe-row-c"><span class="pe-selc"><select id="task-preset"></select></span></span>
+          </div>
+        </div>
+      </div>
+
+      <div class="pe-group">
+        <div class="pe-gh">Fréquence</div>
+        <div class="pe-seg">
+          <label><input type="radio" name="task-freq-mode" value="interval" onchange="taskFreqUI('interval')"><span>Intervalle</span></label>
+          <label><input type="radio" name="task-freq-mode" value="cron" onchange="taskFreqUI('cron')"><span>Horaire précis</span></label>
+        </div>
+        <div class="pe-list" style="margin-top:8px">
+          <div id="task-interval-fields" class="pe-row">
+            <span class="pe-row-l">Toutes les</span>
+            <span class="pe-row-c">
+              <input id="task-interval-n" class="pe-val" type="number" min="1" value="2" style="width:54px">
+              <span class="pe-selc"><select id="task-interval-unit" onchange="taskUnitUI()">
+                <option value="m">minutes</option>
+                <option value="h" selected>heures</option>
+                <option value="d">jours</option>
+              </select></span>
+            </span>
+          </div>
+          <div id="task-time-row" class="pe-row" style="display:none">
+            <span class="pe-row-l">À</span>
+            <span class="pe-row-c"><input id="task-time" class="pe-val" type="time" value="09:00" style="width:110px"></span>
+          </div>
+          <div id="task-cron-fields" class="pe-row stack" style="display:none">
+            <input id="task-cron" class="pe-inp" placeholder="0 9 * * 1-5" spellcheck="false" style="font-family:var(--mono)">
+            <div class="pe-note"><code>minute heure jour mois jour-semaine</code></div>
+          </div>
+        </div>
+      </div>
+
+      <div class="pe-group">
+        <div class="pe-gh">Accès</div>
+        <div class="pe-list">
+          <div class="pe-row">
+            <span class="pe-row-l">Accès à la mémoire</span>
+            <span class="pe-row-c"><label class="pe-switch"><input type="checkbox" id="task-mem" checked><span class="pe-sl"></span></label></span>
+          </div>
+          <div class="pe-row">
+            <span class="pe-row-l">Accès au web</span>
+            <span class="pe-row-c"><label class="pe-switch"><input type="checkbox" id="task-web" checked><span class="pe-sl"></span></label></span>
+          </div>
+        </div>
+      </div>
+
+      <div class="pe-group">
+        <div class="pe-list">
+          <div class="pe-row">
+            <span class="pe-row-l">Tâche active</span>
+            <span class="pe-row-c"><label class="pe-switch"><input type="checkbox" id="task-enabled" checked><span class="pe-sl"></span></label></span>
+          </div>
+        </div>
+      </div>
+
+      <div id="task-modal-status" class="pe-seg-note" style="padding:0 6px"></div>
+    </div>
+    <div class="pe-foot">
+      <div class="foot-l">
+        <button id="task-del" class="pe-del" onclick="deleteTaskUI()" title="supprimer" aria-label="supprimer" style="display:none"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M3 6h18"/><path d="M8 6V4a1 1 0 011-1h6a1 1 0 011 1v2"/><path d="M19 6l-1 14a2 2 0 01-2 2H8a2 2 0 01-2-2L5 6"/><path d="M10 11v6"/><path d="M14 11v6"/></svg></button>
+      </div>
+      <div class="foot-r">
+        <button id="task-run" class="pe-btn" onclick="runTaskNow()" style="display:none">tester maintenant</button>
+        <button class="pe-btn" onclick="closeTask()">annuler</button>
+        <button class="pe-btn primary" onclick="saveTask()">enregistrer</button>
+      </div>
+    </div>
+  </div>
+</div>
 <div id="modal" class="modal-ov" style="display:none">
   <div class="modal-card">
     <div class="modal-head">
       <strong id="modal-title">Preset</strong>
-      <button class="modal-x" onclick="closeModal()" aria-label="Fermer">×</button>
+      <button class="modal-x" onclick="closeModal()" aria-label="Fermer"><svg viewBox="0 0 24 24" width="15" height="15" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M6.5 6.5l11 11"/><path d="M17.5 6.5l-11 11"/></svg></button>
     </div>
     <!-- Chargement : la modale s'ouvre tout de suite, mais son contenu n'arrive
          qu'après (jusqu'à 3 requêtes en accès distant). Ce voile se pose PAR-DESSUS
@@ -637,7 +842,7 @@
               <span class="pe-row-l">Télécharger un modèle <span class="pe-sub">ou un projecteur mmproj — lien direct vers un .gguf</span></span>
               <div class="pe-inpbtn">
                 <input id="m-hf-url" class="pe-inp" placeholder="https://…/model.gguf">
-                <button id="m-hf-btn" onclick="startDownload()" title="Télécharger">↓</button>
+                <button id="m-hf-btn" onclick="startDownload()" title="Télécharger" aria-label="Télécharger"><svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M12 4v11"/><path d="M7.5 10.5 12 15l4.5-4.5"/><path d="M4.5 19.5h15"/></svg></button>
               </div>
               <div id="m-hf-bar" class="pe-bar" style="display:none"><i></i></div>
               <div id="m-hf-progress" class="pe-note" style="display:none"></div>
@@ -659,6 +864,23 @@
               </div>
               <div class="pe-note">Ces dossiers servent aussi de destination de téléchargement.</div>
             </div>
+            <!-- Jeton Hugging Face. Replié comme « Dossiers de modèles » : on n'y
+                 touche qu'une fois, le jour où un dépôt à accès restreint refuse
+                 le téléchargement. Il vaut aussi pour la recherche, d'où sa place
+                 dans ce groupe plutôt qu'à côté de la clé API du serveur, qui ne
+                 parle pas du tout de la même chose. -->
+            <div id="m-hft-toggle" class="pe-row" style="cursor:pointer" onclick="toggleHFToken()">
+              <span class="pe-row-l">Jeton Hugging Face<span class="pe-sub">dépôts à accès restreint (« gated ») ou privés</span></span>
+              <span class="pe-row-c"><span id="m-hft-state" class="pe-sub"></span><span id="m-hft-caret" class="pe-caret"></span></span>
+            </div>
+            <div id="m-hft-body" class="pe-row stack" style="display:none">
+              <div class="pe-inpbtn">
+                <input id="m-hft-input" class="pe-inp" type="password" autocomplete="off" spellcheck="false" placeholder="hf_…" onkeydown="if(event.key==='Enter'){event.preventDefault();saveHFToken();}">
+                <button id="m-hft-save" onclick="saveHFToken()" title="Vérifier et enregistrer" aria-label="Enregistrer">✓</button>
+              </div>
+              <div id="m-hft-note" class="pe-note"></div>
+              <button id="m-hft-clear" class="pe-link" onclick="clearHFToken()" style="display:none">Retirer le jeton</button>
+            </div>
           </div>
         </div>
 
@@ -671,7 +893,7 @@
             <label id="be-lab-image" style="display:none"><input type="radio" name="m-be" value="image" onchange="onBackendMode('image')"><span>Image</span><span class="be-note" id="be-image-note"></span></label>
             <label id="be-lab-fast"><input type="radio" name="m-be" value="fast" onchange="onBackendMode('fast')"><span>Précompilé</span><span class="be-note" id="be-fast-note"></span></label>
             <label id="be-lab-opt"><input type="radio" name="m-be" value="opt" onchange="onBackendMode('opt')"><span>Compilé</span><span class="be-note" id="be-opt-note"></span></label>
-            <label><input type="radio" name="m-be" value="custom" onchange="onBackendMode('custom')"><span>Personnalisé</span></label>
+            <label id="be-lab-custom"><input type="radio" name="m-be" value="custom" onchange="onBackendMode('custom')"><span>Personnalisé</span></label>
           </div>
           <div id="m-backend-custom" class="pe-list" style="display:none;margin-top:8px">
             <div class="pe-row">
@@ -773,6 +995,19 @@
             <span class="pe-row-l">Raisonnement<span class="pe-sub" id="s-reasoning-sub">réflexion étape par étape</span></span>
             <span class="pe-row-c"><label class="pe-switch"><input type="checkbox" id="s-reasoning" onchange="cfgWriteKey('REASONING', this.checked?'on':'off')"><span class="pe-sl"></span></label></span>
           </div>
+          <div class="pe-row" id="s-reasoning-effort-row">
+            <span class="pe-row-l">Intensité du raisonnement<span class="pe-sub" id="s-reasoning-effort-sub">défaut de ce preset — ajustable à la volée depuis la barre de saisie</span></span>
+            <span class="pe-row-c">
+              <select id="s-reasoning-effort" class="pe-val" onchange="cfgWriteKey('REASONING_EFFORT', this.value)">
+                <option value="">auto</option>
+                <option value="none">aucune</option>
+                <option value="low">basse</option>
+                <option value="medium">moyenne</option>
+                <option value="high">haute</option>
+                <option value="xhigh">maximale</option>
+              </select>
+            </span>
+          </div>
           <div class="pe-row">
             <span class="pe-row-l">Flash attention<span class="pe-sub">plus rapide, moins de VRAM</span></span>
             <span class="pe-row-c"><label class="pe-switch"><input type="checkbox" id="s-flash" onchange="eaSetValued('--flash-attn', this.checked?'on':'')"><span class="pe-sl"></span></label></span>
@@ -788,6 +1023,42 @@
         </div>
       </div>
 
+      <!-- Échantillonnage (repris de l'amont AJEAN v0.9.5/v0.9.6) : ces valeurs
+           partent dans CHAQUE requête de complétion, pas sur la ligne de commande
+           du moteur — c'est le seul endroit où elles prennent effet. Un champ vide
+           n'envoie rien, llama-server garde son défaut. Les valeurs recommandées
+           dépendent du modèle (Qwen3.8 en réflexion : temp 1.0, top_p 0.95,
+           top_k 20, min_p 0). -->
+      <div id="m-sampling-row" class="pe-group" style="display:none">
+        <div class="pe-gh">Échantillonnage</div>
+        <div class="pe-list">
+          <div class="pe-row">
+            <span class="pe-row-l">Température<span class="pe-sub">vide = défaut du modèle</span></span>
+            <span class="pe-row-c"><input id="s-temp" class="pe-val" type="number" min="0" step="0.05" placeholder="—" oninput="cfgWriteKey('TEMP', this.value)"></span>
+          </div>
+          <div class="pe-row">
+            <span class="pe-row-l">top_p<span class="pe-sub">noyau de probabilité</span></span>
+            <span class="pe-row-c"><input id="s-topp" class="pe-val" type="number" min="0" max="1" step="0.01" placeholder="—" oninput="cfgWriteKey('TOP_P', this.value)"></span>
+          </div>
+          <div class="pe-row">
+            <span class="pe-row-l">top_k<span class="pe-sub">0 = désactivé</span></span>
+            <span class="pe-row-c"><input id="s-topk" class="pe-val" type="number" min="0" step="1" placeholder="—" oninput="cfgWriteKey('TOP_K', this.value)"></span>
+          </div>
+          <div class="pe-row">
+            <span class="pe-row-l">min_p<span class="pe-sub">seuil de probabilité</span></span>
+            <span class="pe-row-c"><input id="s-minp" class="pe-val" type="number" min="0" max="1" step="0.01" placeholder="—" oninput="cfgWriteKey('MIN_P', this.value)"></span>
+          </div>
+          <div class="pe-row">
+            <span class="pe-row-l">Pénalité de présence<span class="pe-sub">pousse vers de nouveaux mots (0 = off)</span></span>
+            <span class="pe-row-c"><input id="s-presp" class="pe-val" type="number" min="0" max="2" step="0.1" placeholder="—" oninput="cfgWriteKey('PRESENCE_PENALTY', this.value)"></span>
+          </div>
+          <div class="pe-row">
+            <span class="pe-row-l">Pénalité de répétition<span class="pe-sub">anti-répétition (1 = neutre)</span></span>
+            <span class="pe-row-c"><input id="s-reppen" class="pe-val" type="number" min="0" step="0.05" placeholder="—" oninput="cfgWriteKey('REPEAT_PENALTY', this.value)"></span>
+          </div>
+        </div>
+      </div>
+
       <div id="m-raw" class="pe-group">
         <div class="pe-gh" id="m-raw-head">Configuration</div>
         <div class="pe-list">

internal/loki/ui/src/js/01-theme.js

@@ -24,11 +24,14 @@ function initTheme(){
 // Quatre interrupteurs indépendants. Chacun pose un attribut sur <html> ; le CSS
 // fait le reste, sauf « replier les bulles » qui est un comportement (voir
 // 08-chat-render).
+//
+// « barre latérale escamotable » a disparu d'ici : la refonte l'escamote pour de
+// bon (bouton de l'en-tête, data-side — voir 18-shell.js), au lieu de la
+// transformer en tiroir qui recouvre la conversation.
 const VIEW_OPTS=[
   {id:'hide-reasoning', label:'masquer le raisonnement'},
   {id:'hide-tools',     label:"masquer les appels d'outils"},
   {id:'fold-tools',     label:'garder les bulles repliées'},
-  {id:'hide-side',      label:'barre latérale escamotable'},
   {id:'hide-stats',     label:'masquer la vitesse de génération'},
 ];
 function viewOn(id){ return document.documentElement.getAttribute('data-'+id)==='1'; }
@@ -36,12 +39,6 @@ function applyView(id, on){
   document.documentElement.setAttribute('data-'+id, on?'1':'0');
   try{ localStorage.setItem('loki-'+id, on?'1':'0'); }catch(e){}
   const box=document.getElementById('view-'+id); if(box) box.checked=!!on;
-  // La barre latérale peut rester ouverte quand on repasse en mode fixe.
-  if(id==='hide-side' && !on){
-    document.getElementById('side').classList.remove('open');
-    document.getElementById('backdrop').classList.remove('open');
-    document.body.classList.remove('drawer-open');
-  }
 }
 function toggleView(id){ applyView(id, document.getElementById('view-'+id).checked); savePrefs(); }
 function initView(){

internal/loki/ui/src/js/03-icons.js

@@ -0,0 +1,54 @@
+// ─── Jeu d'icônes ────────────────────────────────────────────────────────────
+// Un seul trait pour toute l'interface : 24 unités de côté, 1,8 d'épaisseur,
+// extrémités et jonctions arrondies — celui des deux icônes de la maquette
+// (dépôt et envoi), étendu au reste de l'application.
+//
+// Elles étaient jusqu'ici des GLYPHES DE TEXTE (↻ × ☰ 🗑 ✎ ↓ ▸). C'est le
+// système d'exploitation qui les dessinait : le même bouton sortait fin sur
+// macOS, gras et bleuté sur Windows (émojis en couleur), et carrément absent sur
+// un serveur sans police d'émojis. Aucune cohérence possible, et rien à régler
+// depuis la feuille de style. En SVG, elles suivent currentColor et la taille
+// qu'on leur donne.
+//
+// Ajouter une icône : une entrée ici, et rien d'autre — surtout pas un second
+// dessin ailleurs, c'est ainsi que le trait finit par diverger.
+const ICONS = {
+  menu:      '<path d="M4 7h16"/><path d="M4 12h16"/><path d="M4 17h16"/>',
+  close:     '<path d="M6.5 6.5l11 11"/><path d="M17.5 6.5l-11 11"/>',
+  refresh:   '<path d="M20.5 12a8.5 8.5 0 1 1-2.5-6"/><path d="M20.5 3.5V9H15"/>',
+  pencil:    '<path d="M4 20h4L19 9a2.1 2.1 0 0 0-3-3L5 17z"/><path d="M14.5 7.5l3 3"/>',
+  trash:     '<path d="M4 7h16"/><path d="M9.5 7V4.5h5V7"/><path d="M6.5 7l1 12.5h9l1-12.5"/>',
+  download:  '<path d="M12 4v11"/><path d="M7.5 10.5 12 15l4.5-4.5"/><path d="M4.5 19.5h15"/>',
+  arrowDown: '<path d="M12 5v14"/><path d="M6 13l6 6 6-6"/>',
+  folder:    '<path d="M3 7a2 2 0 0 1 2-2h4l2 2h8a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"/>',
+  file:      '<path d="M13.5 3.5H7A1.5 1.5 0 0 0 5.5 5v14A1.5 1.5 0 0 0 7 20.5h10a1.5 1.5 0 0 0 1.5-1.5V8.5z"/><path d="M13.5 3.5V8.5h5"/>',
+  image:     '<rect x="3.5" y="5" width="17" height="14" rx="2"/><circle cx="8.5" cy="10" r="1.4"/><path d="M4.5 17.5 10 12l3.5 3.5L16 13l3.5 3.5"/>',
+  plus:      '<path d="M12 5.5v13"/><path d="M5.5 12h13"/>',
+  chevron:   '<path d="M9.5 5.5 16 12l-6.5 6.5"/>',
+  search:    '<circle cx="11" cy="11" r="6.5"/><path d="M20 20l-4.4-4.4"/>',
+  // Anneau ouvert : c'est la ROTATION (CSS) qui en fait un indicateur d'activité,
+  // le dessin reste au même trait que le reste du jeu.
+  spinner:   '<path d="M12 3.5a8.5 8.5 0 1 1-8.5 8.5"/>',
+  sun:       '<circle cx="12" cy="12" r="4.2"/><path d="M12 2.5v2.2"/><path d="M12 19.3v2.2"/><path d="M4.2 4.2l1.6 1.6"/><path d="M18.2 18.2l1.6 1.6"/><path d="M2.5 12h2.2"/><path d="M19.3 12h2.2"/><path d="M4.2 19.8l1.6-1.6"/><path d="M18.2 5.8l1.6-1.6"/>',
+};
+
+// iconHTML rend l'icône en chaîne, pour les endroits qui composent déjà du
+// balisage. `aria-hidden` : le sens est porté par le title/aria-label du bouton,
+// jamais par le dessin.
+function iconHTML(name, size){
+  const d = ICONS[name];
+  if(!d) return '';
+  const n = size || 18;
+  return '<svg viewBox="0 0 24 24" width="' + n + '" height="' + n + '" fill="none" '
+    + 'stroke="currentColor" stroke-width="1.8" stroke-linecap="round" '
+    + 'stroke-linejoin="round" aria-hidden="true">' + d + '</svg>';
+}
+
+// icon rend l'icône en ÉLÉMENT, pour les listes construites en DOM (fichiers,
+// discussions) où l'on ne veut pas d'innerHTML.
+function icon(name, size){
+  const span = document.createElement('span');
+  span.className = 'icn';
+  span.innerHTML = iconHTML(name, size); // contenu constant, jamais de donnée
+  return span.firstElementChild || span;
+}

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

@@ -9,7 +9,12 @@ async function loadStatus(){
   let cls='err', txt='arrêté';
   if(s.active && s.health){ cls='ok'; txt='prêt'; }
   else if(s.load_error){ cls='err'; txt='erreur'; }
-  else if(s.active){ cls='loading'; txt='chargement…'; }
+  else if(s.active){
+    cls='loading'; txt='chargement…';
+    // Pourcentage estimé (octets du modèle déjà lus) : voir « ça avance »
+    // plutôt qu'un « chargement… » figé qui ressemble à un plantage.
+    if(typeof s.load_pct==='number' && s.load_pct>=0) txt='chargement '+s.load_pct+' %';
+  }
   el.className='statuspill '+cls;
   el.innerHTML='<span class="dot"></span>'+txt;
   MODEL_READY = !!(s.active && s.health);
@@ -42,7 +47,9 @@ async function loadStatus(){
 function toggleSvcLog(){
   const box=document.getElementById('svc-log-box');
   if(!box) return;
-  box.open = !box.open;
+  // openDetails déplie aussi « Réglages » : sans lui, la section s'ouvrait à
+  // l'intérieur d'un repli fermé — donc nulle part, du point de vue de l'écran.
+  if(box.open) box.open = false; else openDetails(box);
 }
 async function loadSvcLog(){
   const el=document.getElementById('svc-log');
@@ -127,30 +134,64 @@ function updateCtxMeter(){
   // puisse compacter à la demande avant que l'auto-compaction (75%) ne s'en charge.
   document.getElementById('ctx-compact').style.display = (pct>=50 && CTX_USED>0) ? 'inline-block' : 'none';
 }
+// ─── Moniteur machine (pied de barre latérale) ───────────────────────────────
+// Une jauge par ressource : nom, pourcentage, barre, puis le détail chiffré en
+// dessous. C'est la hiérarchie de la maquette — on lit la charge d'un coup
+// d'œil, et le détail (Gio, température) reste là pour qui le cherche.
+//
+// Construit EN DOM et non en innerHTML : les noms de GPU viennent du pilote,
+// donc d'ailleurs. Même règle que pour les noms de fichiers et les titres de
+// discussions.
+function perfRow(label, pct, title){
+  pct = Math.max(0, Math.min(100, Math.round(pct||0)));
+  const row=document.createElement('div'); row.className='perf-row';
+  if(title) row.title=title;
+  const l=document.createElement('div'); l.className='perf-l';
+  const b=document.createElement('b'); b.textContent=label;
+  const v=document.createElement('span'); v.className='perf-pct'; v.textContent=pct+'%';
+  l.append(b,v);
+  const track=document.createElement('div'); track.className='perf-track';
+  const fill=document.createElement('div');
+  // Sauge jusqu'à 75 %, ambre au-delà, rouille à 90 : la couleur ne sert à rien
+  // tant que la machine respire, elle doit sauter aux yeux quand elle sature.
+  fill.className='perf-fill'+(pct>=90?' max':pct>=75?' hot':'');
+  fill.style.width=pct+'%';
+  track.appendChild(fill);
+  row.append(l,track);
+  return row;
+}
 async function loadVram(){
   const gpus=await jget('/api/vram');
-  // Bloc de statistique : intitulé + valeur sur une ligne, jauge, détail dessous.
-  // Même gabarit que la RAM (voir .stat dans le CSS) — le HTML libre d'avant
-  // collait aux bords de la carte.
-  document.getElementById('vram').innerHTML = (gpus||[]).map(g=>{
-    const pct=Math.round(g.used*100/g.total);
-    return '<div class="stat"><div class="stat-h"><span class="stat-n">'+g.name+'</span>'+
-      '<span class="stat-v">'+(g.used/1024).toFixed(1)+' / '+(g.total/1024).toFixed(1)+' GiB</span></div>'+
-      '<div class="bar"><div style="width:'+pct+'%"></div></div>'+
-      '<div class="stat-s">GPU '+g.util+' % · '+g.temp+' °C</div></div>';
-  }).join('') || '<div class="stat"><span class="stat-s">(pas de GPU)</span></div>';
+  const box=document.getElementById('vram');
+  if(!box) return;
+  box.textContent='';
+  if(!gpus || !gpus.length){
+    const d=document.createElement('div'); d.className='perf-sub'; d.textContent='(pas de GPU détecté)';
+    box.appendChild(d);
+    return;
+  }
+  // Deux mesures par carte, deux jauges — une seule barre ne peut pas porter la
+  // charge du processeur ET le remplissage de la mémoire vidéo, et pour du LLM
+  // c'est la VRAM qui décide si un modèle tient. Sur une machine à UNE carte on
+  // retombe exactement sur les trois jauges de la maquette (GPU, VRAM, RAM).
+  const many = gpus.length > 1;
+  gpus.forEach((g,i)=>{
+    const vram=(g.used/1024).toFixed(1)+' / '+(g.total/1024).toFixed(1)+' Gio';
+    box.appendChild(perfRow('GPU '+i, g.util, g.name+' · '+vram+' · '+g.temp+' °C'));
+    box.appendChild(perfRow(many ? 'VRAM '+i : 'VRAM', g.used*100/g.total,
+      g.name+' · '+vram));
+  });
 }
 async function loadRam(){
   const m=await jget('/api/ram');
   const box=document.getElementById('ram-details');
-  if(!m || !m.total){ if(box) box.style.display='none'; return; }
-  if(box) box.style.display='';
-  const pct=Math.round(m.used*100/m.total);
-  document.getElementById('ram').innerHTML =
-    '<div class="stat"><div class="stat-h"><span class="stat-n">Mémoire vive</span>'+
-    '<span class="stat-v">'+(m.used/1024).toFixed(1)+' / '+(m.total/1024).toFixed(1)+' GiB</span></div>'+
-    '<div class="bar"><div style="width:'+pct+'%"></div></div>'+
-    '<div class="stat-s">'+pct+' % utilisée</div></div>';
+  if(!box) return;
+  if(!m || !m.total){ box.style.display='none'; return; }
+  box.style.display='';
+  const host=document.getElementById('ram');
+  host.textContent='';
+  host.appendChild(perfRow('Mémoire vive', m.used*100/m.total,
+    (m.used/1024).toFixed(1)+' / '+(m.total/1024).toFixed(1)+' Gio utilisés'));
 }
 async function loadCfg(){
   // /api/llamacpp en parallèle : il indique si le BIN de la config correspond au
@@ -165,11 +206,20 @@ async function loadCfg(){
     // En conteneur, le moteur vient de l'image : le dire, plutôt que de le
     // ranger dans « personnalisé » qui laisse croire à un bricolage.
     if(lc && lc.provided && sameBinPath(c.BIN, lc.provided_bin)) v='llama.cpp de l\'image';
+    // Moteur mis à jour depuis l'image officielle (Réglages → Moteur) : c'est la
+    // voie normale en conteneur, pas un « personnalisé ».
+    else if(lc && lc.engine && lc.engine.in_use){
+      const b = (lc.engine.tag||'').match(/b\d+$/);
+      v = b ? 'llama.cpp '+b[0]+' (mis à jour)' : 'llama.cpp mis à jour';
+    }
     else if(lc && lc.prebuilt && lc.prebuilt.in_use) v='llama.cpp précompilé';
     else if(lc && lc.in_use) v='llama.cpp compilé';
     else v='llama.cpp personnalisé : '+c.BIN;
     rows.push(row('MOTEUR', v, c.BIN));
   }
+  // Le modèle chargé alimente aussi le sélecteur de l'en-tête : c'est la seule
+  // source qui le connaisse quand aucun preset ne correspond à la configuration.
+  if(typeof setLoadedModel === 'function') setLoadedModel(c.MODEL || '');
   ['MODEL','CTX','BATCH','UBATCH','NGL'].filter(k=>c[k]).forEach(k=>{
     let v=c[k]; if(k==='MODEL') v=v.split('/').pop();
     rows.push(row(k, v));

internal/loki/ui/src/js/06-settings.js

@@ -44,6 +44,8 @@ async function loadPresets(){
   const sp = document.getElementById('status-preset');
   sp.textContent = act ? act.name : '';
   sp.title = act ? 'preset actif' : '';
+  // Sélecteur de modèle de l'en-tête : même donnée, autre point d'entrée.
+  if(typeof renderModelSwitch === 'function') renderModelSwitch(p, act);
   const cont=document.getElementById('presets');
   cont.innerHTML='';
   if(!p.length){ cont.innerHTML='<span class="muted">(aucun)</span>'; return; }
@@ -229,27 +231,39 @@ async function copyText(txt, msg){
 function copyApiKey(){ copyText(OAI_KEY, OAI_KEY?'clé copiée':'aucune clé'); }
 function renderApiKey(d){
   OAI_KEY = d.key || '';
-  // URL de l'endpoint : llama-server tourne sur d.port (≠ port de l'UI web).
-  // On prend l'hôte annoncé par le serveur (IP LAN détectée côté Go) : dans le
-  // tunnel ajean.link, location.hostname serait le domaine du relais (faux) —
-  // l'accès OpenAI reste TOUJOURS l'adresse locale de la machine.
-  const host = d.host || location.hostname;
-  document.getElementById('oai-url').value = 'http://'+host+':'+d.port+'/v1';
-  // Endpoint PUBLIC (ajean.link) : affiché seulement si l'accès public est activé.
-  const tg = document.getElementById('oai-public-toggle');
-  if(tg) tg.checked = !!d.oai_public;
-  const pubWrap = document.getElementById('oai-public-wrap');
-  if(d.oai_public && d.machine){
-    document.getElementById('oai-public-url').value = 'https://'+d.machine+'.oai.ajean.link/v1';
-    pubWrap.style.display = '';
-  } else {
-    pubWrap.style.display = 'none';
+  // L'adresse vient du SERVEUR (web_public_url.go) : adresse publique
+  // enregistrée, sinon l'origine par laquelle cette page a été ouverte. Elle
+  // était auparavant recomposée ici — 'http://'+host+':'+port+'/v1' — à partir
+  // du port du MOTEUR et d'une IP détectée côté Go, ce qui donnait en conteneur
+  // une adresse que personne ne pouvait joindre (bridge Docker, port non publié).
+  // location.origin ne sert plus que de filet si le serveur ne dit rien.
+  document.getElementById('oai-url').value = d.url || (location.origin + '/v1');
+  // Champ d'adresse publique : on ne l'écrase pas pendant la frappe.
+  const pa = document.getElementById('public-addr');
+  if(pa && document.activeElement !== pa) pa.value = d.public_url || '';
+  // Sans clé, l'endpoint est ouvert — et il l'est maintenant partout où
+  // l'interface l'est. Ça ne se dit pas à voix basse.
+  const warn = document.getElementById('oai-open-warn');
+  if(warn){
+    warn.style.display = d.set ? 'none' : '';
+    warn.textContent = d.set ? '' :
+      '⚠ Aucune clé : toute personne capable de joindre cette adresse peut utiliser votre modèle.';
   }
   const inp=document.getElementById('oai-key');
-  if(!d.set){ inp.value='(aucune clé — serveur ouvert)'; inp.style.opacity=.6; }
+  if(!d.set){ inp.value='(aucune clé — endpoint ouvert)'; inp.style.opacity=.6; }
   else { inp.style.opacity=1; inp.value = OAI_REVEAL ? OAI_KEY : d.masked; }
   document.getElementById('oai-key-eye').style.display = d.set ? '' : 'none';
 }
+// Enregistre l'adresse publique. Le serveur normalise et refuse en clair : on
+// relaie sa raison telle quelle, elle est écrite pour être lue.
+async function savePublicAddr(){
+  const inp = document.getElementById('public-addr');
+  if(!inp) return;
+  const r = await jpost('/api/oai/public', {url: inp.value});
+  if(!r || !r.ok){ toast('adresse refusée : ' + ((r && r.error) || '')); return; }
+  toast(r.url ? 'adresse enregistrée' : 'adresse effacée — celle du navigateur sera utilisée');
+  loadApiKey();
+}
 async function loadApiKey(){ renderApiKey(await jget('/api/apikey')); }
 // --- Export de la conversation ---------------------------------------------
 // xTurnsTotal : nombre d'échanges du fil, borne haute du curseur. Vient de
@@ -381,50 +395,11 @@ async function downloadExport(url){
     toast('exporté : ' + name);
   }catch(e){ toast('erreur : ' + e.message); }
 }
-// --- Écoute réseau du moteur (HOST + pare-feu) ------------------------------
-// Le retour d'utilisateur qui a motivé ce réglage : « à part le chat dans le
-// navigateur, impossible d'utiliser ton URL dans les logiciels en local ». Le
-// moteur écoutait sur 127.0.0.1 et rien ne le disait nulle part.
-function renderNetwork(st){
-  if(!st) return;
-  const cb = document.getElementById('lan-toggle');
-  if(cb) cb.checked = !!st.exposed;
-  const warn = document.getElementById('lan-warn');
-  if(!warn) return;
-  if(!st.exposed){
-    warn.style.display = '';
-    warn.innerHTML = '<div class="muted" style="margin:0">Le moteur n\'écoute que sur cette machine : l\'adresse ci-dessus ne répond pas depuis un autre ordinateur.</div>';
-    return;
-  }
-  // Exposé mais bloqué par le pare-feu : le cas le plus déroutant (« ça écoute
-  // partout » et pourtant rien ne passe). On donne la commande à coller.
-  if(st.hint){
-    warn.style.display = '';
-    // --err et non --warn : la palette est volontairement monochrome et --warn y
-    // est un gris, illisible comme alerte. Ici il y a une vraie action à faire.
-    warn.innerHTML = '<div style="margin:0;color:var(--err)">⚠ '
-      + escHtml(st.hint).replace(/\n/g,'<br>') + '</div>';
-    return;
-  }
-  warn.style.display = 'none';
-}
-async function loadNetwork(){
-  try{ const r = await jget('/api/network'); renderNetwork(r && r.status); }catch(e){}
-}
-async function toggleLAN(){
-  const cb = document.getElementById('lan-toggle');
-  const on = cb.checked;
-  const r = await jpost('/api/network', {exposed:on});
-  if(!r || !r.ok){ cb.checked = !on; toast('erreur : ' + ((r&&r.error)||'')); return; }
-  renderNetwork(r.status);
-  // llama-server ne lit --host qu'au lancement : sans redémarrage, l'interrupteur
-  // affiche un état que le moteur en cours ne respecte pas encore.
-  if(await askConfirm('Le moteur doit redémarrer pour appliquer ce changement (le modèle sera rechargé).',
-                      {title: on ? 'Ouvrir sur le réseau' : 'Fermer sur le réseau', okText:'Redémarrer'})){
-    await act('restart'); // même chemin que les boutons du panneau Moteur
-  }
-  loadApiKey();
-}
+// L'écoute réseau du moteur (HOST + pare-feu) n'a plus d'interrupteur : depuis
+// que Loki sert /v1 sur son propre port, ouvrir le moteur sur le réseau n'a plus
+// d'objet — et deux interrupteurs pour « rendre l'IA joignable » était
+// exactement la confusion qu'on voulait lever. La route /api/network et la
+// commande `loki network` restent, pour qui veut exposer le moteur en direct.
 function toggleKeyReveal(){ OAI_REVEAL=!OAI_REVEAL; const inp=document.getElementById('oai-key'); if(OAI_KEY) inp.value = OAI_REVEAL ? OAI_KEY : (OAI_KEY.slice(0,8)+'…'+OAI_KEY.slice(-4)); const eye=document.getElementById('oai-key-eye'); if(eye) eye.textContent = OAI_REVEAL ? 'masquer' : 'afficher'; }
 async function apiKeyAction(action){
   if(action==='clear' && !await askConfirm('Retirer la clé rend l\'endpoint OpenAI accessible SANS authentification. Le service va redémarrer.', {title:'Retirer la clé API ?', okText:'Retirer'})) return;
@@ -433,24 +408,6 @@ async function apiKeyAction(action){
   toast('application…');
   renderApiKey(await jpost('/api/apikey', {action}));
 }
-async function toggleOAIPublic(){
-  const cb = document.getElementById('oai-public-toggle');
-  const on = cb.checked;
-  // L'accès OpenAI public passe par ajean.link (<machine>.oai.ajean.link) : il exige
-  // que l'accès distant soit activé sur ce serveur. Sinon, on annule et on explique.
-  if(on){
-    let linked = false;
-    try{ const s = await jget('/api/link/status'); linked = !!(s && s.linked); }catch(e){}
-    if(!linked){
-      cb.checked = false;
-      await askAlert('Vous devez activer l\'accès distant (ajean.link) pour bénéficier de cette fonctionnalité. Ouvrez le panneau « Accès distant » pour connecter ce serveur.', {title:'Accès distant requis'});
-      return;
-    }
-  }
-  await jpost('/api/oai/public', {enabled:on});
-  toast(on ? 'accès public activé' : 'accès public coupé');
-  loadApiKey();
-}
 async function apiKeySet(){
   const k = await askPrompt('Colle ta clé API (ou laisse vide pour annuler) :', {title:'Définir la clé API', placeholder:'sk-…'});
   if(!k || !k.trim()) return;
@@ -494,7 +451,7 @@ async function loadAll(){
   // MANQUANTE lève ici une ReferenceError qui est avalée en silence. Toute
   // suppression de module doit donc retirer son appel de cette ligne, et le test
   // navigateur écoute `pageerror` pour ne pas s'en apercevoir trop tard.
-  await Promise.allSettled([loadStatus(),loadVram(),loadRam(),loadCfg(),loadPresets(),loadConversations(),loadIdentity(),loadAgent(),loadInternet(),loadMCP(),loadApiKey(),loadNetwork(),loadPrefs(),loadLlamacpp()]);
+  await Promise.allSettled([loadStatus(),loadVram(),loadRam(),loadCfg(),loadPresets(),loadConversations(),loadIdentity(),loadAgent(),loadInternet(),loadMCP(),loadApiKey(),loadPrefs(),loadLlamacpp(),loadThinkEffort(),loadTasks()]);
   releaseHeights(); // tout est en place : on rend la main et on mesure pour la prochaine fois
 }
 async function act(a){ toast(a+'…'); await jpost('/api/'+a); setTimeout(loadAll,1500); }

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

@@ -101,6 +101,7 @@ async function openItem(kind, key){
   // Model picker is preset-only: it edits the MODEL= line of the preset.
   const modelRow = document.getElementById('m-model-row');
   const settingsRow = document.getElementById('m-settings-row');
+  const samplingRow = document.getElementById('m-sampling-row');
   const rawHead = document.getElementById('m-raw-head');
   const rawToggle = document.getElementById('m-raw-toggle');
   const rawBody = document.getElementById('m-raw-body');
@@ -108,6 +109,7 @@ async function openItem(kind, key){
   if(kind === 'preset'){
     modelRow.style.display = 'flex';
     settingsRow.style.display = 'flex';
+    if(samplingRow) samplingRow.style.display = 'flex';
     document.getElementById('m-hf-url').value = '';
     resetDlUI();
     resetHfUI();
@@ -119,9 +121,14 @@ async function openItem(kind, key){
     // Dossiers de modèles : replié par défaut (réglage rare), chargé à l'ouverture.
     document.getElementById('m-dir-path').value = '';
     setModelDirsOpen(false);
+    // Jeton Hugging Face : même traitement, mais son ÉTAT est lu tout de suite —
+    // c'est lui qui s'affiche sur la ligne repliée (« aucun », « enregistré »).
+    setHFTokenOpen(false);
+    loadHFToken();
   } else {
     modelRow.style.display = 'none';
     settingsRow.style.display = 'none';
+    if(samplingRow) samplingRow.style.display = 'none';
     // Page mémoire : le contenu EST le champ principal — affiché en clair.
     rawHead.textContent = 'Contenu';
     rawToggle.style.display = 'none';
@@ -258,6 +265,70 @@ function setModelDirsOpen(open){
 function toggleModelDirs(){
   setModelDirsOpen(document.getElementById('m-dirs-body').style.display === 'none');
 }
+
+// ---- Jeton Hugging Face ----------------------------------------------------
+// Un dépôt « gated » se lit sans jeton mais ne se télécharge pas. Le jeton se
+// posait uniquement par la variable d'environnement HF_TOKEN : en conteneur, ça
+// voulait dire éditer un docker-compose et recréer le conteneur pour répondre à
+// un 401 découvert ici. Il se règle donc à l'endroit où le problème apparaît.
+function setHFTokenOpen(open){
+  const b = document.getElementById('m-hft-body');
+  const c = document.getElementById('m-hft-caret');
+  if(!b) return;
+  b.style.display = open ? '' : 'none';
+  if(c) c.classList.toggle('open', open);
+}
+function toggleHFToken(){
+  setHFTokenOpen(document.getElementById('m-hft-body').style.display === 'none');
+}
+async function loadHFToken(){
+  let d = {};
+  try{ d = await jget('/api/hf/token'); }catch(_){ return; }
+  renderHFToken(d);
+}
+// Le jeton n'est jamais renvoyé en clair par le serveur : on n'affiche que sa
+// forme masquée et sa provenance. « env » se signale à part — l'interface ne
+// peut pas effacer une variable du conteneur, promettre le contraire par un
+// bouton « Retirer » serait mentir.
+function renderHFToken(d){
+  const st = document.getElementById('m-hft-state');
+  const note = document.getElementById('m-hft-note');
+  const clear = document.getElementById('m-hft-clear');
+  const inp = document.getElementById('m-hft-input');
+  if(!st || !note || !clear || !inp) return;
+  inp.value = '';
+  const src = (d && d.source) || '';
+  st.textContent = src ? (d.masked || 'enregistré') : 'aucun';
+  clear.style.display = src === 'config' ? '' : 'none';
+  if(src === 'env'){
+    note.textContent = 'Jeton fourni par la variable d’environnement HF_TOKEN. En enregistrer un ici le remplacera.';
+  } else if(src === 'config'){
+    note.textContent = 'Jeton enregistré' + (d.account ? ' — compte ' + d.account : '')
+      + '. Un dépôt à accès restreint exige EN PLUS d’avoir accepté ses conditions sur huggingface.co avec ce compte.';
+  } else {
+    note.textContent = 'Sans jeton, les dépôts à accès restreint répondent 401 au téléchargement. Crée un jeton en lecture sur huggingface.co/settings/tokens, accepte les conditions du dépôt, puis colle-le ici.';
+  }
+}
+// Vérifié côté serveur AVANT d'être enregistré : un jeton mal collé accepté en
+// silence rendrait exactement le 401 qu'on cherche à expliquer.
+async function saveHFToken(){
+  const inp = document.getElementById('m-hft-input');
+  const tok = (inp.value || '').trim();
+  if(!tok){ toast('colle un jeton (hf_…)'); return; }
+  toast('vérification du jeton…');
+  const r = await jpost('/api/hf/token', {token: tok});
+  if(!r || !r.ok){ toast('jeton refusé : ' + ((r && r.error) || '')); return; }
+  renderHFToken(r);
+  toast(r.account ? 'jeton enregistré — compte ' + r.account : 'jeton enregistré');
+}
+async function clearHFToken(){
+  if(!await askConfirm('Les dépôts à accès restreint répondront de nouveau 401 au téléchargement.',
+      {title:'Retirer le jeton Hugging Face ?', okText:'Retirer'})) return;
+  const r = await jpost('/api/hf/token', {token: ''});
+  if(!r || !r.ok){ toast('erreur : ' + ((r && r.error) || '')); return; }
+  renderHFToken(r);
+  toast('jeton retiré');
+}
 async function populateModelDirs(){
   const box = document.getElementById('m-dirs-list');
   if(!box) return;
@@ -273,7 +344,9 @@ async function populateModelDirs(){
     const info = document.createElement('span');
     info.className = 'muted';
     const n = x.count >= 0 ? (x.count + ' modèle' + (x.count>1?'s':'')) : 'illisible';
-    const free = x.free >= 0 ? ', ' + fmtSize(x.free) + ' libres' : '';
+    // « ~ » quand le système de fichiers approxime (FUSE/shfs d'Unraid,
+    // overlay, réseau) : le chiffre est indicatif, il ne bloque plus rien.
+    const free = x.free >= 0 ? ', ' + (x.free_exact === false ? '~' : '') + fmtSize(x.free) + ' libres' : '';
     info.textContent = '(' + n + free + (x.home ? ', dossier loki' : '') + ')';
     row.append(p, info);
     if(!x.home){
@@ -399,6 +472,9 @@ async function populateBackend(){
   document.getElementById('be-lab-image').style.display = beImagePath ? '' : 'none';
   document.getElementById('be-lab-fast').style.display  = beImagePath ? 'none' : '';
   document.getElementById('be-lab-opt').style.display   = beImagePath ? 'none' : '';
+  // En conteneur, « Personnalisé » ne mène nulle part (rien à compiler, et le
+  // moteur se met à jour par la carte Moteur des réglages) : on le retire.
+  document.getElementById('be-lab-custom').style.display = beImagePath ? 'none' : '';
   document.getElementById('be-image-note').textContent  = beImagePath ? 'llama.cpp officiel' : '';
   // Menu « backend détecté » du mode personnalisé : tout ce qu'on trouve dans
   // le dossier backends de loki (l'utilisateur peut y déposer son propre build).
@@ -413,8 +489,11 @@ async function populateBackend(){
   const cur = currentBinInTextarea();
   let mode = 'custom';
   // Un preset sans BIN hérite du moteur global : en conteneur c'est celui de
-  // l'image, qu'on affiche comme tel plutôt qu'en « personnalisé ».
+  // l'image, qu'on affiche comme tel plutôt qu'en « personnalisé ». Et comme
+  // l'option Personnalisé n'y est plus proposée, TOUT BIN non reconnu retombe
+  // aussi sur l'image (un vieux preset pointant un chemin mort redevient sain).
   if(beImagePath && (sameBinPath(cur, beImagePath) || !cur)) mode = 'image';
+  else if(beImagePath) mode = 'image';
   else if(sameBinPath(cur, beFastPath) || underDir(cur, beFastDir)) mode = 'fast';
   else if(sameBinPath(cur, beOptPath)) mode = 'opt';
   const radio = document.querySelector('input[name=m-be][value='+mode+']');
@@ -729,6 +808,14 @@ function populateSettings(){
   set('s-ubatch', cfgReadKey('UBATCH'));
   set('s-tbatch', cfgReadKey('THREADS_BATCH'));
   set('s-kv', cfgReadKey('KV_TYPE'));
+  // Échantillonnage : envoyé PAR REQUÊTE (applySampling côté serveur), donc pas
+  // besoin de redémarrer le moteur pour qu'un changement prenne effet.
+  set('s-temp', cfgReadKey('TEMP'));
+  set('s-topp', cfgReadKey('TOP_P'));
+  set('s-topk', cfgReadKey('TOP_K'));
+  set('s-minp', cfgReadKey('MIN_P'));
+  set('s-presp', cfgReadKey('PRESENCE_PENALTY'));
+  set('s-reppen', cfgReadKey('REPEAT_PENALTY'));
   set('s-moe', eaGetValued('--n-cpu-moe'));
   set('s-spec-n', eaGetValued('--spec-draft-n-max'));
   setSpecType(eaGetValued('--spec-type'));
@@ -746,6 +833,23 @@ function populateSettings(){
     rzSub.textContent = rz ? 'réflexion étape par étape'
                            : 'réflexion étape par étape — non précisé : le modèle décide';
   }
+  // Intensité : passée telle quelle au gabarit jinja du modèle via
+  // `reasoning_effort`. Seuls les gabarits qui la lisent (gpt-oss et apparentés)
+  // changent de comportement ; ailleurs elle est ignorée sans erreur — le
+  // sous-titre le dit pour ne pas laisser croire à un effet garanti.
+  const eff = document.getElementById('s-reasoning-effort');
+  if(eff){
+    eff.value = (cfgReadKey('REASONING_EFFORT')||'').toLowerCase();
+    const effSub = document.getElementById('s-reasoning-effort-sub');
+    if(effSub){
+      // Deux emplacements, deux portées : ici c'est le défaut ENREGISTRÉ avec le
+      // preset (donc rattaché au modèle) ; la liste de la barre de saisie le
+      // dévie pour la suite de la session, jusqu'au prochain preset appliqué.
+      effSub.textContent = eff.value
+        ? 'défaut de ce preset — sans effet si le gabarit du modèle l\'ignore'
+        : 'défaut de ce preset — ajustable à la volée depuis la barre de saisie';
+    }
+  }
   chk('s-flash', eaHasFlag('--flash-attn') && !/^off$/i.test(eaGetValued('--flash-attn')));
   chk('s-mlock', eaHasFlag('--mlock'));
   chk('s-nommap', eaHasFlag('--no-mmap'));
@@ -879,7 +983,7 @@ async function populateDlDirs(){
   for(const x of dlDirList){
     const o = document.createElement('option');
     o.value = x.path;
-    o.textContent = x.path + (x.free >= 0 ? ' — ' + fmtSize(x.free) + ' libres' : '');
+    o.textContent = x.path + (x.free >= 0 ? ' — ' + (x.free_exact === false ? '~' : '') + fmtSize(x.free) + ' libres' : '');
     sel.append(o);
   }
   if(prev && dlDirList.some(x => samePath(x.path, prev))) sel.value = prev;
@@ -917,7 +1021,9 @@ async function startDownloadURL(url){
   // p.size couvre TOUTES les tranches : un modèle découpé annonce ses 45 Go, pas
   // les 15 Go du fichier dont le lien a été collé.
   const nparts = p.parts > 1 ? ' en '+p.parts+' fichiers' : '';
-  e.prog.textContent = fmtSize(p.size)+nparts+' à télécharger — '+fmtSize(p.free)+' libres';
+  e.prog.textContent = fmtSize(p.size)+nparts+' à télécharger — '
+    + (p.free_exact === false ? '~' : '') + fmtSize(p.free) + ' libres'
+    + (p.free_exact === false ? ' (estimation : partage réseau ou agrégé)' : '');
   const r = await jpost('/api/models/download', {url, dir});
   if(!r.ok){
     e.prog.innerHTML = '<span style="color:var(--err)">erreur : '+(r.error||'')+'</span>';
@@ -1055,11 +1161,29 @@ async function hfSearch(){
     const m = document.createElement('span'); m.className = 'hf-meta';
     m.textContent = fmtCount(rep.downloads)+' ↓';
     row.append(n, m);
+    // Dépôt verrouillé : il se LIT sans rien, mais chaque .gguf répond 401 au
+    // transfert. La pastille le dit dès la liste — sinon on choisit un quant,
+    // on lance 15 Go et l'erreur tombe à la fin de la sonde.
+    if(rep.gated){
+      const g = document.createElement('span');
+      g.className = 'hf-fit gated';
+      g.textContent = 'accès restreint';
+      g.title = hfGatedHint(r.hf_token);
+      row.appendChild(g);
+    }
     list.appendChild(row);
   }
   o.appendChild(list);
 }
 
+// Le geste à faire n'est pas le même selon qu'un jeton est configuré ou non :
+// sans jeton il en faut un, avec jeton c'est l'accès au dépôt qui manque.
+function hfGatedHint(hasToken){
+  return hasToken
+    ? 'Dépôt à accès restreint : le jeton enregistré sera utilisé. Si le téléchargement échoue en 401, accepte les conditions du dépôt sur huggingface.co avec le compte de ce jeton.'
+    : 'Dépôt à accès restreint : accepte ses conditions sur huggingface.co, puis enregistre un jeton dans « Jeton Hugging Face » plus bas. Sans jeton, le téléchargement échouera en 401.';
+}
+
 // Millions/milliers abrégés : un dépôt à 1 945 635 téléchargements dit surtout
 // « celui-là est le plus utilisé », pas son compte exact.
 function fmtCount(n){
@@ -1087,8 +1211,36 @@ async function hfPickRepo(repo){
   back.onclick = hfSearch;
   const title = document.createElement('span'); title.className = 'hf-name'; title.textContent = repo;
   head.append(back, title);
+  if(r.gated){
+    const g = document.createElement('span');
+    g.className = 'hf-fit gated'; g.textContent = 'accès restreint';
+    head.appendChild(g);
+  }
   o.appendChild(head);
 
+  // Avertissement en toutes lettres : la pastille seule ne dit pas quoi faire,
+  // et c'est ici que le téléchargement se déclenche.
+  if(r.gated){
+    const warn = document.createElement('div');
+    warn.className = 'pe-note';
+    warn.style.color = r.hf_token ? 'var(--warn)' : 'var(--err)';
+    warn.textContent = hfGatedHint(r.hf_token);
+    o.appendChild(warn);
+    // Le réglage est plus bas dans la même fenêtre : y mener directement évite
+    // de le chercher, et c'est le seul geste qui débloque ce dépôt.
+    if(!r.hf_token){
+      const go = document.createElement('button');
+      go.className = 'pe-link'; go.textContent = 'Renseigner un jeton Hugging Face';
+      go.onclick = ()=>{
+        setHFTokenOpen(true);
+        const inp = document.getElementById('m-hft-input');
+        document.getElementById('m-hft-toggle').scrollIntoView({block:'center', behavior:'smooth'});
+        if(inp) inp.focus();
+      };
+      o.appendChild(go);
+    }
+  }
+
   // Projecteur vision : proposé UNIQUEMENT s'il vient de ce dépôt. Un mmproj
   // encode dans l'espace latent de SON modèle ; en prendre un ailleurs donne un
   // moteur qui démarre et ne voit rien. Quand le dépôt n'en publie pas, on le

internal/loki/ui/src/js/08-chat-render.js

@@ -56,9 +56,13 @@ document.addEventListener('DOMContentLoaded', ()=>{
   });
 });
 
+// Badge de rôle du mode code (builder / verifier) : posé par 09-stream.js à
+// réception d'un delta {role}, repris par addMsg sur les bulles suivantes.
+let ROLE_BADGE='';
 function addMsg(role, text){
   const el=document.createElement('div');
   el.className='msg '+role;
+  if(ROLE_BADGE && (role==='assistant'||role==='reasoning'||role==='tool')) el.dataset.agentRole=ROLE_BADGE;
   const collapsible = (role==='reasoning' || role==='tool');
   // .body must be a real block so <p>/<pre>/<ul> margins behave properly.
   if(collapsible){
@@ -72,6 +76,11 @@ function addMsg(role, text){
     if((role==='user'||role==='assistant') && typeof paintLabel==='function'){
       paintLabel(el.querySelector('.label'), role);
     }
+    // Badge visible sur la bulle assistant pendant une passe de rôle.
+    if(ROLE_BADGE && role==='assistant'){
+      const b=document.createElement('span'); b.className='rolebadge'; b.textContent=ROLE_BADGE==='verifier'?'vérification':ROLE_BADGE;
+      el.querySelector('.label').appendChild(b);
+    }
   }
   el.querySelector('.body').textContent=text;
   // Bulles techniques (raisonnement, outils, mémoire) : elles se posent CÔTE À
@@ -153,13 +162,21 @@ function setLabelCounts(el, add, del){
   if(del) cnt.appendChild(Object.assign(document.createElement('span'),{className:'d',textContent:'-'+del}));
   lab.appendChild(cnt);
 }
-// Ligne de mesures sous une réponse (prefill / decode). Les étiquettes VOUS/Loki
-// sont masquées dans cette mise en page, donc les chiffres qu'on y écrivait
-// avaient disparu : ils ont leur propre ligne, discrète, sous le texte. Masquée
-// par la préférence d'affichage « masquer la vitesse de génération » (CSS).
-function setStats(el, text){
+// Ligne de mesures sous une réponse. Les étiquettes VOUS/Loki sont masquées dans
+// cette mise en page, donc les chiffres qu'on y écrivait avaient disparu : ils
+// ont leur propre ligne, discrète, sous le texte.
+//
+// Deux informations de nature différente y cohabitent, d'où deux éléments :
+//   .worktime — le TEMPS DE TRAVAIL du tour (de la question à la fin de la
+//               réponse, outils et raisonnement compris) ;
+//   .spd      — les mesures de vitesse (prefill / decode).
+// Seule la seconde est escamotée par « masquer la vitesse de génération » : la
+// durée n'est pas une mesure de moteur, c'est ce que la réponse a coûté en
+// temps. La ligne entière disparaît si elle ne porte plus que de la vitesse.
+function setStats(el, work, speed){
   if(!el) return;
   let s = el.querySelector(':scope > .statline');
+  if(!work && !speed){ if(s) s.textContent=''; return; }
   if(!s){
     s=document.createElement('div'); s.className='statline';
     // Apparition en fondu, à la PREMIÈRE pose seulement : la ligne arrive une fois
@@ -169,7 +186,18 @@ function setStats(el, text){
     if(!(typeof REPLAYING!=='undefined' && REPLAYING)) s.classList.add('statline-in');
     el.appendChild(s);
   }
-  s.textContent = text;
+  // Les deux travées sont RÉUTILISÉES d'un rafraîchissement à l'autre : la ligne
+  // est repeinte à chaque token reçu, y recréer des éléments ferait travailler la
+  // mise en page des dizaines de fois par seconde pour rien.
+  let w = s.querySelector(':scope > .worktime');
+  let p = s.querySelector(':scope > .spd');
+  if(!w){ w=document.createElement('span'); w.className='worktime'; s.appendChild(w); }
+  if(!p){ p=document.createElement('span'); p.className='spd'; s.appendChild(p); }
+  w.textContent = work || '';
+  // Le séparateur voyage AVEC la vitesse : masquer celle-ci ne doit pas laisser
+  // un « · » orphelin en bout de durée.
+  p.textContent = speed ? ((work ? '  \u00b7  ' : '') + speed) : '';
+  s.classList.toggle('has-work', !!work);
 }
 function bodyOf(el){ return el.querySelector('.body'); }
 // Render markdown into a message body in place; safe because md() escapes HTML.
@@ -191,6 +219,13 @@ function hydrateImages(root){
     img.dataset.hydrated = '1';
     const src = img.getAttribute('src');
     img.classList.add('chatimg');
+    // Nom lisible pour la loupe : la fin du chemin visé, pas l'URL d'API.
+    let name = img.getAttribute('alt') || '';
+    if(!name){
+      const m = /[?&]path=([^&]*)/.exec(src);
+      if(m){ try{ name = decodeURIComponent(m[1]).split('/').pop(); }catch(_){ name = m[1]; } }
+    }
+    bindZoom(img, name);
     const cached = IMG_CACHE.get(src);
     if(cached){ img.src = cached; return; }
     try{
@@ -223,6 +258,17 @@ function renderToolMsg(el, tu){
     web_open:   {lbl:'page web',  head:'ouverture'},
     web_read:   {lbl:'page web',  head:'lecture'},
     web_grep:   {lbl:'page web',  head:'recherche'},
+    // Outils du mode code : chacun son étiquette, pas le fallback mémoire.
+    read:       {lbl:'lecture',   head:'lecture'},
+    grep:       {lbl:'recherche', head:'grep'},
+    glob:       {lbl:'fichiers',  head:'glob'},
+    criteria:   {lbl:'critères',  head:'critères'},
+    ask:        {lbl:'question',  head:'question'},
+    bash_bg:    {lbl:'terminal',  head:'commande (fond)'},
+    bash_tail:  {lbl:'terminal',  head:'suivi de job'},
+    git_status: {lbl:'git',       head:'git status'},
+    git_diff:   {lbl:'git',       head:'git diff'},
+    git_clone:  {lbl:'git',       head:'git clone'},
   };
   // Outils MCP (nom mcp__<serveur>__<outil>) : en-tête = nom du serveur, libellé lisible,
   // pas le fallback mémoire. On extrait serveur et outil du nom namespacé.
@@ -280,6 +326,21 @@ function renderToolMsg(el, tu){
     // la ligne en cours (max-height côté CSS l'empêche de pousser le fil).
     pre.scrollTop = pre.scrollHeight;
   }
+  // Capture d'écran : l'image est rendue ICI, dans la bulle de l'outil. Elle ne
+  // dépend donc plus de la bonne volonté du modèle à recopier la ligne markdown
+  // — il l'oubliait, et l'utilisateur ne voyait jamais ce qu'il avait demandé.
+  if(tu.image){
+    const wrap=document.createElement('div'); wrap.className='tool-shot';
+    const img=document.createElement('img');
+    // src (et non data-src) : hydrateImages sélectionne sur src, puis le
+    // remplace par un blob obtenu avec la clé de pilotage.
+    img.setAttribute('src', '/api/chat/image?path='+encodeURIComponent(tu.image));
+    img.alt = tu.image.split('/').pop();
+    img.loading = 'lazy';
+    wrap.appendChild(img);
+    body.appendChild(wrap);
+    hydrateImages(wrap);
+  }
   // Diff d'une écriture (fichier ou page de mémoire) : lignes ajoutées en vert,
   // retirées en rouge, contexte en gris — comme un diff de terminal.
   if(tu.diff && tu.diff.length){
@@ -327,9 +388,18 @@ function addCopyButtons(root){
     pre.appendChild(btn);
   });
 }
-// Nouvelle conversation POUR TOUS LES APPAREILS : le serveur vide le fil et
+// Vider la discussion POUR TOUS LES APPAREILS : le serveur vide le fil et
 // diffuse un {reset} ; le flux d'abonnement nettoie alors l'affichage.
-function resetChat(){ jfetch('/api/chat/reset',{method:'POST'}).catch(()=>{}); toast('nouvelle conversation'); }
+//
+// Confirmé, car le geste emporte aussi les FICHIERS de la discussion (dépôts,
+// captures, ce que l'agent y a écrit) : ils n'appartiennent qu'à elle, et plus
+// un message ne les mentionnerait.
+async function resetChat(){
+  if(!await askConfirm('Le fil de cette discussion et ses fichiers (pièces jointes, captures, fichiers écrits par l\'agent) seront effacés.\n\nC\'est définitif.',
+      {title:'Vider la discussion', okText:'Vider', danger:true})) return;
+  jfetch('/api/chat/reset',{method:'POST'}).catch(()=>{});
+  toast('discussion vidée');
+}
 // Compaction : on demande à l'IA un résumé de la conversation destiné à la
 // reprendre dans une session neuve, puis on repart d'un contexte propre seedé
 // avec ce résumé. Réduit drastiquement les tokens tout en gardant le fil.

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

@@ -22,7 +22,10 @@ function addPending(text){
   clearPending();
   PENDING=addMsg('user', text);
   PENDING.classList.add('pending');
-  const l=PENDING.querySelector('.label'); if(l) l.textContent='envoi…';
+  // L'étiquette garde l'avatar et le prénom (paintLabel, posé par addMsg) : une
+  // bulle ne doit JAMAIS s'appeler autrement d'un tour à l'autre. L'envoi en
+  // cours se lit à la bulle grisée (.pending) et à l'infobulle.
+  const l=PENDING.querySelector('.label'); if(l) l.title='envoi en cours…';
   jumpBottom();
   return PENDING;
 }
@@ -33,7 +36,11 @@ function confirmPending(text){
   const b=PENDING.querySelector('.body');
   if(!b || b.textContent!==text) return false;
   PENDING.classList.remove('pending');
-  const l=PENDING.querySelector('.label'); if(l) l.textContent='user';
+  // ⚠️ NE PAS réécrire l'étiquette ici : elle porte l'avatar et le prénom
+  // (17-identity.js). Elle y était remise à « user », si bien que le message
+  // qu'on venait d'envoyer s'affichait « USER » alors que ceux rejoués au
+  // chargement portaient le prénom — deux bulles identiques, deux libellés.
+  const l=PENDING.querySelector('.label'); if(l) l.removeAttribute('title');
   PENDING=null;
   return true;
 }
@@ -44,8 +51,88 @@ function confirmPending(text){
 let REPLAYING=true;
 // État de rendu du tour courant, délimité par les événements user / turn_done.
 let T=null;
-function newTurn(){ T={ reasonEl:null, contentEl:null, pendingToolEl:null, typingEl:null, fullContent:'', fullReason:'', turnCollapsibles:[], serverStats:null, reasonTok:0, contentTok:0, reasonFirstTs:0, reasonLastTs:0, contentFirstTs:0, contentLastTs:0 }; }
+function newTurn(){ T={ reasonEl:null, contentEl:null, pendingToolEl:null, typingEl:null, fullContent:'', fullReason:'', turnCollapsibles:[], serverStats:null, reasonTok:0, contentTok:0, reasonFirstTs:0, reasonLastTs:0, contentFirstTs:0, contentLastTs:0, startTs:0, doneTs:0, speedText:'', model:'' }; }
 newTurn();
+
+// --- Temps de travail du tour ------------------------------------------------
+// « Combien de temps l'IA a-t-elle travaillé ? » se lit sous la réponse, de la
+// question envoyée à la fin du tour — raisonnement, appels d'outils et attentes
+// compris. La mesure est prise sur les HORODATAGES SERVEUR (l'événement `user`
+// puis `turn_done`) : elle est donc exacte en direct comme au rejeu du journal,
+// où tout arrive d'un bloc côté client.
+//
+// Pendant le tour il n'y a pas encore de `turn_done` : le compteur avance à la
+// seconde. Il ne peut pas se baser sur l'horloge du navigateur telle quelle (un
+// téléphone n'est pas à la même heure que la machine), on garde donc l'ÉCART
+// entre les deux, réévalué à chaque événement reçu en direct.
+let TS_SKEW = 0;                       // horloge client − horloge serveur (ms)
+function nowServer(){ return Date.now() - TS_SKEW; }
+let WORK_TIMER = null;
+function startWorkTimer(){ if(WORK_TIMER || REPLAYING) return; WORK_TIMER=setInterval(tickWork, 1000); }
+function stopWorkTimer(){ if(WORK_TIMER){ clearInterval(WORK_TIMER); WORK_TIMER=null; } }
+function tickWork(){ if(T.contentEl) paintStats(T.contentEl); paintTypingClock(); paintTurnClock(); }
+
+// Chrono du TOUR COMPLET, affiché au-dessus de la carte de saisie : le temps
+// entre l'envoi du message et le moment où l'on peut reparler — outils, passes
+// de vérification et compaction compris. Les durées portées par les cartes ne
+// disent que la génération de texte ; celle-ci répond à « ça a pris combien de
+// temps, en tout ? ».
+function paintTurnClock(){
+  const composer = document.getElementById('composer');
+  if(!composer || !T.startTs) return;
+  let el = document.getElementById('turn-clock');
+  if(!el){
+    el = document.createElement('div');
+    el.id = 'turn-clock';
+    el.className = 'composer-banner';
+    composer.insertBefore(el, composer.firstChild);
+  }
+  const ms = (T.doneTs || nowServer()) - T.startTs;
+  if(!(ms > 0)){ el.remove(); return; }
+  el.textContent = (T.doneTs ? 'tour terminé en ' : 'en cours — ') + fmtDur(ms);
+  el.classList.toggle('done', !!T.doneTs);
+}
+// Le compteur se montre AUSSI sur l'indicateur « … » : pendant un appel d'outil
+// ou un long prefill il n'y a encore aucune réponse sous laquelle écrire, et
+// c'est précisément le moment où l'on se demande si ça avance.
+function paintTypingClock(){
+  const el = T.typingEl;
+  if(!el || el.classList.contains('compacting')) return; // le compactage a son propre libellé
+  if(!T.startTs) return;
+  const ms = nowServer() - T.startTs;
+  if(!(ms > 1500)) return;                               // pas de compteur pour une réponse immédiate
+  let c = el.querySelector('.wclock');
+  if(!c){ c=document.createElement('span'); c.className='wclock'; el.appendChild(c); }
+  c.textContent = fmtDur(ms);
+}
+// Durée lisible : dixièmes sous 10 s (un tour court se juge à la fraction),
+// secondes rondes ensuite, puis minutes et heures. Le séparateur décimal reste
+// le POINT — la durée voisine des « 21.5 tok/s » sur la même ligne, une virgule
+// y ferait deux conventions à trois mots d'écart.
+function fmtDur(ms){
+  if(!(ms > 0)) return '';
+  if(ms < 10000) return (ms/1000).toFixed(1) + ' s';
+  const t = Math.round(ms/1000);
+  if(t < 60) return t + ' s';
+  const m = Math.floor(t/60), sec = t % 60;
+  if(m < 60) return m + ' min ' + String(sec).padStart(2, '0') + ' s';
+  return Math.floor(m/60) + ' h ' + String(m % 60).padStart(2, '0') + ' min';
+}
+// Libellé de durée du tour courant, vide tant qu'il n'y a rien à montrer (tour
+// non commencé, ou horloges trop désaccordées pour que l'écart ait un sens).
+function workLabel(){
+  if(!T.startTs) return '';
+  const ms = (T.doneTs || nowServer()) - T.startTs;
+  if(!(ms > 300)) return '';
+  return 'travail ' + fmtDur(ms);
+}
+// Repeint la ligne de mesures de la réponse : durée d'abord, vitesse ensuite.
+// `speed` non fourni = on garde le dernier libellé de vitesse connu (c'est le
+// cas du tic de seconde, qui ne fait avancer que la durée).
+function paintStats(el, speed){
+  if(speed !== undefined) T.speedText = speed;
+  setStats(el, workLabel(), T.speedText);
+}
 const simpleMode=()=>document.documentElement.getAttribute('data-display')==='simple';
 function removeTyping(){ if(T.typingEl){ T.typingEl.remove(); T.typingEl=null; } }
 // Compactage : on ÉTIQUETTE l'indicateur de frappe déjà à l'écran au lieu
@@ -104,9 +191,23 @@ function renderStats(el, s){
   // Réponse de l'assistant : ligne de mesures dédiée sous le texte (son étiquette
   // est masquée dans cette mise en page). Bulle repliable : l'étiquette EST le
   // bouton de repli, on y écrit comme avant.
-  if(el.classList.contains('collapsible')) setLabel(el, ['reasoning'].concat(parts).join('  ·  '));
-  else setStats(el, parts.join('  ·  '));
+  if(el.classList.contains('collapsible')) setLabel(el, ['reasoning'].concat(workLabel()||[], parts).join('  ·  '));
+  else paintStats(el, parts.join('  ·  '));
 }
+// --- Compteurs de bulle -----------------------------------------------------
+// Ils sont PAR BULLE, jamais par tour. Un tour d'agent en ouvre une nouvelle
+// après CHAQUE appel d'outil (le flux repasse T.contentEl à null) ; les
+// compteurs, eux, n'étaient jamais remis à zéro. Chaque bulle affichait donc le
+// CUMUL de tout le tour, divisé par le temps écoulé depuis le tout premier
+// token — exécution des outils, pages web et prefill compris.
+//
+// Sur un tour agentique d'une heure, ça donnait une vitesse qui décroissait
+// mécaniquement de 17 tok/s à 0,9 : le moteur n'avait pas ralenti, le compteur
+// mesurait « tokens générés ÷ durée totale du tour ». La remise à zéro est faite
+// à la CRÉATION de la bulle : tout chemin qui en ouvre une neuve est couvert,
+// aujourd'hui comme demain.
+function resetContentStats(){ T.contentTok=0; T.contentFirstTs=0; T.contentLastTs=0; T.speedText=''; }
+function resetReasonStats(){ T.reasonTok=0; T.reasonFirstTs=0; T.reasonLastTs=0; }
 // Label d'une bulle : nombre de tokens + vitesse. La vitesse est calculée à
 // partir des HORODATAGES SERVEUR (firstTs→lastTs) : le temps réel de génération,
 // donc correct aussi bien en direct qu'au replay (où les deltas arrivent d'un
@@ -114,17 +215,43 @@ function renderStats(el, s){
 function labelTokens(el, role, n, firstTs, lastTs){
   if(!el) return;
   const secs=(lastTs-firstTs)/1000;
-  if(secs>0.05 && n>1){ setLabel(el, role+'  ·  '+n+' tok  ·  '+(n/secs).toFixed(1)+' tok/s'); }
-  else { setLabel(el, role+'  ·  '+n+' tok'); }
+  const m = (secs>0.05 && n>1) ? n+' tok  ·  '+(n/secs).toFixed(1)+' tok/s' : n+' tok';
+  // Bulle de raisonnement : sa propre durée de génération, comme le « réfléchi
+  // pendant… » d'un fil de discussion — elle reste lisible une fois repliée.
+  const d = (secs>0.05 && n>1) ? fmtDur(lastTs-firstTs) : '';
+  // Bulle technique : son étiquette EST le bouton de repli, les mesures y vont.
+  // Réponse de l'assistant : son étiquette porte l'avatar et le nom, les mesures
+  // vont dans la ligne dédiée — comme le font déjà les stats de fin de tour
+  // (applyStats). Sans ce partage, le libellé « Loki » était remplacé en direct
+  // par « assistant · 75 tok · 21.5 tok/s », et ne revenait qu'au rechargement.
+  if(el.classList.contains('collapsible')) setLabel(el, [role].concat(d||[], m).join('  ·  '));
+  else paintStats(el, m);
+}
+// Badge du modèle sur une bulle de réponse : le nom voyage avec la borne de
+// tour (T.model), on le dépose dans dataset.model pour qu'applyIdentity — qui
+// repeint les libellés de zéro — puisse le reposer (voir paintLabel).
+function tagModel(el){
+  if(!el || !T.model) return;
+  el.dataset.model = T.model;
+  const l = el.querySelector('.label');
+  if(l && !l.querySelector('.modelbadge') && typeof modelBadge==='function') l.appendChild(modelBadge(T.model));
 }
 // Pendant le replay on met à jour l'état `busy` mais on NE touche PAS aux boutons
 // (sinon user→stop puis turn_done→send à chaque tour rejoué = flottement visible).
 // L'état final est appliqué une seule fois au caught_up via syncSendBtn().
-function setBusy(on){ busy=on; if(!REPLAYING) syncSendBtn(); }
+function setBusy(on){ busy=on; if(!REPLAYING) syncSendBtn();
+  // La liste des discussions montre laquelle travaille : elle doit suivre l'état
+  // MÊME pendant le rejeu (une page rechargée en cours de génération doit voir
+  // l'anneau tourner sans attendre le premier événement en direct).
+  if(typeof convSyncBusy==='function') convSyncBusy(); }
 function syncSendBtn(){
   const sb=document.getElementById('send');
-  sb.style.display=busy?'none':'inline-block';
-  document.getElementById('stop').style.display=busy?'inline-block':'none';
+  // ⚠️ L'état passe par un ATTRIBUT, jamais par un style inline. Ces deux
+  // boutons étaient montrés/cachés avec `style.display='inline-block'`, qui
+  // l'emportait sur le `display:flex` de la feuille : le bouton gardait sa
+  // boîte de 34 px mais son icône de 18 px se collait à gauche, décalée de 8 px.
+  // C'est invisible tant que l'icône est un glyphe de texte, flagrant en SVG.
+  document.documentElement.setAttribute('data-busy', busy ? '1' : '0');
   // Tant que le moteur n'a pas fini de charger le modèle, envoyer ne mène à rien :
   // on bloque le bouton et l'Entrée, et on le DIT sous le champ. `STATUS_SEEN`
   // évite de verrouiller le chat quand /api/status n'a pas encore répondu (ou ne
@@ -139,37 +266,154 @@ function syncSendBtn(){
     hint.classList.toggle('waiting', !ready);
   }
 }
+// ─── Rendu du bloc en cours : cadencé, puis lissé ────────────────────────────
+// Repris de l'amont AJEAN (v0.9.5 issue #24, puis v0.10.5), adapté.
+//
+// Re-parser le Markdown du bloc ENTIER à chaque token est en O(n²) : sur un long
+// raisonnement (des milliers de tokens) l'interface se met à ramer, les tokens
+// semblent arriver au ralenti — alors que le moteur, lui, débite toujours autant
+// — et un simple rafraîchissement « répare » tout, puisqu'il rend le bloc une
+// seule fois. On coalesce donc : le texte s'accumule (concaténation, quasi
+// gratuite) et on ne re-rend qu'à intervalle borné. Le rendu final exact est
+// garanti par flushRender(), appelé à chaque frontière de bloc (outil, fin de
+// tour, erreur, caught_up).
+let renderTimer=null, renderPending=null, lastRenderMs=0; // {el, text}
+function scheduleRender(el, text){
+  // Changement de bloc en cours de route : on rend d'abord l'ancien à sa dernière
+  // valeur, sinon son ultime bout de texte serait perdu.
+  if(renderPending && renderPending.el!==el) flushRender();
+  renderPending={el, text};
+  if(renderTimer) return;
+  // Cadence ADAPTATIVE : on vise à ne pas passer plus d'~1/6 du temps à re-parser
+  // le Markdown. Tant que le bloc est petit, un rendu coûte 1-2 ms → plancher
+  // 16 ms ≈ 60 img/s, l'apparition reste fluide token par token. Quand le bloc
+  // devient énorme, le rendu coûte cher et on espace tout seul jusqu'à 500 ms :
+  // le O(n²) est cassé sans jamais figer l'interface.
+  const delay=Math.min(500, Math.max(16, lastRenderMs*6));
+  renderTimer=setTimeout(flushRender, delay);
+}
+function flushRender(){
+  if(renderTimer){ clearTimeout(renderTimer); renderTimer=null; }
+  const p=renderPending; renderPending=null;
+  if(!p) return;
+  const t0=performance.now();
+  renderBody(p.el, p.text);
+  lastRenderMs=performance.now()-t0;
+}
+// Annule le rendu en attente SANS le poser : le bloc visé disparaît (fil vidé,
+// raisonnement jeté), le rendre ensuite écrirait dans un élément détaché.
+function cancelRender(){ if(renderTimer){ clearTimeout(renderTimer); renderTimer=null; } renderPending=null; }
+// Lissage d'apparition (« machine à écrire »). Le décodage spéculatif (MTP) rend
+// les tokens PAR RAFALES — plusieurs acceptés d'un coup, puis une pause : le
+// texte grandit par paquets et saute à l'écran. On découple donc l'ARRIVÉE (les
+// rafales du moteur) de l'AFFICHAGE : `target` = tout ce qui est reçu, `shown`
+// avance à cadence régulière (requestAnimationFrame), et on n'affiche que le
+// préfixe révélé. Le rendu passe TOUJOURS par scheduleRender pour conserver le
+// garde-fou anti-O(n²) ci-dessus.
+// UNIQUEMENT EN DIRECT : au rejeu tout est posé d'un bloc, sinon relire un fil
+// deviendrait une lente réécriture caractère par caractère.
+let smooth=null, smoothLast=0; // {el, target, shown, raf}
+function smoothReset(){ if(smooth&&smooth.raf) cancelAnimationFrame(smooth.raf); smooth=null; smoothLast=0; }
+// Solde le bloc courant : on affiche TOUT immédiatement. Appelé à chaque
+// frontière (fin de tour, outil, changement de bloc) — sinon l'ultime bout de
+// texte resterait en retard derrière le curseur de révélation.
+function smoothSnap(){ if(!smooth) return; const el=smooth.el, target=smooth.target; smoothReset(); scheduleRender(el, target); }
+// Débit BASÉ SUR LE TEMPS (indépendant du taux de rafraîchissement). La vitesse
+// de révélation est proportionnelle au RETARD accumulé, avec une constante de
+// temps TAU : le curseur traîne volontairement ~TAU derrière l'arrivée, ce qui
+// donne un écoulement CONTINU malgré les rafales, et se vide en douceur quand la
+// génération s'arrête. Un plancher garantit un progrès même sur un retard
+// minuscule, sans jamais figer.
+const SMOOTH_TAU=260; // ms — plus grand = plus lisse mais traîne davantage
+function smoothStep(ts){
+  if(!smooth) return;
+  if(!smoothLast) smoothLast=ts;
+  const dt=Math.min(120, ts-smoothLast); smoothLast=ts;
+  const remaining=smooth.target.length - smooth.shown;
+  if(remaining<=0){ smooth.raf=null; smoothLast=0; return; }
+  let adv=remaining*dt/SMOOTH_TAU;      // vitesse ∝ retard
+  if(adv<0.4) adv=0.4;                  // progrès minimal
+  smooth.shown=Math.min(smooth.target.length, smooth.shown+Math.ceil(adv));
+  scheduleRender(smooth.el, smooth.target.slice(0, smooth.shown));
+  smooth.raf=requestAnimationFrame(smoothStep);
+}
+function smoothFeed(el, target){
+  if(smooth && smooth.el!==el) smoothSnap();   // changement de bloc : solder l'ancien
+  if(!smooth) smooth={el, target, shown:0, raf:null};
+  smooth.target=target;
+  if(!smooth.raf) smooth.raf=requestAnimationFrame(smoothStep);
+}
+// Rend un bloc en streaming : lissé en direct, instantané au rejeu.
+function feedBlock(el, full){ if(REPLAYING) scheduleRender(el, full); else smoothFeed(el, full); }
+// Solde tout ce qui est en vol : le bloc est terminé, la suite (stats, repli,
+// bulle d'outil) doit voir le texte complet.
+function settleBlocks(){ smoothSnap(); flushRender(); }
+
 // Traite UN événement du flux — même sémantique que l'ancien switch inline, mais
 // piloté par le serveur et rejouable à l'identique.
 function handleDelta(d){
   if(typeof d.seq==='number' && d.seq>lastSeq) lastSeq=d.seq;
+  // Recalage de l'horloge : un événement reçu en DIRECT vient d'être émis, son
+  // `ts` serveur et l'heure locale désignent donc le même instant. Surtout pas
+  // pendant le rejeu, où les `ts` sont vieux de plusieurs heures.
+  if(!REPLAYING && typeof d.ts==='number' && d.ts>0) TS_SKEW = Date.now() - d.ts;
   if(d.caught_up){
+    settleBlocks(); // rendre le dernier bloc rejoué à sa valeur exacte
     // Fin du replay initial : on saute en bas puis on révèle (une seule fois — pas
     // sur les reconnexions, pour ne pas te ramener en bas si tu lisais plus haut).
     setChatLoading(null);
     if(REPLAYING){ REPLAYING=false; jumpBottom(); syncSendBtn(); const c=chatEl(); c.style.transition='opacity .15s'; c.style.opacity='1'; }
+    // Le chrono ne démarre pas pendant le rejeu (aucun tic n'aurait de sens sur
+    // des tours déjà finis) : si le dernier tour rejoué est ENCORE en cours, il
+    // faut le lancer maintenant, sinon la durée resterait figée à l'écran.
+    if(busy && T.startTs && !T.doneTs) startWorkTimer();
     // Fil vide : aucune bulle n'a été rejouée, donc aucune mutation ne viendra
     // déclencher la synchro — c'est ici qu'on décide d'afficher l'accueil.
     syncChatEmpty();
     return; }
   // `reset` = fil vidé OU bascule de discussion (même mécanisme d'epoch côté
   // serveur) : on nettoie l'écran et on resynchronise la liste, car la bascule
-  // a pu être déclenchée depuis un autre appareil.
-  if(d.reset!==undefined){ PENDING=null; document.getElementById('chat').innerHTML=''; newTurn(); setCtxUsed(0); lastSeq=0; setBusy(false); if(typeof loadConversations==='function') loadConversations(); return; }
+  // a pu être déclenchée depuis un autre appareil. Les fichiers suivent : ils
+  // appartiennent à la discussion, le panneau doit changer avec elle.
+  if(d.reset!==undefined){ smoothReset(); cancelRender(); stopWorkTimer(); const tc=document.getElementById('turn-clock'); if(tc) tc.remove(); PENDING=null; document.getElementById('chat').innerHTML=''; newTurn(); setCtxUsed(0); lastSeq=0; setBusy(false); if(typeof loadConversations==='function') loadConversations(); if(typeof filesOnConvChange==='function') filesOnConvChange(); if(typeof modeOnConvChange==='function') modeOnConvChange(); return; }
+  // --- Mode code (20-mode.js) -----------------------------------------------
+  if(d.mode!==undefined){ if(typeof applyModeDelta==='function') applyModeDelta(d.mode); return; }
+  if(d.code_hint){ if(typeof showCodeHint==='function') showCodeHint(); return; }
+  if(d.criteria!==undefined){ if(typeof renderCriteria==='function') renderCriteria(d.criteria); return; }
+  // Bascule de rôle (mode code) : les blocs en cours appartiennent au rôle
+  // précédent — on les solde avant de les oublier, sinon leur dernier fragment
+  // resterait en vol et ne s'afficherait jamais.
+  if(d.role!==undefined){ settleBlocks(); ROLE_BADGE = d.role || ''; T.contentEl=null; T.reasonEl=null; return; }
+  if(d.ask){ if(typeof renderAskCard==='function') renderAskCard(d.ask); return; }
+  if(d.verify_done){ if(typeof onVerifyDone==='function') onVerifyDone(d.verify_done); return; }
   if(d.user!==undefined){
     newTurn();
+    // Modèle du tour : posé par le serveur sur la borne de tour (journalisée),
+    // donc présent au rejeu comme en direct. Repris par tagModel sur chaque
+    // bulle de réponse du tour.
+    T.model = d.model || '';
     let el=PENDING;
     if(!confirmPending(d.user)) el=addMsg('user', d.user);
     // Pièces jointes du tour : rendues DANS la bulle. La bulle en attente en
     // porte déjà (posées à l'envoi), on ne les ajoute donc qu'au replay/à une
     // bulle neuve — sinon elles apparaîtraient en double.
     if(d.files && !hasMsgFiles(el)) addMsgFiles(el, d.files);
-    setBusy(true); T.typingEl=addTyping(); return; }
+    // Départ du chronomètre : l'horodatage SERVEUR du message, pas l'heure
+    // locale — c'est ce qui rend la durée juste au rejeu comme en direct.
+    T.startTs = d.ts || 0; T.doneTs = 0;
+    setBusy(true); startWorkTimer(); paintTurnClock(); T.typingEl=addTyping(); return; }
   // Fin de tour : la discussion vient d'être enregistrée côté serveur — son
   // titre (déduit du 1er message) et son compteur d'échanges ont changé. Pas au
   // replay, qui rejoue tous les tours passés d'un bloc.
-  if(d.turn_done){ removeTyping(); collapseAll(T.turnCollapsibles); if(T.serverStats) renderStats(T.contentEl||T.reasonEl, T.serverStats); setBusy(false); if(!REPLAYING && typeof loadConversations==='function') loadConversations(); return; }
-  if(d.error){ removeTyping(); T.contentEl=null; T.reasonEl=null; const eb=addMsg('assistant',''); eb.classList.add('errmsg'); renderBody(eb, d.error); return; }
+  if(d.turn_done){ settleBlocks(); removeTyping(); collapseAll(T.turnCollapsibles); stopWorkTimer();
+    // La durée se fige ICI : au-delà, plus rien ne bouge, la ligne doit montrer
+    // le temps réellement passé et non continuer d'avancer.
+    T.doneTs = d.ts || T.doneTs || 0;
+    if(T.serverStats) renderStats(T.contentEl||T.reasonEl, T.serverStats);
+    else if(T.contentEl) paintStats(T.contentEl);   // sans mesures serveur, la durée reste
+    paintTurnClock();                               // fige le total au-dessus de la carte
+    setBusy(false); if(!REPLAYING && typeof loadConversations==='function') loadConversations(); return; }
+  if(d.error){ settleBlocks(); removeTyping(); T.contentEl=null; T.reasonEl=null; const eb=addMsg('assistant',''); eb.classList.add('errmsg'); renderBody(eb, d.error); return; }
   if(d.compacting!==undefined){ setCompacting(d.compacting); return; }
   if(d.compacted){ setCompacting(false); addCompactMark(); return; }
   // Pas de toast au REPLAY : le journal est rejoué à chaque chargement de page,
@@ -180,9 +424,14 @@ function handleDelta(d){
   if(d.compact_noop){ setCompacting(false); if(!REPLAYING) toast('rien à compacter (contexte déjà minimal)'); return; }
   if(d.ctx_used!==undefined){ setCtxUsed(d.ctx_used); return; }
   if(d.stats){ T.serverStats=d.stats;
+    // prompt_tokens_total = comptage exact du moteur (include_usage). Absent sur
+    // certains llama-server récents : le serveur publie alors un `ctx_used`
+    // estimé en fin de tour, traité plus bas — on ne remet donc PAS la jauge à
+    // zéro ici, on la laisse simplement inchangée.
     if(d.stats.prompt_tokens_total){ setCtxUsed((d.stats.prompt_tokens_total||0)+(d.stats.gen_tokens||0)); }
     if(T.contentEl||T.reasonEl) renderStats(T.contentEl||T.reasonEl, d.stats); return; }
   if(d.tool_used){
+    settleBlocks(); // le bloc texte précédent (raisonnement/contenu) est terminé
     killTyping('tool'); T.contentEl=null; T.reasonEl=null; const tu=d.tool_used;
     if(!T.pendingToolEl){ collapseAll(T.turnCollapsibles); T.pendingToolEl=addMsg('tool',''); if(REPLAYING||viewOn('fold-tools')) collapseInstant(T.pendingToolEl); T.turnCollapsibles.push(T.pendingToolEl); }
     renderToolMsg(T.pendingToolEl, tu);
@@ -192,16 +441,17 @@ function handleDelta(d){
     if(tu.done){ T.pendingToolEl=null; if(tu.name==='mem_add'||tu.name==='mem_edit') loadMem(); }
     return; }
   if(d.drop_reasoning){
+    smoothReset(); cancelRender(); // le bloc raisonnement disparaît : rien à rendre
     if(T.reasonEl){ const i=T.turnCollapsibles.indexOf(T.reasonEl); if(i>=0) T.turnCollapsibles.splice(i,1); T.reasonEl.remove(); T.reasonEl=null; T.fullReason=''; }
     return; }
   if(d.reasoning_content){
     killTyping('reasoning');
-    if(!T.reasonEl){ collapseAll(T.turnCollapsibles); T.reasonEl=addMsg('reasoning',''); if(REPLAYING||viewOn('fold-tools')) collapseInstant(T.reasonEl); T.fullReason=''; T.turnCollapsibles.push(T.reasonEl); }
+    if(!T.reasonEl){ collapseAll(T.turnCollapsibles); T.reasonEl=addMsg('reasoning',''); if(REPLAYING||viewOn('fold-tools')) collapseInstant(T.reasonEl); T.fullReason=''; resetReasonStats(); T.turnCollapsibles.push(T.reasonEl); }
     // d.replace : le serveur renvoie le bloc ENTIER alors qu'on en affichait déjà
     // le début (voir decorateEvent/coalesceReplay côté serveur) → on repart de zéro
     // au lieu de concaténer, sinon le texte apparaît en double.
-    if(d.replace){ T.fullReason=''; T.reasonTok=0; T.reasonFirstTs=0; }
-    showTyping('reasoning'); T.fullReason+=d.reasoning_content; renderBody(T.reasonEl, T.fullReason);
+    if(d.replace){ smoothSnap(); T.fullReason=''; resetReasonStats(); }
+    showTyping('reasoning'); T.fullReason+=d.reasoning_content; feedBlock(T.reasonEl, T.fullReason);
     // d.toks/d.ts0 présents quand l'événement est coalescé (replay) : plusieurs
     // tokens d'un coup. Sinon (direct), 1 token, ts0=ts.
     if(!T.reasonFirstTs) T.reasonFirstTs=d.ts0||d.ts||0; T.reasonLastTs=d.ts||T.reasonLastTs; T.reasonTok+=(d.toks||1);
@@ -209,9 +459,9 @@ function handleDelta(d){
     return; }
   if(d.content){
     removeTyping();
-    if(!T.contentEl){ collapseAll(T.turnCollapsibles); T.contentEl=addMsg('assistant',''); T.fullContent=''; }
-    if(d.replace){ T.fullContent=''; T.contentTok=0; T.contentFirstTs=0; }
-    T.fullContent+=d.content; renderBody(T.contentEl, T.fullContent);
+    if(!T.contentEl){ collapseAll(T.turnCollapsibles); T.contentEl=addMsg('assistant',''); tagModel(T.contentEl); T.fullContent=''; resetContentStats(); }
+    if(d.replace){ smoothSnap(); T.fullContent=''; resetContentStats(); }
+    T.fullContent+=d.content; feedBlock(T.contentEl, T.fullContent);
     if(!T.contentFirstTs) T.contentFirstTs=d.ts0||d.ts||0; T.contentLastTs=d.ts||T.contentLastTs; T.contentTok+=(d.toks||1);
     labelTokens(T.contentEl, 'assistant', T.contentTok, T.contentFirstTs, T.contentLastTs);
     return; }

internal/loki/ui/src/js/10-llamacpp.js

@@ -28,13 +28,13 @@ async function loadLlamacpp(){
 
     // Job en cours (page rechargée pendant une install) → on raccroche l'affichage.
     if(s.job && s.job.exists && s.job.running && !lcPoll){
-      document.getElementById('lc-details').open = true;
+      openDetails('lc-details');
       lcStartPolling();
     }
     // Job terminé/interrompu qu'on n'a pas encore montré (rechargement APRÈS coup,
     // typiquement quand le service a redémarré) : on l'affiche sans polling.
     else if(s.job && s.job.exists && !s.job.running && !lcPoll && s.job.error && !lcEndShown){
-      document.getElementById('lc-details').open = true;
+      openDetails('lc-details');
       document.getElementById('lc-job').style.display = '';
       lcLogNext = 0;
       document.getElementById('lc-log').textContent = '';
@@ -56,7 +56,8 @@ async function loadLlamacpp(){
 let lcSeenEnd = false, lcEndShown = false;
 function lcChipLabel(action){
   return {install:'Compilation du moteur', update:'Mise à jour du moteur',
-          prebuilt:'Téléchargement du moteur', custom:'Installation du backend'}[action] || 'Installation du moteur';
+          prebuilt:'Téléchargement du moteur', engine:'Mise à jour du moteur',
+          custom:'Installation du backend'}[action] || 'Installation du moteur';
 }
 function lcChipSync(j){
   const chip = document.getElementById('lc-chip');
@@ -73,7 +74,7 @@ function lcChipOpen(){
   const side = document.getElementById('side');
   if(!side.classList.contains('open')) toggleSide();
   const det = document.getElementById('lc-details');
-  det.open = true;
+  openDetails(det); // déplie aussi « Réglages », qui contient la section
   det.scrollIntoView({block:'center'});
   if(!document.getElementById('lc-chip').classList.contains('failed')) return;
   lcSeenEnd = true;
@@ -97,7 +98,7 @@ function lcRenderReco(reco){
   if(desc && reco && reco.why) desc.textContent = reco.why;
 }
 
-// Bascule entre « moteur de l'image » (une ligne d'état) et les trois modes
+// Bascule entre la carte « moteur de l'image » et les trois modes
 // d'installation gérés par Loki.
 function lcRenderProvided(s){
   const box = document.getElementById('lc-provided');
@@ -108,8 +109,87 @@ function lcRenderProvided(s){
   if(!s.provided) return;
   const bin = document.getElementById('lc-provided-bin');
   if(bin) bin.textContent = s.config_bin || '';
-  const job = document.getElementById('lc-job');
-  if(job) job.style.display = 'none';
+  loadEngine();
+  // Un job de mise à jour du moteur peut être en cours : le bloc de progression
+  // était masqué ici tant que la carte ne servait qu'à dire « rien à faire ».
+  if(s.job && s.job.exists && s.job.running && !lcPoll){
+    openDetails('lc-details');
+    lcStartPolling();
+  }
+  lcChipSync(s.job);
+}
+
+// --- Moteur de l'image : le mettre à jour sans reconstruire l'image ---------
+// llama.cpp publie plusieurs versions par jour ; son moteur déjà compilé vit
+// dans l'image officielle, dont on n'extrait que /app (~170 Mo). Voir
+// web_engine.go pour le détail, et pourquoi ce n'est pas une release GitHub :
+// llama.cpp n'en publie aucune pour CUDA/Linux.
+let engState = null;
+
+async function loadEngine(){
+  let s;
+  try{ s = await jget('/api/engine'); }catch(_){ return; }
+  engState = s;
+  const build = document.getElementById('eng-build');
+  if(build) build.textContent = s.build ? ('b'+s.build+(s.commit ? ' · '+s.commit : '')) : 'version inconnue';
+  const src = document.getElementById('eng-source');
+  if(src) src.textContent = {image:'fourni par l\'image', downloaded:'mis à jour par Loki',
+                             prebuilt:'précompilé', custom:'personnalisé'}[s.source] || '';
+  const repo = document.getElementById('eng-repo');
+  if(repo) repo.textContent = s.repo + ':' + (s.variant || 'server');
+  // Le retour arrière n'a de sens que si on n'est pas déjà dessus.
+  const revert = document.getElementById('eng-revert');
+  if(revert) revert.style.display = (s.image_bin && s.source !== 'image') ? '' : 'none';
+  engSay('');
+}
+
+// engSay écrit sous la ligne d'état : c'est le résultat d'une vérification, qui
+// doit rester lisible après le toast (on ne se souvient pas d'un toast).
+function engSay(html, cls){
+  const el = document.getElementById('eng-latest');
+  if(!el) return;
+  el.innerHTML = html;
+  el.className = cls || 'muted';
+  el.style.display = html ? '' : 'none';
+}
+
+async function engCheck(){
+  toast('vérification…');
+  let r;
+  try{ r = await jpost('/api/engine/check', {}); }catch(_){ toast('erreur réseau'); return; }
+  if(!r.ok){ engSay('✗ '+String(r.error||'').replace(/[<>&]/g,'')); toast('erreur'); return; }
+  if(r.update){
+    engSay('Version disponible : <b>b'+r.latest+'</b>'+(r.current ? ' (installée : b'+r.current+')' : '')
+           + ' — « mettre à jour le moteur » pour l\'installer.');
+    toast('mise à jour disponible : b'+r.latest);
+  } else {
+    engSay('Moteur à jour ✓ (b'+r.latest+')');
+    toast('moteur à jour ✓');
+  }
+}
+
+async function engUpdate(){
+  if(!await askConfirm('Télécharger la dernière version de llama.cpp (~170 Mo) et l\'utiliser à la place du moteur de l\'image.\n\n'
+      + 'Le moteur est essayé avant d\'être adopté ; celui de l\'image reste intact. Le moteur redémarre à la fin — la génération en cours sera coupée.',
+      {title:'Mettre à jour le moteur', okText:'Mettre à jour'})) return;
+  let r;
+  try{ r = await jpost('/api/engine/update', {}); }catch(_){ toast('erreur réseau'); return; }
+  if(!r.ok){ toast('erreur : '+(r.error||'')); return; }
+  openDetails('lc-details');
+  lcStartPolling();
+}
+
+// Bascule vers une version déjà installée — « image » = celle d'origine.
+async function engUse(tag){
+  const image = tag === 'image';
+  if(!await askConfirm(image ? 'Repasser sur le moteur livré avec l\'image Docker. Le moteur redémarre.'
+                             : 'Utiliser la version « '+tag+' ». Le moteur redémarre.',
+      {title:'Changer de moteur', okText:'Basculer'})) return;
+  let r;
+  try{ r = await jpost('/api/engine/use', {tag}); }catch(_){ toast('erreur réseau'); return; }
+  if(!r.ok){ toast('erreur : '+(r.error||'')); return; }
+  toast('moteur basculé — redémarrage en cours');
+  loadAll();
 }
 
 function lcRenderMode(mode, installed){
@@ -235,7 +315,7 @@ async function lcInstallCustom(){
   const r = await jpost('/api/llamacpp/install-custom', {repo:url, name});
   if(!r.ok){ toast('erreur : '+(r.error||'')); return; }
   closeCustomBackends();
-  document.getElementById('lc-details').open = true;
+  openDetails('lc-details');
   lcStartPolling();
 }
 

internal/loki/ui/src/js/12-mcp.js

@@ -63,7 +63,8 @@ function renderMCP(r){
     sw.appendChild(cb); sw.appendChild(sl);
 
     const edit = document.createElement('button');
-    edit.className = 'mcp-edit'; edit.title = 'éditer'; edit.textContent = '✎';
+    edit.className = 'mcp-edit'; edit.title = 'éditer';
+    edit.setAttribute('aria-label', 'éditer ce serveur'); edit.appendChild(icon('pencil', 15));
     edit.onclick = (e)=>{ e.stopPropagation(); openMcp(s.name); };
 
     row.appendChild(dot); row.appendChild(info); row.appendChild(sw); row.appendChild(edit);
@@ -77,6 +78,118 @@ async function toggleMcp(name, on){
   toast(on ? 'serveur activé' : 'serveur désactivé');
 }
 
+// ─── Catalogue ───────────────────────────────────────────────────────────────
+// Liste embarquée de serveurs connus, servie par /api/mcp/catalog. Choisir une
+// entrée n'installe RIEN : ça ouvre la modale d'ajout préremplie, l'utilisateur
+// relit la commande (qui s'exécutera sur cette machine) puis enregistre.
+let mcpCatalog = [];
+let mcpCatalogFilter = 'Tous';
+
+async function openMcpCatalog(){
+  showModal('mcp-catalog-modal');
+  const list = document.getElementById('mcp-catalog-list');
+  if(!mcpCatalog.length){
+    list.innerHTML = '<div class="muted" style="font-size:12px">chargement…</div>';
+    const r = await jget('/api/mcp/catalog');
+    mcpCatalog = (r && r.catalog) || [];
+  }
+  renderMcpCatalog();
+}
+
+function closeMcpCatalog(){ hideModal('mcp-catalog-modal'); }
+
+function renderMcpCatalog(){
+  const list = document.getElementById('mcp-catalog-list');
+  const tabs = document.getElementById('mcp-catalog-tabs');
+  list.textContent = '';
+  tabs.textContent = '';
+
+  if(!mcpCatalog.length){
+    list.innerHTML = '<div class="muted" style="font-size:12px">(catalogue vide)</div>';
+    return;
+  }
+
+  const cats = ['Tous'].concat([...new Set(mcpCatalog.map(e=>e.category))].sort());
+  cats.forEach(c=>{
+    const b = document.createElement('button');
+    b.className = 'mcp-cat'+(c===mcpCatalogFilter?' on':'');
+    b.textContent = c;
+    b.onclick = ()=>{ mcpCatalogFilter = c; renderMcpCatalog(); };
+    tabs.appendChild(b);
+  });
+
+  mcpCatalog
+    .filter(e=>mcpCatalogFilter==='Tous' || e.category===mcpCatalogFilter)
+    .forEach(e=>{
+      const row = document.createElement('div');
+      row.className = 'mcp-cat-row';
+
+      const info = document.createElement('div'); info.className = 'mcp-info';
+      const nm = document.createElement('div'); nm.className = 'mcp-name';
+      nm.textContent = e.name;
+      if(e.installed){
+        const tag = document.createElement('span'); tag.className = 'mcp-tag';
+        tag.textContent = 'installé'; tag.style.marginLeft = '6px';
+        nm.appendChild(tag);
+      }
+      const desc = document.createElement('div'); desc.className = 'mcp-cat-desc';
+      desc.textContent = e.description;
+      const meta = document.createElement('div'); meta.className = 'mcp-meta';
+      const cmd = document.createElement('code'); cmd.className = 'mcp-cat-cmd';
+      cmd.textContent = [e.command].concat(e.args||[]).join(' ');
+      cmd.title = cmd.textContent;
+      meta.appendChild(cmd);
+      if(!e.runtimeOk){
+        const w = document.createElement('span'); w.className = 'mcp-err';
+        w.textContent = 'runtime '+(e.runtime||'?')+' absent';
+        w.title = e.runtime==='python'
+          ? "uv/uvx n'est pas installé sur cette machine : ce serveur ne pourra pas démarrer."
+          : "npx n'est pas installé sur cette machine : ce serveur ne pourra pas démarrer.";
+        meta.appendChild(w);
+      }
+      if((e.secrets||[]).length){
+        const s = document.createElement('span'); s.className = 'mcp-tag';
+        s.textContent = 'clé requise'; s.title = e.secrets.join(', ');
+        meta.appendChild(s);
+      }
+      info.appendChild(nm); info.appendChild(desc); info.appendChild(meta);
+
+      const use = document.createElement('button');
+      use.className = 'addbtn mcp-cat-use';
+      use.textContent = e.installed ? 'revoir' : 'utiliser';
+      use.onclick = ()=>{ closeMcpCatalog(); openMcpFromCatalog(e); };
+
+      row.appendChild(info); row.appendChild(use);
+      list.appendChild(row);
+    });
+}
+
+// Préremplit la modale d'ajout à partir d'une entrée du catalogue. Le nom du
+// serveur = l'id de l'entrée, pour que « déjà installé » se détecte ensuite.
+function openMcpFromCatalog(e){
+  openMcp(mcpServers.some(s=>s.name===e.id) ? e.id : '');
+  if(!mcpServers.some(s=>s.name===e.id)){
+    document.getElementById('mcp-name').value = e.id;
+    document.querySelector('input[name="mcp-transport"][value="stdio"]').checked = true;
+    mcpTransportUI('stdio');
+    document.getElementById('mcp-command').value = e.command || '';
+    document.getElementById('mcp-args').value = (e.args||[]).join('\n');
+    document.getElementById('mcp-env').value =
+      Object.entries(e.env||{}).map(([k,v])=>k+'='+v).join('\n');
+    document.getElementById('mcp-url').value = '';
+    document.getElementById('mcp-headers').value = '';
+    document.getElementById('mcp-modal-title').textContent = e.name+' — depuis le catalogue';
+  }
+  const st = document.getElementById('mcp-modal-status');
+  if((e.secrets||[]).length){
+    st.textContent = 'renseigne '+e.secrets.join(', ')+' avant d\'enregistrer';
+    st.style.color = 'var(--err)';
+  } else if(!e.runtimeOk){
+    st.textContent = '⚠ runtime '+(e.runtime||'?')+' absent : le serveur ne démarrera pas ici';
+    st.style.color = 'var(--err)';
+  }
+}
+
 // Ouvre la modale d'ajout (name='') ou d'édition (nom existant).
 function openMcp(name){
   mcpEditing = name || '';

internal/loki/ui/src/js/13-reasoning.js

@@ -0,0 +1,42 @@
+// ─── Intensité du raisonnement (barre de saisie) ─────────────────────────────
+// Le même réglage existe dans l'éditeur de preset, mais il y est figé avec le
+// preset : le changer demande d'ouvrir les réglages, éditer, enregistrer. Ici il
+// s'applique au message suivant, sans redémarrer le moteur — `reasoning_effort`
+// voyage dans le corps de la requête, pas dans la ligne de commande.
+//
+// La valeur part dans la config vivante. Appliquer un preset la réécrit : le
+// réglage reste donc attaché au modèle, cette liste ne fait que le dévier à la
+// volée.
+
+const THINK_EFFORT_LABELS = {
+  '':       'auto',
+  none:     'aucune',
+  low:      'basse',
+  medium:   'moyenne',
+  high:     'haute',
+  xhigh:    'maximale',
+};
+
+async function loadThinkEffort(){
+  try{ applyThinkEffort(await jget('/api/reasoning-effort')); }
+  catch(e){ /* endpoint indisponible : la liste garde sa valeur par défaut */ }
+}
+
+function applyThinkEffort(r){
+  const sel = document.getElementById('think-effort');
+  if(!sel || !r || !r.ok) return;
+  sel.value = r.value || '';
+  // Raisonnement coupé au niveau du preset : le niveau n'a plus de prise. On
+  // grise plutôt que de masquer, pour que le réglage reste trouvable.
+  sel.disabled = !r.on;
+  sel.title = r.on
+    ? 'Intensité du raisonnement — envoyée au gabarit du modèle'
+    : 'Raisonnement désactivé pour ce modèle (réglages → Raisonnement)';
+}
+
+async function setThinkEffort(value){
+  const r = await jpost('/api/reasoning-effort', {value});
+  if(!r || !r.ok){ toast((r && r.error) || 'réglage refusé'); return; }
+  applyThinkEffort(r);
+  toast('raisonnement : '+(THINK_EFFORT_LABELS[r.value||''] || r.value));
+}

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

@@ -26,12 +26,28 @@ function fmtSize(n){
   if(n >= 1024) return Math.round(n/1024)+' Ko';
   return n+' o';
 }
+// Un nom de fichier ne dit pas ce qu'on a joint : pour une image, on montre
+// l'image. Reconnaissance à l'extension — le serveur, lui, renifle le CONTENU
+// (handleChatImage) et répond 415 si ça n'en est pas une, donc au pire on affiche
+// une vignette cassée qui retombe sur son texte de repli.
+const IMG_EXT = /\.(png|jpe?g|gif|webp|bmp|svg|avif|ico|heic|heif|tiff?)$/i;
+function isImageName(name){ return IMG_EXT.test(String(name||'')); }
 // Pastille de fichier, partagée par le composeur et les bulles du fil : même
 // objet visuel des deux côtés, seul le contexte (CSS) change.
+//
+// opts.thumb = URL d'aperçu : la pastille porte alors une vignette à gauche du
+// nom. Le composeur s'en sert avec un objectURL local (rien n'est encore parti
+// vers le serveur à ce stade).
 function fileChip(name, size, opts){
   opts=opts||{};
   const chip=document.createElement('div');
   chip.className='chip-file'+(opts.cls?' '+opts.cls:'');
+  if(opts.thumb){
+    const t=document.createElement('img');
+    t.className='cf-thumb'; t.src=opts.thumb; t.alt='';
+    chip.appendChild(t);
+    chip.classList.add('has-thumb');
+  }
   const n=document.createElement('span');
   n.className='cf-name'; n.textContent=name; n.title=opts.title||name;
   const s=document.createElement('span');
@@ -49,12 +65,31 @@ function fileChip(name, size, opts){
 // Fichiers joints à un message DÉJÀ envoyé : posés AU-DESSUS de la bulle, dans
 // leur propre rangée. Les mettre dedans étirait la bulle vers le haut et donnait
 // un bloc bâtard, moitié texte moitié pastilles.
+// Vignette d'une image DÉJÀ déposée : on la redemande au serveur par son chemin
+// de travail. hydrateImages fait le fetch authentifié et pose le blob: — une
+// balise <img> ne peut pas porter la clé de pilotage.
+function msgImgTile(f){
+  const box=document.createElement('div');
+  box.className='msg-img';
+  const img=document.createElement('img');
+  img.src='/api/chat/image?path='+encodeURIComponent(f.path);
+  img.alt=f.name||''; img.title=f.name||'';
+  box.appendChild(img);
+  return box;
+}
 function addMsgFiles(el, files){
   if(!el || !files || !files.length) return;
   const box=document.createElement('div');
   box.className='msg-files';
-  for(const f of files) box.appendChild(fileChip(f.name, f.size, {title:f.path||f.name}));
+  for(const f of files){
+    // Image : la vignette REMPLACE la pastille texte. Deux objets pour un seul
+    // fichier (une vignette + son nom en pastille) doublerait la rangée sans rien
+    // apprendre — le nom vit dans l'infobulle et dans la loupe.
+    if(f.path && isImageName(f.name)) box.appendChild(msgImgTile(f));
+    else box.appendChild(fileChip(f.name, f.size, {title:f.path||f.name}));
+  }
   el.parentNode.insertBefore(box, el);
+  hydrateImages(box);
   // Envoi sans un mot : la bulle serait un rectangle vide sous les pastilles.
   markEmptyMsg(el);
   return box;
@@ -202,11 +237,18 @@ function renderAttach(){
       sizeText: a.state==='err' ? 'échec'
         : (a.state==='up' && a.size>ATTACH_CHUNK) ? Math.round((a.sent||0)*100/a.size)+' %'
         : fmtSize(a.size),
-      onRemove: ()=>{ ATTACH=ATTACH.filter(o=>o.id!==a.id); renderAttach(); }
+      thumb: a.thumb,
+      onRemove: ()=>{ ATTACH=ATTACH.filter(o=>o.id!==a.id); dropThumb(a); renderAttach(); }
     }));
   }
 }
-function clearAttach(){ ATTACH=[]; renderAttach(); }
+// L'aperçu du composeur vit sur un objectURL local : il meurt avec sa pastille,
+// sinon chaque fichier retiré laisse son image en mémoire jusqu'au rechargement.
+// (La bulle envoyée, elle, repart du serveur — elle ne dépend pas de cet URL.)
+function dropThumb(a){
+  if(a && a.thumb){ URL.revokeObjectURL(a.thumb); a.thumb=null; }
+}
+function clearAttach(){ for(const a of ATTACH) dropThumb(a); ATTACH=[]; renderAttach(); }
 // Ce qui part avec le message, pour l'afficher dans sa bulle.
 function attachSent(){ return ATTACH.filter(a=>a.state==='ok').map(a=>({name:a.name,size:a.size,path:a.path})); }
 
@@ -277,7 +319,11 @@ function addFiles(files){
   for(const f of files||[]){
     if(f.size>ATTACH_MAX){ toast('« '+f.name+' » fait '+fmtSize(f.size)+' — maximum '+fmtSize(ATTACH_MAX)); continue; }
     if(!f.size){ toast('« '+f.name+' » est vide'); continue; }
-    ATTACH.push({id:++ATTACH_SEQ, name:f.name||'fichier', size:f.size, file:f, path:null, state:'queued'});
+    // Aperçu tout de suite, depuis le fichier local : rien n'est encore parti
+    // vers le serveur (le dépôt n'a lieu qu'à l'envoi), donc c'est la seule
+    // source d'image disponible à ce stade.
+    const thumb = isImageName(f.name) ? URL.createObjectURL(f) : null;
+    ATTACH.push({id:++ATTACH_SEQ, name:f.name||'fichier', size:f.size, file:f, path:null, state:'queued', thumb:thumb});
   }
   renderAttach();
 }

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

@@ -1,9 +1,15 @@
-// ─── Fichiers du dossier de travail ──────────────────────────────────────────
+// ─── Fichiers de la discussion ───────────────────────────────────────────────
 // L'agent écrit des rapports, des scripts, des exports, des captures. Jusqu'ici
 // on ne pouvait récupérer un fichier que si le modèle avait pensé à en mettre le
 // lien dans sa réponse — tout le reste restait invisible, et faire le ménage
 // demandait un shell.
 //
+// Le panneau montre les fichiers de la discussion OUVERTE, et rien d'autre :
+// chaque discussion a son dossier côté serveur (chat_convfiles.go), changer de
+// discussion change donc la liste, et supprimer une discussion emporte ses
+// fichiers. `FILES_SCOPE = 'legacy'` ouvre le détour « hors discussion » : les
+// fichiers d'avant ce rangement, que la migration n'a pas su rattacher.
+//
 // Le panneau est construit EN DOM, jamais en innerHTML : les noms de fichiers
 // viennent du modèle et du système de fichiers, donc d'ailleurs. Même règle que
 // pour les titres de discussions (16-conversations.js).
@@ -11,7 +17,8 @@
 // Le téléchargement réutilise downloadWorkspaceFile (14-attach.js), qui sait
 // déjà gérer le blob et les cas particuliers du navigateur.
 
-let FILES_DIR = '';   // dossier affiché, relatif au dossier de travail
+let FILES_DIR = '';   // dossier affiché, relatif à la racine du panneau
+let FILES_SCOPE = ''; // '' = discussion ouverte, 'legacy' = fichiers hors discussion
 let FILES_OPEN = false;
 
 // Ouvre/ferme le panneau. L'état est persisté : sur un grand écran on garde
@@ -44,7 +51,7 @@ async function loadFiles(dir){
   const foot = document.getElementById('files-foot');
   if(!list) return;
   let r;
-  try{ r = await jget('/api/chat/files?dir='+encodeURIComponent(FILES_DIR)); }
+  try{ r = await jget('/api/chat/files?dir='+encodeURIComponent(FILES_DIR)+'&scope='+encodeURIComponent(FILES_SCOPE)); }
   catch(_){ filesMsg('lecture impossible'); return; }
   if(!r.ok){
     // Un dossier supprimé entre deux affichages (par l'agent, ou depuis un autre
@@ -58,13 +65,50 @@ async function loadFiles(dir){
   if(!r.entries.length){
     const d = document.createElement('div');
     d.className = 'files-empty muted';
-    d.textContent = FILES_DIR ? '(dossier vide)' : "L'agent n'a encore rien écrit ici.";
+    d.textContent = FILES_DIR ? '(dossier vide)'
+      : (FILES_SCOPE === 'legacy' ? '(plus rien hors discussion)'
+                                  : "Rien dans cette discussion — les fichiers déposés et ceux que l'agent écrit apparaissent ici.");
     list.appendChild(d);
   }
   for(const e of r.entries) list.appendChild(fileRow(e));
 
-  foot.textContent = r.count + (r.count > 1 ? ' fichiers · ' : ' fichier · ') + fmtSize(r.total);
+  renderFoot(foot, r);
+}
+
+// Pied : occupation disque de ce qui est affiché — la discussion ouverte, ou le
+// hors-discussion — et le va-et-vient entre les deux. Le bouton n'apparaît que
+// s'il reste vraiment quelque chose hors discussion (compté par le serveur), et
+// disparaît de lui-même une fois le ménage fait.
+function renderFoot(foot, r){
+  if(!foot) return;
+  foot.textContent = '';
+  const n = document.createElement('span');
+  n.textContent = r.count + (r.count > 1 ? ' fichiers · ' : ' fichier · ') + fmtSize(r.total);
+  foot.appendChild(n);
   foot.title = r.root || '';
+  // Tout emporter d'un coup : la discussion entière (dossiers et sous-dossiers
+  // compris) en une archive .zip. Absent quand il n'y a rien à archiver.
+  if(r.count > 0){
+    const z = document.createElement('button');
+    z.className = 'files-scope';
+    z.textContent = '.zip';
+    z.title = 'tout télécharger en une archive .zip';
+    z.onclick = ()=>downloadFilesZip(z);
+    foot.appendChild(z);
+  }
+  if(FILES_SCOPE !== 'legacy' && !r.legacy) return;
+  const b = document.createElement('button');
+  b.className = 'files-scope';
+  if(FILES_SCOPE === 'legacy'){
+    b.textContent = '← cette discussion';
+    b.title = 'revenir aux fichiers de la discussion ouverte';
+    b.onclick = ()=>{ FILES_SCOPE = ''; loadFiles(''); };
+  } else {
+    b.textContent = 'hors discussion (' + r.legacy + ')';
+    b.title = "fichiers d'avant le rangement par discussion";
+    b.onclick = ()=>{ FILES_SCOPE = 'legacy'; loadFiles(''); };
+  }
+  foot.appendChild(b);
 }
 
 function filesMsg(txt){
@@ -76,7 +120,9 @@ function filesMsg(txt){
   list.appendChild(d);
 }
 
-// Fil d'Ariane : « travail / captures / <id> », chaque segment cliquable.
+// Fil d'Ariane : « discussion / captures », chaque segment cliquable. La racine
+// est le dossier de la discussion ouverte — on n'en sort pas, sauf par le
+// détour « hors discussion », qui a sa propre racine.
 function renderCrumb(r){
   const c = document.getElementById('files-crumb');
   c.textContent = '';
@@ -89,7 +135,7 @@ function renderCrumb(r){
     c.appendChild(b);
   };
   const parts = r.dir ? r.dir.split('/') : [];
-  seg('travail', '', parts.length === 0);
+  seg(FILES_SCOPE === 'legacy' ? 'hors discussion' : 'discussion', '', parts.length === 0);
   let acc = '';
   parts.forEach((p, i)=>{
     acc = acc ? acc + '/' + p : p;
@@ -106,7 +152,7 @@ function fileRow(e){
 
   const ic = document.createElement('span');
   ic.className = 'files-ic';
-  ic.textContent = e.dir ? '▸' : (e.image ? '▣' : '·');
+  ic.appendChild(icon(e.dir ? 'folder' : (e.image ? 'image' : 'file'), 16));
   row.appendChild(ic);
 
   const mid = document.createElement('span');
@@ -135,12 +181,14 @@ function fileRow(e){
   acts.className = 'files-acts';
   if(!e.dir){
     const dl = document.createElement('button');
-    dl.className = 'iconbtn'; dl.textContent = '↓'; dl.title = 'télécharger';
+    dl.className = 'iconbtn'; dl.appendChild(icon('download', 16));
+    dl.title = 'télécharger'; dl.setAttribute('aria-label', 'télécharger');
     dl.onclick = ev=>{ ev.stopPropagation(); downloadWorkspaceFile(e.path, e.name, row); };
     acts.appendChild(dl);
   }
   const rm = document.createElement('button');
-  rm.className = 'iconbtn'; rm.textContent = '🗑'; rm.title = 'supprimer';
+  rm.className = 'iconbtn'; rm.appendChild(icon('trash', 16));
+  rm.title = 'supprimer'; rm.setAttribute('aria-label', 'supprimer');
   rm.onclick = ev=>{ ev.stopPropagation(); removeFile(e); };
   acts.appendChild(rm);
   row.appendChild(acts);
@@ -155,12 +203,66 @@ async function removeFile(e){
     : '« '+e.name+' » ('+fmtSize(e.size)+') sera supprimé.';
   if(!await askConfirm(quoi + '\n\nC\'est définitif — le fichier ne part pas à la corbeille.',
       {title:'Supprimer ?', okText:'Supprimer', danger:true})) return;
-  const r = await jpost('/api/chat/file/delete', {path: e.path});
+  const r = await jpost('/api/chat/file/delete', {path: e.path, scope: FILES_SCOPE});
   if(!r.ok){ toast('suppression impossible : '+(r.error||'')); return; }
   toast('supprimé — '+fmtSize(r.freed||0)+' libérés');
   loadFiles();
 }
 
+// Télécharge TOUT le contenu affiché (discussion ou hors-discussion) en .zip.
+// Même danse que downloadWorkspaceFile (14-attach.js) : la fiche meta d'abord —
+// c'est elle qui CONSTRUIT l'archive côté serveur — puis le brut en direct, ou
+// les tranches base64 derrière le tunnel chiffré.
+async function downloadFilesZip(btn){
+  if(btn){ btn.disabled = true; btn.textContent = '…'; }
+  try{
+    const m = await jfetch('/api/chat/files/zip?meta=1&scope='+encodeURIComponent(FILES_SCOPE));
+    const meta = await m.json().catch(()=>({}));
+    if(!m.ok || !meta.ok){ toast('archive impossible : '+(meta.error||('HTTP '+m.status))); return; }
+    let blob;
+    if(meta.e2e){
+      blob = await fetchZipB64(meta.size||0);
+    } else {
+      const r = await jfetch('/api/chat/files/zip?scope='+encodeURIComponent(FILES_SCOPE));
+      if(!r.ok){ let msg='HTTP '+r.status; try{ msg=(await r.json()).error||msg; }catch(_){} toast('archive impossible : '+msg); return; }
+      blob = await r.blob();
+    }
+    const u = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = u; a.download = meta.name || 'loki-fichiers.zip';
+    document.body.appendChild(a); a.click(); a.remove();
+    setTimeout(()=>URL.revokeObjectURL(u), 10000);
+    toast(meta.files + ' fichier'+(meta.files>1?'s':'')+' archivé'+(meta.files>1?'s':''));
+  }catch(e){ toast('archive impossible : '+((e&&e.message)||'erreur')); }
+  finally{ if(btn){ btn.disabled = false; btn.textContent = '.zip'; } }
+}
+
+// Tranches base64 du zip (tunnel chiffré) — cousin de fetchFileB64.
+async function fetchZipB64(size){
+  const parts = [];
+  let off = 0;
+  do{
+    const r = await jfetch('/api/chat/files/zip?b64=1&len='+DL_CHUNK+'&offset='+off+'&scope='+encodeURIComponent(FILES_SCOPE));
+    const j = await r.json();
+    if(!r.ok || !j.ok) throw new Error(j.error||('HTTP '+r.status));
+    const bytes = b64ToBytes(j.data||'');
+    parts.push(bytes);
+    if(!bytes.length && !j.eof) throw new Error('transfert interrompu');
+    off = (j.offset||0) + bytes.length;
+    if(j.eof) break;
+  } while(off < size);
+  return new Blob(parts, {type:'application/zip'});
+}
+
+// Changement de discussion (bascule, « vider »), signalé par le flux SSE :
+// le panneau montre les fichiers de la discussion OUVERTE, il doit donc être
+// redessiné. On revient aussi à sa racine — le sous-dossier affiché était celui
+// de l'autre discussion, il n'existe pas forcément ici.
+function filesOnConvChange(){
+  FILES_DIR = ''; FILES_SCOPE = '';
+  if(FILES_OPEN) loadFiles('');
+}
+
 // Date courte : l'heure pour aujourd'hui, la date sinon. Ce qu'on veut savoir,
 // c'est « est-ce que ça vient du tour que je viens de lancer ? ».
 document.addEventListener('DOMContentLoaded', initFiles);

internal/loki/ui/src/js/16-conversations.js

@@ -8,43 +8,145 @@
 // Les titres viennent du premier message de l'utilisateur : ils sont construits
 // en DOM (jamais en innerHTML) pour qu'un titre contenant < > & " ne casse ni le
 // balisage ni les gestionnaires d'événement.
+//
+// La liste chargée est GARDÉE en mémoire (CONVS) pour que la recherche filtre
+// sans aller-retour serveur : elle ne porte que des métadonnées — identifiant,
+// titre, dates, nombre d'échanges — jamais les messages.
+
+let CONVS = [], CONV_ACTIVE = '';
+// Vrai quand le SERVEUR dit qu'un tour tourne sur la discussion active. Sert au
+// premier affichage : le flux SSE n'a pas encore rejoué son journal, mais la
+// ligne doit déjà s'animer si un agent travaille (page rechargée en cours de
+// route, ou ouverte depuis un autre appareil).
+let CONV_BUSY = false;
 
 async function loadConversations(){
   let r;
   try{ r = await jget('/api/conversations'); }catch(_){ return; }
+  CONVS = r.conversations || [];
+  CONV_ACTIVE = r.active || '';
+  CONV_BUSY = !!r.busy;
+  renderConversations();
+}
+
+function renderConversations(){
   const cont = document.getElementById('conv-list');
   if(!cont) return;
-  cont.innerHTML = '';
-  const list = r.conversations || [];
-  if(!list.length){ cont.innerHTML = '<span class="muted">(aucune)</span>'; return; }
+  const q = (document.getElementById('conv-search')?.value || '').trim().toLowerCase();
+  cont.textContent = '';
+  const list = q
+    ? CONVS.filter(c => (c.title || 'Nouvelle discussion').toLowerCase().includes(q))
+    : CONVS;
+  if(!list.length){
+    const e = document.createElement('div');
+    e.className = 'conv-empty';
+    e.textContent = q ? 'aucune discussion ne correspond' : '(aucune)';
+    cont.appendChild(e);
+    syncTopbarTitle();
+    convSyncBusy();
+    return;
+  }
   for(const c of list){
     const row = document.createElement('div');
-    row.className = 'preset' + (c.id === r.active ? ' active' : '');
+    row.className = 'preset' + (c.id === CONV_ACTIVE ? ' active' : '');
+    // L'identifiant est porté par la ligne : convSyncBusy retrouve ainsi CELLE
+    // qui travaille sans redessiner la liste (un redessin relancerait
+    // l'animation de l'anneau à chaque événement du flux).
+    row.dataset.conv = c.id;
     row.onclick = () => convSwitch(c.id);
 
     const info = document.createElement('div'); info.className = 'preset-info';
     const nm = document.createElement('div'); nm.className = 'preset-name';
-    if(c.id === r.active){ const d = document.createElement('i'); d.className = 'preset-dot'; nm.appendChild(d); }
     const title = c.title || 'Nouvelle discussion';
     nm.appendChild(document.createTextNode(title));
-    nm.title = title;
-    const meta = document.createElement('div'); meta.className = 'preset-meta';
-    const when = document.createElement('span'); when.className = 'muted';
-    when.textContent = convWhen(c.updated) + (c.turns ? ' · ' + c.turns + ' échange' + (c.turns > 1 ? 's' : '') : '');
-    meta.appendChild(when);
-    info.appendChild(nm); info.appendChild(meta);
+    nm.title = title + (c.turns ? ' · ' + c.turns + ' échange' + (c.turns > 1 ? 's' : '') : '');
+    info.appendChild(nm);
+
+    // Heure à droite du titre, sur la même ligne (maquette). Elle s'efface au
+    // survol : renommer et supprimer prennent sa place, la ligne ne s'allonge
+    // donc jamais et rien ne se chevauche.
+    const when = document.createElement('span');
+    when.className = 'conv-when';
+    when.textContent = convWhen(c.updated);
 
     // Renommer / supprimer : stopPropagation, sinon le clic bascule aussi.
     const acts = document.createElement('div'); acts.className = 'conv-acts';
-    const ren = document.createElement('button'); ren.className = 'iconbtn'; ren.textContent = '✎';
-    ren.title = 'renommer'; ren.onclick = e => { e.stopPropagation(); convRename(c.id, title); };
-    const del = document.createElement('button'); del.className = 'iconbtn'; del.textContent = '🗑';
-    del.title = 'supprimer'; del.onclick = e => { e.stopPropagation(); convDelete(c.id, title); };
+    const ren = document.createElement('button'); ren.className = 'iconbtn';
+    ren.appendChild(icon('pencil', 15)); ren.title = 'renommer';
+    ren.setAttribute('aria-label', 'renommer la discussion');
+    ren.onclick = e => { e.stopPropagation(); convRename(c.id, title); };
+    const del = document.createElement('button'); del.className = 'iconbtn';
+    del.appendChild(icon('trash', 15)); del.title = 'supprimer';
+    del.setAttribute('aria-label', 'supprimer la discussion');
+    del.onclick = e => { e.stopPropagation(); convDelete(c.id, title); };
     acts.appendChild(ren); acts.appendChild(del);
 
-    row.appendChild(info); row.appendChild(acts);
+    row.append(info, when, acts);
     cont.appendChild(row);
   }
+  syncTopbarTitle();
+  convSyncBusy();
+}
+
+// --- Discussion au travail : anneau qui tourne ------------------------------
+// Une seule génération tourne à la fois, et c'est forcément sur la discussion
+// OUVERTE (le serveur n'a qu'un fil en mémoire) : l'indicateur va donc sur la
+// ligne active. Deux sources le renseignent — le flux SSE (`busy`, instantané)
+// et la liste (`CONV_BUSY`, utile avant que le rejeu ait rattrapé). Une fois le
+// rattrapage fini, l'état local fait foi : il est plus frais que la liste, qui
+// n'est rechargée qu'en fin de tour.
+function convBusyNow(){
+  const live = (typeof busy !== 'undefined') && busy;
+  if(typeof REPLAYING !== 'undefined' && !REPLAYING) return !!live;
+  return CONV_BUSY || !!live;
+}
+
+// Pose ou retire l'anneau dans un conteneur, SANS toucher au reste de son
+// contenu : réécrire l'hôte remettrait l'animation à zéro.
+function convSpinToggle(host, on, before){
+  if(!host) return;
+  let sp = host.querySelector(':scope > .conv-spin');
+  if(on && !sp){
+    sp = document.createElement('span');
+    sp.className = 'conv-spin';
+    sp.title = 'l\u2019agent travaille sur cette discussion\u2026';
+    sp.setAttribute('role', 'img');
+    sp.setAttribute('aria-label', 'génération en cours');
+    sp.appendChild(icon('spinner', 14));
+    if(before) host.insertBefore(sp, before); else host.appendChild(sp);
+  } else if(!on && sp){
+    sp.remove();
+  }
+}
+
+// Rafraîchit l'indicateur partout où il se montre : la ligne de la discussion
+// concernée, et l'en-tête (la barre latérale est escamotée sur téléphone — sans
+// ça, rien ne dirait que ça travaille).
+function convSyncBusy(){
+  const on = convBusyNow();
+  const cont = document.getElementById('conv-list');
+  if(cont){
+    for(const row of cont.querySelectorAll('.preset')){
+      const mine = on && row.dataset.conv === CONV_ACTIVE;
+      row.classList.toggle('working', mine);
+      convSpinToggle(row, mine, row.firstChild);
+    }
+  }
+  // Dans l'en-tête, l'anneau est un FRÈRE du titre : celui-ci tronque son texte
+  // à l'ellipse, un enfant y serait rogné avec lui sur un titre long.
+  const tb = document.getElementById('topbar-title');
+  convSpinToggle(tb && tb.parentNode, on, tb);
+}
+
+// Titre de l'en-tête : celui de la discussion ouverte. Il dit de quoi on parle
+// quand la barre latérale est escamotée — c'est-à-dire quand on en a besoin.
+function syncTopbarTitle(){
+  const el = document.getElementById('topbar-title');
+  if(!el) return;
+  const cur = CONVS.find(c => c.id === CONV_ACTIVE);
+  const t = (cur && cur.title) || 'Nouvelle discussion';
+  el.textContent = t;
+  el.title = t;
 }
 
 // Date courte : l'heure pour aujourd'hui, la date sinon — une liste de
@@ -62,6 +164,8 @@ async function convNew(){
   try{
     await jpost('/api/conversations/new', {});
     toast('nouvelle discussion');
+    const s = document.getElementById('conv-search');
+    if(s) s.value = ''; // sinon la discussion toute neuve est masquée par le filtre
     loadConversations();
   }catch(_){ toast('erreur réseau'); }
 }
@@ -85,7 +189,9 @@ async function convRename(id, current){
 }
 
 async function convDelete(id, title){
-  if(!await askConfirm('Supprimer « ' + title + ' » ? Cette discussion et son historique seront perdus.',
+  // Le geste emporte aussi les fichiers de la discussion : ils lui appartiennent
+  // (un dossier par discussion côté serveur), autant le dire avant.
+  if(!await askConfirm('Supprimer « ' + title + ' » ? Son historique ET ses fichiers (pièces jointes, captures, fichiers écrits par l\'agent) seront perdus.',
                        {title:'Supprimer la discussion', okText:'Supprimer', danger:true})) return;
   try{
     const r = await jpost('/api/conversations/delete', {id});

internal/loki/ui/src/js/17-identity.js

@@ -25,6 +25,21 @@ function paintLabel(label, role){
   const who = document.createElement('span'); who.className = 'who';
   who.textContent = role === 'user' ? (IDENT.name || 'toi') : 'Loki';
   label.appendChild(av); label.appendChild(who);
+  // Badge du modèle : quelle IA a produit CETTE réponse. Le nom vit dans
+  // dataset.model (posé par tagModel, 09-stream.js) — c'est ce qui le fait
+  // survivre au repeint des libellés lors d'un changement d'identité.
+  if(role === 'assistant' && label.parentElement && label.parentElement.dataset.model){
+    label.appendChild(modelBadge(label.parentElement.dataset.model));
+  }
+}
+
+// modelBadge fabrique la pastille du nom de modèle (partagée paintLabel/tagModel).
+function modelBadge(name){
+  const b = document.createElement('span');
+  b.className = 'modelbadge';
+  b.textContent = name;
+  b.title = 'modèle : ' + name;
+  return b;
 }
 
 async function loadIdentity(){