Loki/internal/loki/chat_compact.go

package loki

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
	"regexp"
	"strconv"
	"strings"
)

// Compactage du contexte, façon Hermes Agent : au lieu de vider la conversation
// quand la fenêtre de contexte se remplit, on la scinde en trois zones —
//
//	Head  (tête)  : messages système + tout premier message utilisateur. Protégé.
//	Tail  (queue) : les tours récents (dans un budget de tokens). Protégé.
//	Torso (torse) : tout le milieu. C'est LA SEULE zone compactée.
//
// Le torse est d'abord dégraissé sans IA (les vieux résultats d'outils longs
// sont remplacés par un marqueur), puis résumé par le modèle local en UN seul
// appel, et le tout est remplacé par un court résumé. Résultat : des
// conversations quasi illimitées sans jamais « clear », comme Hermes.
//
// La logique vit côté serveur (dans le flux de chat) donc elle profite à TOUS
// les clients — UI web, terminal, accès distant ajean.link — sans duplication.

const (
	// Seuil de déclenchement proactif : on compacte quand l'historique estimé
	// dépasse cette fraction de la fenêtre de contexte.
	compactTriggerFrac = 0.75
	// Budget de la queue : fraction de la fenêtre gardée intacte (tours récents).
	// Plus la queue est petite, plus on compacte de torse d'un coup → le contexte
	// retombe bas et met longtemps à re-déclencher (au lieu de compacter souvent).
	// Descendu de 0.25 à 0.20 avec l'archivage recall : compacter plus large ne
	// coûte plus de perte (les gros blocs restent rappelables), donc autant faire
	// des compactions franches et rares plutôt que fréquentes et molles.
	compactTailFrac = 0.20
	// Un résultat d'outil du torse plus long que ça est remplacé par un marqueur
	// dans le torse DÉGRAISSÉ (repli si le résumé échoue).
	compactToolPruneLen = 200
	// Longueur à laquelle on RACCOURCIT (sans l'effacer) un résultat d'outil avant
	// de le donner au résumeur : assez pour que les faits d'une page web y soient,
	// assez court pour que dix pages tiennent dans la transcription.
	compactToolSummaryLen = 1200
)

// compactPrunedMarker remplace un vieux résultat d'outil dans le torse. Il dit
// EXPLICITEMENT de ne pas relancer l'outil : le texte précédent (« Old tool
// result cleared ») se lisait comme une invitation à re-télécharger la page, et
// le modèle repartait en boucle — page relue, contexte plein, nouveau compactage,
// résultat re-effacé, et ainsi de suite.
const compactPrunedMarker = "[Old tool result removed to save context. The important content is in the summary above — do NOT call this tool again to fetch it back.]"

// compactSummaryPrefix ouvre le message `user` synthétique qui porte le résumé.
// Sert aussi à le reconnaître pour ne pas le confondre avec une vraie demande.
const compactSummaryPrefix = "[CONTEXT COMPACTED]"

// compactEnabled indique si le compactage automatique du contexte est actif.
// Défaut : true. Seule une valeur off/false/0/no/non explicite (config.env
// COMPACT) le désactive — cohérent avec toolLimitEnabled().
func compactEnabled() bool {
	switch strings.ToLower(strings.TrimSpace(ReadConfig()["COMPACT"])) {
	case "off", "false", "0", "no", "non":
		return false
	}
	return true
}

// ctxWindow renvoie la fenêtre de contexte configurée (config.env CTX), 32768
// par défaut — la même valeur que celle passée à llama-server au lancement.
func ctxWindow() int {
	if v := ReadConfig()["CTX"]; v != "" {
		if n, err := strconv.Atoi(v); err == nil && n > 0 {
			return n
		}
	}
	return 32768
}

// compactSummaryBudget renvoie le budget en tokens du résumé, adapté à la
// fenêtre. Assez pour PORTER LE FIL (la demande, les faits déjà trouvés, les
// décisions, l'état d'avancement) sans jamais le perdre — c'était la plainte de
// fond : à 700 tokens fixes, tout le passé d'une longue conversation était
// écrasé en un demi-paragraphe et le modèle « perdait le fil ». Le résumé reste
// de toute façon minuscule devant le torse compacté (souvent des dizaines de
// milliers de tokens), donc la réduction demeure massive. Bornes : 700 (petites
// fenêtres) à 1600 (grandes), ~4 % de la fenêtre entre les deux.
func compactSummaryBudget() int {
	n := ctxWindow() * 4 / 100
	if n < 700 {
		n = 700
	}
	if n > 1600 {
		n = 1600
	}
	return n
}

// imageLostMarker remplace la partie `image_url` d'un message multimodal dans
// msgText. Toute la chaîne de compaction passe par msgText — estimation de
// contexte, choix des messages à résumer, transcript donné au résumeur — et
// msgText n'extrayait QUE les parties `text`. Un message qui porte une capture
// (screenshotImageMessage) ne pesait donc que sa légende (« Capture … »), et le
// résumeur ne savait même pas qu'une image avait été montrée : au compactage
// suivant l'image disparaissait SANS AUCUNE trace. Observé en amont comme cause
// probable de boucles de raisonnement — le modèle a bien regardé l'image, ne
// peut plus s'y référer, et redérive à l'aveugle en texte.
//
// Ce marqueur ne rend pas l'image récupérable (le résumé est du texte), il rend
// sa PERTE visible : le résumeur peut la mentionner, et le modèle sait qu'il
// doit REVOIR l'image plutôt que deviner.
//
// Formulation volontairement générale depuis l'arrivée de see_image : une image
// peut désormais venir d'une capture (web_screenshot), d'une pièce jointe ou
// d'un fichier du disque. Dire « reprends la capture » enverrait le modèle
// photographier une page web alors que l'image perdue était un PNG sur le
// disque — le geste juste dépend de la provenance, que la légende conservée
// juste avant ce marqueur indique.
const imageLostMarker = " [image — not kept in the conversation past this point; look at it again (see_image on the file, or a new screenshot) if you still need to see it]"

