@nosserb/prmt 0.0.0-stage → 2.0.0

package/tui/promethee/theme.py

@@ -0,0 +1,92 @@
+"""Couleurs de l'interface : la palette de Prométhée, les rôles qui s'en servent et les thèmes Textual.
+
+Les valeurs sont les mêmes que celles de la console web (src/styles/base.css) : les deux interfaces
+partagent la nuit, l'or antique et le feu. Aucune couleur n'est écrite en dur ailleurs que dans ce
+fichier et dans logo.py (les pixels du logo).
+"""
+from __future__ import annotations
+
+from textual.theme import Theme
+
+# ---------------------------------------------------------------- identité
+NOIR = "#0a0908"        # fond
+NOIR_2 = "#12100e"      # panneaux : saisie, validation, accueil
+OR = "#d99a21"
+AMBRE = "#ff9900"
+FEU = "#ff6500"
+BLANC = "#f5f0e8"       # texte
+
+# ---------------------------------------------------------------- surfaces, traits, texte
+PANNEAU = "#181410"     # bloc de code, citation
+TRAIT = "#3a2f23"       # bordure au repos, ascenseur
+SELECTION = "#5a3a10"   # texte sélectionné
+OR_CLAIR = "#f3d27a"    # titre de premier niveau
+TEXTE_2 = "#b8ac9c"
+
+# ---------------------------------------------------------------- rôles (noms utilisés partout dans le code)
+ORANGE = AMBRE          # accent principal : invite, puces, bordure active
+DIM = "#9c9183"         # texte discret : aides, messages de l'utilisateur, détails (contraste 6,4 sur le fond)
+GREEN = "#58b97a"       # réussite
+RED = "#e5484d"         # danger, échec
+YELLOW = "#f2c230"      # avertissement, refus
+
+# Modes de saisie : conservés tels quels. Ils codent un état que tu connais déjà, et chacun est doublé
+# d'un caractère d'invite et d'une ligne d'aide : la couleur n'est jamais le seul repère.
+SHELL_COLOR = "#ff5fd7"   # mode « ! » (comme le mode bash de Claude Code)
+MEMORY_COLOR = "#5fafff"  # mode « # » (note pour la mémoire)
+PLAN_COLOR = "#5fd7d7"    # mode plan (Shift+Tab)
+AGENT_COLOR = "#af87ff"   # agents
+CODE_COLOR = "#5fd787"    # IA de code
+
+DIFF_DEL = "#ffd7d7 on #5f1f1f"
+DIFF_ADD = "#d7ffd7 on #1f4f1f"
+
+# ---------------------------------------------------------------- politique : un signe et un mot, jamais la couleur seule
+# issue rendue par la politique → (signe, libellé, couleur)
+NIVEAUX = {
+    "read": ("●", "lecture", GREEN),
+    "sensitive": ("▲", "sensible", YELLOW),
+    "outside": ("◆", "hors politique", FEU),
+    "refused": ("✕", "refusée", RED),
+}
+
+# ---------------------------------------------------------------- thèmes Textual
+# Les widgets de Textual (Markdown, zone de saisie, notifications, ascenseurs) prennent leurs couleurs
+# dans le thème : sans lui, les titres, les liens et les tableaux des réponses sortaient en bleu.
+_VARIABLES = {
+    "markdown-h1-color": OR_CLAIR, "markdown-h1-background": "transparent", "markdown-h1-text-style": "bold",
+    "markdown-h2-color": OR, "markdown-h2-background": "transparent", "markdown-h2-text-style": "bold",
+    "markdown-h3-color": AMBRE, "markdown-h3-background": "transparent", "markdown-h3-text-style": "bold",
+    "markdown-h4-color": TEXTE_2, "markdown-h4-background": "transparent", "markdown-h4-text-style": "bold",
+    "markdown-h5-color": TEXTE_2, "markdown-h5-background": "transparent", "markdown-h5-text-style": "italic",
+    "markdown-h6-color": DIM, "markdown-h6-background": "transparent", "markdown-h6-text-style": "italic",
+    "link-color": AMBRE, "link-style": "underline", "link-background": "transparent",
+    "link-color-hover": BLANC, "link-background-hover": SELECTION, "link-style-hover": "bold",
+    "text-primary": AMBRE, "text-secondary": OR, "text-accent": FEU,
+    "text-warning": YELLOW, "text-error": RED, "text-success": GREEN,
+    "scrollbar": TRAIT, "scrollbar-hover": AMBRE, "scrollbar-active": AMBRE,
+    "border": AMBRE, "border-blurred": TRAIT,
+    "input-selection-background": SELECTION,
+    "screen-selection-background": SELECTION, "screen-selection-foreground": BLANC,
+    "block-cursor-background": AMBRE, "block-cursor-foreground": NOIR, "block-cursor-text-style": "bold",
+}
+
+THEME = "promethee"
+THEME_TERMINAL = "promethee-terminal"
+# Préférence « fond » → thème
+FONDS = {"promethee": THEME, "terminal": THEME_TERMINAL}
+
+THEMES = (
+    # Le fond de Prométhée : la nuit, peinte par l'application.
+    Theme(name=THEME, dark=True, primary=AMBRE, secondary=OR, accent=FEU, foreground=BLANC, background=NOIR,
+          surface=NOIR_2, panel=PANNEAU, success=GREEN, warning=YELLOW, error=RED,
+          variables={**_VARIABLES, "scrollbar-background": NOIR, "scrollbar-background-hover": NOIR,
+                     "scrollbar-background-active": NOIR, "scrollbar-corner-color": NOIR}),
+    # Le fond de ton terminal (transparence, image de fond) : rien n'est peint derrière le texte.
+    Theme(name=THEME_TERMINAL, dark=True, ansi=True, primary=AMBRE, secondary=OR, accent=FEU, success=GREEN,
+          warning=YELLOW, error=RED, foreground="ansi_default", background="ansi_default", surface="ansi_default",
+          panel="ansi_default", boost="ansi_default",
+          variables={**_VARIABLES, "ansi-background": "ansi_black", "ansi-foreground": "ansi_white",
+                     "scrollbar-background": "ansi_default", "scrollbar-background-hover": "ansi_default",
+                     "scrollbar-background-active": "ansi_default", "scrollbar-corner-color": "ansi_default"}),
+)

