Lot 15 : presets tenus par la façade (LOKI_PRESETS=rust)

La façade sert la liste des presets (pastilles, mesures du bench quand
elles correspondent à la configuration), leur ordre, l'éditeur (lecture,
graine d'un preset neuf, enregistrement avec nom de fichier unique,
prompt système), la suppression (refusée pour l'actif, modèle compris sur
demande), les aperçus de l'éditeur (cache de prompts, second slot, avis
MoE et de chargement, réutilisant le port de loki serve), la copie en
placement auto, les presets externes (la clé n'est jamais rendue, test
par un vrai appel de complétion) et la bascule, quand LOKI_PRESETS=rust
(expérimental ; le Go reste le défaut).

Ce qui touche au moteur reste au Go jusqu'à son lot : facade_presets.go
expose /internal/v1/preset/apply (bascule avec état du slot gardé et
moteur relancé ou arrêté, preset en service réappliqué) et
/internal/v1/tune/guard (verrou de l'optimiseur), et remet les routes du
tunnel à la façade.

Parité : parity_presets_test.go tire du Go les fonctions pures et 70
appels de route avec presets/, models/ et la base après chacun, rejoués
par tests/presets_api.rs ; bascule et application vérifiées de bout en
bout contre le faux Go, presetApply côté Go.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016tcGfJWefW5kUGoC2wL8cv

rust/loki-rs/src/api.rs

@@ -40,6 +40,8 @@ pub struct Ctx {
     pub push: Option<std::sync::Arc<crate::push::Push>>,
     /// Mémoire tenue par la façade (`LOKI_MEM=rust`).
     pub mem: Option<std::sync::Arc<crate::memory::Memory>>,
+    /// Presets tenus par la façade (`LOKI_PRESETS=rust`).
+    pub presets: bool,
     /// Jeton de l'API interne : une requête qui le porte vient du Go.
     pub internal_token: String,
 }
@@ -55,6 +57,7 @@ impl Ctx {
             || self.files.is_some()
             || self.push.is_some()
             || self.mem.is_some()
+            || self.presets
     }
 
     /// La requête vient du Go (jeton interne valide) : déjà authentifiée par

rust/loki-rs/src/lib.rs

@@ -28,6 +28,7 @@ pub mod models;
 pub mod oai;
 pub mod paths;
 pub mod presets;
+pub mod presets_api;
 pub mod proxy;
 pub mod push;
 pub mod serve;

rust/loki-rs/src/main.rs

@@ -145,6 +145,9 @@ fn serve() -> ExitCode {
         // LOKI_MEM=rust : la mémoire (pages, index, trackers, mode mémoire,
         // interrupteurs du mode agent).
         let mem_rust = held_by_facade("LOKI_MEM");
+        // LOKI_PRESETS=rust : les presets (liste, éditeur, aperçus, externes,
+        // bascule ; l'application au moteur reste au Go).
+        let presets_rust = held_by_facade("LOKI_PRESETS");
         let mut env = vec![
             (auth::INTERNAL_ENV.to_string(), token.clone()),
             // Adresse de l'API interne du Go, héritée par ses enfants :
@@ -159,6 +162,7 @@ fn serve() -> ExitCode {
             ("LOKI_FILES", files_rust),
             ("LOKI_PUSH", push_rust),
             ("LOKI_MEM", mem_rust),
+            ("LOKI_PRESETS", presets_rust),
         ];
         for (var, on) in held {
             if on {
@@ -238,6 +242,7 @@ fn serve() -> ExitCode {
             files,
             push: push_rust.then(|| std::sync::Arc::new(loki_rs::push::Push::new())),
             mem: mem_rust.then(|| std::sync::Arc::new(loki_rs::memory::Memory::new(mem_home))),
+            presets: presets_rust,
         };
         let res = proxy::serve(listener, cfg, shutdown_signal()).await;
         eprintln!("[loki-rs] arrêt demandé — arrêt du serveur Go");

rust/loki-rs/src/models.rs

@@ -244,7 +244,7 @@ impl ModelRefs {
     }
 
     /// `modelUsers` : pour UN modèle (nom de fichier ou chemin).
-    fn users(&self, dirs: &ModelDirs, name: &str) -> (Vec<String>, bool) {
+    pub(crate) fn users(&self, dirs: &ModelDirs, name: &str) -> (Vec<String>, bool) {
         let k = dirs.ref_key(name);
         if k.is_empty() {
             return (Vec::new(), false);
@@ -400,7 +400,11 @@ pub fn delete_model(
 }
 
 /// `deleteModelFile` : rend les octets libérés.
-fn delete_model_file(dirs: &ModelDirs, refs: &ModelRefs, name: &str) -> Result<i64, String> {
+pub(crate) fn delete_model_file(
+    dirs: &ModelDirs,
+    refs: &ModelRefs,
+    name: &str,
+) -> Result<i64, String> {
     let p = gguf::resolve_model_path(name, &dirs.home, &dirs.stored, dirs.env.as_deref())?
         .to_string_lossy()
         .into_owned();

rust/loki-rs/src/proxy.rs

@@ -77,6 +77,8 @@ pub struct Config {
     pub push: Option<Arc<crate::push::Push>>,
     /// Mémoire (pages, trackers, mode) tenue par la façade (`LOKI_MEM=rust`).
     pub mem: Option<Arc<crate::memory::Memory>>,
+    /// Presets tenus par la façade (`LOKI_PRESETS=rust`).
+    pub presets: bool,
 }
 
 struct Proxy {
@@ -110,6 +112,7 @@ pub async fn serve(
             files: cfg.files,
             push: cfg.push,
             mem: cfg.mem,
+            presets: cfg.presets,
             internal_token: cfg.internal_token.clone(),
         },
     });
@@ -197,6 +200,9 @@ impl Proxy {
         {
             return chatapi::serve(&self.ctx, chat, req, from_go).await;
         }
+        if self.ctx.presets && crate::presets_api::handles(path) {
+            return crate::presets_api::serve(&self.ctx, req, from_go).await;
+        }
         if let Some(m) = &self.ctx.mem
             && crate::memory::handles(path)
         {

rust/loki-rs/src/serve/run.rs

@@ -384,7 +384,7 @@ fn probe_serve_gpus(env: &Env, cfg: &Cfg, extra: &[String], si: &mut SysInfo) {
 }
 
 /// `probeCacheRAM`.
-fn probe_cache_ram(env: &Env, cfg: &Cfg, extra: &[String], si: &mut SysInfo) {
+pub(crate) fn probe_cache_ram(env: &Env, cfg: &Cfg, extra: &[String], si: &mut SysInfo) {
     probe_env(env, si, CACHE_ARG_ENV, true);
     if !si.model.is_empty() {
         let mp = Path::new(&si.model);

rust/loki-rs/tests/common/fakego.rs

@@ -74,6 +74,10 @@ pub struct FakeGo {
     pub turn_view: Mutex<Option<serde_json::Value>>,
     pub turn_verifier: Mutex<Option<serde_json::Value>>,
     pub tool_results: Mutex<HashMap<String, String>>,
+    /// /internal/v1/tune/guard : message d'une optimisation en cours.
+    pub tune_busy: Mutex<Option<String>>,
+    /// /internal/v1/preset/apply reçus : (chemin, mode).
+    pub preset_applies: Mutex<Vec<(String, String)>>,
     /// Comportement de /internal/v1/crypt/* (préfixe « SCELLE: » par défaut).
     pub crypt_mode: Mutex<CryptMode>,
     /// Réponse de /internal/v1/conv/workspace (None : 404).
@@ -325,6 +329,24 @@ async fn handle(st: Arc<FakeGo>, req: Request<Incoming>) -> Response<Full<Bytes>
             *st.go_busy.lock().unwrap() = None;
             resp(204, "")
         }
+        "/internal/v1/tune/guard" => match st.tune_busy.lock().unwrap().clone() {
+            Some(e) => resp(
+                200,
+                serde_json::json!({ "busy": true, "error": e }).to_string(),
+            ),
+            None => resp(200, r#"{"busy":false}"#),
+        },
+        "/internal/v1/preset/apply" => {
+            let body = req.into_body().collect().await.unwrap().to_bytes();
+            let v: serde_json::Value = serde_json::from_slice(&body).unwrap_or_default();
+            let path = v["path"].as_str().unwrap_or("").to_string();
+            let mode = v["mode"].as_str().unwrap_or("").to_string();
+            if mode == "refus" || path.ends_with("refus.env") {
+                return resp(500, r#"{"error":"application refusée"}"#);
+            }
+            st.preset_applies.lock().unwrap().push((path, mode));
+            resp(204, "")
+        }
         "/internal/v1/conv/workspace" => match st.conv_workspace.lock().unwrap().clone() {
             Some(v) => resp(200, v.to_string()),
             None => resp(404, "404 page not found"),
@@ -507,6 +529,7 @@ pub struct Opts {
     pub files: Option<Arc<loki_rs::convfiles::ConvFiles>>,
     pub push: Option<Arc<loki_rs::push::Push>>,
     pub mem: Option<Arc<loki_rs::memory::Memory>>,
+    pub presets: bool,
 }
 
 /// Comme [`start`], avec la conversation tenue par la façade
@@ -602,6 +625,7 @@ pub async fn start_with(
         files: opts.files,
         push: opts.push,
         mem: opts.mem,
+        presets: opts.presets,
     };
     tokio::spawn(loki_rs::proxy::serve(fl, cfg, async move {
         let _ = rx.await;

rust/loki-rs/tests/lot2.rs

@@ -100,6 +100,7 @@ async fn banc(cle: Option<&str>) -> Banc {
         files: None,
         push: None,
         mem: None,
+        presets: false,
     };
     tokio::spawn(loki_rs::proxy::serve(l, cfg, async move {
         let _ = rx.await;

rust/loki-rs/tests/presets_api.rs

@@ -0,0 +1,414 @@
+//! Lot 15 : presets tenus par la façade (`LOKI_PRESETS=rust`).
+//!
+//! Le journal tiré du Go (`internal/loki/parity_presets_test.go` →
+//! `tests/parity_presets/presets.json`) est rejoué : fonctions pures, puis la
+//! suite d'appels aux routes par la façade, avec après chacun le dossier
+//! presets/ (et models/) et les clés touchées en base. La bascule et
+//! l'enregistrement du preset en service, qui pilotent le moteur au Go, sont
+//! vérifiés de bout en bout contre le faux Go.
+
+mod common;
+
+use std::collections::{BTreeMap, HashMap};
+use std::path::Path;
+
+use common::fakego;
+use loki_rs::presets_api as pa;
+use serde_json::{Value, json};
+
+fn fixture() -> Value {
+    serde_json::from_str(include_str!("parity_presets/presets.json")).expect("journal")
+}
+
+fn s(v: &Value) -> &str {
+    v.as_str().unwrap()
+}
+
+fn strs(v: &Value) -> Vec<String> {
+    v.as_array()
+        .map(|a| a.iter().map(|x| s(x).to_string()).collect())
+        .unwrap_or_default()
+}
+
+fn cfg(v: &Value) -> HashMap<String, String> {
+    v.as_object()
+        .unwrap()
+        .iter()
+        .map(|(k, x)| (k.clone(), s(x).to_string()))
+        .collect()
+}
+
+#[test]
+fn parite_des_fonctions_pures() {
+    let fx = fixture();
+    for c in fx["display_name"].as_array().unwrap() {
+        assert_eq!(
+            pa::with_display_name(s(&c["content"]), s(&c["name"])),
+            s(&c["out"]),
+            "{c}"
+        );
+    }
+    for (v, want) in fx["quote"].as_object().unwrap() {
+        assert_eq!(pa::quote_value(v), s(want), "{v:?}");
+    }
+    let m: BTreeMap<String, String> = [("Z", "1"), ("A", "deux mots"), ("M", ""), ("Q", "q\"q")]
+        .iter()
+        .map(|(k, v)| (k.to_string(), v.to_string()))
+        .collect();
+    assert_eq!(pa::format_env(&m), s(&fx["format_env"]));
+    let home = Path::new("/h");
+    for (n, want) in fx["names"].as_object().unwrap() {
+        let got = match pa::safe_preset_path(home, n) {
+            Ok(_) => "ok".to_string(),
+            Err(e) => e,
+        };
+        assert_eq!(got, s(want), "{n:?}");
+    }
+    for (c, want) in fx["quant"].as_object().unwrap() {
+        assert_eq!(pa::detect_quant(c), s(want), "{c:?}");
+    }
+    for (c, want) in fx["reasoning"].as_object().unwrap() {
+        assert_eq!(pa::preset_reasoning(c), s(want), "{c:?}");
+    }
+    for (c, want) in fx["model"].as_object().unwrap() {
+        assert_eq!(pa::model_from_preset_content(c), s(want), "{c:?}");
+    }
+    for (u, want) in fx["completions"].as_object().unwrap() {
+        assert_eq!(pa::completions_url(u), s(want), "{u:?}");
+    }
+    for c in fx["external"].as_array().unwrap() {
+        assert_eq!(
+            pa::external_preset_content(
+                s(&c["url"]),
+                s(&c["model"]),
+                s(&c["key"]),
+                s(&c["ctx"]),
+                c["vision"].as_bool().unwrap()
+            ),
+            s(&c["out"])
+        );
+    }
+    for (b, want) in fx["api_error"].as_object().unwrap() {
+        assert_eq!(pa::extract_api_error(b.as_bytes()), s(want), "{b:?}");
+    }
+    for c in fx["join"].as_array().unwrap() {
+        assert_eq!(pa::join_args(&strs(&c["args"])), s(&c["out"]), "{c}");
+    }
+    for c in fx["set_key"].as_array().unwrap() {
+        assert_eq!(
+            pa::preset_set_key(s(&c["content"]), s(&c["key"]), s(&c["val"])),
+            s(&c["out"]),
+            "{c}"
+        );
+    }
+    for c in fx["autoplace"].as_array().unwrap() {
+        match pa::auto_placement_preset(s(&c["in"])) {
+            Ok((out, changes)) => {
+                assert_eq!(s(&c["err"]), "", "{c}");
+                assert_eq!(out, s(&c["out"]), "{c}");
+                assert_eq!(changes, strs(&c["changes"]), "{c}");
+            }
+            Err(e) => assert_eq!(e, s(&c["err"]), "{c}"),
+        }
+    }
+    for c in fx["bench_fp"].as_array().unwrap() {
+        assert_eq!(
+            pa::bench_fingerprint(&cfg(&c["cfg"]), &cfg(&c["cur"])),
+            s(&c["out"]),
+            "{c}"
+        );
+    }
+    let tmp = tempfile::tempdir().unwrap();
+    for (p, want) in fx["imposes"].as_object().unwrap() {
+        let p = p.replace("{{HOME}}", tmp.path().to_str().unwrap());
+        assert_eq!(
+            pa::preset_imposes_engine(tmp.path(), &p),
+            want.as_bool().unwrap(),
+            "{p:?}"
+        );
+    }
+}
+
+/// Faux service de complétions : mêmes réponses que celui du test Go.
+async fn fake_completions() -> String {
+    use http_body_util::{BodyExt, Full};
+    use hyper::service::service_fn;
+    use hyper_util::rt::TokioIo;
+    let l = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+    let addr = l.local_addr().unwrap();
+    tokio::spawn(async move {
+        while let Ok((sock, _)) = l.accept().await {
+            tokio::spawn(async move {
+                let svc = service_fn(|req: hyper::Request<hyper::body::Incoming>| async move {
+                    let path = req.uri().path().to_string();
+                    let auth = req
+                        .headers()
+                        .get("authorization")
+                        .map(|v| v.to_str().unwrap().to_string())
+                        .unwrap_or_default();
+                    let body = req.into_body().collect().await.unwrap().to_bytes();
+                    let (code, out): (u16, &str) = if path.starts_with("/ok/") {
+                        if String::from_utf8_lossy(&body).contains("\"max_tokens\":1")
+                            && auth == "Bearer k1"
+                        {
+                            (200, "{}")
+                        } else {
+                            (400, "")
+                        }
+                    } else if path.starts_with("/refus/") {
+                        (401, r#"{"error":{"message":"clé invalide"}}"#)
+                    } else if path.starts_with("/brut/") {
+                        (404, " page absente ")
+                    } else {
+                        (500, "")
+                    };
+                    let mut r = hyper::Response::new(Full::new(bytes::Bytes::from(out)));
+                    *r.status_mut() = hyper::StatusCode::from_u16(code).unwrap();
+                    Ok::<_, std::convert::Infallible>(r)
+                });
+                let _ = hyper::server::conn::http1::Builder::new()
+                    .serve_connection(TokioIo::new(sock), svc)
+                    .await;
+            });
+        }
+    });
+    format!("http://{addr}")
+}
+
+fn apply_store(go: &fakego::FakeGo, m: &serde_json::Map<String, Value>) {
+    for (k, v) in m {
+        let (b, key) = k.split_once('/').unwrap();
+        let mut st = go.store.lock().unwrap();
+        let bucket = st.entry(b.to_string()).or_default();
+        if s(v).is_empty() {
+            bucket.remove(key);
+        } else {
+            bucket.insert(key.to_string(), s(v).as_bytes().to_vec());
+        }
+    }
+}
+
+fn disk(home: &Path) -> BTreeMap<String, String> {
+    let mut out = BTreeMap::new();
+    for d in ["presets", "models"] {
+        if let Ok(rd) = std::fs::read_dir(home.join(d)) {
+            for e in rd.flatten() {
+                out.insert(
+                    format!("{d}/{}", e.file_name().to_string_lossy()),
+                    String::from_utf8_lossy(&std::fs::read(e.path()).unwrap()).into_owned(),
+                );
+            }
+        }
+    }
+    out
+}
+
+/// Retire récursivement les champs à zéro : le Go réécrit les mesures restantes
+/// par sa struct (champs nuls ajoutés), la façade les garde telles quelles —
+/// même lecture pour le Go.
+fn sans_zeros(v: &Value) -> Value {
+    match v {
+        Value::Object(m) => Value::Object(
+            m.iter()
+                .filter(|(_, x)| {
+                    !(x.is_null()
+                        || x.as_f64() == Some(0.0)
+                        || x.as_str() == Some("")
+                        || x.as_bool() == Some(false))
+                })
+                .map(|(k, x)| (k.clone(), sans_zeros(x)))
+                .collect(),
+        ),
+        Value::Array(a) => Value::Array(a.iter().map(sans_zeros).collect()),
+        x => x.clone(),
+    }
+}
+
+fn state(go: &fakego::FakeGo) -> Value {
+    let mut st = serde_json::Map::new();
+    if let Some(b) = go.store.lock().unwrap().get("state") {
+        for (k, v) in b {
+            let txt = String::from_utf8_lossy(v).into_owned();
+            if k.starts_with("sysprompt:") {
+                st.insert(k.clone(), json!(txt));
+            } else if k == "preset_order" || k == "bench_presets" {
+                st.insert(k.clone(), serde_json::from_str(&txt).unwrap_or(Value::Null));
+            }
+        }
+    }
+    Value::Object(st)
+}
+
+#[tokio::test]
+async fn parite_des_routes() {
+    let fx = fixture();
+    let tmp = tempfile::tempdir().unwrap();
+    let home = tmp.path().to_path_buf();
+    let h = home.to_string_lossy().into_owned();
+    let url = fake_completions().await;
+    let opts = fakego::Opts {
+        presets: true,
+        ..Default::default()
+    };
+    let (facade, go, _stop, _) = fakego::start_with(home.clone(), opts).await;
+    apply_store(&go, fx["seed"].as_object().unwrap());
+    for (i, st) in fx["steps"].as_array().unwrap().iter().enumerate() {
+        if let Some(files) = st.get("files").and_then(Value::as_object) {
+            for (rel, content) in files {
+                let p = home.join(rel);
+                if s(content).is_empty() {
+                    let _ = std::fs::remove_file(&p);
+                } else {
+                    std::fs::create_dir_all(p.parent().unwrap()).unwrap();
+                    std::fs::write(&p, s(content)).unwrap();
+                }
+            }
+        }
+        if let Some(m) = st.get("store").and_then(Value::as_object) {
+            apply_store(&go, m);
+        }
+        let (m, p) = (s(&st["method"]), s(&st["path"]));
+        let body = st
+            .get("body")
+            .and_then(Value::as_str)
+            .unwrap_or("")
+            .replace("{{URL}}", &url);
+        let (code, b) = fakego::send(facade, m, p, &[], &body).await;
+        let ctx = format!("étape {i} : {m} {p} {body}");
+        let txt = String::from_utf8_lossy(&b)
+            .replace(&url, "{{URL}}")
+            .replace(&h, "{{HOME}}");
+        assert_eq!(
+            u64::from(code.as_u16()),
+            st["status"].as_u64().unwrap(),
+            "{ctx} : {txt}"
+        );
+        let got: Value = serde_json::from_str(&txt).unwrap();
+        assert_eq!(got, st["out"], "{ctx}");
+        let d: BTreeMap<String, String> = disk(&home)
+            .into_iter()
+            .map(|(k, v)| (k, v.replace(&url, "{{URL}}")))
+            .collect();
+        let want_disk: BTreeMap<String, String> =
+            serde_json::from_value(st["disk"].clone()).unwrap();
+        assert_eq!(d, want_disk, "{ctx} (disque)");
+        assert_eq!(
+            sans_zeros(&state(&go)),
+            sans_zeros(&st["state"]),
+            "{ctx} (base)"
+        );
+    }
+    assert!(go.preset_applies.lock().unwrap().is_empty());
+}
+
+/// Bascule, enregistrement du preset en service, verrou de l'optimiseur :
+/// la façade fait appliquer par le Go.
+#[tokio::test]
+async fn bascule_et_application() {
+    let tmp = tempfile::tempdir().unwrap();
+    let home = tmp.path().to_path_buf();
+    let opts = fakego::Opts {
+        presets: true,
+        ..Default::default()
+    };
+    let (facade, go, _stop, _) = fakego::start_with(home.clone(), opts).await;
+    let dir = home.join("presets");
+    std::fs::create_dir_all(&dir).unwrap();
+    std::fs::write(dir.join("a.env"), "# NAME=Alpha\nMODEL=a.gguf\n").unwrap();
+    std::fs::write(dir.join("b.env"), "# NAME=Beta\nMODEL=b.gguf\n").unwrap();
+    std::fs::write(dir.join("refus.env"), "# NAME=Zut\nMODEL=z.gguf\n").unwrap();
+    go.set("config", "MODEL", "a.gguf");
+
+    let (c, b) = fakego::send(facade, "POST", "/api/switch", &[], r#"{"id":"b"}"#).await;
+    assert_eq!(c, 200);
+    assert_eq!(
+        serde_json::from_slice::<Value>(&b).unwrap(),
+        json!({ "ok": true, "preset": "Beta" })
+    );
+    let (c, b) = fakego::send(facade, "POST", "/api/switch", &[], r#"{"n":1}"#).await;
+    assert_eq!(c, 200, "{}", String::from_utf8_lossy(&b));
+    let (c, b) = fakego::send(facade, "POST", "/api/switch", &[], r#"{"id":"zz"}"#).await;
+    assert_eq!(c, 404);
+    assert_eq!(
+        serde_json::from_slice::<Value>(&b).unwrap()["error"],
+        "preset introuvable (supprimé ou renommé ?)"
+    );
+    let (c, _) = fakego::send(facade, "POST", "/api/switch", &[], r#"{"n":9}"#).await;
+    assert_eq!(c, 400);
+    let (c, b) = fakego::send(facade, "POST", "/api/switch", &[], r#"{"id":"refus"}"#).await;
+    assert_eq!(c, 500);
+    assert_eq!(
+        serde_json::from_slice::<Value>(&b).unwrap()["error"],
+        "application refusée"
+    );
+    // Le preset en service (a) modifié : appliqué, moteur relancé par le Go.
+    let (c, b) = fakego::send(
+        facade,
+        "POST",
+        "/api/preset/save",
+        &[],
+        r#"{"id":"a","name":"Alpha","content":"MODEL=a.gguf\nCTX=100000\n","sysprompt":"Bref."}"#,
+    )
+    .await;
+    assert_eq!(c, 200);
+    assert_eq!(
+        serde_json::from_slice::<Value>(&b).unwrap()["applied"],
+        true
+    );
+    assert_eq!(go.get("state", "sysprompt:a").as_deref(), Some("Bref."));
+    let applies = go.preset_applies.lock().unwrap().clone();
+    let names: Vec<(String, String)> = applies
+        .iter()
+        .map(|(p, m)| {
+            (
+                Path::new(p)
+                    .file_name()
+                    .unwrap()
+                    .to_string_lossy()
+                    .into_owned(),
+                m.clone(),
+            )
+        })
+        .collect();
+    assert_eq!(
+        names,
+        vec![
+            ("b.env".to_string(), "switch".to_string()),
+            ("a.env".to_string(), "switch".to_string()),
+            ("a.env".to_string(), "save".to_string()),
+        ]
+    );
+    // Optimisation en cours : refus, rien d'appliqué.
+    *go.tune_busy.lock().unwrap() = Some("une optimisation tient le moteur".into());
+    let (c, b) = fakego::send(facade, "POST", "/api/switch", &[], r#"{"id":"b"}"#).await;
+    assert_eq!(c, 409);
+    assert_eq!(
+        serde_json::from_slice::<Value>(&b).unwrap(),
+        json!({ "ok": false, "tuning": true, "error": "une optimisation tient le moteur" })
+    );
+    let (c, _) = fakego::send(
+        facade,
+        "POST",
+        "/api/preset/save",
+        &[],
+        r#"{"name":"N","content":"X=1"}"#,
+    )
+    .await;
+    assert_eq!(c, 409);
+    assert_eq!(go.preset_applies.lock().unwrap().len(), 3);
+}
+
+#[tokio::test]
+async fn sans_la_variable_les_presets_restent_au_go() {
+    let tmp = tempfile::tempdir().unwrap();
+    let (facade, _go, _stop) = fakego::start(tmp.path().to_path_buf()).await;
+    for p in [
+        "/api/presets",
+        "/api/preset/save",
+        "/api/switch",
+        "/api/preset/external/test",
+    ] {
+        let (_, _, b) = fakego::get(facade, p, &[]).await;
+        assert_eq!(&b[..], format!("go:{p}").as_bytes());
+    }
+}

rust/loki-rs/tests/proxy.rs

@@ -106,6 +106,7 @@ async fn facade(backend: SocketAddr) -> (SocketAddr, oneshot::Sender<()>) {
         files: None,
         push: None,
         mem: None,
+        presets: false,
     };
     tokio::spawn(loki_rs::proxy::serve(l, cfg, async move {
         let _ = rx.await;