@nosserb/prmt 0.0.0-stage → 2.0.0

package/tui/promethee/consignes.py

@@ -0,0 +1,278 @@
+"""Ce que le modèle reçoit : outils déclarés, consignes, rappels et relances mesurés sur le modèle 8B."""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+# --------------------------------------------------------------------------- Outil : exécution de commandes
+TOOL_NAME = "executer_commande"
+TOOL = {
+    "type": "function",
+    "function": {
+        "name": TOOL_NAME,
+        "description": "Exécute une commande PowerShell sur l'ordinateur de l'utilisateur (Windows 11) et renvoie "
+                       "sa sortie. L'utilisateur valide chaque commande avant son exécution.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "commande": {"type": "string", "description": "La commande PowerShell à exécuter."},
+                "explication": {"type": "string", "description": "En une phrase courte : ce que fait la commande et pourquoi."},
+            },
+            "required": ["commande", "explication"],
+        },
+    },
+}
+
+# --------------------------------------------------------------------------- Outils : fichiers
+READ_TOOL, WRITE_TOOL, EDIT_TOOL = "lire_fichier", "ecrire_fichier", "modifier_fichier"
+FILE_TOOL_NAMES = {READ_TOOL, WRITE_TOOL, EDIT_TOOL}
+_PATH_PARAM = {"type": "string", "description": "Chemin du fichier : absolu, ou relatif au dossier courant."}
+_WHY_PARAM = {"type": "string", "description": "En une phrase courte : ce que change cette écriture et pourquoi."}
+FILE_TOOLS = [
+    {"type": "function", "function": {
+        "name": READ_TOOL,
+        "description": "Lit un fichier texte de l'ordinateur de l'utilisateur et renvoie son contenu avec les numéros "
+                       "de ligne. À utiliser avant de modifier un fichier.",
+        "parameters": {"type": "object", "properties": {
+            "chemin": _PATH_PARAM,
+            "debut": {"type": "integer", "description": "Optionnel : première ligne à lire (1 = début du fichier)."},
+            "fin": {"type": "integer", "description": "Optionnel : dernière ligne à lire."},
+        }, "required": ["chemin"]}}},
+    {"type": "function", "function": {
+        "name": WRITE_TOOL,
+        "description": "Crée un fichier texte, ou remplace entièrement son contenu. L'utilisateur voit le contenu "
+                       "(ou les différences) et valide avant l'écriture.",
+        "parameters": {"type": "object", "properties": {
+            "chemin": _PATH_PARAM,
+            "contenu": {"type": "string", "description": "Le contenu complet du fichier."},
+            "explication": _WHY_PARAM,
+        }, "required": ["chemin", "contenu", "explication"]}}},
+    {"type": "function", "function": {
+        "name": EDIT_TOOL,
+        "description": "Modifie une partie d'un fichier existant en remplaçant un extrait exact par un nouveau texte. "
+                       "L'utilisateur voit les différences et valide avant l'écriture.",
+        "parameters": {"type": "object", "properties": {
+            "chemin": _PATH_PARAM,
+            "ancien_texte": {"type": "string", "description": "Extrait EXACT du fichier à remplacer, copié depuis "
+                             "lire_fichier (sans les numéros de ligne), assez long pour n'apparaître qu'une fois."},
+            "nouveau_texte": {"type": "string", "description": "Le texte qui remplace cet extrait."},
+            "explication": _WHY_PARAM,
+        }, "required": ["chemin", "ancien_texte", "nouveau_texte", "explication"]}}},
+]
+# --------------------------------------------------------------------------- Outils : recherche (lecture seule)
+# Comme Glob / Grep dans Claude Code : sans validation. Mesuré : « trouve les .log » → chercher_fichiers 3/3 (sans eux,
+# il essayait de « lire » le dossier 3/3), « quels fichiers contiennent password » → chercher_texte 3/3, et les autres
+# demandes gardent le bon outil (15/15).
+SEARCH_FILES_TOOL, SEARCH_TEXT_TOOL = "chercher_fichiers", "chercher_texte"
+SEARCH_TOOL_NAMES = {SEARCH_FILES_TOOL, SEARCH_TEXT_TOOL}
+_FOLDER_PARAM = {"type": "string", "description": "Optionnel : dossier où chercher (par défaut le dossier courant)."}
+SEARCH_TOOLS = [
+    {"type": "function", "function": {
+        "name": SEARCH_FILES_TOOL,
+        "description": "Cherche des fichiers par leur nom (motif comme *.log ou rapport*.txt) dans un dossier et ses "
+                       "sous-dossiers. Lecture seule, sans validation.",
+        "parameters": {"type": "object", "properties": {
+            "motif": {"type": "string", "description": "Motif du nom de fichier, par exemple *.log ou *config*."},
+            "dossier": _FOLDER_PARAM,
+        }, "required": ["motif"]}}},
+    {"type": "function", "function": {
+        "name": SEARCH_TEXT_TOOL,
+        "description": "Cherche un texte (ou une expression régulière) dans le contenu des fichiers d'un dossier et de "
+                       "ses sous-dossiers ; renvoie les lignes trouvées avec le fichier et le numéro de ligne. Lecture "
+                       "seule, sans validation.",
+        "parameters": {"type": "object", "properties": {
+            "texte": {"type": "string", "description": "Le texte ou l'expression régulière à chercher."},
+            "dossier": _FOLDER_PARAM,
+            "fichiers": {"type": "string", "description": "Optionnel : seulement les fichiers dont le nom correspond à "
+                                                          "ce motif, par exemple *.log."},
+        }, "required": ["texte"]}}},
+]
+TOOLS = [TOOL] + FILE_TOOLS + SEARCH_TOOLS
+
+TOOL_GUIDE = """
+
+## Exécution de commandes
+Tu as accès à l'ordinateur de l'utilisateur grâce à l'outil `executer_commande` (PowerShell 5.1 sous Windows 11).
+Dossier courant : {cwd}. Date : {date}. L'utilisateur valide chaque commande avant son exécution.
+Toi, tu n'as pas de navigateur, mais l'ordinateur est connecté à Internet : une commande peut s'en servir si c'est utile (par exemple `curl.exe -s -4 https://ifconfig.me` donne l'adresse IP publique IPv4, et `-6` au lieu de `-4` l'IPv6).
+
+Quand utiliser l'outil :
+- Dès que la question porte sur CETTE machine (son IP, ses ports, ses fichiers, ses processus, sa configuration, ses logs…) : exécute la commande toi-même avec l'outil au lieu d'expliquer à l'utilisateur comment faire.
+- Quand l'utilisateur te demande d'agir (créer, tester, lancer, scanner une cible autorisée…).
+- Pas pour une question de cours ou une explication générale : là, réponds directement.
+
+Sécurité :
+- Chaque commande que tu proposes est d'abord contrôlée par la politique de sécurité de Prométhée (liste blanche, périmètre), puis affichée à l'utilisateur, qui la valide ou la refuse.
+- Donc ne refuse jamais toi-même une action que l'utilisateur te demande explicitement (même supprimer, modifier ou installer quelque chose sur sa machine) : propose la commande exacte avec l'outil. Si la politique la refuse, le résultat de l'outil te dit pourquoi et ce que l'utilisateur peut autoriser : transmets-le-lui, sans chercher un détour.
+- Ne demande JAMAIS de confirmation par écrit (« voulez-vous vraiment… ? ») : l'interface affiche déjà la commande à l'utilisateur pour qu'il la valide. Appelle directement l'outil.
+- Quand l'utilisateur te donne une commande précise à exécuter, appelle immédiatement l'outil avec cette commande exacte, sans la recopier en texte.
+- De ta propre initiative, en revanche, utilise seulement des commandes en lecture seule : ne modifie ni ne supprime rien sans qu'on te l'ait demandé.
+
+Comment l'utiliser :
+- Une commande à la fois, qui fait exactement ce qui est demandé (rien de plus).
+- Si le résultat ne répond pas à la question (mauvaise commande, sortie vide, erreur), exécute directement une meilleure commande avec l'outil.
+- Après le résultat, réponds à la question de l'utilisateur avec les VRAIES données de la sortie (valeurs, noms, chiffres). Ne réexplique pas la commande.
+- N'invente jamais d'information absente de la sortie.
+- Si l'utilisateur refuse une commande, arrête-toi et attends ses instructions.
+
+Fichiers (utilise ces outils plutôt que des commandes PowerShell pour lire ou écrire un fichier) :
+- `lire_fichier` : lire un fichier ; le contenu revient avec les numéros de ligne. Lis toujours un fichier avant de le modifier.
+- `ecrire_fichier` : créer un fichier (script, notes, rapport…) ou remplacer tout son contenu. Sans chemin précis, crée-le dans le dossier courant.
+- `modifier_fichier` : changer une partie d'un fichier ; `ancien_texte` doit être copié exactement depuis `lire_fichier`, sans les numéros de ligne.
+- L'utilisateur voit les différences et valide chaque écriture.
+
+Installer un logiciel sous Windows (avec winget, jamais avec une URL de téléchargement devinée) :
+- Lance `winget install <nom du logiciel> --accept-package-agreements --accept-source-agreements`, sans --id : winget trouve lui-même le paquet à partir de son nom.
+- Si winget répond « No package found » ou « Multiple packages found », lance `winget search <mot-clé>`, puis réessaie avec `--id <Id exact lu dans la colonne Id>`.
+- Mets entre guillemets tout chemin qui contient des espaces.
+
+Recherche (lecture seule, sans validation : préfère-les aux commandes pour chercher) :
+- `chercher_fichiers` : trouver des fichiers par leur nom (motif *.log, *config*…).
+- `chercher_texte` : trouver un mot ou une expression dans le contenu des fichiers."""
+
+# Rappel ajouté (invisible) au dernier message de l'utilisateur : sans lui, ce modèle de 8B
+# oublie l'outil dans les longues conversations (mesuré : 2-3/5 sans, 5/5 avec).
+# Il cite aussi les outils fichiers : sans eux, le modèle créait les fichiers avec `echo … > fichier` (4/4).
+TOOL_REMINDER = ("\n\n(Rappel système : si ma demande consiste à agir sur ma machine ou à l'observer, appelle "
+                 "directement l'outil adapté (executer_commande, ou lire_fichier / ecrire_fichier / modifier_fichier "
+                 "pour un fichier, chercher_fichiers / chercher_texte pour chercher) ; je validerai dans l'interface.)")
+
+# ---------------------------------------------------------------- interpréteur de la demande
+# Avant de répondre, un appel très court (≈0,3 s) classe la demande : « action » (exécuter) ou
+# « explication » (répondre directement). Mesuré : 18/19 demandes bien classées. Sans lui, le modèle
+# exécutait des commandes pour des questions de cours (« explique netstat » → netstat lancé 4/4).
+ROUTER_SYSTEM = """Tu es un classificateur. L'utilisateur parle à un assistant de cybersécurité qui peut exécuter des commandes sur son PC Windows. Classe sa DERNIÈRE demande :
+- "action" : il veut que l'assistant FASSE quelque chose maintenant ou obtienne une information réelle (sur son PC, son réseau, un site, un fichier) : afficher, lire ou ouvrir un fichier, vérifier, chercher, scanner, auditer, tester, installer, créer, modifier, corriger, supprimer, lancer. Une relance courte (« install le », « vas-y », « c'est pas ça ») après une action est aussi une action.
+- "explication" : il veut apprendre ou comprendre : un cours, une définition, « comment faire », « c'est quoi », « explique », « donne-moi les commandes », un exemple de code à lire, un avis, ou une simple discussion (« merci »).
+Indique aussi "code" : true si la demande porte sur la programmation : écrire, compléter, corriger, relire ou expliquer un programme, un script ou un extrait de code (Rust, Python, C, JavaScript, script PowerShell…), ou une erreur de compilation ; une relance courte après une demande de code (« corrige-le », « relance-le ») aussi. false pour tout le reste : commandes système ou réseau à lancer, cybersécurité, cours général, discussion.
+Réponds uniquement en JSON."""
+ROUTER_SCHEMA = {"type": "object", "properties": {"type": {"type": "string", "enum": ["action", "explication"]},
+                                                  "code": {"type": "boolean"}}, "required": ["type", "code"]}
+
+# --------------------------------------------------------------------------- IA de code (bascule automatique)
+# Quand l'interpréteur reconnaît une demande de programmation, la réponse est confiée à un modèle meilleur en code
+# (même conversation, mêmes outils, même validation), puis Prométhée reprend la main au message suivant.
+CODE_MODEL = "qwen3.5:9b"
+CODE_SYSTEM = """
+
+## Mode code
+Pour cette demande, tu tournes sur {model}, un modèle meilleur en programmation : tu restes Prométhée et tu réponds en français.
+- Rust (cargo, rustc) et Python sont déjà installés sur ce PC : ne les installe pas.
+- Quand l'utilisateur veut un programme ou un script, écris-le dans un fichier avec ecrire_fichier (ou modifier_fichier), pas seulement dans ta réponse.
+- Puis vérifie-le toi-même avec executer_commande et corrige jusqu'à zéro erreur : Rust → `cargo new nom --vcs none`, le code dans nom\\src\\main.rs, puis `cargo check --manifest-path nom\\Cargo.toml` (un fichier .rs seul : `rustc --edition 2021 fichier.rs`) ; Python → `python -m py_compile fichier.py` puis exécution ; script PowerShell → exécution.
+- Puis lance-le vraiment : s'il lit un fichier, crée un petit fichier d'exemple avec ecrire_fichier et lance le programme dessus ; vérifie que la sortie est juste.
+- N'écris jamais qu'un code compile ou fonctionne sans l'avoir vu dans une sortie de commande."""
+EXPLAIN_REMINDER = "\n\n(Rappel système : ceci est une question de cours ou une discussion. Réponds directement, sans exécuter de commande.)"
+# Retour à Prométhée après l'IA de code : sur « merci ! », il refaisait toute la demande de code (3/4 ; 0/4 avec ce rappel)
+RETURN_REMINDER = ("\n\n(Rappel système : ceci est une question de cours ou une discussion. Réponds directement, sans exécuter "
+                   "de commande. Ta réponse précédente a terminé la demande d'avant : ne la refais pas, réponds seulement "
+                   "à ce dernier message, en une ou deux phrases si c'est un remerciement ou une simple discussion.)")
+# IA de code qui annonce son plan (« Allons-y : d'abord créer le projet ») sans rien lancer : relancée
+CODE_START = re.compile(r"allons-y|commençons|je vais (?:maintenant )?(?:écrire|créer|commencer|coder)|"
+                        r"d'abord,? (?:je |cré|écri)", re.I)
+
+# Méthode ajoutée à la demande quand on demande un audit : le modèle suit alors de vraies étapes
+# au lieu d'inventer des commandes (mesuré : 8/8 démarrent l'audit avec l'outil).
+AUDIT_RE = re.compile(r"audit|pentest|test d.intrusion|vuln[ée]rabilit", re.I)
+AUDIT_PLAYBOOK = """
+
+(Méthode pour un audit autorisé d'un site web ou d'une machine : exécute toi-même chaque étape avec l'outil, une commande à la fois, au lieu de me donner une liste de commandes.
+1. `Resolve-DnsName <domaine>` : adresses IP et serveurs DNS.
+2. `nmap -Pn -sV --top-ports 100 <cible>` : ports ouverts et versions des services.
+3. `curl.exe -sI https://<domaine>` : en-têtes HTTP (serveur, HSTS, CSP, X-Frame-Options, cookies).
+4. `nmap -Pn -p 443 --script ssl-enum-ciphers <domaine>` : configuration TLS.
+5. `curl.exe -s https://<domaine>/robots.txt` : chemins déclarés.
+Après chaque résultat, passe directement à l'étape suivante. À la fin seulement, fais le rapport : constats réels, risques, recommandations.)"""
+
+# Relance quand, pour une demande d'action, le modèle écrit des commandes au lieu de les exécuter.
+NUDGE = ("(Contrôle automatique : je t'ai demandé d'agir, pas de m'écrire des commandes ou des appels d'outils en texte. "
+         "Fais-le maintenant toi-même en appelant vraiment l'outil : executer_commande pour une commande, "
+         "lire_fichier / ecrire_fichier / modifier_fichier pour un fichier.)")
+# Relance quand le modèle annonce l'étape suivante (« Passons au scan… ») mais rend la main sans l'exécuter.
+CONTINUE = ("(Contrôle automatique : la tâche n'est pas terminée. Exécute maintenant l'étape suivante avec l'outil "
+            "adapté. S'il ne reste vraiment plus rien à exécuter, fais le rapport final.)")
+ANNOUNCE = re.compile(r"passons|prochaine étape|étape suivante|lançons|exécutons|"
+                      r"je vais (?:maintenant )?(?:lancer|exécuter|scanner|vérifier|analyser|compiler|tester)|"
+                      r"\bje (?:compile|teste|recompile)\b", re.I)
+MAX_CONTINUES = 6
+# Pendant un plan accepté ou un audit, il demande parfois « Je l'exécute ? » au lieu de continuer
+ASK_CONFIRM = re.compile(r"(?:je l'exécute|je continue|on continue|je lance|voulez-vous|veux-tu|dois-je|souhaitez-vous|"
+                         r"est-elle correcte|est-ce correct)[^?\n]{0,80}\?|veuillez (?:valider|confirmer)|"
+                         r"valide[rz]? (?:cette|la) commande|confirme[rz]? (?:cette|la) commande", re.I)
+NO_CONFIRM = ("(Contrôle automatique : ne me demande pas de confirmation par écrit, je valide déjà chaque commande dans "
+              "l'interface. Exécute maintenant l'étape suivante du plan avec l'outil adapté. S'il ne reste plus rien à "
+              "exécuter, fais le bilan.)")
+# Un agent qui vient de modifier du code conclut souvent « ça devrait marcher » sans recompiler (vu en Rust) :
+# relancé jusqu'à 2 fois pour vérifier d'abord.
+CODE_EXTS = {".rs", ".c", ".h", ".cpp", ".cc", ".hpp", ".go", ".java", ".cs", ".py", ".js", ".ts"}
+VERIFY = ("(Contrôle automatique : tu as modifié {path} mais tu n'as rien relancé depuis : tu ne sais pas encore si ça "
+          "marche. Vérifie maintenant avec executer_commande ({how}), corrige s'il reste des erreurs, et seulement "
+          "ensuite fais ton rapport.)")
+
+
+# IA de code : « ça compile » n'est pas « ça marche » (vu : programme Rust compilé, jamais lancé, qui ne trouvait aucune
+# ligne car il cherchait « Failed password from » au lieu de « Failed password for root from »).
+COMPILE_ONLY = re.compile(r"^\s*(?:cd\s[^;]+;\s*)?(?:cargo\s+(?:check|build|clippy|fmt)|rustc\s+(?!--explain|--version)|"
+                          r"python(?:\.exe)?\s+-m\s+(?:py_compile|compileall)|gcc\s|g\+\+\s|clang\s|javac\s|go\s+(?:build|vet)|tsc\b)",
+                          re.I)
+INSPECT_CMD = re.compile(r"^\s*(?:Get-ChildItem|Get-Content|Get-Item|Test-Path|Resolve-Path|Select-String|dir|ls|type|cat)\b",
+                         re.I)
+EMPTY_REPORT = ("(Contrôle automatique : ta réponse est vide. Fais maintenant ton rapport final en français : ce que tu as "
+                "écrit, le résultat de la dernière compilation ou exécution, et ce qui ne marche pas encore s'il reste un "
+                "problème.)")
+RUN_CHECK = ("(Contrôle automatique : ça compile, mais tu n'as pas encore lancé le programme : tu ne sais pas s'il donne le "
+             "bon résultat. S'il lit un fichier, crée d'abord un petit fichier d'exemple avec ecrire_fichier. Lance-le avec "
+             "executer_commande (cargo run --manifest-path … -- arguments, python fichier.py arguments…), compare sa sortie "
+             "au résultat attendu et corrige si besoin, puis fais ton rapport. Si ce n'est pas un programme qu'on peut "
+             "lancer, dis-le simplement.)")
+
+
+def verify_nudge(path: str, cwd: Path) -> str:
+    """Relance « vérifie ton code », avec la commande adaptée au fichier modifié."""
+    file = Path(path) if Path(path).is_absolute() else cwd / path
+    ext = file.suffix.lower()
+    if ext == ".rs":
+        toml = next((d / "Cargo.toml" for d in file.parents if (d / "Cargo.toml").is_file()), None)
+        how = (f"`cargo check --manifest-path \"{toml}\"`, puis cargo run ou cargo test" if toml else
+               f"ce fichier n'est dans aucun projet cargo : compile-le avec `rustc --edition 2021 \"{file}\"`, "
+               "puis lance l'exécutable produit")
+    elif ext == ".py":
+        how = f"`python -m py_compile \"{file}\"`, puis lance-le sur un petit exemple"
+    else:
+        how = "la commande qui le compile ou le lance"
+    return VERIFY.format(path=path, how=how)
+# Rapport « compilé correctement, aucune erreur » alors que sa dernière commande a échoué (vu en Rust : projet jamais
+# créé, deux commandes en erreur, puis succès annoncé) : relancé une fois, puis averti dans le rapport.
+SUCCESS_CLAIM = re.compile(r"(?:compil|fonctionn|march|exécut|réussi|termin)\w*(?:(?!\b(?:pas|plus|jamais)\b)[^.\n]){0,40}?"
+                           r"(?:correctement|sans (?:erreur|problème)|avec succès)|aucune erreur|tout fonctionne|"
+                           r"ça (?:marche|fonctionne)(?! pas)", re.I)
+FAILED_CLAIM = ("(Contrôle automatique : ta dernière commande `{cmd}` a échoué (code {code}) : tu ne peux pas écrire que ça "
+                "marche. Lis son erreur, corrige et relance ; ou, si tu t'arrêtes, dis honnêtement ce qui ne marche pas.)")
+AUDIT_STEPS = 5  # nombre d'étapes de la méthode d'audit
+REPORT_RE = re.compile(r"rapport|recommandation", re.I)
+
+# Contrôle de la réponse finale : les adresses IP et numéros (ports, PID…) cités doivent apparaître
+# dans les sorties des commandes. Ex. réel : le modèle a « listé » les ports 19444 à 19459 qui n'existent pas.
+VALUE_RE = re.compile(r"(?<![\w.:])(?:\d{1,3}(?:\.\d{1,3}){3}|\d{3,5})(?![\w.:]*\d)")
+
+
+def unverified_values(answer: str, references: str) -> list[str]:
+    missing: list[str] = []
+    for value in dict.fromkeys(VALUE_RE.findall(answer)):
+        if not re.search(rf"(?<![\d.]){re.escape(value)}(?![\d])", references):
+            missing.append(value)
+    return missing
+
+
+CODE_BLOCK = re.compile(r"```[ \t]*(?:powershell|ps1?|pwsh|cmd|bat|bash|sh|shell|console)?[ \t]*\n\s*\S", re.I)
+INLINE_CMD = re.compile(r"`(?:nmap|curl(?:\.exe)?|wget|netstat|ipconfig|ping|tracert|nslookup|whoami|systeminfo|tasklist|"
+                        r"winget|[A-Z][a-z]+-[A-Z][A-Za-z]+)\b[^`]*`")
+
+
+# Appel d'outil écrit en texte (JSON) au lieu d'être vraiment appelé
+TOOL_TEXT = re.compile(r'"(?:commande|chemin|ancien_texte|nouveau_texte|contenu)"\s*:|'
+                       r"\b(?:executer_commande|lire_fichier|ecrire_fichier|modifier_fichier)\b|<tool_call>")
+
+
+def writes_commands(text: str) -> bool:
+    return bool(CODE_BLOCK.search(text) or INLINE_CMD.search(text) or TOOL_TEXT.search(text))

