Lot 46 : outils recall et recall_search exécutés par la façade

Les deux outils qui rappellent un bloc archivé par la compaction ne passent
plus par /tool/exec du Go : src/recall.rs porte toolRecall et
toolRecallSearch (id tolérant comme recallIDToSeq, mots-clés en minuscules
rune par rune comme strings.ToLower, score libellé double et plus récent
d'abord, limites, extraits et textes du Go). L'archive reste au Go, seul à
tenir la séquence de la base, qui la sert à la façade
(GET /internal/v1/recall/block?seq=N et /internal/v1/recall/blocks, blocs
chiffrés sous une mémoire verrouillée exclus) ; ses propres outils passent
par les mêmes lectures. Go injoignable : l'appel passe par lui.

Parité : journal de 41 appels sur une archive de 35 blocs tiré du Go
(parity_recall_test.go → tests/parity_recall/recall.json), rejoué par
tests/recall.rs ; un tour de la façade qui rappelle et cherche
(tests/lot6.rs) ; TestRecallInterneLecture 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

@@ -52,6 +52,10 @@ pub struct FakeGo {
     /// Résultat imposé à tout outil (sinon « exec:<nom> »), et archive recall.
     pub tool_result: Mutex<Option<String>>,
     pub recall: Mutex<Vec<String>>,
+    /// Blocs servis par /internal/v1/recall/block(s) (lot 46), et lectures
+    /// reçues (« block <seq> », « blocks »).
+    pub recall_blocks: Mutex<Vec<serde_json::Value>>,
+    pub recall_log: 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.
@@ -502,6 +506,34 @@ async fn handle(st: Arc<FakeGo>, req: Request<Incoming>) -> Response<Full<Bytes>
             ),
             None => resp(200, r#"{"busy":false}"#),
         },
+        "/internal/v1/recall/block" => {
+            let seq = req
+                .uri()
+                .query()
+                .unwrap_or("")
+                .strip_prefix("seq=")
+                .unwrap_or("")
+                .to_string();
+            st.recall_log.lock().unwrap().push(format!("block {seq}"));
+            let found = st
+                .recall_blocks
+                .lock()
+                .unwrap()
+                .iter()
+                .find(|b| b["seq"].as_u64().map(|n| n.to_string()).as_deref() == Some(seq.as_str()))
+                .cloned();
+            match found {
+                Some(b) => resp(200, b.to_string()),
+                None => resp(404, r#"{"error":"bloc introuvable"}"#),
+            }
+        }
+        "/internal/v1/recall/blocks" => {
+            st.recall_log.lock().unwrap().push("blocks".into());
+            resp(
+                200,
+                serde_json::Value::Array(st.recall_blocks.lock().unwrap().clone()).to_string(),
+            )
+        }
         "/internal/v1/service/prestart" => {
             *st.prestarts.lock().unwrap() += 1;
             let e = st.tune_busy.lock().unwrap().clone().unwrap_or_default();