// msgText extrait le texte d'un message (Content est `any`, en pratique string
// ou nil quand l'assistant n'a que des tool_calls). Un message multimodal
// (userMessageContent : parties texte + image quand la vision est active) porte
// un tableau de parties ; on en recolle les segments `text` pour que l'estimation
// de contexte et le transcript de compaction ne partent pas d'un texte vide, et
// on marque la présence d'une partie `image_url` (voir imageLostMarker) — sans
// quoi elle reste invisible à toute la chaîne de compaction.
func msgText(m Message) string {
	switch v := m.Content.(type) {
	case string:
		return v
	case []map[string]any:
		var b strings.Builder
		for _, part := range v {
			switch part["type"] {
			case "text":
				if s, ok := part["text"].(string); ok {
					b.WriteString(s)
				}
			case "image_url":
				b.WriteString(imageLostMarker)
			}
		}
		return b.String()
	case []any: // même contenu relu depuis le JSON persisté (map générique)
		var b strings.Builder
		for _, p := range v {
			part, ok := p.(map[string]any)
			if !ok {
				continue
			}
			switch part["type"] {
			case "text":
				if s, ok := part["text"].(string); ok {
					b.WriteString(s)
				}
			case "image_url":
				b.WriteString(imageLostMarker)
			}
		}
		return b.String()
	}
	return ""
}

// msgTokens estime grossièrement le coût en tokens d'un message (~4 caractères
// par token, plus un forfait par message pour le rôle et les délimiteurs). C'est
// volontairement approximatif : le comptage EXACT vient de llama.cpp
// (PromptTokensTotal) ; ici on veut juste décider quand compacter.
func msgTokens(m Message) int {
	n := 4
	n += len(msgText(m)) / 4
	for _, tc := range m.ToolCalls {
		n += (len(tc.Function.Name) + len(tc.Function.Arguments)) / 4
	}
	return n
}

// estimateTokens estime la taille de l'historique en tokens.
func estimateTokens(msgs []Message) int {
	total := 0
	for _, m := range msgs {
		total += msgTokens(m)
	}
	return total
}

// MaybeCompact compacte l'historique si (et seulement si) il dépasse le seuil
// proactif. Renvoie l'historique (compacté ou inchangé) et un booléen indiquant
// s'il a changé. À appeler sur l'historique BRUT (avant InjectSkills) pour que
// le résultat puisse être renvoyé au client sans le préfixe système injecté.
//
// knownTokens = taille RÉELLE du contexte au tour précédent (usage.prompt_tokens
// + tokens générés), telle que rapportée par llama.cpp et affichée par l'UI. On
// la préfère à estimateTokens() car cette dernière n'est qu'une heuristique et,
// surtout, ne « voit » pas le prompt système injecté (machine briefing) ni le
// gabarit de chat — donc elle sous-estime largement le vrai contexte. 0 = inconnu
// (clients sans compteur, ex. terminal) → repli sur l'estimation.
// compactWouldTrigger indique si un tour VA déclencher une compaction proactive
// (compactage activé ET contexte au-dessus du seuil). Exposé pour que le flux de
// chat puisse afficher une bannière « compactage en cours » AVANT de lancer le
// résumé (qui bloque plusieurs secondes), au lieu d'une UI figée sans info.
func compactWouldTrigger(msgs []Message, knownTokens int) bool {
	if !compactEnabled() {
		return false
	}
	used := knownTokens
	if used <= 0 {
		used = estimateTokens(msgs)
	}
	return used >= int(float64(ctxWindow())*compactTriggerFrac)
}

// compactNeeded = compactWouldTrigger, plus une garde de MARGE DE GÉNÉRATION.
// Tant que le raisonnement de la dernière étape était compté dans le contexte
// (à tort : il n'est jamais renvoyé), il offrait par accident une marge à peu
// près proportionnelle à la longueur des étapes. Ce compte est désormais juste,
// et sans max_tokens ni budget de raisonnement, une étape aussi longue que la
// plus longue récente doit encore tenir : sinon le moteur coupe en plein
// raisonnement (« length »). peakGen = 0 (inconnu, API externe) : seuil seul.
func compactNeeded(msgs []Message, used, peakGen int) bool {
	if compactWouldTrigger(msgs, used) {
		return true
	}
	return compactEnabled() && genHeadroomShort(used, peakGen, ctxWindow())
}

// genHeadroomShort : la fenêtre ne laisse plus la place d'une génération de
// 1,2 × la plus longue récente (plancher de 8 k jetons, ramené à 1/8 de la
// fenêtre pour les petites), plus une petite marge. Fonction pure, testable.
// Plancher et marge sont choisis pour ne JAMAIS devancer le seuil de 75 % à eux
// seuls : seule une génération longue avance la compaction.
//
// Et jamais avant la MOITIÉ de la fenêtre, si longue que soit la génération :
// une étape de 40 k sur 65 k (ou de 20 k sur 32 k) réclamait sinon une place
// que l'historique compacté lui-même — prompt système, outils, résumé, queue —
// ne laisse pas. La garde repartait alors à CHAQUE étape, résumé de résumé, le
// fil perdu pour rien. Au-delà, c'est le rejeu sur « length » qui rattrape.
func genHeadroomShort(used, peakGen, window int) bool {
	if used <= 0 || peakGen <= 0 || window <= 0 {
		return false
	}
	need := max(peakGen*6/5, min(8192, window/8)) + min(1024, window/32)
	return used+min(need, window/2) > window
}

