mirror of
https://github.com/R0m1k3/Loki.git
synced 2026-10-19 13:08:15 +02:00
MichaelandClaude Opus 5.5
01c11be4ae
- LSP (lsp.go) : un signal resté dans le tampon par une republication tardive faisait rendre « aucun diagnostic » à l'édition suivante, avant même que le serveur ait vu la nouvelle version. Le canal est vidé, une publication d'une version antérieure est ignorée, et check attend 350 ms de calme après la dernière publication (liste vide puis analyse : c'est l'analyse qui compte), toujours borné par lspDiagWait. Au passage : interblocage latent levé (writeMsg → markDead reprenait mu, déjà tenu par check) — dead devient atomique. - run_shell : ErrWaitDelay (commande finie, process laissé en arrière-plan sur les tubes) rend la sortie au lieu de « WaitDelay expired » qui l'effaçait (AJEAN 7403a8a0). - Clé de pilotage web : lue depuis un cache à chaque requête au lieu d'ouvrir la base sous dbMu (AJEAN #120). Lectures réussies seulement, invalidé par toute écriture du bucket d'état, par la date/taille du fichier (autre process) et au bout d'une seconde. - MCP : l'appel suit le contexte du tour (le bouton stop l'annule), délai par serveur (callTimeoutSec) et allongé par l'argument timeout de l'outil, plafonné à 30 min ; un délai dépassé n'est plus relancé (OpenFox 2ef584b8). - Recall : les blocs d'une compaction s'archivent en une seule transaction au lieu d'une par bloc (AJEAN #130). - Compactage en cours de tour : après un essai qui n'a rien réduit, pas de nouvel essai avant +5 % de la fenêtre (sauf à 90 %), pour les tâches et sous-agents aussi ; la cause d'un résumé raté est journalisée (AJEAN 68659e73). - Motifs de relance : un motif vide (qui correspondait à tout) est écarté, une surcharge sans motif utilisable retombe sur l'embarqué, et un changement de retry_patterns agit sans redémarrer (OpenFox 8e9b4869, c52c5bf7). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
89 lines
2.2 KiB
Go
89 lines
2.2 KiB
Go
package loki
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
|
|
bolt "go.etcd.io/bbolt"
|
|
)
|
|
|
|
// Une écriture de ce process est vue tout de suite : le cache ne retarde pas un
|
|
// changement de clé.
|
|
func TestWebKeyCacheInvalidatedByLocalWrite(t *testing.T) {
|
|
testHome(t)
|
|
if err := putStr(bkState, "web_key", "ancienne"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if k, err := readWebKeyErr(); err != nil || k != "ancienne" {
|
|
t.Fatalf("clé = %q, %v", k, err)
|
|
}
|
|
if err := putStr(bkState, "web_key", "nouvelle"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if k, err := readWebKeyErr(); err != nil || k != "nouvelle" {
|
|
t.Fatalf("clé après écriture = %q, %v ; attendu la nouvelle", k, err)
|
|
}
|
|
}
|
|
|
|
// Une écriture d'un AUTRE process (sans cacheBust ici) finit vue : au plus
|
|
// cacheMaxAge plus tard.
|
|
func TestWebKeyCacheSeesExternalWrite(t *testing.T) {
|
|
testHome(t)
|
|
if err := putStr(bkState, "web_key", "a"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if k, _ := readWebKeyErr(); k != "a" {
|
|
t.Fatalf("clé = %q", k)
|
|
}
|
|
// Écriture directe, comme le ferait la CLI : pas de cacheBust.
|
|
err := withDB(func(d *bolt.DB) error {
|
|
return d.Update(func(tx *bolt.Tx) error {
|
|
return tx.Bucket([]byte(bkState)).Put([]byte("web_key"), []byte("b"))
|
|
})
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
deadline := time.Now().Add(cacheMaxAge + 500*time.Millisecond)
|
|
for {
|
|
if k, _ := readWebKeyErr(); k == "b" {
|
|
return
|
|
}
|
|
if time.Now().After(deadline) {
|
|
t.Fatal("écriture externe jamais vue")
|
|
}
|
|
time.Sleep(50 * time.Millisecond)
|
|
}
|
|
}
|
|
|
|
// Sans changement, les lectures suivantes n'ouvrent plus la base.
|
|
func TestWebKeyCacheServesRepeatedReads(t *testing.T) {
|
|
testHome(t)
|
|
if err := putStr(bkState, "web_key", "k"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if k, _ := readWebKeyErr(); k != "k" {
|
|
t.Fatalf("clé = %q", k)
|
|
}
|
|
// Base verrouillée par « un autre process » : une lecture qui l'ouvrirait
|
|
// attendrait la borne de 5 s puis échouerait.
|
|
dbMu.Lock()
|
|
type res struct {
|
|
k string
|
|
err error
|
|
}
|
|
ch := make(chan res, 1)
|
|
go func() { k, err := readWebKeyErr(); ch <- res{k, err} }()
|
|
select {
|
|
case r := <-ch:
|
|
dbMu.Unlock()
|
|
if r.err != nil || r.k != "k" {
|
|
t.Fatalf("clé = %q, %v", r.k, r.err)
|
|
}
|
|
case <-time.After(300 * time.Millisecond):
|
|
dbMu.Unlock()
|
|
<-ch
|
|
t.Fatal("lecture servie par la base, pas par le cache")
|
|
}
|
|
}
|