@nosserb/prmt 0.0.0-stage → 2.0.0

package/tui/README.md

@@ -0,0 +1,103 @@
+# Prométhée : la TUI `prmt`
+
+Interface de discussion dans le terminal pour une IA locale de cybersécurité (Ollama, modèle `promethee`). Elle peut exécuter des commandes PowerShell et écrire des fichiers sur ta machine. Chaque commande passe d'abord par une politique de sécurité, puis par ta validation.
+
+Elle fait partie d'une plateforme à deux interfaces. L'autre est la console web, dans `C:\Users\<utilisateur>\prj\promethee-site`. Les deux partagent la même liste blanche, le même périmètre réseau et un journal que chacune sait lire.
+
+## Lancer
+
+```
+prmt                 interface de discussion
+prmt -m deephat      avec un autre modèle
+prmt -c              reprendre la dernière conversation
+prmt -r              choisir une conversation à reprendre
+```
+
+Le lanceur (`~\.local\bin\prmt.cmd`, copie dans `lanceur\`) appelle `.venv\Scripts\python.exe prmt_tui.py`. Dépendances : Python 3.13 et Textual, installés dans `.venv`.
+
+## Relier la console
+
+La politique vient de la console. Pour que la TUI la trouve, la console écrit un fichier de liaison, `Documents\Promethee\plateforme.json`, à chaque démarrage de son serveur. Sans démarrer le serveur :
+
+```
+cd C:\Users\<utilisateur>\prj\promethee-site
+npm run lier
+```
+
+Sans ce fichier, ou sans Node, la TUI fonctionne quand même. La barre d'état affiche alors « validation manuelle » : tu valides chaque commande, sans liste blanche. `/etat` dit pourquoi.
+
+## Ce qui se passe quand Prométhée propose une commande
+
+1. **Vérification.** L'analyseur de PowerShell la lit sans l'exécuter : erreur de syntaxe, programme absent, paramètre inventé. En cas de problème, le modèle la corrige et tu ne la vois pas.
+2. **Politique.** Le moteur de la console la classe.
+   - `● lecture` : elle t'est montrée, et tu peux choisir de ne plus être interrogé jusqu'à la fin de la session. Ce choix vaut pour le nom d'une lecture reconnue (`ipconfig`, `Get-Process`), sinon pour la ligne exacte.
+   - `▲ sensible` : elle écrit, contacte le réseau ou vient de ta liste personnelle. Elle t'est montrée à chaque fois, avec les fichiers écrits et les hôtes contactés.
+   - `✕ refusée` : elle ne t'est pas proposée et rien ne s'exécute. Le modèle reçoit la raison et te dit quoi taper pour l'autoriser.
+3. **Ta validation.** `1` Oui, `2` Oui et ne plus demander, `3` ou `Esc` Non.
+4. **Exécution**, 5 minutes au plus, `Esc` pour arrêter. Une commande de la liste blanche s'exécute en mode de langage contraint de PowerShell, qui bloque les appels directs à .NET (réglage « langage contraint » de la console, actif par défaut).
+5. **Journal.** Une ligne dans `Documents\Promethee\journal.jsonl`.
+
+## Politique : stricte ou souple
+
+| | stricte (par défaut) | souple |
+|---|---|---|
+| Commande de la liste blanche | montrée | montrée |
+| Commande hors liste (`cargo`, `python`, `.\outil.exe`, un script) | refusée | montrée comme `◆ hors politique`, en rouge |
+| Commande destructrice non débloquée (`Remove-Item`, `Stop-Computer`, `winget install`…) | refusée | refusée |
+| Scan ou test de port vers une cible non déclarée | refusé | refusé |
+| Script `.ps1` lancé par son chemin | refusé | lu et analysé : refusé s'il contient une commande refusée dans les deux modes |
+| Adresse écrite en clair dans une commande hors liste (`python scan.py 10.0.0.5`) | refusée | refusée si la cible n'est pas déclarée |
+| Désactiver une protection de Windows, chemin réseau `\\serveur\partage` | refusé | refusé |
+
+```
+/politique                       mode actuel et résumé de la liste blanche
+/politique souple                changer de mode (gardé d'un lancement à l'autre)
+/permissions autoriser cargo     ajouter une commande à ta liste
+/permissions autoriser Remove-Item   débloquer une commande destructrice
+/permissions retirer cargo
+/perimetre ajouter labo.test     déclarer une cible, après attestation
+/perimetre retirer labo.test
+```
+
+Les tests de ports, les scans et les audits ne sont permis que sur cette machine et sur les cibles déclarées : des systèmes qui t'appartiennent ou pour lesquels tu as une autorisation écrite.
+
+## Commandes
+
+`/aide` les décrit toutes. Les principales :
+
+| | |
+|---|---|
+| `/etat` | état de la plateforme, mesuré à l'instant |
+| `/journal`, `/journal refus` | dernières actions des deux interfaces |
+| `/recherche`, `/recherche on`, `/recherche off` | recherche web par SearXNG (`npm run searxng` dans le dossier de la console) |
+| `/modele`, `/modele <nom>` | modèles installés, en changer |
+| `/code` | IA de code : bascule automatique et modèle |
+| `/plan` ou `Shift+Tab` | proposer un plan sans rien exécuter |
+| `/agents`, `/commandes` | agents et commandes personnalisées |
+| `/memoire`, `/init` | mémoire `PROMETHEE.md` |
+| `/compact`, `/reprendre`, `/clear` | contexte et conversations |
+| `/theme terminal`, `/theme promethee` | fond de l'interface |
+| `! commande` | exécuter ta propre commande |
+| `# note` | ajouter une note à la mémoire |
+| `@fichier`, `@agent-nom` | joindre un fichier, confier une tâche à un agent |
+
+## Fichiers
+
+| | |
+|---|---|
+| `Documents\Promethee\sessions\` | conversations enregistrées |
+| `Documents\Promethee\journal.jsonl` | journal des actions de la TUI |
+| `Documents\Promethee\preferences.json` | politique, fond et recherche web choisis (sans console reliée) |
+| `Documents\Promethee\plateforme.json` | fichier de liaison, écrit par la console |
+| `Documents\Promethee\PROMETHEE.md` | mémoire globale |
+| `Documents\Promethee\agents\`, `commandes\` | agents et commandes personnalisées |
+
+## Code et tests
+
+Le code est dans le paquet `promethee\` (41 modules). `prmt_tui.py` reste le point d'entrée. L'architecture, l'audit de la version d'origine et les choix de la refonte sont dans [docs/ANALYSE.md](docs/ANALYSE.md).
+
+```
+.venv\Scripts\python.exe -m unittest discover -s tests -t .
+```
+
+143 tests, sans écran, avec un faux Ollama, un faux SearXNG, un faux PowerShell et un dossier utilisateur jetable. La version d'avant la refonte est le commit `c290fc3`.

package/tui/prmt_tui.py

@@ -0,0 +1,65 @@
+"""Prométhée : interface de discussion dans le terminal (style Claude Code) pour Ollama.
+
+Prométhée peut exécuter des commandes PowerShell sur la machine, mais CHAQUE commande doit
+être validée par l'utilisateur (comme le mode par défaut de Claude Code).
+
+Lancement :  prmt            (ou : python prmt_tui.py [-m MODELE])
+Dépendance : textual (installé dans le venv .venv à côté de ce fichier)
+"""
+from __future__ import annotations
+
+import importlib
+
+from promethee.app import PrometheeApp, main
+
+# Le code vit dans le paquet « promethee ». Ce fichier reste le point d'entrée du lanceur prmt, et les noms
+# d'avant le découpage (prmt_tui.is_dangerous, prmt_tui.build_script…) y restent accessibles.
+_MODULES = (
+    "promethee.config",
+    "promethee.theme",
+    "promethee.ollama",
+    "promethee.consignes",
+    "promethee.securite",
+    "promethee.shell",
+    "promethee.fichiers",
+    "promethee.appels",
+    "promethee.conversation",
+    "promethee.memoire",
+    "promethee.agents",
+    "promethee.commandes",
+    "promethee.completion",
+    "promethee.plan",
+    "promethee.presse_papiers",
+    "promethee.logo",
+    "promethee.widgets",
+    "promethee.textes",
+    "promethee.app.ecran",
+    "promethee.app.saisie",
+    "promethee.app.taches",
+    "promethee.app.notes",
+    "promethee.app.definitions",
+    "promethee.app.contexte",
+    "promethee.app.envoi",
+    "promethee.app.tour",
+    "promethee.app.outils",
+    "promethee.app.validation",
+    "promethee.app.historique",
+    "promethee.app.modele",
+    "promethee.app.commandes_slash",
+    "promethee.app.clavier",
+    "promethee.app.application",
+)
+
+
+def __getattr__(name: str):
+    for module in _MODULES:
+        found = importlib.import_module(module)
+        if hasattr(found, name):
+            return getattr(found, name)
+    raise AttributeError(f"module 'prmt_tui' has no attribute {name!r}")
+
+
+__all__ = ["PrometheeApp", "main"]
+
+if __name__ == "__main__":
+    main()

package/tui/promethee/__init__.py

@@ -0,0 +1 @@
+"""Prométhée : interface de discussion dans le terminal pour une IA locale de cybersécurité (Ollama)."""

package/tui/promethee/__main__.py

@@ -0,0 +1,4 @@
+"""Lancement : python -m promethee [-m MODELE] [-c | -r]"""
+from .app import main
+
+main()

package/tui/promethee/accueil.py

@@ -0,0 +1,66 @@
+"""Écran d'accueil : l'état de la session (modèle, politique, dossier, mémoire) puis les gestes à connaître."""
+from __future__ import annotations
+
+from rich.text import Text
+from textual.widgets import Static
+
+from .memoire import read_memory
+from .theme import DIM, GREEN, ORANGE, RED, YELLOW
+
+
+class Accueil(Static):
+    """Panneau d'accueil. Ses lignes d'état suivent l'application : rafraichir() après chaque changement."""
+
+    def on_mount(self) -> None:
+        self.rafraichir()
+
+    def rafraichir(self) -> None:
+        self.update(self.contenu())
+
+    def _modele(self) -> tuple[str, str, str]:
+        app = self.app
+        detail = app.model + (f" · {app.model_desc}" if app.model_desc else "")
+        if app.model_state:
+            bad = any(w in app.model_state for w in ("introuvable", "injoignable", "erreur"))
+            return ("✕" if bad else "◌", RED if bad else YELLOW, f"{detail} · {app.model_state}")
+        if not app.supports_tools:
+            return "▲", YELLOW, f"{detail} · prêt, sans commandes (ce modèle n'a pas d'outils)"
+        return "●", GREEN, f"{detail} · prêt" + (f" · contexte de {app.num_ctx:,} jetons".replace(",", " ") if app.num_ctx else "")
+
+    def _politique(self) -> tuple[str, str, str]:
+        politique = self.app.politique
+        if politique.etat == "prête":
+            if politique.mode == "stricte":
+                return "●", GREEN, "stricte · liste blanche et périmètre partagés avec la console"
+            return "▲", YELLOW, "souple · le hors-liste passe à ta validation, les planchers refusent toujours"
+        if politique.etat == "en attente":
+            return "◌", YELLOW, f"{politique.mode} · démarrage du moteur…"
+        return "▲", YELLOW, f"validation manuelle · {politique.raison or 'moteur de la console indisponible'}"
+
+    def contenu(self) -> Text:
+        app = self.app
+        t = Text()
+        t.append("✻ ", style=ORANGE)
+        t.append("Bienvenue dans Prométhée !", style="bold")
+        t.append("\n  IA locale de cybersécurité · hors ligne · tes données restent sur ta machine", style=DIM)
+        t.append("\n")
+        for label, (sign, color, value) in (("modèle", self._modele()), ("politique", self._politique())):
+            t.append(f"\n  {label:<10}", style=DIM)
+            t.append(f"{sign} ", style=color)
+            t.append(value)
+        t.append(f"\n  {'commandes':<10}", style=DIM)
+        t.append("tu valides chaque commande", style=ORANGE)
+        t.append(" avant qu'elle s'exécute")
+        t.append(f"\n  {'dossier':<10}", style=DIM)
+        t.append(str(app.cwd))
+        memory = read_memory(app.cwd)
+        if memory:
+            t.append(f"\n  {'mémoire':<10}", style=DIM)
+            t.append(" + ".join(f"{label} ({text.count(chr(10)) + 1} lignes)" for label, _, text in memory))
+        t.append("\n")
+        t.append("\n  /aide pour l'aide · /etat l'état de la plateforme · /modele pour changer de modèle", style=DIM)
+        t.append("\n  ! commande pour l'exécuter toi-même · # note pour la mémoire · @fichier pour le joindre", style=DIM)
+        t.append("\n  Shift+Tab : mode plan · /reprendre une conversation · /compact", style=DIM)
+        t.append("\n  @agent-nom pour confier une tâche à un agent · /agents pour les gérer", style=DIM)
+        t.append("\n  /commandes : tes commandes perso · /init : mémoire du dossier · Esc Esc : revenir en arrière", style=DIM)
+        return t

package/tui/promethee/agents.py

@@ -0,0 +1,220 @@
+"""Agents : définition, fichiers, consignes, génération."""
+from __future__ import annotations
+
+import os
+import re
+import unicodedata
+from pathlib import Path
+
+from .config import SAVE_DIR
+from .consignes import EDIT_TOOL, READ_TOOL, SEARCH_FILES_TOOL, SEARCH_TEXT_TOOL, TOOL_NAME, WRITE_TOOL
+from .fichiers import read_text_file
+from .securite import precheck
+
+# --------------------------------------------------------------------------- Agents (sous-agents, comme Claude Code)
+# Un agent = un fichier Markdown : en-tête (nom, description, outils, modèle) + ses consignes. Il travaille dans son
+# propre contexte (les longues sorties de commandes n'encombrent pas la conversation) et renvoie seulement son rapport.
+# Mesuré avec l'outil lancer_agent en plus : 18/18 bons choix d'outil (ipconfig, fichiers, délégation demandée), et le
+# modèle ne délègue pas de lui-même ce qu'il sait faire (« analyse ce journal » → lire_fichier, 3/3).
+AGENT_TOOL = "lancer_agent"
+AGENTS_DIR = SAVE_DIR / "agents"                # agents globaux
+LOCAL_AGENTS = Path(".promethee") / "agents"    # agents d'un dossier (relatif au dossier courant)
+AGENT_MENTION = re.compile(r"(?:^|(?<=\s))@agent-([a-z0-9][a-z0-9-]*)", re.I)
+MAX_AGENT_STEPS = 14  # écrire, compiler, corriger, recompiler, tester… (10 ne suffisait pas pour du code)
+AGENT_TOOL_NAMES = [TOOL_NAME, READ_TOOL, WRITE_TOOL, EDIT_TOOL, SEARCH_FILES_TOOL, SEARCH_TEXT_TOOL]
+# Noms d'outils de Claude Code acceptés dans l'en-tête (pour reprendre un agent écrit pour Claude Code)
+CLAUDE_TOOL_NAMES = {"bash": TOOL_NAME, "powershell": TOOL_NAME, "read": READ_TOOL, "write": WRITE_TOOL,
+                     "edit": EDIT_TOOL, "multiedit": EDIT_TOOL, "grep": SEARCH_TEXT_TOOL, "glob": SEARCH_FILES_TOOL,
+                     "ls": SEARCH_FILES_TOOL}
+TOOL_LABELS = {TOOL_NAME: "commandes", READ_TOOL: "lecture", WRITE_TOOL: "création de fichiers",
+               EDIT_TOOL: "modification de fichiers", SEARCH_FILES_TOOL: "recherche de fichiers",
+               SEARCH_TEXT_TOOL: "recherche dans les fichiers"}
+SCOPE_LABELS = {"intégré": "intégré", "global": "global", "dossier": "ce dossier"}
+
+BUILTIN_AGENTS = [
+    {"name": "explorateur",
+     "description": "Cherche et lit des fichiers sur l'ordinateur (lecture seule) pour répondre à une question, puis "
+                    "résume ce qu'il a trouvé. Utile pour fouiller un dossier ou de nombreux fichiers.",
+     "tools": [SEARCH_FILES_TOOL, SEARCH_TEXT_TOOL, READ_TOOL, TOOL_NAME],
+     "prompt": "Tu es l'explorateur : tu trouves l'information demandée dans les fichiers et les dossiers de "
+               "l'ordinateur, en LECTURE SEULE.\n"
+               "- Pour chercher : chercher_fichiers (par nom, par exemple *.log) et chercher_texte (un mot dans le "
+               "contenu des fichiers), sans validation. Une commande (Get-ChildItem, Get-Item) seulement si ces "
+               "outils ne suffisent pas.\n"
+               "- Pour lire un fichier : l'outil lire_fichier.\n"
+               "- Ne crée, ne modifie et ne supprime jamais rien.\n"
+               "- Arrête-toi dès que tu as la réponse. Ton rapport : ce que tu as trouvé, avec les chemins exacts, "
+               "court et factuel.\n"
+               "- Ne cite le contenu d'un fichier que si tu l'as lu avec lire_fichier, et recopie-le exactement. "
+               "N'invente jamais de contenu."},
+    {"name": "analyste-logs",
+     "description": "Analyse des journaux (auth.log, access.log, journaux d'événements Windows…) pour repérer les "
+                    "attaques (force brute, scans, connexions suspectes) et en fait un rapport chiffré.",
+     "tools": [READ_TOOL, SEARCH_FILES_TOOL, SEARCH_TEXT_TOOL, TOOL_NAME],
+     "prompt": "Tu es l'analyste SOC : tu analyses les journaux indiqués et tu repères les événements suspects.\n"
+               "- Lis le fichier avec lire_fichier ; pour un gros fichier, Select-String -Pattern 'Failed|Invalid' ; "
+               "pour les journaux Windows, Get-WinEvent.\n"
+               "- Compte précisément : échecs de connexion par IP et par compte, connexions réussies, IP suspectes, "
+               "horaires. Ne compte pas de tête : fais compter PowerShell, par exemple "
+               "`Select-String -Path auth.log -Pattern 'Failed password' | ForEach-Object { if ($_.Line -match "
+               "'from (\\S+)') { $Matches[1] } } | Group-Object | Select-Object Count, Name` (nombre d'échecs par IP).\n"
+               "- Ne modifie rien.\n"
+               "- Ton rapport : résumé en une phrase, tableau des IP suspectes (IP, nombre d'échecs, comptes visés), "
+               "connexions réussies notables, gravité (faible / moyenne / élevée), recommandations. Uniquement des "
+               "valeurs lues dans les journaux."},
+]
+
+AGENT_SYSTEM = """Tu es « {name} », un agent spécialisé de Prométhée (assistant de cybersécurité local). Prométhée t'a confié une tâche : fais-la seul, avec tes outils, puis écris ton rapport.
+
+## Ta spécialité
+{prompt}
+
+## Règles
+- Ordinateur de l'utilisateur : Windows 11, PowerShell 5.1. Dossier courant : {cwd}. Date : {date}.
+- Tes outils : {tools}. L'utilisateur valide chacune de tes commandes et de tes écritures.
+- Une commande à la fois ; si elle échoue, corrige-la (écris `curl.exe` et non `curl`, mets entre guillemets les chemins avec des espaces).
+- Tu ne peux pas parler à l'utilisateur : ne pose pas de question et ne demande jamais de confirmation par écrit.
+- N'invente rien : seulement ce que tu as lu dans les sorties de commandes et les fichiers.
+- Quand tu as fini, réponds sans appeler d'outil : ce texte est ton rapport, transmis à Prométhée. Commence directement par les résultats."""
+AGENT_REMINDER = ("\n\n(Rappel système : fais la tâche toi-même en appelant directement tes outils ; l'utilisateur "
+                  "valide dans l'interface. Quand tu as fini, écris ton rapport sans appeler d'outil.)")
+AGENT_REPORT_NOW = ("(Contrôle automatique : tu as atteint le nombre maximum d'étapes. N'appelle plus d'outil : écris "
+                    "maintenant ton rapport avec ce que tu as trouvé.)")
+AGENT_HINT = " ; ou lancer_agent pour confier la tâche à un agent."
+# Sans elle, après un échange « @agent-… » dans l'historique, le modèle recopiait « @agent-… » au lieu de répondre
+AGENT_DONE = "\n\n(Fin du rapport de l'agent. Réponds maintenant à l'utilisateur à partir de ce rapport.)"
+
+
+def agent_slug(name: str) -> str:
+    """« Analyste Logs » → « analyste-logs » (minuscules, chiffres et tirets)."""
+    plain = unicodedata.normalize("NFKD", name).encode("ascii", "ignore").decode("ascii").lower()
+    return re.sub(r"-{2,}", "-", re.sub(r"[^a-z0-9]+", "-", plain)).strip("-")[:40]
+
+
+def parse_agent(text: str, path: Path | None = None, scope: str = "global") -> dict | None:
+    """Fichier d'agent : en-tête « --- nom / description / outils / modele --- » puis les consignes."""
+    match = re.match(r"\ufeff?\s*---[ \t]*\r?\n(.*?)\r?\n---[ \t]*(?:\r?\n|$)(.*)$", text, re.S)  # \ufeff : BOM éventuel
+    if not match:
+        return None
+    meta: dict[str, str] = {}
+    for line in match.group(1).splitlines():
+        key, sep, value = line.partition(":")
+        if sep:
+            meta[key.strip().lower()] = value.strip().strip("\"'")
+    name = agent_slug(meta.get("nom") or meta.get("name") or (path.stem if path else ""))
+    prompt = match.group(2).strip()
+    if not name or not prompt:
+        return None
+    tools: list[str] = []
+    for raw in re.split(r"[,;\s]+", meta.get("outils") or meta.get("tools") or ""):
+        tool = raw.strip().strip("[]\"'")
+        tool = tool if tool in AGENT_TOOL_NAMES else CLAUDE_TOOL_NAMES.get(tool.lower(), "")
+        if tool and tool not in tools:
+            tools.append(tool)
+    return {"name": name, "description": meta.get("description", ""), "tools": tools or list(AGENT_TOOL_NAMES),
+            "model": meta.get("modele") or meta.get("modèle") or meta.get("model") or "", "prompt": prompt,
+            "scope": scope, "path": path}
+
+
+def agent_markdown(agent: dict) -> str:
+    lines = ["---", f"nom: {agent['name']}", f"description: {' '.join(agent['description'].split())}",
+             f"outils: {', '.join(agent['tools'])}"]
+    if agent.get("model"):
+        lines.append(f"modele: {agent['model']}")
+    return "\n".join(lines) + "\n---\n\n" + agent["prompt"].strip() + "\n"
+
+
+def agent_dirs(cwd: Path) -> list[tuple[str, Path]]:
+    dirs = [("global", AGENTS_DIR)]
+    local = cwd / LOCAL_AGENTS
+    if os.path.normcase(str(local)) != os.path.normcase(str(AGENTS_DIR)):
+        dirs.append(("dossier", local))
+    return dirs
+
+
+def list_agents(cwd: Path) -> list[dict]:
+    """Agents intégrés, puis globaux, puis ceux du dossier : un agent écrit remplace l'intégré du même nom."""
+    agents = {a["name"]: dict(a, scope="intégré", path=None, model="") for a in BUILTIN_AGENTS}
+    for scope, folder in agent_dirs(cwd):
+        try:
+            files = sorted(folder.glob("*.md"))
+        except OSError:
+            continue
+        for path in files:
+            try:
+                agent = parse_agent(read_text_file(path)[0], path, scope)
+            except (OSError, ValueError):
+                continue
+            if agent:
+                agents[agent["name"]] = agent
+    return list(agents.values())
+
+
+def find_agent(name: str, cwd: Path) -> dict | None:
+    slug = agent_slug(name.removeprefix("agent-"))
+    return next((a for a in list_agents(cwd) if a["name"] == slug), None)
+
+
+def agent_tool_def(agents: list[dict]) -> dict:
+    return {"type": "function", "function": {
+        "name": AGENT_TOOL,
+        "description": "Confie une tâche à un agent spécialisé, qui travaille dans son propre contexte puis renvoie "
+                       "son rapport.",
+        "parameters": {"type": "object", "properties": {
+            "agent": {"type": "string", "enum": [a["name"] for a in agents], "description": "Nom de l'agent."},
+            "tache": {"type": "string", "description": "La tâche complète à confier (l'agent ne voit pas la "
+                                                       "conversation)."},
+        }, "required": ["agent", "tache"]}}}
+
+
+def agents_guide(agents: list[dict]) -> str:
+    lines = "\n".join(f"- `{a['name']}` : {' '.join(a['description'].split()) or '(sans description)'}" for a in agents)
+    return ("\n\n## Agents\nAvec l'outil `lancer_agent`, tu peux confier une tâche à un agent spécialisé : il travaille "
+            "seul, dans son propre contexte, puis te renvoie son rapport (l'utilisateur valide toujours ses commandes). "
+            f"Agents disponibles :\n{lines}\nUtilise un agent seulement si l'utilisateur le demande, ou si la tâche "
+            "correspond exactement à sa description. Sinon, fais-le toi-même avec les autres outils. Dans `tache`, "
+            "écris une consigne complète (l'agent ne voit pas la conversation).")
+
+
+def unique_agent_path(folder: Path, name: str) -> tuple[str, Path]:
+    candidate, n = name, 2
+    while (folder / f"{candidate}.md").exists():
+        candidate, n = f"{name}-{n}", n + 1
+    return candidate, folder / f"{candidate}.md"
+
+
+AGENT_GEN_SYSTEM = """Tu conçois des agents spécialisés pour Prométhée, un assistant de cybersécurité local sous Windows 11 (PowerShell 5.1). À partir de la description de l'utilisateur, écris la définition d'UN agent :
+- nom : court, en minuscules, mots séparés par des tirets (par exemple « analyste-logs », « auditeur-web »).
+- description : une ou deux phrases : ce que fait l'agent et QUAND l'utiliser (Prométhée s'en sert pour choisir l'agent).
+- outils : seulement ceux dont il a besoin parmi executer_commande (commandes PowerShell), lire_fichier, ecrire_fichier, modifier_fichier, chercher_fichiers (trouver des fichiers par nom), chercher_texte (chercher dans leur contenu).
+- consignes : ses instructions, à la deuxième personne (« Tu es… »), en 5 à 12 lignes : son rôle, sa méthode étape par étape, les commandes PowerShell ou outils à privilégier, ce qu'il ne doit pas faire, et le contenu de son rapport final.
+Cite seulement des commandes PowerShell qui existent vraiment, avec leurs vrais paramètres, entre backticks ; ne mentionne pas de fichier de configuration qui n'existe pas sous Windows.
+Réponds uniquement en JSON."""
+AGENT_CMD = re.compile(r"[`'\"«]\s*([A-Z][a-z]+-[A-Z][A-Za-z]+(?:[ \t][^`'\"»\n]*)?)[`'\"»]")
+AGENT_GEN_FIX = ("(Contrôle automatique : dans les consignes, {problems}. Réécris la définition complète en JSON, en "
+                 "remplaçant ces commandes par des commandes PowerShell correctes.)")
+
+
+def agent_command_problems(prompt: str, cwd: Path) -> list[tuple[str, str]]:
+    """Commandes PowerShell citées dans les consignes d'un agent : paramètres inventés, commandes inexistantes."""
+    commands: list[str] = []
+    for match in AGENT_CMD.finditer(prompt):
+        command = match.group(1).strip()
+        if command not in commands:
+            commands.append(command)
+    problems: list[tuple[str, str]] = []
+    for command in commands[:6]:
+        for short, detail in precheck(command, cwd):
+            if ("paramètre" in short or "pas installé" in short) and short not in (s for s, _ in problems):
+                problems.append((short, detail))
+    return problems
+AGENT_SCHEMA = {"type": "object", "properties": {
+    "nom": {"type": "string"},
+    "description": {"type": "string"},
+    "outils": {"type": "array", "items": {"type": "string", "enum": AGENT_TOOL_NAMES}},
+    "consignes": {"type": "string"},
+}, "required": ["nom", "description", "outils", "consignes"]}
+AGENT_TEMPLATE = {"name": "mon-agent", "tools": [TOOL_NAME, READ_TOOL, SEARCH_FILES_TOOL, SEARCH_TEXT_TOOL],
+                  "description": "Ce que fait cet agent, et quand Prométhée doit l'utiliser.",
+                  "prompt": "Tu es … (le rôle de l'agent).\n\nMéthode :\n1. …\n2. …\n\nNe fais jamais : …\n\n"
+                            "Ton rapport final : …"}

package/tui/promethee/app/__init__.py

@@ -0,0 +1,4 @@
+"""L'application Textual. La classe PrometheeApp est assemblée à partir des modules de ce dossier."""
+from .application import PrometheeApp, main
+
+__all__ = ["PrometheeApp", "main"]