Les 5 évolutions : plan, auto-critique, RAG, vérif HTML, benchmark

1. Plan-puis-exécute (enhance.make_plan) : les demandes complexes sont
   décomposées en 3-5 étapes (event SSE 'plan', carte PLAN dans le fil,
   meta.plan persisté) ; le plan guide l'agent et le moteur code.
2. Auto-critique « Qualité + » (enhance.self_review, toggle Intelligence) :
   critique éclair puis révision de la réponse (event 'revision').
3. Mémoire long-terme RAG (rag.py) : échanges vectorisés via /api/embed
   (modèle d'embedding auto-détecté), rappel cosinus top-3 inter-sessions
   injecté en contexte, indexation en arrière-plan, élagage à 2000 souvenirs.
4. Vérification HTML (tools.check_html) : références locales cassées et
   balises déséquilibrées ; branchée sur l'auto-vérification des outils ET
   sur le moteur code avec une passe d'auto-correction Aider.
5. Benchmark intégré (bench.py + /api/bench) : 5 épreuves notées /100
   (appel d'outil, code exécuté en sous-processus isolé, consignes, JSON,
   format), streaming SSE, scores stockés ; carte BENCHMARK dans l'UI.

Config : plan_mode / self_review / rag_enabled / embed_model + carte
Intelligence (3 toggles). Client SSE : events plan/revision ; PlanCard.

Tests : heuristique+parsing du plan, révision, index/rappel RAG (exclusion
de la session courante), html_check, bench 100/100 sur modèle simulé,
intégration chat HTTP (event plan + meta persisté), build front.

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

backend/app/tools.py

@@ -50,8 +50,40 @@ def read_file(path: str) -> dict:
     return {"ok": True, "content": content, "summary": summary}
 
 
+def check_html(target: str) -> list[str]:
+    """Contrôles rapides d'une page HTML : références locales et balises.
+
+    Renvoie une liste de problèmes (vide = OK).
+    """
+    issues: list[str] = []
+    try:
+        with open(target, "r", encoding="utf-8", errors="replace") as f:
+            content = f.read()
+    except OSError:
+        return issues
+
+    base_dir = os.path.dirname(target)
+
+    # Références locales cassées (href/src vers un fichier absent).
+    for _, ref in re.findall(r"""(href|src)=["']([^"'#]+)["']""", content, re.I):
+        if re.match(r"^(https?:|data:|mailto:|tel:|//|javascript:)", ref, re.I):
+            continue
+        ref_path = os.path.normpath(os.path.join(base_dir, ref.split("?")[0]))
+        if not os.path.exists(ref_path):
+            issues.append(f"référence cassée : {ref}")
+
+    # Équilibre des balises structurantes.
+    for tag in ("html", "head", "body", "div", "section", "script", "style"):
+        opened = len(re.findall(rf"<{tag}[\s>]", content, re.I))
+        closed = len(re.findall(rf"</{tag}>", content, re.I))
+        if opened != closed:
+            issues.append(f"balise <{tag}> : {opened} ouverte(s) / {closed} fermée(s)")
+
+    return issues[:6]
+
+
 def _verify_written(target: str) -> str | None:
-    """Vérification syntaxique immédiate après écriture (py/json).
+    """Vérification immédiate après écriture (py/json/html).
 
     Renvoyer l'erreur au modèle tout de suite lui permet de se corriger dans
     le même tour, au lieu de livrer un fichier cassé.
@@ -65,6 +97,10 @@ def _verify_written(target: str) -> str | None:
             _json.loads(content)
         elif ext == ".py":
             compile(content, target, "exec")
+        elif ext in (".html", ".htm"):
+            problems = check_html(target)
+            if problems:
+                return " ; ".join(problems)
     except SyntaxError as exc:
         return f"SyntaxError ligne {exc.lineno}: {exc.msg}"
     except ValueError as exc: