@nosserb/prmt 0.0.0-stage → 2.0.0

package/tui/promethee/app/plateforme.py

@@ -0,0 +1,409 @@
+"""Politique d'exécution, périmètre, journal, recherche web, état de la plateforme et fond de l'interface."""
+from __future__ import annotations
+
+import datetime as dt
+import re
+import time
+from pathlib import Path
+
+from rich.text import Text
+from textual import work
+from textual.widgets import Static
+
+from .. import journal, preferences, recherche
+from ..etat import SIGNES, collecter, pluriel, rendre
+from ..politique import MODES, Indisponible, Refus
+from ..theme import DIM, FONDS, GREEN, RED, YELLOW
+
+ISSUES = {"ok": ("ok", "réussie"), "error": ("probleme", "en échec"), "refused": ("probleme", "refusée"),
+          "cancelled": ("inactif", "annulée"), "info": ("info", "")}
+HOTE = re.compile(r"^[A-Za-z0-9]([A-Za-z0-9.-]{0,251}[A-Za-z0-9])?$|^[0-9a-fA-F:]{2,39}$")
+
+
+class Plateforme:
+    """Partie de PrometheeApp : politique d'exécution, périmètre, journal, recherche web, état de la plateforme et fond de
+    l'interface."""
+
+    # ------------------------------------------------------------------ politique (fils de travail)
+    @work(thread=True, exclusive=True, group="politique")
+    def demarrer_politique(self) -> None:
+        """Lance le moteur de politique dès l'ouverture : le premier verdict n'attend pas son démarrage."""
+        ready = self.politique.demarrer()
+        self.call_from_thread(self._politique_demarree, ready)
+
+    def _politique_demarree(self, ready: bool) -> None:
+        self.update_status()
+        if not ready and self.politique.reliee:
+            self._policy_warned = True
+            self.add_notice(f"Politique indisponible ({self.politique.raison}) : tu valides chaque commande toi-même, "
+                            "sans liste blanche. /etat pour le détail.", YELLOW)
+
+    def _verdict(self, command: str):
+        """Verdict de la politique pour une commande, ou None (validation manuelle). Appelé depuis un fil de travail."""
+        before = self.politique.etat
+        verdict = self.politique.verdict(command, self.cwd)
+        if verdict is None and self.politique.reliee and not self._policy_warned:
+            self._policy_warned = True
+            self.call_from_thread(self.add_notice, f"Politique indisponible ({self.politique.raison}) : tu valides chaque "
+                                  "commande toi-même, sans liste blanche.", YELLOW)
+        elif verdict is not None:
+            self._policy_warned = False
+        if self.politique.etat != before:
+            self.call_from_thread(self.update_status)
+        return verdict
+
+    # ------------------------------------------------------------------ journal
+    def noter_commande(self, command: str, code: int | None, output: str, note: str, started: float, cwd: Path,
+                       verdict, confirmation: str, source: str) -> None:
+        """Une ligne de journal par commande : exécutée, en échec, arrêtée, ou refusée par toi."""
+        duration = round((time.monotonic() - started) * 1000)
+        if confirmation == "refus" or note.startswith("arrêtée par toi"):
+            outcome, detail = "cancelled", (note[:1].upper() + note[1:] + ".") if note else "Annulée."
+        elif note:
+            outcome, detail = "error", note[:1].upper() + note[1:] + "."
+        else:
+            outcome, detail = ("ok" if code == 0 else "error"), f"Code de sortie {code} en {duration} ms."
+        journal.noter("command", outcome, command, detail, command=command, cwd=str(cwd),
+                      level=verdict.issue if verdict is not None else None,
+                      policy=self.politique.mode if verdict is not None else "manuelle",
+                      confirmation=confirmation, source=source, agent=self._agent_name or None, session=self.session_id,
+                      constrained=True if verdict is not None and verdict.mode_contraint and confirmation != "refus" else None,
+                      exitCode=code, durationMs=duration if confirmation != "refus" else None,
+                      timedOut=True if "délai dépassé" in note else None,
+                      tail=output[-journal.QUEUE_SORTIE:] if output else None)
+
+    def noter_refus(self, command: str, verdict, source: str) -> None:
+        journal.noter("refusal", "refused", command, "\n".join(r.message for r in verdict.blocages), command=command,
+                      cwd=str(self.cwd), codes=[r.code for r in verdict.blocages], policy=verdict.mode, source=source,
+                      agent=self._agent_name or None, session=self.session_id)
+
+    def noter_fichier(self, tool: str, path: Path, outcome: str, detail: str, **data) -> None:
+        journal.noter("command", outcome, f"{tool} {path}", detail, tool=tool, path=str(path), source="modèle",
+                      agent=self._agent_name or None, session=self.session_id, **data)
+
+    def noter_recherche(self, plan: dict, search: dict) -> None:
+        """Une ligne de journal par recherche web, au format de la console : la console la lit aussi."""
+        place = search.get("place")
+        if search["state"] == "done":
+            n = len(search["sources"])
+            detail = f"{n} source{'s' if n > 1 else ''}" + (f", lieu : {place['name']}" if place else "")
+        else:
+            detail = search.get("error") or ""
+        outcome = "ok" if search["state"] == "done" else "cancelled" if self.cancel_event.is_set() else "error"
+        journal.noter("search", outcome, f"Recherche web : {recherche.cut(plan['query'], 100)}", detail,
+                      donnees={"query": plan["query"], "place": place["name"] if place else plan.get("place"),
+                               "sources": [s["url"] for s in search["sources"]]},
+                      session=self.session_id)
+
+    # ------------------------------------------------------------------ recherche web
+    def reglage_recherche(self) -> dict:
+        """{enabled, url} : dans les réglages de la console si la TUI y est reliée, sinon dans ses préférences."""
+        return recherche.lire_reglage(self.politique.lien)
+
+    def client_recherche(self, reglage: dict | None = None) -> recherche.Searxng:
+        lien = self.politique.lien or {}
+        return recherche.Searxng((reglage or self.reglage_recherche())["url"], str(lien.get("racine") or "") or None)
+
+    @work(thread=True, group="plateforme")
+    def cmd_recherche(self, arg: str = "") -> None:
+        word = arg.strip().lower()
+        lien = self.politique.lien
+        fichier = recherche.fichier_partage(lien)
+        where = f"réglage partagé avec la console : {fichier}" if fichier else "réglage gardé dans les préférences de la TUI"
+        if word in ("on", "oui", "activer", "active"):
+            enabled = True
+        elif word in ("off", "non", "couper", "coupe", "desactiver", "désactiver"):
+            enabled = False
+        elif word:
+            self.call_from_thread(self.add_notice, "Usage : /recherche · /recherche on · /recherche off", YELLOW)
+            return
+        else:
+            reglage = self.reglage_recherche()
+            self.call_from_thread(self._montrer_recherche, reglage, self.client_recherche(reglage).health(), where)
+            return
+        try:
+            reglage = recherche.ecrire_reglage(lien, enabled=enabled)
+        except (OSError, ValueError, recherche.ErreurRecherche) as err:
+            self.call_from_thread(self.add_notice, f"Recherche web inchangée : {err}", RED)
+            return
+        journal.noter("settings", "info", f"Recherche web {'activée' if enabled else 'coupée'}", session=self.session_id,
+                      search=reglage)
+        if not enabled:
+            self.call_from_thread(self.add_notice, f"Recherche web coupée : aucune requête ne part sur internet ({where}). "
+                                  "/recherche on pour la rétablir.")
+            return
+        self.call_from_thread(self.add_notice, "Recherche web activée : quand une question le demande, Prométhée cherche "
+                              f"sur internet par SearXNG et te montre la requête et les sources ({where}).", GREEN)
+        sante = self.client_recherche(reglage).health()
+        if not sante["available"]:
+            self.call_from_thread(self.add_notice, f"Attention : {sante['error']}", YELLOW)
+
+    def _montrer_recherche(self, reglage: dict, sante: dict, where: str) -> None:
+        """/recherche seul : active ou non, l'adresse de SearXNG, et s'il répond."""
+        text = Text()
+        text.append("Recherche web : ", style="bold")
+        text.append("active" if reglage["enabled"] else "coupée", style=GREEN if reglage["enabled"] else YELLOW)
+        text.append(f" · {where}", style=DIM)
+        if sante["available"]:
+            text.append(f"\n  ● SearXNG {reglage['url']} répond en {sante['latencyMs']} ms", style=GREEN)
+        else:
+            text.append(f"\n  ✕ SearXNG {reglage['url']} ne répond pas : {sante['error']}", style=RED)
+        text.append("\n  Quand une question demande une information récente ou un lieu, Prométhée cherche de lui-même, te "
+                    "montre la requête et les sources, puis répond sans proposer de commande.", style=DIM)
+        text.append("\n  /recherche on · /recherche off", style=f"italic {DIM}")
+        self.chat.mount(Static(text, classes="notice"))
+        self.call_after_refresh(self._follow)
+
+    # ------------------------------------------------------------------ /politique
+    @work(thread=True, group="plateforme")
+    def cmd_politique(self, arg: str = "") -> None:
+        politique = self.politique
+        word = arg.strip().lower()
+        if word in MODES:
+            if word != politique.mode:
+                politique.mode = word
+                try:
+                    preferences.ecrire(politique=word)
+                except OSError:
+                    pass
+                journal.noter("settings", "info", f"Politique de la TUI : {word}", session=self.session_id, policy=word)
+            self.call_from_thread(self.update_status)
+            self.call_from_thread(self.add_notice, (
+                "Politique stricte : tout refus de la liste blanche est appliqué, comme dans la console."
+                if word == "stricte" else
+                "Politique souple : ce que l'analyse ne sait pas vérifier (scripts, compilateurs, programmes lancés par "
+                "leur chemin) t'est montré comme « hors politique » et tu le valides. Restent refusés : commande "
+                "destructrice non débloquée, cible hors périmètre, protections de Windows, chemin réseau."),
+                GREEN if word == "stricte" else YELLOW)
+            return
+        if word in ("relancer", "restart"):
+            politique.fermer()
+            politique._retenter_a = 0.0
+            ready = politique.demarrer()
+            self.call_from_thread(self.update_status)
+            self.call_from_thread(self.add_notice, "Moteur de politique relancé." if ready
+                                  else f"Le moteur de politique ne démarre pas : {politique.raison}", GREEN if ready else RED)
+            return
+        if word:
+            self.call_from_thread(self.add_notice, "Usage : /politique · /politique stricte · /politique souple · "
+                                  "/politique relancer", YELLOW)
+            return
+        resume = politique.resume()
+        self.call_from_thread(self.update_status)
+        if resume is None:
+            self.call_from_thread(self.add_notice_md, (
+                f"**Politique : validation manuelle**\n\nLe moteur de la console n'est pas disponible "
+                f"({politique.raison or 'raison inconnue'}). Chaque commande t'est montrée et tu la valides, sans liste "
+                "blanche ni contrôle du périmètre.\n\n*`/politique relancer` pour réessayer · `/etat` pour le détail*"))
+            return
+        counts = resume.get("counts") or {}
+        custom = ", ".join(f"`{c.get('name')}`" for c in resume.get("custom") or []) or "aucune"
+        unlocked = ", ".join(f"`{u}`" for u in resume.get("unlocked") or []) or "aucune"
+        self.call_from_thread(self.add_notice_md, (
+            f"**Politique {politique.mode}** (moteur de la console {politique.version})\n\n"
+            f"- Liste blanche : {counts.get('read', 0)} commandes de lecture, {counts.get('sensitive', 0)} sensibles, "
+            f"{counts.get('destructive', 0)} destructrices, {counts.get('forbidden', 0)} interdites.\n"
+            f"- Débloquées par toi : {unlocked} · ajoutées par toi : {custom}\n"
+            f"- Écriture permise dans : {', '.join(f'`{r}`' for r in resume.get('roots') or [])}\n"
+            f"- Cibles réseau déclarées : {len(resume.get('targets') or [])} (`/perimetre`)\n\n"
+            "`stricte` : tout refus de la liste blanche est appliqué. `souple` : le hors-liste passe à ta validation ; "
+            "commande destructrice non débloquée, cible hors périmètre, protections de Windows et chemin réseau restent "
+            "refusés.\n\n"
+            "*`/politique stricte` · `/politique souple` · `/permissions autoriser <commande>` · `/perimetre ajouter <hôte>`*"))
+
+    # ------------------------------------------------------------------ /permissions
+    @work(thread=True, group="plateforme")
+    def cmd_permissions(self, arg: str = "") -> None:
+        action, _, rest = arg.partition(" ")
+        action, names = action.lower(), rest.split()
+        if action in ("reset", "effacer", "clear"):
+            self.allowed.clear()
+            self.allowed_lines.clear()
+            self.allow_edits = False
+            self.call_from_thread(self.add_notice, "Toutes les commandes et toutes les écritures de fichiers demanderont "
+                                  "de nouveau ta validation.", GREEN)
+            return
+        if action in ("autoriser", "allow", "ajouter", "debloquer", "débloquer") and names:
+            self._changer_liste(names, True)
+            return
+        if action in ("retirer", "revoke", "verrouiller", "enlever") and names:
+            self._changer_liste(names, False)
+            return
+        if action:
+            self.call_from_thread(self.add_notice, "Usage : /permissions · /permissions reset · /permissions autoriser "
+                                  "<commande…> · /permissions retirer <commande…>", YELLOW)
+            return
+        session = sorted(self.allowed) + [f"« {line} »" for line in sorted(self.allowed_lines)]
+        if session:
+            self.call_from_thread(self.add_notice, "Autorisées sans validation (session) : " + ", ".join(session)
+                                  + "   ·  /permissions reset pour tout redemander")
+        else:
+            self.call_from_thread(self.add_notice, "Aucune commande autorisée automatiquement : chaque commande demande "
+                                  "ta validation.")
+        if self.allow_edits:
+            self.call_from_thread(self.add_notice, "Écritures de fichiers autorisées pour la session (sauf fichiers sensibles "
+                                  "ou hors de ton dossier)   ·  /permissions reset pour tout redemander")
+        resume = self.politique.resume()
+        if resume is not None:
+            custom = [str(c.get("name")) for c in resume.get("custom") or []]
+            unlocked = [str(u) for u in resume.get("unlocked") or []]
+            self.call_from_thread(self.add_notice, "Liste blanche (partagée avec la console) : débloquées "
+                                  + (", ".join(unlocked) or "aucune") + " · ajoutées " + (", ".join(custom) or "aucune")
+                                  + "   ·  /permissions autoriser <commande> · /permissions retirer <commande>")
+
+    def _changer_liste(self, names: list[str], allow: bool) -> None:
+        try:
+            result = self.politique.autoriser(names) if allow else self.politique.retirer(names)
+        except (Indisponible, Refus) as err:
+            self.call_from_thread(self.add_notice, f"Liste blanche inchangée : {err}", RED)
+            return
+        if not allow:
+            removed = result.get("removed") or []
+            self.call_from_thread(self.add_notice, ("Autorisation retirée : " + ", ".join(removed) + ".") if removed
+                                  else "Aucune de ces commandes n'était autorisée par toi.", GREEN if removed else YELLOW)
+            return
+        if result.get("unlocked"):
+            self.call_from_thread(self.add_notice, "Débloquée : " + ", ".join(result["unlocked"]) + ". Chaque exécution "
+                                  "te sera montrée et signalée en rouge. /permissions retirer pour la reverrouiller.", YELLOW)
+        if result.get("added"):
+            self.call_from_thread(self.add_notice, "Ajoutée à ta liste blanche : " + ", ".join(result["added"])
+                                  + ". Ses arguments ne sont pas contrôlés : chaque exécution te sera montrée.", YELLOW)
+        if result.get("already"):
+            self.call_from_thread(self.add_notice, "Déjà autorisée : " + ", ".join(result["already"]) + ".")
+        for refused in result.get("refused") or []:
+            self.call_from_thread(self.add_notice, f"Non autorisée : {refused.get('name')} ({refused.get('reason')}).", RED)
+
+    # ------------------------------------------------------------------ /perimetre
+    def cmd_perimetre(self, arg: str = "") -> None:
+        action, _, rest = arg.partition(" ")
+        action, rest = action.lower(), rest.strip()
+        if action in ("ajouter", "add", "declarer", "déclarer") and rest:
+            host, _, note = rest.partition(" ")
+            self._demander_attestation(host.strip().lower(), note.strip())
+        elif action in ("retirer", "remove", "enlever", "supprimer") and rest:
+            self._retirer_cible(rest.split()[0].lower())
+        elif action:
+            self.add_notice("Usage : /perimetre · /perimetre ajouter <hôte> [note] · /perimetre retirer <hôte>", YELLOW)
+        else:
+            self._montrer_perimetre()
+
+    @work(thread=True, group="plateforme")
+    def _montrer_perimetre(self) -> None:
+        resume = self.politique.resume()
+        if resume is None:
+            self.call_from_thread(self.add_notice, "Périmètre non contrôlé : la politique n'est pas disponible "
+                                  f"({self.politique.raison or 'raison inconnue'}).", YELLOW)
+            return
+        targets = resume.get("targets") or []
+        lines = "\n".join(f"- `{t.get('host')}`" + (" (sous-domaines compris)" if t.get("includeSubdomains") else "")
+                          + (f" · {t.get('note')}" if t.get("note") else "") + f" · attestée le {str(t.get('attestedAt') or '')[:10]}"
+                          for t in targets)
+        self.call_from_thread(self.add_notice_md, (
+            "**Périmètre autorisé**\n\n"
+            "Les tests de ports et les audits ne sont permis que sur cette machine et sur les cibles que tu as déclarées, "
+            "parce qu'elles t'appartiennent ou que tu as une autorisation écrite.\n\n"
+            + (lines if lines else "Aucune cible déclarée : seuls les tests sur cette machine (127.0.0.1) sont permis.")
+            + "\n\n*`/perimetre ajouter <hôte> [note]` · `/perimetre retirer <hôte>` · la console web montre la même liste*"))
+
+    def _demander_attestation(self, host: str, note: str) -> None:
+        if not HOTE.match(host) or "/" in host:
+            self.add_notice(f"« {host} » n'est pas un hôte unique (nom ou adresse IP, sans plage ni masque).", RED)
+            return
+        domain = not re.fullmatch(r"[0-9.]+|[0-9a-fA-F:]+", host)
+        body = Text.assemble((f"  {host}\n", "bold"), (f"  {note}\n" if note else "", DIM),
+                             ("\n  Les tests ne sont permis que sur des systèmes qui t'appartiennent ou pour lesquels tu as une\n"
+                              "  autorisation écrite. Cette attestation est datée et inscrite au journal.", DIM))
+        options = [("yes", "J'atteste que cette cible m'appartient ou que j'ai une autorisation écrite")]
+        if domain:
+            options.append(("sub", "J'atteste la même chose pour ce domaine et ses sous-domaines"))
+        options.append(("no", "Annuler (Esc)"))
+
+        def chosen(decision: str) -> None:
+            if decision in ("yes", "sub"):
+                self._ajouter_cible(host, note, decision == "sub")
+
+        self.ask("Déclarer une cible", body, "Ajouter cette cible à ton périmètre ?", options, chosen)
+
+    @work(thread=True, group="plateforme")
+    def _ajouter_cible(self, host: str, note: str, subdomains: bool) -> None:
+        try:
+            self.politique.ajouter_cible(host, note, subdomains)
+        except (Indisponible, Refus) as err:
+            self.call_from_thread(self.add_notice, f"Cible non ajoutée : {err}", RED)
+            return
+        self.call_from_thread(self.add_notice, f"Cible ajoutée au périmètre : {host}"
+                              + (" et ses sous-domaines" if subdomains else "") + ". /perimetre retirer pour l'enlever.", GREEN)
+
+    @work(thread=True, group="plateforme")
+    def _retirer_cible(self, host: str) -> None:
+        try:
+            self.politique.retirer_cible(host)
+        except (Indisponible, Refus) as err:
+            self.call_from_thread(self.add_notice, f"Périmètre inchangé : {err}", RED)
+            return
+        self.call_from_thread(self.add_notice, f"Cible retirée du périmètre : {host}.", GREEN)
+
+    # ------------------------------------------------------------------ /journal
+    def cmd_journal(self, arg: str = "") -> None:
+        fichiers = [journal.FICHIER]
+        if self.politique.lien is not None:
+            fichiers.append(Path(str(self.politique.lien["donnees"])) / "journal.jsonl")
+        entries = journal.lire(fichiers)
+        word = arg.strip().lower()
+        if word in ("refus", "refusees", "refusées"):
+            entries = [e for e in entries if e["kind"] == "refusal"]
+        count = int(word) if word.isdigit() else 15
+        shown = entries[-max(1, min(count, 60)):]
+        if not shown:
+            self.add_notice("Journal vide : il se remplit dès la première commande." if not word.startswith("refus")
+                            else "Aucun refus dans le journal.")
+            return
+        text = Text()
+        text.append(f"Journal · {pluriel(len(shown), 'dernière entrée', 'dernières entrées')} sur {len(entries)}", style=f"bold {DIM}")
+        for entry in shown:
+            when = journal._moment(entry)
+            state, label = ISSUES[entry["outcome"]]
+            sign, color = SIGNES[state]
+            origin = "TUI" if (entry.get("data") or {}).get("origin") == "tui" else "console"
+            stamp = f"{when:%d/%m %H:%M}" if when and when.date() != dt.date.today() else f"{when:%H:%M}" if when else "?"
+            text.append(f"\n  {stamp:<11}", style=DIM)
+            text.append(f"{sign} ", style=color)
+            text.append(f"{label:<9}" if label else " " * 9, style=color)
+            text.append(entry["title"][:90])
+            text.append(f"  ({origin})", style=DIM)
+        text.append(f"\n  fichier : {journal.FICHIER}   ·   /journal 40 · /journal refus", style=f"italic {DIM}")
+        self.chat.mount(Static(text, classes="notice"))
+        self.call_after_refresh(self._follow)
+
+    # ------------------------------------------------------------------ /etat
+    @work(thread=True, exclusive=True, group="etat")
+    def cmd_etat(self, arg: str = "") -> None:
+        self.call_from_thread(self.set_hints, "Mesure de l'état de la plateforme…")
+        sections = collecter(self)
+        self.call_from_thread(self._montrer_etat, sections)
+
+    def _montrer_etat(self, sections) -> None:
+        panel = Static(rendre(sections), classes="etat")
+        panel.border_title = "État de la plateforme"
+        panel.border_subtitle = f"mesuré à {dt.datetime.now():%H:%M:%S}"
+        self.chat.mount(panel)
+        self.set_hints()
+        self.update_status()
+        self.call_after_refresh(self._follow)
+
+    # ------------------------------------------------------------------ /theme
+    def cmd_theme(self, arg: str = "") -> None:
+        word = arg.strip().lower()
+        if word in ("promethee", "prométhée", "nuit"):
+            word = "promethee"
+        if word not in FONDS:
+            current = next((k for k, v in FONDS.items() if v == self.theme), "promethee")
+            self.add_notice(f"Fond actuel : {current}. /theme promethee : le fond de Prométhée (la nuit) · "
+                            "/theme terminal : le fond de ton terminal (transparence, image).")
+            return
+        self.theme = FONDS[word]
+        try:
+            preferences.ecrire(fond=word)
+        except OSError:
+            pass
+        self.add_notice("Fond de Prométhée appliqué." if word == "promethee" else "Fond de ton terminal appliqué.", GREEN)

