Banc d'essai : journal régénéré après le changement de l'UI

Le banc coupe son corpus au milieu de l'index.html embarqué : les deux
lignes de la carte « Serveurs MCP » et le champ de la fenêtre d'édition le
déplacent. Journal tiré sous Linux (LOKI_PARITY_UPDATE=1, TestPariteBench).

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

NOTICE.md

@@ -56,11 +56,13 @@ expose à la place un export/import de paquet chiffré en fichier local.
 
 Le second moteur de Loki (`internal/loki/backend_strata.go`) est
 **[Strata](https://github.com/Niko1221/Strata)** (MIT), spécialisé dans
-Qwen3.8-Flash-Next. Son intégration est reprise d'AJEAN (« AJEAN MoE 1.0 »,
+Qwen3.8-Flash-Next. Son intégration est reprise d'AJEAN (« AJEAN MoE 1.1 »,
 `backend_moe.go`) : Loki télécharge le paquet figé publié par AJEAN sur sa
-release `moe-v1.0` (sources de Strata et binaire Linux CUDA 12 compilé, avec
-les modifications d'AJEAN), vérifié par SHA-256. Ni Strata ni le modèle ne sont
-inclus dans l'image : ils sont téléchargés à la demande.
+release `moe-v1.1` (sources de Strata et binaire Linux CUDA 12 compilé, avec
+les modifications d'AJEAN), vérifié par SHA-256 avec les empreintes publiées
+par AJEAN. La reprise automatique d'une installation 1.0 (`strataMigrate`) est
+reprise d'AJEAN (`moeMigrate`). Ni Strata ni le modèle ne sont inclus dans
+l'image : ils sont téléchargés à la demande.
 
 ## Services externes
 

README.md

@@ -111,7 +111,7 @@ Loki a deux moteurs, et le choix se fait **par preset** (clé `ENGINE`) :
 - **[Strata](https://github.com/Niko1221/Strata)** — spécialisé dans
   **Qwen3.8 Flash Next** (MoE de 125 B) : les experts sont répartis entre
   VRAM, RAM et disque pour faire tourner ce modèle sur une carte de joueur.
-  Intégration reprise d'AJEAN (paquet figé « AJEAN MoE 1.0 », vérifié par
+  Intégration reprise d'AJEAN (paquet figé « AJEAN MoE 1.1 », vérifié par
   SHA-256).
 
 **Paramètres → Moteur → Strata** : la fenêtre lit la machine (cartes, RAM,
@@ -120,7 +120,26 @@ puis installe et active le modèle en un clic (téléchargement de 66 à 84 Go d
 `/data/strata`). Le modèle installé devient un preset comme les autres :
 basculer dessus lance Strata, basculer sur un autre preset revient à llama.cpp.
 Son engrenage ouvre les réglages propres à Strata (contexte jusqu'à 262 144,
-cache KV fp16/8 bits, prédiction MTP, lecture des images, carte d'appoint).
+cache KV fp16/8 bits, prédiction MTP, lecture des images, seconde carte).
+
+La seconde carte a trois réglages : **non utilisée**, **aide aux experts** (le
+défaut : elle garde et calcule une part des experts) ou **partage des couches**
+(les deux cartes se répartissent les couches du modèle). Le partage est souvent
+plus rapide avec deux cartes identiques (+50 % en génération mesuré par un
+utilisateur d'AJEAN sur deux RTX 3060) ; sur deux cartes très différentes,
+l'aide aux experts reste le meilleur choix. En partage des couches, le mode
+« hors RAM » n'est jamais choisi : la seconde carte n'y garde pas d'experts.
+
+Depuis le paquet 1.1, la carte d'appoint calcule elle-même ses experts à la
+lecture des prompts (au lieu de les recopier vers la principale) : les ajouts
+de 100 à 200 jetons se lisent ~30 à 40 % plus vite (mesures d'AJEAN). Un modèle
+installé avec la 1.0 passe à la 1.1 **à son premier lancement**, sans
+réinstallation : Loki télécharge le nouveau paquet (~340 Mo), reprend
+l'environnement Python et la configuration de la 1.0 (le dossier
+`/data/strata/ajean-moe-1.0` doit donc rester en place) et réécrit le preset.
+En cas d'échec, la 1.0 continue de tourner et la raison est dans le journal du
+moteur. En mode « hors RAM », le contexte est plafonné à 131 072 jetons (au-delà,
+le cache KV verrouillé en RAM ne tient plus).
 
 Pré-requis : Linux + NVIDIA RTX 20 ou plus récente (8 Go de VRAM minimum, une
 deuxième carte est utilisée comme carte d'appoint), environ 46 Go de RAM pour

internal/loki/backend_models.go

@@ -282,10 +282,96 @@ type dlState struct {
 	Part      int    `json:"part"`  // tranche en cours (1-based)
 	Finished  bool   `json:"finished"`
 	Canceled  bool   `json:"canceled"`
+	Paused    bool   `json:"paused"`
 	Err       string `json:"error"`
 	StartedAt int64  `json:"started_at"`
 
 	cancel context.CancelFunc `json:"-"` // set while in flight, cleared on finish
+	gate   *dlGate            `json:"-"`
+}
+
+// dlGate met un téléchargement en pause (repris d'AJEAN v0.18.1) : les
+// connexions en cours sont coupées (rien ne reste ouvert vers le CDN pendant la
+// pause), et chaque morceau attend la reprise puis repart de l'octet où il
+// s'était arrêté, par une requête de plage.
+type dlGate struct {
+	mu      sync.Mutex
+	paused  bool
+	wake    chan struct{}              // fermé à la reprise
+	attempt map[int]context.CancelFunc // requêtes en cours, coupées par la pause
+	next    int
+}
+
+func newDlGate() *dlGate { return &dlGate{attempt: map[int]context.CancelFunc{}} }
+
+func (g *dlGate) setPaused(p bool) {
+	if g == nil {
+		return
+	}
+	g.mu.Lock()
+	defer g.mu.Unlock()
+	if p == g.paused {
+		return
+	}
+	g.paused = p
+	if p {
+		g.wake = make(chan struct{})
+		for _, c := range g.attempt {
+			c()
+		}
+		return
+	}
+	close(g.wake)
+}
+
+// wait bloque tant que le téléchargement est en pause. false = annulé entre-temps.
+func (g *dlGate) wait(ctx context.Context) bool {
+	if g == nil {
+		return ctx.Err() == nil
+	}
+	g.mu.Lock()
+	paused, wake := g.paused, g.wake
+	g.mu.Unlock()
+	if !paused {
+		return ctx.Err() == nil
+	}
+	select {
+	case <-wake:
+		return ctx.Err() == nil
+	case <-ctx.Done():
+		return false
+	}
+}
+
+func (g *dlGate) isPaused() bool {
+	if g == nil {
+		return false
+	}
+	g.mu.Lock()
+	defer g.mu.Unlock()
+	return g.paused
+}
+
+// begin ouvre une requête que la pause pourra couper ; la fonction rendue la referme.
+func (g *dlGate) begin(ctx context.Context) (context.Context, func()) {
+	if g == nil {
+		return ctx, func() {}
+	}
+	actx, cancel := context.WithCancel(ctx)
+	g.mu.Lock()
+	id := g.next
+	g.next++
+	g.attempt[id] = cancel
+	if g.paused {
+		cancel() // pause tombée entre wait et begin
+	}
+	g.mu.Unlock()
+	return actx, func() {
+		g.mu.Lock()
+		delete(g.attempt, id)
+		g.mu.Unlock()
+		cancel()
+	}
 }
 
 var (
@@ -429,7 +515,7 @@ func handleModelDownload(w http.ResponseWriter, r *http.Request) {
 	ctx, cancel := context.WithCancel(context.Background())
 	st := &dlState{
 		Filename: name, URL: urls[0], Dir: filepath.Dir(dests[0]),
-		Parts: len(todoURLs), StartedAt: time.Now().Unix(), cancel: cancel,
+		Parts: len(todoURLs), StartedAt: time.Now().Unix(), cancel: cancel, gate: newDlGate(),
 	}
 	dlDownloads[name] = st
 	dlMu.Unlock()
@@ -759,7 +845,9 @@ func runDownloadSet(ctx context.Context, st *dlState, urls, dests []string) {
 				dt := now.Sub(lastAt).Seconds()
 				dlMu.Lock()
 				st.Done = cur
-				if dt > 0 {
+				if st.Paused {
+					st.Speed = 0
+				} else if dt > 0 {
 					inst := int64(float64(cur-last) / dt)
 					if st.Speed == 0 {
 						st.Speed = inst
@@ -827,7 +915,7 @@ func dlOnePart(ctx context.Context, st *dlState, dlURL, dest string, total int64
 			return err
 		}
 	}
-	if err := dlFetch(ctx, f, dlURL, total, conns, done); err != nil {
+	if err := dlFetch(ctx, st.gate, f, dlURL, total, conns, done); err != nil {
 		f.Close()
 		_ = os.Remove(tmp)
 		return err
@@ -845,9 +933,9 @@ func dlOnePart(ctx context.Context, st *dlState, dlURL, dest string, total int64
 
 // dlFetch writes the whole body into f, either as one stream or as `conns`
 // parallel byte ranges. done is incremented atomically as bytes land on disk.
-func dlFetch(ctx context.Context, f *os.File, dlURL string, total int64, conns int, done *int64) error {
+func dlFetch(ctx context.Context, g *dlGate, f *os.File, dlURL string, total int64, conns int, done *int64) error {
 	if conns <= 1 {
-		return dlChunk(ctx, f, dlURL, 0, total-1, total <= 0, done)
+		return dlChunk(ctx, g, f, dlURL, 0, total-1, total <= 0, done)
 	}
 	size := total / int64(conns)
 	var wg sync.WaitGroup
@@ -861,7 +949,7 @@ func dlFetch(ctx context.Context, f *os.File, dlURL string, total int64, conns i
 		wg.Add(1)
 		go func(i int, start, end int64) {
 			defer wg.Done()
-			errs[i] = dlChunk(ctx, f, dlURL, start, end, false, done)
+			errs[i] = dlChunk(ctx, g, f, dlURL, start, end, false, done)
 		}(i, start, end)
 	}
 	wg.Wait()
@@ -876,11 +964,15 @@ func dlFetch(ctx context.Context, f *os.File, dlURL string, total int64, conns i
 // dlChunk downloads [start,end] into f at the right offset, retrying from where
 // it stopped if the connection drops mid-chunk. With whole=true it streams the
 // entire body sequentially (server without range support, unknown size).
-func dlChunk(ctx context.Context, f *os.File, dlURL string, start, end int64, whole bool, done *int64) error {
+func dlChunk(ctx context.Context, g *dlGate, f *os.File, dlURL string, start, end int64, whole bool, done *int64) error {
 	const attempts = 4
 	pos := start
 	var lastErr error
 	for try := 0; try < attempts; try++ {
+		// Une pause n'est pas un échec : on attend la reprise sans consommer d'essai.
+		if !g.wait(ctx) {
+			return ctx.Err()
+		}
 		if err := ctx.Err(); err != nil {
 			return err // cancelled: never retry
 		}
@@ -900,18 +992,26 @@ func dlChunk(ctx context.Context, f *os.File, dlURL string, start, end int64, wh
 		} else if pos > start {
 			rng = fmt.Sprintf("bytes=%d-", pos) // best-effort resume
 		}
-		req, err := dlRequest(ctx, dlURL, rng)
+		actx, release := g.begin(ctx)
+		req, err := dlRequest(actx, dlURL, rng)
 		if err != nil {
+			release()
 			return err
 		}
 		resp, err := dlClient.Do(req)
 		if err != nil {
+			release()
+			if g.isPaused() && ctx.Err() == nil {
+				try--
+				continue
+			}
 			lastErr = err
 			continue
 		}
 		if resp.StatusCode != 200 && resp.StatusCode != 206 {
 			err := dlSourceError(resp, dlURL)
 			resp.Body.Close()
+			release()
 			return err
 		}
 		if resp.StatusCode == 200 && pos > start {
@@ -921,10 +1021,15 @@ func dlChunk(ctx context.Context, f *os.File, dlURL string, start, end int64, wh
 		}
 		n, cerr := dlCopy(f, resp.Body, pos, done)
 		resp.Body.Close()
+		release()
 		pos += n
 		if cerr == nil {
 			return nil
 		}
+		if g.isPaused() && ctx.Err() == nil {
+			try-- // coupé par la pause : la reprise repart de pos
+			continue
+		}
 		lastErr = cerr
 	}
 	return lastErr
@@ -981,6 +1086,35 @@ func handleModelDownloadCancel(w http.ResponseWriter, r *http.Request) {
 	sendJSON(w, 200, map[string]any{"ok": true})
 }
 
+// handleModelDownloadPause met en pause ({"pause":true}) ou reprend
+// ({"pause":false}) un téléchargement en cours. Le fichier partiel est gardé.
+func handleModelDownloadPause(w http.ResponseWriter, r *http.Request) {
+	var req struct {
+		Filename string `json:"filename"`
+		Pause    bool   `json:"pause"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		sendJSON(w, 400, map[string]any{"ok": false, "error": err.Error()})
+		return
+	}
+	name := filepath.Base(strings.TrimSpace(req.Filename))
+	dlMu.Lock()
+	st, ok := dlDownloads[name]
+	if !ok || st.Finished {
+		dlMu.Unlock()
+		sendJSON(w, 404, map[string]any{"ok": false, "error": "aucun téléchargement en cours pour " + name})
+		return
+	}
+	st.Paused = req.Pause
+	if req.Pause {
+		st.Speed = 0
+	}
+	g := st.gate
+	dlMu.Unlock()
+	g.setPaused(req.Pause)
+	sendJSON(w, 200, map[string]any{"ok": true, "paused": req.Pause})
+}
+
 // cleanStalePartFiles removes leftover *.gguf.part files in every model dir at
 // startup. A download killed by a crash or a service restart can't be resumed
 // (its state lived in memory), so the partial file would otherwise sit there

internal/loki/backend_models_dl_test.go

@@ -231,3 +231,96 @@ func TestDLProbeSurfacesExplainedError(t *testing.T) {
 		t.Errorf("message %q sans indication sur le jeton", err)
 	}
 }
+
+type slowWriter struct{ http.ResponseWriter }
+
+func (s slowWriter) Write(b []byte) (int, error) {
+	time.Sleep(2 * time.Millisecond)
+	return s.ResponseWriter.Write(b)
+}
+
+// Une pause coupe le flux, garde ce qui est écrit, et la reprise termine un
+// fichier identique à la source (repris d'AJEAN v0.18.1).
+func TestRunDownloadPauseResume(t *testing.T) {
+	data := make([]byte, 48<<20)
+	rand.New(rand.NewSource(2)).Read(data)
+	t.Setenv("LOKI_DL_CONNS", "4")
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		http.ServeContent(slowWriter{w}, r, "m.gguf", time.Time{}, bytes.NewReader(data))
+	}))
+	defer srv.Close()
+
+	dest := filepath.Join(t.TempDir(), "m.gguf")
+	st := &dlState{Filename: "m.gguf", gate: newDlGate()}
+	done := make(chan struct{})
+	go func() {
+		runDownloadSet(context.Background(), st, []string{srv.URL + "/m.gguf"}, []string{dest})
+		close(done)
+	}()
+
+	time.Sleep(300 * time.Millisecond)
+	st.gate.setPaused(true)
+	time.Sleep(1500 * time.Millisecond) // le compteur publié se fige
+	dlMu.Lock()
+	a := st.Done
+	dlMu.Unlock()
+	time.Sleep(1500 * time.Millisecond)
+	dlMu.Lock()
+	b, fin := st.Done, st.Finished
+	dlMu.Unlock()
+	if fin || a != b || a == 0 {
+		t.Fatalf("pause inopérante : %d puis %d octets, terminé=%v", a, b, fin)
+	}
+	st.gate.setPaused(false)
+	select {
+	case <-done:
+	case <-time.After(30 * time.Second):
+		t.Fatal("pas terminé après la reprise")
+	}
+	if st.Err != "" {
+		t.Fatalf("erreur après reprise : %s", st.Err)
+	}
+	got, err := os.ReadFile(dest)
+	if err != nil || !bytes.Equal(got, data) {
+		t.Fatalf("fichier différent de la source après reprise (err=%v)", err)
+	}
+}
+
+// La route : pause puis reprise d'un téléchargement connu, refus pour
+// l'inconnu et pour un téléchargement terminé.
+func TestHandleModelDownloadPause(t *testing.T) {
+	dlMu.Lock()
+	saved := dlDownloads
+	dlDownloads = map[string]*dlState{
+		"a.gguf": {Filename: "a.gguf", Speed: 9, gate: newDlGate()},
+		"b.gguf": {Filename: "b.gguf", Finished: true},
+	}
+	dlMu.Unlock()
+	t.Cleanup(func() { dlMu.Lock(); dlDownloads = saved; dlMu.Unlock() })
+	post := func(body string) (int, string) {
+		w := httptest.NewRecorder()
+		handleModelDownloadPause(w, httptest.NewRequest("POST", "/api/models/download/pause", strings.NewReader(body)))
+		return w.Code, strings.TrimSpace(w.Body.String())
+	}
+	if code, out := post(`{"filename":"../a.gguf","pause":true}`); code != 200 || out != `{"ok":true,"paused":true}` {
+		t.Fatalf("pause : %d %s", code, out)
+	}
+	dlMu.Lock()
+	st := dlDownloads["a.gguf"]
+	paused, speed := st.Paused, st.Speed
+	dlMu.Unlock()
+	if !paused || speed != 0 || !st.gate.isPaused() {
+		t.Errorf("état après pause : paused=%v speed=%d porte=%v", paused, speed, st.gate.isPaused())
+	}
+	if code, out := post(`{"filename":"a.gguf","pause":false}`); code != 200 || out != `{"ok":true,"paused":false}` || st.gate.isPaused() {
+		t.Fatalf("reprise : %d %s", code, out)
+	}
+	for _, body := range []string{`{"filename":"b.gguf","pause":true}`, `{"filename":"x.gguf","pause":true}`} {
+		if code, _ := post(body); code != 404 {
+			t.Errorf("%s : %d, attendu 404", body, code)
+		}
+	}
+	if code, _ := post(`[`); code != 400 {
+		t.Errorf("corps illisible : %d", code)
+	}
+}

internal/loki/backend_strata.go

@@ -5,11 +5,13 @@ package loki
 // répartit les experts entre VRAM, RAM et disque pour faire tenir le modèle sur
 // une carte de joueur.
 //
-// Repris d'AJEAN (backend_moe.go, « AJEAN MoE 1.0 ») : le moteur est le paquet
-// FIGÉ publié par AJEAN sur sa release GitHub moe-v1.0 — sources de Strata et
+// Repris d'AJEAN (backend_moe.go, « AJEAN MoE 1.1 ») : le moteur est le paquet
+// FIGÉ publié par AJEAN sur sa release GitHub moe-v1.1 — sources de Strata et
 // binaire Linux CUDA 12 compilé et validé par l'auteur d'AJEAN (avec ses
-// modifications : experts de la carte d'appoint gardés hors RAM). Les deux
-// fichiers sont vérifiés par SHA-256 avant usage.
+// modifications : experts de la carte d'appoint gardés hors RAM et, depuis la
+// 1.1, calculés par elle à la lecture des prompts). Les deux fichiers sont
+// vérifiés par SHA-256 avant usage. Un modèle installé avec la 1.0 passe à la
+// 1.1 à son premier lancement (strataMigrate).
 //
 // Le choix du moteur se fait par PRESET : ENGINE=strata. Sans la clé (ou
 // ENGINE=llamacpp), rien ne change, llama-server reste le moteur.
@@ -47,11 +49,12 @@ import (
 	"os/exec"
 )
 
-// Paquet figé (release moe-v1.0 d'AJEAN). Le moteur est compilé en CUDA 12.8,
+// Paquet figé (release moe-v1.1 d'AJEAN). Le moteur est compilé en CUDA 12.8,
 // mode portable AVX2, sm_75/80/86/89/120 : RTX 20 à 50. Un moteur installé d'un
-// autre paquet est remplacé au lancement (strataEnsureEngine).
+// autre paquet est remplacé au lancement (strataEnsureEngine), une installation
+// d'une version précédente est reprise (strataMigrate).
 const (
-	strataVersion     = "1.0"
+	strataVersion     = "1.1"
 	strataSrcAsset    = "ajean-moe-src-" + strataVersion + ".tar.gz"
 	strataEngineAsset = "ajean-moe-engine-" + strataVersion + "-linux-x64-cuda12.zip"
 	// strataEngineLocal : le nom sous lequel l'installeur attend le moteur (CUDA12_ASSET).
@@ -69,10 +72,11 @@ var (
 	strataDiskFree = diskFree
 )
 
-// strataAssetSHA : empreintes des fichiers de la release, vérifiées avant usage.
+// strataAssetSHA : empreintes des fichiers de la release, vérifiées avant usage
+// (celles qu'AJEAN publie dans son backend_moe.go pour moe-v1.1).
 var strataAssetSHA = map[string]string{
-	strataSrcAsset:    "5747f69426973d957e4f9894a8e3333c6ef0d6ac8565e26ddb8d36f52211cb3b",
-	strataEngineAsset: "b5851bc138ab32ca3ffefc16bf91c8f557e4d503503473a22f2b6c9e9b8fd34c",
+	strataSrcAsset:    "5a72a90f2182ff0ccab2bdbd7cff15598a21ad94501aa19de2b1b18e2dbc8115",
+	strataEngineAsset: "8c717206ee90120f967445169dc39bb11beffdad3d592c75ae08f75bec72f0d3",
 }
 
 // Valeurs de la clé ENGINE d'un preset.
@@ -132,8 +136,14 @@ const strataLowRAMHeadroomGB = 10
 
 // strataDropHeadroomGB : RAM à laisser à côté des experts verrouillés quand la
 // carte d'aide garde les siens hors RAM (mesuré par AJEAN : 46 Go de RAM,
-// 34,7 Gio d'experts verrouillés, ~2,3 Go encore libres).
-const strataDropHeadroomGB = 7
+// 34,7 Gio d'experts verrouillés, ~2,3 Go encore libres ; le moteur 1.1 prend
+// ~1 Go de plus que la 1.0).
+const strataDropHeadroomGB = 8
+
+// strataDropMaxCtx : contexte maximal en mode hors RAM. Le cache KV au-delà de
+// la part en VRAM est verrouillé en RAM : à 167 936 jetons, le serveur de test
+// d'AJEAN tombait à 1,3 Go libres dès la première requête (moteur 1.1).
+const strataDropMaxCtx = 131072
 
 // strataHelperExpertsGB : ce que la carte d'aide garde d'experts (sa VRAM moins
 // le contexte CUDA, l'encodeur d'images et la marge : 5,3 Gio sur une 3070 8 Go).
@@ -210,7 +220,9 @@ func strataPackHasExpertsBin(args []string) bool {
 // Pure : la décision se teste en table.
 func strataResolveExperts(cfg map[string]string, args []string, availGB, helperGB float64) string {
 	binReady := strataPackHasExpertsBin(args) && strataEngineInstalled() == strataEngineAsset
-	dropReady := binReady && strataHelperOn(cfg) && cfg["STRATA_DROP"] != "0"
+	// (experts de la carte d'aide hors RAM : propre au mode d'aide, jamais en
+	// partage des couches, où la seconde carte ne garde pas d'experts)
+	dropReady := binReady && strataHelperOn(cfg) && !strataLayerSplit(cfg) && cfg["STRATA_DROP"] != "0"
 	arena := strataArenaGB(cfg)
 	switch strings.ToLower(strings.TrimSpace(cfg["STRATA_EXPERTS"])) {
 	case strataExpertsDisk:
@@ -494,6 +506,7 @@ type strataDetails struct {
 	// pour les réglages : ce que la machine permet et l'état actuel
 	HasHelper bool `json:"has_helper"` // une carte d'aide est disponible
 	HelperOn  bool `json:"helper_on"`
+	Split     bool `json:"split_layers"` // les deux cartes se partagent les couches
 	Vision    bool `json:"vision"`
 }
 
@@ -555,6 +568,7 @@ func strataDetailsFor(presetID string, env strataEnv) *strataDetails {
 		if strataHelperOn(pc) {
 			d.HelperOn = true
 			d.HelperGPU = gpuName(h)
+			d.Split = strataLayerSplit(pc)
 		}
 	}
 	d.Vision = pc["STRATA_VISION"] != "0"
@@ -870,7 +884,8 @@ func strataFindConfig(quant string) (string, error) {
 //
 //   - --prefill 16384     : +15 % de lecture sur les longs prompts (40K) ;
 //   - --short-read 150    : les petits ajouts (< 150 jetons) sont lus comme en
-//     génération, sans le coût fixe du chemin par blocs : ~40 % plus rapides ;
+//     génération, sans le coût fixe du chemin par blocs : ~40 % plus rapides
+//     (48 avec une carte d'aide, voir strataBuildConfig) ;
 //   - --prompt-cache-root 256 : point de reprise posé à la fin du prompt système
 //     (défaut 2048) : une nouvelle conversation démarre en ~0,3 s au lieu de 4-5 s.
 var strataTuning = map[string]string{
@@ -957,6 +972,16 @@ func strataBuildConfig(base map[string]any, cfg map[string]string, apiKey, mode
 	}
 	helper := strings.TrimSpace(cfg["STRATA_HELPER_GPU"])
 	hasHelper := strataHelperOn(cfg)
+	if strataLayerSplit(cfg) {
+		// Partage des couches : le serveur de Strata le fait de lui-même quand sa
+		// clé « gpu » liste plusieurs cartes (--layer-split auto, réparti selon la
+		// VRAM libre), numérotées comme nvidia-smi. Pas de chemin « aide » : la
+		// réserve de VRAM de l'installeur et l'encodeur d'images restent en place.
+		main, _ := strconv.Atoi(strings.TrimSpace(cfg["STRATA_MAIN_GPU"]))
+		second, _ := strconv.Atoi(helper)
+		out["gpu"] = []any{main, second}
+		hasHelper = false
+	}
 	// Deuxième carte en aide : elle garde et CALCULE sa part des experts (le
 	// chemin « helper » du moteur), la carte principale reste CUDA0. Les cartes
 	// sont posées par CUDA_VISIBLE_DEVICES (serveStrata), PAS par la clé « gpu » :
@@ -1002,6 +1027,10 @@ func strataBuildConfig(base map[string]any, cfg map[string]string, apiKey, mode
 		// de copie : 8 fils et 32 tampons (le moteur en prendrait 32 et 128)
 		env["STRATA_STAGER_THREADS"] = "8"
 		env["STRATA_STAGER_RING"] = "32"
+		// sa VRAM libre réservée : 640 Mio (défaut 1024) = ~230 experts de plus
+		// hors RAM, l'encodeur d'images y tourne encore ; le moteur refuse moins
+		// de 512
+		env["STRATA_REMOTE_DROP_RESERVE_MIB"] = "640"
 	case "arena":
 		// experts.bin mappé tel quel (variante mesurée par AJEAN), sans part PCIe :
 		// le mappage n'en donne pas l'adresse GPU.
@@ -1017,8 +1046,22 @@ func strataBuildConfig(base map[string]any, cfg map[string]string, apiKey, mode
 		k, v, _ := strings.Cut(kv, "=")
 		env[k] = v
 	}
+	if hasHelper {
+		// Lecture d'un prompt (moteur 1.1) : les experts que la carte d'aide garde
+		// sont calculés par elle au lieu d'être recopiés vers la principale par son
+		// lien PCIe (le chemin passe par la source « helper ») ; le chemin par blocs
+		// coûte alors moins cher, les ajouts courts n'en sont exclus que sous 48
+		// jetons. Mesuré par AJEAN : 100 nouveaux jetons 1,19 -> 0,85 s, 200 :
+		// 1,96 -> 1,12 s.
+		env["STRATA_PREFILL_HELPER_SOURCE"] = "1"
+		args = strataSetArg(args, "--short-read", "48")
+	}
 	out["env"] = env
 	if ctx := strings.TrimSpace(cfg["CTX"]); ctx != "" {
+		// hors RAM, le cache KV verrouillé au-delà de strataDropMaxCtx ne tient plus
+		if n, err := strconv.Atoi(ctx); err == nil && n > strataDropMaxCtx && env["STRATA_REMOTE_DROP"] == "1" {
+			ctx = strconv.Itoa(strataDropMaxCtx)
+		}
 		args = strataSetArg(args, "--max-context", ctx)
 	}
 	// réglages imposés par le preset (sinon : ceux de l'installeur)
@@ -1162,6 +1205,16 @@ func strataHelperOn(cfg map[string]string) bool {
 	return h != "" && h != "-1" && cfg["STRATA_HELPER"] != "0"
 }
 
+// strataLayerSplit : les deux cartes se partagent les COUCHES du modèle (clé de
+// preset STRATA_SPLIT=layers) au lieu que la seconde n'aide que pour une part
+// des experts. Mesuré par un utilisateur d'AJEAN sur deux RTX 3060 identiques
+// (#121 amont) : la carte d'aide ne travaillait qu'à ~15 %, le partage des
+// couches donnait +50 % en génération. Sur deux cartes très différentes, le
+// mode d'aide reste le défaut mesuré : le partage est un choix, jamais imposé.
+func strataLayerSplit(cfg map[string]string) bool {
+	return strataHelperOn(cfg) && cfg["STRATA_SPLIT"] == "layers"
+}
+
 // strataCudaDevices : ordre des cartes vu par le moteur, la principale en CUDA0.
 func strataCudaDevices(cfg map[string]string) string {
 	main := strings.TrimSpace(cfg["STRATA_MAIN_GPU"])
@@ -1184,17 +1237,99 @@ func strataPreflight(cfg map[string]string) error {
 	if _, err := os.Stat(path); err != nil {
 		return fmt.Errorf("configuration de Strata introuvable : %s — réinstalle le modèle", path)
 	}
-	py := filepath.Join(filepath.Dir(path), ".venv", "bin", "python")
+	py := strataVenvPython(filepath.Dir(path))
 	if _, err := os.Stat(py); err != nil {
 		return fmt.Errorf("environnement Python de Strata absent (%s) : réinstalle le modèle", py)
 	}
 	return nil
 }
 
+// strataVenvPython : le Python de l'environnement de Strata, dans ses sources.
+func strataVenvPython(srcDir string) string { return filepath.Join(srcDir, ".venv", "bin", "python") }
+
+// strataMigrate : un preset installé par une version précédente du paquet
+// (STRATA_CONFIG dans strataHome()/ajean-moe-<ancienne>) passe à la version
+// courante au lancement, sans réinstaller : les modèles et packs (data/)
+// servent tels quels. Les sources de la version courante sont posées (~340 Mo
+// avec le moteur), l'environnement Python de l'ancienne est repris par un lien
+// quand les dépendances n'ont pas changé, le moteur compilé est installé par
+// strataEnsureEngine, la config de l'installeur est recopiée avec ses chemins
+// réécrits, et les presets qui la citaient comme la config vivante pointent sur
+// la nouvelle. En cas d'échec rien n'est réécrit : l'ancienne version continue
+// de tourner. Repris d'AJEAN (moeMigrate, AJEAN MoE 1.1).
+func strataMigrate(cfg map[string]string) error {
+	old := strings.TrimSpace(cfg["STRATA_CONFIG"])
+	oldDir := filepath.Dir(old)
+	newDir := strataSrcDir()
+	if old == "" || oldDir == newDir || filepath.Dir(oldDir) != strataHome() || !strings.HasPrefix(filepath.Base(oldDir), "ajean-moe-") {
+		return nil
+	}
+	newPath := filepath.Join(newDir, filepath.Base(old))
+	if !isFile(newPath) {
+		raw, err := os.ReadFile(old)
+		if err != nil {
+			return err
+		}
+		if !isFile(filepath.Join(newDir, "setup.py")) {
+			src, err := strataFetch(strataSrcAsset)
+			if err != nil {
+				return err
+			}
+			if err := extractArchive(src, strataHome()); err != nil {
+				return fmt.Errorf("décompression : %w", err)
+			}
+		}
+		venv := filepath.Join(newDir, ".venv")
+		if _, err := os.Lstat(venv); err != nil {
+			a, _ := os.ReadFile(filepath.Join(oldDir, "requirements.txt"))
+			b, _ := os.ReadFile(filepath.Join(newDir, "requirements.txt"))
+			if len(a) == 0 || string(a) != string(b) || !isFile(strataVenvPython(oldDir)) {
+				return fmt.Errorf("dépendances Python changées : réinstalle le modèle depuis Paramètres → Moteur → Strata")
+			}
+			if err := os.Symlink(filepath.Join(oldDir, ".venv"), venv); err != nil {
+				return err
+			}
+		}
+		if err := os.MkdirAll(filepath.Join(newDir, "engine-cuda12"), 0o755); err != nil {
+			return err
+		}
+		if err := strataEnsureEngine(); err != nil {
+			return err
+		}
+		body := strings.ReplaceAll(string(raw), oldDir+string(os.PathSeparator), newDir+string(os.PathSeparator))
+		if err := os.WriteFile(newPath+".new", []byte(body), 0o644); err != nil {
+			return err
+		}
+		if err := os.Rename(newPath+".new", newPath); err != nil {
+			return err
+		}
+	}
+	// les presets qui citent l'ancienne config, puis la config vivante (les deux
+	// changent ensemble : l'empreinte du preset actif reste celle de la config)
+	if list, _ := filepath.Glob(filepath.Join(presetsDir(), "*.env")); len(list) > 0 {
+		for _, p := range list {
+			b, err := os.ReadFile(p)
+			if err != nil || !strings.Contains(string(b), "STRATA_CONFIG="+old+"\n") {
+				continue
+			}
+			_ = os.WriteFile(p, []byte(strings.ReplaceAll(string(b), "STRATA_CONFIG="+old+"\n", "STRATA_CONFIG="+newPath+"\n")), 0o644)
+		}
+	}
+	if err := SetConfigKey("STRATA_CONFIG", newPath); err != nil {
+		return err
+	}
+	cfg["STRATA_CONFIG"] = newPath
+	fmt.Fprintf(os.Stderr, "[loki serve] paquet AJEAN MoE %s : installation reprise depuis %s\n", strataVersion, filepath.Base(oldDir))
+	return nil
+}
+
 // serveStrata : la branche Strata de `loki serve`. Écrit la config finale à
 // côté de celle de l'installeur puis remplace le process par le serveur de
 // Strata (comme pour llama-server : le superviseur suit directement le moteur).
 func serveStrata(cfg map[string]string) error {
+	if err := strataMigrate(cfg); err != nil {
+		fmt.Fprintf(os.Stderr, "[loki serve] passage au paquet AJEAN MoE %s impossible (%v) : la version installée reste utilisée\n", strataVersion, err)
+	}
 	if err := strataPreflight(cfg); err != nil {
 		return err
 	}
@@ -1223,7 +1358,7 @@ func serveStrata(cfg map[string]string) error {
 		return err
 	}
 	srcDir := filepath.Dir(path)
-	py := filepath.Join(srcDir, ".venv", "bin", "python")
+	py := strataVenvPython(srcDir)
 	tag := strataConfigTag(path)
 	final["log"] = filepath.Join(strataHome(), "strata-"+tag+".log")
 	out := filepath.Join(strataHome(), "loki-strata-"+tag+".json")
@@ -1326,6 +1461,9 @@ type strataSettingsReq struct {
 	Vision  bool   `json:"vision"`
 	Helper  bool   `json:"helper"`
 	Experts string `json:"experts"` // auto, ram ou disk ; vide = inchangé
+	// Split : rôle de la seconde carte, « helper » (aide aux experts) ou
+	// « layers » (partage des couches). Vide = inchangé (anciens clients).
+	Split string `json:"split"`
 }
 
 // strataApplySettings réécrit les clés du preset (pure, testable).
@@ -1340,6 +1478,8 @@ func strataApplySettings(content string, r strataSettingsReq) (string, error) {
 		return "", fmt.Errorf("MTP hors limites : %d", r.Spec)
 	case r.Experts != "" && r.Experts != strataExpertsAuto && r.Experts != strataExpertsRAM && r.Experts != strataExpertsDisk:
 		return "", fmt.Errorf("placement des experts inconnu : %s", r.Experts)
+	case r.Split != "" && r.Split != "helper" && r.Split != "layers":
+		return "", fmt.Errorf("répartition inconnue : %s", r.Split)
 	}
 	set := map[string]string{
 		"CTX": strconv.Itoa(r.Ctx), "STRATA_KV": r.KV, "STRATA_SPEC": strconv.Itoa(r.Spec),
@@ -1350,6 +1490,14 @@ func strataApplySettings(content string, r strataSettingsReq) (string, error) {
 		set["STRATA_EXPERTS"] = r.Experts
 		keys = append(keys, "STRATA_EXPERTS")
 	}
+	if r.Split != "" {
+		// « helper » est le défaut : la clé disparaît plutôt que d'être écrite
+		set["STRATA_SPLIT"] = ""
+		if r.Split == "layers" {
+			set["STRATA_SPLIT"] = "layers"
+		}
+		keys = append(keys, "STRATA_SPLIT")
+	}
 	var lines []string
 	for _, l := range strings.Split(strings.TrimRight(content, "\n"), "\n") {
 		k, _, _ := strings.Cut(strings.TrimSpace(l), "=")
@@ -1359,6 +1507,9 @@ func strataApplySettings(content string, r strataSettingsReq) (string, error) {
 		lines = append(lines, l)
 	}
 	for _, k := range keys {
+		if set[k] == "" && k == "STRATA_SPLIT" {
+			continue
+		}
 		lines = append(lines, k+"="+set[k])
 	}
 	return strings.Join(lines, "\n") + "\n", nil

internal/loki/backend_strata_migrate_test.go

@@ -0,0 +1,133 @@
+package loki
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Moteur 1.1 : avec une carte d'aide, la lecture d'un prompt passe par elle
+// (source « helper ») et le chemin direct ne garde que les ajouts sous 48 jetons.
+func TestStrataBuildConfigHelperPrompt(t *testing.T) {
+	base := map[string]any{"args": []any{"--pack", "/p"}}
+	out, _ := strataBuildConfig(base, map[string]string{"STRATA_HELPER_GPU": "0"}, "", "ram")
+	if argAfter(strataArgs(t, out), "--short-read") != "48" || out["env"].(map[string]any)["STRATA_PREFILL_HELPER_SOURCE"] != "1" {
+		t.Errorf("carte d'aide : lecture courte et source d'aide attendues : %v %v", strataArgs(t, out), out["env"])
+	}
+	// carte d'aide coupée ou absente : réglages d'avant
+	for _, cfg := range []map[string]string{{}, {"STRATA_HELPER_GPU": "0", "STRATA_HELPER": "0"}} {
+		out, _ = strataBuildConfig(base, cfg, "", "ram")
+		if argAfter(strataArgs(t, out), "--short-read") != "150" || out["env"].(map[string]any)["STRATA_PREFILL_HELPER_SOURCE"] != nil {
+			t.Errorf("une carte (%v) : %v %v", cfg, strataArgs(t, out), out["env"])
+		}
+	}
+}
+
+// Mode hors RAM : réserve de VRAM de la carte d'aide abaissée, contexte plafonné.
+func TestStrataBuildConfigDropReserveAndCtx(t *testing.T) {
+	base := map[string]any{"args": []any{"--pack", "/p"}, "env": map[string]any{}}
+	cfg := map[string]string{"STRATA_HELPER_GPU": "0", "CTX": "167936"}
+	out, _ := strataBuildConfig(base, cfg, "", "drop")
+	if out["env"].(map[string]any)["STRATA_REMOTE_DROP_RESERVE_MIB"] != "640" {
+		t.Errorf("réserve de la carte d'aide : %v", out["env"])
+	}
+	if got := argAfter(strataArgs(t, out), "--max-context"); got != "131072" {
+		t.Errorf("contexte hors RAM non plafonné : %s", got)
+	}
+	// hors du mode hors RAM : le contexte demandé
+	for _, mode := range []string{"ram", "arena", "disk"} {
+		out, _ = strataBuildConfig(base, cfg, "", mode)
+		if got := argAfter(strataArgs(t, out), "--max-context"); got != "167936" {
+			t.Errorf("%s : contexte plafonné sans mode hors RAM : %s", mode, got)
+		}
+		if out["env"].(map[string]any)["STRATA_REMOTE_DROP_RESERVE_MIB"] != nil {
+			t.Errorf("%s : réserve du mode hors RAM posée : %v", mode, out["env"])
+		}
+	}
+}
+
+// Un modèle installé avec le paquet 1.0 passe au paquet courant à son premier
+// lancement, sans réinstallation.
+func TestStrataMigrate(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("lien symbolique : Strata ne tourne que sous Linux")
+	}
+	home := t.TempDir()
+	t.Setenv("LOKI_HOME", home)
+	oldDir := filepath.Join(strataHome(), "ajean-moe-1.0")
+	newDir := strataSrcDir()
+	for _, d := range []string{filepath.Join(oldDir, ".venv", "bin"), filepath.Join(newDir, "engine-cuda12"), presetsDir()} {
+		_ = os.MkdirAll(d, 0o755)
+	}
+	_ = os.WriteFile(strataVenvPython(oldDir), []byte("#!/bin/sh\n"), 0o755)
+	for _, d := range []string{oldDir, newDir} {
+		_ = os.WriteFile(filepath.Join(d, "requirements.txt"), []byte("numpy\n"), 0o644)
+	}
+	_ = os.WriteFile(filepath.Join(newDir, "setup.py"), []byte(""), 0o644)
+	_ = os.WriteFile(strataEngineMarker(), []byte(strataEngineAsset+"\n"), 0o644)
+	old := filepath.Join(oldDir, "strata-swift-iq3_xxs.json")
+	_ = os.WriteFile(old, []byte(`{"exe": "`+filepath.Join(oldDir, "engine-cuda12", "strata")+`", "args": []}`), 0o644)
+	preset := filepath.Join(presetsDir(), "P.env")
+	_ = os.WriteFile(preset, []byte("ENGINE=strata\nSTRATA_CONFIG="+old+"\nCTX=1\n"), 0o644)
+	other := filepath.Join(presetsDir(), "L.env")
+	_ = os.WriteFile(other, []byte("MODEL=/m.gguf\n"), 0o644)
+	if err := SetConfigKey("STRATA_CONFIG", old); err != nil {
+		t.Fatal(err)
+	}
+	cfg := map[string]string{"ENGINE": "strata", "STRATA_CONFIG": old}
+	if err := strataMigrate(cfg); err != nil {
+		t.Fatal(err)
+	}
+	want := filepath.Join(newDir, "strata-swift-iq3_xxs.json")
+	if cfg["STRATA_CONFIG"] != want || ReadConfig()["STRATA_CONFIG"] != want {
+		t.Fatalf("config vivante : %q", cfg["STRATA_CONFIG"])
+	}
+	b, _ := os.ReadFile(want)
+	if strings.Contains(string(b), oldDir) || !strings.Contains(string(b), filepath.Join(newDir, "engine-cuda12")) {
+		t.Errorf("chemins non réécrits : %s", b)
+	}
+	if p, _ := os.ReadFile(preset); !strings.Contains(string(p), "STRATA_CONFIG="+want+"\n") {
+		t.Errorf("preset non réécrit : %s", p)
+	}
+	if p, _ := os.ReadFile(other); string(p) != "MODEL=/m.gguf\n" {
+		t.Errorf("preset d'un autre moteur touché : %s", p)
+	}
+	if !isFile(strataVenvPython(newDir)) {
+		t.Error("environnement Python non repris")
+	}
+	// déjà à jour : rien à faire
+	if err := strataMigrate(cfg); err != nil || cfg["STRATA_CONFIG"] != want {
+		t.Errorf("seconde passe : %v %q", err, cfg["STRATA_CONFIG"])
+	}
+}
+
+// Dépendances Python changées : rien n'est réécrit, l'ancienne version tourne.
+func TestStrataMigrateRequirementsChanged(t *testing.T) {
+	home := t.TempDir()
+	t.Setenv("LOKI_HOME", home)
+	oldDir := filepath.Join(strataHome(), "ajean-moe-1.0")
+	newDir := strataSrcDir()
+	for _, d := range []string{filepath.Join(oldDir, ".venv", "bin"), newDir} {
+		_ = os.MkdirAll(d, 0o755)
+	}
+	_ = os.WriteFile(strataVenvPython(oldDir), []byte("#!/bin/sh\n"), 0o755)
+	_ = os.WriteFile(filepath.Join(oldDir, "requirements.txt"), []byte("numpy\n"), 0o644)
+	_ = os.WriteFile(filepath.Join(newDir, "requirements.txt"), []byte("numpy\ntorch\n"), 0o644)
+	_ = os.WriteFile(filepath.Join(newDir, "setup.py"), []byte(""), 0o644)
+	old := filepath.Join(oldDir, "strata-iq3_xxs.json")
+	_ = os.WriteFile(old, []byte(`{"args": []}`), 0o644)
+	cfg := map[string]string{"STRATA_CONFIG": old}
+	if err := strataMigrate(cfg); err == nil || !strings.Contains(err.Error(), "dépendances") {
+		t.Fatalf("erreur de dépendances attendue : %v", err)
+	}
+	if cfg["STRATA_CONFIG"] != old || isFile(filepath.Join(newDir, "strata-iq3_xxs.json")) {
+		t.Errorf("config réécrite malgré l'échec : %q", cfg["STRATA_CONFIG"])
+	}
+	// un preset hors de strata/ (copié à la main) n'est pas touché
+	cfg = map[string]string{"STRATA_CONFIG": filepath.Join(home, "ailleurs", "ajean-moe-1.0", "strata-x.json")}
+	if err := strataMigrate(cfg); err != nil {
+		t.Errorf("config hors de strata/ : %v", err)
+	}
+}

internal/loki/backend_strata_split_test.go

@@ -0,0 +1,124 @@
+package loki
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// Partage des couches (#121 amont) : la clé « gpu » liste les deux cartes (le
+// serveur de Strata en déduit --layer-split), et rien du mode d'aide ne subsiste.
+func TestStrataBuildConfigLayerSplit(t *testing.T) {
+	base := map[string]any{
+		"args":   []any{"--pack", "/p", "--vram-reserve-mib", "900"},
+		"vision": map[string]any{"exe": "/v"},
+	}
+	cfg := map[string]string{"STRATA_MAIN_GPU": "1", "STRATA_HELPER_GPU": "0", "STRATA_SPLIT": "layers"}
+	out, err := strataBuildConfig(base, cfg, "", "drop")
+	if err != nil {
+		t.Fatal(err)
+	}
+	g, ok := out["gpu"].([]any)
+	if !ok || len(g) != 2 || g[0] != 1 || g[1] != 0 {
+		t.Fatalf("gpu = %v, attendu [1 0] (principale d'abord, numéros nvidia-smi)", out["gpu"])
+	}
+	a := strataArgs(t, out)
+	if strataHasArg(a, "--remote-expert-opt") || strataHasArg(a, "--expert-cache-device1") {
+		t.Errorf("options du mode d'aide en partage des couches : %v", a)
+	}
+	if argAfter(a, "--vram-reserve-mib") != "900" {
+		t.Errorf("la réserve de VRAM de l'installeur doit rester : %v", a)
+	}
+	if argAfter(a, "--short-read") != "150" {
+		t.Errorf("lecture des prompts par la carte d'aide en partage des couches : %v", a)
+	}
+	env := out["env"].(map[string]any)
+	if env["STRATA_REMOTE_DROP"] != nil || env["STRATA_PREFILL_HELPER_SOURCE"] != nil {
+		t.Errorf("experts hors RAM ou source d'aide (mode d'aide) en partage des couches : %v", env)
+	}
+	if _, has := out["vision"].(map[string]any)["cuda_device"]; has {
+		t.Errorf("encodeur d'images déplacé sur la seconde carte en partage des couches")
+	}
+
+	// Sans la clé, rien ne change : le mode d'aide reste le défaut.
+	delete(cfg, "STRATA_SPLIT")
+	out, _ = strataBuildConfig(base, cfg, "", "drop")
+	if _, has := out["gpu"]; has {
+		t.Errorf("clé gpu posée en mode d'aide : %v", out["gpu"])
+	}
+	if !strataHasArg(strataArgs(t, out), "--remote-expert-opt") {
+		t.Errorf("mode d'aide perdu sans STRATA_SPLIT")
+	}
+	// Seconde carte coupée : pas de partage même si la clé traîne.
+	cfg["STRATA_SPLIT"], cfg["STRATA_HELPER"] = "layers", "0"
+	if strataLayerSplit(cfg) {
+		t.Errorf("partage des couches avec la seconde carte coupée")
+	}
+}
+
+// En partage des couches, la seconde carte ne garde pas d'experts : le mode
+// hors RAM (qui compte sur elle pour en loger une part) n'est jamais choisi.
+func TestStrataResolveExpertsLayerSplit(t *testing.T) {
+	home := t.TempDir()
+	t.Setenv("LOKI_HOME", home)
+	pack := filepath.Join(home, "pack")
+	_ = os.MkdirAll(pack, 0o755)
+	_ = os.WriteFile(filepath.Join(pack, "experts.bin"), []byte("x"), 0o644)
+	_ = os.MkdirAll(filepath.Join(strataSrcDir(), "engine-cuda12"), 0o755)
+	_ = os.WriteFile(strataEngineMarker(), []byte(strataEngineAsset+"\n"), 0o644)
+	args := []string{"--pack", pack}
+	cfg := map[string]string{"STRATA_CONFIG": "/x/strata-swift-iq3_xxs.json", "STRATA_HELPER_GPU": "1", "STRATA_DROP": "1"}
+	if got := strataResolveExperts(cfg, args, 44, 12); got != "drop" {
+		t.Fatalf("mode d'aide : %s, attendu drop", got)
+	}
+	cfg["STRATA_SPLIT"] = "layers"
+	if got := strataResolveExperts(cfg, args, 44, 12); got != "arena" {
+		t.Errorf("partage des couches : %s, attendu arena", got)
+	}
+	cfg["STRATA_EXPERTS"] = "ram"
+	if got := strataResolveExperts(cfg, args, 44, 12); got != "ram" {
+		t.Errorf("partage des couches, experts en RAM : %s, attendu ram", got)
+	}
+}
+
+func TestStrataApplySettingsSplit(t *testing.T) {
+	in := "ENGINE=strata\nSTRATA_HELPER_GPU=0\n"
+	req := strataSettingsReq{Ctx: 131072, KV: "fp16", Spec: 3, Vision: true, Helper: true, Split: "layers"}
+	out, err := strataApplySettings(in, req)
+	if err != nil || !strings.Contains(out, "STRATA_SPLIT=layers\n") {
+		t.Fatalf("STRATA_SPLIT=layers attendu : %q (%v)", out, err)
+	}
+	req.Split = "helper"
+	if out, _ = strataApplySettings(out, req); strings.Contains(out, "STRATA_SPLIT") {
+		t.Errorf("retour au mode d'aide : la clé doit disparaître : %q", out)
+	}
+	// un ancien client n'envoie pas « split » : la clé est conservée
+	req.Split = ""
+	out, _ = strataApplySettings("STRATA_SPLIT=layers\n", req)
+	if !strings.Contains(out, "STRATA_SPLIT=layers") {
+		t.Errorf("clé effacée par un client qui ne la connaît pas : %q", out)
+	}
+	req.Split = "nimporte"
+	if _, err := strataApplySettings(in, req); err == nil {
+		t.Errorf("répartition inconnue acceptée")
+	}
+}
+
+func TestStrataDetailsForLayerSplit(t *testing.T) {
+	home := t.TempDir()
+	t.Setenv("LOKI_HOME", home)
+	base := filepath.Join(home, "base.json")
+	_ = os.WriteFile(base, []byte(`{"args":["--pack","/p"],"vision":{"exe":"v"}}`), 0o644)
+	_ = os.MkdirAll(presetsDir(), 0o755)
+	preset := "ENGINE=strata\nSTRATA_CONFIG=" + base + "\nSTRATA_MAIN_GPU=1\nSTRATA_HELPER_GPU=0\nSTRATA_SPLIT=layers\n"
+	_ = os.WriteFile(filepath.Join(presetsDir(), "X.env"), []byte(preset), 0o644)
+	env := strataEnv{GPUs: []strataGPU{{Index: 0, Name: "NVIDIA GeForce RTX 3060", VRAMGB: 12}, {Index: 1, Name: "NVIDIA GeForce RTX 3060", VRAMGB: 12}}}
+	d := strataDetailsFor("X", env)
+	if d == nil {
+		t.Fatal("pas de détails")
+	}
+	if !d.Split || !d.HelperOn || d.HelperGPU == "" || d.VisionGPU != d.MainGPU || d.ShortRead != "150" {
+		t.Errorf("%+v", *d)
+	}
+}

internal/loki/backend_strata_test.go

@@ -184,7 +184,7 @@ func TestStrataDetailsFor(t *testing.T) {
 	}
 	if d.KV != "fp16" || d.KVResident != "32768" || d.Spec != "3" || d.Ctx != "131072" || !d.Mmap ||
 		d.MainGPU != "RTX 5060 Ti (16 Go)" || d.HelperGPU != "RTX 3070 (8 Go)" || d.VisionGPU != "RTX 3070 (8 Go)" ||
-		d.ShortRead != "150" || d.CacheRoot != "256" || d.Prefill != "16384" {
+		d.ShortRead != "48" || d.CacheRoot != "256" || d.Prefill != "16384" {
 		t.Errorf("%+v", *d)
 	}
 }

internal/loki/facade_chat_test.go

@@ -301,7 +301,7 @@ func TestFacadeRelaieLesModeles(t *testing.T) {
 	local := func(w http.ResponseWriter, r *http.Request) { io.WriteString(w, "go") }
 
 	routes := []string{"/api/models/download", "/api/models/download/probe",
-		"/api/models/download/status", "/api/models/download/cancel", "/api/models",
+		"/api/models/download/status", "/api/models/download/cancel", "/api/models/download/pause", "/api/models",
 		"/api/models/delete", "/api/models/dirs", "/api/hf/search", "/api/hf/files", "/api/hf/token"}
 	for _, p := range routes {
 		w := httptest.NewRecorder()

internal/loki/facade_mcp.go

@@ -37,11 +37,15 @@ var facadeMCPRoutes = map[string]bool{
 	"/api/mcp/toggle":  true,
 	"/api/mcp/tool":    true,
 	"/api/mcp/test":    true,
+	// Les délais globaux : la façade tient le pool, c'est elle qui doit
+	// fermer ses sessions quand ils changent.
+	"/api/mcp/timeouts":      true,
+	"/api/mcp/timeouts/save": true,
 }
 
 // facadeMCPJSON appelle l'API interne MCP de la façade et décode sa réponse.
-// Délai large : un appel d'outil MCP peut durer (mcpCallTimeout), une
-// première connexion npx/uvx aussi (mcpConnectTimeoutCold).
+// Délai large, simple garde-fou : la façade borne elle-même la connexion
+// (1 h au plus) et l'appel, nouvel essai compris (mcpCallTimeoutMax chacun).
 func facadeMCPJSON(path string, body any, out any) error {
 	b, err := json.Marshal(body)
 	if err != nil {
@@ -53,7 +57,7 @@ func facadeMCPJSON(path string, body any, out any) error {
 	}
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set(internalTokenHeader, internalToken())
-	resp, err := (&http.Client{Timeout: mcpConnectTimeoutCold + mcpCallTimeout}).Do(req)
+	resp, err := (&http.Client{Timeout: mcpTimeoutMaxSec*time.Second + 2*mcpCallTimeoutMax}).Do(req)
 	if err != nil {
 		return err
 	}

internal/loki/facade_models.go

@@ -49,4 +49,5 @@ var facadeModelRoutes = map[string]bool{
 	"/api/models/download/probe":  true,
 	"/api/models/download/status": true,
 	"/api/models/download/cancel": true,
+	"/api/models/download/pause":  true,
 }

internal/loki/mcp_call_ctx_test.go

@@ -74,22 +74,27 @@ func TestMCPCallHonorsTurnCancel(t *testing.T) {
 }
 
 func TestMCPCallTimeoutFor(t *testing.T) {
+	def := MCPTimeouts{}.normalized()
 	cases := []struct {
 		cfg  MCPServerConfig
+		t    MCPTimeouts
 		args map[string]any
 		want time.Duration
 	}{
-		{MCPServerConfig{}, nil, mcpCallTimeout},
-		{MCPServerConfig{CallTimeoutSec: 600}, nil, 10 * time.Minute},
-		{MCPServerConfig{}, map[string]any{"timeout": 300.0}, 330 * time.Second},          // secondes
-		{MCPServerConfig{}, map[string]any{"timeout": 200000.0}, 230 * time.Second},       // millisecondes
-		{MCPServerConfig{}, map[string]any{"timeout": 5000.0}, mcpCallTimeout},            // 5 s : le défaut reste
-		{MCPServerConfig{}, map[string]any{"timeout": "400"}, 430 * time.Second},          // chaîne
-		{MCPServerConfig{}, map[string]any{"timeout": 86400.0 * 1000}, mcpCallTimeoutMax}, // plafond
-		{MCPServerConfig{CallTimeoutSec: 30}, nil, 30 * time.Second},                      // plus court que le défaut
+		{MCPServerConfig{}, def, nil, 120 * time.Second},
+		{MCPServerConfig{CallTimeoutSec: 600}, def, nil, 10 * time.Minute},
+		{MCPServerConfig{}, def, map[string]any{"timeout": 300.0}, 330 * time.Second},          // secondes
+		{MCPServerConfig{}, def, map[string]any{"timeout": 200000.0}, 230 * time.Second},       // millisecondes
+		{MCPServerConfig{}, def, map[string]any{"timeout": 5000.0}, 120 * time.Second},         // 5 s : le défaut reste
+		{MCPServerConfig{}, def, map[string]any{"timeout": "400"}, 430 * time.Second},          // chaîne
+		{MCPServerConfig{}, def, map[string]any{"timeout": 86400.0 * 1000}, mcpCallTimeoutMax}, // plafond
+		{MCPServerConfig{CallTimeoutSec: 30}, def, nil, 30 * time.Second},                      // plus court que le défaut
+		{MCPServerConfig{}, MCPTimeouts{Connect: 20, Call: 45}, nil, 45 * time.Second},         // réglage global
+		{MCPServerConfig{CallTimeoutSec: 90}, MCPTimeouts{Connect: 20, Call: 45}, nil, 90 * time.Second},
+		{MCPServerConfig{}, MCPTimeouts{Connect: 20, Call: 3600}, nil, time.Hour}, // pas rogné par le plafond
 	}
 	for i, c := range cases {
-		if got := mcpCallTimeoutFor(c.cfg, c.args); got != c.want {
+		if got := mcpCallTimeoutFor(c.cfg, c.t, c.args); got != c.want {
 			t.Errorf("cas %d : %s, attendu %s", i, got, c.want)
 		}
 	}

internal/loki/mcp_client.go

@@ -36,19 +36,17 @@ import (
 // pour router les appels sans avoir à re-parser des noms potentiellement
 // ambigus.
 
+// Les délais de connexion et d'appel sont réglables (mcp_timeouts.go) :
+// 20 s et 120 s par défaut.
 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.
+	// C'est un minimum : un délai de connexion réglé plus long l'emporte.
 	mcpConnectTimeoutCold = 3 * time.Minute
-	// mcpCallTimeout borne un appel d'outil MCP.
-	mcpCallTimeout = 120 * time.Second
 )
 
 // mcpOutputCap borne la sortie d'un outil MCP renvoyée au modèle. L'amont
@@ -194,11 +192,12 @@ func (m *mcpManager) ensure(name string, cfg MCPServerConfig) *mcpSession {
 	m.mu.Unlock()
 
 	// Connexion hors-lock (peut être lente).
-	ctx, cancel := context.WithTimeout(context.Background(), mcpTimeoutFor(cfg))
+	timeouts := LoadMCPTimeouts()
+	ctx, cancel := context.WithTimeout(context.Background(), mcpTimeoutFor(cfg, timeouts))
 	defer cancel()
 	sess, err := mcpConnect(ctx, name, cfg)
 	if err != nil {
-		s.err = mcpFriendlyErr(err, cfg)
+		s.err = mcpFriendlyErr(err, cfg, timeouts)
 	} else {
 		s.sess = sess
 		lt, lerr := sess.ListTools(ctx, nil)
@@ -391,7 +390,7 @@ func mcpCall(parent context.Context, name string, args map[string]any) string {
 	}
 	servers, _ := LoadMCPConfig()
 	cfg, exists := servers[ref.server]
-	timeout := mcpCallTimeoutFor(cfg, args)
+	timeout := mcpCallTimeoutFor(cfg, LoadMCPTimeouts(), args)
 
 	result, err := mcpCallOnce(parent, ref, args, timeout)
 	if err != nil {
@@ -424,14 +423,16 @@ func mcpCall(parent context.Context, name string, args map[string]any) string {
 
 // mcpCallTimeoutMax plafonne le délai d'un appel, quoi que demandent l'outil
 // ou la config : au-delà, c'est un job d'arrière-plan, pas un appel d'outil.
-const mcpCallTimeoutMax = 30 * time.Minute
+// Il suit la borne des réglages (1 h) : un délai réglé à 3600 s n'est pas
+// rogné en silence.
+const mcpCallTimeoutMax = mcpTimeoutMaxSec * time.Second
 
-// mcpCallTimeoutFor : délai d'un appel. Défaut mcpCallTimeout, remplacé par
-// CallTimeoutSec du serveur ; un argument « timeout » de l'outil lui-même
+// mcpCallTimeoutFor : délai d'un appel. Le réglage global (t.Call), remplacé
+// par CallTimeoutSec du serveur ; un argument « timeout » de l'outil lui-même
 // (beaucoup en ont un : navigateur, build, requête) l'allonge de 30 s pour que
 // l'outil ait le temps de rendre SA propre erreur de délai.
-func mcpCallTimeoutFor(cfg MCPServerConfig, args map[string]any) time.Duration {
-	d := mcpCallTimeout
+func mcpCallTimeoutFor(cfg MCPServerConfig, t MCPTimeouts, args map[string]any) time.Duration {
+	d := t.call()
 	if cfg.CallTimeoutSec > 0 {
 		d = time.Duration(cfg.CallTimeoutSec) * time.Second
 	}
@@ -598,6 +599,8 @@ type MCPServerStatus struct {
 	Env     map[string]string `json:"env,omitempty"`
 	URL     string            `json:"url,omitempty"`
 	Headers map[string]string `json:"headers,omitempty"`
+	// CallTimeoutSec : délai d'un appel propre au serveur (0 = réglage global).
+	CallTimeoutSec int `json:"callTimeoutSec,omitempty"`
 }
 
 // MCPStatus renvoie l'état de tous les serveurs configurés, en tentant de
@@ -621,7 +624,9 @@ func MCPStatus() ([]MCPServerStatus, error) {
 			URL:       cfg.URL,
 			Headers:   cfg.Headers,
 			Tools:     []string{},
-			Disabled:  cfg.DisabledTools,
+
+			CallTimeoutSec: cfg.CallTimeoutSec,
+			Disabled:       cfg.DisabledTools,
 		}
 		if st.Disabled == nil {
 			st.Disabled = []string{}
@@ -643,29 +648,36 @@ 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 {
+// mcpTimeoutFor choisit le délai de connexion d'un serveur : le réglage
+// global, mais au moins mcpConnectTimeoutCold pour un lanceur qui télécharge
+// son paquet à la volée (npx, uvx).
+func mcpTimeoutFor(cfg MCPServerConfig, t MCPTimeouts) time.Duration {
+	if mcpColdLauncher(cfg) {
+		return max(t.connect(), mcpConnectTimeoutCold)
+	}
+	return t.connect()
+}
+
+// mcpColdLauncher : npx ou uvx, qui téléchargent le paquet au premier
+// lancement.
+func mcpColdLauncher(cfg MCPServerConfig) bool {
 	base := strings.ToLower(filepath.Base(cfg.Command))
 	base = strings.TrimSuffix(strings.TrimSuffix(base, ".exe"), ".cmd")
-	if base == "npx" || base == "uvx" {
-		return mcpConnectTimeoutCold
-	}
-	return mcpConnectTimeout
+	return base == "npx" || base == "uvx"
 }
 
 // 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 {
+func mcpFriendlyErr(err error, cfg MCPServerConfig, t MCPTimeouts) 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" {
+	if mcpColdLauncher(cfg) {
+		base := strings.ToLower(filepath.Base(cfg.Command))
+		base = strings.TrimSuffix(strings.TrimSuffix(base, ".exe"), ".cmd")
 		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)
+	return fmt.Errorf("délai dépassé — le serveur n'a pas répondu au handshake en %s (délai de connexion réglable dans les réglages MCP)", t.connect())
 }

internal/loki/mcp_config.go

@@ -52,7 +52,7 @@ type MCPServerConfig struct {
 	DisabledTools []string `json:"disabledTools,omitempty"`
 
 	// CallTimeoutSec : délai d'un appel d'outil de ce serveur, en secondes.
-	// 0 = défaut (mcpCallTimeout). Pour un serveur dont les outils sont longs
+	// 0 = réglage global (MCPTimeouts.Call). Pour un serveur dont les outils sont longs
 	// par nature (build, scraping, requête lourde).
 	CallTimeoutSec int `json:"callTimeoutSec,omitempty"`
 }

internal/loki/mcp_timeouts.go

@@ -0,0 +1,89 @@
+package loki
+
+import (
+	"time"
+)
+
+// Délais MCP réglables depuis l'UI (repris d'AJEAN c05a0a9f) : connexion d'une
+// session et appel d'outil, en secondes, communs à tous les serveurs. Un
+// serveur peut remplacer le délai d'appel par le sien (CallTimeoutSec), et un
+// lancement npx/uvx garde au moins mcpConnectTimeoutCold pour se connecter.
+
+// MCPTimeouts : les délais globaux, en secondes. Stockés dans bkState sous
+// la clé mcpTimeoutsKey ; zéro (ou clé absente) = valeur par défaut.
+type MCPTimeouts struct {
+	// Connect borne l'établissement d'une session (handshake initialize +
+	// tools/list). Un serveur qui rame ne doit pas figer le tour de chat.
+	Connect int `json:"connect"`
+	// Call borne un appel d'outil MCP.
+	Call int `json:"call"`
+}
+
+const (
+	// Valeurs par défaut, en secondes (les anciennes constantes).
+	mcpConnectTimeoutDefault = 20
+	mcpCallTimeoutDefault    = 120
+	// mcpTimeoutMaxSec : borne haute des réglages (1 h), globaux comme par
+	// serveur.
+	mcpTimeoutMaxSec = 3600
+	mcpTimeoutsKey   = "mcp_timeouts"
+)
+
+// LoadMCPTimeouts lit les délais globaux. Une valeur absente, nulle ou
+// illisible retombe sur son défaut ; une valeur hors bornes (base modifiée à
+// la main) est ramenée à mcpTimeoutMaxSec.
+func LoadMCPTimeouts() MCPTimeouts {
+	var t MCPTimeouts
+	if !getJSON(bkState, mcpTimeoutsKey, &t) {
+		t = MCPTimeouts{}
+	}
+	return t.normalized()
+}
+
+func (t MCPTimeouts) normalized() MCPTimeouts {
+	fix := func(v, def int) int {
+		switch {
+		case v <= 0:
+			return def
+		case v > mcpTimeoutMaxSec:
+			return mcpTimeoutMaxSec
+		}
+		return v
+	}
+	return MCPTimeouts{
+		Connect: fix(t.Connect, mcpConnectTimeoutDefault),
+		Call:    fix(t.Call, mcpCallTimeoutDefault),
+	}
+}
+
+// SaveMCPTimeouts enregistre les délais globaux (valeurs déjà validées par
+// l'appelant ; normalisées par sûreté).
+func SaveMCPTimeouts(t MCPTimeouts) error {
+	mcpConfigMu.Lock()
+	defer mcpConfigMu.Unlock()
+	return putJSON(bkState, mcpTimeoutsKey, t.normalized())
+}
+
+// connect et call : les délais en durées.
+func (t MCPTimeouts) connect() time.Duration { return time.Duration(t.Connect) * time.Second }
+func (t MCPTimeouts) call() time.Duration    { return time.Duration(t.Call) * time.Second }
+
+// mcpTimeoutsError : le refus d'un réglage hors bornes, nil sinon. Même texte
+// pour la façade (mcp/mod.rs).
+func mcpTimeoutsError(t MCPTimeouts) string {
+	if t.Connect < 1 || t.Connect > mcpTimeoutMaxSec {
+		return "connexion : 1 à 3600 s"
+	}
+	if t.Call < 1 || t.Call > mcpTimeoutMaxSec {
+		return "appel d'outil : 1 à 3600 s"
+	}
+	return ""
+}
+
+// mcpCallTimeoutSecError : le refus d'un délai par serveur hors bornes.
+func mcpCallTimeoutSecError(sec int) string {
+	if sec < 0 || sec > mcpTimeoutMaxSec {
+		return "délai d'un appel : 0 à 3600 s (vide = réglage global)"
+	}
+	return ""
+}

internal/loki/mcp_timeouts_test.go

@@ -0,0 +1,171 @@
+package loki
+
+import (
+	"encoding/json"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+)
+
+// Une base vide donne les délais par défaut : 20 s de connexion, 120 s
+// d'appel.
+func TestMCPTimeoutsDefautsSansConfig(t *testing.T) {
+	testHome(t)
+	got := LoadMCPTimeouts()
+	if got != (MCPTimeouts{Connect: 20, Call: 120}) {
+		t.Fatalf("défauts = %+v", got)
+	}
+	if d := mcpTimeoutFor(MCPServerConfig{Command: "node"}, got); d != 20*time.Second {
+		t.Errorf("connexion = %s", d)
+	}
+	if d := mcpCallTimeoutFor(MCPServerConfig{}, got, nil); d != 120*time.Second {
+		t.Errorf("appel = %s", d)
+	}
+}
+
+// Enregistrés puis relus ; une valeur nulle retombe sur son défaut, une
+// valeur trop grande (base modifiée à la main) sur la borne, une valeur
+// illisible sur les défauts.
+func TestMCPTimeoutsAllerRetour(t *testing.T) {
+	testHome(t)
+	if err := SaveMCPTimeouts(MCPTimeouts{Connect: 5, Call: 300}); err != nil {
+		t.Fatal(err)
+	}
+	if got := LoadMCPTimeouts(); got != (MCPTimeouts{Connect: 5, Call: 300}) {
+		t.Fatalf("relecture = %+v", got)
+	}
+	for raw, want := range map[string]MCPTimeouts{
+		`{"connect":0,"call":0}`:         {20, 120},
+		`{"connect":-4,"call":99999}`:    {20, 3600},
+		`{"connect":"x","call":50}`:      {20, 120},
+		`{"CONNECT":7}`:                  {7, 120},
+		`null`:                           {20, 120},
+		`{"connect":30,"call":40} reste`: {20, 120},
+	} {
+		if err := putStr(bkState, mcpTimeoutsKey, raw); err != nil {
+			t.Fatal(err)
+		}
+		if got := LoadMCPTimeouts(); got != want {
+			t.Errorf("%s : %+v, attendu %+v", raw, got, want)
+		}
+	}
+}
+
+// Un lanceur npx/uvx garde au moins mcpConnectTimeoutCold ; un délai réglé
+// plus long l'emporte.
+func TestMCPTimeoutForLanceurFroid(t *testing.T) {
+	npx := MCPServerConfig{Command: "npx"}
+	if d := mcpTimeoutFor(npx, MCPTimeouts{Connect: 20, Call: 120}); d != mcpConnectTimeoutCold {
+		t.Errorf("npx, 20 s : %s", d)
+	}
+	if d := mcpTimeoutFor(npx, MCPTimeouts{Connect: 600, Call: 120}); d != 10*time.Minute {
+		t.Errorf("npx, 600 s : %s", d)
+	}
+	if d := mcpTimeoutFor(MCPServerConfig{URL: "http://x"}, MCPTimeouts{Connect: 45, Call: 120}); d != 45*time.Second {
+		t.Errorf("http, 45 s : %s", d)
+	}
+}
+
+func mcpRoute(t *testing.T, h func(w *httptest.ResponseRecorder), want int) map[string]any {
+	t.Helper()
+	w := httptest.NewRecorder()
+	h(w)
+	var out map[string]any
+	if err := json.Unmarshal(w.Body.Bytes(), &out); err != nil {
+		t.Fatalf("réponse %q : %v", w.Body.String(), err)
+	}
+	if w.Code != want {
+		t.Fatalf("code %d, attendu %d : %s", w.Code, want, w.Body.String())
+	}
+	return out
+}
+
+// Les routes des délais globaux : lecture, refus hors bornes, enregistrement
+// qui ferme les sessions ouvertes.
+func TestMCPTimeoutsRoutes(t *testing.T) {
+	testHome(t)
+	t.Setenv(facadeMCPEnv, "")
+	get := func() map[string]any {
+		return mcpRoute(t, func(w *httptest.ResponseRecorder) {
+			handleMCPTimeouts(w, httptest.NewRequest("GET", "/api/mcp/timeouts", nil))
+		}, 200)
+	}
+	post := func(body string, want int) map[string]any {
+		return mcpRoute(t, func(w *httptest.ResponseRecorder) {
+			handleMCPTimeoutsSave(w, httptest.NewRequest("POST", "/api/mcp/timeouts/save", strings.NewReader(body)))
+		}, want)
+	}
+	if v := get(); v["connect"] != 20.0 || v["call"] != 120.0 {
+		t.Fatalf("GET : %v", v)
+	}
+	for body, msg := range map[string]string{
+		`{"connect":0,"call":120}`:    "connexion : 1 à 3600 s",
+		`{"connect":20,"call":3601}`:  "appel d'outil : 1 à 3600 s",
+		`{"connect":20}`:              "appel d'outil : 1 à 3600 s",
+		`{"connect":"20","call":120}`: "json: cannot unmarshal string into Go struct field MCPTimeouts.connect of type int",
+	} {
+		if v := post(body, 400); v["error"] != msg {
+			t.Errorf("%s : %v", body, v["error"])
+		}
+	}
+	// Une session ouverte sur un serveur configuré : fermée à l'enregistrement.
+	if err := SetMCPServer("lent", MCPServerConfig{URL: "http://127.0.0.1:1/mcp", Enabled: false}); err != nil {
+		t.Fatal(err)
+	}
+	fakeMCPSlow(t)
+	if v := post(`{"connect":30,"call":600}`, 200); v["connect"] != 30.0 || v["call"] != 600.0 {
+		t.Fatalf("POST : %v", v)
+	}
+	mcpMgr.mu.Lock()
+	_, open := mcpMgr.sessions["lent"]
+	mcpMgr.mu.Unlock()
+	if open {
+		t.Error("la session est restée ouverte")
+	}
+	if v := get(); v["connect"] != 30.0 || v["call"] != 600.0 {
+		t.Fatalf("GET après enregistrement : %v", v)
+	}
+	if got := getStr(bkState, mcpTimeoutsKey); got != `{"connect":30,"call":600}` {
+		t.Errorf("stocké : %s", got)
+	}
+}
+
+// Le délai d'un serveur passe par /api/mcp/save, revient dans /api/mcp et
+// survit à un nouvel enregistrement sans lui (0 = réglage global).
+func TestMCPSaveCallTimeoutSec(t *testing.T) {
+	testHome(t)
+	t.Setenv(facadeMCPEnv, "")
+	t.Cleanup(mcpCloseAll)
+	save := func(body string, want int) map[string]any {
+		return mcpRoute(t, func(w *httptest.ResponseRecorder) {
+			handleMCPSave(w, httptest.NewRequest("POST", "/api/mcp/save", strings.NewReader(body)))
+		}, want)
+	}
+	v := save(`{"name":"long","url":"http://127.0.0.1:1/mcp","enabled":false,"callTimeoutSec":900}`, 200)
+	srv := v["servers"].([]any)[0].(map[string]any)
+	if srv["callTimeoutSec"] != 900.0 {
+		t.Fatalf("état : %v", srv)
+	}
+	servers, _ := LoadMCPConfig()
+	if servers["long"].CallTimeoutSec != 900 {
+		t.Fatalf("config : %+v", servers["long"])
+	}
+	st, _ := MCPStatus()
+	if len(st) != 1 || st[0].CallTimeoutSec != 900 {
+		t.Fatalf("MCPStatus : %+v", st)
+	}
+	// Champ vidé dans l'UI : retour au réglage global, clé absente.
+	v = save(`{"name":"long","url":"http://127.0.0.1:1/mcp","enabled":false}`, 200)
+	if _, ok := v["servers"].([]any)[0].(map[string]any)["callTimeoutSec"]; ok {
+		t.Fatalf("callTimeoutSec resté : %v", v)
+	}
+	for _, body := range []string{
+		`{"name":"x","url":"http://h","callTimeoutSec":-1}`,
+		`{"name":"x","url":"http://h","callTimeoutSec":3601}`,
+	} {
+		if v := save(body, 400); v["error"] != "délai d'un appel : 0 à 3600 s (vide = réglage global)" {
+			t.Errorf("%s : %v", body, v["error"])
+		}
+	}
+}

internal/loki/parity_mcp_test.go

@@ -91,13 +91,76 @@ func TestPariteMCP(t *testing.T) {
 	}
 	fx["prompt_line"] = lines
 	timeouts := map[string]any{}
+	def := MCPTimeouts{}.normalized()
 	for _, cmd := range []string{"npx", "/usr/local/bin/NPX", "uvx.exe", "npx.cmd", "node", "", "uvx-x", "C:/bin/uvx.EXE"} {
 		cfg := MCPServerConfig{Command: cmd}
-		timeouts[cmd] = map[string]any{"secs": int(mcpTimeoutFor(cfg).Seconds()),
-			"err": mcpFriendlyErr(context.DeadlineExceeded, cfg).Error()}
+		timeouts[cmd] = map[string]any{"secs": int(mcpTimeoutFor(cfg, def).Seconds()),
+			"err": mcpFriendlyErr(context.DeadlineExceeded, cfg, def).Error()}
 	}
 	fx["timeouts"] = timeouts
-	fx["friendly_other"] = mcpFriendlyErr(errors.New("autre"), MCPServerConfig{Command: "npx"}).Error()
+	fx["friendly_other"] = mcpFriendlyErr(errors.New("autre"), MCPServerConfig{Command: "npx"}, def).Error()
+	// Délais globaux (mcp_timeouts) : lecture de la base, puis leur effet sur
+	// la connexion et sur l'appel.
+	var stored []any
+	for _, raw := range []string{"", `{"connect":5,"call":300}`, `{"connect":0,"call":0}`, `{"connect":-4,"call":99999}`,
+		`{"connect":"x","call":50}`, `{"CONNECT":7,"Call":8}`, `null`, `[1]`, `{"connect":30,"call":40} reste`,
+		`{"connect":1.5,"call":60}`, `{"connect":3600,"call":3600,"autre":1}`} {
+		_ = putStr(bkState, mcpTimeoutsKey, raw)
+		stored = append(stored, map[string]any{"in": raw, "out": LoadMCPTimeouts()})
+	}
+	fx["timeouts_stored"] = stored
+	var effects []any
+	for _, tm := range []MCPTimeouts{{20, 120}, {5, 45}, {600, 3600}, {180, 1}} {
+		for _, c := range []struct {
+			cfg  MCPServerConfig
+			args string
+		}{
+			{MCPServerConfig{Command: "node"}, `{}`},
+			{MCPServerConfig{Command: "npx"}, `{}`},
+			{MCPServerConfig{URL: "http://h", CallTimeoutSec: 90}, `{}`},
+			{MCPServerConfig{Command: "uvx", CallTimeoutSec: 3600}, `{"timeout":7200}`},
+			{MCPServerConfig{URL: "http://h"}, `{"timeout":600}`},
+			{MCPServerConfig{URL: "http://h"}, `{"timeout":99999999}`},
+		} {
+			var args map[string]any
+			_ = json.Unmarshal([]byte(c.args), &args)
+			cfgJSON, _ := json.Marshal(c.cfg)
+			effects = append(effects, map[string]any{
+				"timeouts": tm, "cfg": string(cfgJSON), "args": c.args,
+				"connect": mcpTimeoutFor(c.cfg, tm).Milliseconds(),
+				"err":     mcpFriendlyErr(context.DeadlineExceeded, c.cfg, tm).Error(),
+				"call":    mcpCallTimeoutFor(c.cfg, tm, args).Milliseconds(),
+			})
+		}
+	}
+	fx["timeouts_effects"] = effects
+	_ = putStr(bkState, mcpTimeoutsKey, "")
+	var routes []any
+	for _, rq := range [][2]string{
+		{"/api/mcp/timeouts", ""},
+		{"/api/mcp/timeouts/save", `{"connect":0,"call":120}`},
+		{"/api/mcp/timeouts/save", `{"connect":20,"call":3601}`},
+		{"/api/mcp/timeouts/save", `{"connect":20}`},
+		{"/api/mcp/timeouts/save", `{"connect":"20","call":120}`},
+		{"/api/mcp/timeouts/save", `{"connect":2.5,"call":120}`},
+		{"/api/mcp/timeouts/save", `[]`},
+		{"/api/mcp/timeouts/save", `pas du json`},
+		{"/api/mcp/timeouts/save", `{"Connect":45,"CALL":900,"x":1}`},
+		{"/api/mcp/timeouts", ""},
+		{"/api/mcp/timeouts/save", `{"connect":3600,"call":1}`},
+		{"/api/mcp/timeouts", ""},
+	} {
+		w := httptest.NewRecorder()
+		if rq[0] == "/api/mcp/timeouts" {
+			handleMCPTimeouts(w, httptest.NewRequest("GET", rq[0], nil))
+		} else {
+			handleMCPTimeoutsSave(w, httptest.NewRequest("POST", rq[0], strings.NewReader(rq[1])))
+		}
+		routes = append(routes, map[string]any{"path": rq[0], "body": rq[1], "code": w.Code,
+			"resp": strings.TrimSpace(w.Body.String()), "state": getStr(bkState, mcpTimeoutsKey)})
+	}
+	fx["timeouts_routes"] = routes
+	_ = putStr(bkState, mcpTimeoutsKey, "")
 	var flat []any
 	for _, raw := range []string{
 		`{"content":[{"type":"text","text":"  un "},{"type":"text","text":"deux\n"}]}`,
@@ -148,7 +211,7 @@ func TestPariteMCP(t *testing.T) {
 		{Op: "set", Name: "a__b", Cfg: `{"command":"x"}`},
 		{Op: "set", Name: "both", Cfg: `{"command":"x","url":"http://u"}`},
 		{Op: "set", Name: "none", Cfg: `{"enabled":true}`},
-		{Op: "set", Name: "web", Cfg: `{"url":"http://u/mcp","headers":{"X":"1"},"enabled":false}`},
+		{Op: "set", Name: "web", Cfg: `{"url":"http://u/mcp","headers":{"X":"1"},"enabled":false,"callTimeoutSec":45}`},
 		{Op: "enable", Name: "web", On: true},
 		{Op: "enable", Name: "nope", On: true},
 		{Op: "tool", Name: "fs", Tool: "write", On: false},
@@ -285,7 +348,7 @@ func TestPariteMCP(t *testing.T) {
 	}
 	_ = SetMCPToolEnabled("alpha", "secret", false)
 	_ = SetMCPServer("beta", MCPServerConfig{Command: "loki-mcp-absent-pour-test", Enabled: true})
-	_ = SetMCPServer("gamma", MCPServerConfig{URL: ts.URL, Enabled: false})
+	_ = SetMCPServer("gamma", MCPServerConfig{URL: ts.URL, Enabled: false, CallTimeoutSec: 300})
 	raw := getStr(bkState, "mcp")
 	raw = strings.Replace(raw, `}}`, `},"delta":{"enabled":true}}`, 1)
 	_ = putStr(bkState, "mcp", raw)

internal/loki/parity_strata_test.go

@@ -249,13 +249,14 @@ func TestPariteStrata(t *testing.T) {
 		return out
 	}
 
+	srcDir := filepath.Base(strataSrcDir())
 	src := []parityArchEntry{
-		{Name: "ajean-moe-1.0/", Type: "dir", Mode: 0o755},
-		{Name: "ajean-moe-1.0/setup.sh", Type: "file", Body: parityStrataSetup, Mode: 0o755},
-		{Name: "ajean-moe-1.0/setup.py", Type: "file", Body: "# installeur\n", Mode: 0o644},
-		{Name: "ajean-moe-1.0/serve/server.py", Type: "file", Body: "# serveur\n", Mode: 0o644},
+		{Name: srcDir + "/", Type: "dir", Mode: 0o755},
+		{Name: srcDir + "/setup.sh", Type: "file", Body: parityStrataSetup, Mode: 0o755},
+		{Name: srcDir + "/setup.py", Type: "file", Body: "# installeur\n", Mode: 0o644},
+		{Name: srcDir + "/serve/server.py", Type: "file", Body: "# serveur\n", Mode: 0o644},
 	}
-	goodRel := parityStrataRel{Src: src, Engine: "moteur strata 1.0"}
+	goodRel := parityStrataRel{Src: src, Engine: "moteur strata " + strataVersion}
 	mem47 := "MemTotal:       49283072 kB\nMemFree:         1000000 kB\nMemAvailable:   41943040 kB\n"
 	mem64 := "MemTotal:       67108864 kB\nMemAvailable:   65011712 kB\n"
 	mem16 := "MemTotal:       16777216 kB\nMemAvailable:   12582912 kB\n"
@@ -332,7 +333,7 @@ func TestPariteStrata(t *testing.T) {
 		mu.Unlock()
 		st.After = map[string]string{}
 		cfg := ReadConfig()
-		for _, k := range []string{"ENGINE", "STRATA_CONFIG", "CTX", "STRATA_KV", "STRATA_HELPER"} {
+		for _, k := range []string{"ENGINE", "STRATA_CONFIG", "CTX", "STRATA_KV", "STRATA_HELPER", "STRATA_SPLIT"} {
 			if v := cfg[k]; v != "" {
 				st.After["config/"+k] = mask(v)
 			}
@@ -381,6 +382,10 @@ func TestPariteStrata(t *testing.T) {
 			Method: "POST", Path: "/api/strata/settings", Body: settings("S", 98304, "")},
 		{Name: "réglages du preset actif pendant une optimisation", Tune: true,
 			Method: "POST", Path: "/api/strata/settings", Body: settings("S", 98304, "")},
+		{Name: "réglages, répartition inconnue", Method: "POST", Path: "/api/strata/settings", Body: settings("S", 98304, `,"split":"nimporte"`)},
+		{Name: "réglages, partage des couches", Method: "POST", Path: "/api/strata/settings", Body: settings("S", 98304, `,"split":"layers"`)},
+		{Name: "réglages d'un ancien client, partage gardé", Method: "POST", Path: "/api/strata/settings", Body: settings("S", 98304, "")},
+		{Name: "réglages, retour à l'aide aux experts", Method: "POST", Path: "/api/strata/settings", Body: settings("S", 98304, `,"split":"helper"`)},
 
 		// Installation.
 		{Name: "installation en GET", Method: "GET", Path: "/api/strata/install"},
@@ -393,42 +398,52 @@ func TestPariteStrata(t *testing.T) {
 			Body: `{"family":"qwen","quant":"IQ3_S"}`, Wait: true},
 		{Name: "release introuvable", Meminfo: mem47, Release: &parityStrataRel{Status: 404, Src: src, Engine: "x"},
 			Method: "POST", Path: "/api/strata/install", Body: `{"family":"swift","quant":"IQ3_XXS"}`, Wait: true},
-		{Name: "moteur altéré", Release: &parityStrataRel{Src: src, Engine: "moteur strata 1.0", BadSHA: true},
+		{Name: "moteur altéré", Release: &parityStrataRel{Src: src, Engine: "moteur strata " + strataVersion, BadSHA: true},
 			Method: "POST", Path: "/api/strata/install", Body: `{"family":"swift","quant":"IQ3_XXS"}`, Wait: true},
 		{Name: "installation", Release: &goodRel, Method: "POST", Path: "/api/strata/install",
 			Body: `{"family":"swift","quant":"IQ3_XXS"}`, Wait: true},
 		{Name: "après l'installation", Method: "GET", Path: "/api/strata"},
 		{Name: "mode lancé connu, modèles inactifs", State: map[string]string{"strata_experts_mode": "drop"}, Files: map[string]string{
-			"presets/STRATA FLASH NEXT CLASSIQUE IQ2_XS.env": "# NAME=Classique IQ2_XS\nENGINE=strata\nSTRATA_CONFIG={{HOME}}/strata/ajean-moe-1.0/strata-swift-iq3_xxs.json\n" +
+			"presets/STRATA FLASH NEXT CLASSIQUE IQ2_XS.env": "# NAME=Classique IQ2_XS\nENGINE=strata\nSTRATA_CONFIG={{HOME}}/strata/" + srcDir + "/strata-swift-iq3_xxs.json\n" +
 				"STRATA_MAIN_GPU=1\nSTRATA_HELPER_GPU=-1\nSTRATA_EXPERTS=disk\n",
-			"presets/STRATA FLASH NEXT CLASSIQUE Q2_0.env": "ENGINE=moe\nSTRATA_CONFIG={{HOME}}/strata/ajean-moe-1.0/strata-swift-iq3_xxs.json\n" +
+			"presets/STRATA FLASH NEXT CLASSIQUE Q2_0.env": "ENGINE=moe\nSTRATA_CONFIG={{HOME}}/strata/" + srcDir + "/strata-swift-iq3_xxs.json\n" +
 				"STRATA_MAIN_GPU=0\nSTRATA_HELPER_GPU=1\nSTRATA_HELPER=0\nSTRATA_VISION=0\nSTRATA_EXPERTS=ram\n",
 		}, Method: "GET", Path: "/api/strata"},
 		{Name: "experts.bin et moteur du paquet", Files: map[string]string{
 			"strata/data/packs/swift-iq3_xxs/experts.bin": "x",
 		}, State: map[string]string{"strata_experts_mode": ""}, Method: "GET", Path: "/api/strata"},
-		{Name: "RAM juste sous le seuil du mode hors RAM", Meminfo: "MemTotal:       49283072 kB\nMemAvailable:   43164063 kB\n",
+		{Name: "RAM juste sous le seuil du mode hors RAM", Meminfo: "MemTotal:       49283072 kB\nMemAvailable:   44140625 kB\n",
 			Method: "GET", Path: "/api/strata"},
-		{Name: "RAM au-dessus du seuil du mode hors RAM", Meminfo: "MemTotal:       49283072 kB\nMemAvailable:   43457032 kB\n",
+		{Name: "RAM au-dessus du seuil du mode hors RAM", Meminfo: "MemTotal:       49283072 kB\nMemAvailable:   44433594 kB\n",
 			Method: "GET", Path: "/api/strata"},
+		{Name: "contexte plafonné en mode hors RAM", Files: map[string]string{
+			"presets/STRATA FLASH NEXT SWIFT 1.5 IQ3_XXS.env": "# NAME=Qwen3.8 Flash Next Swift 1.5 IQ3_XXS (Strata)\nENGINE=strata\n" +
+				"STRATA_CONFIG={{HOME}}/strata/" + srcDir + "/strata-swift-iq3_xxs.json\nSTRATA_MAIN_GPU=1\nSTRATA_HELPER_GPU=0\n" +
+				"STRATA_VISION=1\nSTRATA_EXPERTS=auto\nSTRATA_DROP=1\nSTRATA_KV=fp16\nSTRATA_KV_RESIDENT=32768\nSTRATA_SPEC=3\nCTX=196608\nREASONING=off\n",
+		}, Method: "GET", Path: "/api/strata"},
+		{Name: "seconde carte en partage des couches", Files: map[string]string{
+			"presets/STRATA FLASH NEXT SWIFT 1.5 IQ3_XXS.env": "# NAME=Qwen3.8 Flash Next Swift 1.5 IQ3_XXS (Strata)\nENGINE=strata\n" +
+				"STRATA_CONFIG={{HOME}}/strata/" + srcDir + "/strata-swift-iq3_xxs.json\nSTRATA_MAIN_GPU=1\nSTRATA_HELPER_GPU=0\n" +
+				"STRATA_VISION=1\nSTRATA_EXPERTS=auto\nSTRATA_DROP=1\nSTRATA_KV=fp16\nSTRATA_KV_RESIDENT=32768\nSTRATA_SPEC=3\nCTX=196608\nREASONING=off\nSTRATA_SPLIT=layers\n",
+		}, Method: "GET", Path: "/api/strata"},
 		{Name: "mode hors RAM coupé dans le preset", Files: map[string]string{
 			"presets/STRATA FLASH NEXT SWIFT 1.5 IQ3_XXS.env": "# NAME=Qwen3.8 Flash Next Swift 1.5 IQ3_XXS (Strata)\nENGINE=strata\n" +
-				"STRATA_CONFIG={{HOME}}/strata/ajean-moe-1.0/strata-swift-iq3_xxs.json\nSTRATA_MAIN_GPU=1\nSTRATA_HELPER_GPU=0\n" +
+				"STRATA_CONFIG={{HOME}}/strata/" + srcDir + "/strata-swift-iq3_xxs.json\nSTRATA_MAIN_GPU=1\nSTRATA_HELPER_GPU=0\n" +
 				"STRATA_VISION=1\nSTRATA_EXPERTS=auto\nSTRATA_DROP=0\nSTRATA_KV=fp16\nSTRATA_KV_RESIDENT=32768\nSTRATA_SPEC=3\nCTX=131072\nREASONING=off\n",
 		}, Method: "GET", Path: "/api/strata"},
 		{Name: "moteur d'un autre paquet", Meminfo: mem47, Files: map[string]string{
-			"strata/ajean-moe-1.0/engine-cuda12/.loki-engine": "ajean-moe-engine-0.9-linux-x64-cuda12.zip\n",
+			"strata/" + srcDir + "/engine-cuda12/.loki-engine": "ajean-moe-engine-0.9-linux-x64-cuda12.zip\n",
 		}, Method: "GET", Path: "/api/strata"},
 		{Name: "réinstallation, moteur téléchargé périmé", Files: map[string]string{
-			"strata/dl/ajean-moe-engine-1.0-linux-x64-cuda12.zip": "ancien moteur",
+			"strata/dl/" + strataEngineAsset: "ancien moteur",
 		}, Method: "POST", Path: "/api/strata/install", Body: `{"family":"swift","quant":"IQ3_XXS"}`, Wait: true},
 		{Name: "installeur en échec", Method: "POST", Path: "/api/strata/install", Body: `{"family":"qwen","quant":"Q2_0"}`, Wait: true},
 		{Name: "installeur sans configuration", Method: "POST", Path: "/api/strata/install", Body: `{"family":"qwen","quant":"IQ2_XS"}`, Wait: true},
 		{Name: "configuration de lancement disparue", Files: map[string]string{
-			"strata/ajean-moe-1.0/strata-swift-iq3_xxs.json": "-",
+			"strata/" + srcDir + "/strata-swift-iq3_xxs.json": "-",
 		}, Method: "GET", Path: "/api/strata"},
 		{Name: "configuration de lancement illisible", Files: map[string]string{
-			"strata/ajean-moe-1.0/strata-swift-iq3_xxs.json": "[1]",
+			"strata/" + srcDir + "/strata-swift-iq3_xxs.json": "[1]",
 		}, Method: "GET", Path: "/api/strata"},
 	} {
 		run(st)

internal/loki/ui/index.html

@@ -2773,6 +2773,17 @@ html[data-files="1"] #files-btn{color:var(--accent)}
     <div id="mcp-block" class="gated-group">
       <div class="subhead">Serveurs MCP<span id="mcp-badge" class="sbadge"></span><span class="help" tabindex="0" onclick="event.preventDefault();event.stopPropagation();this.classList.toggle('open')">?<span class="tip">Connecte des <b>serveurs MCP</b> (Model Context Protocol) pour donner de nouveaux outils à l'IA : accès fichiers, bases de données, APIs métier… <b>stdio</b> = programme lancé localement (npx/uvx/binaire) · <b>http</b> = serveur distant. ⚠ un serveur stdio exécute du code sur cette machine, au même titre que le shell.</span></span></div>
       <div class="slist">
+        <!-- Délais communs à tous les serveurs (AJEAN c05a0a9f, e44b6139),
+             enregistrés à chaque modification. Un serveur peut remplacer le
+             délai d'appel dans sa fenêtre d'édition. -->
+        <div class="pe-row">
+          <span class="pe-row-l">Délai de connexion<span class="pe-sub">pour joindre un serveur ; au moins 3 min au premier lancement npx/uvx</span></span>
+          <span class="pe-row-c"><input id="mcp-timeout-connect" class="pe-val" type="number" min="1" max="3600" step="1" value="20" style="width:54px" onchange="saveMcpTimeouts()"><span class="pe-unit">s</span></span>
+        </div>
+        <div class="pe-row">
+          <span class="pe-row-l">Délai d'un appel d'outil<span class="pe-sub">réglable aussi serveur par serveur</span></span>
+          <span class="pe-row-c"><input id="mcp-timeout-call" class="pe-val" type="number" min="1" max="3600" step="1" value="120" style="width:54px" onchange="saveMcpTimeouts()"><span class="pe-unit">s</span></span>
+        </div>
         <div class="rowbody">
           <!-- 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. -->
@@ -3292,6 +3303,10 @@ html[data-files="1"] #files-btn{color:var(--accent)}
           <textarea id="mcp-headers" class="ctl ta" spellcheck="false" style="min-height:44px" placeholder="Authorization: Bearer sk-…"></textarea>
         </div>
       </div>
+      <div class="fld">
+        <label class="fld-l" for="mcp-call-timeout">Délai d'un appel d'outil <span class="opt">(secondes, 1 à 3600 — vide = réglage global)</span></label>
+        <input id="mcp-call-timeout" class="ctl" type="number" min="1" max="3600" step="1" inputmode="numeric" placeholder="réglage global">
+      </div>
       <div id="mcp-modal-status" class="muted" style="font-size:12px;min-height:16px"></div>
       <div id="mcp-tools-section" style="display:none">
         <div class="subhead" style="margin-top:6px">Outils <span id="mcp-tools-count" class="muted" style="text-transform:none;letter-spacing:0;font-weight:400;font-family:var(--font)"></span><span class="help" tabindex="0" onclick="event.preventDefault();event.stopPropagation();this.classList.toggle('open')">?<span class="tip">Décoche un outil pour le masquer à l'IA sans déconnecter le serveur. Utile pour ne garder que ce dont tu as besoin.</span></span></div>
@@ -3500,6 +3515,7 @@ html[data-files="1"] #files-btn{color:var(--accent)}
               </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>
+              <button id="m-hf-pause" class="pe-link" onclick="togglePauseDownload()" style="display:none">Mettre en pause</button>
               <button id="m-hf-cancel" class="pe-link" onclick="cancelDownload()" style="display:none">Annuler le téléchargement</button>
             </div>
             <div class="pe-row">
@@ -4521,6 +4537,7 @@ async function loadCfg(){
       rows.push(row('CTX', d.ctx));
       rows.push(row('KV', d.kv+(d.kv_resident ? ' · '+k(d.kv_resident)+' VRAM' : '')));
       rows.push(row('MTP', d.spec));
+      if(d.helper_gpu) rows.push(row('GPU 2', d.split_layers ? 'couches' : 'aide', d.helper_gpu));
       rows.push(row('EXPERTS', ({drop:'mlock (hors appoint)', ram:'RAM', arena:'experts.bin', disk:'mmap (disque)'})[d.mode] || (d.mmap ? 'mmap' : 'RAM'), d.mode_label||''));
       if(d.vision_gpu) rows.push(row('VISION', 'on', d.vision_gpu));
     }else if(c.CTX) rows.push(row('CTX', c.CTX));
@@ -6753,6 +6770,7 @@ function dlEls(){
     prog: document.getElementById('m-hf-progress'),
     bar:  document.getElementById('m-hf-bar'),
     cancel: document.getElementById('m-hf-cancel'),
+    pause: document.getElementById('m-hf-pause'),
   };
 }
 // Arrête le poll local sans toucher au téléchargement serveur.
@@ -6762,7 +6780,7 @@ function resetDlUI(){
   const e = dlEls();
   stopDlPoll(); dlName='';
   e.prog.style.display='none'; e.bar.style.display='none';
-  e.cancel.style.display='none'; e.btn.disabled=false;
+  e.cancel.style.display='none'; e.pause.style.display='none'; e.btn.disabled=false;
 }
 // Remplit le sélecteur de destination avec les dossiers de modèles connus.
 // L'espace libre est dans le libellé de l'option : c'est l'info utile au moment
@@ -6879,6 +6897,22 @@ async function cancelDownload(){
   await jpost('/api/models/download/cancel', {filename: dlName});
   // L'état « annulé » est confirmé par le prochain tick de poll.
 }
+// Met en pause ou reprend : le fichier partiel est gardé, la reprise repart
+// de là où le transfert s'était arrêté (repris d'AJEAN v0.18.1).
+let dlPaused = false;
+async function togglePauseDownload(){
+  if(!dlName) return;
+  const e = dlEls();
+  e.pause.disabled = true;
+  try{
+    const r = await jpost('/api/models/download/pause', {filename: dlName, pause: !dlPaused});
+    if(r.ok) setDlPaused(r.paused);
+  }finally{ e.pause.disabled = false; }
+}
+function setDlPaused(p){
+  dlPaused = !!p;
+  dlEls().pause.textContent = dlPaused ? 'Reprendre' : 'Mettre en pause';
+}
 // Suit un téléchargement (nouveau ou déjà en cours) et pilote barre + texte.
 function watchDownload(fname){
   const e = dlEls();
@@ -6889,7 +6923,10 @@ function watchDownload(fname){
   e.bar.style.display = 'block';
   e.cancel.style.display = 'inline';
   e.cancel.disabled = false;
-  const stop = ()=>{ stopDlPoll(); dlName=''; e.btn.disabled=false; e.cancel.style.display='none'; };
+  e.pause.style.display = 'inline';
+  e.pause.disabled = false;
+  setDlPaused(false);
+  const stop = ()=>{ stopDlPoll(); dlName=''; e.btn.disabled=false; e.cancel.style.display='none'; e.pause.style.display='none'; };
   const tick = async ()=>{
     const list = await jget('/api/models/download/status');
     const st = (list||[]).find(d=>d.filename===fname);
@@ -6913,6 +6950,7 @@ function watchDownload(fname){
       if(dlQueue.length) startDownloadURL(dlQueue.shift());
       return;
     }
+    if(!!st.paused !== dlPaused) setDlPaused(st.paused);
     const pct = st.total>0 ? st.done*100/st.total : 0;
     if(st.total>0){
       e.bar.className = 'pe-bar';
@@ -6922,7 +6960,8 @@ function watchDownload(fname){
     }
     const tot = st.total>0 ? ' / '+fmtSize(st.total)+' ('+Math.round(pct)+'%)' : '';
     let extra = '';
-    if(st.speed>0){
+    if(st.paused) extra += ' — en pause';
+    else if(st.speed>0){
       extra += ' — '+fmtSize(st.speed)+'/s';
       if(st.total>0){
         const eta = Math.max(0, Math.round((st.total-st.done)/st.speed));
@@ -9281,7 +9320,11 @@ function strataRenderSettings(fit){
     ['Experts', sel('strata-s-experts', [['auto','auto (selon la RAM libre)'],['ram','en RAM (le plus rapide)'],['disk','depuis le disque (mmap, économe)']], d.experts||'auto')],
     ['Lire les images', sw('strata-s-vision', d.vision)],
   ];
-  if(d.has_helper) rows.push(["Carte d'appoint", sw('strata-s-helper', d.helper_on)]);
+  // Seconde carte : aide aux experts (défaut mesuré) ou partage des couches,
+  // souvent plus rapide avec deux cartes identiques (#121 d'AJEAN).
+  if(d.has_helper) rows.push(['Seconde carte', sel('strata-s-helper',
+    [['off', 'non utilisée'], ['helper', 'aide aux experts'], ['layers', 'partage des couches']],
+    !d.helper_on ? 'off' : d.split_layers ? 'layers' : 'helper')]);
   document.getElementById('strata-settings').innerHTML = rows.map(([a,b])=>
     '<div class="moe-kv"><span>'+escHtml(a)+'</span><span>'+b+'</span></div>').join('');
   strataCtxLbl();
@@ -9301,8 +9344,11 @@ async function strataSaveSettings(){
   if(!fit || !fit.preset) return;
   const v = id => document.getElementById(id);
   const body = {preset: fit.preset, ctx: +v('strata-s-ctx').value, kv: v('strata-s-kv').value, spec: +v('strata-s-spec').value,
-    vision: v('strata-s-vision').checked, helper: v('strata-s-helper') ? v('strata-s-helper').checked : false,
+    vision: v('strata-s-vision').checked,
     experts: v('strata-s-experts') ? v('strata-s-experts').value : ''};
+  const second = v('strata-s-helper') ? v('strata-s-helper').value : 'off';
+  body.helper = second !== 'off';
+  if(body.helper) body.split = second;
   if(fit.active && !await askConfirm('Le modèle va redémarrer avec ces réglages (quelques minutes).', {title:'Strata — Qwen3.8 Flash Next', okText:'Enregistrer'})) return;
   const r = await jpost('/api/strata/settings', body);
   if(!r.ok){ toast('Erreur : '+(r.error||'')); return; }
@@ -9321,14 +9367,16 @@ function strataRenderDetails(fit){
   const k = n => (+n >= 1024 ? Math.round(+n/1024)+'K' : n);
   const rows = [
     ['Carte principale', d.main_gpu],
-    ["Carte d'appoint", d.helper_gpu || 'aucune'],
+    ['Seconde carte', d.helper_gpu ? d.helper_gpu + (d.split_layers ? ' · partage des couches' : ' · aide aux experts') : 'aucune'],
     ['Lecture des images', d.vision_gpu || 'aucune'],
     ['Contexte', (+d.ctx).toLocaleString('fr-FR')+' jetons'],
     ['Cache KV', d.kv + (d.kv_resident ? ' · '+k(d.kv_resident)+' en VRAM, le reste en RAM' : '')],
     ['Prédiction (MTP)', d.spec+' jetons'],
     ['Experts hors GPU', (d.mode_label || (d.mmap ? 'lus depuis le disque (mmap)' : 'chargés en RAM'))
       + (fit.active ? ' — dernier lancement' : ' — selon la RAM libre maintenant')],
-    ['Lecture des prompts', 'blocs de '+k(d.prefill)+', lecture directe sous '+d.short_read+' jetons'],
+    // paquet 1.1 : la carte d'appoint calcule ses experts à la lecture d'un prompt
+    ['Lecture des prompts', 'blocs de '+k(d.prefill)+', lecture directe sous '+d.short_read+' jetons'
+      + (d.helper_gpu && !d.split_layers ? ", experts de la carte d'appoint calculés par elle" : '')],
     ["Démarrage d'une conversation", 'reprise après le prompt système (dès '+d.cache_root+' jetons)'],
     ['Version du moteur', 'paquet AJEAN MoE '+d.version],
   ];
@@ -9469,7 +9517,47 @@ async function deleteExternal(){
 let mcpServers = [];
 let mcpEditing = null; // nom du serveur en cours d'édition ('' ou null = nouveau)
 
-async function loadMCP(){ renderMCP(await jget('/api/mcp')); }
+async function loadMCP(){
+  renderMCP(await jget('/api/mcp'));
+  loadMcpTimeouts();
+}
+
+// ─── Délais globaux ──────────────────────────────────────────────────────────
+// Connexion et appel d'outil, communs à tous les serveurs (/api/mcp/timeouts).
+// Un seul enregistrement par modification : « change » part à la validation
+// ou à la perte du focus, pas à chaque frappe.
+let mcpTimeouts = {connect: 20, call: 120};
+
+async function loadMcpTimeouts(){
+  const r = await jget('/api/mcp/timeouts');
+  if(!r || !r.ok) return;
+  mcpTimeouts = {connect: r.connect, call: r.call};
+  document.getElementById('mcp-timeout-connect').value = r.connect;
+  document.getElementById('mcp-timeout-call').value = r.call;
+  mcpCallTimeoutPlaceholder();
+}
+
+async function saveMcpTimeouts(){
+  const connect = Number(document.getElementById('mcp-timeout-connect').value);
+  const call = Number(document.getElementById('mcp-timeout-call').value);
+  const ok = v => Number.isInteger(v) && v >= 1 && v <= 3600;
+  if(!ok(connect) || !ok(call)){
+    toast('délai invalide : de 1 à 3600 s');
+    loadMcpTimeouts(); // revient aux valeurs enregistrées
+    return;
+  }
+  const r = await jpost('/api/mcp/timeouts/save', {connect, call});
+  if(!r || !r.ok){ toast('erreur : '+((r && r.error) || 'délais non enregistrés')); loadMcpTimeouts(); return; }
+  mcpTimeouts = {connect: r.connect, call: r.call};
+  mcpCallTimeoutPlaceholder();
+  toast('délais MCP enregistrés');
+}
+
+// Le champ « délai d'un appel » de la fenêtre d'édition montre le réglage
+// global qu'il remplacerait.
+function mcpCallTimeoutPlaceholder(){
+  document.getElementById('mcp-call-timeout').placeholder = 'réglage global ('+mcpTimeouts.call+' s)';
+}
 
 function renderMCP(r){
   mcpServers = (r && r.servers) || [];
@@ -9642,6 +9730,7 @@ function openMcpFromCatalog(e){
       Object.entries(e.env||{}).map(([k,v])=>k+'='+v).join('\n');
     document.getElementById('mcp-url').value = '';
     document.getElementById('mcp-headers').value = '';
+    document.getElementById('mcp-call-timeout').value = '';
     document.getElementById('mcp-modal-title').textContent = e.name+' — depuis le catalogue';
   }
   const st = document.getElementById('mcp-modal-status');
@@ -9669,6 +9758,8 @@ function openMcp(name){
   document.getElementById('mcp-env').value = s && s.env ? Object.entries(s.env).map(([k,v])=>k+'='+v).join('\n') : '';
   document.getElementById('mcp-url').value = s ? (s.url||'') : '';
   document.getElementById('mcp-headers').value = s && s.headers ? Object.entries(s.headers).map(([k,v])=>k+': '+v).join('\n') : '';
+  document.getElementById('mcp-call-timeout').value = s && s.callTimeoutSec ? s.callTimeoutSec : '';
+  mcpCallTimeoutPlaceholder();
   const st = document.getElementById('mcp-modal-status');
   st.textContent = ''; st.style.color = '';
   if(s && s.enabled && s.error){ st.textContent = '⚠ '+s.error; st.style.color = 'var(--err)'; }
@@ -9747,6 +9838,13 @@ async function saveMcp(){
     body.headers = mcpParseKV(document.getElementById('mcp-headers').value, ':');
     body.command = ''; body.args = undefined; body.env = undefined;
   }
+  // Vide = réglage global (0 côté serveur).
+  const ct = document.getElementById('mcp-call-timeout').value.trim();
+  if(ct){
+    const n = Number(ct);
+    if(!Number.isInteger(n) || n < 1 || n > 3600){ toast("délai d'un appel d'outil : de 1 à 3600 s, ou vide"); return; }
+    body.callTimeoutSec = n;
+  }
   const st = document.getElementById('mcp-modal-status');
   st.textContent = 'connexion…'; st.style.color = '';
   const r = await jpost('/api/mcp/save', body);

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

@@ -488,6 +488,17 @@ document.documentElement.setAttribute('data-side',localStorage.getItem('loki-sid
     <div id="mcp-block" class="gated-group">
       <div class="subhead">Serveurs MCP<span id="mcp-badge" class="sbadge"></span><span class="help" tabindex="0" onclick="event.preventDefault();event.stopPropagation();this.classList.toggle('open')">?<span class="tip">Connecte des <b>serveurs MCP</b> (Model Context Protocol) pour donner de nouveaux outils à l'IA : accès fichiers, bases de données, APIs métier… <b>stdio</b> = programme lancé localement (npx/uvx/binaire) · <b>http</b> = serveur distant. ⚠ un serveur stdio exécute du code sur cette machine, au même titre que le shell.</span></span></div>
       <div class="slist">
+        <!-- Délais communs à tous les serveurs (AJEAN c05a0a9f, e44b6139),
+             enregistrés à chaque modification. Un serveur peut remplacer le
+             délai d'appel dans sa fenêtre d'édition. -->
+        <div class="pe-row">
+          <span class="pe-row-l">Délai de connexion<span class="pe-sub">pour joindre un serveur ; au moins 3 min au premier lancement npx/uvx</span></span>
+          <span class="pe-row-c"><input id="mcp-timeout-connect" class="pe-val" type="number" min="1" max="3600" step="1" value="20" style="width:54px" onchange="saveMcpTimeouts()"><span class="pe-unit">s</span></span>
+        </div>
+        <div class="pe-row">
+          <span class="pe-row-l">Délai d'un appel d'outil<span class="pe-sub">réglable aussi serveur par serveur</span></span>
+          <span class="pe-row-c"><input id="mcp-timeout-call" class="pe-val" type="number" min="1" max="3600" step="1" value="120" style="width:54px" onchange="saveMcpTimeouts()"><span class="pe-unit">s</span></span>
+        </div>
         <div class="rowbody">
           <!-- 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. -->
@@ -1007,6 +1018,10 @@ document.documentElement.setAttribute('data-side',localStorage.getItem('loki-sid
           <textarea id="mcp-headers" class="ctl ta" spellcheck="false" style="min-height:44px" placeholder="Authorization: Bearer sk-…"></textarea>
         </div>
       </div>
+      <div class="fld">
+        <label class="fld-l" for="mcp-call-timeout">Délai d'un appel d'outil <span class="opt">(secondes, 1 à 3600 — vide = réglage global)</span></label>
+        <input id="mcp-call-timeout" class="ctl" type="number" min="1" max="3600" step="1" inputmode="numeric" placeholder="réglage global">
+      </div>
       <div id="mcp-modal-status" class="muted" style="font-size:12px;min-height:16px"></div>
       <div id="mcp-tools-section" style="display:none">
         <div class="subhead" style="margin-top:6px">Outils <span id="mcp-tools-count" class="muted" style="text-transform:none;letter-spacing:0;font-weight:400;font-family:var(--font)"></span><span class="help" tabindex="0" onclick="event.preventDefault();event.stopPropagation();this.classList.toggle('open')">?<span class="tip">Décoche un outil pour le masquer à l'IA sans déconnecter le serveur. Utile pour ne garder que ce dont tu as besoin.</span></span></div>
@@ -1215,6 +1230,7 @@ document.documentElement.setAttribute('data-side',localStorage.getItem('loki-sid
               </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>
+              <button id="m-hf-pause" class="pe-link" onclick="togglePauseDownload()" style="display:none">Mettre en pause</button>
               <button id="m-hf-cancel" class="pe-link" onclick="cancelDownload()" style="display:none">Annuler le téléchargement</button>
             </div>
             <div class="pe-row">

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

@@ -330,6 +330,7 @@ async function loadCfg(){
       rows.push(row('CTX', d.ctx));
       rows.push(row('KV', d.kv+(d.kv_resident ? ' · '+k(d.kv_resident)+' VRAM' : '')));
       rows.push(row('MTP', d.spec));
+      if(d.helper_gpu) rows.push(row('GPU 2', d.split_layers ? 'couches' : 'aide', d.helper_gpu));
       rows.push(row('EXPERTS', ({drop:'mlock (hors appoint)', ram:'RAM', arena:'experts.bin', disk:'mmap (disque)'})[d.mode] || (d.mmap ? 'mmap' : 'RAM'), d.mode_label||''));
       if(d.vision_gpu) rows.push(row('VISION', 'on', d.vision_gpu));
     }else if(c.CTX) rows.push(row('CTX', c.CTX));

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

@@ -1501,6 +1501,7 @@ function dlEls(){
     prog: document.getElementById('m-hf-progress'),
     bar:  document.getElementById('m-hf-bar'),
     cancel: document.getElementById('m-hf-cancel'),
+    pause: document.getElementById('m-hf-pause'),
   };
 }
 // Arrête le poll local sans toucher au téléchargement serveur.
@@ -1510,7 +1511,7 @@ function resetDlUI(){
   const e = dlEls();
   stopDlPoll(); dlName='';
   e.prog.style.display='none'; e.bar.style.display='none';
-  e.cancel.style.display='none'; e.btn.disabled=false;
+  e.cancel.style.display='none'; e.pause.style.display='none'; e.btn.disabled=false;
 }
 // Remplit le sélecteur de destination avec les dossiers de modèles connus.
 // L'espace libre est dans le libellé de l'option : c'est l'info utile au moment
@@ -1627,6 +1628,22 @@ async function cancelDownload(){
   await jpost('/api/models/download/cancel', {filename: dlName});
   // L'état « annulé » est confirmé par le prochain tick de poll.
 }
+// Met en pause ou reprend : le fichier partiel est gardé, la reprise repart
+// de là où le transfert s'était arrêté (repris d'AJEAN v0.18.1).
+let dlPaused = false;
+async function togglePauseDownload(){
+  if(!dlName) return;
+  const e = dlEls();
+  e.pause.disabled = true;
+  try{
+    const r = await jpost('/api/models/download/pause', {filename: dlName, pause: !dlPaused});
+    if(r.ok) setDlPaused(r.paused);
+  }finally{ e.pause.disabled = false; }
+}
+function setDlPaused(p){
+  dlPaused = !!p;
+  dlEls().pause.textContent = dlPaused ? 'Reprendre' : 'Mettre en pause';
+}
 // Suit un téléchargement (nouveau ou déjà en cours) et pilote barre + texte.
 function watchDownload(fname){
   const e = dlEls();
@@ -1637,7 +1654,10 @@ function watchDownload(fname){
   e.bar.style.display = 'block';
   e.cancel.style.display = 'inline';
   e.cancel.disabled = false;
-  const stop = ()=>{ stopDlPoll(); dlName=''; e.btn.disabled=false; e.cancel.style.display='none'; };
+  e.pause.style.display = 'inline';
+  e.pause.disabled = false;
+  setDlPaused(false);
+  const stop = ()=>{ stopDlPoll(); dlName=''; e.btn.disabled=false; e.cancel.style.display='none'; e.pause.style.display='none'; };
   const tick = async ()=>{
     const list = await jget('/api/models/download/status');
     const st = (list||[]).find(d=>d.filename===fname);
@@ -1661,6 +1681,7 @@ function watchDownload(fname){
       if(dlQueue.length) startDownloadURL(dlQueue.shift());
       return;
     }
+    if(!!st.paused !== dlPaused) setDlPaused(st.paused);
     const pct = st.total>0 ? st.done*100/st.total : 0;
     if(st.total>0){
       e.bar.className = 'pe-bar';
@@ -1670,7 +1691,8 @@ function watchDownload(fname){
     }
     const tot = st.total>0 ? ' / '+fmtSize(st.total)+' ('+Math.round(pct)+'%)' : '';
     let extra = '';
-    if(st.speed>0){
+    if(st.paused) extra += ' — en pause';
+    else if(st.speed>0){
       extra += ' — '+fmtSize(st.speed)+'/s';
       if(st.total>0){
         const eta = Math.max(0, Math.round((st.total-st.done)/st.speed));

internal/loki/ui/src/js/10b-strata.js

@@ -128,7 +128,11 @@ function strataRenderSettings(fit){
     ['Experts', sel('strata-s-experts', [['auto','auto (selon la RAM libre)'],['ram','en RAM (le plus rapide)'],['disk','depuis le disque (mmap, économe)']], d.experts||'auto')],
     ['Lire les images', sw('strata-s-vision', d.vision)],
   ];
-  if(d.has_helper) rows.push(["Carte d'appoint", sw('strata-s-helper', d.helper_on)]);
+  // Seconde carte : aide aux experts (défaut mesuré) ou partage des couches,
+  // souvent plus rapide avec deux cartes identiques (#121 d'AJEAN).
+  if(d.has_helper) rows.push(['Seconde carte', sel('strata-s-helper',
+    [['off', 'non utilisée'], ['helper', 'aide aux experts'], ['layers', 'partage des couches']],
+    !d.helper_on ? 'off' : d.split_layers ? 'layers' : 'helper')]);
   document.getElementById('strata-settings').innerHTML = rows.map(([a,b])=>
     '<div class="moe-kv"><span>'+escHtml(a)+'</span><span>'+b+'</span></div>').join('');
   strataCtxLbl();
@@ -148,8 +152,11 @@ async function strataSaveSettings(){
   if(!fit || !fit.preset) return;
   const v = id => document.getElementById(id);
   const body = {preset: fit.preset, ctx: +v('strata-s-ctx').value, kv: v('strata-s-kv').value, spec: +v('strata-s-spec').value,
-    vision: v('strata-s-vision').checked, helper: v('strata-s-helper') ? v('strata-s-helper').checked : false,
+    vision: v('strata-s-vision').checked,
     experts: v('strata-s-experts') ? v('strata-s-experts').value : ''};
+  const second = v('strata-s-helper') ? v('strata-s-helper').value : 'off';
+  body.helper = second !== 'off';
+  if(body.helper) body.split = second;
   if(fit.active && !await askConfirm('Le modèle va redémarrer avec ces réglages (quelques minutes).', {title:'Strata — Qwen3.8 Flash Next', okText:'Enregistrer'})) return;
   const r = await jpost('/api/strata/settings', body);
   if(!r.ok){ toast('Erreur : '+(r.error||'')); return; }
@@ -168,14 +175,16 @@ function strataRenderDetails(fit){
   const k = n => (+n >= 1024 ? Math.round(+n/1024)+'K' : n);
   const rows = [
     ['Carte principale', d.main_gpu],
-    ["Carte d'appoint", d.helper_gpu || 'aucune'],
+    ['Seconde carte', d.helper_gpu ? d.helper_gpu + (d.split_layers ? ' · partage des couches' : ' · aide aux experts') : 'aucune'],
     ['Lecture des images', d.vision_gpu || 'aucune'],
     ['Contexte', (+d.ctx).toLocaleString('fr-FR')+' jetons'],
     ['Cache KV', d.kv + (d.kv_resident ? ' · '+k(d.kv_resident)+' en VRAM, le reste en RAM' : '')],
     ['Prédiction (MTP)', d.spec+' jetons'],
     ['Experts hors GPU', (d.mode_label || (d.mmap ? 'lus depuis le disque (mmap)' : 'chargés en RAM'))
       + (fit.active ? ' — dernier lancement' : ' — selon la RAM libre maintenant')],
-    ['Lecture des prompts', 'blocs de '+k(d.prefill)+', lecture directe sous '+d.short_read+' jetons'],
+    // paquet 1.1 : la carte d'appoint calcule ses experts à la lecture d'un prompt
+    ['Lecture des prompts', 'blocs de '+k(d.prefill)+', lecture directe sous '+d.short_read+' jetons'
+      + (d.helper_gpu && !d.split_layers ? ", experts de la carte d'appoint calculés par elle" : '')],
     ["Démarrage d'une conversation", 'reprise après le prompt système (dès '+d.cache_root+' jetons)'],
     ['Version du moteur', 'paquet AJEAN MoE '+d.version],
   ];

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

@@ -5,7 +5,47 @@
 let mcpServers = [];
 let mcpEditing = null; // nom du serveur en cours d'édition ('' ou null = nouveau)
 
-async function loadMCP(){ renderMCP(await jget('/api/mcp')); }
+async function loadMCP(){
+  renderMCP(await jget('/api/mcp'));
+  loadMcpTimeouts();
+}
+
+// ─── Délais globaux ──────────────────────────────────────────────────────────
+// Connexion et appel d'outil, communs à tous les serveurs (/api/mcp/timeouts).
+// Un seul enregistrement par modification : « change » part à la validation
+// ou à la perte du focus, pas à chaque frappe.
+let mcpTimeouts = {connect: 20, call: 120};
+
+async function loadMcpTimeouts(){
+  const r = await jget('/api/mcp/timeouts');
+  if(!r || !r.ok) return;
+  mcpTimeouts = {connect: r.connect, call: r.call};
+  document.getElementById('mcp-timeout-connect').value = r.connect;
+  document.getElementById('mcp-timeout-call').value = r.call;
+  mcpCallTimeoutPlaceholder();
+}
+
+async function saveMcpTimeouts(){
+  const connect = Number(document.getElementById('mcp-timeout-connect').value);
+  const call = Number(document.getElementById('mcp-timeout-call').value);
+  const ok = v => Number.isInteger(v) && v >= 1 && v <= 3600;
+  if(!ok(connect) || !ok(call)){
+    toast('délai invalide : de 1 à 3600 s');
+    loadMcpTimeouts(); // revient aux valeurs enregistrées
+    return;
+  }
+  const r = await jpost('/api/mcp/timeouts/save', {connect, call});
+  if(!r || !r.ok){ toast('erreur : '+((r && r.error) || 'délais non enregistrés')); loadMcpTimeouts(); return; }
+  mcpTimeouts = {connect: r.connect, call: r.call};
+  mcpCallTimeoutPlaceholder();
+  toast('délais MCP enregistrés');
+}
+
+// Le champ « délai d'un appel » de la fenêtre d'édition montre le réglage
+// global qu'il remplacerait.
+function mcpCallTimeoutPlaceholder(){
+  document.getElementById('mcp-call-timeout').placeholder = 'réglage global ('+mcpTimeouts.call+' s)';
+}
 
 function renderMCP(r){
   mcpServers = (r && r.servers) || [];
@@ -178,6 +218,7 @@ function openMcpFromCatalog(e){
       Object.entries(e.env||{}).map(([k,v])=>k+'='+v).join('\n');
     document.getElementById('mcp-url').value = '';
     document.getElementById('mcp-headers').value = '';
+    document.getElementById('mcp-call-timeout').value = '';
     document.getElementById('mcp-modal-title').textContent = e.name+' — depuis le catalogue';
   }
   const st = document.getElementById('mcp-modal-status');
@@ -205,6 +246,8 @@ function openMcp(name){
   document.getElementById('mcp-env').value = s && s.env ? Object.entries(s.env).map(([k,v])=>k+'='+v).join('\n') : '';
   document.getElementById('mcp-url').value = s ? (s.url||'') : '';
   document.getElementById('mcp-headers').value = s && s.headers ? Object.entries(s.headers).map(([k,v])=>k+': '+v).join('\n') : '';
+  document.getElementById('mcp-call-timeout').value = s && s.callTimeoutSec ? s.callTimeoutSec : '';
+  mcpCallTimeoutPlaceholder();
   const st = document.getElementById('mcp-modal-status');
   st.textContent = ''; st.style.color = '';
   if(s && s.enabled && s.error){ st.textContent = '⚠ '+s.error; st.style.color = 'var(--err)'; }
@@ -283,6 +326,13 @@ async function saveMcp(){
     body.headers = mcpParseKV(document.getElementById('mcp-headers').value, ':');
     body.command = ''; body.args = undefined; body.env = undefined;
   }
+  // Vide = réglage global (0 côté serveur).
+  const ct = document.getElementById('mcp-call-timeout').value.trim();
+  if(ct){
+    const n = Number(ct);
+    if(!Number.isInteger(n) || n < 1 || n > 3600){ toast("délai d'un appel d'outil : de 1 à 3600 s, ou vide"); return; }
+    body.callTimeoutSec = n;
+  }
   const st = document.getElementById('mcp-modal-status');
   st.textContent = 'connexion…'; st.style.color = '';
   const r = await jpost('/api/mcp/save', body);

internal/loki/web_api.go

@@ -1166,6 +1166,9 @@ type mcpSaveReq struct {
 	URL     string            `json:"url"`
 	Headers map[string]string `json:"headers"`
 	Enabled *bool             `json:"enabled"`
+	// CallTimeoutSec : délai d'un appel propre au serveur, en secondes
+	// (0 ou absent = réglage global).
+	CallTimeoutSec int `json:"callTimeoutSec"`
 }
 
 // handleMCP renvoie l'état de tous les serveurs MCP configurés (connexion tentée
@@ -1241,6 +1244,10 @@ func handleMCPSave(w http.ResponseWriter, r *http.Request) {
 		sendJSON(w, 400, map[string]any{"ok": false, "error": err.Error()})
 		return
 	}
+	if msg := mcpCallTimeoutSecError(req.CallTimeoutSec); msg != "" {
+		sendJSON(w, 400, map[string]any{"ok": false, "error": msg})
+		return
+	}
 	enabled := true
 	if req.Enabled != nil {
 		enabled = *req.Enabled
@@ -1252,6 +1259,8 @@ func handleMCPSave(w http.ResponseWriter, r *http.Request) {
 		URL:     strings.TrimSpace(req.URL),
 		Headers: req.Headers,
 		Enabled: enabled,
+
+		CallTimeoutSec: req.CallTimeoutSec,
 	}
 	if err := SetMCPServer(req.Name, cfg); err != nil {
 		sendJSON(w, 400, map[string]any{"ok": false, "error": err.Error()})
@@ -1334,6 +1343,36 @@ func handleMCPTest(w http.ResponseWriter, r *http.Request) {
 	sendJSON(w, 200, map[string]any{"ok": true, "servers": list})
 }
 
+// handleMCPTimeouts renvoie les délais MCP globaux (secondes).
+func handleMCPTimeouts(w http.ResponseWriter, r *http.Request) {
+	t := LoadMCPTimeouts()
+	sendJSON(w, 200, map[string]any{"ok": true, "connect": t.Connect, "call": t.Call})
+}
+
+// handleMCPTimeoutsSave enregistre les délais MCP globaux (1 à 3600 s) et
+// ferme les sessions ouvertes, pour que le délai de connexion s'applique dès
+// la suivante.
+func handleMCPTimeoutsSave(w http.ResponseWriter, r *http.Request) {
+	var req MCPTimeouts
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		sendJSON(w, 400, map[string]any{"ok": false, "error": err.Error()})
+		return
+	}
+	if msg := mcpTimeoutsError(req); msg != "" {
+		sendJSON(w, 400, map[string]any{"ok": false, "error": msg})
+		return
+	}
+	if err := SaveMCPTimeouts(req); err != nil {
+		sendJSON(w, 500, map[string]any{"ok": false, "error": err.Error()})
+		return
+	}
+	servers, _ := LoadMCPConfig()
+	for name := range servers {
+		mcpInvalidate(name)
+	}
+	sendJSON(w, 200, map[string]any{"ok": true, "connect": req.Connect, "call": req.Call})
+}
+
 // handleMem / handleMemSave / handleMemDelete : éditeur web des pages mémoire
 // (memory/<nom>.md). Payload partagé saveReq (name/old/content) ; "name" = nom
 // de fichier de la page.

internal/loki/web_server.go

@@ -259,6 +259,7 @@ func newWebMux() *http.ServeMux {
 	api("/api/models/download/probe", handleModelDownloadProbe) // taille + espace libre avant de lancer
 	api("/api/models/download/status", handleModelDownloadStatus)
 	api("/api/models/download/cancel", handleModelDownloadCancel)
+	api("/api/models/download/pause", handleModelDownloadPause)
 	api("/api/hf/search", handleHFSearch) // chercher un modèle GGUF sur Hugging Face
 	api("/api/hf/files", handleHFFiles)   // quants et projecteurs d'un dépôt
 	api("/api/hf/token", handleHFToken)   // jeton pour les dépôts à accès restreint
@@ -333,6 +334,8 @@ func newWebMux() *http.ServeMux {
 	api("/api/mcp/toggle", handleMCPToggle)
 	api("/api/mcp/tool", handleMCPTool)
 	api("/api/mcp/test", handleMCPTest)
+	api("/api/mcp/timeouts", handleMCPTimeouts)
+	api("/api/mcp/timeouts/save", handleMCPTimeoutsSave)
 	api("/api/memory", handleMemoryMode)
 	// Tâches planifiées : l'IA exécute des consignes toute seule sur une fréquence
 	// réglable (tasks.go). Le planificateur tourne dans CE process — celui qui

rust/loki-rs/src/downloads.rs

@@ -3,7 +3,7 @@
 //! `backend_model_dirs.go` et `backend_hf.go` (lot 8 de la migration).
 //!
 //! Tenus par la façade quand `LOKI_MODELS=rust` (expérimental ; le Go
-//! par défaut) : `POST /api/models/download`, `/probe`, `/cancel`,
+//! par défaut) : `POST /api/models/download`, `/probe`, `/cancel`, `/pause`,
 //! `GET /api/models/download/status`. Le Go remet alors à la façade ces
 //! routes quand elles lui arrivent par le tunnel du relais, et ne vide plus
 //! les `.part` au démarrage (c'est la façade qui le fait).
@@ -71,6 +71,7 @@ pub fn handles(path: &str) -> bool {
             | "/api/models/download/probe"
             | "/api/models/download/status"
             | "/api/models/download/cancel"
+            | "/api/models/download/pause"
     )
 }
 
@@ -519,6 +520,7 @@ pub struct DlState {
     pub part: i64,
     pub finished: bool,
     pub canceled: bool,
+    pub paused: bool,
     #[serde(rename = "error")]
     pub err: String,
     pub started_at: i64,
@@ -527,6 +529,8 @@ pub struct DlState {
 struct Entry {
     state: Mutex<DlState>,
     cancel: watch::Sender<bool>,
+    /// `dlGate` : vrai pendant une pause.
+    pause: watch::Sender<bool>,
 }
 
 impl Entry {
@@ -549,6 +553,37 @@ impl Stop {
     }
 }
 
+/// `dlGate` : la pause d'un téléchargement. Les requêtes en cours sont
+/// coupées (rien ne reste ouvert vers le CDN pendant la pause), et chaque
+/// morceau attend la reprise puis repart de l'octet où il s'était arrêté, par
+/// une requête de plage.
+#[derive(Clone)]
+struct Gate(watch::Receiver<bool>);
+
+impl Gate {
+    fn is_paused(&self) -> bool {
+        *self.0.borrow()
+    }
+    /// Attend la reprise ; `false` : annulé entre-temps.
+    async fn wait(&self, stop: &Stop) -> bool {
+        if self.is_paused() {
+            let mut rx = self.0.clone();
+            tokio::select! {
+                _ = rx.wait_for(|p| !*p) => {}
+                _ = stop.wait() => return false,
+            }
+        }
+        !stop.is_set()
+    }
+    /// Se résout quand la pause tombe (jamais si l'émetteur a disparu).
+    async fn paused(&self) {
+        let mut rx = self.0.clone();
+        if rx.wait_for(|p| *p).await.is_err() {
+            std::future::pending::<()>().await;
+        }
+    }
+}
+
 /// Ce qu'un téléchargement doit savoir de la machine.
 #[derive(Clone)]
 pub struct DlEnv {
@@ -615,6 +650,28 @@ impl Downloads {
         }
     }
 
+    /// `handleModelDownloadPause` : met en pause ou reprend ; `false` :
+    /// inconnu ou terminé. Le fichier partiel est gardé.
+    pub fn pause(&self, name: &str, paused: bool) -> bool {
+        let Some(e) = self.map().get(name).cloned() else {
+            return false;
+        };
+        let running = e.with(|s| {
+            if s.finished {
+                return false;
+            }
+            s.paused = paused;
+            if paused {
+                s.speed = 0;
+            }
+            true
+        });
+        if running {
+            let _ = e.pause.send_replace(paused);
+        }
+        running
+    }
+
     fn request(&self, env: &DlEnv, url: &str, range: Option<&str>) -> reqwest::RequestBuilder {
         let mut rb = self
             .client
@@ -722,6 +779,7 @@ impl Downloads {
             );
         }
         let (tx, rx) = watch::channel(false);
+        let (pause_tx, pause_rx) = watch::channel(false);
         let entry = Arc::new(Entry {
             state: Mutex::new(DlState {
                 filename: name.clone(),
@@ -732,12 +790,14 @@ impl Downloads {
                 ..Default::default()
             }),
             cancel: tx,
+            pause: pause_tx,
         });
         map.insert(name.clone(), entry.clone());
         drop(map);
         let parts = todo.len();
         let me = self.clone();
-        tokio::spawn(async move { me.run_set(env, entry, Stop(rx), todo).await });
+        let gate = Gate(pause_rx);
+        tokio::spawn(async move { me.run_set(env, entry, Stop(rx), gate, todo).await });
         (
             StatusCode::OK,
             json!({ "ok": true, "filename": name, "parts": parts }),
@@ -752,6 +812,7 @@ impl Downloads {
         env: DlEnv,
         entry: Arc<Entry>,
         stop: Stop,
+        gate: Gate,
         todo: Vec<(String, String)>,
     ) {
         let done = Arc::new(AtomicI64::new(0));
@@ -812,7 +873,9 @@ impl Downloads {
                     let dt = now.duration_since(last_at).as_secs_f64();
                     entry.with(|s| {
                         s.done = cur;
-                        if dt > 0.0 {
+                        if s.paused {
+                            s.speed = 0;
+                        } else if dt > 0.0 {
                             let inst = ((cur - last) as f64 / dt) as i64;
                             s.speed = if s.speed == 0 {
                                 inst
@@ -829,7 +892,7 @@ impl Downloads {
         for (i, ((u, dest), (total, ranged))) in todo.iter().zip(sizes).enumerate() {
             entry.with(|s| s.part = i as i64 + 1);
             if let Err(h) = self
-                .one_part(&env, &entry, &stop, u, dest, total, ranged, &done)
+                .one_part(&env, &entry, &stop, &gate, u, dest, total, ranged, &done)
                 .await
             {
                 ticker.abort();
@@ -851,6 +914,7 @@ impl Downloads {
         env: &DlEnv,
         entry: &Entry,
         stop: &Stop,
+        gate: &Gate,
         url: &str,
         dest: &str,
         total: i64,
@@ -877,7 +941,7 @@ impl Downloads {
             path: tmp.clone(),
         });
         let res = if conns <= 1 {
-            self.chunk(env, stop, &file, url, 0, total - 1, total <= 0, done)
+            self.chunk(env, stop, gate, &file, url, 0, total - 1, total <= 0, done)
                 .await
         } else {
             let size = total / conns as i64;
@@ -888,7 +952,7 @@ impl Downloads {
                 } else {
                     start + size - 1
                 };
-                self.chunk(env, stop, &file, url, start, end, false, done)
+                self.chunk(env, stop, gate, &file, url, start, end, false, done)
             });
             futures_util::future::join_all(parts)
                 .await
@@ -918,6 +982,7 @@ impl Downloads {
         &self,
         env: &DlEnv,
         stop: &Stop,
+        gate: &Gate,
         file: &Arc<PartFile>,
         url: &str,
         start: i64,
@@ -927,7 +992,13 @@ impl Downloads {
     ) -> Result<(), Halt> {
         let mut pos = start;
         let mut last_err = String::new();
-        for attempt in 0..DL_ATTEMPTS {
+        let mut attempt: u64 = 0;
+        while attempt < DL_ATTEMPTS {
+            // Une pause n'est pas un échec : on attend la reprise sans
+            // consommer d'essai.
+            if !gate.wait(stop).await {
+                return Err(Halt::Canceled);
+            }
             if stop.is_set() {
                 return Err(Halt::Canceled);
             }
@@ -948,13 +1019,16 @@ impl Downloads {
                 None
             };
             let resp = tokio::select! {
-                r = self.request(env, url, range.as_deref()).send() => r,
+                r = self.request(env, url, range.as_deref()).send() => r.map_err(|e| e.to_string()),
                 _ = stop.wait() => return Err(Halt::Canceled),
+                _ = gate.paused() => Err("en pause".to_string()),
             };
             let resp = match resp {
                 Ok(r) => r,
+                Err(_) if gate.is_paused() && !stop.is_set() => continue,
                 Err(e) => {
-                    last_err = e.to_string();
+                    last_err = e;
+                    attempt += 1;
                     continue;
                 }
             };
@@ -967,7 +1041,7 @@ impl Downloads {
                 done.fetch_add(start - pos, Ordering::Relaxed);
                 pos = start;
             }
-            match copy_at(stop, file, resp, pos, done).await {
+            match copy_at(stop, gate, file, resp, pos, done).await {
                 (n, Ok(())) => {
                     let _ = n;
                     return Ok(());
@@ -975,7 +1049,12 @@ impl Downloads {
                 (_, Err(Halt::Canceled)) => return Err(Halt::Canceled),
                 (n, Err(Halt::Err(e))) => {
                     pos += n;
+                    // coupé par la pause : la reprise repart de pos
+                    if gate.is_paused() && !stop.is_set() {
+                        continue;
+                    }
                     last_err = e;
+                    attempt += 1;
                 }
             }
         }
@@ -987,6 +1066,7 @@ impl Downloads {
 /// même en cas d'erreur (pour reprendre).
 async fn copy_at(
     stop: &Stop,
+    gate: &Gate,
     file: &Arc<PartFile>,
     resp: reqwest::Response,
     off: i64,
@@ -999,6 +1079,17 @@ async fn copy_at(
         let next = tokio::select! {
             n = stream.next() => n,
             _ = stop.wait() => return (written, Err(Halt::Canceled)),
+            _ = gate.paused() => {
+                // pause : ce qui est reçu est écrit, le flux est coupé
+                return match flush(file, &mut buf, off + written).await {
+                    Ok(k) => {
+                        written += k;
+                        done.fetch_add(k, Ordering::Relaxed);
+                        (written, Err(Halt::Err("en pause".into())))
+                    }
+                    Err(we) => (written, Err(Halt::Err(we))),
+                };
+            }
         };
         let eof = next.is_none();
         match next {
@@ -1186,6 +1277,22 @@ pub async fn serve(
                 )
             }
         }
+        "/api/models/download/pause" => {
+            let v = match body_json(body).await {
+                Ok(v) => v,
+                Err(e) => return bad(e),
+            };
+            let name = filepath_base(str_of(&v, "filename").trim());
+            let paused = v.get("pause").and_then(Value::as_bool).unwrap_or(false);
+            if dl.pause(&name, paused) {
+                send_json(StatusCode::OK, &json!({ "ok": true, "paused": paused }))
+            } else {
+                send_json(
+                    StatusCode::NOT_FOUND,
+                    &json!({ "ok": false, "error": format!("aucun téléchargement en cours pour {name}") }),
+                )
+            }
+        }
         "/api/models/download" => {
             let v = match body_json(body).await {
                 Ok(v) => v,

rust/loki-rs/src/mcp/config.rs

@@ -26,7 +26,7 @@ pub struct ServerConfig {
     #[serde(rename = "disabledTools", skip_serializing_if = "Vec::is_empty")]
     pub disabled_tools: Vec<String>,
     /// `CallTimeoutSec` : délai d'un appel d'outil de ce serveur, en
-    /// secondes ; 0 = défaut ([`CALL_TIMEOUT`]).
+    /// secondes ; 0 = réglage global ([`Timeouts::call`]).
     #[serde(rename = "callTimeoutSec", skip_serializing_if = "is_zero")]
     pub call_timeout_sec: i64,
 }
@@ -285,21 +285,107 @@ pub fn prompt_line(tools: &[(String, String)]) -> String {
     )
 }
 
-/// `mcpConnectTimeout`.
-pub const CONNECT_TIMEOUT: Duration = Duration::from_secs(20);
 /// `mcpConnectTimeoutCold` : npx et uvx téléchargent le paquet au premier
-/// lancement.
+/// lancement ; un minimum, un délai de connexion réglé plus long l'emporte.
 pub const CONNECT_TIMEOUT_COLD: Duration = Duration::from_secs(180);
-/// `mcpCallTimeout`.
-pub const CALL_TIMEOUT: Duration = Duration::from_secs(120);
+/// `mcpTimeoutMaxSec` : borne haute des réglages (1 h).
+pub const TIMEOUT_MAX_SECS: i64 = 3600;
 /// `mcpCallTimeoutMax` : plafond d'un appel, quoi que demandent l'outil ou la
-/// config.
-pub const CALL_TIMEOUT_MAX: Duration = Duration::from_secs(30 * 60);
+/// config ; il suit la borne des réglages.
+pub const CALL_TIMEOUT_MAX: Duration = Duration::from_secs(TIMEOUT_MAX_SECS as u64);
+/// `mcpTimeoutsKey` : clé des délais globaux (`state/mcp_timeouts`).
+pub const ST_TIMEOUTS: &str = "mcp_timeouts";
 
-/// `mcpCallTimeoutFor` : [`CALL_TIMEOUT`], remplacé par `callTimeoutSec` du
+/// `MCPTimeouts` : les délais globaux, en secondes (`mcp_timeouts.go`).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Timeouts {
+    pub connect: i64,
+    pub call: i64,
+}
+
+impl Default for Timeouts {
+    /// 20 s de connexion, 120 s d'appel.
+    fn default() -> Self {
+        Timeouts {
+            connect: 0,
+            call: 0,
+        }
+        .normalized()
+    }
+}
+
+impl Timeouts {
+    /// `normalized` : nul ou négatif = défaut, au-delà de la borne = la borne.
+    pub fn normalized(self) -> Self {
+        let fix = |v: i64, def: i64| if v <= 0 { def } else { v.min(TIMEOUT_MAX_SECS) };
+        Timeouts {
+            connect: fix(self.connect, 20),
+            call: fix(self.call, 120),
+        }
+    }
+
+    pub fn connect(&self) -> Duration {
+        Duration::from_secs(self.connect.max(0) as u64)
+    }
+
+    pub fn call(&self) -> Duration {
+        Duration::from_secs(self.call.max(0) as u64)
+    }
+
+    /// `json.Marshal(MCPTimeouts)`.
+    pub fn marshal(&self) -> String {
+        format!(r#"{{"connect":{},"call":{}}}"#, self.connect, self.call)
+    }
+}
+
+/// Le type Go décodé (`MCPTimeouts`) et ses champs, pour [`crate::gojson`].
+pub const TIMEOUTS_TYPE: &str = "MCPTimeouts";
+pub const TIMEOUTS_FIELDS: [(&str, crate::gojson::Kind); 2] = [
+    ("connect", crate::gojson::Kind::Int),
+    ("call", crate::gojson::Kind::Int),
+];
+
+/// `LoadMCPTimeouts` : `getJSON` puis normalisation. Une valeur que
+/// `json.Unmarshal` refuse, même en partie, donne les défauts.
+pub fn decode_timeouts(raw: Option<&[u8]>) -> Timeouts {
+    let raw = raw.unwrap_or_default();
+    if raw.is_empty() || serde_json::from_slice::<Value>(raw).is_err() {
+        return Timeouts::default();
+    }
+    let d = crate::gojson::decode_struct(raw, TIMEOUTS_TYPE, &TIMEOUTS_FIELDS);
+    if d.err.is_some() {
+        return Timeouts::default();
+    }
+    Timeouts {
+        connect: d.int("connect"),
+        call: d.int("call"),
+    }
+    .normalized()
+}
+
+/// `mcpTimeoutsError` : le refus d'un réglage hors bornes.
+pub fn timeouts_error(t: &Timeouts) -> Option<&'static str> {
+    if !(1..=TIMEOUT_MAX_SECS).contains(&t.connect) {
+        return Some("connexion : 1 à 3600 s");
+    }
+    if !(1..=TIMEOUT_MAX_SECS).contains(&t.call) {
+        return Some("appel d'outil : 1 à 3600 s");
+    }
+    None
+}
+
+/// `mcpCallTimeoutSecError` : le refus d'un délai par serveur hors bornes.
+pub fn call_timeout_sec_error(sec: i64) -> Option<&'static str> {
+    if !(0..=TIMEOUT_MAX_SECS).contains(&sec) {
+        return Some("délai d'un appel : 0 à 3600 s (vide = réglage global)");
+    }
+    None
+}
+
+/// `mcpCallTimeoutFor` : le réglage global, remplacé par `callTimeoutSec` du
 /// serveur ; un argument `timeout` de l'outil l'allonge de 30 s.
-pub fn call_timeout_for(cfg: &ServerConfig, args: &Map<String, Value>) -> Duration {
-    let mut d = CALL_TIMEOUT;
+pub fn call_timeout_for(cfg: &ServerConfig, tm: &Timeouts, args: &Map<String, Value>) -> Duration {
+    let mut d = tm.call();
     if cfg.call_timeout_sec > 0 {
         d = Duration::from_secs(cfg.call_timeout_sec as u64);
     }
@@ -354,23 +440,27 @@ fn launcher(cfg: &ServerConfig) -> String {
     b.strip_suffix(".cmd").unwrap_or(b).to_string()
 }
 
-/// `mcpTimeoutFor`.
-pub fn timeout_for(cfg: &ServerConfig) -> Duration {
+/// `mcpTimeoutFor` : le réglage global, au moins [`CONNECT_TIMEOUT_COLD`]
+/// pour npx et uvx.
+pub fn timeout_for(cfg: &ServerConfig, tm: &Timeouts) -> Duration {
     match launcher(cfg).as_str() {
-        "npx" | "uvx" => CONNECT_TIMEOUT_COLD,
-        _ => CONNECT_TIMEOUT,
+        "npx" | "uvx" => tm.connect().max(CONNECT_TIMEOUT_COLD),
+        _ => tm.connect(),
     }
 }
 
 /// `mcpFriendlyErr` pour un délai dépassé.
-pub fn timeout_error(cfg: &ServerConfig) -> String {
+pub fn timeout_error(cfg: &ServerConfig, tm: &Timeouts) -> String {
     let l = launcher(cfg);
     if l == "npx" || l == "uvx" {
         return format!(
             "délai dépassé — {l} 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)"
         );
     }
-    "délai dépassé — le serveur n'a pas répondu au handshake en 20s".into()
+    format!(
+        "délai dépassé — le serveur n'a pas répondu au handshake en {} (délai de connexion réglable dans les réglages MCP)",
+        crate::tools::shell::go_duration(tm.connect())
+    )
 }
 
 /// `mcpOutputCap` : environ un caractère par jeton de contexte, jamais sous
@@ -534,20 +624,24 @@ mod tests {
         };
         let s = Duration::from_secs;
         let none = Map::new();
-        assert_eq!(call_timeout_for(&cfg(0), &none), CALL_TIMEOUT);
-        assert_eq!(call_timeout_for(&cfg(600), &none), s(600));
-        assert_eq!(call_timeout_for(&cfg(0), &args(json!(300.0))), s(330));
-        assert_eq!(call_timeout_for(&cfg(0), &args(json!(200000.0))), s(230));
+        let def = Timeouts::default();
+        let ct = |c: &ServerConfig, a: &Map<String, Value>| call_timeout_for(c, &def, a);
+        assert_eq!(ct(&cfg(0), &none), s(120));
+        assert_eq!(ct(&cfg(600), &none), s(600));
+        assert_eq!(ct(&cfg(0), &args(json!(300.0))), s(330));
+        assert_eq!(ct(&cfg(0), &args(json!(200000.0))), s(230));
+        assert_eq!(ct(&cfg(0), &args(json!(5000.0))), s(120));
+        assert_eq!(ct(&cfg(0), &args(json!("400"))), s(430));
         assert_eq!(
-            call_timeout_for(&cfg(0), &args(json!(5000.0))),
-            CALL_TIMEOUT
-        );
-        assert_eq!(call_timeout_for(&cfg(0), &args(json!("400"))), s(430));
-        assert_eq!(
-            call_timeout_for(&cfg(0), &args(json!(86400.0 * 1000.0))),
+            ct(&cfg(0), &args(json!(86400.0 * 1000.0))),
             CALL_TIMEOUT_MAX
         );
-        assert_eq!(call_timeout_for(&cfg(30), &none), s(30));
+        assert_eq!(ct(&cfg(30), &none), s(30));
+        // Le réglage global, remplacé par celui du serveur, jamais rogné.
+        let tm = |call| Timeouts { connect: 20, call };
+        assert_eq!(call_timeout_for(&cfg(0), &tm(45), &none), s(45));
+        assert_eq!(call_timeout_for(&cfg(90), &tm(45), &none), s(90));
+        assert_eq!(call_timeout_for(&cfg(0), &tm(3600), &none), s(3600));
         assert_eq!(
             call_deadline_error(s(330)),
             "[erreur MCP] pas de réponse après 5m30s (délai de l'appel ; un argument timeout plus grand l'allonge)"
@@ -577,9 +671,41 @@ mod tests {
             command: cmd.into(),
             ..Default::default()
         };
-        assert_eq!(timeout_for(&c("/usr/bin/npx")), CONNECT_TIMEOUT_COLD);
-        assert_eq!(timeout_for(&c("UVX.EXE")), CONNECT_TIMEOUT_COLD);
-        assert_eq!(timeout_for(&c("npx.cmd")), CONNECT_TIMEOUT_COLD);
-        assert_eq!(timeout_for(&c("node")), CONNECT_TIMEOUT);
+        let def = Timeouts::default();
+        assert_eq!(timeout_for(&c("/usr/bin/npx"), &def), CONNECT_TIMEOUT_COLD);
+        assert_eq!(timeout_for(&c("UVX.EXE"), &def), CONNECT_TIMEOUT_COLD);
+        assert_eq!(timeout_for(&c("npx.cmd"), &def), CONNECT_TIMEOUT_COLD);
+        assert_eq!(timeout_for(&c("node"), &def), Duration::from_secs(20));
+        // Un délai réglé plus long que le minimum des lanceurs l'emporte.
+        let long = Timeouts {
+            connect: 600,
+            call: 120,
+        };
+        assert_eq!(timeout_for(&c("npx"), &long), Duration::from_secs(600));
+        assert_eq!(timeout_for(&c("node"), &long), Duration::from_secs(600));
+    }
+
+    #[test]
+    fn delais_globaux() {
+        let d = |raw: &str| decode_timeouts(Some(raw.as_bytes()));
+        let t = |connect, call| Timeouts { connect, call };
+        assert_eq!(decode_timeouts(None), t(20, 120));
+        assert_eq!(d(r#"{"connect":5,"call":300}"#), t(5, 300));
+        assert_eq!(d(r#"{"connect":0,"call":0}"#), t(20, 120));
+        assert_eq!(d(r#"{"connect":-4,"call":99999}"#), t(20, 3600));
+        assert_eq!(d(r#"{"connect":"x","call":50}"#), t(20, 120));
+        assert_eq!(d(r#"{"CONNECT":7}"#), t(7, 120));
+        assert_eq!(d("null"), t(20, 120));
+        assert_eq!(d(r#"{"connect":30,"call":40} reste"#), t(20, 120));
+        assert_eq!(t(30, 600).marshal(), r#"{"connect":30,"call":600}"#);
+        assert_eq!(timeouts_error(&t(0, 120)), Some("connexion : 1 à 3600 s"));
+        assert_eq!(
+            timeouts_error(&t(20, 3601)),
+            Some("appel d'outil : 1 à 3600 s")
+        );
+        assert_eq!(timeouts_error(&t(3600, 1)), None);
+        assert!(call_timeout_sec_error(-1).is_some());
+        assert!(call_timeout_sec_error(0).is_none());
+        assert!(call_timeout_sec_error(3601).is_some());
     }
 }

rust/loki-rs/src/mcp/mod.rs

@@ -29,7 +29,7 @@ use crate::gojson::{self, Kind};
 use crate::proxy::Body;
 use crate::store::{BK_STATE, Store};
 use client::Session;
-use config::{ServerConfig, Servers};
+use config::{ServerConfig, Servers, Timeouts};
 
 /// Clé de la configuration (`state/mcp`).
 pub const ST_MCP: &str = "mcp";
@@ -108,6 +108,26 @@ impl Mcp {
         Ok(())
     }
 
+    /// `SaveMCPTimeouts` puis la fermeture des sessions des serveurs
+    /// configurés : le nouveau délai de connexion vaut dès la suivante.
+    async fn save_timeouts(&self, store: &Store, t: Timeouts) -> Result<(), String> {
+        let names: Vec<String> = {
+            let _g = self.cfg_lock.lock().await;
+            store
+                .put(
+                    BK_STATE,
+                    config::ST_TIMEOUTS,
+                    t.normalized().marshal().into_bytes(),
+                )
+                .await?;
+            Self::load(store).await.keys().cloned().collect()
+        };
+        for name in names {
+            self.invalidate(&name).await;
+        }
+        Ok(())
+    }
+
     /// `mcpInvalidate` : la session du serveur fermée et oubliée, ses outils
     /// retirés du registre.
     pub async fn invalidate(&self, name: &str) {
@@ -136,8 +156,27 @@ impl Mcp {
         }
     }
 
-    /// `ensure` : la session du serveur, connectée ou en erreur.
-    async fn ensure(&self, name: &str, cfg: &ServerConfig, version: &str) -> Arc<Slot> {
+    /// `LoadMCPTimeouts` : les délais globaux (`state/mcp_timeouts`).
+    pub async fn timeouts(store: &Store) -> Timeouts {
+        config::decode_timeouts(
+            store
+                .get(BK_STATE, config::ST_TIMEOUTS)
+                .await
+                .ok()
+                .flatten()
+                .as_deref(),
+        )
+    }
+
+    /// `ensure` : la session du serveur, connectée ou en erreur. Le délai de
+    /// connexion est lu au moment de se connecter.
+    async fn ensure(
+        &self,
+        store: &Store,
+        name: &str,
+        cfg: &ServerConfig,
+        version: &str,
+    ) -> Arc<Slot> {
         let slot = lock(&self.slots)
             .entry(name.to_string())
             .or_insert_with(|| {
@@ -150,14 +189,15 @@ impl Mcp {
         slot.state
             .get_or_init(|| async {
                 let cfg = &slot.cfg;
+                let tm = Self::timeouts(store).await;
                 let mut st = SlotState::default();
                 let work = async {
                     let sess = Session::connect(cfg, version).await?;
                     let tools = sess.list_tools().await;
                     Ok::<_, String>((sess, tools))
                 };
-                match tokio::time::timeout(config::timeout_for(cfg), work).await {
-                    Err(_) => st.err = Some(config::timeout_error(cfg)),
+                match tokio::time::timeout(config::timeout_for(cfg, &tm), work).await {
+                    Err(_) => st.err = Some(config::timeout_error(cfg, &tm)),
                     Ok(Err(e)) => st.err = Some(e),
                     Ok(Ok((sess, tools))) => {
                         match tools {
@@ -191,12 +231,12 @@ impl Mcp {
     }
 
     /// `mcpEnsureAll` : les serveurs activés connectés en parallèle.
-    async fn ensure_all(&self, servers: &Servers, version: &str) {
+    async fn ensure_all(&self, store: &Store, servers: &Servers, version: &str) {
         join_all(
             servers
                 .iter()
                 .filter(|(_, c)| c.enabled && !c.transport().is_empty())
-                .map(|(n, c)| self.ensure(n, c, version)),
+                .map(|(n, c)| self.ensure(store, n, c, version)),
         )
         .await;
     }
@@ -208,13 +248,13 @@ impl Mcp {
         if servers.is_empty() {
             return Vec::new();
         }
-        self.ensure_all(&servers, version).await;
+        self.ensure_all(store, &servers, version).await;
         let mut out = Vec::new();
         for (name, cfg) in &servers {
             if !cfg.enabled || cfg.transport().is_empty() {
                 continue;
             }
-            let slot = self.ensure(name, cfg, version).await;
+            let slot = self.ensure(store, name, cfg, version).await;
             let Some(st) = slot.state.get() else { continue };
             if st.sess.is_none() {
                 continue;
@@ -255,8 +295,11 @@ impl Mcp {
         };
         let cap = config::output_cap(config::ctx_window(&store.config().await));
         let servers = Self::load(store).await;
-        let timeout =
-            config::call_timeout_for(&servers.get(&server).cloned().unwrap_or_default(), args);
+        let timeout = config::call_timeout_for(
+            &servers.get(&server).cloned().unwrap_or_default(),
+            &Self::timeouts(store).await,
+            args,
+        );
         let mut err = match self.call_once(&server, &tool, args, cap, timeout).await {
             Ok(r) => return r,
             Err(e) => e,
@@ -266,7 +309,7 @@ impl Mcp {
         }
         if let Some(cfg) = servers.get(&server).filter(|c| c.enabled) {
             self.invalidate(&server).await;
-            self.ensure(&server, cfg, version).await;
+            self.ensure(store, &server, cfg, version).await;
             match self.call_once(&server, &tool, args, cap, timeout).await {
                 Ok(r) => return r,
                 Err(e) => err = e,
@@ -307,7 +350,7 @@ impl Mcp {
     /// activés.
     pub async fn status(&self, store: &Store, version: &str) -> Vec<Value> {
         let servers = Self::load(store).await;
-        self.ensure_all(&servers, version).await;
+        self.ensure_all(store, &servers, version).await;
         let mut out = Vec::new();
         for (name, cfg) in &servers {
             let mut st = json!({
@@ -324,11 +367,13 @@ impl Mcp {
                 ("env", json!(cfg.env)),
                 ("url", json!(cfg.url)),
                 ("headers", json!(cfg.headers)),
+                ("callTimeoutSec", json!(cfg.call_timeout_sec)),
             ] {
                 let empty = match &v {
                     Value::String(s) => s.is_empty(),
                     Value::Array(a) => a.is_empty(),
                     Value::Object(o) => o.is_empty(),
+                    Value::Number(n) => n.as_i64() == Some(0),
                     _ => false,
                 };
                 if !empty {
@@ -336,7 +381,7 @@ impl Mcp {
                 }
             }
             if cfg.enabled && !cfg.transport().is_empty() {
-                let slot = self.ensure(name, cfg, version).await;
+                let slot = self.ensure(store, name, cfg, version).await;
                 if let Some(s) = slot.state.get() {
                     if s.sess.is_some() {
                         st["connected"] = json!(true);
@@ -367,7 +412,7 @@ impl Mcp {
             }
             let servers = Self::load(&store).await;
             if !servers.is_empty() {
-                me.ensure_all(&servers, &version).await;
+                me.ensure_all(&store, &servers, &version).await;
             }
         });
     }
@@ -494,6 +539,8 @@ pub fn handles(path: &str) -> bool {
             | "/api/mcp/toggle"
             | "/api/mcp/tool"
             | "/api/mcp/test"
+            | "/api/mcp/timeouts"
+            | "/api/mcp/timeouts/save"
     )
 }
 
@@ -562,11 +609,16 @@ pub async fn serve(
                     ("url", Kind::Str),
                     ("headers", Kind::StrMap),
                     ("enabled", Kind::OptBool),
+                    ("callTimeoutSec", Kind::Int),
                 ],
             );
             if let Some(e) = d.err.clone() {
                 return fail(StatusCode::BAD_REQUEST, e);
             }
+            let call_timeout_sec = d.int("callTimeoutSec");
+            if let Some(e) = config::call_timeout_sec_error(call_timeout_sec) {
+                return fail(StatusCode::BAD_REQUEST, e);
+            }
             let cfg = ServerConfig {
                 command: d.str("command").trim().to_string(),
                 args: d.str_list("args").unwrap_or_default(),
@@ -579,7 +631,7 @@ pub async fn serve(
                     .collect(),
                 enabled: d.opt_bool("enabled").unwrap_or(true),
                 disabled_tools: Vec::new(),
-                call_timeout_sec: 0,
+                call_timeout_sec,
             };
             let name = d.str("name");
             let res = mcp
@@ -654,6 +706,34 @@ pub async fn serve(
             mcp.invalidate(&d.str("name")).await;
             servers_ok(mcp.status(store, &version).await)
         }
+        "/api/mcp/timeouts" => {
+            let t = Mcp::timeouts(store).await;
+            send_json(
+                StatusCode::OK,
+                &json!({ "ok": true, "connect": t.connect, "call": t.call }),
+            )
+        }
+        "/api/mcp/timeouts/save" => {
+            let raw = read_body(body).await;
+            let d = gojson::decode_struct(&raw, config::TIMEOUTS_TYPE, &config::TIMEOUTS_FIELDS);
+            if let Some(e) = d.err.clone() {
+                return fail(StatusCode::BAD_REQUEST, e);
+            }
+            let t = Timeouts {
+                connect: d.int("connect"),
+                call: d.int("call"),
+            };
+            if let Some(e) = config::timeouts_error(&t) {
+                return fail(StatusCode::BAD_REQUEST, e);
+            }
+            match mcp.save_timeouts(store, t).await {
+                Ok(()) => send_json(
+                    StatusCode::OK,
+                    &json!({ "ok": true, "connect": t.connect, "call": t.call }),
+                ),
+                Err(e) => fail(StatusCode::INTERNAL_SERVER_ERROR, e),
+            }
+        }
         _ => fail(StatusCode::NOT_FOUND, "route inconnue"),
     }
 }

rust/loki-rs/src/strata/api.rs

@@ -345,7 +345,7 @@ impl Strata {
             "mmap": mode == "disk" || mode == "arena", "drop": mode == "drop",
             "experts": experts, "mode_label": experts_label(&mode), "mode": mode,
             "main_gpu": main_gpu,
-            "has_helper": false, "helper_on": false,
+            "has_helper": false, "helper_on": false, "split_layers": false,
         });
         let kvr = val("--kv-resident");
         if !kvr.is_empty() {
@@ -356,6 +356,7 @@ impl Strata {
             d["has_helper"] = json!(true);
             if helper_on(&pc) {
                 d["helper_on"] = json!(true);
+                d["split_layers"] = json!(layer_split(&pc));
                 let hg = gpu_name(h);
                 if !hg.is_empty() {
                     d["helper_gpu"] = json!(hg);
@@ -825,6 +826,7 @@ pub async fn serve(
                     ("vision", Kind::Bool),
                     ("helper", Kind::Bool),
                     ("experts", Kind::Str),
+                    ("split", Kind::Str),
                 ],
             );
             if let Some(e) = d.err.clone() {
@@ -838,6 +840,7 @@ pub async fn serve(
                 vision: d.bool("vision"),
                 helper: d.bool("helper"),
                 experts: d.str("experts"),
+                split: d.str("split"),
             };
             if r.preset.contains(['/', '\\']) || r.preset.is_empty() {
                 return fail(StatusCode::BAD_REQUEST, "preset invalide");

rust/loki-rs/src/strata/mod.rs

@@ -19,24 +19,27 @@ use std::path::{Path, PathBuf};
 
 use serde_json::{Map, Value, json};
 
-/// Paquet figé (release moe-v1.0 d'AJEAN).
-pub const VERSION: &str = "1.0";
-pub const RELEASE_BASE: &str = "https://github.com/nathaninline/ajean/releases/download/moe-v1.0/";
-pub const SRC_ASSET: &str = "ajean-moe-src-1.0.tar.gz";
-pub const ENGINE_ASSET: &str = "ajean-moe-engine-1.0-linux-x64-cuda12.zip";
+/// Paquet figé (release moe-v1.1 d'AJEAN : experts de la carte d'aide
+/// calculés par elle à la lecture des prompts). Un modèle installé avec la
+/// 1.0 passe à la 1.1 à son premier lancement (`strataMigrate`, côté Go :
+/// `loki serve` d'un preset Strata reste au Go).
+pub const VERSION: &str = "1.1";
+pub const RELEASE_BASE: &str = "https://github.com/nathaninline/ajean/releases/download/moe-v1.1/";
+pub const SRC_ASSET: &str = "ajean-moe-src-1.1.tar.gz";
+pub const ENGINE_ASSET: &str = "ajean-moe-engine-1.1-linux-x64-cuda12.zip";
 /// Le nom sous lequel l'installeur attend le moteur (CUDA12_ASSET).
 pub const ENGINE_LOCAL: &str = "strata-linux-x64-cuda12.zip";
 
-/// `strataAssetSHA`.
+/// `strataAssetSHA` (celles qu'AJEAN publie pour moe-v1.1).
 pub fn default_asset_sha() -> HashMap<String, String> {
     HashMap::from([
         (
             SRC_ASSET.to_string(),
-            "5747f69426973d957e4f9894a8e3333c6ef0d6ac8565e26ddb8d36f52211cb3b".to_string(),
+            "5a72a90f2182ff0ccab2bdbd7cff15598a21ad94501aa19de2b1b18e2dbc8115".to_string(),
         ),
         (
             ENGINE_ASSET.to_string(),
-            "b5851bc138ab32ca3ffefc16bf91c8f557e4d503503473a22f2b6c9e9b8fd34c".to_string(),
+            "8c717206ee90120f967445169dc39bb11beffdad3d592c75ae08f75bec72f0d3".to_string(),
         ),
     ])
 }
@@ -137,7 +140,11 @@ pub fn quant(id: &str) -> Option<Quant> {
 }
 
 pub const LOW_RAM_HEADROOM_GB: f64 = 10.0;
-pub const DROP_HEADROOM_GB: f64 = 7.0;
+/// `strataDropHeadroomGB` (le moteur 1.1 prend ~1 Go de plus que la 1.0).
+pub const DROP_HEADROOM_GB: f64 = 8.0;
+/// `strataDropMaxCtx` : contexte maximal en mode hors RAM (le cache KV
+/// au-delà de la part en VRAM est verrouillé en RAM).
+pub const DROP_MAX_CTX: i64 = 131072;
 
 /// `strataHelperExpertsGB`.
 pub fn helper_experts_gb(vram_gb: f64) -> f64 {
@@ -280,6 +287,13 @@ pub fn helper_on(cfg: &Cfg) -> bool {
     !h.is_empty() && h != "-1" && cfg_get(cfg, "STRATA_HELPER") != "0"
 }
 
+/// `strataLayerSplit` : les deux cartes se partagent les couches
+/// (`STRATA_SPLIT=layers`) au lieu que la seconde n'aide que pour une part
+/// des experts. Un choix, jamais imposé : le mode d'aide reste le défaut.
+pub fn layer_split(cfg: &Cfg) -> bool {
+    helper_on(cfg) && cfg_get(cfg, "STRATA_SPLIT") == "layers"
+}
+
 /// `strataResolveExperts` : le mode lancé (drop, ram, arena, disk), d'après
 /// le choix du preset et la RAM disponible.
 pub fn resolve_experts(
@@ -290,7 +304,9 @@ pub fn resolve_experts(
     helper_gb: f64,
 ) -> &'static str {
     let bin_ready = pack_has_experts_bin(args) && paths.engine_installed() == ENGINE_ASSET;
-    let drop_ready = bin_ready && helper_on(cfg) && cfg_get(cfg, "STRATA_DROP") != "0";
+    // (jamais en partage des couches : la seconde carte n'y garde pas d'experts)
+    let drop_ready =
+        bin_ready && helper_on(cfg) && !layer_split(cfg) && cfg_get(cfg, "STRATA_DROP") != "0";
     let arena = arena_gb(cfg);
     match cfg_get(cfg, "STRATA_EXPERTS")
         .trim()
@@ -404,7 +420,18 @@ pub fn build_config(base: &Value, cfg: &Cfg, api_key: &str, mode: &str) -> Resul
         args = set_arg(args, flag, v);
     }
     let helper = cfg_get(cfg, "STRATA_HELPER_GPU").trim();
-    let has_helper = helper_on(cfg);
+    let mut has_helper = helper_on(cfg);
+    if layer_split(cfg) {
+        // Partage des couches : la clé « gpu » liste les deux cartes (numéros
+        // nvidia-smi), le serveur de Strata en déduit --layer-split.
+        let main = cfg_get(cfg, "STRATA_MAIN_GPU")
+            .trim()
+            .parse::<i64>()
+            .unwrap_or(0);
+        let second = helper.parse::<i64>().unwrap_or(0);
+        out.insert("gpu".into(), json!([main, second]));
+        has_helper = false;
+    }
     if has_helper {
         args = set_arg(args, "--expert-cache-device1", "auto");
         if !has_arg(&args, "--remote-expert-opt") {
@@ -431,6 +458,8 @@ pub fn build_config(base: &Value, cfg: &Cfg, api_key: &str, mode: &str) -> Resul
             env.insert("STRATA_REMOTE_DROP".into(), json!("1"));
             env.insert("STRATA_STAGER_THREADS".into(), json!("8"));
             env.insert("STRATA_STAGER_RING".into(), json!("32"));
+            // VRAM libre réservée de la carte d'aide : 640 Mio (défaut 1024)
+            env.insert("STRATA_REMOTE_DROP_RESERVE_MIB".into(), json!("640"));
         }
         "arena" => {
             args = set_arg(args, "--pcie-frac", "0");
@@ -445,10 +474,23 @@ pub fn build_config(base: &Value, cfg: &Cfg, api_key: &str, mode: &str) -> Resul
     for (k, v) in ENV_TUNING {
         env.insert(k.into(), json!(v));
     }
+    if has_helper {
+        // Lecture d'un prompt (moteur 1.1) : les experts de la carte d'aide
+        // sont calculés par elle (source « helper ») ; le chemin direct ne
+        // garde que les ajouts sous 48 jetons.
+        env.insert("STRATA_PREFILL_HELPER_SOURCE".into(), json!("1"));
+        args = set_arg(args, "--short-read", "48");
+    }
+    let drop_on = env.get("STRATA_REMOTE_DROP").and_then(Value::as_str) == Some("1");
     out.insert("env".into(), Value::Object(env));
     let ctx = cfg_get(cfg, "CTX").trim();
     if !ctx.is_empty() {
-        args = set_arg(args, "--max-context", ctx);
+        // hors RAM, le cache KV verrouillé au-delà de DROP_MAX_CTX ne tient plus
+        let capped = match ctx.parse::<i64>() {
+            Ok(n) if n > DROP_MAX_CTX && drop_on => DROP_MAX_CTX.to_string(),
+            _ => ctx.to_string(),
+        };
+        args = set_arg(args, "--max-context", &capped);
     }
     for (key, flag) in [
         ("STRATA_KV", "--kv"),
@@ -766,6 +808,8 @@ pub struct SettingsReq {
     pub vision: bool,
     pub helper: bool,
     pub experts: String,
+    /// « helper » ou « layers » ; vide = inchangé (anciens clients).
+    pub split: String,
 }
 
 /// `strataApplySettings` : réécrit les clés du preset. Pure.
@@ -786,6 +830,9 @@ pub fn apply_settings(content: &str, r: &SettingsReq) -> Result<String, String>
     {
         return Err(format!("placement des experts inconnu : {}", r.experts));
     }
+    if !r.split.is_empty() && r.split != "helper" && r.split != "layers" {
+        return Err(format!("répartition inconnue : {}", r.split));
+    }
     let mut set: Vec<(&str, String)> = vec![
         ("CTX", r.ctx.to_string()),
         ("STRATA_KV", r.kv.clone()),
@@ -796,6 +843,11 @@ pub fn apply_settings(content: &str, r: &SettingsReq) -> Result<String, String>
     if !r.experts.is_empty() {
         set.push(("STRATA_EXPERTS", r.experts.clone()));
     }
+    if !r.split.is_empty() {
+        // « helper » est le défaut : la clé disparaît plutôt que d'être écrite
+        let v = if r.split == "layers" { "layers" } else { "" };
+        set.push(("STRATA_SPLIT", v.into()));
+    }
     let mut lines: Vec<String> = Vec::new();
     for l in content.trim_end_matches('\n').split('\n') {
         let k = l.trim().split_once('=').map_or(l.trim(), |(k, _)| k);
@@ -805,6 +857,9 @@ pub fn apply_settings(content: &str, r: &SettingsReq) -> Result<String, String>
         lines.push(l.to_string());
     }
     for (k, v) in set {
+        if k == "STRATA_SPLIT" && v.is_empty() {
+            continue;
+        }
         lines.push(format!("{k}={v}"));
     }
     Ok(lines.join("\n") + "\n")

rust/loki-rs/src/strata/tests.rs

@@ -369,6 +369,125 @@ fn modes_des_experts() {
     assert!(out["env"].get("STRATA_REMOTE_DROP").is_none());
 }
 
+// Moteur 1.1 (`TestStrataBuildConfigHelperPrompt`).
+#[test]
+fn lecture_des_prompts_par_la_carte_d_aide() {
+    let base = json!({ "args": ["--pack", "/p"] });
+    let out = build_config(&base, &cfg(&[("STRATA_HELPER_GPU", "0")]), "", "ram").unwrap();
+    assert_eq!(arg_after(&args_of(&out), "--short-read"), "48");
+    assert_eq!(out["env"]["STRATA_PREFILL_HELPER_SOURCE"], "1");
+    for c in [
+        Cfg::new(),
+        cfg(&[("STRATA_HELPER_GPU", "0"), ("STRATA_HELPER", "0")]),
+    ] {
+        let out = build_config(&base, &c, "", "ram").unwrap();
+        assert_eq!(arg_after(&args_of(&out), "--short-read"), "150", "{c:?}");
+        assert!(out["env"].get("STRATA_PREFILL_HELPER_SOURCE").is_none());
+    }
+}
+
+// `TestStrataBuildConfigDropReserveAndCtx`.
+#[test]
+fn hors_ram_reserve_et_contexte() {
+    let base = json!({ "args": ["--pack", "/p"], "env": {} });
+    let c = cfg(&[("STRATA_HELPER_GPU", "0"), ("CTX", "167936")]);
+    let out = build_config(&base, &c, "", "drop").unwrap();
+    assert_eq!(out["env"]["STRATA_REMOTE_DROP_RESERVE_MIB"], "640");
+    assert_eq!(arg_after(&args_of(&out), "--max-context"), "131072");
+    for mode in ["ram", "arena", "disk"] {
+        let out = build_config(&base, &c, "", mode).unwrap();
+        assert_eq!(
+            arg_after(&args_of(&out), "--max-context"),
+            "167936",
+            "{mode}"
+        );
+        assert!(out["env"].get("STRATA_REMOTE_DROP_RESERVE_MIB").is_none());
+    }
+}
+
+// `TestStrataBuildConfigLayerSplit`.
+#[test]
+fn partage_des_couches() {
+    let base = json!({
+        "args": ["--pack", "/p", "--vram-reserve-mib", "900"],
+        "vision": { "exe": "/v" },
+    });
+    let mut c = cfg(&[
+        ("STRATA_MAIN_GPU", "1"),
+        ("STRATA_HELPER_GPU", "0"),
+        ("STRATA_SPLIT", "layers"),
+    ]);
+    let out = build_config(&base, &c, "", "drop").unwrap();
+    assert_eq!(out["gpu"], json!([1, 0]));
+    let a = args_of(&out);
+    assert!(!has_arg(&a, "--remote-expert-opt") && !has_arg(&a, "--expert-cache-device1"));
+    assert_eq!(arg_after(&a, "--vram-reserve-mib"), "900");
+    assert_eq!(arg_after(&a, "--short-read"), "150");
+    assert!(out["env"].get("STRATA_REMOTE_DROP").is_none());
+    assert!(out["env"].get("STRATA_PREFILL_HELPER_SOURCE").is_none());
+    assert!(out["vision"].get("cuda_device").is_none());
+    c.remove("STRATA_SPLIT");
+    let out = build_config(&base, &c, "", "drop").unwrap();
+    assert!(out.get("gpu").is_none());
+    assert!(has_arg(&args_of(&out), "--remote-expert-opt"));
+    c.insert("STRATA_SPLIT".into(), "layers".into());
+    c.insert("STRATA_HELPER".into(), "0".into());
+    assert!(!layer_split(&c));
+}
+
+// `TestStrataResolveExpertsLayerSplit`.
+#[test]
+fn partage_des_couches_sans_hors_ram() {
+    let d = tempfile::tempdir().unwrap();
+    let p = Paths {
+        home: d.path().to_path_buf(),
+    };
+    let pack = d.path().join("pack");
+    std::fs::create_dir_all(&pack).unwrap();
+    std::fs::write(pack.join("experts.bin"), "x").unwrap();
+    std::fs::create_dir_all(p.src_dir().join("engine-cuda12")).unwrap();
+    std::fs::write(p.engine_marker(), format!("{ENGINE_ASSET}\n")).unwrap();
+    let args = vec!["--pack".to_string(), pack.to_string_lossy().into_owned()];
+    let mut c = cfg(&[
+        ("STRATA_CONFIG", "/x/strata-swift-iq3_xxs.json"),
+        ("STRATA_HELPER_GPU", "1"),
+        ("STRATA_DROP", "1"),
+    ]);
+    assert_eq!(resolve_experts(&p, &c, &args, 44.0, 12.0), "drop");
+    c.insert("STRATA_SPLIT".into(), "layers".into());
+    assert_eq!(resolve_experts(&p, &c, &args, 44.0, 12.0), "arena");
+    c.insert("STRATA_EXPERTS".into(), "ram".into());
+    assert_eq!(resolve_experts(&p, &c, &args, 44.0, 12.0), "ram");
+}
+
+// `TestStrataApplySettingsSplit`.
+#[test]
+fn reglages_de_la_seconde_carte() {
+    let input = "ENGINE=strata\nSTRATA_HELPER_GPU=0\n";
+    let mut r = SettingsReq {
+        ctx: 131072,
+        kv: "fp16".into(),
+        spec: 3,
+        vision: true,
+        helper: true,
+        split: "layers".into(),
+        ..SettingsReq::default()
+    };
+    let out = apply_settings(input, &r).unwrap();
+    assert!(out.contains("STRATA_SPLIT=layers\n"), "{out:?}");
+    r.split = "helper".into();
+    let out = apply_settings(&out, &r).unwrap();
+    assert!(!out.contains("STRATA_SPLIT"), "{out:?}");
+    r.split = String::new();
+    let out = apply_settings("STRATA_SPLIT=layers\n", &r).unwrap();
+    assert!(out.contains("STRATA_SPLIT=layers"), "{out:?}");
+    r.split = "nimporte".into();
+    assert_eq!(
+        apply_settings(input, &r).unwrap_err(),
+        "répartition inconnue : nimporte"
+    );
+}
+
 #[test]
 fn reglages_des_experts() {
     let input = "ENGINE=strata\nSTRATA_EXPERTS=auto\n";

rust/loki-rs/tests/bench.rs

@@ -469,12 +469,19 @@ async fn bail_travail_annexe_et_trace() {
         *bn.go.side_jobs.lock().unwrap(),
         vec!["begin 1".to_string(), "end 1 true".to_string()]
     );
+    // La longueur du prompt suit le corpus de code, c'est-à-dire l'UI
+    // embarquée : la vérifier en dur cassait le test à chaque retouche de
+    // l'interface. On vérifie la forme de la trace.
+    let perfs = bn.go.bench_perfs.lock().unwrap().clone();
+    assert_eq!(perfs.len(), 1, "{perfs:?}");
+    let n = perfs[0]["prompt_n"].as_i64().unwrap_or(0);
+    assert!(n > 0, "{perfs:?}");
     assert_eq!(
-        *bn.go.bench_perfs.lock().unwrap(),
-        vec![json!({
-            "prompt_n": 2036, "prompt_ms": 1018.0, "prompt_per_second": 2000.0,
+        perfs[0],
+        json!({
+            "prompt_n": n, "prompt_ms": n as f64 / 2.0, "prompt_per_second": 2000.0,
             "predicted_n": 300, "predicted_per_second": 50.0,
-        })]
+        })
     );
     // La clé de l'API locale accompagne les requêtes du bench.
     let auth = bn.fake.lock().unwrap().auth.clone();

rust/loki-rs/tests/downloads.rs

@@ -260,6 +260,13 @@ async fn wait_finished(dl: &Downloads, name: &str) -> DlState {
     panic!("téléchargement {name} jamais terminé : {:?}", dl.status());
 }
 
+fn state_of(dl: &Downloads, name: &str) -> DlState {
+    dl.status()
+        .into_iter()
+        .find(|s| s.filename == name)
+        .unwrap()
+}
+
 fn models(home: &Path) -> PathBuf {
     home.join("models")
 }
@@ -537,6 +544,58 @@ async fn annulation_efface_le_part() {
     assert_eq!(entries(&models(tmp.path())), Vec::<String>::new());
 }
 
+// `TestRunDownloadPauseResume` : la pause coupe le flux et garde ce qui est
+// écrit ; la reprise repart de là par une plage et termine un fichier
+// identique à la source.
+#[tokio::test]
+async fn pause_puis_reprise() {
+    let (addr, hf) = fake_hf().await;
+    let data = payload(8 << 20, 5);
+    hf.files
+        .lock()
+        .unwrap()
+        .insert("/m.gguf".into(), Arc::new(data.clone()));
+    *hf.slow.lock().unwrap() = true;
+    let tmp = tempfile::tempdir().unwrap();
+    let dl = Arc::new(Downloads::new());
+    let (code, _) = dl.start(
+        env(),
+        &dirs_at(tmp.path()),
+        &format!("http://{addr}/m.gguf"),
+        "",
+    );
+    assert_eq!(code, StatusCode::OK);
+    assert!(!dl.pause("autre.gguf", true));
+    tokio::time::sleep(Duration::from_millis(300)).await;
+    assert!(dl.pause("m.gguf", true));
+    tokio::time::sleep(Duration::from_millis(1500)).await;
+    let a = state_of(&dl, "m.gguf");
+    tokio::time::sleep(Duration::from_millis(1500)).await;
+    let b = state_of(&dl, "m.gguf");
+    assert!(
+        a.paused && !b.finished && a.done == b.done && a.done > 0 && b.speed == 0,
+        "pause inopérante : {a:?} puis {b:?}"
+    );
+    let before = hf.log.lock().unwrap().len();
+    assert!(dl.pause("m.gguf", false));
+    let end = wait_finished(&dl, "m.gguf").await;
+    assert!(
+        end.err.is_empty() && !end.canceled && !end.paused,
+        "{end:?}"
+    );
+    let got = std::fs::read(models(tmp.path()).join("m.gguf")).unwrap();
+    assert!(got == data, "fichier différent de la source après reprise");
+    // La reprise demande la suite, pas le début.
+    let log = hf.log.lock().unwrap().clone();
+    let resumed = log[before..]
+        .iter()
+        .filter_map(|l| l.strip_prefix("/m.gguf bytes="))
+        .any(|r| !r.starts_with("0-"));
+    assert!(resumed, "{log:?}");
+    // Terminé : plus rien à mettre en pause.
+    assert!(!dl.pause("m.gguf", true));
+}
+
 #[tokio::test]
 async fn refus_avant_de_lancer() {
     let tmp = tempfile::tempdir().unwrap();

rust/loki-rs/tests/mcp.rs

@@ -66,17 +66,44 @@ fn parite_des_fonctions_pures() {
             .unwrap_or_default();
         assert_eq!(cf::prompt_line(&tools), s(&c["out"]), "{c}");
     }
+    let def = cf::Timeouts::default();
     for (cmd, v) in fx["timeouts"].as_object().unwrap() {
         let cfg = cf::ServerConfig {
             command: cmd.clone(),
             ..Default::default()
         };
         assert_eq!(
-            cf::timeout_for(&cfg).as_secs() as i64,
+            cf::timeout_for(&cfg, &def).as_secs() as i64,
             v["secs"].as_i64().unwrap(),
             "{cmd}"
         );
-        assert_eq!(cf::timeout_error(&cfg), s(&v["err"]), "{cmd}");
+        assert_eq!(cf::timeout_error(&cfg, &def), s(&v["err"]), "{cmd}");
+    }
+    // Délais globaux : lecture de la base, puis leur effet.
+    let tm = |v: &Value| cf::Timeouts {
+        connect: v["connect"].as_i64().unwrap(),
+        call: v["call"].as_i64().unwrap(),
+    };
+    for c in fx["timeouts_stored"].as_array().unwrap() {
+        let raw = s(&c["in"]);
+        let got = cf::decode_timeouts((!raw.is_empty()).then_some(raw.as_bytes()));
+        assert_eq!(got, tm(&c["out"]), "{raw}");
+    }
+    for c in fx["timeouts_effects"].as_array().unwrap() {
+        let t = tm(&c["timeouts"]);
+        let cfg: cf::ServerConfig = serde_json::from_str(s(&c["cfg"])).unwrap();
+        let args: Map<String, Value> = serde_json::from_str(s(&c["args"])).unwrap();
+        assert_eq!(
+            cf::timeout_for(&cfg, &t).as_millis() as i64,
+            c["connect"].as_i64().unwrap(),
+            "{c}"
+        );
+        assert_eq!(cf::timeout_error(&cfg, &t), s(&c["err"]), "{c}");
+        assert_eq!(
+            cf::call_timeout_for(&cfg, &t, &args).as_millis() as i64,
+            c["call"].as_i64().unwrap(),
+            "{c}"
+        );
     }
     for c in fx["flatten"].as_array().unwrap() {
         let v: Value = serde_json::from_str(s(&c["in"])).unwrap();
@@ -422,6 +449,50 @@ async fn routes_de_configuration() {
     );
     let stored: Value = serde_json::from_str(&go.get("state", "mcp").unwrap()).unwrap();
     assert_eq!(stored["web"]["url"], json!(url));
+    assert!(stored["web"].get("callTimeoutSec").is_none());
+    // Délai d'un appel propre au serveur : rangé, rendu, puis retiré quand le
+    // champ revient vide.
+    let body = |ct: Option<i64>| {
+        let mut b = json!({ "name": "web", "url": url, "headers": { "X-Cle": "k" } });
+        if let Some(n) = ct {
+            b["callTimeoutSec"] = json!(n);
+        }
+        b.to_string()
+    };
+    let (c, v) = post("/api/mcp/save", body(Some(900))).await;
+    assert_eq!(
+        (c, v["servers"][0]["callTimeoutSec"].clone()),
+        (200, json!(900))
+    );
+    let stored: Value = serde_json::from_str(&go.get("state", "mcp").unwrap()).unwrap();
+    assert_eq!(stored["web"]["callTimeoutSec"], 900);
+    let (c, v) = post("/api/mcp/save", body(None)).await;
+    assert_eq!(c, 200);
+    assert!(v["servers"][0].get("callTimeoutSec").is_none(), "{v}");
+    for n in [-1, 3601] {
+        let (c, v) = post("/api/mcp/save", body(Some(n))).await;
+        assert_eq!(
+            (c, v["error"].clone()),
+            (
+                400,
+                json!("délai d'un appel : 0 à 3600 s (vide = réglage global)")
+            )
+        );
+    }
+    let (c, v) = post(
+        "/api/mcp/save",
+        r#"{"name":"x","url":"http://h","callTimeoutSec":"9"}"#.into(),
+    )
+    .await;
+    assert_eq!(
+        (c, v["error"].clone()),
+        (
+            400,
+            json!(
+                "json: cannot unmarshal string into Go struct field mcpSaveReq.callTimeoutSec of type int"
+            )
+        )
+    );
     // Erreurs de la configuration et du JSON.
     let (c, v) = post("/api/mcp/save", r#"{"name":"a__b","command":"x"}"#.into()).await;
     assert_eq!(
@@ -506,6 +577,67 @@ async fn routes_de_configuration() {
     pool.close_all().await;
 }
 
+/// Les routes des délais globaux rejouées contre la façade : mêmes codes,
+/// mêmes réponses, même valeur rangée ; un enregistrement réussi ferme les
+/// sessions ouvertes.
+#[tokio::test]
+async fn routes_des_delais() {
+    let tmp = tempfile::tempdir().unwrap();
+    let seen = Arc::new(Mutex::new(Vec::new()));
+    let fx = fixture();
+    let url = fake_server(fx["wire"].clone(), seen.clone()).await;
+    let pool = Arc::new(Mcp::new(tmp.path().to_path_buf()));
+    let (facade, go, _stop, _) = fakego::start_with(
+        tmp.path().to_path_buf(),
+        fakego::Opts {
+            mcp: Some(pool.clone()),
+            ..Default::default()
+        },
+    )
+    .await;
+    go.set(
+        "state",
+        "mcp",
+        &json!({ "web": { "url": url, "enabled": true } }).to_string(),
+    );
+    let initialize = || {
+        seen.lock()
+            .unwrap()
+            .iter()
+            .filter(|l| l.starts_with("initialize"))
+            .count()
+    };
+    let (_, b) = fakego::send(facade, "GET", "/api/mcp", &[], "").await;
+    let v: Value = serde_json::from_slice(&b).unwrap();
+    assert_eq!(v["servers"][0]["connected"], true, "{v}");
+    let mut connections = initialize();
+    for c in fx["timeouts_routes"].as_array().unwrap() {
+        let path = s(&c["path"]);
+        let method = if path.ends_with("/save") {
+            "POST"
+        } else {
+            "GET"
+        };
+        let (code, b) = fakego::send(facade, method, path, &[], s(&c["body"])).await;
+        assert_eq!(code.as_u16() as i64, c["code"].as_i64().unwrap(), "{c}");
+        let got: Value = serde_json::from_slice(&b).unwrap();
+        let want: Value = serde_json::from_str(s(&c["resp"])).unwrap();
+        assert_eq!(got, want, "{c}");
+        assert_eq!(
+            go.get("state", cf::ST_TIMEOUTS).unwrap_or_default(),
+            s(&c["state"]),
+            "{c}"
+        );
+        // Session fermée : la liste suivante se reconnecte.
+        fakego::send(facade, "GET", "/api/mcp", &[], "").await;
+        let now = initialize();
+        let saved = method == "POST" && code.as_u16() == 200;
+        assert_eq!(now, connections + usize::from(saved), "{c}");
+        connections = now;
+    }
+    pool.close_all().await;
+}
+
 #[tokio::test]
 async fn catalogue_embarque() {
     let tmp = tempfile::tempdir().unwrap();
@@ -544,6 +676,8 @@ async fn sans_la_variable_mcp_reste_au_go() {
         "/api/mcp/save",
         "/api/mcp/catalog",
         "/api/mcp/test",
+        "/api/mcp/timeouts",
+        "/api/mcp/timeouts/save",
     ] {
         let (_, _, b) = fakego::get(facade, p, &[]).await;
         assert_eq!(&b[..], format!("go:{p}").as_bytes());

rust/loki-rs/tests/parity_bench/bench.json

@@ -304,7 +304,7 @@
             "max_tokens": 300,
             "messages": [
               {
-                "content": "<8129 octets ae9cc838495d>",
+                "content": "<8130 octets 081c43a7796f>",
                 "role": "user"
               }
             ],
@@ -615,7 +615,7 @@
             "max_tokens": 300,
             "messages": [
               {
-                "content": "<8129 octets ae9cc838495d>",
+                "content": "<8130 octets 081c43a7796f>",
                 "role": "user"
               }
             ],
@@ -1066,7 +1066,7 @@
             "max_tokens": 300,
             "messages": [
               {
-                "content": "<8129 octets ae9cc838495d>",
+                "content": "<8130 octets 081c43a7796f>",
                 "role": "user"
               }
             ],
@@ -1314,7 +1314,7 @@
             "max_tokens": 300,
             "messages": [
               {
-                "content": "<8129 octets ae9cc838495d>",
+                "content": "<8130 octets 081c43a7796f>",
                 "role": "user"
               }
             ],
@@ -1686,8 +1686,8 @@
           "predicted_ms": 81920,
           "predicted_n": 4096,
           "predicted_per_second": 50,
-          "prompt_ms": 16403,
-          "prompt_n": 32806,
+          "prompt_ms": 16395,
+          "prompt_n": 32790,
           "prompt_per_second": 2000,
           "protocol": 2
         },
@@ -1759,7 +1759,7 @@
             "max_tokens": 4096,
             "messages": [
               {
-                "content": "<131209 octets a079a2b6a1db>",
+                "content": "<131145 octets 8d4ca4a3239d>",
                 "role": "user"
               }
             ],
@@ -1790,8 +1790,8 @@
           "predicted_ms": 81920,
           "predicted_n": 4096,
           "predicted_per_second": 50,
-          "prompt_ms": 16403,
-          "prompt_n": 32806,
+          "prompt_ms": 16395,
+          "prompt_n": 32790,
           "prompt_per_second": 2000,
           "protocol": 2
         }
@@ -1813,8 +1813,8 @@
             "predicted_ms": 81920,
             "predicted_n": 4096,
             "predicted_per_second": 50,
-            "prompt_ms": 16403,
-            "prompt_n": 32806,
+            "prompt_ms": 16395,
+            "prompt_n": 32790,
             "prompt_per_second": 2000,
             "protocol": 2
           }
@@ -2093,7 +2093,7 @@
             "max_tokens": 16,
             "messages": [
               {
-                "content": "<3745 octets 5578a8f2779c>",
+                "content": "<3745 octets 4d9bad4c301c>",
                 "role": "user"
               }
             ],
@@ -2260,7 +2260,7 @@
             "max_tokens": 300,
             "messages": [
               {
-                "content": "<8129 octets ae9cc838495d>",
+                "content": "<8130 octets 081c43a7796f>",
                 "role": "user"
               }
             ],
@@ -2541,7 +2541,7 @@
             "max_tokens": 300,
             "messages": [
               {
-                "content": "<8129 octets ae9cc838495d>",
+                "content": "<8130 octets 081c43a7796f>",
                 "role": "user"
               }
             ],
@@ -2693,7 +2693,7 @@
             "max_tokens": 300,
             "messages": [
               {
-                "content": "<8129 octets ae9cc838495d>",
+                "content": "<8130 octets 081c43a7796f>",
                 "role": "user"
               }
             ],
@@ -2868,7 +2868,7 @@
             "max_tokens": 300,
             "messages": [
               {
-                "content": "<8129 octets ae9cc838495d>",
+                "content": "<8130 octets 081c43a7796f>",
                 "role": "user"
               }
             ],
@@ -3287,7 +3287,7 @@
             "max_tokens": 300,
             "messages": [
               {
-                "content": "<8129 octets ae9cc838495d>",
+                "content": "<8130 octets 081c43a7796f>",
                 "role": "user"
               }
             ],
@@ -3457,7 +3457,7 @@
             "max_tokens": 300,
             "messages": [
               {
-                "content": "<8129 octets ae9cc838495d>",
+                "content": "<8130 octets 081c43a7796f>",
                 "role": "user"
               }
             ],
@@ -3652,7 +3652,7 @@
             "max_tokens": 300,
             "messages": [
               {
-                "content": "<8129 octets ae9cc838495d>",
+                "content": "<8130 octets 081c43a7796f>",
                 "role": "user"
               }
             ],
@@ -3867,7 +3867,7 @@
             "max_tokens": 300,
             "messages": [
               {
-                "content": "<8129 octets ae9cc838495d>",
+                "content": "<8130 octets 081c43a7796f>",
                 "role": "user"
               }
             ],

rust/loki-rs/tests/parity_mcp/mcp.json

@@ -163,37 +163,37 @@
     {
       "op": "set",
       "name": "web",
-      "cfg": "{\"url\":\"http://u/mcp\",\"headers\":{\"X\":\"1\"},\"enabled\":false}",
+      "cfg": "{\"url\":\"http://u/mcp\",\"headers\":{\"X\":\"1\"},\"enabled\":false,\"callTimeoutSec\":45}",
       "error": "",
-      "state": "{\"fs\":{\"command\":\"npx\",\"args\":[\"-y\",\"@x/fs\",\"\\u003cw\\u003e\"],\"env\":{\"A\":\"\\u0026\"},\"enabled\":true},\"web\":{\"url\":\"http://u/mcp\",\"headers\":{\"X\":\"1\"},\"enabled\":false}}"
+      "state": "{\"fs\":{\"command\":\"npx\",\"args\":[\"-y\",\"@x/fs\",\"\\u003cw\\u003e\"],\"env\":{\"A\":\"\\u0026\"},\"enabled\":true},\"web\":{\"url\":\"http://u/mcp\",\"headers\":{\"X\":\"1\"},\"enabled\":false,\"callTimeoutSec\":45}}"
     },
     {
       "op": "enable",
       "name": "web",
       "on": true,
       "error": "",
-      "state": "{\"fs\":{\"command\":\"npx\",\"args\":[\"-y\",\"@x/fs\",\"\\u003cw\\u003e\"],\"env\":{\"A\":\"\\u0026\"},\"enabled\":true},\"web\":{\"url\":\"http://u/mcp\",\"headers\":{\"X\":\"1\"},\"enabled\":true}}"
+      "state": "{\"fs\":{\"command\":\"npx\",\"args\":[\"-y\",\"@x/fs\",\"\\u003cw\\u003e\"],\"env\":{\"A\":\"\\u0026\"},\"enabled\":true},\"web\":{\"url\":\"http://u/mcp\",\"headers\":{\"X\":\"1\"},\"enabled\":true,\"callTimeoutSec\":45}}"
     },
     {
       "op": "enable",
       "name": "nope",
       "on": true,
       "error": "serveur MCP inconnu: nope",
-      "state": "{\"fs\":{\"command\":\"npx\",\"args\":[\"-y\",\"@x/fs\",\"\\u003cw\\u003e\"],\"env\":{\"A\":\"\\u0026\"},\"enabled\":true},\"web\":{\"url\":\"http://u/mcp\",\"headers\":{\"X\":\"1\"},\"enabled\":true}}"
+      "state": "{\"fs\":{\"command\":\"npx\",\"args\":[\"-y\",\"@x/fs\",\"\\u003cw\\u003e\"],\"env\":{\"A\":\"\\u0026\"},\"enabled\":true},\"web\":{\"url\":\"http://u/mcp\",\"headers\":{\"X\":\"1\"},\"enabled\":true,\"callTimeoutSec\":45}}"
     },
     {
       "op": "tool",
       "name": "fs",
       "tool": "write",
       "error": "",
-      "state": "{\"fs\":{\"command\":\"npx\",\"args\":[\"-y\",\"@x/fs\",\"\\u003cw\\u003e\"],\"env\":{\"A\":\"\\u0026\"},\"enabled\":true,\"disabledTools\":[\"write\"]},\"web\":{\"url\":\"http://u/mcp\",\"headers\":{\"X\":\"1\"},\"enabled\":true}}"
+      "state": "{\"fs\":{\"command\":\"npx\",\"args\":[\"-y\",\"@x/fs\",\"\\u003cw\\u003e\"],\"env\":{\"A\":\"\\u0026\"},\"enabled\":true,\"disabledTools\":[\"write\"]},\"web\":{\"url\":\"http://u/mcp\",\"headers\":{\"X\":\"1\"},\"enabled\":true,\"callTimeoutSec\":45}}"
     },
     {
       "op": "tool",
       "name": "fs",
       "tool": "read",
       "error": "",
-      "state": "{\"fs\":{\"command\":\"npx\",\"args\":[\"-y\",\"@x/fs\",\"\\u003cw\\u003e\"],\"env\":{\"A\":\"\\u0026\"},\"enabled\":true,\"disabledTools\":[\"write\",\"read\"]},\"web\":{\"url\":\"http://u/mcp\",\"headers\":{\"X\":\"1\"},\"enabled\":true}}"
+      "state": "{\"fs\":{\"command\":\"npx\",\"args\":[\"-y\",\"@x/fs\",\"\\u003cw\\u003e\"],\"env\":{\"A\":\"\\u0026\"},\"enabled\":true,\"disabledTools\":[\"write\",\"read\"]},\"web\":{\"url\":\"http://u/mcp\",\"headers\":{\"X\":\"1\"},\"enabled\":true,\"callTimeoutSec\":45}}"
     },
     {
       "op": "tool",
@@ -201,21 +201,21 @@
       "tool": "write",
       "on": true,
       "error": "",
-      "state": "{\"fs\":{\"command\":\"npx\",\"args\":[\"-y\",\"@x/fs\",\"\\u003cw\\u003e\"],\"env\":{\"A\":\"\\u0026\"},\"enabled\":true,\"disabledTools\":[\"read\"]},\"web\":{\"url\":\"http://u/mcp\",\"headers\":{\"X\":\"1\"},\"enabled\":true}}"
+      "state": "{\"fs\":{\"command\":\"npx\",\"args\":[\"-y\",\"@x/fs\",\"\\u003cw\\u003e\"],\"env\":{\"A\":\"\\u0026\"},\"enabled\":true,\"disabledTools\":[\"read\"]},\"web\":{\"url\":\"http://u/mcp\",\"headers\":{\"X\":\"1\"},\"enabled\":true,\"callTimeoutSec\":45}}"
     },
     {
       "op": "tool",
       "name": "fs",
       "tool": "read",
       "error": "",
-      "state": "{\"fs\":{\"command\":\"npx\",\"args\":[\"-y\",\"@x/fs\",\"\\u003cw\\u003e\"],\"env\":{\"A\":\"\\u0026\"},\"enabled\":true,\"disabledTools\":[\"read\"]},\"web\":{\"url\":\"http://u/mcp\",\"headers\":{\"X\":\"1\"},\"enabled\":true}}"
+      "state": "{\"fs\":{\"command\":\"npx\",\"args\":[\"-y\",\"@x/fs\",\"\\u003cw\\u003e\"],\"env\":{\"A\":\"\\u0026\"},\"enabled\":true,\"disabledTools\":[\"read\"]},\"web\":{\"url\":\"http://u/mcp\",\"headers\":{\"X\":\"1\"},\"enabled\":true,\"callTimeoutSec\":45}}"
     },
     {
       "op": "tool",
       "name": "nope",
       "tool": "x",
       "error": "serveur MCP inconnu: nope",
-      "state": "{\"fs\":{\"command\":\"npx\",\"args\":[\"-y\",\"@x/fs\",\"\\u003cw\\u003e\"],\"env\":{\"A\":\"\\u0026\"},\"enabled\":true,\"disabledTools\":[\"read\"]},\"web\":{\"url\":\"http://u/mcp\",\"headers\":{\"X\":\"1\"},\"enabled\":true}}"
+      "state": "{\"fs\":{\"command\":\"npx\",\"args\":[\"-y\",\"@x/fs\",\"\\u003cw\\u003e\"],\"env\":{\"A\":\"\\u0026\"},\"enabled\":true,\"disabledTools\":[\"read\"]},\"web\":{\"url\":\"http://u/mcp\",\"headers\":{\"X\":\"1\"},\"enabled\":true,\"callTimeoutSec\":45}}"
     },
     {
       "op": "delete",
@@ -382,13 +382,14 @@
       "connected": false,
       "tools": [],
       "disabled": [],
-      "url": "{{URL}}"
+      "url": "{{URL}}",
+      "callTimeoutSec": 300
     }
   ],
-  "store": "{\"alpha\":{\"url\":\"{{URL}}\",\"enabled\":true,\"disabledTools\":[\"secret\"]},\"beta\":{\"command\":\"loki-mcp-absent-pour-test\",\"enabled\":true},\"gamma\":{\"url\":\"{{URL}}\",\"enabled\":false},\"delta\":{\"enabled\":true}}",
+  "store": "{\"alpha\":{\"url\":\"{{URL}}\",\"enabled\":true,\"disabledTools\":[\"secret\"]},\"beta\":{\"command\":\"loki-mcp-absent-pour-test\",\"enabled\":true},\"gamma\":{\"url\":\"{{URL}}\",\"enabled\":false,\"callTimeoutSec\":300},\"delta\":{\"enabled\":true}}",
   "timeouts": {
     "": {
-      "err": "délai dépassé — le serveur n'a pas répondu au handshake en 20s",
+      "err": "délai dépassé — le serveur n'a pas répondu au handshake en 20s (délai de connexion réglable dans les réglages MCP)",
       "secs": 20
     },
     "/usr/local/bin/NPX": {
@@ -400,7 +401,7 @@
       "secs": 180
     },
     "node": {
-      "err": "délai dépassé — le serveur n'a pas répondu au handshake en 20s",
+      "err": "délai dépassé — le serveur n'a pas répondu au handshake en 20s (délai de connexion réglable dans les réglages MCP)",
       "secs": 20
     },
     "npx": {
@@ -412,7 +413,7 @@
       "secs": 180
     },
     "uvx-x": {
-      "err": "délai dépassé — le serveur n'a pas répondu au handshake en 20s",
+      "err": "délai dépassé — le serveur n'a pas répondu au handshake en 20s (délai de connexion réglable dans les réglages MCP)",
       "secs": 20
     },
     "uvx.exe": {
@@ -420,6 +421,437 @@
       "secs": 180
     }
   },
+  "timeouts_effects": [
+    {
+      "args": "{}",
+      "call": 120000,
+      "cfg": "{\"command\":\"node\",\"enabled\":false}",
+      "connect": 20000,
+      "err": "délai dépassé — le serveur n'a pas répondu au handshake en 20s (délai de connexion réglable dans les réglages MCP)",
+      "timeouts": {
+        "connect": 20,
+        "call": 120
+      }
+    },
+    {
+      "args": "{}",
+      "call": 120000,
+      "cfg": "{\"command\":\"npx\",\"enabled\":false}",
+      "connect": 180000,
+      "err": "délai dépassé — npx 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)",
+      "timeouts": {
+        "connect": 20,
+        "call": 120
+      }
+    },
+    {
+      "args": "{}",
+      "call": 90000,
+      "cfg": "{\"url\":\"http://h\",\"enabled\":false,\"callTimeoutSec\":90}",
+      "connect": 20000,
+      "err": "délai dépassé — le serveur n'a pas répondu au handshake en 20s (délai de connexion réglable dans les réglages MCP)",
+      "timeouts": {
+        "connect": 20,
+        "call": 120
+      }
+    },
+    {
+      "args": "{\"timeout\":7200}",
+      "call": 3600000,
+      "cfg": "{\"command\":\"uvx\",\"enabled\":false,\"callTimeoutSec\":3600}",
+      "connect": 180000,
+      "err": "délai dépassé — uvx 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)",
+      "timeouts": {
+        "connect": 20,
+        "call": 120
+      }
+    },
+    {
+      "args": "{\"timeout\":600}",
+      "call": 630000,
+      "cfg": "{\"url\":\"http://h\",\"enabled\":false}",
+      "connect": 20000,
+      "err": "délai dépassé — le serveur n'a pas répondu au handshake en 20s (délai de connexion réglable dans les réglages MCP)",
+      "timeouts": {
+        "connect": 20,
+        "call": 120
+      }
+    },
+    {
+      "args": "{\"timeout\":99999999}",
+      "call": 3600000,
+      "cfg": "{\"url\":\"http://h\",\"enabled\":false}",
+      "connect": 20000,
+      "err": "délai dépassé — le serveur n'a pas répondu au handshake en 20s (délai de connexion réglable dans les réglages MCP)",
+      "timeouts": {
+        "connect": 20,
+        "call": 120
+      }
+    },
+    {
+      "args": "{}",
+      "call": 45000,
+      "cfg": "{\"command\":\"node\",\"enabled\":false}",
+      "connect": 5000,
+      "err": "délai dépassé — le serveur n'a pas répondu au handshake en 5s (délai de connexion réglable dans les réglages MCP)",
+      "timeouts": {
+        "connect": 5,
+        "call": 45
+      }
+    },
+    {
+      "args": "{}",
+      "call": 45000,
+      "cfg": "{\"command\":\"npx\",\"enabled\":false}",
+      "connect": 180000,
+      "err": "délai dépassé — npx 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)",
+      "timeouts": {
+        "connect": 5,
+        "call": 45
+      }
+    },
+    {
+      "args": "{}",
+      "call": 90000,
+      "cfg": "{\"url\":\"http://h\",\"enabled\":false,\"callTimeoutSec\":90}",
+      "connect": 5000,
+      "err": "délai dépassé — le serveur n'a pas répondu au handshake en 5s (délai de connexion réglable dans les réglages MCP)",
+      "timeouts": {
+        "connect": 5,
+        "call": 45
+      }
+    },
+    {
+      "args": "{\"timeout\":7200}",
+      "call": 3600000,
+      "cfg": "{\"command\":\"uvx\",\"enabled\":false,\"callTimeoutSec\":3600}",
+      "connect": 180000,
+      "err": "délai dépassé — uvx 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)",
+      "timeouts": {
+        "connect": 5,
+        "call": 45
+      }
+    },
+    {
+      "args": "{\"timeout\":600}",
+      "call": 630000,
+      "cfg": "{\"url\":\"http://h\",\"enabled\":false}",
+      "connect": 5000,
+      "err": "délai dépassé — le serveur n'a pas répondu au handshake en 5s (délai de connexion réglable dans les réglages MCP)",
+      "timeouts": {
+        "connect": 5,
+        "call": 45
+      }
+    },
+    {
+      "args": "{\"timeout\":99999999}",
+      "call": 3600000,
+      "cfg": "{\"url\":\"http://h\",\"enabled\":false}",
+      "connect": 5000,
+      "err": "délai dépassé — le serveur n'a pas répondu au handshake en 5s (délai de connexion réglable dans les réglages MCP)",
+      "timeouts": {
+        "connect": 5,
+        "call": 45
+      }
+    },
+    {
+      "args": "{}",
+      "call": 3600000,
+      "cfg": "{\"command\":\"node\",\"enabled\":false}",
+      "connect": 600000,
+      "err": "délai dépassé — le serveur n'a pas répondu au handshake en 10m0s (délai de connexion réglable dans les réglages MCP)",
+      "timeouts": {
+        "connect": 600,
+        "call": 3600
+      }
+    },
+    {
+      "args": "{}",
+      "call": 3600000,
+      "cfg": "{\"command\":\"npx\",\"enabled\":false}",
+      "connect": 600000,
+      "err": "délai dépassé — npx 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)",
+      "timeouts": {
+        "connect": 600,
+        "call": 3600
+      }
+    },
+    {
+      "args": "{}",
+      "call": 90000,
+      "cfg": "{\"url\":\"http://h\",\"enabled\":false,\"callTimeoutSec\":90}",
+      "connect": 600000,
+      "err": "délai dépassé — le serveur n'a pas répondu au handshake en 10m0s (délai de connexion réglable dans les réglages MCP)",
+      "timeouts": {
+        "connect": 600,
+        "call": 3600
+      }
+    },
+    {
+      "args": "{\"timeout\":7200}",
+      "call": 3600000,
+      "cfg": "{\"command\":\"uvx\",\"enabled\":false,\"callTimeoutSec\":3600}",
+      "connect": 600000,
+      "err": "délai dépassé — uvx 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)",
+      "timeouts": {
+        "connect": 600,
+        "call": 3600
+      }
+    },
+    {
+      "args": "{\"timeout\":600}",
+      "call": 3600000,
+      "cfg": "{\"url\":\"http://h\",\"enabled\":false}",
+      "connect": 600000,
+      "err": "délai dépassé — le serveur n'a pas répondu au handshake en 10m0s (délai de connexion réglable dans les réglages MCP)",
+      "timeouts": {
+        "connect": 600,
+        "call": 3600
+      }
+    },
+    {
+      "args": "{\"timeout\":99999999}",
+      "call": 3600000,
+      "cfg": "{\"url\":\"http://h\",\"enabled\":false}",
+      "connect": 600000,
+      "err": "délai dépassé — le serveur n'a pas répondu au handshake en 10m0s (délai de connexion réglable dans les réglages MCP)",
+      "timeouts": {
+        "connect": 600,
+        "call": 3600
+      }
+    },
+    {
+      "args": "{}",
+      "call": 1000,
+      "cfg": "{\"command\":\"node\",\"enabled\":false}",
+      "connect": 180000,
+      "err": "délai dépassé — le serveur n'a pas répondu au handshake en 3m0s (délai de connexion réglable dans les réglages MCP)",
+      "timeouts": {
+        "connect": 180,
+        "call": 1
+      }
+    },
+    {
+      "args": "{}",
+      "call": 1000,
+      "cfg": "{\"command\":\"npx\",\"enabled\":false}",
+      "connect": 180000,
+      "err": "délai dépassé — npx 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)",
+      "timeouts": {
+        "connect": 180,
+        "call": 1
+      }
+    },
+    {
+      "args": "{}",
+      "call": 90000,
+      "cfg": "{\"url\":\"http://h\",\"enabled\":false,\"callTimeoutSec\":90}",
+      "connect": 180000,
+      "err": "délai dépassé — le serveur n'a pas répondu au handshake en 3m0s (délai de connexion réglable dans les réglages MCP)",
+      "timeouts": {
+        "connect": 180,
+        "call": 1
+      }
+    },
+    {
+      "args": "{\"timeout\":7200}",
+      "call": 3600000,
+      "cfg": "{\"command\":\"uvx\",\"enabled\":false,\"callTimeoutSec\":3600}",
+      "connect": 180000,
+      "err": "délai dépassé — uvx 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)",
+      "timeouts": {
+        "connect": 180,
+        "call": 1
+      }
+    },
+    {
+      "args": "{\"timeout\":600}",
+      "call": 630000,
+      "cfg": "{\"url\":\"http://h\",\"enabled\":false}",
+      "connect": 180000,
+      "err": "délai dépassé — le serveur n'a pas répondu au handshake en 3m0s (délai de connexion réglable dans les réglages MCP)",
+      "timeouts": {
+        "connect": 180,
+        "call": 1
+      }
+    },
+    {
+      "args": "{\"timeout\":99999999}",
+      "call": 3600000,
+      "cfg": "{\"url\":\"http://h\",\"enabled\":false}",
+      "connect": 180000,
+      "err": "délai dépassé — le serveur n'a pas répondu au handshake en 3m0s (délai de connexion réglable dans les réglages MCP)",
+      "timeouts": {
+        "connect": 180,
+        "call": 1
+      }
+    }
+  ],
+  "timeouts_routes": [
+    {
+      "body": "",
+      "code": 200,
+      "path": "/api/mcp/timeouts",
+      "resp": "{\"call\":120,\"connect\":20,\"ok\":true}",
+      "state": ""
+    },
+    {
+      "body": "{\"connect\":0,\"call\":120}",
+      "code": 400,
+      "path": "/api/mcp/timeouts/save",
+      "resp": "{\"error\":\"connexion : 1 à 3600 s\",\"ok\":false}",
+      "state": ""
+    },
+    {
+      "body": "{\"connect\":20,\"call\":3601}",
+      "code": 400,
+      "path": "/api/mcp/timeouts/save",
+      "resp": "{\"error\":\"appel d'outil : 1 à 3600 s\",\"ok\":false}",
+      "state": ""
+    },
+    {
+      "body": "{\"connect\":20}",
+      "code": 400,
+      "path": "/api/mcp/timeouts/save",
+      "resp": "{\"error\":\"appel d'outil : 1 à 3600 s\",\"ok\":false}",
+      "state": ""
+    },
+    {
+      "body": "{\"connect\":\"20\",\"call\":120}",
+      "code": 400,
+      "path": "/api/mcp/timeouts/save",
+      "resp": "{\"error\":\"json: cannot unmarshal string into Go struct field MCPTimeouts.connect of type int\",\"ok\":false}",
+      "state": ""
+    },
+    {
+      "body": "{\"connect\":2.5,\"call\":120}",
+      "code": 400,
+      "path": "/api/mcp/timeouts/save",
+      "resp": "{\"error\":\"json: cannot unmarshal number 2.5 into Go struct field MCPTimeouts.connect of type int\",\"ok\":false}",
+      "state": ""
+    },
+    {
+      "body": "[]",
+      "code": 400,
+      "path": "/api/mcp/timeouts/save",
+      "resp": "{\"error\":\"json: cannot unmarshal array into Go value of type loki.MCPTimeouts\",\"ok\":false}",
+      "state": ""
+    },
+    {
+      "body": "pas du json",
+      "code": 400,
+      "path": "/api/mcp/timeouts/save",
+      "resp": "{\"error\":\"invalid character 'p' looking for beginning of value\",\"ok\":false}",
+      "state": ""
+    },
+    {
+      "body": "{\"Connect\":45,\"CALL\":900,\"x\":1}",
+      "code": 200,
+      "path": "/api/mcp/timeouts/save",
+      "resp": "{\"call\":900,\"connect\":45,\"ok\":true}",
+      "state": "{\"connect\":45,\"call\":900}"
+    },
+    {
+      "body": "",
+      "code": 200,
+      "path": "/api/mcp/timeouts",
+      "resp": "{\"call\":900,\"connect\":45,\"ok\":true}",
+      "state": "{\"connect\":45,\"call\":900}"
+    },
+    {
+      "body": "{\"connect\":3600,\"call\":1}",
+      "code": 200,
+      "path": "/api/mcp/timeouts/save",
+      "resp": "{\"call\":1,\"connect\":3600,\"ok\":true}",
+      "state": "{\"connect\":3600,\"call\":1}"
+    },
+    {
+      "body": "",
+      "code": 200,
+      "path": "/api/mcp/timeouts",
+      "resp": "{\"call\":1,\"connect\":3600,\"ok\":true}",
+      "state": "{\"connect\":3600,\"call\":1}"
+    }
+  ],
+  "timeouts_stored": [
+    {
+      "in": "",
+      "out": {
+        "connect": 20,
+        "call": 120
+      }
+    },
+    {
+      "in": "{\"connect\":5,\"call\":300}",
+      "out": {
+        "connect": 5,
+        "call": 300
+      }
+    },
+    {
+      "in": "{\"connect\":0,\"call\":0}",
+      "out": {
+        "connect": 20,
+        "call": 120
+      }
+    },
+    {
+      "in": "{\"connect\":-4,\"call\":99999}",
+      "out": {
+        "connect": 20,
+        "call": 3600
+      }
+    },
+    {
+      "in": "{\"connect\":\"x\",\"call\":50}",
+      "out": {
+        "connect": 20,
+        "call": 120
+      }
+    },
+    {
+      "in": "{\"CONNECT\":7,\"Call\":8}",
+      "out": {
+        "connect": 7,
+        "call": 8
+      }
+    },
+    {
+      "in": "null",
+      "out": {
+        "connect": 20,
+        "call": 120
+      }
+    },
+    {
+      "in": "[1]",
+      "out": {
+        "connect": 20,
+        "call": 120
+      }
+    },
+    {
+      "in": "{\"connect\":30,\"call\":40} reste",
+      "out": {
+        "connect": 20,
+        "call": 120
+      }
+    },
+    {
+      "in": "{\"connect\":1.5,\"call\":60}",
+      "out": {
+        "connect": 20,
+        "call": 120
+      }
+    },
+    {
+      "in": "{\"connect\":3600,\"call\":3600,\"autre\":1}",
+      "out": {
+        "connect": 3600,
+        "call": 3600
+      }
+    }
+  ],
   "tool_server": [
     {
       "desc": "[MCP: alpha] desc",

rust/loki-rs/tests/strata.rs

@@ -318,6 +318,7 @@ async fn parite_de_strata() {
             "CTX",
             "STRATA_KV",
             "STRATA_HELPER",
+            "STRATA_SPLIT",
         ] {
             if let Some(v) = bn.go.get("config", k).filter(|v| !v.is_empty()) {
                 after.insert(format!("config/{k}"), Value::String(bn.mask(&v)));