// logCtx trace un fait du comptage de contexte (fenêtre pleine, relance après
// un raisonnement sans action) : de quoi vérifier, journal en main, qu'ils ne
// deviennent pas plus fréquents.
func logCtx(format string, args ...any) {
	fmt.Fprintf(os.Stderr, "[ctx] "+format+"\n", args...)
}

// logCtxEstimate compare le contexte ESTIMÉ avant une requête au compte réel
// du moteur (usage.prompt_tokens), et ne parle qu'au-delà de 2 % d'écart.
func logCtxEstimate(phase string, est, actual int) {
	if actual <= 0 {
		return
	}
	if d := est - actual; d*50 > actual || -d*50 > actual {
		logCtx("%s estimé=%d réel=%d écart=%+d", phase, est, actual, d)
	}
}

// ctxPending ajoute au dernier contexte mesuré (used, valable pour les
// measured premiers messages) l'estimation des messages arrivés depuis : le
// nouveau message utilisateur, ceux de la file. Le compte du moteur ne les a
// pas vus. measured = 0 (inconnu, discussion rechargée) ou plus grand que
// l'historique (réécrit entre-temps) : on s'en tient au compte mesuré.
func ctxPending(used, measured int, msgs []Message) int {
	if used <= 0 || measured <= 0 || measured > len(msgs) {
		return used
	}
	return used + estimateTokens(msgs[measured:])
}

// logCompact trace UNE ligne par décision de compaction sur la sortie d'erreur
// (donc dans `journalctl -u loki-ui`). Sans ça, une compaction qui ne se
// déclenche pas — ou qui se déclenche et n'enlève rien — est invisible : côté
// UI on ne voit qu'une jauge qui reste haute, sans savoir si le seuil n'a pas
// été atteint ou si la réduction a été refusée.
func logCompact(phase string, used int, before, after []Message, changed bool) {
	fmt.Fprintf(os.Stderr, "[compact] %s ctx=%d seuil=%d/%d est_avant=%d est_apres=%d msgs=%d→%d changé=%v\n",
		phase, used, int(float64(ctxWindow())*compactTriggerFrac), ctxWindow(),
		estimateTokens(before), estimateTokens(after), len(before), len(after), changed)
}

func MaybeCompact(ctx context.Context, msgs []Message, caps Caps, knownTokens int) ([]Message, bool) {
	if !compactWouldTrigger(msgs, knownTokens) {
		return msgs, false
	}
	return compactMessages(ctx, msgs, caps)
}

// compactMessages exécute la compaction sans tenir compte du seuil (utilisé en
// secours réactif quand llama-server refuse un prompt trop long). Renvoie
// l'historique compacté et true s'il a effectivement changé.
// compactBounds calcule les frontières head/tail pour un historique donné et un
// budget de queue (en tokens). Fonction pure (pas d'IO) → testable :
//   - head : nb de messages protégés en tête = messages système, et RIEN d'autre.
//     Le tout premier message utilisateur y était épinglé pour « ancrer
//     l'objectif » ; c'était contre-productif. Après compaction, le modèle voyait
//     deux demandes explicites — celle du DÉBUT de la conversation, épinglée, et
//     celle réinjectée par `pending` — et répondait volontiers à l'ancienne, en
//     abandonnant la tâche en cours. La demande courante est déjà garantie par
//     `pending` ; le premier message, lui, part au résumé comme le reste.
//   - tailStart : index de début de la queue protégée. On remonte depuis la fin
//     jusqu'à remplir le budget, puis on recule jusqu'à une frontière SÛRE :
//     un message `user`, ou un `assistant` (qui, s'il porte des tool_calls, part
//     dans la queue AVEC ses résultats). On ne sépare ainsi jamais un
//     assistant+tool_calls de ses `tool`, et on ne laisse jamais un `tool`
//     orphelin en tête de queue.
//
// Reculer jusqu'à un `user` UNIQUEMENT était trop strict et rendait toute
// 2ᵉ compaction inopérante dans un même tour : pendant une longue boucle
// d'outils il n'y a AUCUN message `user`, donc la queue avalait toute la
// séquence d'outils et le torse était vide (« le compactage ne fait rien »
// alors que ce sont précisément les pages web lues qui remplissent la
// fenêtre). S'arrêter sur un `assistant` coupe proprement entre deux groupes
// d'appels d'outils.
//
// Le torse à compacter est [head, tailStart). Il est vide (tailStart <= head)
// quand il n'y a rien à résumer.
func compactBounds(msgs []Message, tailBudget int) (head, tailStart int) {
	for head < len(msgs) && msgs[head].Role == "system" {
		head++
	}
	tailStart = len(msgs)
	acc := 0
	for i := len(msgs) - 1; i >= head; i-- {
		acc += msgTokens(msgs[i])
		tailStart = i
		if acc >= tailBudget {
			break
		}
	}
	// Jamais sur un rappel de loki (isLokiInjected) : il a le rôle `user` sans
	// être une demande. En tête de queue, la vraie demande réinjectée juste
	// avant (pending, voir compactMessages) lui serait collée — deux `user`
	// d'affilée, que les gabarits à alternance stricte refusent à chaque tour.
	// On recule jusqu'à l'appel d'outil qui le précède : la queue garde un
	// groupe de plus, rien n'est perdu.
	for tailStart > head && ((msgs[tailStart].Role != "user" && msgs[tailStart].Role != "assistant") ||
		isLokiInjected(msgs[tailStart])) {
		tailStart--
	}
	return head, tailStart
}

