Lot 13 : mémoire tenue par la façade (LOKI_MEM=rust)

La façade sert l'éditeur des pages mémoire (lecture, enregistrement,
renommage, suppression, déplacement vers un autre projet, index MEMORY.md
tenu par le code), le panneau des trackers, le mode mémoire du projet
actif et les interrupteurs du mode agent, quand LOKI_MEM=rust
(expérimental ; le Go reste le défaut).

Les pages restent des fichiers memory/<projet>/*.md écrits de façon sûre
(.bak, temporaire synchronisé puis renommé, relecture vérifiée), les
trackers des valeurs du bucket tracker. Le chiffrement reste au Go : la
façade fait ouvrir et sceller ses contenus par /internal/v1/crypt/*, et
n'écrit jamais en clair quand la mémoire est verrouillée.

gojson.rs reproduit le décodage d'encoding/json (première valeur, EOF,
erreurs du scanner et de type, structs anonymes) pour renvoyer au client
les mêmes messages que le Go ; il servira aux lots suivants.

Côté Go : facade_mem.go remet ces routes à la façade quand elles arrivent
par le tunnel ; coffre, instantanés, sauvegarde et projets restent au Go.

Parité : parity_gojson_test.go (81 corps) → tests/gojson.rs ;
parity_mem_test.go (noms, titres, slugs, modes, 36 dates, 102 appels de
route avec le disque et la base après chacun) → tests/memory.rs.

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

@@ -16,6 +16,18 @@ use tokio::sync::oneshot;
 
 pub const JETON: &str = "0123456789abcdef0123456789abcdef";
 
+/// Scellement simulé par le faux Go.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum CryptMode {
+    /// « SCELLE: » + clair (historique des essais de la conversation).
+    #[default]
+    Scelle,
+    /// Chiffrement coupé : rien ne change.
+    Plain,
+    /// Magic des pages mémoire (`LOKIMEMv1`) + clair.
+    Magic,
+}
+
 #[derive(Default)]
 pub struct FakeGo {
     /// bucket → clé → valeur.
@@ -62,6 +74,8 @@ 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>>,
+    /// 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).
     pub conv_workspace: Mutex<Option<serde_json::Value>>,
 }
@@ -148,6 +162,24 @@ async fn handle(st: Arc<FakeGo>, req: Request<Incoming>) -> Response<Full<Bytes>
                 return resp(423, r#"{"error":"mémoire verrouillée"}"#);
             }
             let body = req.into_body().collect().await.unwrap().to_bytes();
+            match *st.crypt_mode.lock().unwrap() {
+                // Chiffrement coupé : clair rendu tel quel.
+                CryptMode::Plain => return resp(200, body),
+                // Enveloppe au magic des pages (`LOKIMEMv1`).
+                CryptMode::Magic => {
+                    return if path.ends_with("seal") {
+                        let mut out = b"LOKIMEMv1".to_vec();
+                        out.extend_from_slice(&body);
+                        resp(200, out)
+                    } else {
+                        resp(
+                            200,
+                            body.strip_prefix(b"LOKIMEMv1").unwrap_or(&body).to_vec(),
+                        )
+                    };
+                }
+                CryptMode::Scelle => {}
+            }
             if path.ends_with("seal") {
                 let mut out = b"SCELLE:".to_vec();
                 out.extend_from_slice(&body);
@@ -474,6 +506,7 @@ pub struct Opts {
     pub settings: bool,
     pub files: Option<Arc<loki_rs::convfiles::ConvFiles>>,
     pub push: Option<Arc<loki_rs::push::Push>>,
+    pub mem: Option<Arc<loki_rs::memory::Memory>>,
 }
 
 /// Comme [`start`], avec la conversation tenue par la façade
@@ -568,6 +601,7 @@ pub async fn start_with(
         settings: opts.settings,
         files: opts.files,
         push: opts.push,
+        mem: opts.mem,
     };
     tokio::spawn(loki_rs::proxy::serve(fl, cfg, async move {
         let _ = rx.await;

rust/loki-rs/tests/gojson.rs

@@ -0,0 +1,41 @@
+//! Décodage JSON des requêtes au comportement d'`encoding/json` : le journal
+//! tiré du Go (`internal/loki/parity_gojson_test.go` →
+//! `tests/parity_gojson/decode.json`) est rejoué contre `gojson`.
+
+use loki_rs::gojson::{Kind, decode_struct};
+use serde_json::{Value, json};
+
+const FIELDS: &[(&str, Kind)] = &[
+    ("name", Kind::Str),
+    ("on", Kind::Bool),
+    ("n", Kind::Int),
+    ("args", Kind::StrList),
+    ("env", Kind::StrMap),
+    ("opt", Kind::OptStr),
+    ("flag", Kind::OptBool),
+];
+
+#[test]
+fn parite_du_decodage() {
+    let fx: Value =
+        serde_json::from_str(include_str!("parity_gojson/decode.json")).expect("journal");
+    for c in fx["cases"].as_array().unwrap() {
+        let input = c["in"].as_str().unwrap();
+        let d = decode_struct(input.as_bytes(), "parityDecodeT", FIELDS);
+        let out = json!({
+            "name": d.str("name"),
+            "on": d.bool("on"),
+            "n": d.int("n"),
+            "args": d.str_list("args"),
+            "env": d.str_map("env").map(|m| m.into_iter().map(|(k, v)| (k, Value::String(v))).collect::<serde_json::Map<_, _>>()),
+            "opt": d.opt_str("opt"),
+            "flag": d.opt_bool("flag"),
+        });
+        assert_eq!(out, c["out"], "{input:?} : champs");
+        assert_eq!(
+            d.err.as_deref().unwrap_or(""),
+            c["err"].as_str().unwrap_or(""),
+            "{input:?} : erreur"
+        );
+    }
+}

rust/loki-rs/tests/lot2.rs

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

rust/loki-rs/tests/memory.rs

@@ -0,0 +1,394 @@
+//! Lot 13 : mémoire tenue par la façade (`LOKI_MEM=rust`).
+//!
+//! Le journal tiré du Go (`internal/loki/parity_mem_test.go` →
+//! `tests/parity_mem/mem.json`) est rejoué : noms et titres de pages, slugs,
+//! modes mémoire, dates des trackers (fuseau fixe UTC+2), puis la suite
+//! d'appels aux routes par la façade, avec après chacun le dossier memory/ et
+//! les clés touchées en base.
+
+mod common;
+
+use std::collections::BTreeMap;
+use std::path::Path;
+use std::sync::Arc;
+
+use common::fakego::{self, CryptMode};
+use loki_rs::memory::{self, Memory, Tz};
+use serde_json::{Value, json};
+
+fn fixture() -> Value {
+    serde_json::from_str(include_str!("parity_mem/mem.json")).expect("journal")
+}
+
+fn now_ms() -> i64 {
+    std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_millis() as i64
+}
+
+/// Masque identifiants de points et instants « maintenant », dans l'ordre
+/// d'apparition (même règle que le test Go).
+#[derive(Default)]
+struct Masker {
+    ids: Vec<(String, String)>,
+}
+
+impl Masker {
+    fn mask(&mut self, s: &str) -> String {
+        let id_re = regex::Regex::new(r#""id":"(\d{15,})""#).unwrap();
+        let mut out = String::new();
+        let mut last = 0;
+        for c in id_re.captures_iter(s) {
+            let m = c.get(0).unwrap();
+            let id = c[1].to_string();
+            let ph = match self.ids.iter().find(|(i, _)| *i == id) {
+                Some((_, p)) => p.clone(),
+                None => {
+                    let p = format!("{{{{ID{}}}}}", self.ids.len() + 1);
+                    self.ids.push((id, p.clone()));
+                    p
+                }
+            };
+            out.push_str(&s[last..m.start()]);
+            out.push_str(&format!(r#""id":"{ph}""#));
+            last = m.end();
+        }
+        out.push_str(&s[last..]);
+        let now_re = regex::Regex::new(r#""(ts|first_ts|last_ts)":(\d{12,14})"#).unwrap();
+        let now = now_ms();
+        now_re
+            .replace_all(&out, |c: &regex::Captures| {
+                let v: i64 = c[2].parse().unwrap();
+                if (v - now).abs() < 86_400_000 {
+                    format!(r#""{}":"{{{{NOW}}}}""#, &c[1])
+                } else {
+                    c[0].to_string()
+                }
+            })
+            .into_owned()
+    }
+
+    fn unmask(&self, s: &str) -> String {
+        let mut s = s.to_string();
+        for (id, ph) in &self.ids {
+            s = s.replace(ph, id);
+        }
+        s
+    }
+
+    fn canon(&mut self, v: &Value) -> Value {
+        serde_json::from_str(&self.mask(&serde_json::to_string(v).unwrap())).unwrap()
+    }
+}
+
+#[test]
+fn parite_des_fonctions_pures() {
+    let fx = fixture();
+    for c in fx["names"].as_array().unwrap() {
+        let input = c["in"].as_str().unwrap();
+        match memory::mem_file_name(input) {
+            Ok(o) => assert_eq!(o, c["out"].as_str().unwrap_or("<erreur>"), "{input:?}"),
+            Err(e) => assert_eq!(e, c["err"].as_str().unwrap_or("<ok>"), "{input:?}"),
+        }
+    }
+    for (input, want) in fx["titles"].as_object().unwrap() {
+        assert_eq!(memory::title_of(input), want.as_str().unwrap(), "{input:?}");
+    }
+    for (input, want) in fx["slugs"].as_object().unwrap() {
+        assert_eq!(
+            memory::slugify_ident(input),
+            want.as_str().unwrap(),
+            "{input:?}"
+        );
+    }
+    for (input, want) in fx["modes"].as_object().unwrap() {
+        assert_eq!(
+            memory::normalize_mem_mode(input),
+            want.as_str().unwrap(),
+            "{input:?}"
+        );
+    }
+    for c in fx["when"].as_array().unwrap() {
+        let input = c["in"].as_str().unwrap();
+        let now = now_ms();
+        match memory::parse_when(input, now, Tz::Fixed(7200)) {
+            Ok((ts, date_only)) => {
+                assert!(c.get("err").is_none(), "{input:?} : erreur attendue");
+                let got = if (ts - now).abs() < 86_400_000 {
+                    json!("{{NOW}}")
+                } else {
+                    json!(ts)
+                };
+                assert_eq!(got, c["ts"], "{input:?}");
+                assert_eq!(
+                    date_only,
+                    c["date_only"].as_bool().unwrap_or(false),
+                    "{input:?}"
+                );
+            }
+            Err(e) => assert_eq!(e, c["err"].as_str().unwrap_or("<ok>"), "{input:?}"),
+        }
+    }
+}
+
+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 v = v.as_str().unwrap();
+        let mut s = go.store.lock().unwrap();
+        let bucket = s.entry(b.to_string()).or_default();
+        if v.is_empty() {
+            bucket.remove(key);
+        } else {
+            bucket.insert(key.to_string(), v.as_bytes().to_vec());
+        }
+    }
+}
+
+fn disk(root: &Path) -> BTreeMap<String, String> {
+    fn walk(root: &Path, dir: &Path, out: &mut BTreeMap<String, String>) {
+        let Ok(rd) = std::fs::read_dir(dir) else {
+            return;
+        };
+        for e in rd.flatten() {
+            let p = e.path();
+            if e.file_type().unwrap().is_dir() {
+                walk(root, &p, out);
+            } else {
+                let rel = p
+                    .strip_prefix(root)
+                    .unwrap()
+                    .to_string_lossy()
+                    .replace('\\', "/");
+                out.insert(
+                    rel,
+                    String::from_utf8_lossy(&std::fs::read(&p).unwrap()).into_owned(),
+                );
+            }
+        }
+    }
+    let mut out = BTreeMap::new();
+    walk(root, root, &mut out);
+    out
+}
+
+fn state(go: &fakego::FakeGo) -> Value {
+    let get = |b: &str, k: &str| go.get(b, k).unwrap_or_default();
+    let projects = go
+        .get("state", "projects")
+        .and_then(|p| serde_json::from_str::<Value>(&p).ok())
+        .unwrap_or(Value::Null);
+    let mut trackers = serde_json::Map::new();
+    let mut raw = serde_json::Map::new();
+    if let Some(b) = go.store.lock().unwrap().get("tracker") {
+        for (k, v) in b {
+            let s = String::from_utf8_lossy(v).into_owned();
+            match serde_json::from_str::<Value>(&s) {
+                Ok(x) => {
+                    trackers.insert(k.clone(), x);
+                }
+                Err(_) => {
+                    raw.insert(k.clone(), Value::String(s));
+                }
+            }
+        }
+    }
+    json!({
+        "agent": get("state", "agent"),
+        "active": get("state", "active_project"),
+        "compact": get("config", "COMPACT"),
+        "mem_mode": get("config", "MEM_MODE"),
+        "projects": projects,
+        "trackers": trackers,
+        "tracker_raw": raw,
+    })
+}
+
+async fn start(home: &Path, tz: Tz) -> (std::net::SocketAddr, Arc<fakego::FakeGo>, impl Drop) {
+    let opts = fakego::Opts {
+        mem: Some(Arc::new(Memory::with_tz(home.to_path_buf(), tz))),
+        ..Default::default()
+    };
+    let (facade, go, stop, _) = fakego::start_with(home.to_path_buf(), opts).await;
+    struct Stop(Option<tokio::sync::oneshot::Sender<()>>);
+    impl Drop for Stop {
+        fn drop(&mut self) {
+            if let Some(s) = self.0.take() {
+                let _ = s.send(());
+            }
+        }
+    }
+    (facade, go, Stop(Some(stop)))
+}
+
+#[tokio::test]
+async fn parite_des_routes() {
+    let fx = fixture();
+    let tmp = tempfile::tempdir().unwrap();
+    let home = tmp.path().to_path_buf();
+    let (facade, go, _stop) = start(&home, Tz::Fixed(7200)).await;
+    *go.crypt_mode.lock().unwrap() = CryptMode::Plain;
+    apply_store(&go, fx["seed"].as_object().unwrap());
+    let root = home.join("memory");
+    let mut mk = Masker::default();
+    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 = root.join(rel);
+                let content = content.as_str().unwrap();
+                if content.is_empty() {
+                    let _ = std::fs::remove_dir_all(&p);
+                    let _ = std::fs::remove_file(&p);
+                } else if rel.ends_with('/') {
+                    std::fs::create_dir_all(&p).unwrap();
+                } else {
+                    std::fs::create_dir_all(p.parent().unwrap()).unwrap();
+                    std::fs::write(&p, content).unwrap();
+                }
+            }
+        }
+        if let Some(s) = st.get("store").and_then(Value::as_object) {
+            apply_store(&go, s);
+        }
+        let (m, p) = (st["method"].as_str().unwrap(), st["path"].as_str().unwrap());
+        let body = st.get("body").and_then(Value::as_str).unwrap_or("");
+        let (path, body) = (mk.unmask(p), mk.unmask(body));
+        let (code, b) = fakego::send(facade, m, &path, &[], &body).await;
+        let ctx = format!("étape {i} : {m} {p} {body}");
+        assert_eq!(
+            u64::from(code.as_u16()),
+            st["status"].as_u64().unwrap(),
+            "{ctx} : {}",
+            String::from_utf8_lossy(&b)
+        );
+        let got: Value = serde_json::from_slice(&b).unwrap();
+        assert_eq!(mk.canon(&got), st["out"], "{ctx}");
+        let want_disk: BTreeMap<String, String> =
+            serde_json::from_value(st["disk"].clone()).unwrap();
+        assert_eq!(disk(&root), want_disk, "{ctx} (disque)");
+        assert_eq!(mk.canon(&state(&go)), st["state"], "{ctx} (base)");
+    }
+}
+
+/// Pages chiffrées : ouvertes par le Go, écrites scellées ; mémoire
+/// verrouillée : listées sans contenu, jamais réécrites en clair.
+#[tokio::test]
+async fn pages_et_trackers_chiffres() {
+    let tmp = tempfile::tempdir().unwrap();
+    let home = tmp.path().to_path_buf();
+    let (facade, go, _stop) = start(&home, Tz::Fixed(0)).await;
+    *go.crypt_mode.lock().unwrap() = CryptMode::Magic;
+    let dir = home.join("memory").join("generale");
+    let (code, _) = fakego::send(
+        facade,
+        "POST",
+        "/api/mem/save",
+        &[],
+        r##"{"name":"secret","content":"# Secret\nmot de passe"}"##,
+    )
+    .await;
+    assert_eq!(code, 200);
+    let raw = std::fs::read(dir.join("secret.md")).unwrap();
+    assert_eq!(raw, b"LOKIMEMv1# Secret\nmot de passe\n");
+    // L'index, lui, reste en clair (comme le Go).
+    let idx = std::fs::read_to_string(dir.join("MEMORY.md")).unwrap();
+    assert!(idx.ends_with("- [Secret](secret.md)\n"), "{idx}");
+    let (_, b) = fakego::send(facade, "GET", "/api/mem?name=secret", &[], "").await;
+    let v: Value = serde_json::from_slice(&b).unwrap();
+    assert_eq!(v["content"], "# Secret\nmot de passe\n");
+    let (_, b) = fakego::send(
+        facade,
+        "POST",
+        "/api/tracker",
+        &[],
+        r#"{"action":"add","name":"Tension","when":"2024-01-02","text":"12/8"}"#,
+    )
+    .await;
+    assert_eq!(serde_json::from_slice::<Value>(&b).unwrap()["ok"], true);
+    let sealed = go.get("tracker", "generale/tension").unwrap();
+    assert!(sealed.starts_with("LOKIMEMv1{"), "{sealed}");
+
+    // Verrouillée.
+    *go.locked.lock().unwrap() = true;
+    let (_, b) = fakego::send(facade, "GET", "/api/agent", &[], "").await;
+    let v: Value = serde_json::from_slice(&b).unwrap();
+    let pages = v["pages"].as_array().unwrap();
+    let secret = pages.iter().find(|p| p["name"] == "secret.md").unwrap();
+    assert_eq!(secret["desc"], "🔒 (chiffré — mémoire verrouillée)");
+    let (code, _) = fakego::send(facade, "GET", "/api/mem?name=secret", &[], "").await;
+    assert_eq!(code, 404);
+    let (code, b) = fakego::send(
+        facade,
+        "POST",
+        "/api/mem/save",
+        &[],
+        r#"{"name":"secret","content":"écrasé"}"#,
+    )
+    .await;
+    assert_eq!(code, 400);
+    assert_eq!(
+        serde_json::from_slice::<Value>(&b).unwrap()["error"],
+        "page chiffrée, mémoire verrouillée"
+    );
+    assert_eq!(
+        std::fs::read(dir.join("secret.md")).unwrap(),
+        raw,
+        "page réécrite alors que la mémoire est verrouillée"
+    );
+    let (code, b) = fakego::send(
+        facade,
+        "POST",
+        "/api/tracker",
+        &[],
+        r#"{"action":"add","name":"Autre","text":"x"}"#,
+    )
+    .await;
+    assert_eq!(code, 400);
+    assert_eq!(
+        serde_json::from_slice::<Value>(&b).unwrap()["error"],
+        "valeur chiffrée, mémoire verrouillée"
+    );
+    // Les trackers scellés ne sont plus lisibles : la liste les tait.
+    let (_, b) = fakego::send(facade, "GET", "/api/tracker", &[], "").await;
+    assert_eq!(
+        serde_json::from_slice::<Value>(&b).unwrap()["trackers"],
+        json!([])
+    );
+}
+
+#[tokio::test]
+async fn sans_la_variable_la_memoire_reste_au_go() {
+    let tmp = tempfile::tempdir().unwrap();
+    let (facade, _go, _stop) = fakego::start(tmp.path().to_path_buf()).await;
+    for p in [
+        "/api/mem",
+        "/api/mem/save",
+        "/api/mem/move",
+        "/api/agent",
+        "/api/skills/toggle",
+        "/api/memory",
+        "/api/tracker",
+    ] {
+        let (_, _, b) = fakego::get(facade, p, &[]).await;
+        assert_eq!(&b[..], format!("go:{p}").as_bytes());
+    }
+}
+
+/// Le coffre, les instantanés et les projets restent au Go même avec la
+/// variable.
+#[tokio::test]
+async fn coffre_et_projets_restent_au_go() {
+    let tmp = tempfile::tempdir().unwrap();
+    let (facade, _go, _stop) = start(tmp.path(), Tz::Local).await;
+    for p in [
+        "/api/mem/health",
+        "/api/mem/unlock",
+        "/api/mem/snapshots",
+        "/api/projects",
+        "/api/backup/export",
+    ] {
+        let (_, _, b) = fakego::get(facade, p, &[]).await;
+        assert_eq!(&b[..], format!("go:{p}").as_bytes());
+    }
+}

rust/loki-rs/tests/proxy.rs

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