package/tui/promethee/widgets.py

@@ -0,0 +1,493 @@
+"""Widgets de la conversation : saisie, réponse, appel d'outil, agent, choix et validation."""
+from __future__ import annotations
+
+from urllib.parse import urlsplit
+
+from rich.style import Style
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.message import Message
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import Markdown, Static, TextArea
+
+from .recherche import js_number, osm_link
+from .theme import AGENT_COLOR, DIM, FEU, GREEN, NIVEAUX, ORANGE, RED, SHELL_COLOR, YELLOW
+
+# --------------------------------------------------------------------------- Widgets
+class PromptInput(TextArea):
+    """Zone de saisie : Entrée envoie, Ctrl+J (ou \\ + Entrée) ajoute une ligne, ↑/↓ = historique."""
+
+    class Submitted(Message):
+        def __init__(self, value: str) -> None:
+            super().__init__()
+            self.value = value
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(
+            soft_wrap=True,
+            show_line_numbers=False,
+            highlight_cursor_line=False,
+            compact=True,
+            tab_behavior="focus",
+            **kwargs,
+        )
+        self.prompt_history: list[str] = []
+        self._hist_idx: int | None = None
+        self._draft = ""
+
+    async def _on_key(self, event) -> None:
+        key = event.key
+        if key == "enter":
+            event.stop()
+            event.prevent_default()
+            app = self.app
+            if getattr(app, "_comp_items", None):
+                # Menu d'autocomplétion ouvert : Entrée choisit (et lance la commande « / » choisie)
+                app.accept_completion(submit=app._comp_kind == "/")
+                return
+            row, col = self.cursor_location
+            line = self.document.get_line(row)
+            if col > 0 and line[:col].endswith("\\"):
+                # "\" + Entrée => nouvelle ligne (comme dans Claude Code)
+                self.replace("\n", (row, col - 1), (row, col))
+                return
+            if self.text.strip():
+                self.post_message(self.Submitted(self.text))
+            return
+        if key in ("ctrl+j", "shift+enter", "alt+enter"):
+            event.stop()
+            event.prevent_default()
+            self.insert("\n")
+            return
+        await super()._on_key(event)
+
+    # Historique des messages avec ↑ / ↓
+    def action_cursor_up(self, select: bool = False) -> None:
+        if not select and getattr(self.app, "_comp_items", None):
+            self.app.move_completion(-1)
+            return
+        if not select and self.cursor_location[0] == 0 and self.prompt_history:
+            if self._hist_idx is None:
+                self._draft = self.text
+                self._hist_idx = len(self.prompt_history)
+            if self._hist_idx > 0:
+                self._hist_idx -= 1
+                self._load(self.prompt_history[self._hist_idx])
+            return
+        super().action_cursor_up(select)
+
+    def action_cursor_down(self, select: bool = False) -> None:
+        if not select and getattr(self.app, "_comp_items", None):
+            self.app.move_completion(1)
+            return
+        last_row = self.document.line_count - 1
+        if not select and self._hist_idx is not None and self.cursor_location[0] == last_row:
+            self._hist_idx += 1
+            if self._hist_idx >= len(self.prompt_history):
+                self._hist_idx = None
+                self._load(self._draft)
+            else:
+                self._load(self.prompt_history[self._hist_idx])
+            return
+        super().action_cursor_down(select)
+
+    def _load(self, text: str) -> None:
+        self.app._comp_dismissed = text  # un « /commande » de l'historique n'ouvre pas le menu
+        self.load_text(text)
+        self.move_cursor(self.document.end)
+
+    def remember(self, text: str) -> None:
+        if not self.prompt_history or self.prompt_history[-1] != text:
+            self.prompt_history.append(text)
+        self._hist_idx = None
+        self._draft = ""
+
+
+class AssistantMessage(Horizontal):
+    def __init__(self, text: str = "") -> None:
+        super().__init__()
+        self._initial = text
+
+    def compose(self) -> ComposeResult:
+        yield Static("⏺", classes="bullet")
+        with Vertical(classes="body"):
+            yield Markdown(self._initial, classes="answer")
+
+    @property
+    def markdown(self) -> Markdown:
+        return self.query_one(".answer", Markdown)
+
+
+class ToolCallView(Vertical):
+    """Affichage d'un outil : « ⏺ PowerShell(commande) » (ou « ! commande », « Modifier(fichier »…) puis « ⎿ sortie »."""
+
+    def __init__(self, command: str, label: str = "PowerShell", waiting: str = "En attente de ta validation…",
+                 initial=None) -> None:
+        super().__init__()
+        self.command = command
+        self.label = label
+        self._waiting = waiting
+        self._initial = initial  # fonction appelée une fois affiché (réaffichage d'une session)
+
+    def compose(self) -> ComposeResult:
+        yield Static(self._head(DIM), classes="tool-head")
+        yield Static(Text.assemble(("⎿  ", DIM), (self._waiting, DIM)), classes="tool-out")
+
+    def on_mount(self) -> None:
+        if self._initial is not None:
+            self._initial(self)
+            self._initial = None
+
+    def _head(self, color: str) -> Text:
+        cmd = self.command if len(self.command) <= 300 else self.command[:300] + "…"
+        if self.label == "!":
+            return Text.assemble(("! ", f"bold {SHELL_COLOR}"), (cmd, "bold"))
+        return Text.assemble(("⏺ ", color), (self.label, "bold"), ("(", DIM), (cmd, ""), (")", DIM))
+
+    def _out(self, text: Text) -> None:
+        self.query_one(".tool-head", Static).update(self._head(self._color))
+        self.query_one(".tool-out", Static).update(text)
+
+    def set_running(self, auto: bool = False) -> None:
+        self._color = ORANGE
+        note = "Exécution…" + ("  (autorisée pour la session)" if auto else "")
+        self._out(Text.assemble(("⎿  ", DIM), (note, DIM)))
+
+    def set_denied(self) -> None:
+        self._color = DIM
+        self._out(Text.assemble(("⎿  ", DIM), ("Refusée", YELLOW)))
+
+    def set_skipped(self, reason: str) -> None:
+        self._color = DIM
+        self._out(Text.assemble(("⎿  ", DIM), (reason, YELLOW)))
+
+    def set_refused(self, reason: str, advice: list[str] | None = None) -> None:
+        """Refus de la politique : la commande ne t'a pas été proposée et rien n'a été exécuté."""
+        self._color = RED
+        text = Text.assemble(("⎿  ", DIM), ("✕ Refusée par la politique", f"bold {RED}"))
+        if reason:
+            text.append(f" : {reason}")
+        if advice:
+            text.append("\n   Pour la permettre : " + " · ".join(advice), style=DIM)
+        self._out(text)
+
+    def set_text(self, summary: str, detail: Text | None = None, color: str = GREEN) -> None:
+        """Résultat d'un outil fichier : une ligne de résumé, puis éventuellement le diff."""
+        self._color = color
+        text = Text.assemble(("⎿  ", DIM), (summary, ""))
+        if detail is not None and detail.plain.strip():
+            text.append("\n")
+            text.append_text(detail)
+        self._out(text)
+
+    def set_result(self, code: int | None, output: str, note: str = "") -> None:
+        self._color = GREEN if code == 0 else RED
+        lines = output.strip("\n").split("\n") if output.strip() else []
+        shown = lines[:12]
+        text = Text()
+        if not shown:
+            text.append("⎿  ", style=DIM)
+            text.append("(aucune sortie)", style=DIM)
+        for i, line in enumerate(shown):
+            text.append("⎿  " if i == 0 else "   ", style=DIM)
+            text.append(line[:400] + ("\n" if i < len(shown) - 1 else ""))
+        if len(lines) > len(shown):
+            text.append(f"\n   … +{len(lines) - len(shown)} lignes (/sortie pour tout voir)", style=f"italic {DIM}")
+        extra = []
+        if note:
+            extra.append(note)
+        if code not in (0, None):
+            extra.append(f"code de sortie {code}")
+        if extra:
+            text.append("\n   " + " · ".join(extra), style=RED if code else YELLOW)
+        self._out(text)
+
+    _color = DIM
+
+
+def _domaine(url: str) -> str:
+    try:
+        host = urlsplit(url).hostname or ""
+    except ValueError:
+        return ""
+    return host[4:] if host.startswith("www.") else host
+
+
+def _lien(url: str) -> Style:
+    """Adresse cliquable dans les terminaux qui le permettent (lien OSC 8, comme Windows Terminal)."""
+    return Style(link=url, underline=True)
+
+
+def search_lines(search: dict) -> Text:
+    """Ce que montre une recherche web terminée : sources numérotées (titre, domaine, adresse complète) puis, pour un
+    lieu, son nom, son adresse, ses coordonnées et le lien OpenStreetMap. Pas de carte dans un terminal."""
+    text = Text()
+
+    def line() -> None:
+        text.append("\n   " if text.plain else "⎿  ", style=DIM)
+
+    if search.get("state") == "failed":
+        line()
+        text.append(search.get("error") or "La recherche a échoué.", style=RED)
+    else:
+        sources = search.get("sources") or []
+        if not sources:
+            line()
+            text.append("Aucun résultat", style=YELLOW)
+        for s in sources:
+            line()
+            text.append(f"[{s['n']}] ", style=f"bold {ORANGE}")
+            text.append(s["title"], style="bold")
+            domain = _domaine(s["url"])
+            if domain:
+                text.append(f" · {domain}", style=DIM)
+            text.append("\n       ")
+            text.append(s["url"], style=_lien(s["url"]))
+    place = search.get("place")
+    if place:
+        lat, lon = js_number(place["lat"]), js_number(place["lon"])
+        link = osm_link(place["lat"], place["lon"])
+        line()
+        text.append("Lieu : ", style=f"bold {ORANGE}")
+        text.append(place["name"], style="bold")
+        if place.get("address"):
+            text.append(f"\n       {place['address']}")
+        text.append(f"\n       coordonnées : {lat}, {lon}", style=DIM)
+        text.append("\n       ")
+        text.append(link, style=_lien(link))
+    elif search.get("placeQuery") and search.get("state") != "failed":
+        line()
+        text.append(f"Lieu « {search['placeQuery']} » introuvable sur la carte.", style=YELLOW)
+    return text
+
+
+class SearchView(Vertical):
+    """Recherche web : « ⏺ Recherche web : « requête » » pendant la recherche, puis ses sources et son lieu."""
+
+    def __init__(self, requete: str, search: dict | None = None, replay: bool = False) -> None:
+        super().__init__()
+        self.requete = requete
+        self._search = search
+        self._replay = replay   # réaffichage d'une session : la recherche est finie, même sans détail enregistré
+
+    def compose(self) -> ComposeResult:
+        yield Static(self._head(ORANGE), classes="tool-head")
+        yield Static(Text.assemble(("⎿  ", DIM), ("Recherche en cours…", DIM)), classes="tool-out")
+
+    def on_mount(self) -> None:
+        if self._search is not None:
+            self.set_result(self._search)
+        elif self._replay:
+            self._out(DIM, Text.assemble(("⎿  ", DIM), ("Résultats non enregistrés", DIM)))
+
+    def _head(self, color: str) -> Text:
+        return Text.assemble(("⏺ ", color), ("Recherche web : ", "bold"), (f"« {self.requete} »", ""))
+
+    def _out(self, color: str, text: Text) -> None:
+        self.query_one(".tool-head", Static).update(self._head(color))
+        self.query_one(".tool-out", Static).update(text)
+
+    def set_result(self, search: dict) -> None:
+        self._search = search
+        self._out(RED if search.get("state") == "failed" else GREEN, search_lines(search))
+
+
+def short_count(n: int) -> str:
+    return f"{n / 1000:.1f} k".replace(".", ",") if n >= 1000 else str(n)
+
+
+class AgentView(Vertical):
+    """Travail d'un agent : « ⏺ Agent nom(tâche) », ses outils en retrait, puis « ⎿ Terminé (… outils · … s) »."""
+
+    def __init__(self, name: str, task: str, initial=None) -> None:
+        super().__init__()
+        self.agent_name = name
+        self.agent_task = task
+        self._initial = initial
+        self.done = False
+        self.uses = 0
+
+    def compose(self) -> ComposeResult:
+        yield Static(self._head(AGENT_COLOR), classes="agent-head")
+        yield Vertical(classes="agent-body")
+        yield Static(Text.assemble(("⎿  ", DIM), ("Démarrage…", DIM)), classes="agent-foot")
+
+    def on_mount(self) -> None:
+        if self._initial is not None:
+            self._initial(self)
+            self._initial = None
+
+    def _head(self, color: str) -> Text:
+        task = " ".join(self.agent_task.split())
+        task = task if len(task) <= 90 else task[:90] + "…"
+        return Text.assemble(("⏺ ", color), ("Agent ", "bold"), (self.agent_name, f"bold {AGENT_COLOR}"),
+                             ("(", DIM), (task, ""), (")", DIM))
+
+    @property
+    def body(self) -> Vertical:
+        return self.query_one(".agent-body", Vertical)
+
+    def _foot(self, text: Text) -> None:
+        self.query_one(".agent-foot", Static).update(text)
+
+    def set_progress(self, uses: int) -> None:
+        self.uses = uses
+        self._foot(Text.assemble(("⎿  ", DIM), (f"Au travail… {uses} outil{'s' if uses > 1 else ''} utilisé"
+                                                 f"{'s' if uses > 1 else ''}", DIM)))
+
+    def set_done(self, uses: int, tokens: int, seconds: float, note: str = "", color: str = GREEN,
+                 expanded: bool = False) -> None:
+        self.done, self.uses = True, uses
+        self._result = (tokens, seconds, note, color)
+        self.query_one(".agent-head", Static).update(self._head(color))
+        self.set_expanded(expanded)
+
+    def set_expanded(self, expanded: bool) -> None:
+        if not self.done:
+            return  # pendant le travail, le détail reste visible
+        tokens, seconds, note, color = self._result
+        stats = [f"{self.uses} outil{'s' if self.uses > 1 else ''}"] if self.uses >= 0 else []
+        if tokens:
+            stats.append(f"{short_count(tokens)} tokens")
+        if seconds:
+            stats.append(f"{seconds:.0f} s")
+        text = Text.assemble(("⎿  ", DIM), (note or "Terminé", color if note else ""),
+                             (f" ({' · '.join(stats)})" if stats else "", DIM))
+        if self.body.children:
+            text.append("  · Ctrl+O : " + ("replier" if expanded else "voir le détail"), style=f"italic {DIM}")
+        self._foot(text)
+        self.body.display = expanded
+
+
+class ChoicePrompt(Widget, can_focus=True):
+    """Choix au clavier sous la conversation (validation d'une commande, d'un fichier, d'une session…)."""
+
+    BINDINGS = [
+        Binding("up", "move(-1)", show=False),
+        Binding("down", "move(1)", show=False),
+        Binding("enter", "choose", show=False),
+        *[Binding(str(i), f"pick({i - 1})", show=False) for i in range(1, 10)],
+    ]
+    selected = reactive(0)
+    hint = "↑↓ choisir · Entrée valider (ou tape le numéro) · Esc refuser"
+
+    def __init__(self, title: str, body: Text | None, question: str, options: list[tuple[str, str]], callback,
+                 danger: bool = False, command: str = "") -> None:
+        super().__init__()
+        self.title = title
+        self.body = body
+        self.question = question
+        self.options = options
+        self.callback = callback
+        self.danger = danger
+        self.command = command
+        self._done = False
+        if danger:
+            self.add_class("-danger")
+
+    def render(self) -> Text:
+        t = Text()
+        t.append(f"{self.title}\n", style=f"bold {RED if self.danger else ORANGE}")
+        if self.body is not None and self.body.plain.strip():
+            t.append("\n")
+            t.append_text(self.body)
+            t.append("\n")
+        if self.question:
+            t.append(f"\n{self.question}\n", style="bold")
+        for i, (_, label) in enumerate(self.options):
+            if i == self.selected:
+                t.append(f"❯ {i + 1}. {label}", style=f"bold {ORANGE}")
+            else:
+                t.append(f"  {i + 1}. {label}", style=DIM)
+            if i < len(self.options) - 1:
+                t.append("\n")
+        return t
+
+    def action_move(self, delta: int) -> None:
+        self.selected = (self.selected + delta) % len(self.options)
+
+    def action_pick(self, index: int) -> None:
+        if index < len(self.options):
+            self.selected = index
+            self.action_choose()
+
+    def action_choose(self) -> None:
+        self.resolve(self.options[self.selected][0])
+
+    def resolve(self, decision: str) -> None:
+        if not self._done:
+            self._done = True
+            self.callback(decision)
+
+
+def verdict_lines(verdict) -> Text:
+    """Ce que la politique dit d'une commande : son niveau (un signe et un mot), ce qu'elle écrit, qui elle contacte,
+    et ce qu'il faut lire avant de valider."""
+    sign, label, color = NIVEAUX[verdict.issue]
+    text = Text()
+    text.append(f"  {sign} {label}", style=f"bold {color}")
+    text.append(f" · politique {verdict.mode}\n", style=DIM)
+    for path in verdict.ecritures[:4]:
+        text.append(f"    écrit : {path}\n", style=DIM)
+    if len(verdict.ecritures) > 4:
+        text.append(f"    … et {len(verdict.ecritures) - 4} autres fichiers\n", style=DIM)
+    if verdict.reseau:
+        text.append(f"    contacte : {', '.join(verdict.reseau[:6])}\n", style=DIM)
+    for reason in verdict.a_lire()[:5]:
+        text.append(f"    {reason.message}\n", style=YELLOW if reason.gravite == "warn" else FEU)
+    if verdict.issue == "outside":
+        text.append("    L'analyse ne sait pas vérifier cette commande : toi seul la contrôles.\n", style=f"bold {FEU}")
+    return text
+
+
+class PermissionPrompt(ChoicePrompt):
+    """Demande de validation d'une commande (comme le mode par défaut de Claude Code).
+
+    verdict : le verdict de la politique, ou None si elle n'est pas disponible (validation manuelle).
+    scope : ce que couvre « ne plus demander » : "noms" (les commandes citées) ou "ligne" (cette commande exacte).
+    """
+
+    def __init__(self, command: str, explanation: str, dangerous: bool, prefixes: list[str], callback,
+                 verdict=None, scope: str = "noms", title: str = "Exécuter une commande",
+                 question: str = "Veux-tu exécuter cette commande ?", refusal: str = "Non, et dire à Prométhée quoi faire autrement (Esc)") -> None:
+        body = Text()
+        for line in command.split("\n"):
+            body.append(f"  {line}\n", style="bold")
+        if explanation:
+            body.append(f"  {explanation}\n", style=DIM)
+        if verdict is not None:
+            body.append("\n")
+            body.append_text(verdict_lines(verdict))
+        if dangerous:
+            body.append("\n  ⚠ Cette commande peut modifier ou supprimer des choses sur ta machine : lis-la bien.\n",
+                        style=f"bold {RED}")
+        body.rstrip()
+        options: list[tuple[str, str]] = [("yes", "Oui")]
+        if not dangerous and prefixes and (verdict is None or verdict.lecture):
+            names = ", ".join(f"« {p} »" for p in prefixes) if scope == "noms" else "cette commande exacte"
+            options.append(("always", f"Oui, et ne plus demander pour {names} pendant cette session"))
+        options.append(("no", refusal))
+        super().__init__(title, body, question, options, callback,
+                         danger=dangerous or (verdict is not None and verdict.issue == "outside"), command=command)
+        self.verdict = verdict
+
+
+class ToolState:
+    """Suivi des outils pendant une réponse (ou pendant le travail d'un agent)."""
+
+    def __init__(self) -> None:
+        self.failed: set[str] = set()     # commandes déjà en échec
+        self.last_ok: str | None = None   # dernière commande réussie (relancée telle quelle juste après = inutile)
+        self.ran: list[str] = []          # commandes / fichiers + leurs sorties (pour contrôler la réponse finale)
+        self.uses = 0                     # nombre d'outils appelés
+        self.unverified: str | None = None  # code modifié sans commande lancée depuis (pas recompilé, pas testé)
+        self.last_fail: tuple[str, int] | None = None  # dernière commande lancée, si elle a échoué
+        self.compiled_only = False        # le code compile mais le programme n'a pas encore été lancé
+        self.refused = 0                  # commandes refusées par la politique pendant cette réponse
+
+
+# clés des messages propres à l'interface, retirées avant l'envoi au modèle (search : sources et lieu, pour l'écran)
+LOCAL_KEYS = ("display", "direct", "intent", "mode", "search")

package/tui/requirements.txt

@@ -0,0 +1 @@
+textual>=8,<9