Compaction : COMPACT_CONTINUATION résume dans le prolongement du prompt en cache, en opt-in

Le résumé d'une compaction part aujourd'hui dans une requête à part — prompt
du résumeur et transcription des anciens tours — que le moteur local calcule à
froid : des dizaines de secondes sur un 27B, des minutes sur un MoE, à chaque
compaction. Nouvelle clé COMPACT_CONTINUATION (off par défaut) : quand le slot
porte encore le prompt de la discussion, la requête de résumé est celle du tour
telle qu'elle est partie, suivie d'une seule demande de résumé ; le moteur ne
calcule qu'elle. Sans la clé, requêtes de compaction identiques à l'octet près
(prompt du résumeur comparé à une copie figée, testé).

- vue MODÈLE pour tout ce qui est rangé : bornes, archives recall, demande
  réinjectée, garantie de réduction et sortie ne changent pas ; la vue
  d'envoi (turnViewDry, wireMessages, buildChatPayload) ne sert qu'à la
  requête, rien d'injecté n'entre dans l'historique (testé)
- frontière recalée sur la vue envoyée (messages non système un pour un,
  vérifiés rôle par rôle), désignée par le nombre de messages gardés et le
  début du premier ; tout résumer avant, dater l'avancement à la frontière
- mêmes règles de résumé (+ mode Code), même budget, température 0.2 sans
  l'échantillonnage du preset, enable_thinking=false ajouté aux arguments du
  tour, reasoning_effort du tour, tool_choice « none », sans flux
- messages utilisateur de fin hors de la vue : pas en cache, et pas deux
  `user` d'affilée pour les gabarits stricts
- slot vérifié : tampon posé par une étape de tour acceptée (llm_slots.go,
  sous le verrou du compteur en vol), perdu dès qu'une autre requête part —
  vérification, sous-agent, tâche, préchauffage, résumé, bench, /v1 — ou que
  le modèle ou la fenêtre changent ; relu à l'envoi
- marge en jetons réels (dernier compte + non vu + demande + budget + 5 %)
- repli sur la transcription au moindre écart : refus du moteur, réseau,
  appel d'outil émis (tool_calls décodés) ou écrit en texte, raisonnement
  seul, résumé vide ; refus du gabarit ou appel d'outil = suspendue pour le
  modèle jusqu'au redémarrage, deux échecs de suite aussi
- avec la clé : pas de résumé quand même un vide ne réduirait pas de 20 %
  (borne exacte, avant tout archivage) ; après un refus faute de réduction,
  pas de nouvel essai avant +10 % de contexte, jamais à 90 % de la fenêtre,
  oublié quand le contexte baisse
- réactif, fenêtre pleine, bouton manuel, tâches, sous-agents, terminal,
  preset externe : chemin d'avant ; télémétrie kind=compact avec la discussion

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

internal/loki/llm_client.go

@@ -1165,6 +1165,12 @@ type chatPayloadOpts struct {
 	toolChoiceNone bool
 	effort         string
 	kwargs         map[string]any
+	// noSampling : sans l'échantillonnage du preset. Pour le résumé en
+	// continuation (COMPACT_CONTINUATION, chat_compact_cont.go), qui garde celui
+	// du résumeur d'aujourd'hui — température 0.2 seule : une pénalité de
+	// répétition jouerait contre la reprise fidèle des noms, chemins et chiffres.
+	// L'échantillonnage ne touche pas au prompt : le cache n'y perd rien.
+	noSampling bool
 }
 
 // buildChatPayload : le corps d'une requête de complétion de chat, à partir des
@@ -1189,7 +1195,9 @@ func buildChatPayload(ep chatEndpoint, sent []Message, temperature float64, o ch
 	// l'emporte sur la température ci-dessus). Posé AVANT le raisonnement : les
 	// deux blocs écrivent des clés disjointes, mais l'ordre rend explicite que
 	// c'est bien loki qui a le dernier mot sur `chat_template_kwargs`.
-	applySampling(payload)
+	if !o.noSampling {
+		applySampling(payload)
+	}
 	if o.effort != "" {
 		payload["reasoning_effort"] = o.effort
 	}
@@ -1398,8 +1406,9 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 		// Un préchauffage en vol (PREWARM, chat_prewarm.go) est annulé ici, sauf
 		// s'il prépare exactement le début de CETTE requête d'un tour de chat.
 		endReq := func() {}
+		var reqSeq uint64
 		if !ep.External {
-			endReq = engineRequestStartKeep(prewarmKeeper(ptag.kind, sent, payload))
+			endReq, reqSeq = engineRequestBegin(prewarmKeeper(ptag.kind, sent, payload))
 		}
 		resp, err := http.DefaultClient.Do(req)
 		if err != nil {
@@ -1569,6 +1578,11 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 		}
 		if !ep.External {
 			engineServed() // le slot porte désormais cette requête (llm_slots.go)
+			// Étape d'un tour de discussion : une compaction en continuation
+			// pourra la prolonger (chat_compact_cont.go). Sans la clé, rien.
+			if ptag.kind == perfMain && compactContinuationOn(chatCfg) {
+				engineMarkMain(reqSeq, ptag.conv)
+			}
 		}
 		toolCalls := map[int]*ToolCall{}
 		// argBufs : arguments de chaque appel, accumulés sans recopie. `+=` sur la
@@ -2481,10 +2495,18 @@ func runChatTools(ctx context.Context, messages []Message, tools []Tool, tempera
 				used = base + estimateTokens(messages[stepStart:])
 				lastEst = used
 			}
-			if compactNeeded(messages, used, peakGen) {
+			// COMPACT_CONTINUATION (chat_compact_cont.go) : tour de discussion
+			// seulement, ni tâche ni sous-agent. Sans la clé, rien ne change.
+			mainConv := ""
+			if ptag.kind == perfMain {
+				mainConv = ptag.conv
+			}
+			if compactNeeded(messages, used, peakGen) && !compactRefusedSkip(mainConv, used) {
+				opt := compactOptsMid(chatCfg, ep, mainConv, messages, used, tools, reasoningEffort, reasoningKwargs, pol,
+					disableTools || toolChoiceNone)
 				yes, no := true, false
 				cb(StreamEvent{Compacting: &yes})
-				c, changed := compactMessages(ctx, messages, caps)
+				c, changed := compactMessagesNoted(ctx, messages, caps, opt)
 				cb(StreamEvent{Compacting: &no})
 				logCompact("en-tour", used, messages, c, changed)
 				if changed {