package/tui/promethee/conversation.py

@@ -0,0 +1,94 @@
+"""Compactage de la conversation et sessions enregistrées."""
+from __future__ import annotations
+
+import datetime as dt
+import json
+import os
+import re
+
+from .config import SAVE_DIR
+from .shell import SHELL_TAG
+
+# --------------------------------------------------------------------------- Compactage de la conversation
+AUTO_COMPACT_PCT = 80  # compactage automatique quand le contexte dépasse ce pourcentage
+COMPACT_SYSTEM = """Tu résumes une conversation entre un utilisateur et Prométhée (assistant de cybersécurité qui exécute des commandes et modifie des fichiers sur le PC Windows de l'utilisateur), pour que Prométhée puisse la continuer sans l'historique complet.
+Écris en français, en puces courtes, 250 mots maximum, avec ces parties :
+- Objectif : ce que veut l'utilisateur, demandes en cours.
+- Faits établis : informations obtenues avec leurs VALEURS EXACTES (adresses IP, ports, chemins, noms, versions, résultats de commandes).
+- Fait : commandes lancées, fichiers créés ou modifiés.
+- Reste à faire.
+Recopie les valeurs telles quelles. N'invente rien : ce qui n'est pas dans la conversation ne doit pas apparaître."""
+
+
+def conversation_transcript(messages: list[dict], summary: str = "", max_chars: int = 18_000) -> str:
+    parts = [f"[Résumé d'une partie plus ancienne]\n{summary}"] if summary else []
+    for m in messages:
+        content = (m.get("content") or "").strip()
+        if m["role"] == "user":
+            parts.append(("Commande lancée par l'utilisateur : " + content[len(SHELL_TAG):].strip()[:1500])
+                         if content.startswith(SHELL_TAG) else f"Utilisateur : {content}")
+        elif m["role"] == "assistant":
+            if content:
+                parts.append(f"Prométhée : {content}")
+            for call in m.get("tool_calls") or []:
+                fn = call.get("function") or {}
+                args = fn.get("arguments") or {}
+                if isinstance(args, dict):
+                    shown = args.get("commande") or args.get("chemin") or json.dumps(args, ensure_ascii=False)
+                else:
+                    shown = str(args)
+                parts.append(f"Prométhée utilise {fn.get('name', '?')} : {str(shown)[:300]}")
+        elif m["role"] == "tool":
+            parts.append(f"Résultat : {content[:1200]}" + (" […]" if len(content) > 1200 else ""))
+    text = "\n\n".join(parts)
+    if len(text) > max_chars:  # on garde le début (contexte) et surtout la fin (le plus récent)
+        text = text[:3000] + "\n\n[… partie du milieu coupée …]\n\n" + text[-(max_chars - 3000):]
+    return text
+
+
+# --------------------------------------------------------------------------- Sessions (reprise)
+SESSIONS_DIR = SAVE_DIR / "sessions"
+
+
+def new_session_id() -> str:
+    return dt.datetime.now().strftime("%Y-%m-%d_%H-%M-%S") + "-" + os.urandom(2).hex()
+
+
+def list_sessions(limit: int = 9) -> list[dict]:
+    if not SESSIONS_DIR.is_dir():
+        return []
+    files = sorted(SESSIONS_DIR.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True)
+    sessions = []
+    for path in files:
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            continue
+        if data.get("messages") or data.get("summary"):
+            sessions.append(data)
+        if len(sessions) >= limit:
+            break
+    return sessions
+
+
+def describe_when(iso: str) -> str:
+    try:
+        when = dt.datetime.fromisoformat(iso)
+    except (TypeError, ValueError):
+        return "?"
+    today = dt.date.today()
+    if when.date() == today:
+        return f"aujourd'hui {when:%H:%M}"
+    if when.date() == today - dt.timedelta(days=1):
+        return f"hier {when:%H:%M}"
+    return f"{when:%d/%m %H:%M}"
+
+
+def parse_tool_result(content: str) -> tuple[int | None, str]:
+    """Code de sortie et sortie d'un résultat d'outil enregistré (pour réafficher une conversation)."""
+    content = re.split(r"\n\n\((?:Indice|Rappel)", content, maxsplit=1)[0]
+    head, _, body = content.partition("\n")
+    match = re.match(r"Code de sortie : (-?\d+)", head)
+    if match:
+        return int(match.group(1)), body
+    return None, body

