feat(domain,infra,app): rotation/rétention log.jsonl + lecture paginée (LS6)
Backend uniquement (UI React repoussée à LS7) : - domain : port ConversationArchive + structs SegmentStats/PageCursor/PageDirection/ TurnSlice/RotationDecision/RotationThresholds, fn pures rotation_plan/clamp_page_limit + consts ; re-exports lib. - infrastructure : impl ConversationArchive pour FsConversationLog (stats/rotate/page + helpers), archive segmentée hors chemin chaud. - application : ReadConversationPage + DTO + ConversationArchiveProvider (conversation/paginate), RotateConversationLog (conversation/rotate), exports mod/lib. - app-tauri : AppConversationArchiveProvider + wiring (state), rotation détachée dans launch_agent + commande read_conversation_page (commands), DTOs (dto), commande enregistrée (generate_handler!). - tests (QA, verts) : conversation_log, conversation_rotate_paginate (nouveau), dto (module test). Pivots INV-LS6 et cohérence fold-après-rotation verts. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
@ -18,8 +18,9 @@ use std::path::PathBuf;
|
||||
|
||||
use domain::conversation::ConversationId;
|
||||
use domain::conversation_log::{
|
||||
bound_handoff_summary, ConversationLog, ConversationTurn, Handoff, HandoffStore,
|
||||
HandoffSummarizer, ProviderSessionStore, TurnId, TurnRole, HANDOFF_SUMMARY_MAX_CHARS,
|
||||
bound_handoff_summary, ConversationArchive, ConversationLog, ConversationTurn, Handoff,
|
||||
HandoffStore, HandoffSummarizer, PageCursor, PageDirection, ProviderSessionStore, TurnId,
|
||||
TurnRole, HANDOFF_SUMMARY_MAX_CHARS, MAX_ARCHIVE_SEGMENTS, ROTATE_AFTER_BYTES,
|
||||
};
|
||||
use domain::input::InputSource;
|
||||
use domain::ports::StoreError;
|
||||
@ -1292,3 +1293,558 @@ async fn provider_is_isolated_per_conversation() {
|
||||
"aucune fuite de c1 dans le providers.json de c2"
|
||||
);
|
||||
}
|
||||
|
||||
// ===========================================================================
|
||||
// LS6 — rotation (ConversationArchive) + pagination humaine, I/O réelle.
|
||||
// Réutilise le scaffolding L2 (TempDir absolu, constructeurs déterministes).
|
||||
// Convention d'archive : `<conversationId>/log.<k>.jsonl` (k≥1, le plus ancien=1).
|
||||
// ===========================================================================
|
||||
|
||||
/// Liste, triés croissants, les indices `k` des segments d'archive `log.<k>.jsonl`
|
||||
/// présents sur disque pour `c` (l'actif `log.jsonl` est exclu).
|
||||
fn archive_segment_indices(tmp: &TempDir, c: ConversationId) -> Vec<usize> {
|
||||
let dir = tmp.conversation_dir(c);
|
||||
let mut out = Vec::new();
|
||||
if let Ok(rd) = std::fs::read_dir(&dir) {
|
||||
for entry in rd.flatten() {
|
||||
if let Some(name) = entry.file_name().to_str() {
|
||||
if let Some(mid) = name
|
||||
.strip_prefix("log.")
|
||||
.and_then(|s| s.strip_suffix(".jsonl"))
|
||||
{
|
||||
if let Ok(k) = mid.parse::<usize>() {
|
||||
out.push(k);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
out.sort_unstable();
|
||||
out
|
||||
}
|
||||
|
||||
/// Écrit un segment d'archive brut `log.<k>.jsonl` (simulation de crash / dédoublonnage).
|
||||
fn write_raw_archive_segment(
|
||||
tmp: &TempDir,
|
||||
c: ConversationId,
|
||||
k: usize,
|
||||
turns: &[ConversationTurn],
|
||||
) {
|
||||
let dir = tmp.conversation_dir(c);
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let mut buf = String::new();
|
||||
for t in turns {
|
||||
buf.push_str(&serde_json::to_string(t).unwrap());
|
||||
buf.push('\n');
|
||||
}
|
||||
std::fs::write(dir.join(format!("log.{k}.jsonl")), buf).unwrap();
|
||||
}
|
||||
|
||||
/// Tous les `.tmp` restant dans le dossier de la conversation (doivent être absents).
|
||||
fn leftover_tmp_files(tmp: &TempDir, c: ConversationId) -> Vec<String> {
|
||||
let dir = tmp.conversation_dir(c);
|
||||
let mut out = Vec::new();
|
||||
if let Ok(rd) = std::fs::read_dir(&dir) {
|
||||
for entry in rd.flatten() {
|
||||
if let Some(name) = entry.file_name().to_str() {
|
||||
if name.ends_with(".tmp") {
|
||||
out.push(name.to_owned());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn ids(turns: &[ConversationTurn]) -> Vec<TurnId> {
|
||||
turns.iter().map(|t| t.id).collect()
|
||||
}
|
||||
|
||||
/// Enregistre `n` tours (id 1..=n) dans l'actif et renvoie le log.
|
||||
async fn seed_turns(log: &FsConversationLog, c: ConversationId, n: u128) {
|
||||
for i in 1..=n {
|
||||
let role = if i % 2 == 1 {
|
||||
TurnRole::Prompt
|
||||
} else {
|
||||
TurnRole::Response
|
||||
};
|
||||
log.append(c, turn(c, turn_id(i), role, &format!("texte du tour {i}")))
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
// --- INV-LS6 : le test pivot -------------------------------------------------
|
||||
|
||||
/// INV-LS6 (PIVOT) : après `rotate(keep_from=up_to)`, le curseur `up_to` reste
|
||||
/// trouvable dans l'ACTIF, donc `ConversationLog::read(since=up_to)` renvoie toujours
|
||||
/// le bon incrément, et `last(n)` fonctionne. C'est l'invariant qui garantit que la
|
||||
/// rotation ne casse jamais le fold incrémental du handoff.
|
||||
#[tokio::test]
|
||||
async fn inv_ls6_read_since_up_to_survives_rotation() {
|
||||
let tmp = TempDir::new();
|
||||
let log = FsConversationLog::new(&tmp.project_path());
|
||||
let c = conv_id(1);
|
||||
seed_turns(&log, c, 10).await;
|
||||
|
||||
// up_to = curseur du handoff (tour 5). On rote en gardant tout depuis 5.
|
||||
let up_to = turn_id(5);
|
||||
log.rotate(c, up_to).await.expect("rotate ok");
|
||||
|
||||
// Le curseur est dans l'actif ⇒ l'incrément strictement postérieur est intact.
|
||||
let inc = log.read(c, Some(up_to)).await.unwrap();
|
||||
assert_eq!(
|
||||
texts(&inc),
|
||||
(6..=10)
|
||||
.map(|i| format!("texte du tour {i}"))
|
||||
.collect::<Vec<_>>(),
|
||||
"read(since=up_to) renvoie l'incrément 6..=10 après rotation"
|
||||
);
|
||||
// last(n) lit bien la fin (archive-unaware mais l'actif contient la queue).
|
||||
let last3 = log.last(c, 3).await.unwrap();
|
||||
assert_eq!(ids(&last3), vec![turn_id(8), turn_id(9), turn_id(10)]);
|
||||
}
|
||||
|
||||
// --- archive : déplacement de tête, aucune perte, idempotence ----------------
|
||||
|
||||
/// `rotate(keep_from=5)` déplace la tête froide (1..4) dans un segment, garde
|
||||
/// `[5..10]` dans l'actif, sans perdre aucun tour (∪ actif+archives = tous).
|
||||
#[tokio::test]
|
||||
async fn rotate_moves_cold_head_to_a_segment_without_loss() {
|
||||
let tmp = TempDir::new();
|
||||
let log = FsConversationLog::new(&tmp.project_path());
|
||||
let c = conv_id(1);
|
||||
seed_turns(&log, c, 10).await;
|
||||
|
||||
log.rotate(c, turn_id(5)).await.expect("rotate ok");
|
||||
|
||||
// Un seul segment d'archive créé (le plus ancien = index 1).
|
||||
assert_eq!(archive_segment_indices(&tmp, c), vec![1]);
|
||||
|
||||
// L'actif = [5..10] (keep_from inclus en tête).
|
||||
let active = log.read(c, None).await.unwrap();
|
||||
assert_eq!(ids(&active), (5..=10).map(turn_id).collect::<Vec<_>>());
|
||||
|
||||
// Aucun tour perdu : la page archive-aware réunit tout, 1..10 en ordre croissant.
|
||||
let page = log
|
||||
.page(
|
||||
c,
|
||||
PageCursor {
|
||||
anchor: None,
|
||||
direction: PageDirection::Forward,
|
||||
},
|
||||
200,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(ids(&page.turns), (1..=10).map(turn_id).collect::<Vec<_>>());
|
||||
assert!(!page.has_more, "10 tours ≤ limit ⇒ pas d'autre page");
|
||||
}
|
||||
|
||||
/// `rotate` est idempotente : un 2e appel avec le même `keep_from` (désormais en tête
|
||||
/// de l'actif) est un no-op — aucun nouveau segment, actif inchangé.
|
||||
#[tokio::test]
|
||||
async fn rotate_is_idempotent() {
|
||||
let tmp = TempDir::new();
|
||||
let log = FsConversationLog::new(&tmp.project_path());
|
||||
let c = conv_id(1);
|
||||
seed_turns(&log, c, 10).await;
|
||||
|
||||
log.rotate(c, turn_id(5)).await.expect("rotate 1");
|
||||
let after1 = log.read(c, None).await.unwrap();
|
||||
let segs1 = archive_segment_indices(&tmp, c);
|
||||
|
||||
log.rotate(c, turn_id(5)).await.expect("rotate 2 (no-op)");
|
||||
let after2 = log.read(c, None).await.unwrap();
|
||||
let segs2 = archive_segment_indices(&tmp, c);
|
||||
|
||||
assert_eq!(ids(&after1), ids(&after2), "actif inchangé au 2e rotate");
|
||||
assert_eq!(segs1, segs2, "aucun nouveau segment au 2e rotate");
|
||||
assert_eq!(segs2, vec![1], "toujours exactement un segment");
|
||||
}
|
||||
|
||||
/// `keep_from` absent de l'actif (déjà roté / inconnu) ⇒ no-op, jamais de perte.
|
||||
#[tokio::test]
|
||||
async fn rotate_with_unknown_keep_from_is_noop() {
|
||||
let tmp = TempDir::new();
|
||||
let log = FsConversationLog::new(&tmp.project_path());
|
||||
let c = conv_id(1);
|
||||
seed_turns(&log, c, 5).await;
|
||||
|
||||
log.rotate(c, turn_id(999)).await.expect("rotate noop");
|
||||
assert!(archive_segment_indices(&tmp, c).is_empty(), "aucun segment");
|
||||
let active = log.read(c, None).await.unwrap();
|
||||
assert_eq!(ids(&active), (1..=5).map(turn_id).collect::<Vec<_>>());
|
||||
}
|
||||
|
||||
/// Réécriture de l'actif **atomique** : après rotation, aucun `.tmp` ne traîne et la
|
||||
/// queue active est intégralement présente (jamais perdue).
|
||||
#[tokio::test]
|
||||
async fn rotate_leaves_no_tmp_and_preserves_active_queue() {
|
||||
let tmp = TempDir::new();
|
||||
let log = FsConversationLog::new(&tmp.project_path());
|
||||
let c = conv_id(1);
|
||||
seed_turns(&log, c, 8).await;
|
||||
|
||||
log.rotate(c, turn_id(4)).await.expect("rotate ok");
|
||||
|
||||
assert!(
|
||||
leftover_tmp_files(&tmp, c).is_empty(),
|
||||
"aucun .tmp résiduel après écriture atomique : {:?}",
|
||||
leftover_tmp_files(&tmp, c)
|
||||
);
|
||||
let active = log.read(c, None).await.unwrap();
|
||||
assert_eq!(
|
||||
ids(&active),
|
||||
(4..=8).map(turn_id).collect::<Vec<_>>(),
|
||||
"queue active [4..8] intégralement préservée"
|
||||
);
|
||||
}
|
||||
|
||||
/// Tête dupliquée (simulation de crash : archive écrite mais actif non swappé) ⇒ la
|
||||
/// lecture paginée **dédoublonne par TurnId** (chaque tour une seule fois).
|
||||
#[tokio::test]
|
||||
async fn page_dedups_duplicated_head_after_crash() {
|
||||
let tmp = TempDir::new();
|
||||
let log = FsConversationLog::new(&tmp.project_path());
|
||||
let c = conv_id(1);
|
||||
seed_turns(&log, c, 6).await; // actif = [1..6]
|
||||
|
||||
// Crash simulé : un segment d'archive contenant la tête (1..3) est écrit, mais
|
||||
// l'actif n'a PAS été tronqué (il contient toujours 1..6).
|
||||
let active_all = log.read(c, None).await.unwrap();
|
||||
let head: Vec<ConversationTurn> = active_all[..3].to_vec();
|
||||
write_raw_archive_segment(&tmp, c, 1, &head);
|
||||
|
||||
// La page réunit archive(1..3) + actif(1..6) MAIS dédoublonne ⇒ 1..6, pas de doublon.
|
||||
let page = log
|
||||
.page(
|
||||
c,
|
||||
PageCursor {
|
||||
anchor: None,
|
||||
direction: PageDirection::Forward,
|
||||
},
|
||||
200,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
ids(&page.turns),
|
||||
(1..=6).map(turn_id).collect::<Vec<_>>(),
|
||||
"dédoublonnage par TurnId : chaque tour une seule fois"
|
||||
);
|
||||
}
|
||||
|
||||
/// `append` ne déclenche **jamais** la rotation : grossir l'actif au-delà du seuil
|
||||
/// d'octets sans appeler `rotate` ne crée aucun segment d'archive.
|
||||
#[tokio::test]
|
||||
async fn append_never_triggers_rotation_even_over_threshold() {
|
||||
let tmp = TempDir::new();
|
||||
let log = FsConversationLog::new(&tmp.project_path());
|
||||
let c = conv_id(1);
|
||||
|
||||
// Dépasser le seuil d'octets (1 MiB) : ~16 tours de 80 000 caractères.
|
||||
let big = "m".repeat(80_000);
|
||||
for i in 1..=16u128 {
|
||||
log.append(c, turn(c, turn_id(i), TurnRole::Response, &big))
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
let stats = log.stats(c).await.unwrap();
|
||||
assert!(
|
||||
stats.active_bytes > ROTATE_AFTER_BYTES,
|
||||
"pré-condition : actif au-dessus du seuil d'octets ({})",
|
||||
stats.active_bytes
|
||||
);
|
||||
// Pourtant : aucun segment d'archive (la rotation est hors-chemin, jamais sur append).
|
||||
assert!(
|
||||
archive_segment_indices(&tmp, c).is_empty(),
|
||||
"append ne crée jamais d'archive : {:?}",
|
||||
archive_segment_indices(&tmp, c)
|
||||
);
|
||||
}
|
||||
|
||||
// --- pagination humaine ------------------------------------------------------
|
||||
|
||||
/// Page vide pour une conversation vide.
|
||||
#[tokio::test]
|
||||
async fn page_of_empty_conversation_is_empty() {
|
||||
let tmp = TempDir::new();
|
||||
let log = FsConversationLog::new(&tmp.project_path());
|
||||
let c = conv_id(1);
|
||||
let page = log
|
||||
.page(
|
||||
c,
|
||||
PageCursor {
|
||||
anchor: None,
|
||||
direction: PageDirection::Forward,
|
||||
},
|
||||
50,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(page.turns.is_empty() && !page.has_more);
|
||||
}
|
||||
|
||||
/// Forward depuis le début, Backward depuis la fin, ancré dans les deux sens ;
|
||||
/// `has_more` correct ; ordre **chronologique croissant** dans chaque page.
|
||||
#[tokio::test]
|
||||
async fn page_forward_backward_anchored_and_has_more() {
|
||||
let tmp = TempDir::new();
|
||||
let log = FsConversationLog::new(&tmp.project_path());
|
||||
let c = conv_id(1);
|
||||
seed_turns(&log, c, 10).await;
|
||||
|
||||
// Forward depuis le début, limit 4 ⇒ [1..4], has_more.
|
||||
let p = log
|
||||
.page(
|
||||
c,
|
||||
PageCursor {
|
||||
anchor: None,
|
||||
direction: PageDirection::Forward,
|
||||
},
|
||||
4,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(ids(&p.turns), (1..=4).map(turn_id).collect::<Vec<_>>());
|
||||
assert!(p.has_more);
|
||||
|
||||
// Backward depuis la fin, limit 4 ⇒ [7..10] (ordre croissant !), has_more.
|
||||
let p = log
|
||||
.page(
|
||||
c,
|
||||
PageCursor {
|
||||
anchor: None,
|
||||
direction: PageDirection::Backward,
|
||||
},
|
||||
4,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(ids(&p.turns), (7..=10).map(turn_id).collect::<Vec<_>>());
|
||||
assert!(p.has_more);
|
||||
|
||||
// Ancré Forward après le tour 4, limit 3 ⇒ [5,6,7], has_more.
|
||||
let p = log
|
||||
.page(
|
||||
c,
|
||||
PageCursor {
|
||||
anchor: Some(turn_id(4)),
|
||||
direction: PageDirection::Forward,
|
||||
},
|
||||
3,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(ids(&p.turns), vec![turn_id(5), turn_id(6), turn_id(7)]);
|
||||
assert!(p.has_more);
|
||||
|
||||
// Ancré Backward avant le tour 4, limit 10 ⇒ [1,2,3], plus rien avant.
|
||||
let p = log
|
||||
.page(
|
||||
c,
|
||||
PageCursor {
|
||||
anchor: Some(turn_id(4)),
|
||||
direction: PageDirection::Backward,
|
||||
},
|
||||
10,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(ids(&p.turns), vec![turn_id(1), turn_id(2), turn_id(3)]);
|
||||
assert!(!p.has_more, "rien avant le tour 1");
|
||||
|
||||
// Dernière page Forward (fin atteinte) ⇒ has_more = false.
|
||||
let p = log
|
||||
.page(
|
||||
c,
|
||||
PageCursor {
|
||||
anchor: Some(turn_id(7)),
|
||||
direction: PageDirection::Forward,
|
||||
},
|
||||
50,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(ids(&p.turns), vec![turn_id(8), turn_id(9), turn_id(10)]);
|
||||
assert!(!p.has_more);
|
||||
}
|
||||
|
||||
/// La pagination est **archive-aware** : après rotation, une page peut chevaucher
|
||||
/// plusieurs segments (archive + actif) et reste en ordre croissant continu.
|
||||
#[tokio::test]
|
||||
async fn page_spans_multiple_segments_after_rotation() {
|
||||
let tmp = TempDir::new();
|
||||
let log = FsConversationLog::new(&tmp.project_path());
|
||||
let c = conv_id(1);
|
||||
seed_turns(&log, c, 12).await;
|
||||
log.rotate(c, turn_id(7)).await.expect("rotate"); // archive [1..6], actif [7..12]
|
||||
|
||||
// Une page ancrée Forward autour de la frontière archive/actif renvoie un span continu.
|
||||
let p = log
|
||||
.page(
|
||||
c,
|
||||
PageCursor {
|
||||
anchor: Some(turn_id(5)),
|
||||
direction: PageDirection::Forward,
|
||||
},
|
||||
4,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
// Tours 6 (archive) puis 7,8,9 (actif) : continuité par-delà la frontière de segment.
|
||||
assert_eq!(
|
||||
ids(&p.turns),
|
||||
vec![turn_id(6), turn_id(7), turn_id(8), turn_id(9)]
|
||||
);
|
||||
assert!(p.has_more);
|
||||
}
|
||||
|
||||
/// Le **texte complet** d'un tour est préservé (non borné) à la lecture paginée — la
|
||||
/// borne LS5 ne s'applique qu'au handoff, jamais au log canonique.
|
||||
#[tokio::test]
|
||||
async fn page_preserves_full_unbounded_turn_text() {
|
||||
let tmp = TempDir::new();
|
||||
let log = FsConversationLog::new(&tmp.project_path());
|
||||
let c = conv_id(1);
|
||||
let big = "Z".repeat(50_000);
|
||||
log.append(c, turn(c, turn_id(1), TurnRole::Response, &big))
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let p = log
|
||||
.page(
|
||||
c,
|
||||
PageCursor {
|
||||
anchor: None,
|
||||
direction: PageDirection::Forward,
|
||||
},
|
||||
50,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(p.turns.len(), 1);
|
||||
assert_eq!(
|
||||
p.turns[0].text.chars().count(),
|
||||
50_000,
|
||||
"texte complet préservé (non borné) à la pagination"
|
||||
);
|
||||
}
|
||||
|
||||
// --- backstop MAX_ARCHIVE_SEGMENTS ------------------------------------------
|
||||
|
||||
/// Au-delà de [`MAX_ARCHIVE_SEGMENTS`] segments, le(s) plus ANCIEN(s) sont supprimés ;
|
||||
/// l'actif n'est jamais touché et aucun tour `≥ keep_from` n'est archivé/perdu.
|
||||
#[tokio::test]
|
||||
async fn rotation_enforces_max_archive_segments_dropping_oldest() {
|
||||
let tmp = TempDir::new();
|
||||
let log = FsConversationLog::new(&tmp.project_path());
|
||||
let c = conv_id(1);
|
||||
let total = 40u128;
|
||||
seed_turns(&log, c, total).await;
|
||||
|
||||
// Roter `MAX_ARCHIVE_SEGMENTS + 3` fois, en avançant keep_from d'un tour à chaque fois.
|
||||
// Chaque rotation déplace une tête d'un tour ⇒ crée un segment.
|
||||
let rotations = (MAX_ARCHIVE_SEGMENTS + 3) as u128;
|
||||
for k in 2..=(1 + rotations) {
|
||||
log.rotate(c, turn_id(k)).await.expect("rotate ok");
|
||||
}
|
||||
|
||||
// Backstop : jamais plus de MAX_ARCHIVE_SEGMENTS segments sur disque.
|
||||
let segs = archive_segment_indices(&tmp, c);
|
||||
assert_eq!(
|
||||
segs.len(),
|
||||
MAX_ARCHIVE_SEGMENTS,
|
||||
"plafonné à MAX_ARCHIVE_SEGMENTS, obtenu {segs:?}"
|
||||
);
|
||||
|
||||
// L'actif n'a pas été touché par le backstop : il commence au dernier keep_from.
|
||||
let last_keep = 1 + rotations; // = turn_id du dernier keep_from
|
||||
let active = log.read(c, None).await.unwrap();
|
||||
assert_eq!(
|
||||
active.first().map(|t| t.id),
|
||||
Some(turn_id(last_keep)),
|
||||
"l'actif commence à keep_from (jamais archivé/supprimé)"
|
||||
);
|
||||
assert_eq!(
|
||||
active.last().map(|t| t.id),
|
||||
Some(turn_id(total)),
|
||||
"la fin de l'actif est intacte"
|
||||
);
|
||||
// read(since=last_keep) — le curseur survit (INV-LS6) même après backstop.
|
||||
let inc = log.read(c, Some(turn_id(last_keep))).await.unwrap();
|
||||
assert_eq!(
|
||||
inc.first().map(|t| t.id),
|
||||
Some(turn_id(last_keep + 1)),
|
||||
"l'incrément après le dernier curseur reste correct"
|
||||
);
|
||||
}
|
||||
|
||||
// --- cohérence fold-après-rotation (le must-have) ----------------------------
|
||||
|
||||
/// COHÉRENCE (must-have) : beaucoup de tours → `rotate(keep_from = up_to)` → encore des
|
||||
/// tours → un `fold` ultérieur **étend correctement** le handoff. On lit l'actif depuis
|
||||
/// `up_to` (INV-LS6 : toujours trouvable après rotation), on replie l'incrément, et
|
||||
/// `up_to` AVANCE. Prouve que la rotation ne casse jamais le fold incrémental réel.
|
||||
#[tokio::test]
|
||||
async fn fold_after_rotation_extends_handoff_correctly() {
|
||||
let tmp = TempDir::new();
|
||||
let log = FsConversationLog::new(&tmp.project_path());
|
||||
let summarizer = HeuristicHandoffSummarizer::new();
|
||||
let c = conv_id(1);
|
||||
|
||||
// 1. Tours 1..7 enregistrés PUIS repliés ⇒ handoff.up_to = 7.
|
||||
seed_turns(&log, c, 7).await;
|
||||
let first_batch = log.read(c, None).await.unwrap();
|
||||
let handoff = summarizer.fold(None, &first_batch).await;
|
||||
let handoff = bound_handoff_summary(handoff, HANDOFF_SUMMARY_MAX_CHARS);
|
||||
assert_eq!(handoff.up_to, turn_id(7), "curseur = dernier tour replié");
|
||||
|
||||
// 2. Plus de tours arrivent (8..15), non encore repliés, écrits dans l'actif.
|
||||
for i in 8..=15u128 {
|
||||
let role = if i % 2 == 1 {
|
||||
TurnRole::Prompt
|
||||
} else {
|
||||
TurnRole::Response
|
||||
};
|
||||
log.append(c, turn(c, turn_id(i), role, &format!("texte du tour {i}")))
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
// 3. Rotation au plancher = up_to du handoff (7) : tête froide 1..6 archivée.
|
||||
log.rotate(c, handoff.up_to).await.expect("rotate ok");
|
||||
// L'actif commence bien au curseur (INV-LS6) ⇒ le curseur reste trouvable.
|
||||
assert_eq!(
|
||||
ids(&log.read(c, None).await.unwrap()),
|
||||
(7..=15).map(turn_id).collect::<Vec<_>>(),
|
||||
"actif = [up_to..fin] après rotation"
|
||||
);
|
||||
|
||||
// 4. Fold ultérieur : on lit l'incrément depuis up_to (8..15) DANS L'ACTIF, on replie.
|
||||
let increment = log.read(c, Some(handoff.up_to)).await.unwrap();
|
||||
assert_eq!(
|
||||
ids(&increment),
|
||||
(8..=15).map(turn_id).collect::<Vec<_>>(),
|
||||
"read(since=up_to) renvoie l'incrément 8..15 malgré la rotation"
|
||||
);
|
||||
let advanced = summarizer.fold(Some(handoff.clone()), &increment).await;
|
||||
let advanced = bound_handoff_summary(advanced, HANDOFF_SUMMARY_MAX_CHARS);
|
||||
|
||||
// up_to a AVANCÉ jusqu'au dernier tour, et le résumé intègre les tours récents.
|
||||
assert_eq!(
|
||||
advanced.up_to,
|
||||
turn_id(15),
|
||||
"le curseur avance après le fold"
|
||||
);
|
||||
assert!(
|
||||
advanced.summary_md.contains("texte du tour 15"),
|
||||
"le fold intègre le tour le plus récent : {}",
|
||||
advanced.summary_md
|
||||
);
|
||||
assert_ne!(
|
||||
advanced.up_to, handoff.up_to,
|
||||
"la rotation ne fige pas le curseur du handoff"
|
||||
);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user