func compactMessages(ctx context.Context, msgs []Message, caps Caps) ([]Message, bool) {
	// Budget de queue = fraction de la CONVERSATION (pas de la fenêtre). Le lier à
	// la fenêtre était le bug : une conversation de 25k tokens dans une fenêtre de
	// 64k gardait 16k (0.25×64k) en queue → torse minuscule → réduction < 20% →
	// refusée. Lié à la conversation, on garde toujours ~25% des tours récents et
	// on compacte les ~75% du début, quelle que soit la taille de la fenêtre.
	tailBudget := int(float64(estimateTokens(msgs)) * compactTailFrac)
	head, tailStart := compactBounds(msgs, tailBudget)

	// Rien à compacter : le torse [head, tailStart) est vide.
	if tailStart <= head {
		return msgs, false
	}

	torso := msgs[head:tailStart]

	// 3. Archivage des gros blocs (mémoire longue). AVANT de compacter, chaque bloc
	//    du torse assez long est enregistré VERBATIM sous un id (r7…) : le résumé et
	//    le repli le remplacent par une référence à cet id, que le modèle pourra
	//    rappeler avec recall(id). C'est ce qui rend le compactage sûr même
	//    agressif — rien n'est perdu, seulement déplacé hors du contexte.
	//    On n'archive QUE si le modèle a réellement ses outils (mode agent) : sans
	//    eux il ne pourrait pas rappeler, autant garder un résumé propre sans ids.
	//    Un échec d'écriture (base absente, tests) laisse archived[i] nil → repli
	//    transparent sur le comportement classique (troncature/marqueur sans id).
	archived := make([]*recallEntry, len(torso))
	var index []recallEntry
	if caps.Agent && compactEnabled() {
		names := torsoToolNames(torso)
		for i, m := range torso {
			if !recallEligible(m) {
				continue
			}
			content := msgText(m)
			label := recallLabel(m.Role, names[m.ToolCallID], content)
			id, aerr := archiveRecallBlock(label, m.Role, content)
			if aerr != nil {
				continue
			}
			archived[i] = &recallEntry{id: id, label: label}
			index = append(index, recallEntry{id: id, label: label})
		}
	}

	// 4. Dégraissage sans IA : les vieux résultats d'outils longs deviennent un
	//    marqueur. On travaille sur une copie pour ne pas muter l'historique amont.
	//    ⚠️ Ce torse dégraissé ne sert QUE de repli si le résumé échoue — surtout
	//    PAS d'entrée au résumeur, cf. juste en dessous. Un bloc archivé pointe vers
	//    son id (récupérable par recall) au lieu d'être effacé aveuglément.
	pruned := make([]Message, len(torso))
	for i, m := range torso {
		pruned[i] = m
		if e := archived[i]; e != nil {
			pruned[i].Content = recallMarker(e.id, e.label)
			continue
		}
		if m.Role == "tool" {
			if t := msgText(m); len(t) > compactToolPruneLen {
				pruned[i].Content = compactPrunedMarker
			}
		}
	}

	// 5. Résumé du torse par le modèle local (un seul appel).
	//
	//    Le résumé se fait sur le torse ORIGINAL, pas sur le dégraissé. C'était LE
	//    bug de fond : on effaçait tous les résultats d'outils PUIS on demandait un
	//    résumé de ce qui restait. Le résumeur ne voyait donc que « Tool result:
	//    [Old tool result cleared] » à la place de chaque page web lue — le résumé
	//    ne pouvait contenir AUCUNE des informations trouvées, seulement la trace
	//    que des outils avaient tourné. À chaque compactage, l'IA repartait donc
	//    d'une recherche vide et recommençait à zéro : elle ne s'arrêtait jamais.
	//
	//    Un bloc archivé est réduit à sa TÊTE (assez pour le résumer fidèlement).
	//    On ne montre PAS l'id recall au résumeur : sa seule tâche est d'écrire de
	//    la prose. Lui exposer « recall:rN » l'incite à répondre juste par l'id
	//    (résumé dégénéré) ; l'index des ids est de toute façon ajouté séparément
	//    et de façon déterministe par compactSummaryUserMsg.
	//    Les résultats d'outils non archivés sont seulement RACCOURCIS (leur début,
	//    qui porte l'essentiel : titre, en-tête, premières lignes) pour que la
	//    transcription reste bornée. Les faits survivent, le volume reste maîtrisé.
	forSummary := make([]Message, len(torso))
	for i, m := range torso {
		forSummary[i] = m
		if archived[i] != nil {
			r := []rune(msgText(m))
			headTxt := string(r)
			if len(r) > recallSummaryHeadLen {
				headTxt = string(r[:recallSummaryHeadLen]) + "…"
			}
			forSummary[i].Content = headTxt + "\n[…reste de ce bloc omis ici]"
			continue
		}
		if m.Role == "tool" {
			if r := []rune(msgText(m)); len(r) > compactToolSummaryLen {
				forSummary[i].Content = string(r[:compactToolSummaryLen]) + "\n[…suite coupée]"
			}
		}
	}
	summary, err := summarizeTranscriptFor(ctx, renderTranscript(forSummary), caps.Code)
	var mid []Message
	if err != nil || summaryLooksEmpty(summary) {
		// Résumé raté (erreur, vide, ou juste une référence recall) → on garde le
		// torse dégraissé, qui porte au moins les têtes de blocs et les marqueurs
		// recall : bien plus informatif qu'un résumé dégénéré.
		mid = pruned
	} else {
		// Le résumé est injecté comme un tour utilisateur→assistant (jamais un
		// message `system` au milieu : certains gabarits, ex. Qwen, exigent que le
		// system soit uniquement en tête — cf. mémoire qwen36-chat-template-fix).
		// Le message porte aussi la CONSCIENCE de la compaction et l'index des ids
		// rappelables (voir compactSummaryUserMsg).
		sumMsg := compactSummaryUserMsg(summary, index)
		// Mode Code : les critères ne vivent pas dans le fil (seuls les appels à
		// l'outil criteria y passent, et ils viennent d'être résumés). On rend
		// leur état au builder ici, dans un message de toute façon neuf — pas de
		// cache invalidé en plus (repris d'OpenFox).
		if caps.Code {
			if list := critList(convEnsureActive()); len(list) > 0 {
				sumMsg += "\n\nAcceptance criteria (current state):\n" + critRender(list)
			}
		}
		mid = []Message{
			{Role: "user", Content: sumMsg},
			{Role: "assistant", Content: "Understood. I'll resume from exactly where I left off, using the findings above, and call recall(id) if I need the full content of an archived block, without redoing work that is already done."},
		}
	}

	// La demande EN COURS ne doit JAMAIS être diluée dans le résumé. Pendant une
	// longue boucle d'outils (recherche web : dix pages lues d'affilée), la queue
	// n'est faite que d'appels d'outils : le message `user` qui a lancé la
	// recherche tombe dans le torse, alors que le TOUT PREMIER message de la
	// conversation, lui, reste épinglé en tête. Après compaction le modèle voyait
	// donc, comme seule demande explicite, la question du DÉBUT de la conversation
	// — et il y répondait en abandonnant la recherche en cours.
	// On réinjecte donc textuellement la dernière vraie demande du torse, juste
	// avant la queue (les résultats d'outils qu'elle a produits la suivent, comme
	// dans l'historique d'origine). Le torse reste entièrement compactable.
	//
	// Seulement quand c'est nécessaire (AJEAN 0.17.4), sinon deux bugs :
	//   - la queue contient déjà un message `user` : la dernière demande du torse a
	//     DÉJÀ reçu sa réponse, la réinjecter juste avant la nouvelle faisait
	//     répondre le modèle une seconde fois à une vieille question ;
	//   - repli sans résumé (mid = torse dégraissé) : ce message y est déjà, il se
	//     retrouvait en double, cette fois APRÈS ses propres résultats d'outils.
	//
	// Un rappel de loki (budget d'outils, relance) a le rôle `user` sans être une
	// demande (isLokiInjected) : ni il ne prouve qu'une demande a été servie, ni
	// il ne se réinjecte à la place de la vraie.
	tailHasUser := false
	for _, m := range msgs[tailStart:] {
		if m.Role == "user" && !isLokiInjected(m) {
			tailHasUser = true
			break
		}
	}
	summarized := err == nil && !summaryLooksEmpty(summary)
	var pending []Message
	for i := len(torso) - 1; i >= 0 && summarized && !tailHasUser; i-- {
		if torso[i].Role != "user" || isLokiInjected(torso[i]) {
			continue
		}
		if strings.HasPrefix(msgText(torso[i]), compactSummaryPrefix) {
			continue // résumé d'une compaction précédente, pas une demande
		}
		pending = []Message{torso[i]}
		break
	}

	out := make([]Message, 0, head+len(mid)+len(pending)+len(msgs)-tailStart)
	out = append(out, msgs[:head]...)
	out = append(out, mid...)
	out = append(out, pending...)
	out = append(out, msgs[tailStart:]...)

	// Garantie de réduction : on n'accepte la compaction que si elle enlève au
	// moins ~20% du contexte estimé. Sinon (torse déjà maigre, résumé peu rentable)
	// on la refuse — sans ça, loki « compactait » à presque chaque message sans
	// vraiment réduire, puis re-déclenchait aussitôt.
	before, after := estimateTokens(msgs), estimateTokens(out)
	if after > before*4/5 {
		return msgs, false
	}
	return out, true
}

