Niveau supérieur : mémoire compressée, outils chirurgicaux, modèle code auto

Faire d'un petit modèle un bon agent :
- memory.py : contexte = invite + résumé des anciens tours + 10 derniers
  messages ; résumé régénéré en arrière-plan après chaque réponse (colonne
  summary sur sessions, migration douce). Contexte court = modèle concentré
  et qui tient sur le GPU.
- tools.py : edit_file (recherche/remplacement exact, erreurs pédagogiques,
  unicité exigée), grep_search (regex bornée, dossiers ignorés), et
  vérification syntaxique auto (.py/.json) après chaque écriture — l'erreur
  revient au modèle qui se corrige dans le même tour.
- coder.pick_code_model : les tâches de code vont au meilleur modèle code
  installé (qwen-coder, deepseek-coder…) via config code_model=auto.
- Branché dans la route chat (mémoire + résolution du modèle code) et la
  boucle agent (code_task) ; UI : descriptions et glyphes des nouveaux outils.

Tests : edit/grep/vérification, compression mémoire (19 msgs -> 12 dont
résumé), pick auto/explicite, chat HTTP de bout en bout, build front.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01SVay7z3y7q2gEe54ByAE6N

backend/app/routes/chat.py

@@ -18,7 +18,7 @@ from fastapi import APIRouter, HTTPException
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 
-from .. import agent_config, coder, db, router as msg_router
+from .. import agent_config, coder, db, memory, router as msg_router
 from ..agent import run_agent
 from ..config import settings
 
@@ -110,16 +110,23 @@ async def chat(req: ChatRequest) -> StreamingResponse:
         and await msg_router.is_code_task(req.content, model)
     )
 
-    convo = [{"role": "system", "content": cfg["system_prompt"]}]
-    convo += db.list_messages_for_model(req.session_id)
+    # Mémoire compressée : système + résumé des anciens tours + messages récents.
+    convo = memory.build_convo(req.session_id, cfg["system_prompt"])
+
+    # Moteur code : choisit le meilleur modèle code installé (config "auto").
+    code_model = (
+        await coder.pick_code_model(model, cfg.get("code_model"))
+        if use_code else model
+    )
 
     async def event_stream():
         yield _sse("start", {"model": model, "engine": "code" if use_code else "agent"})
 
         # Chemin « moteur code » : Aider gère la tâche de bout en bout.
         if use_code:
-            async for chunk in _code_stream(req, model):
+            async for chunk in _code_stream(req, code_model):
                 yield chunk
+            asyncio.create_task(memory.maybe_summarize(req.session_id, model))
             return
 
         final_content = ""
@@ -215,6 +222,8 @@ async def chat(req: ChatRequest) -> StreamingResponse:
                 "error": error_message or None,
             },
         )
+        # Compression de l'historique en arrière-plan (sans bloquer la réponse).
+        asyncio.create_task(memory.maybe_summarize(req.session_id, model))
 
     return StreamingResponse(
         event_stream(),

backend/app/routes/config.py

@@ -21,6 +21,7 @@ class ConfigPatch(BaseModel):
     tools: dict[str, bool] | None = None
     confirm_shell: bool | None = None
     think: bool | None = None
+    code_model: str | None = None
 
 
 @router.get("")