package/tui/promethee/app/saisie.py

@@ -0,0 +1,100 @@
+"""Autocompletion de la saisie ( / et @ )."""
+from __future__ import annotations
+
+import re
+
+from rich.text import Text
+from textual.widgets import Static
+
+from ..commandes import MENU_ROWS
+from ..completion import (
+    AT_TOKEN, agent_completions, command_completions, custom_command_completions, file_completions,
+)
+from ..theme import DIM, ORANGE
+from ..widgets import PromptInput
+
+
+class Saisie:
+    """Partie de PrometheeApp : autocompletion de la saisie ( / et @ )."""
+
+    # ------------------------------------------------------------------ autocomplétion ( / et @ )
+    def at_token(self) -> tuple[str, int] | None:
+        """« @chemin » en cours de frappe juste avant le curseur : (chemin, colonne du @)."""
+        row, col = self.input.cursor_location
+        match = AT_TOKEN.search(self.input.document.get_line(row)[:col])
+        return (match.group(1), match.start()) if match else None
+
+    def update_completions(self) -> None:
+        items: list[tuple[str, str, str]] = []
+        kind = ""
+        text = self.input.text
+        if self._perm is None and text != self._comp_dismissed:
+            self._comp_dismissed = None
+            if text.startswith("/") and not re.search(r"\s", text):
+                items, kind = command_completions(text) + custom_command_completions(text, self.cwd), "/"
+            else:
+                token = self.at_token()
+                if token is not None:
+                    # Fichiers d'abord (le plus courant) ; les agents passent devant dès « @ag… »
+                    agents, files = agent_completions(token[0], self.cwd), file_completions(token[0], self.cwd)
+                    first = len(token[0]) >= 2 and "agent-".startswith(token[0].lower()[:6])
+                    items, kind = (agents + files if first else files + agents), "@"
+        if [i[0] for i in items] != [i[0] for i in self._comp_items]:
+            self._comp_index = 0
+        self._comp_items, self._comp_kind = items, kind
+        self.render_completions()
+        self.set_hints()
+
+    def render_completions(self) -> None:
+        menu = self.query_one("#completions", Static)
+        items = self._comp_items
+        if not items:
+            menu.display = False
+            return
+        start = max(0, min(self._comp_index - MENU_ROWS // 2, len(items) - MENU_ROWS))
+        shown = items[start:start + MENU_ROWS]
+        width = max(len(label) for _, label, _ in shown) + 3
+        text = Text()
+        for k, (_, label, desc) in enumerate(shown):
+            selected = start + k == self._comp_index
+            text.append(("❯ " if selected else "  ") + label.ljust(width), style=f"bold {ORANGE}" if selected else "")
+            text.append(desc, style=ORANGE if selected else DIM)
+            if k < len(shown) - 1:
+                text.append("\n")
+        if len(items) > len(shown):
+            text.append(f"\n  … {len(items)} au total", style=f"italic {DIM}")
+        menu.update(text)
+        menu.display = True
+
+    def move_completion(self, delta: int) -> None:
+        if self._comp_items:
+            self._comp_index = (self._comp_index + delta) % len(self._comp_items)
+            self.render_completions()
+
+    def hide_completions(self) -> None:
+        self._comp_dismissed = self.input.text
+        self._comp_items = []
+        self.render_completions()
+        self.set_hints()
+
+    def accept_completion(self, submit: bool = False) -> None:
+        if not self._comp_items:
+            return
+        value = self._comp_items[self._comp_index][0]
+        if self._comp_kind == "/":
+            self.input.load_text(value if submit else value + " ")
+            self.input.move_cursor(self.input.document.end)
+            if submit:
+                self.input.post_message(PromptInput.Submitted(value))
+            return
+        token = self.at_token()
+        if token is None:
+            return
+        row, col = self.input.cursor_location
+        insert = "@" + value + ("" if value.endswith("\\") else " ")  # dossier : on continue la complétion
+        self.input.replace(insert, (row, token[1]), (row, col))
+        self.input.move_cursor((row, token[1] + len(insert)))
+
+    def action_complete(self) -> None:
+        if self._comp_items and self._perm is None:
+            self.accept_completion(submit=False)

package/tui/promethee/app/taches.py

@@ -0,0 +1,92 @@
+"""Mode plan et liste de tâches."""
+from __future__ import annotations
+
+import re
+
+from rich.text import Text
+from textual.widgets import Static
+
+from ..plan import PLAN_APPROVED, command_keywords, plan_steps
+from ..theme import DIM, GREEN, ORANGE
+
+
+class Taches:
+    """Partie de PrometheeApp : mode plan et liste de tâches."""
+
+    # ------------------------------------------------------------------ mode plan
+    def action_toggle_plan(self) -> None:
+        if self._perm is None:
+            self.set_plan_mode(not self.plan_mode)
+
+    def set_plan_mode(self, on: bool) -> None:
+        self.plan_mode = on
+        self.query_one("#input-box").set_class(on, "-plan")
+        self.set_hints()
+
+    def offer_plan(self) -> None:
+        """Après un plan : l'exécuter (retour en mode normal) ou continuer à l'affiner."""
+        steps = plan_steps(self.last_answer)
+
+        def chosen(decision: str) -> None:
+            if decision != "go":
+                return
+            self.set_plan_mode(False)
+            if len(steps) >= 2:
+                self.start_tasks("plan", [{"title": t, "text": full, "action": action} for t, full, action in steps])
+            self.send_message("Exécute le plan.", PLAN_APPROVED)
+
+        options = [("go", "Oui : quitter le mode plan et l'exécuter (tu valideras chaque commande)"),
+                   ("keep", "Non : rester en mode plan pour l'affiner (Esc)")]
+        detail = Text(f"  {len(steps)} étapes : " + " · ".join(t for t, _, _ in steps), style=DIM) if steps else None
+        self.ask("Plan prêt", detail, "Exécuter ce plan ?", options, chosen, esc="continuer à planifier")
+
+    # ------------------------------------------------------------------ liste de tâches
+    def start_tasks(self, kind: str, tasks: list[dict]) -> None:
+        self.task_kind = kind
+        self.tasks = [{"title": t["title"], "text": t.get("text", t["title"]), "pattern": t.get("pattern"),
+                       "action": t.get("action", True), "state": "todo"} for t in tasks]
+        self.render_tasks()
+
+    def plan_steps_left(self) -> int:
+        """Étapes du plan accepté qui demandent encore une commande ou un fichier (lu depuis le thread de l'agent)."""
+        if self.task_kind != "plan":
+            return 0
+        return sum(1 for t in list(self.tasks) if t["state"] != "done" and t["action"])
+
+    def task_progress(self, command: str, ok: bool) -> None:
+        """Coche l'étape correspondant à une commande (ou un fichier) réellement exécutée avec succès."""
+        todo = [t for t in self.tasks if t["state"] != "done"]
+        if not ok or not todo:
+            return
+        if self.task_kind == "audit":
+            hit = next((t for t in todo if t["pattern"] and re.search(t["pattern"], command, re.I)), None)
+        else:
+            words = command_keywords(command)
+            steps = [t for t in todo if t["action"]] or todo
+            hit = next((t for t in steps if any(w in t["text"].lower() for w in words)), None) or steps[0]
+        if hit is not None:
+            hit["state"] = "done"
+            self.render_tasks()
+
+    def render_tasks(self) -> None:
+        box = self.query_one("#tasks", Static)
+        if not self.tasks:
+            box.display = False
+            return
+        done = sum(t["state"] == "done" for t in self.tasks)
+        current = next((t for t in self.tasks if t["state"] != "done"), None) if self.generating else None
+        text = Text()
+        text.append(f"Tâches {done}/{len(self.tasks)}", style=f"bold {DIM}")
+        for t in self.tasks:
+            text.append("\n")
+            if t["state"] == "done":
+                text.append("  ☑ ", style=GREEN)
+                text.append(t["title"], style=f"strike {DIM}")
+            elif t is current:
+                text.append("  ☐ ", style=ORANGE)
+                text.append(t["title"], style=f"bold {ORANGE}")
+            else:
+                text.append("  ☐ ", style=DIM)
+                text.append(t["title"])
+        box.update(text)
+        box.display = True