// summaryLooksEmpty détecte un résumé raté : trop court, ou constitué seulement
// de références « recall:rN » (un petit modèle, mal aiguillé, répond parfois par
// un id au lieu d'écrire de la vraie prose). Dans ce cas on préfère le repli
// dégraissé. Seuil à 40 caractères de VRAI texte (hors jetons recall).
func summaryLooksEmpty(s string) bool {
	s = strings.TrimSpace(s)
	if len([]rune(s)) < 40 {
		return true
	}
	var real strings.Builder
	for _, f := range strings.Fields(s) {
		low := strings.ToLower(strings.Trim(f, ".,;:()[]-•*"))
		if strings.HasPrefix(low, "recall:r") || strings.HasPrefix(low, "recall(") {
			continue
		}
		real.WriteString(f)
		real.WriteString(" ")
	}
	return len([]rune(strings.TrimSpace(real.String()))) < 40
}

// recallEntry associe un id d'archive à son libellé court, pour l'index injecté
// dans le message de compaction.
type recallEntry struct{ id, label string }

// recallEligible dit si un message du torse mérite d'être archivé sous un id :
// un bloc assez gros (le résumé ne le porterait pas fidèlement) d'un rôle réel,
// et qui n'est pas déjà le résumé d'une compaction précédente (on ne ré-archive
// pas un résumé).
func recallEligible(m Message) bool {
	switch m.Role {
	case "tool", "user", "assistant":
	default:
		return false
	}
	t := msgText(m)
	if len([]rune(t)) <= recallArchiveMinLen {
		return false
	}
	return !strings.HasPrefix(t, compactSummaryPrefix)
}

// torsoToolNames associe chaque ToolCallID du torse au nom de l'outil qui l'a
// produit (l'assistant porte les tool_calls, le résultat ne porte que l'id),
// pour donner un libellé lisible aux blocs archivés (« web_read: … »).
func torsoToolNames(torso []Message) map[string]string {
	names := map[string]string{}
	for _, m := range torso {
		for _, tc := range m.ToolCalls {
			if tc.ID != "" {
				names[tc.ID] = tc.Function.Name
			}
		}
	}
	return names
}

// recallMarker remplace un bloc archivé dans le torse dégraissé (repli). Il cite
// l'id récupérable et interdit explicitement de relancer l'outil pour le refaire.
func recallMarker(id, label string) string {
	return fmt.Sprintf("[Block archived to save context — full content retrievable with recall(\"%s\") (%s). Do NOT re-run a tool to fetch it back.]", id, label)
}

