Lot 28 : optimiseur tenu par la façade (LOKI_TUNE=rust)

Avec LOKI_TUNE=rust (expérimental, Unix seulement), la façade sert
/api/tune, /api/tune/status, /api/tune/cancel, /api/tune/apply et
/api/tune/last, et déroule l'optimisation sans perte (rust/loki-rs/src/tune) :
vrai moteur arrêté, essais composés à blanc puis lancés par les « loki
serve » du Go (LOKI_TUNE_TRIAL), chacun dans son groupe de processus,
mesurés par le bench complet à profondeur fixe, retenus au-delà du
bruit ; vrai moteur relancé. Rien n'est écrit sans un clic : copie du
preset, ou le preset lui-même — redémarrage, sonde, et ancienne version
rétablie si elle échoue.

- tune/core.rs : la partie pure (EXTRA_ARGS, réglages, essais de chaque
  étape, garde-fous, diff et réécriture du preset, score) ;
- tune/lock.rs : le verrou tune.lock au format du Go, identité des
  processus comme procIdentity (la reprise du Go reconnaît la façade
  vivante, et écarte son verrou si elle meurt), ménage d'un verrou
  périmé (essai orphelin arrêté, application interrompue défaite) ;
- tune/job.rs : routes, job, essais et application.

Le verrou de génération reste celui du Go, pris par le bail du moteur au
motif « tune » (refus de l'optimiseur pour les autres, stop du chat qui
annule). Le Go prête /internal/v1/tune/context (bench, génération, jobs
du mode code, état du moteur, télémétrie) et le démarrage ou l'arrêt du
moteur sans le refus de l'optimiseur (service/action « os »). Hors
Unix, la façade passe LOKI_TUNE vide au Go, qui garde l'optimiseur.

serde_json lit désormais les flottants à l'arrondi exact
(float_roundtrip), comme le Go.

Parité : parity_tune_test.go tire du Go un journal (partie pure, contenu
du verrou, résultat enregistré, vérification après application) rejoué
par tests/tune_core.rs. tests/tune.rs déroule de vraies optimisations, le
binaire de test jouant « loki serve » ; les tests du verrou du Go sont
portés ; TestFacadeTune côté Go.

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

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

@@ -117,6 +117,14 @@ pub struct FakeGo {
     pub bench_perfs: Mutex<Vec<serde_json::Value>>,
     /// Délai avant de répondre à une prise de bail.
     pub lease_delay: Mutex<Option<std::time::Duration>>,
+    /// /internal/v1/tune/context : refus du processus web et télémétrie
+    /// (« main_active » : `service_active`).
+    pub tune_ctx_busy: Mutex<String>,
+    pub tune_perf: Mutex<serde_json::Value>,
+    /// /internal/v1/service/action reçus avec « os » ; une erreur à rendre
+    /// pour une action donnée.
+    pub service_os: Mutex<Vec<String>>,
+    pub service_os_fail: Mutex<Option<(String, String)>>,
 }
 
 impl FakeGo {
@@ -470,6 +478,19 @@ async fn handle(st: Arc<FakeGo>, req: Request<Incoming>) -> Response<Full<Bytes>
             let body = req.into_body().collect().await.unwrap().to_bytes();
             let v: serde_json::Value = serde_json::from_slice(&body).unwrap_or_default();
             let if_active = v["if_active"].as_bool().unwrap_or(false);
+            if v["os"].as_bool() == Some(true) {
+                let action = v["action"].as_str().unwrap_or("").to_string();
+                st.service_os.lock().unwrap().push(action.clone());
+                let fail = st.service_os_fail.lock().unwrap().clone();
+                if let Some((a, e)) = fail.filter(|(a, _)| *a == action) {
+                    let _ = a;
+                    return resp(
+                        200,
+                        serde_json::json!({"ran": true, "error": e}).to_string(),
+                    );
+                }
+                return resp(200, r#"{"ran":true,"error":""}"#);
+            }
             st.service_actions
                 .lock()
                 .unwrap()
@@ -479,6 +500,14 @@ async fn handle(st: Arc<FakeGo>, req: Request<Incoming>) -> Response<Full<Bytes>
             }
             resp(200, r#"{"ran":true,"error":""}"#)
         }
+        "/internal/v1/tune/context" => {
+            let v = serde_json::json!({
+                "busy": *st.tune_ctx_busy.lock().unwrap(),
+                "main_active": *st.service_active.lock().unwrap(),
+                "perf": *st.tune_perf.lock().unwrap(),
+            });
+            resp(200, v.to_string())
+        }
         "/internal/v1/dictate/stop" => {
             *st.dictate_stops.lock().unwrap() += 1;
             resp(204, "")
@@ -756,6 +785,7 @@ pub struct Opts {
     pub strata: Option<Arc<loki_rs::strata::api::Strata>>,
     pub tasks: Option<Arc<loki_rs::tasks::Tasks>>,
     pub bench: Option<Arc<loki_rs::bench::job::Bench>>,
+    pub tune: Option<Arc<loki_rs::tune::job::Tune>>,
     /// Base de départ, posée avant que la façade démarre : (bucket, clé,
     /// valeur).
     pub seed: Vec<(String, String, String)>,
@@ -868,6 +898,7 @@ pub async fn start_with(
         strata: opts.strata,
         tasks: opts.tasks,
         bench: opts.bench,
+        tune: opts.tune,
     };
     tokio::spawn(loki_rs::proxy::serve(fl, cfg, async move {
         let _ = rx.await;