mirror of
https://github.com/R0m1k3/Loki.git
synced 2026-10-11 17:26:57 +02:00
MichaelandClaude Opus 5.5
c3005f5b56
StartTurn persistait AVANT de lancer la génération : un marshal, puis deux commits bbolt (contenu, puis index), soit deux fsync et plusieurs ouvertures de base — 26-30 ms mesurés sur un NVMe Windows, bien plus sur un /mnt/user d'Unraid ou un disque de parité, payés à chaque message avant que la requête ne parte vers llama-server. Même facture au milieu d'un tour (vérification du mode Code) et pour chaque résultat d'outil coupé (« voir plus »). - chat_persist.go : un écrivain unique et ordonné. L'instantané reste pris sous c.mu (images → références, marshal, identifiant de la discussion) ; seule l'E/S part en différé. Le dernier instantané de chaque discussion l'emporte (numéro pris sous c.mu), les lots sont fusionnés en UNE transaction : contenu + index ensemble, résultats d'outils compris. - Seuls StartTurn, la persistance en cours de tour et les résultats d'outils sont asynchrones. Fin de tour, reset, bascules, compactage manuel restent synchrones et attendent tout ce qui précède ; la suppression écarte puis attend les écritures qui la visent (plus de discussion ressuscitée). - Discussion active gardée en RAM, créée sous verrou (plus de double identifiant sur base neuve) et changée sous c.mu avec le contenu : un instantané ne peut plus écrire l'ancien fil sous le nouvel identifiant. - « Voir plus » servi depuis la mémoire tant que le résultat n'est pas écrit ; verrouillage vérifié avant de rendre un id. - En plein tour, la base reçoit le journal sous sa forme de fin de tour (compactLog, version pure de compactLogLocked) ; la mémoire n'est pas touchée. - Vidage de l'écrivain avant redémarrage, « Quitter », exec et (dé)chiffrement. Le contexte vu par le modèle ne change pas : il lit c.Messages en mémoire, les résultats complets d'outils et la compaction du journal ne servent qu'à l'UI. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
74 lines
2.6 KiB
Go
74 lines
2.6 KiB
Go
package loki
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// Un résultat coupé est rangé à part, relu en entier, et part avec sa discussion.
|
|
func TestToolResultsSaveLoadDelete(t *testing.T) {
|
|
testHome(t)
|
|
_ = putStr(bkChat, ckActive, "c42")
|
|
long := strings.Repeat("ligne de sortie\n", 500)
|
|
ev := fillToolResult(&ToolUsedEvent{Name: "bash", Done: true}, long)
|
|
if ev.ResultID == "" || !strings.HasPrefix(ev.ResultID, "c42.") {
|
|
t.Fatalf("id attendu préfixé par la discussion, got %q", ev.ResultID)
|
|
}
|
|
if len([]rune(ev.Result)) != toolPreviewChars || ev.ResultChars != len([]rune(long)) {
|
|
t.Fatalf("aperçu %d car., taille %d — attendu %d et %d", len([]rune(ev.Result)), ev.ResultChars, toolPreviewChars, len([]rune(long)))
|
|
}
|
|
if got, ok := loadToolResult(ev.ResultID); !ok || got != long {
|
|
t.Fatal("le résultat complet doit être relisible")
|
|
}
|
|
short := fillToolResult(&ToolUsedEvent{}, "ok")
|
|
if short.ResultID != "" || short.Result != "ok" {
|
|
t.Fatal("un résultat court part entier, sans id")
|
|
}
|
|
deleteToolResultsFor("c42")
|
|
if _, ok := loadToolResult(ev.ResultID); ok {
|
|
t.Fatal("les résultats doivent partir avec leur discussion")
|
|
}
|
|
}
|
|
|
|
// Une sortie de commande coupée le DIT, avec sa taille réelle.
|
|
func TestTailOutputAnnouncesCut(t *testing.T) {
|
|
if tailOutput("court") != "court" {
|
|
t.Fatal("une sortie courte reste intacte")
|
|
}
|
|
out := tailOutput(strings.Repeat("x", toolMaxOutput+10))
|
|
if !strings.HasPrefix(out, "[sortie tronquée : ") || !strings.Contains(out, "au total") {
|
|
t.Fatalf("mention de coupe absente : %q", out[:60])
|
|
}
|
|
}
|
|
|
|
// Mémoire chiffrée : le résultat complet est chiffré en base et relu intact ;
|
|
// verrouillée, rien n'est écrit (le flux portera le résultat entier) et le
|
|
// nettoyage des orphelins ne tourne pas (l'index illisible ferait tout effacer).
|
|
func TestToolResultsChiffres(t *testing.T) {
|
|
testHome(t)
|
|
clearMemDEK()
|
|
if _, err := EnableMemEncryption("motdepasse-fort"); err != nil {
|
|
t.Fatalf("EnableMemEncryption: %v", err)
|
|
}
|
|
full := strings.Repeat("ligne de sortie\n", 500)
|
|
id := saveToolResult(full)
|
|
if id == "" {
|
|
t.Fatal("résultat non enregistré")
|
|
}
|
|
persistQ.flush() // l'écriture est différée (chat_persist.go)
|
|
if !looksEncrypted(getBytes(bkToolRes, id)) {
|
|
t.Fatal("résultat en clair alors que la mémoire est chiffrée")
|
|
}
|
|
if got, ok := loadToolResult(id); !ok || got != full {
|
|
t.Fatal("résultat chiffré non restitué à l'identique")
|
|
}
|
|
clearMemDEK()
|
|
if saveToolResult("autre") != "" {
|
|
t.Fatal("mémoire verrouillée : rien n'aurait dû être écrit")
|
|
}
|
|
pruneToolResults()
|
|
if getBytes(bkToolRes, id) == nil {
|
|
t.Fatal("le nettoyage a effacé un résultat pendant que la mémoire était verrouillée")
|
|
}
|
|
}
|