// compactSummaryUserMsg construit le message `user` synthétique qui porte le
// résumé. Il rend le modèle CONSCIENT que la conversation a été compactée (il le
// sait aussi bien que nous), et lui donne l'index des blocs rappelables. L'index
// ne liste QUE les ids créés à cette passe : sa taille reste bornée, une
// conversation infinie ne gonfle jamais cette section (les vieux blocs restent
// joignables par recall_search).
func compactSummaryUserMsg(summary string, index []recallEntry) string {
	var b strings.Builder
	b.WriteString(compactSummaryPrefix)
	if len(index) > 0 {
		b.WriteString(" The earlier turns of this conversation were summarized to save context, but nothing is lost: any block referenced below (or in the summary) as recall:rN can be brought back verbatim with the recall(id) tool, and recall_search(\"keywords\") finds older archived blocks not listed here. Here is the summary:\n\n")
	} else {
		b.WriteString(" The earlier turns of this conversation were summarized to save context. Here is the summary:\n\n")
	}
	b.WriteString(summary)
	if len(index) > 0 {
		b.WriteString("\n\nArchived blocks you can bring back with recall(id):\n")
		for _, e := range index {
			fmt.Fprintf(&b, "- %s — %s\n", e.id, e.label)
		}
		b.WriteString("Only recall a block when you actually need its full content.")
	}
	return b.String()
}

// renderTranscript sérialise le torse en texte lisible pour le résumeur.
func renderTranscript(msgs []Message) string {
	var b strings.Builder
	for _, m := range msgs {
		switch m.Role {
		case "user":
			// Rappel de loki : une note du système, pas une demande que le
			// résumé devrait attribuer à l'utilisateur.
			if isLokiInjected(m) {
				fmt.Fprintf(&b, "System: %s\n", msgText(m))
				continue
			}
			fmt.Fprintf(&b, "User: %s\n", msgText(m))
		case "assistant":
			if t := msgText(m); t != "" {
				fmt.Fprintf(&b, "Assistant: %s\n", t)
			}
			for _, tc := range m.ToolCalls {
				fmt.Fprintf(&b, "Assistant → tool %s(%s)\n", tc.Function.Name, tc.Function.Arguments)
			}
		case "tool":
			fmt.Fprintf(&b, "Tool result: %s\n", msgText(m))
		case "system":
			fmt.Fprintf(&b, "System: %s\n", msgText(m))
		}
	}
	s := b.String()
	// Garde-fou pour les petites fenêtres : le résumeur ne doit pas lui-même
	// déborder. On plafonne la transcription (~0,7×contexte en tokens ≈ 2,8
	// caractères/token) en gardant la FIN (la plus récente) et en marquant la
	// troncature de tête.
	maxChars := int(float64(ctxWindow()) * 2.8)
	if maxChars > 0 && len(s) > maxChars {
		s = "[…start truncated…]\n" + s[len(s)-maxChars:]
	}
	return s
}

// summarizeResp modélise le sous-ensemble utile d'une réponse non-streamée de
// /v1/chat/completions.
type summarizeResp struct {
	Choices []struct {
		Message struct {
			Content          string `json:"content"`
			ReasoningContent string `json:"reasoning_content"`
		} `json:"message"`
		FinishReason string `json:"finish_reason"`
	} `json:"choices"`
}

// summarizeTranscript demande au modèle local un résumé dense et fidèle du torse.
// Un seul appel NON streamé, sans outils — comme Hermes, on réutilise le modèle
// principal déjà chargé (aucune dépendance, cohérent avec la fenêtre de contexte).
func summarizeTranscript(ctx context.Context, transcript string) (string, error) {
	return summarizeTranscriptFor(ctx, transcript, false)
}

// codeSummaryRules : ce qu'un résumé de mode Code doit garder en plus — sans
// quoi le builder réécrit des fichiers déjà faits et retombe dans des erreurs
// déjà résolues (repris du COMPACTION_PROMPT d'OpenFox).
const codeSummaryRules = `
This is a CODING session. Also keep:
- Every file created or modified (path) and what changed in it
- Errors hit (build, tests, tools) and how each was resolved — or that it is still open
- The commands that build and test the project`