package/tui/promethee/etat.py

@@ -0,0 +1,253 @@
+"""État de la plateforme, affiché par /etat : IA locale, moteur d'exécution, périmètre, activité, connexions.
+
+Tout vient de mesures faites au moment de la commande : appels à Ollama, résumé rendu par la politique,
+lecture des journaux. Rien n'est inventé : une mesure qui échoue s'affiche comme un échec, avec sa raison.
+"""
+from __future__ import annotations
+
+import datetime as dt
+import json
+import subprocess
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+from rich.text import Text
+
+from . import journal
+from .agents import list_agents
+from .commandes import list_custom_commands
+from .config import CMD_TIMEOUT, CREATE_NO_WINDOW
+from .conversation import SESSIONS_DIR
+from .memoire import read_memory
+from .ollama import OLLAMA, api
+from .shell import decode_output, refreshed_env
+from .theme import DIM, GREEN, OR_CLAIR, RED, YELLOW
+
+# état d'une ligne → (signe, couleur). Le signe change avec l'état : la couleur n'est jamais le seul repère.
+SIGNES = {"ok": ("●", GREEN), "attention": ("▲", YELLOW), "probleme": ("✕", RED), "inactif": ("○", DIM), "info": ("·", DIM)}
+Ligne = tuple[str, str]            # (état, texte)
+Section = tuple[str, list[Ligne]]  # (titre, lignes)
+
+
+def pluriel(n: int, mot: str, pluriel_mot: str | None = None) -> str:
+    return f"{n} {mot if n < 2 else (pluriel_mot or mot + 's')}"
+
+
+def nombre(n: int) -> str:
+    return f"{n:,}".replace(",", " ")
+
+
+def depuis(quand: dt.datetime, maintenant: dt.datetime | None = None) -> str:
+    """« il y a 3 min », « il y a 2 h », « hier », « le 04/11 »."""
+    now = maintenant or dt.datetime.now().astimezone()
+    seconds = (now - quand).total_seconds()
+    if seconds < 90:
+        return "à l'instant"
+    if seconds < 3600:
+        return f"il y a {int(seconds // 60)} min"
+    if seconds < 86_400 and quand.date() == now.date():
+        return f"il y a {int(seconds // 3600)} h"
+    if (now.date() - quand.date()).days == 1:
+        return "hier"
+    return f"le {quand:%d/%m}"
+
+
+def version_powershell() -> str:
+    """Version de PowerShell installée, ou "" s'il ne répond pas."""
+    try:
+        proc = subprocess.run(["powershell.exe", "-NoProfile", "-NonInteractive", "-Command", "$PSVersionTable.PSVersion.ToString()"],
+                              env=refreshed_env(), stdin=subprocess.DEVNULL, capture_output=True,
+                              creationflags=CREATE_NO_WINDOW, timeout=20)
+    except (OSError, subprocess.SubprocessError):
+        return ""
+    return decode_output(proc.stdout).strip().split("\n")[0].strip() if proc.returncode == 0 else ""
+
+
+def console_en_ligne(port: int, delai: float = 1.5) -> str:
+    """Version de la console web si son serveur répond sur cette machine, sinon ""."""
+    try:
+        with urllib.request.urlopen(f"http://127.0.0.1:{port}/api/session", timeout=delai) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+    except (OSError, ValueError, urllib.error.URLError):
+        return ""
+    return str(data.get("version") or "") if isinstance(data, dict) else ""
+
+
+# --------------------------------------------------------------------------- sections
+def section_ia(app) -> Section:
+    lignes: list[Ligne] = []
+    start = time.monotonic()
+    try:
+        version = api("/api/version", timeout=4).get("version") or "?"
+    except Exception as err:
+        return "IA locale", [("probleme", f"Ollama ne répond pas sur {OLLAMA} ({err}). Lance l'application Ollama.")]
+    latency = round((time.monotonic() - start) * 1000)
+    try:
+        installed = api("/api/tags", timeout=6).get("models") or []
+        loaded = api("/api/ps", timeout=6).get("models") or []
+    except Exception as err:
+        return "IA locale", [("attention", f"Ollama {version} répond, mais pas sa liste de modèles ({err}).")]
+    lignes.append(("ok", f"Ollama {version} · répond en {latency} ms · {pluriel(len(installed), 'modèle installé', 'modèles installés')}"))
+
+    def charge(name: str) -> str:
+        full = name if ":" in name else f"{name}:latest"
+        entry = next((m for m in loaded if m.get("name") in (name, full)), None)
+        if entry is None:
+            return "non chargé"
+        return "en mémoire GPU" if entry.get("size_vram") else "chargé sur le processeur (carte graphique non détectée)"
+
+    names = {str(m.get("name") or "") for m in installed}
+
+    def installe(name: str) -> bool:
+        return name in names or f"{name}:latest" in names
+
+    if app.model_state:
+        lignes.append(("probleme" if "introuvable" in app.model_state or "injoignable" in app.model_state or "erreur" in app.model_state
+                       else "attention", f"{app.model} · {app.model_state}"))
+    else:
+        where = charge(app.model)
+        parts = [app.model] + ([app.model_desc] if app.model_desc else []) + [where,
+                 "commandes : oui" if app.supports_tools else "commandes : non (modèle sans outils)"]
+        if app.num_ctx:
+            pct = min(100, round(100 * app.ctx_used / app.num_ctx))
+            parts.append(f"contexte {pct} % ({nombre(app.ctx_used)} / {nombre(app.num_ctx)} jetons)")
+        if app.last_tps:
+            parts.append(f"{app.last_tps:.0f} jetons/s")
+        lignes.append(("attention" if "processeur" in where or not app.supports_tools else "ok", " · ".join(parts)))
+    if app.code_model != app.model:
+        if not installe(app.code_model):
+            lignes.append(("attention", f"IA de code {app.code_model} · non installée (/code <modèle> pour en choisir une autre)"))
+        else:
+            lignes.append(("ok" if app.code_auto else "inactif", f"IA de code {app.code_model} · {charge(app.code_model)} · "
+                           + ("bascule automatique" if app.code_auto else "bascule coupée (/code on)")))
+    return "IA locale", lignes
+
+
+def section_moteur(app, resume: dict | None) -> Section:
+    lignes: list[Ligne] = []
+    version = app.ps_version
+    lignes.append(("ok", f"PowerShell {version} · {CMD_TIMEOUT // 60} min au plus par commande") if version
+                  else ("probleme", "PowerShell ne répond pas : aucune commande ne peut être exécutée"))
+    politique = app.politique
+    if resume is None:
+        raison = politique.raison or "moteur de la console indisponible"
+        lignes.append(("attention", f"validation manuelle : tu valides chaque commande, sans liste blanche ({raison})"))
+        return "Moteur d'exécution", lignes
+    lignes.append(("ok", "mode de langage contraint : PowerShell bloque lui-même les appels .NET des commandes autorisées")
+                  if resume.get("constrained") else
+                  ("attention", "mode de langage contraint coupé dans les réglages de la console : il ne reste que la politique"))
+    counts = resume.get("counts") or {}
+    unlocked = [str(u) for u in resume.get("unlocked") or []]
+    custom = [str(c.get("name")) for c in resume.get("custom") or [] if isinstance(c, dict)]
+    lignes.append(("ok" if politique.mode == "stricte" else "attention",
+                   f"politique {politique.mode} · moteur de la console {politique.version or '?'} · "
+                   + ("tout refus de la liste blanche est appliqué" if politique.mode == "stricte"
+                      else "le hors-liste passe à ta validation, les planchers refusent toujours")))
+    lignes.append(("info", f"liste blanche : {pluriel(int(counts.get('read', 0)), 'lecture')}, "
+                   f"{pluriel(int(counts.get('sensitive', 0)), 'sensible')}, "
+                   f"{pluriel(int(counts.get('destructive', 0)), 'destructrice')} ({pluriel(len(unlocked), 'débloquée')}), "
+                   f"{pluriel(int(counts.get('forbidden', 0)), 'interdite')}"))
+    if unlocked:
+        lignes.append(("attention", "débloquées : " + ", ".join(unlocked)))
+    if custom:
+        lignes.append(("info", "liste personnelle (arguments non contrôlés) : " + ", ".join(custom)))
+    roots = [str(r) for r in resume.get("roots") or []]
+    if roots:
+        lignes.append(("info", "écriture permise dans : " + ", ".join(roots)))
+    return "Moteur d'exécution", lignes
+
+
+def section_perimetre(resume: dict | None) -> Section:
+    if resume is None:
+        return "Périmètre réseau", [("inactif", "non contrôlé : la politique n'est pas disponible")]
+    targets = [t for t in resume.get("targets") or [] if isinstance(t, dict)]
+    if not targets:
+        return "Périmètre réseau", [("inactif", "aucune cible déclarée : seuls les tests sur cette machine sont permis "
+                                                "(/perimetre ajouter <hôte>)")]
+    lignes = []
+    for t in targets:
+        note = f" · {t['note']}" if t.get("note") else ""
+        sub = " · sous-domaines compris" if t.get("includeSubdomains") else ""
+        lignes.append(("ok", f"{t.get('host')}{sub}{note} · attestée le {str(t.get('attestedAt') or '')[:10]}"))
+    return "Périmètre réseau", lignes
+
+
+def section_activite(fichiers: list[Path]) -> Section:
+    entries = journal.lire(fichiers)
+    compte = journal.bilan(entries)
+    if not entries:
+        return "Activité", [("inactif", "journal vide : il se remplit dès la première commande")]
+
+    def ligne(c: dict) -> str:
+        return (f"{pluriel(c['executees'], 'exécutée')} · {c['echecs']} en échec · "
+                f"{pluriel(c['refusees'], 'refusée')} par la politique · {pluriel(c['annulees'], 'annulée')} par toi")
+
+    lignes: list[Ligne] = [("info", f"aujourd'hui : {ligne(compte['jour'])}"),
+                           ("info", f"{compte['jours']} derniers jours : {ligne(compte['periode'])} "
+                                    f"(TUI {compte['tui']}, console {compte['console']})")]
+    last = compte["derniere"]
+    if last is not None:
+        when = journal._moment(last)
+        label = {"ok": "réussie", "error": "en échec", "refused": "refusée", "cancelled": "annulée", "info": ""}[last["outcome"]]
+        lignes.append(("info", f"dernière : {depuis(when) if when else '?'} · {last['title'][:70]} ({label})"))
+    return "Activité (TUI et console)", lignes
+
+
+def section_connexions(app) -> Section:
+    lien = app.politique.lien
+    lignes: list[Ligne] = []
+    if lien is None:
+        lignes.append(("inactif", f"console web non reliée : {app.politique.raison}"))
+    else:
+        port = int(lien.get("port") or 4317)
+        version = console_en_ligne(port)
+        lignes.append(("ok", f"console web {version} en ligne : http://127.0.0.1:{port}") if version
+                      else ("inactif", f"console web arrêtée (« npm start » dans {lien.get('racine') or 'son dossier'})"))
+        lignes.append(("info", f"réglages et périmètre partagés : {lien.get('donnees')}"))
+    lignes.append(("info", f"journal de la TUI : {journal.FICHIER}"))
+    return "Connexions", lignes
+
+
+def section_session(app) -> Section:
+    n = sum(1 for m in app.messages if m.get("role") == "user")
+    title = f"« {app.session_title} » · " if app.session_title else ""
+    lignes: list[Ligne] = [("info", f"{title}{pluriel(n, 'message')} · dossier {app.cwd}")]
+    memory = read_memory(app.cwd)
+    try:
+        saved = sum(1 for _ in SESSIONS_DIR.glob("*.json"))
+    except OSError:
+        saved = 0
+    lignes.append(("info", ("mémoire " + " + ".join(f"{label} ({pluriel(text.count(chr(10)) + 1, 'ligne')})" for label, _, text in memory)
+                            if memory else "mémoire vide")
+                   + f" · {pluriel(len(list_agents(app.cwd)), 'agent')} · "
+                   + pluriel(len(list_custom_commands(app.cwd)), 'commande perso', 'commandes perso')
+                   + f" · {pluriel(saved, 'conversation enregistrée', 'conversations enregistrées')}"))
+    auto = sorted(app.allowed) + sorted(app.allowed_lines)
+    if auto or app.allow_edits:
+        lignes.append(("attention", "sans validation pour cette session : " + ", ".join(auto + (["écritures de fichiers"] if app.allow_edits else []))))
+    return "Session", lignes
+
+
+def collecter(app) -> list[Section]:
+    """Mesure l'état de la plateforme (appelé depuis un fil de travail : plusieurs appels réseau et un PowerShell)."""
+    if not app.ps_version:
+        app.ps_version = version_powershell()
+    resume = app.politique.resume()
+    fichiers = [journal.FICHIER]
+    if app.politique.lien is not None:
+        fichiers.append(Path(str(app.politique.lien["donnees"])) / "journal.jsonl")
+    return [section_ia(app), section_moteur(app, resume), section_perimetre(resume), section_activite(fichiers),
+            section_connexions(app), section_session(app)]
+
+
+def rendre(sections: list[Section]) -> Text:
+    text = Text()
+    for i, (titre, lignes) in enumerate(sections):
+        text.append(("\n\n" if i else "") + titre, style=f"bold {OR_CLAIR}")
+        for etat, contenu in lignes:
+            signe, couleur = SIGNES[etat]
+            text.append(f"\n  {signe} ", style=couleur)
+            text.append(contenu, style=DIM if etat in ("info", "inactif") else "")
+    return text