Lot 6 : un tour de discussion de bout en bout en Rust (chat::generate)

Port d'EnqueueOrStart, StartTurn, generate, drainQueued,
startQueuedIfAny, dropQueued et compactAndPublish :
- envoi : réessai reconnu (cid), tour préparé par le Go (/turn/start), mis
  en file si un tour tourne, sinon moteur prêt (/health), verrou du tour
  puis bail du moteur du Go, bulle journalisée et enregistrée tout de suite ;
- tour : compaction de début de tour, vue d'envoi (tête du Go, historique
  sans <context_update>, préambule fusionné comme InjectSkills), boucle
  dont chaque événement devient un delta du journal, historique rangé
  (outils, réponse, raisonnement renvoyé, rappels en porte-à-faux retirés),
  contexte estimé si le moteur ne le compte pas, compaction de fin de tour ;
- fin : turn_done, journal coalescé, verrou et bail rendus, discussion
  enregistrée, file abandonnée après un stop ou message suivant lancé,
  sinon Web Push ;
- stop : le tour en cours, ou le détenteur Go du moteur.

chat::history porte historyFromView, dropStrayNudges, le rappel des pages
mémoire lues, l'assemblage d'InjectSkills et la forme des tool_used du
journal, avec leurs tests Go. ConvState garde ctxUsedLen et genPeak en
mémoire seulement. EngineLease::interrupted ne garde plus de verrou à
travers une attente.

Écarts : boucle de vérification du mode Code, critères pour la
compaction, préchauffage, télémétrie, retry_patterns personnalisés.

Tests de bout en bout : tour complet (outil, réponse, bail rendu,
discussion enregistrée, doublon), message en file injecté entre deux
étapes, moteur tenu par une tâche planifiée (409, stop), moteur pas prêt.

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

@@ -42,6 +42,8 @@ pub struct FakeGo {
     pub recall: Mutex<Vec<String>>,
     /// Discussion active annoncée et discussions supprimées.
     pub conv_log: Mutex<Vec<String>>,
+    /// Tours : débuts, vues et fins demandés.
+    pub turn_log: Mutex<Vec<String>>,
     /// Adresse d'écoute du faux Go (pour un client `Store` direct).
     pub backend: Mutex<Option<SocketAddr>>,
 }
@@ -191,6 +193,34 @@ async fn handle(st: Arc<FakeGo>, req: Request<Incoming>) -> Response<Full<Bytes>
                 .push(format!("{what} {}", v["id"].as_str().unwrap_or_default()));
             resp(204, "")
         }
+        "/internal/v1/turn/start" => {
+            let body = req.into_body().collect().await.unwrap().to_bytes();
+            let v: serde_json::Value = serde_json::from_slice(&body).unwrap_or_default();
+            let msg = v["message"].as_str().unwrap_or_default().to_string();
+            st.turn_log.lock().unwrap().push(format!("start {msg}"));
+            if msg.trim().is_empty() {
+                return resp(400, r#"{"error":"message vide"}"#);
+            }
+            let caps = serde_json::json!({"Agent": true, "Mem": "off", "Code": false, "Role": ""});
+            let out = serde_json::json!({
+                "files": [], "caps": caps, "turn_caps": caps,
+                "content": msg, "model": "m1", "code_hint": false,
+            });
+            resp(200, out.to_string())
+        }
+        "/internal/v1/turn/view" => {
+            st.turn_log.lock().unwrap().push("view".into());
+            let out = serde_json::json!({
+                "head": [{"role": "system", "content": "Tu es Loki."}],
+                "prefix": "PRÉAMBULE",
+                "tools": [{"type": "function", "function": {"name": "bash", "description": "", "parameters": {"type": "object"}}}],
+            });
+            resp(200, out.to_string())
+        }
+        "/internal/v1/turn/done" => {
+            st.turn_log.lock().unwrap().push("done".into());
+            resp(204, "")
+        }
         "/internal/v1/engine/stop" => {
             st.lease_log.lock().unwrap().push("stop".into());
             *st.go_busy.lock().unwrap() = None;