// summarizeTranscriptFor : code = résumé d'une session du mode Code.
func summarizeTranscriptFor(ctx context.Context, transcript string, code bool) (string, error) {
	sys := `You are a context compactor. You are given the transcript of the older turns of a conversation between a user and an AI assistant (with its tools). The PURPOSE of your summary is to let the conversation continue in a fresh, smaller context WITHOUT losing any information that is useful or important to understand what came before and keep working — preserve everything that matters, drop only what is redundant.

The assistant is MID-TASK: it will read your summary and must resume exactly where it left off, WITHOUT redoing work it has already done. Its own internal reasoning is NOT part of the transcript and is lost — your summary is the only memory it keeps.

Summarize densely and faithfully, keeping ONLY the essentials:
- The user's CURRENT request, goal(s) and constraints
- FINDINGS: the concrete information already gathered — facts, figures, dates, names, URLs, file paths, values, config. This is the most important part: whatever is not here is lost and will have to be looked up again.
- Sources already consulted (URLs opened, files read, commands run) — so they are not consulted a second time
- Decisions made and established facts
- STATE OF PROGRESS: what is already answered, what is still missing, and the next concrete step
Strict rules: no preamble or conclusion, no verbatim or long quotes, no throwaway detail. Use short bullet points. Be as concise as you can WHILE keeping every fact, decision and still-open task: a detail you drop here is lost for good, so when in doubt keep it. This is a dense compression summary, not a report. Always write ACTUAL prose sentences/bullets — never answer with just an id or a reference.
Write the summary in the SAME language as the conversation.`
	if code {
		sys += codeSummaryRules
	}

	// Le résumé part au MÊME endroit que le chat : sur un preset externe, il
	// s'appuie sur l'API distante (backend_external.go). Le laisser taper le
	// llama-server local ferait échouer toute compaction dès qu'aucun moteur
	// local ne tourne — et la compaction, c'est ce qui empêche le fil de mourir.
	ep := resolveChatEndpoint()
	payload := map[string]any{
		"model": ep.Model,
		"messages": []Message{
			{Role: "system", Content: sys},
			{Role: "user", Content: transcript},
		},
		"stream":      false,
		"temperature": 0.2,
		// Borne dure : sans ça, un modèle bavard (surtout à reasoning) produit un
		// résumé énorme et lent, donc peu de réduction → re-compaction à chaque tour.
		"max_tokens": compactSummaryBudget(),
		// Pas de réflexion pour un résumé : plus rapide, plus dense, et évite qu'un
		// modèle hybride gaspille tout le budget en <think> (résumé vide). llama.cpp
		// passe ces kwargs au gabarit Jinja (--jinja).
		"chat_template_kwargs": map[string]any{"enable_thinking": false},
	}
	if ep.External {
		// Propre à llama.cpp : une API distante stricte (OpenAI) refuse un
		// argument inconnu par un 400, et la compaction échouait à chaque fois.
		delete(payload, "chat_template_kwargs")
	}
	body, _ := json.Marshal(payload)
	req, err := http.NewRequestWithContext(ctx, "POST", ep.URL, bytes.NewReader(body))
	if err != nil {
		return "", err
	}
	req.Header.Set("Content-Type", "application/json")
	ep.auth(req.Header.Set)
	if !ep.External {
		defer engineRequestStart()() // voir llm_slots.go
	}
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return "", friendlyLLMError(err)
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		b, _ := io.ReadAll(io.LimitReader(resp.Body, 500))
		who := "llama-server"
		if ep.External {
			who = "API externe"
		}
		return "", fmt.Errorf("résumé: %s %d: %s", who, resp.StatusCode, strings.TrimSpace(string(b)))
	}
	raw, err := io.ReadAll(resp.Body)
	if err != nil {
		return "", err
	}
	// Decoder et non Unmarshal : comme avant, seule la première valeur JSON
	// compte — un octet parasite après elle (proxy, passerelle) ne doit pas
	// faire échouer une compaction qui passait.
	var out summarizeResp
	if err := json.NewDecoder(bytes.NewReader(raw)).Decode(&out); err != nil {
		return "", err
	}
	// Télémétrie de la compaction : réponse non streamée, timings et usage sont
	// à la racine. Lue à part et sans échec possible (perfWire) : un compteur
	// mal typé ne doit jamais faire échouer la compaction.
	perfRecord(perfRecFromWire(perfTag{kind: perfCompact, conv: perfTagOf(ctx).conv}, decodePerfWire(raw)), nil)
	if len(out.Choices) == 0 {
		return "", fmt.Errorf("résumé: réponse vide")
	}
	ch := out.Choices[0]
	return cleanSummary(ch.Message.Content, ch.Message.ReasoningContent, ch.FinishReason)
}

// summaryRuneCap borne le résumé en caractères, en filet de sécurité
// seulement. L'ancienne borne fixe de 2200 caractères (≈ 550 tokens) coupait
// un résumé que max_tokens autorisait à ~1600 tokens — et le prompt met l'ÉTAT
// D'AVANCEMENT en dernier : c'était précisément lui, ce dont l'agent a besoin
// pour reprendre, qui tombait. max_tokens borne déjà la sortie ; ×6 caractères
// par token laisse passer tout résumé que le moteur a pu produire (le français
// tourne autour de 4) et ne mord que sur une API qui ignorerait max_tokens.
func summaryRuneCap() int {
	return compactSummaryBudget() * 6
}

// cleanSummary extrait le texte final d'une réponse de résumé. Une erreur fait
// retomber l'appelant sur le torse dégraissé, sans perte : bien mieux que
// d'installer du raisonnement brut comme « mémoire » de la conversation.
//   - un bloc <think>…</think> en tête est retiré, seule la réponse compte ;
//   - un <think> ouvert en tête et jamais refermé (modèle qui ignore
//     enable_thinking=false et bute sur max_tokens), ou un texte vide à côté
//     d'un reasoning_content : il n'y a QUE du raisonnement, pas de résumé →
//     erreur ;
//   - finish_reason=length : le texte est gardé (le début d'un bon résumé vaut
//     mieux que rien), marqué « […] » et tracé dans le journal.
func cleanSummary(content, reasoning, finish string) (string, error) {
	c := strings.TrimSpace(content)
	// Le raisonnement ne se retire qu'en TÊTE : soit un bloc <think>…</think>
	// qui ouvre la réponse, soit un </think> sans <think> avant lui (gabarit qui
	// ouvre le bloc dans le prompt). Couper au DERNIER </think>, comme avant,
	// amputait tout le début d'un résumé de session Code qui cite la balise (un
	// parseur, un gabarit) — et une balise citée après un <think> en milieu de
	// texte n'est pas du raisonnement non plus.
	for {
		i := strings.Index(c, thinkClose)
		if i < 0 {
			break
		}
		if o := strings.Index(c[:i], "<think>"); o > 0 {
			break
		}
		c = strings.TrimSpace(c[i+len(thinkClose):])
		if !strings.HasPrefix(c, "<think>") {
			break
		}
	}
	if strings.HasPrefix(c, "<think>") {
		return "", fmt.Errorf("résumé: raisonnement jamais refermé, aucun résumé")
	}
	if c == "" {
		if strings.TrimSpace(reasoning) != "" || strings.TrimSpace(content) != "" {
			return "", fmt.Errorf("résumé: rien hors du raisonnement")
		}
		return "", fmt.Errorf("résumé: texte vide")
	}
	cut := ""
	if r := []rune(c); len(r) > summaryRuneCap() {
		// Coupé sur une frontière de rune (é, … ne doivent pas devenir des �).
		c = strings.TrimSpace(string(r[:summaryRuneCap()]))
		cut = fmt.Sprintf("par le filet de %d caractères", summaryRuneCap())
	}
	if finish == "length" {
		cut = fmt.Sprintf("par max_tokens=%d", compactSummaryBudget())
	}
	if cut != "" {
		// Tracé dans les deux cas : le filet ne mord que sur une API qui
		// ignore max_tokens, et c'est l'ÉTAT D'AVANCEMENT qui tombe.
		fmt.Fprintf(os.Stderr, "[compact] résumé coupé %s (%d caractères gardés)\n", cut, len([]rune(c)))
		c += " […]"
	}
	return c, nil
}

