@nosserb/prmt 0.0.0-stage → 2.0.0

package/tui/promethee/app/outils.py

@@ -0,0 +1,589 @@
+"""Appels d'outils du modèle et des agents : commandes, fichiers, recherche, délégation."""
+from __future__ import annotations
+
+import datetime as dt
+import json
+import os
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from rich.text import Text
+
+from ..agents import (
+    AGENT_DONE, AGENT_MENTION, AGENT_REMINDER, AGENT_REPORT_NOW, AGENT_SYSTEM, AGENT_TOOL, MAX_AGENT_STEPS,
+    find_agent, list_agents,
+)
+from ..appels import prune_calls
+from ..completion import human_size
+from ..config import MAX_TOOL_CHARS
+from ..consignes import (
+    ANNOUNCE, ASK_CONFIRM, CODE_EXTS, COMPILE_ONLY, CONTINUE, EDIT_TOOL, FAILED_CLAIM, FILE_TOOL_NAMES, INSPECT_CMD,
+    NO_CONFIRM, NUDGE, READ_TOOL, SEARCH_FILES_TOOL, SEARCH_TOOL_NAMES, SUCCESS_CLAIM, TOOLS, TOOL_NAME, WRITE_TOOL,
+    unverified_values, verify_nudge, writes_commands,
+)
+from ..fichiers import (
+    HOME, MAX_READ_CHARS, MAX_READ_LINES, SEARCH_LINES_TO_MODEL, apply_edit, change_summary,
+    missing_mentioned_files, new_file_format, numbered, read_text_file, render_diff, resolve_path, search_desc,
+    search_files, search_text, sensitive_path, show_path, write_text_file,
+)
+from ..memoire import GLOBAL_MEMORY
+from ..securite import precheck
+from ..shell import APP_CONTROL, for_model
+from ..theme import DIM, GREEN, RED, YELLOW
+from ..widgets import AgentView, ToolCallView, ToolState
+
+# Résultat d'un outil fichier : (message pour le modèle, texte de référence pour contrôler la réponse, décision)
+Resultat = tuple[str, str, str]
+
+
+class _Rendu(Exception):
+    """L'outil fichier s'arrête là : son résultat est prêt (erreur à corriger par le modèle, ou rien à changer)."""
+
+    def __init__(self, resultat: Resultat) -> None:
+        super().__init__(resultat[0])
+        self.resultat = resultat
+
+
+@dataclass
+class EtatAgent:
+    """Ce qu'un agent retient d'une étape à l'autre de son travail."""
+    st: ToolState = field(default_factory=ToolState)
+    nudged: bool = False    # relancé pour avoir écrit ses commandes au lieu de les exécuter
+    continues: int = 0      # relances « continue »
+    verifies: int = 0       # relances « vérifie ton code »
+    honest: bool = False    # relancé pour un succès annoncé après un échec
+
+
+class Outils:
+    """Partie de PrometheeApp : appels d'outils du modèle et des agents : commandes, fichiers, recherche, délégation."""
+
+    def _run_tool_calls(self, calls: list[dict], msgs: list[dict], st: ToolState,
+                        allowed: list[str] | None = None) -> bool:
+        """Exécute les appels d'outils du modèle principal ou d'un agent (allowed = ses outils).
+        Ajoute les résultats à msgs. Renvoie True si le tour doit s'arrêter : tu as refusé une action,
+        ou la politique en a refusé deux."""
+        for call in calls:
+            if self.cancel_event.is_set():
+                return False
+            name = (call.get("function") or {}).get("name") or "?"
+            args = self._call_arguments(call)
+            st.uses += 1
+            known = allowed if allowed is not None else [t["function"]["name"] for t in self.request_tools()]
+            if name not in known:
+                listed = ", ".join(f"`{n}`" for n in known) or "aucun"
+                msgs.append({"role": "tool", "tool_name": name, "content": f"Outil inconnu ou non disponible : {name}. "
+                                                                           f"Outils disponibles : {listed}."})
+            elif name == AGENT_TOOL:
+                if self._agent_call(args, msgs, st):
+                    return True
+            elif name in SEARCH_TOOL_NAMES:
+                self._search_call(name, args, msgs, st)
+            elif name in FILE_TOOL_NAMES:
+                if self._file_call(name, args, msgs, st):
+                    return True
+            elif self._command_call(args, msgs, st):
+                return True
+        return False
+
+    @staticmethod
+    def _call_arguments(call: dict) -> dict:
+        """Arguments d'un appel d'outil. Un texte qui n'est pas du JSON est pris pour la commande elle-même."""
+        args = (call.get("function") or {}).get("arguments") or {}
+        if isinstance(args, str):
+            try:
+                args = json.loads(args)
+            except json.JSONDecodeError:
+                args = {"commande": args}
+        return args if isinstance(args, dict) else {}
+
+    def _agent_call(self, args: dict, msgs: list[dict], st: ToolState) -> bool:
+        """lancer_agent : confie la tâche à l'agent. Renvoie True si tu as refusé une de ses actions."""
+        agent = find_agent(str(args.get("agent") or ""), self.cwd)
+        task = str(args.get("tache") or "").strip()
+        if agent is None or not task:
+            names = ", ".join(a["name"] for a in list_agents(self.cwd))
+            msgs.append({"role": "tool", "tool_name": AGENT_TOOL, "content": (
+                f"Agent inconnu : {args.get('agent')}. Agents disponibles : {names}." if agent is None else
+                "Erreur : la tâche est vide. Écris dans `tache` la consigne complète pour l'agent.")})
+            return False
+        return self._delegate(agent, task, msgs, st)[1]
+
+    def _search_call(self, name: str, args: dict, msgs: list[dict], st: ToolState) -> None:
+        content = self._search_tool(name, args)
+        msgs.append({"role": "tool", "tool_name": name, "content": content})
+        st.ran += [f"{name} {json.dumps(args, ensure_ascii=False)}", content]
+        self.call_from_thread(self.task_progress, " ".join(str(v) for v in args.values()), True)
+
+    def _file_call(self, name: str, args: dict, msgs: list[dict], st: ToolState) -> bool:
+        """lire_fichier, ecrire_fichier, modifier_fichier. Renvoie True si tu as refusé l'écriture."""
+        content, reference, decision = self._file_tool(name, args)
+        msgs.append({"role": "tool", "tool_name": name, "content": content})
+        if reference:
+            st.ran += [f"{name} {args.get('chemin', '')}", reference]
+        if name != READ_TOOL and content.startswith("Fichier "):
+            self.call_from_thread(self.task_progress, str(args.get("chemin") or ""), True)
+            # Un fichier a changé : relancer la même commande (cargo check après une correction…) a de nouveau un sens
+            st.last_ok = None
+            st.failed.clear()
+            if Path(str(args.get("chemin") or "")).suffix.lower() in CODE_EXTS:
+                st.unverified = str(args.get("chemin"))
+                st.compiled_only = False
+        return decision == "no"
+
+    # ------------------------------------------------------------------ executer_commande (thread)
+    def _command_call(self, args: dict, msgs: list[dict], st: ToolState) -> bool:
+        """Une commande proposée par le modèle : contrôles, politique, ta validation, exécution.
+        Renvoie True si le tour doit s'arrêter."""
+
+        def reply(content: str) -> None:
+            msgs.append({"role": "tool", "tool_name": TOOL_NAME, "content": content})
+
+        # qwen3.5 envoie parfois « command » ou « cmd » au lieu de « commande » (vu : 12 étapes perdues en
+        # « commande vide » sans comprendre pourquoi)
+        command = str(args.get("commande") or args.get("command") or args.get("cmd") or "").strip()
+        if not command:
+            got = ", ".join(f"« {k} »" for k in args) or "aucun"
+            reply(f"Erreur : commande vide. {TOOL_NAME} attend la commande PowerShell complète dans le paramètre "
+                  f"« commande » (paramètres reçus : {got}). Rappelle {TOOL_NAME} avec « commande » rempli.")
+            return False
+        view = self.call_from_thread(self._new_tool_view, command)
+        skipped = self._skip_command(command, st)
+        if skipped is not None:
+            shown, told = skipped
+            self.call_from_thread(view.set_skipped, shown)
+            reply(told)
+            return False
+        # 4) Politique : liste blanche, périmètre, arguments. Un refus n'est pas montré à l'utilisateur.
+        verdict = self._verdict(command)
+        if verdict is not None and verdict.refusee:
+            self.call_from_thread(view.set_refused, verdict.resume(), verdict.conseils())
+            self.noter_refus(command, verdict, "modèle")
+            reply(verdict.pour_modele())
+            st.failed.add(command)
+            st.refused += 1
+            # Deux refus dans la même réponse : le modèle cherche un détour, on s'arrête là
+            self._policy_stop = st.refused >= 2
+            return self._policy_stop
+        auto = self.is_allowed(command, verdict)
+        decision = "auto" if auto else self._ask_permission(command, str(args.get("explication") or ""), verdict)
+        if decision == "no":
+            self.call_from_thread(view.set_denied)
+            self.noter_commande(command, None, "", "refusée par toi", time.monotonic(), self.cwd, verdict, "refus", "modèle")
+            reply("L'utilisateur a refusé d'exécuter cette commande. Arrête-toi et attends ses instructions.")
+            return True
+        if decision == "always":
+            self.call_from_thread(self.allow, command)
+        code, output, note = self._run_command(command, verdict, auto, view)
+        reply(for_model(code, output, note))
+        self._after_command(command, code, output, st)
+        return False
+
+    def _skip_command(self, command: str, st: ToolState) -> tuple[str, str] | None:
+        """Commande à ne pas lancer telle quelle : (ce qui s'affiche, ce que reçoit le modèle), ou None.
+        Le modèle la corrige seul : elle ne t'est pas montrée."""
+        if command in st.failed:
+            # Le petit modèle a tendance à relancer à l'identique une commande fausse :
+            # inutile de la réexécuter (ni de la faire valider), on lui demande de la corriger.
+            return ("Non relancée : commande identique à celle qui vient d'échouer",
+                    "Non exécutée : c'est exactement la même commande que celle qui vient d'échouer, elle échouerait "
+                    "de la même façon. Corrige-la (autre syntaxe, autre option, autre commande) et rappelle l'outil, "
+                    "ou explique le problème à l'utilisateur.")
+        if command == st.last_ok:
+            # Même commande que celle qui vient de réussir, sans rien entre les deux : même résultat
+            return ("Non relancée : identique à la commande précédente, déjà réussie",
+                    "Non exécutée : tu viens déjà d'exécuter exactement cette commande avec succès, sa sortie est "
+                    "juste au-dessus. Utilise-la et passe à l'étape suivante (autre commande) ou au bilan.")
+        # 3) Vérification automatique avant de montrer la commande à l'utilisateur
+        self.call_from_thread(self._spinner, True, "check", "Vérification de la commande")
+        problems = precheck(command, self.cwd)
+        if not problems:
+            return None
+        st.failed.add(command)
+        return ("Vérification : " + ", ".join(s for s, _ in problems) + " → "
+                + (f"l'agent {self._agent_name}" if self._agent_name else "Prométhée") + " corrige la commande",
+                "Non exécutée (vérification automatique, avant de la montrer à l'utilisateur) : "
+                + " ; ".join(d for _, d in problems) + ". Corrige la commande et rappelle l'outil.")
+
+    def _run_command(self, command: str, verdict, auto: bool, view: ToolCallView) -> tuple[int | None, str, str]:
+        """Exécute la commande validée, l'inscrit au journal et affiche son résultat."""
+        self.call_from_thread(view.set_running, auto)
+        self.call_from_thread(self._spinner, True, "command")
+        started, where = time.monotonic(), self.cwd
+        code, output, note = self._execute(command, verdict)
+        self.noter_commande(command, code, output, note, started, where, verdict, "session" if auto else "toi", "modèle")
+        self.last_output = output
+        self.call_from_thread(view.set_result, code, output, note)
+        self.call_from_thread(self.task_progress, command, code == 0)
+        return code, output, note
+
+    @staticmethod
+    def _after_command(command: str, code: int | None, output: str, st: ToolState) -> None:
+        """Ce que le tour retient d'une commande exécutée, pour ses contrôles et ses relances."""
+        st.ran += [command, output]
+        if code not in (0, None):
+            st.failed.add(command)
+        st.last_ok = command if code == 0 else None
+        st.unverified = None  # une commande a tourné après la dernière modification du code
+        # (un programme compilé que Smart App Control empêche de lancer n'est pas un échec du code)
+        st.last_fail = (command, code) if code not in (0, None) and not APP_CONTROL.search(output) else None
+        if code == 0 and COMPILE_ONLY.search(command):
+            st.compiled_only = True
+        elif not INSPECT_CMD.match(command):
+            st.compiled_only = False  # programme lancé (ou bloqué par Smart App Control), ou autre commande
+
+    # ------------------------------------------------------------------ agents (thread)
+    def _direct_agent(self, msgs: list[dict], name: str) -> None:
+        """« @agent-nom tâche » : l'agent travaille, son rapport est la réponse (sans tour du modèle principal)."""
+        agent = find_agent(name, self.cwd)
+        content = next(m["content"] for m in reversed(msgs) if m["role"] == "user")
+        task = AGENT_MENTION.sub("", content, count=1).strip()
+        if agent is None or not task:
+            names = ", ".join(f"@agent-{a['name']}" for a in list_agents(self.cwd))
+            error = (f"agent inconnu : « {name} ». Agents disponibles : {names} (/agents pour les gérer)."
+                     if agent is None else f"écris la tâche à confier après @agent-{agent['name']}.")
+            self.call_from_thread(self.finish_agent, msgs, None, error, False, False, False)
+            return
+        call = {"function": {"name": AGENT_TOOL, "arguments": {"agent": agent["name"], "tache": task}}}
+        msgs.append({"role": "assistant", "content": "", "tool_calls": [call]})
+        report, refused = self._delegate(agent, task, msgs, ToolState(), direct=True)
+        cancelled = self.cancel_event.is_set()
+        if not refused and not cancelled:
+            self.call_from_thread(self._new_bubble, report)
+        self.call_from_thread(self.finish_agent, msgs, None, None, cancelled, refused, True)
+
+    def _delegate(self, agent: dict, task: str, msgs: list[dict], st: ToolState,
+                  direct: bool = False) -> tuple[str, bool]:
+        """Confie une tâche à un agent : son cadre s'affiche, il travaille, son rapport rejoint la conversation."""
+        view = self.call_from_thread(self._new_agent_view, agent["name"], task)
+        report, refused, ran = self._run_subagent(agent, task, view)
+        content = f"Rapport de l'agent {agent['name']} :\n{report}"
+        message = {"role": "tool", "tool_name": AGENT_TOOL, "content": content if direct or refused else content + AGENT_DONE}
+        if direct:
+            message["direct"] = True  # demandé avec @agent-nom : le rapport est la réponse affichée
+        msgs.append(message)
+        st.ran += ran  # ses sorties de commandes servent aussi à contrôler la réponse finale
+        return report, refused
+
+    def _run_subagent(self, agent: dict, task: str, view: AgentView) -> tuple[str, bool, list[str]]:
+        """Fait travailler un agent dans son propre contexte. Renvoie (rapport, refusé, sorties lues)."""
+        name = agent["name"]
+        tools = [t for t in TOOLS if t["function"]["name"] in agent["tools"]]
+        allowed = [t["function"]["name"] for t in tools]
+        model = agent.get("model") or self._turn_model or self.model
+        system = AGENT_SYSTEM.format(name=name, prompt=agent["prompt"], cwd=self.cwd,
+                                     date=dt.date.today().strftime("%d/%m/%Y"),
+                                     tools=", ".join(allowed) or "aucun") + self.memory_text()
+        msgs: list[dict] = [{"role": "user", "content": task}]
+        e = EtatAgent()
+        start, tokens, prompt_tokens = time.monotonic(), 0, 0
+        report, refused, error = "", False, None
+        pending: str | None = None  # relance, jamais gardée dans l'historique de l'agent
+        saved = (self._tool_parent, self._agent_name)
+        self._tool_parent, self._agent_name = self.call_from_thread(lambda: view.body), name
+        try:
+            for step in range(MAX_AGENT_STEPS + 1):
+                if self.cancel_event.is_set():
+                    break
+                last = step == MAX_AGENT_STEPS  # dernier tour : plus d'outils, il doit rendre son rapport
+                self.call_from_thread(self._spinner, True, "agent", f"Agent {name}")
+                request = [{"role": "system", "content": system}] + [dict(m) for m in msgs]
+                request[1]["content"] += AGENT_REMINDER
+                if last:
+                    request.append({"role": "user", "content": AGENT_REPORT_NOW})
+                elif pending:
+                    request.append({"role": "user", "content": pending})
+                text, calls, final, error = self._stream_turn(None, request, model, [] if last else tools)
+                if final:
+                    tokens += final.get("eval_count") or 0
+                    prompt_tokens = max(prompt_tokens, final.get("prompt_eval_count") or 0)
+                if error or self.cancel_event.is_set():
+                    break
+                if not calls or last:
+                    pending = self._agent_nudge(e, text, allowed, last)
+                    if pending is None:
+                        report = self._agent_report(text, e.st)
+                        break
+                    msgs.append({"role": "assistant", "content": text})
+                    continue
+                pending = None
+                calls = prune_calls(calls, self.cwd)
+                msgs.append({"role": "assistant", "content": "", "tool_calls": calls})
+                refused = self._run_tool_calls(calls, msgs, e.st, allowed)
+                self.call_from_thread(view.set_progress, e.st.uses)
+                if refused:
+                    break
+        finally:
+            self._tool_parent, self._agent_name = saved
+        seconds = time.monotonic() - start
+        report, note, color = self._agent_outcome(report, refused, error)
+        self.call_from_thread(view.set_done, e.st.uses, tokens + prompt_tokens, seconds, note, color, self.show_details)
+        if e.st.ran and not note:
+            self._check_agent_report(name, task, report, e.st, msgs)
+        return report, refused, e.st.ran
+
+    def _agent_nudge(self, e: EtatAgent, text: str, allowed: list[str], last: bool) -> str | None:
+        """L'agent a répondu sans appeler d'outil : faut-il le relancer plutôt que prendre ce texte pour son rapport ?
+        Renvoie la consigne de relance, ou None."""
+        st = e.st
+        if allowed and not st.uses and not e.nudged and writes_commands(text):
+            # Il a écrit les commandes au lieu de les exécuter : relancé une fois
+            e.nudged = True
+            return NUDGE
+        if st.uses and not last and e.continues < 3 and (ANNOUNCE.search(text) or ASK_CONFIRM.search(text)):
+            # Il annonce une étape sans la faire, ou demande une confirmation : on le relance
+            e.continues += 1
+            return NO_CONFIRM if ASK_CONFIRM.search(text) else CONTINUE
+        if st.unverified and TOOL_NAME in allowed and not last and e.verifies < 2:
+            # Code modifié puis rapport sans rien relancer : il doit d'abord vérifier
+            e.verifies += 1
+            return verify_nudge(st.unverified, self.cwd)
+        if st.last_fail and SUCCESS_CLAIM.search(text) and TOOL_NAME in allowed and not last and not e.honest:
+            # « Ça marche » alors que sa dernière commande a échoué
+            e.honest = True
+            return FAILED_CLAIM.format(cmd=st.last_fail[0], code=st.last_fail[1])
+        return None
+
+    @staticmethod
+    def _agent_report(text: str, st: ToolState) -> str:
+        """Le rapport de l'agent, avec un avertissement s'il annonce un succès après une commande en échec."""
+        report = text.strip()
+        if st.last_fail and SUCCESS_CLAIM.search(report):
+            report += (f"\n\n⚠ Contrôle automatique : la dernière commande de l'agent (`{st.last_fail[0]}`) a "
+                       f"échoué (code {st.last_fail[1]}) : ne te fie pas à ce rapport, ça ne marche sans doute pas.")
+        return report
+
+    def _agent_outcome(self, report: str, refused: bool, error: str | None) -> tuple[str, str, str]:
+        """Comment le travail de l'agent s'est terminé : (rapport rendu, note affichée, couleur de la note)."""
+        note, color = "", GREEN
+        if refused:
+            note, color = "Arrêté : tu as refusé une de ses actions", YELLOW
+            report = "L'utilisateur a refusé une action de l'agent : il s'est arrêté avant la fin."
+        elif self.cancel_event.is_set():
+            note, color = "Interrompu", DIM
+            report = "(Agent interrompu par l'utilisateur.)"
+        elif error:
+            note, color = f"Erreur : {error}", RED
+            report = f"(L'agent n'a pas pu terminer : {error})"
+        elif not report:
+            note, color = "Terminé sans rapport", YELLOW
+            report = "(L'agent n'a rien rapporté.)"
+        if len(report) > MAX_TOOL_CHARS:
+            report = report[:MAX_TOOL_CHARS] + "\n[… rapport coupé …]"
+        return report, note, color
+
+    def _check_agent_report(self, name: str, task: str, report: str, st: ToolState, msgs: list[dict]) -> None:
+        """Contrôle du rapport : valeurs citées absentes de tout ce que l'agent a lu ?"""
+        refs = "\n".join(st.ran + [task, self.memory_text()] + [m["content"] for m in msgs if m["role"] == "tool"])
+        missing = unverified_values(report, refs)
+        if missing:
+            shown = ", ".join(missing[:8]) + (f"… (+{len(missing) - 8})" if len(missing) > 8 else "")
+            self.call_from_thread(self.add_notice, f"À vérifier (rapport de l'agent {name}) : ces valeurs "
+                                  f"n'apparaissent dans aucune sortie (il a pu les inventer) : {shown}", YELLOW)
+
+    # ------------------------------------------------------------------ outils fichiers (thread)
+    def _file_tool(self, name: str, args: dict) -> Resultat:
+        """lire / écrire / modifier un fichier. Renvoie (message pour le modèle, texte de référence, décision)."""
+        raw = str(args.get("chemin") or "").strip()
+        if not raw:
+            return "Erreur : le paramètre « chemin » est vide. Indique le chemin du fichier.", "", ""
+        path = resolve_path(raw, self.cwd)
+        label = {READ_TOOL: "Lire", WRITE_TOOL: "Écrire", EDIT_TOOL: "Modifier"}[name]
+        view = self.call_from_thread(self._new_tool_view, show_path(path, self.cwd), label,
+                                     "Lecture…" if name == READ_TOOL else "En attente de ta validation…")
+        try:
+            if path.is_dir():
+                self._fail(view, f"{path} est un dossier, pas un fichier. Pour lister son contenu, utilise executer_commande "
+                                 "avec Get-ChildItem.", "C'est un dossier")
+            if name == READ_TOOL:
+                return self._read_file(path, args, view)
+            # Écriture ou modification : on calcule le nouveau contenu, puis l'utilisateur valide le diff
+            old, new, encoding, newline = self._file_change(name, path, args, view)
+            return self._file_write(name, path, old, new, encoding, newline, str(args.get("explication") or ""), view)
+        except _Rendu as rendu:
+            return rendu.resultat
+
+    def _fail(self, view: ToolCallView, message: str, shown: str | None = None) -> None:
+        """Arrête l'outil fichier sur une erreur que le modèle doit corriger."""
+        self.call_from_thread(view.set_skipped, shown or message)
+        raise _Rendu((f"Erreur : {message}", "", ""))
+
+    def _read_file(self, path: Path, args: dict, view: ToolCallView) -> Resultat:
+        if not path.exists():
+            self._fail(view, f"fichier introuvable : {path}. Vérifie le chemin : lis seulement un fichier que tu as vu, "
+                             "ou trouve-le avec chercher_fichiers.", "Fichier introuvable")
+        try:
+            text, encoding, _ = read_text_file(path)
+        except (OSError, ValueError) as err:
+            self._fail(view, f"lecture impossible de {path} : {err}", f"Lecture impossible : {err}")
+        return self._read_result(path, text, encoding, args, view)
+
+    def _file_change(self, name: str, path: Path, args: dict, view: ToolCallView) -> tuple[str | None, str, str, str]:
+        """Le changement demandé : (ancien contenu ou None, nouveau contenu, encodage, fin de ligne).
+        S'arrête (_Rendu) si le changement est impossible, vide, ou si une mémoire cite des fichiers inventés."""
+        old: str | None = None
+        encoding, newline = new_file_format(path)
+        if path.exists():
+            try:
+                old, encoding, newline = read_text_file(path)
+            except (OSError, ValueError) as err:
+                self._fail(view, f"lecture impossible de {path} : {err}", f"Lecture impossible : {err}")
+        if name == WRITE_TOOL:
+            content = args.get("contenu")
+            if not isinstance(content, str):
+                self._fail(view, "le paramètre « contenu » est manquant.", "Contenu manquant")
+            if "\n" not in content and content.count("\\n") >= 2:
+                content = content.replace("\\n", "\n").replace("\\t", "\t")  # sauts de ligne échappés deux fois
+            new = content.replace("\r\n", "\n")
+        else:
+            if old is None:
+                self._fail(view, f"le fichier {path} n'existe pas. Pour le créer, utilise ecrire_fichier.", "Fichier introuvable")
+            new, error = apply_edit(old, str(args.get("ancien_texte") or ""), str(args.get("nouveau_texte") or ""))
+            if new is None:
+                self._fail(view, error, "Extrait introuvable ou ambigu → Prométhée relit le fichier" if "fois" in error
+                           or "introuvable" in error else error)
+        if old is not None and new == old:
+            self.call_from_thread(view.set_text, "Aucun changement : contenu identique", None, DIM)
+            raise _Rendu(("Aucun changement : le nouveau contenu est identique à l'actuel.", "", ""))
+        if path.name.lower() == "promethee.md" and path != GLOBAL_MEMORY:
+            # Mémoire d'un dossier : pas de fichiers inventés (une seule fois par nom : s'il insiste, tu tranches)
+            missing = [m for m in missing_mentioned_files(new, old or "", path.parent)
+                       if m.lower() not in self._memory_rejected]
+            if missing:
+                self._memory_rejected.update(m.lower() for m in missing)
+                existing = [rel for rel, _, _ in search_files("*", path.parent)[0]][:30]
+                self._fail(view, f"{path.name} cite des fichiers qui n'existent pas dans {path.parent} : {', '.join(missing)}. "
+                                 "La mémoire ne doit contenir que ce que tu as vu : rappelle "
+                                 f"{'ecrire_fichier' if name == WRITE_TOOL else 'modifier_fichier'} avec un contenu corrigé"
+                                 + (f" (fichiers qui existent : {', '.join(existing)})." if existing else "."),
+                           f"Fichiers inexistants cités ({', '.join(missing)}) → Prométhée corrige")
+        return old, new, encoding, newline
+
+    def _file_write(self, name: str, path: Path, old: str | None, new: str, encoding: str, newline: str,
+                    explanation: str, view: ToolCallView) -> Resultat:
+        """Te montre le diff (sauf écriture autorisée pour la session), écrit le fichier, l'inscrit au journal."""
+        home = os.path.normcase(str(HOME)) + os.sep
+        outside = not os.path.normcase(str(path)).startswith(home)
+        # Profil PowerShell, dossier Démarrage, clés, mémoire, agents : toujours montrés, même après « oui pour toutes »
+        sensitive = "" if outside else sensitive_path(path)
+        if self.allow_edits and not outside and not sensitive:
+            decision = "auto"
+        else:
+            decision = self._wait_choice(
+                lambda done: self.show_edit_permission(name, path, old, new, explanation, outside, done, sensitive))
+        if decision == "no":
+            self.call_from_thread(view.set_denied)
+            self.noter_fichier(name, path, "cancelled", "Écriture refusée par toi.")
+            return ("L'utilisateur a refusé cette écriture dans le fichier. Arrête-toi et attends ses instructions.",
+                    "", "no")
+        if decision == "always":
+            self.allow_edits = True
+        try:
+            write_text_file(path, new, encoding, newline)
+        except OSError as err:
+            self.noter_fichier(name, path, "error", f"Écriture impossible : {err}")
+            self._fail(view, f"écriture impossible dans {path} : {err}", f"Écriture impossible : {err}")
+        diff, added, removed = render_diff(old, new, max_lines=10)
+        self.noter_fichier(name, path, "ok", change_summary(added, removed, old is None), added=added, removed=removed,
+                           confirmation="session" if decision == "auto" else "toi", outside=outside or None)
+        summary = change_summary(added, removed, old is None) + ("  (autorisé pour la session)" if decision == "auto" else "")
+        self.call_from_thread(view.set_text, summary, diff)
+        what = "créé" if old is None else "modifié"
+        return f"Fichier {what} : {path} (+{added} −{removed} lignes).", new, decision
+
+    def _read_result(self, path: Path, text: str, encoding: str, args: dict, view: ToolCallView) -> Resultat:
+        lines = text.split("\n")
+        if lines and lines[-1] == "":
+            lines.pop()  # saut de ligne final
+        total = len(lines)
+        if not total:
+            self.call_from_thread(view.set_text, "Fichier vide", None, DIM)
+            return f"Le fichier {path} est vide.", "", "auto"
+
+        def number(value, default: int) -> int:
+            try:
+                return int(value)
+            except (TypeError, ValueError):
+                return default
+
+        start = min(max(1, number(args.get("debut"), 1)), total)
+        end = max(start, min(total, number(args.get("fin"), total), start + MAX_READ_LINES - 1))
+        body = numbered("\n".join(lines[start - 1:end]), start)
+        if len(body) > MAX_READ_CHARS:
+            cut = body.rfind("\n", 0, MAX_READ_CHARS)
+            body = body[:cut] if cut > 0 else body[:MAX_READ_CHARS] + " […ligne coupée…]"
+            end = start + body.count("\n")
+        partial = start > 1 or end < total
+        note = (f"\n[Lignes {start} à {end} sur {total}. Pour la suite : lire_fichier avec debut={end + 1}.]"
+                if end < total else "")
+        count = end - start + 1
+        self.call_from_thread(view.set_text, f"{count} ligne{'s' if count > 1 else ''} lue{'s' if count > 1 else ''}"
+                              + (f" (sur {total})" if partial else ""))
+        return f"Contenu de {path} ({total} lignes) :\n{body}{note}", "\n".join(lines[start - 1:end]), "auto"
+
+    # ------------------------------------------------------------------ outils de recherche (thread)
+    def _search_tool(self, name: str, args: dict) -> str:
+        """chercher_fichiers / chercher_texte : lecture seule, donc sans validation (comme Glob / Grep)."""
+        raw = str(args.get("dossier") or "").strip()
+        root = resolve_path(raw, self.cwd) if raw and raw != "." else self.cwd
+        view = self.call_from_thread(self._new_tool_view, search_desc(name, args, show_path(root, self.cwd)
+                                                                      if root != self.cwd else ""), "Chercher", "Recherche…")
+        if not root.is_dir():
+            self.call_from_thread(view.set_skipped, "Dossier introuvable")
+            return f"Erreur : dossier introuvable : {root}. Vérifie le chemin."
+        self.call_from_thread(self._spinner, True, "check", "Recherche")
+        found = (self._find_files if name == SEARCH_FILES_TOOL else self._find_text)(args, root, view)
+        if isinstance(found, str):
+            return found   # rien trouvé, ou demande invalide : le message est prêt et la vue est à jour
+        summary, content, shown = found
+        detail = Text("\n".join("   " + line[:160] for line in shown[:8]), style=DIM)
+        if len(shown) > 8:
+            detail.append(f"\n   … +{len(shown) - 8}", style=f"italic {DIM}")
+        self.call_from_thread(view.set_text, summary, detail)
+        return content
+
+    def _find_files(self, args: dict, root: Path, view: ToolCallView) -> str | tuple[str, str, list[str]]:
+        """chercher_fichiers : (résumé affiché, résultat pour le modèle, lignes montrées), ou le message s'il n'y a rien."""
+        pattern = str(args.get("motif") or "").strip() or "*"
+        found, note = search_files(pattern, root, self.cancel_event)
+        extra = f" ; {note}" if note else ""
+        if not found:
+            self.call_from_thread(view.set_text, "Aucun fichier trouvé" + extra, None, DIM)
+            return f"Aucun fichier « {pattern} » dans {root} ni ses sous-dossiers{extra}."
+        lines = [f"{rel}  ({human_size(size)}, modifié le {dt.datetime.fromtimestamp(mtime):%d/%m/%Y %H:%M})"
+                 for rel, size, mtime in found]
+        summary = f"{len(found)} fichier{'s' if len(found) > 1 else ''} trouvé{'s' if len(found) > 1 else ''}{extra}"
+        content = f"Fichiers « {pattern} » dans {root} ({len(found)}{extra}) :\n" + "\n".join(lines)
+        return summary, content, [rel for rel, _, _ in found]
+
+    def _find_text(self, args: dict, root: Path, view: ToolCallView) -> str | tuple[str, str, list[str]]:
+        """chercher_texte : (résumé affiché, résultat pour le modèle, lignes montrées), ou le message s'il n'y a rien."""
+        text = str(args.get("texte") or "").strip()
+        if not text:
+            self.call_from_thread(view.set_skipped, "Texte à chercher vide")
+            return "Erreur : le paramètre « texte » est vide."
+        files = str(args.get("fichiers") or "").strip()
+        found, scanned, note = search_text(text, root, files, self.cancel_event)
+        extra = f" ; {note}" if note else ""
+        if not found:
+            self.call_from_thread(view.set_text, f"Aucune ligne trouvée ({scanned} fichiers lus{extra})", None, DIM)
+            return f"Aucune ligne ne contient « {text} » dans {root} ({scanned} fichiers lus{extra})."
+        n_files = len({rel for rel, _, _ in found})
+        shown = [f"{rel}:{number}: {line}" for rel, number, line in found]
+        summary = (f"{len(found)} ligne{'s' if len(found) > 1 else ''} dans {n_files} fichier"
+                   f"{'s' if n_files > 1 else ''}{extra}")
+        content = (f"Lignes contenant « {text} » dans {root} ({len(found)} lignes dans {n_files} fichiers, "
+                   f"{scanned} fichiers lus{extra}) :\n")
+        if len(found) <= SEARCH_LINES_TO_MODEL:
+            return summary, content + "\n".join(shown), shown
+        # Beaucoup de lignes (jusqu'à 100 × 200 caractères) : elles rempliraient le contexte de 8 192 jetons
+        # avant toute lecture. Le modèle reçoit le compte par fichier et les premières lignes.
+        counts: dict[str, int] = {}
+        for rel, _, _ in found:
+            counts[rel] = counts.get(rel, 0) + 1
+        ranked = sorted(counts.items(), key=lambda kv: -kv[1])
+        content += ("Par fichier : " + ", ".join(f"{rel} ({n})" for rel, n in ranked[:30])
+                    + (" …" if len(ranked) > 30 else "") + f"\nLes {SEARCH_LINES_TO_MODEL} premières lignes :\n"
+                    + "\n".join(line[:160] for line in shown[:SEARCH_LINES_TO_MODEL])
+                    + "\n(Lis le fichier le plus utile avec lire_fichier, ou précise la recherche.)")
+        return summary, content, shown