// contextOverflow : le refus du moteur (corps d'erreur msg) signale-t-il un
// débordement de la fenêtre de contexte ? Reconnaît les libellés de llama.cpp
// (« exceeds the available context size », exceed_context_size_error) et des API
// OpenAI-compatibles (context_length_exceeded, « maximum context length »). À
// défaut de libellé reconnu, on se fie à la taille estimée : une conversation
// déjà à 90 % de la fenêtre a toutes les chances d'être la cause.
func contextOverflow(msg string, msgs []Message) bool {
	m := strings.ToLower(msg)
	for _, k := range []string{"context size", "context_size", "context length", "context_length",
		"context window", "n_ctx", "too many tokens", "prompt is too long", "exceeds the context"} {
		if strings.Contains(m, k) {
			return true
		}
	}
	return estimateTokens(msgs) >= int(float64(ctxWindow())*0.9)
}

// ---- dernier recours : la requête ne rentre toujours pas -------------------
// Repris d'AJEAN 0.17.5.

var reqTokensRe = regexp.MustCompile(`request \((\d+) tokens\)`)

// overflowTokens extrait la taille réelle de la requête refusée par llama.cpp
// (« request (132291 tokens) exceeds… »), 0 si absente.
func overflowTokens(msg string) int {
	if m := reqTokensRe.FindStringSubmatch(msg); m != nil {
		n, _ := strconv.Atoi(m[1])
		return n
	}
	return 0
}

const shrinkTruncMarker = "\n[…tronqué : contexte plein. Relance l'outil de façon plus ciblée si tu as besoin de la suite]"

// shrinkToFit est le filet quand le moteur a refusé le prompt ET que le
// compactage n'a rien pu faire (torse vide, ou réduction jugée trop faible :
// typiquement un tour qui a lu beaucoup de gros fichiers d'un coup, tout est
// dans la queue protégée). Avant, l'erreur 400 remontait telle quelle et la
// conversation restait bloquée. Ici on réduit pour de bon :
//  1. les gros résultats d'outils (du plus ancien au plus récent) sont tronqués ;
//  2. si ça ne suffit pas, on retire les plus vieux échanges, par tour entier
//     (frontière `user`), en gardant les messages système de tête.
//
// La cible vise 60 % de la fenêtre, corrigée par l'écart entre estimation et
// taille réelle (actual, lue dans l'erreur) : l'estimation sous-compte (images…).
func shrinkToFit(msgs []Message, actual int) ([]Message, bool) {
	est := estimateTokens(msgs)
	if est <= 0 {
		return msgs, false
	}
	ratio := 1.0
	if actual > est {
		ratio = float64(actual) / float64(est)
	}
	target := int(float64(ctxWindow()) * 0.6 / ratio)
	out := append([]Message(nil), msgs...)
	for i := range out {
		if estimateTokens(out) <= target {
			break
		}
		if out[i].Role != "tool" {
			continue
		}
		if r := []rune(msgText(out[i])); len(r) > 2000 {
			out[i].Content = string(r[:1500]) + shrinkTruncMarker
		}
	}
	head := 0
	for head < len(out) && out[head].Role == "system" {
		head++
	}
	for estimateTokens(out) > target {
		// Coupe d'abord aux vraies demandes : couper sur un rappel de loki
		// jetterait la demande en gardant la fin de sa boucle d'outils. Un
		// rappel ne sert de coupe qu'en dernier recours, quand il n'y a plus
		// aucune demande après la tête (une seule longue boucle d'outils) —
		// comme avant qu'ils soient persistés.
		next, nudge := -1, -1
		for k := head + 1; k < len(out); k++ {
			if out[k].Role != "user" {
				continue
			}
			if !isLokiInjected(out[k]) {
				next = k
				break
			}
			if nudge < 0 {
				nudge = k
			}
		}
		if next < 0 {
			next = nudge
		}
		if next < 0 {
			break
		}
		out = append(out[:head:head], out[next:]...)
	}
	return out, estimateTokens(out) < est
}

// toolResultMax borne TOUT résultat d'outil dans la vue du modèle (≈ 8k
// tokens). Le terminal et le web ont déjà leur propre plafond, plus bas ;
// celui-ci rattrape les autres (lecture de fichier, pages mémoire, MCP…) : un
// seul résultat géant suffisait à faire déborder une fenêtre de 65k d'un coup,
// sans que le compactage puisse rien y faire. L'UI, elle, garde le résultat
// complet (« voir plus », tool_results.go).
const toolResultMax = 30000

func capToolResult(s string) string {
	if r := []rune(s); len(r) > toolResultMax {
		return string(r[:toolResultMax]) + "\n[…tronqué : résultat trop long. Cible une partie plus précise si tu as besoin de la suite]"
	}
	return s
}