@nosserb/prmt 0.0.0-stage → 2.0.0

package/tui/promethee/securite.py

@@ -0,0 +1,204 @@
+"""Avant de montrer une commande : vérification par l'analyseur de PowerShell et repérage des commandes risquées."""
+from __future__ import annotations
+
+import base64
+import os
+import re
+import subprocess
+import tempfile
+from pathlib import Path
+
+from .config import CREATE_NO_WINDOW
+from .shell import decode_output, refreshed_env
+
+# ---------------------------------------------------------------- vérification avant validation
+# Chaque commande est analysée par le vrai analyseur de PowerShell (sans l'exécuter) avant de te
+# la montrer : erreur de syntaxe, programme absent, `curl` (alias trompeur d'Invoke-WebRequest).
+# En cas de problème, le modèle la corrige seul : tu ne vois que des commandes plausibles.
+PRECHECK_PS = r"""$ErrorActionPreference = 'Stop'
+try {
+  $src = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('@B64@'))
+  $tokens = $null; $errs = $null
+  $ast = [System.Management.Automation.Language.Parser]::ParseInput($src, [ref]$tokens, [ref]$errs)
+  if ($errs.Count -gt 0) { 'SYNTAXE ' + $errs[0].Message; exit }
+  $defined = @($ast.FindAll({ $args[0] -is [System.Management.Automation.Language.FunctionDefinitionAst] }, $true) | ForEach-Object { $_.Name })
+  $names = @($ast.FindAll({ $args[0] -is [System.Management.Automation.Language.CommandAst] }, $true) | ForEach-Object { $_.GetCommandName() } | Where-Object { $_ } | Select-Object -Unique)
+  foreach ($n in $names) {
+    if ($defined -contains $n) { continue }
+    if ($n -eq 'curl' -or $n -eq 'wget') { 'ALIAS ' + $n; continue }
+    if (-not (Get-Command $n -ErrorAction SilentlyContinue)) { 'INTROUVABLE ' + $n }
+  }
+  # Paramètres inventés (« Get-NetFirewallProfile -Enabled ») : seulement pour les cmdlets et fonctions connues
+  $common = @('Verbose','Debug','ErrorAction','WarningAction','InformationAction','ErrorVariable','WarningVariable',
+              'InformationVariable','OutVariable','OutBuffer','PipelineVariable','WhatIf','Confirm')
+  foreach ($c in $ast.FindAll({ $args[0] -is [System.Management.Automation.Language.CommandAst] }, $true)) {
+    $n = $c.GetCommandName()
+    if (-not $n -or $defined -contains $n) { continue }
+    # Lecteurs spéciaux (Cert:, HKLM:, Env:…) : leurs paramètres dynamiques ne sont pas connus ici
+    if ($c.Extent.Text -match '(?i)\b(Cert|HK\w+|Env|WSMan|Function|Variable|Alias|Registry)::?') { continue }
+    try {
+      $info = Get-Command $n -ErrorAction SilentlyContinue | Select-Object -First 1
+      if ($info -and $info.CommandType -eq 'Alias') { $info = $info.ResolvedCommand }
+      if (-not $info -or ($info.CommandType -ne 'Cmdlet' -and $info.CommandType -ne 'Function')) { continue }
+      $params = $info.Parameters
+      if (-not $params -or $params.Count -eq 0) { continue }
+      $known = @($params.Keys) + @($params.Values | ForEach-Object { $_.Aliases }) + $common
+      foreach ($p in $c.CommandElements) {
+        if ($p -isnot [System.Management.Automation.Language.CommandParameterAst] -or -not $p.ParameterName) { continue }
+        $pn = $p.ParameterName
+        if (@($known | Where-Object { $_ -like "$pn*" }).Count -eq 0) {
+          'PARAMETRE ' + $info.Name + ' ' + $pn + ' ' + ((@($params.Keys | Where-Object { $common -notcontains $_ }) | Select-Object -First 25) -join ',')
+        }
+      }
+    } catch { }
+  }
+} catch { }
+"""
+PLACEHOLDER = re.compile(r"<[^<>|]{2,40}>")
+
+
+def precheck(command: str, cwd: Path) -> list[tuple[str, str]]:
+    """Problèmes détectés sans exécuter la commande : [(résumé pour l'écran, explication pour le modèle)]."""
+    script = PRECHECK_PS.replace("@B64@", base64.b64encode(command.encode("utf-8")).decode("ascii"))
+    path = ""
+    try:
+        fd, path = tempfile.mkstemp(prefix="prmt_chk_", suffix=".ps1")
+        with os.fdopen(fd, "w", encoding="utf-8-sig", newline="\r\n") as f:
+            f.write(script)
+        proc = subprocess.run(
+            ["powershell.exe", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-File", path],
+            cwd=str(cwd), env=refreshed_env(), stdin=subprocess.DEVNULL, capture_output=True,
+            creationflags=CREATE_NO_WINDOW, timeout=20,
+        )
+        out = decode_output(proc.stdout)
+    except (OSError, subprocess.SubprocessError):
+        return []  # la vérification ne doit jamais bloquer l'utilisateur
+    finally:
+        if path:
+            try:
+                os.remove(path)
+            except OSError:
+                pass
+    problems: list[tuple[str, str]] = []
+    for line in out.split("\n"):
+        kind, _, arg = line.strip().partition(" ")
+        if kind == "SYNTAXE":
+            if PLACEHOLDER.search(command):
+                problems.append(("valeur manquante (" + PLACEHOLDER.search(command).group(0) + ")",
+                                 "la commande contient un espace réservé comme <adresse_ip> : remplace-le par la vraie valeur "
+                                 "(demande-la à l'utilisateur si tu ne la connais pas)"))
+            else:
+                problems.append(("erreur de syntaxe", f"erreur de syntaxe PowerShell : {arg}"))
+        elif kind == "ALIAS":
+            problems.append((f"`{arg}` à remplacer par curl.exe",
+                             f"dans PowerShell 5.1, `{arg}` est un alias d'Invoke-WebRequest qui n'accepte pas les options "
+                             f"de {arg} : écris `curl.exe` à la place"))
+        elif kind == "INTROUVABLE":
+            problems.append((f"« {arg} » n'est pas installé",
+                             f"« {arg} » n'est ni installé sur cette machine ni une commande PowerShell : utilise une autre "
+                             "commande disponible, ou propose à l'utilisateur de l'installer"))
+        elif kind == "PARAMETRE":
+            cmd, _, rest = arg.partition(" ")
+            param, _, known = rest.partition(" ")
+            listed = ", ".join(f"-{k}" for k in known.split(",") if k)
+            problems.append((f"{cmd} n'a pas de paramètre -{param}",
+                             f"{cmd} n'a pas de paramètre -{param} (paramètre inventé). Ses paramètres : {listed}. "
+                             "Utilise seulement ceux-là, ou filtre le résultat avec Where-Object / Select-Object"))
+    return problems
+
+# Commandes qui modifient / suppriment / exécutent du code : jamais autorisées automatiquement.
+DANGEROUS_ANYWHERE = {
+    "remove-item", "format-volume", "clear-disk", "initialize-disk", "stop-computer", "restart-computer",
+    "set-executionpolicy", "invoke-expression", "iex", "stop-process", "set-content", "out-file", "add-content",
+    "new-item", "move-item", "rename-item", "copy-item", "clear-content", "remove-itemproperty", "set-itemproperty",
+    "new-itemproperty", "start-process", "diskpart", "bcdedit", "vssadmin", "wbadmin", "takeown", "icacls",
+    "cipher", "taskkill", "shutdown", "set-mppreference", "add-mppreference", "remove-mppreference",
+    "set-netfirewallprofile", "new-netfirewallrule", "remove-netfirewallrule", "disable-netfirewallrule",
+    "set-service", "stop-service", "start-service", "restart-service", "new-service", "remove-service",
+    "new-localuser", "set-localuser", "remove-localuser", "add-localgroupmember", "remove-localgroupmember",
+    "uninstall-package", "install-package", "install-module", "clear-recyclebin", "set-acl", "invoke-command",
+}
+DANGEROUS_PREFIX = {
+    "rm", "ri", "del", "erase", "rd", "rmdir", "mv", "mi", "move", "ren", "rni", "cp", "cpi", "copy", "ni", "md",
+    "mkdir", "sc", "sc.exe", "ac", "clc", "sp", "rp", "spps", "kill", "saps", "start", "format", "reg", "reg.exe",
+    "net", "net.exe", "netsh", "schtasks", "attrib", "fsutil", "wmic", "powershell", "pwsh", "cmd", "winget",
+    "choco", "pip", "npm", "msiexec", "runas", "bitsadmin", "certutil", "mshta", "rundll32", "regsvr32",
+}
+SEGMENT_SPLIT = re.compile(r"\|\||&&|[|;\n]")
+FILE_REDIRECT = re.compile(r"(?<!&)>{1,2}(?!&)\s*(?!\s*(?:\$null\b|nul\b))", re.I)
+# Programme ou script désigné par son chemin (« .\\outil.exe », « C:\\x\\y.ps1 ») ou chargé avec « . script » :
+# son nom ne dit rien de ce qu'il fait, il n'est donc jamais autorisé pour la session.
+PATH_CALL = re.compile(r"""(?:^|[|;{(\n])\s*(?:\.\s|['"]?(?:\.{1,2}|~|[A-Za-z]:)?[\\/])""")
+
+
+def segments(cmd: str) -> list[str]:
+    return [s.strip() for s in SEGMENT_SPLIT.split(cmd) if s.strip()]
+
+
+def prefix_of(segment: str) -> str:
+    m = re.match(r"""^[&.(\s]*['"]?([^\s'"(){}]+)""", segment)
+    if not m:
+        return ""
+    token = m.group(1).replace("\\", "/").rsplit("/", 1)[-1].lower()
+    return token[:-4] if token.endswith(".exe") and token not in ("sc.exe", "reg.exe", "net.exe") else token
+
+
+CMD_POSITION = re.compile(r"(?:^|[|;{(\n])\s*([^\s|;{}()]+)")
+NEVER_AUTO = re.compile(r"`|\[[\w.]+\]::|&", re.I)
+
+
+def command_words(cmd: str) -> list[str]:
+    """Tous les noms de commande, y compris ceux cachés dans { } et ( ) (ex. Where-Object { notepad })."""
+    words = []
+    for m in CMD_POSITION.finditer(cmd):
+        token = m.group(1)
+        if token[0] in "$'\"-0123456789@[.":
+            continue  # variable, texte, paramètre, nombre… : pas une commande
+        word = prefix_of(token)
+        if word and word not in words:
+            words.append(word)
+    return words
+
+
+def can_auto_allow(cmd: str) -> bool:
+    """Une commande n'est autorisable automatiquement que si elle est simple et non risquée."""
+    cleaned = re.sub(r"[0-9*]?>&[0-9]", "", cmd)  # 2>&1 n'est pas un opérateur d'appel
+    return (not is_dangerous(cmd) and not NEVER_AUTO.search(cleaned) and not PATH_CALL.search(cmd)
+            and bool(command_words(cmd)))
+
+
+def is_dangerous(cmd: str) -> bool:
+    words = {w.lower() for w in re.findall(r"[A-Za-z][\w.-]*", cmd)}
+    if words & DANGEROUS_ANYWHERE:
+        return True
+    if any(prefix_of(s) in DANGEROUS_PREFIX for s in segments(cmd)):
+        return True
+    # Aussi dans les blocs : « Get-ChildItem | ForEach-Object { rm $_ } » supprime autant que « rm »
+    if any(w in DANGEROUS_PREFIX for w in command_words(cmd)):
+        return True
+    return bool(FILE_REDIRECT.search(cmd))
+
+
+# Portée d'un « ne plus demander » : pour une lecture reconnue, il vaut pour le nom de la commande ; pour tout le
+# reste (python, git, curl, nmap…), seulement pour la ligne exacte. Sinon, après « python --version », n'importe
+# quel « python script.py » partait sans validation.
+READ_VERBS = ("get-", "test-", "resolve-", "select-", "where-", "sort-", "measure-", "format-", "group-", "compare-",
+              "convertto-", "convertfrom-", "find-", "join-", "split-")
+READ_NAMES = {
+    "foreach-object", "out-string", "out-host", "write-output", "write-host", "ipconfig", "whoami", "hostname", "ping",
+    "tracert", "pathping", "nslookup", "netstat", "arp", "getmac", "systeminfo", "tasklist", "ver", "where", "findstr",
+    "sort", "more", "type", "dir", "ls", "cat", "gc", "gci", "gi", "gp", "gps", "gsv", "gcm", "gm", "select", "echo",
+    "pwd", "tree", "ft", "fl", "fw", "measure", "group", "sls", "oh", "gl",
+}
+
+
+def is_read_name(word: str) -> bool:
+    return word in READ_NAMES or word.startswith(READ_VERBS)
+
+
+def session_scope(cmd: str) -> tuple[str, list[str]]:
+    """Ce que couvrirait un « ne plus demander » : ("noms", [commandes]) ou ("ligne", [la commande exacte])."""
+    words = command_words(cmd)
+    if words and all(is_read_name(w) for w in words):
+        return "noms", words
+    return "ligne", [" ".join(cmd.split())]

package/tui/promethee/shell.py

@@ -0,0 +1,190 @@
+"""Exécution PowerShell : décodage des sorties, environnement, script lancé, résultat renvoyé au modèle."""
+from __future__ import annotations
+
+import os
+import re
+
+from .config import MAX_TOOL_CHARS
+
+
+def _codepages() -> tuple[str, str]:
+    try:
+        import ctypes
+        k32 = ctypes.windll.kernel32
+        return f"cp{k32.GetOEMCP()}", f"cp{k32.GetACP()}"
+    except Exception:
+        return "cp850", "cp1252"
+
+
+OEM_CP, ANSI_CP = _codepages()
+FRENCH_CHARS = set("àâäçéèêëîïôöùûüÿœÀÂÄÇÉÈÊËÎÏÔÖÙÛÜŒ«»’\xa0°")
+
+
+def _decode_line(raw: bytes) -> str:
+    # Une même sortie mélange les encodages : PowerShell et la plupart des outils écrivent en OEM
+    # (cp850), certains messages d'erreur (findstr…) en ANSI (cp1252), python/git en UTF-8.
+    try:
+        return raw.decode("utf-8")
+    except UnicodeDecodeError:
+        pass
+    candidates = [raw.decode(OEM_CP, "replace"), raw.decode(ANSI_CP, "replace")]
+    return max(candidates, key=lambda s: sum(c in FRENCH_CHARS for c in s))
+
+
+def decode_output(data: bytes) -> str:
+    try:
+        text = data.decode("utf-8")
+    except UnicodeDecodeError:
+        text = "\n".join(_decode_line(line) for line in data.split(b"\n"))
+    text = text.replace("\r\n", "\n").replace("\xa0", " ")
+    if "\r" in text:
+        # Barres de progression (winget, curl…) : un \r seul réécrit la ligne, comme dans un terminal
+        text = "\n".join(_last_segment(line) for line in text.split("\n"))
+    return text
+
+
+def _last_segment(line: str) -> str:
+    parts = [p for p in line.split("\r") if p.strip()]
+    return parts[-1] if parts else ""
+
+
+def refreshed_env() -> dict[str, str]:
+    """Environnement avec le PATH relu dans le registre : un logiciel installé pendant la session
+    (winget, installateur…) est trouvé sans relancer prmt, comme dans un nouveau terminal."""
+    env = dict(os.environ)
+    try:
+        import winreg
+        found: list[str] = []
+        for root, key in ((winreg.HKEY_LOCAL_MACHINE, r"SYSTEM\CurrentControlSet\Control\Session Manager\Environment"),
+                          (winreg.HKEY_CURRENT_USER, "Environment")):
+            try:
+                with winreg.OpenKey(root, key) as k:
+                    value, _ = winreg.QueryValueEx(k, "Path")
+                found += [os.path.expandvars(p) for p in value.split(";") if p.strip()]
+            except OSError:
+                pass
+        current = env.get("PATH", "").split(";")
+        known = {p.rstrip("\\").lower() for p in current}
+        extra = [p for p in found if p.rstrip("\\").lower() not in known]
+        if extra:
+            env["PATH"] = ";".join(current + extra)
+    except Exception:
+        pass
+    env["PATH"] = windows_first(env.get("PATH", ""), env.get("SystemRoot") or env.get("windir") or "C:\\Windows")
+    return env
+
+
+def windows_first(path: str, root: str) -> str:
+    """PATH avec les dossiers de Windows en tête, comme dans le moteur de la console : « whoami » ou « ipconfig »
+    sont alors ceux de Windows, ceux que la politique a vérifiés, et pas un programme du même nom placé avant."""
+    head = [f"{root}\\System32", root, f"{root}\\System32\\Wbem", f"{root}\\System32\\WindowsPowerShell\\v1.0"]
+    lowered = {h.lower() for h in head}
+    return ";".join(head + [p for p in path.split(";") if p and p.rstrip("\\").lower() not in lowered])
+
+
+CWD_MARK = "__PRMT_CWD__="
+
+
+MODULE_NAME = re.compile(r"^[A-Za-z0-9._-]{1,80}$")
+CONSTRAINED = "$ExecutionContext.SessionState.LanguageMode = 'ConstrainedLanguage'"
+
+
+def build_script(cmd: str, modules: tuple[str, ...] | list[str] = (), constrained: bool = False) -> str:
+    # Le marqueur final permet de suivre les "cd" d'une commande à l'autre.
+    # $OutputEncoding = encodage console : sinon PowerShell 5.1 transmet les pipes natifs
+    # (ex. arp -a | findstr) en ASCII et les accents deviennent des « ? ».
+    # constrained : seconde barrière, comme dans la console. Les modules de fonctions sont chargés juste avant,
+    # sinon ils ne se chargeraient plus (mesuré : Get-NetTCPConnection échoue en mode contraint sans cela).
+    imports = "".join(f"Import-Module -Name '{m}' -ErrorAction SilentlyContinue\n" for m in modules if MODULE_NAME.match(m))
+    return (
+        "$ProgressPreference='SilentlyContinue'\n"
+        "$OutputEncoding = [Console]::OutputEncoding\n"
+        + imports + (CONSTRAINED + "\n" if constrained else "") +
+        f"{cmd}\n"
+        "$__ok = $?; $__code = $LASTEXITCODE\n"
+        # Retour à la ligne avant le marqueur : certaines commandes (curl…) ne finissent pas par un \n
+        f"Write-Output (\"`n{CWD_MARK}\" + (Get-Location).ProviderPath)\n"
+        "if (-not $__ok) { if ($__code) { exit $__code } else { exit 1 } }\n"
+    )
+
+
+# Les erreurs PowerShell citent le fichier .ps1 temporaire et soulignent la ligne fautive :
+# on ne garde que le message (plus lisible pour l'utilisateur, moins de bruit pour le modèle).
+ERR_LOCATION = re.compile(r"^(?:Au caractère|At) .*prmt_\w+\.ps1:\d+\s*(?::|char:)\s*\d+\s*$")
+ERR_DETAIL = re.compile(r"^\s+\+ (?:CategoryInfo|FullyQualifiedErrorId)\s*:")
+
+
+def tidy_output(text: str) -> str:
+    lines: list[str] = []
+    in_location = in_detail = False
+    for line in text.split("\n"):
+        if ERR_LOCATION.match(line):
+            in_location = True
+            continue
+        if in_location and line.startswith("+ "):
+            continue
+        in_location = False
+        if ERR_DETAIL.match(line):
+            in_detail = True
+            continue
+        # PowerShell coupe les longues lignes de détail (~120 colonnes) : on saute leur suite
+        if in_detail and line.startswith(" ") and line.strip():
+            continue
+        in_detail = False
+        line = line.rstrip()
+        if not line and (not lines or not lines[-1]):
+            continue  # pas de lignes vides en double
+        lines.append(line)
+    return "\n".join(lines).strip("\n")
+
+
+def for_model(code: int | None, output: str, note: str = "") -> str:
+    out = output.strip() or "(aucune sortie)"
+    if len(out) > MAX_TOOL_CHARS:
+        cut = len(out) - 3300
+        out = out[:1800] + f"\n[… {cut} caractères coupés …]\n" + out[-1500:]
+    head = f"Code de sortie : {code}" if code is not None else "Commande non terminée"
+    return f"{head}{(' (' + note + ')') if note else ''}\n{out}{hint_for(code, out)}"
+
+
+# Indices ajoutés au résultat envoyé au modèle (pas à l'écran) : un modèle de 8B suit bien mieux
+# une consigne placée dans la sortie d'une commande que dans le prompt système.
+WINGET_HINT = ("\n\n(Indice : le nom n'a pas suffi. Lance maintenant `winget search <un seul mot-clé>`, "
+               "puis réessaie avec `winget install -e --id <Id exact copié depuis la colonne Id> "
+               "--accept-package-agreements --accept-source-agreements`.)")
+
+
+# Mesuré : après une commande fausse, le modèle relance l'outil 5/6 avec cet indice (2/6 sans),
+# et répond toujours directement quand l'échec EST la réponse (processus absent, port fermé).
+ERROR_HINT = ("\n\n(Indice : si cette sortie répond déjà à la question, réponds. Si la commande était fausse "
+              "(syntaxe, option, nom), rappelle directement l'outil avec une commande corrigée, sans demander la permission par écrit.)")
+
+
+# Smart App Control (Windows 11) bloque au hasard les programmes qu'on vient de compiler : pas une erreur du code.
+APP_CONTROL = re.compile(r"os error 4551|contr[ôo]le d.application a bloqu|application control policy has blocked", re.I)
+APP_CONTROL_HINT = ("\n\n(Indice : c'est Windows (Smart App Control) qui a bloqué l'exécution du programme compilé, pas une "
+                    "erreur du code : la compilation a réussi. Ne réessaie pas de le lancer. Vérifie le code avec "
+                    "`cargo check` et `cargo clippy`, et dis à l'utilisateur que Smart App Control a bloqué l'exécution.)")
+
+
+def hint_for(code: int | None, out: str) -> str:
+    if "No package found matching input criteria" in out or "Multiple packages found matching input criteria" in out:
+        return WINGET_HINT
+    if APP_CONTROL.search(out):
+        return APP_CONTROL_HINT
+    if code not in (0, None):
+        return ERROR_HINT
+    return ""
+
+
+# --------------------------------------------------------------------------- Mode « ! » (commande lancée par l'utilisateur)
+SHELL_TAG = "[Commande lancée par l'utilisateur avec !]"
+
+
+def shell_message(command: str, code: int | None, output: str, note: str) -> str:
+    """Message ajouté à la conversation après « ! commande » (sans les indices destinés au modèle)."""
+    out = output.strip() or "(aucune sortie)"
+    if len(out) > MAX_TOOL_CHARS:
+        out = out[:1800] + f"\n[… {len(out) - 3300} caractères coupés …]\n" + out[-1500:]
+    head = f"Code de sortie : {code}" if code is not None else "Commande non terminée"
+    return f"{SHELL_TAG} `{command}`\n{head}{(' (' + note + ')') if note else ''}\n{out}"

package/tui/promethee/textes.py

@@ -0,0 +1,190 @@
+"""Textes fixes de l'interface : aide, spinner, feuille de style."""
+from __future__ import annotations
+
+from .theme import AGENT_COLOR, DIM, MEMORY_COLOR, OR, OR_CLAIR, ORANGE, PLAN_COLOR, RED, SHELL_COLOR
+
+# --------------------------------------------------------------------------- Application
+SPINNER = ["·", "✢", "✳", "✶", "✻", "✽", "✻", "✶", "✳", "✢"]
+VERBS = [
+    "Réflexion", "Analyse", "Décryptage", "Forge", "Attise les braises", "Allume le feu",
+    "Énumération", "Investigation", "Rétro-ingénierie", "Recherche de failles", "Déchiffrement",
+]
+
+HELP = """\
+**Commandes**
+- `/aide` : afficher cette aide
+- `/etat` : état de la plateforme, mesuré à l'instant (Ollama, modèle, PowerShell, politique, périmètre, activité)
+- `/clear` : nouvelle conversation (efface la mémoire de Prométhée et les autorisations de la session)
+- `/modele` : lister les modèles · `/modele deephat` : changer de modèle
+- `/copier` : copier la dernière réponse · `/copier code` : seulement les blocs de code
+- `/sortie` : afficher la sortie complète de la dernière commande exécutée
+- `/politique` : politique d'exécution et liste blanche · `/politique stricte` · `/politique souple`
+- `/permissions` : autorisations de la session · `/permissions reset` : tout redemander ·
+  `/permissions autoriser <commande>` · `/permissions retirer <commande>`
+- `/perimetre` : cibles réseau déclarées · `/perimetre ajouter <hôte>` · `/perimetre retirer <hôte>`
+- `/journal` : dernières actions (commandes exécutées ou refusées, fichiers écrits, recherches web) · `/journal refus`
+- `/recherche` : recherche web, active ou non, et SearXNG répond-il · `/recherche on` · `/recherche off`
+- `/theme terminal` : garder le fond de ton terminal · `/theme promethee` : le fond de Prométhée
+- `/sauver` : enregistrer la conversation (dossier Documents\\Promethee)
+- `/compact` : résumer la conversation pour libérer le contexte (automatique à 80 %)
+- `/reprendre` : reprendre une conversation précédente (aussi : `prmt -c` la dernière, `prmt -r` pour choisir)
+- `/memoire` : voir la mémoire · `/memoire ouvrir` : la modifier dans le Bloc-notes
+- `/plan` : activer ou couper le mode plan (comme `Shift+Tab`)
+- `/quitter` : quitter
+- Tape `/` : la liste des commandes s'affiche (`↑↓` choisir, `Tab` compléter, `Entrée` lancer, `Esc` fermer).
+
+**Mode commande `!`**
+- `! commande` : exécute ta commande PowerShell. Une lecture part **directement** ; une commande sensible, risquée
+  ou hors politique te demande **une confirmation** ; un refus de la politique vaut aussi pour toi.
+- Sa sortie est ajoutée à la conversation : Prométhée peut ensuite l'analyser (« explique ce résultat »).
+
+**Mémoire `#` (fichiers PROMETHEE.md)**
+- `# ma VM Kali est en 192.168.56.10` : enregistre l'information, dans la mémoire globale ou dans celle du dossier courant.
+- Prométhée relit sa mémoire à chaque message : plus besoin de répéter ton contexte (niveau, machines, préférences).
+- Mémoire globale : `Documents\\Promethee\\PROMETHEE.md` · mémoire d'un dossier : `PROMETHEE.md` dans ce dossier.
+
+**Fichiers joints `@`**
+- `analyse @auth.log` : le contenu du fichier est joint à ta question. En tapant `@`, la liste des fichiers du dossier
+  s'affiche (`Tab` pour compléter, `\\` pour entrer dans un sous-dossier). `@dossier` joint la liste de son contenu.
+
+**Agents (`@agent-nom`, `/agents`)**
+- Un agent est un assistant spécialisé qui travaille **dans son propre contexte** (ses longues sorties de commandes
+  n'encombrent pas la conversation) puis renvoie seulement son **rapport**. Tu valides toujours ses commandes.
+- `@agent-analyste-logs analyse @auth.log` : confie directement la tâche à l'agent. Prométhée peut aussi déléguer
+  de lui-même si tu le lui demandes (« demande à l'explorateur de trouver… »).
+- `/agents` : liste des agents, **créer** un agent (tu le décris, Prométhée l'écrit), le modifier, le supprimer.
+  Intégrés : `explorateur` (cherche dans les fichiers), `analyste-logs` (analyse de journaux).
+- Fichiers : `Documents\\Promethee\\agents\\nom.md` (globaux) ou `.promethee\\agents\\nom.md` dans un dossier.
+- `Ctrl+O` : afficher ou replier le détail du travail des agents.
+
+**IA de code (`/code`)**
+- Quand tu demandes d'écrire, corriger ou expliquer du code, Prométhée passe la main à une IA de code
+  (`qwen3.5:9b` par défaut) pour cette réponse, puis la reprend : même conversation, mêmes outils, tu valides
+  toujours. Elle vérifie son code (compilation, exécution) avant de dire que ça marche.
+- `/code` : état · `/code off` / `/code on` : couper / rétablir la bascule · `/code <modèle>` : changer d'IA de code.
+
+**Commandes personnalisées (`/commandes`)**
+- Un fichier `nom.md` dans `Documents\\Promethee\\commandes` (ou `.promethee\\commandes` d'un dossier) devient la
+  commande `/nom` : son texte est envoyé à Prométhée, `$ARGUMENTS` remplacé par ce que tu tapes après (`$1`, `$2`…
+  pour chaque mot). Elles apparaissent dans le menu `/`.
+- `/commandes` : les lister, en **créer** une (tu la décris, Prométhée l'écrit), la modifier, la supprimer.
+
+**Retour en arrière, mémoire du dossier, contexte**
+- `Esc` `Esc` (saisie vide) : choisir un de tes messages ; la conversation repart juste avant, et le message revient
+  dans la saisie pour le modifier (les commandes déjà exécutées ne sont pas annulées).
+- `/init` : Prométhée explore le dossier courant et écrit sa mémoire `PROMETHEE.md` (tu valides le fichier).
+- `/contexte` : ce qui remplit le contexte du modèle (consignes, mémoire, messages, sorties de commandes…).
+
+**Recherche**
+- Prométhée cherche des fichiers (`chercher_fichiers`, par nom) ou du texte dans des fichiers (`chercher_texte`)
+  **sans te demander** : c'est de la lecture seule, comme `lire_fichier`.
+
+**Recherche web (`/recherche`)**
+- Quand une question demande une information récente ou précise (dernière version, actualité, CVE, prix) ou un lieu,
+  Prométhée cherche de lui-même sur internet par SearXNG, installé chez toi. Tu vois la requête et les sources
+  numérotées, et pour un lieu son adresse, ses coordonnées et un lien OpenStreetMap. La réponse cite ses sources : [1].
+- Rien ne s'exécute sur ta machine : la réponse qui suit une recherche ne peut proposer aucune commande.
+- `/recherche` : état · `/recherche off` / `/recherche on` : couper / rétablir. Le réglage est partagé avec la console
+  quand elle est reliée. SearXNG absent : `npm run searxng` dans le dossier de la console.
+
+**Mode plan (`Shift+Tab`)**
+- Prométhée propose un plan numéroté **sans rien exécuter**. Tu le relis, tu l'affines, puis tu choisis de l'exécuter :
+  il repasse alors en mode normal, et tu valides toujours chaque commande.
+- Pendant l'exécution d'un plan ou d'un audit, la **liste des tâches** s'affiche au-dessus de la saisie et se coche
+  d'après les commandes réellement exécutées.
+
+**Exécution de commandes**
+- Prométhée peut lancer des commandes PowerShell, mais **tu valides chacune** avant qu'elle s'exécute.
+- `1` Oui · `2` Oui et ne plus demander (session) · `3` / `Esc` Non. « Ne plus demander » vaut pour le nom d'une
+  commande de lecture reconnue (`ipconfig`, `Get-Process`…) ; pour toute autre, seulement pour la ligne exacte.
+- Les commandes qui modifient ou suppriment quelque chose sont signalées en rouge et **toujours** soumises à validation.
+- `Esc` pendant une commande : l'arrêter. Délai maximum : 5 minutes.
+
+**Politique d'exécution (`/politique`)**
+- Avant de t'être montrée, chaque commande est analysée par le moteur de la console web (le vrai analyseur de
+  PowerShell, sans l'exécuter) : liste blanche, arguments, dossiers d'écriture, cibles réseau.
+- `● lecture` · `▲ sensible` (écrit, contacte le réseau, commande débloquée) · `◆ hors politique` · `✕ refusée`.
+- **stricte** (par défaut) : une commande hors liste blanche est refusée, sans t'être proposée. Prométhée reçoit
+  la raison et cherche une commande de lecture, ou te dit quoi autoriser.
+- **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 dans les deux modes : commande destructrice
+  non débloquée, cible hors périmètre, protections de Windows, chemin réseau.
+- `/permissions autoriser cargo` ajoute une commande à ta liste ; `/permissions autoriser Remove-Item` débloque une
+  commande destructrice. La liste est partagée avec la console web.
+- Les tests de ports et les scans ne sont permis que sur cette machine et sur les cibles de `/perimetre` : des
+  systèmes qui t'appartiennent ou pour lesquels tu as une autorisation écrite.
+- Si la console n'est pas reliée, la barre d'état affiche « validation manuelle » : tu valides chaque commande, sans
+  liste blanche. Chaque action est inscrite dans `Documents\\Promethee\\journal.jsonl` (`/journal`).
+
+**Fichiers**
+- Prométhée lit les fichiers sans demander (lecture seule), mais te montre un **diff coloré** avant chaque création
+  ou modification : `1` Oui · `2` Oui pour toutes les modifications de la session · `3` / `Esc` Non.
+- Les fichiers hors de ton dossier utilisateur sont signalés en rouge et toujours soumis à validation.
+- Les fichiers relus ou exécutés plus tard aussi, même après « oui pour toutes » : mémoire `PROMETHEE.md`, agents et
+  commandes de Prométhée, profil PowerShell, dossier `AppData`, fichiers et dossiers cachés (`.ssh`, `.git`, `.env`).
+
+**Contrôles automatiques (interpréteur)**
+- Avant de répondre, ta demande est classée : *action* (Prométhée exécute) ou *explication* (il répond sans rien lancer).
+- S'il écrit des commandes au lieu de les exécuter, ou annonce une étape sans la faire, il est relancé automatiquement.
+- Chaque commande est vérifiée avant de t'être montrée (syntaxe, programme installé, `curl` → `curl.exe`) et corrigée si besoin.
+- Après la réponse, les IP et ports cités qui n'apparaissent dans aucune sortie de commande te sont signalés.
+- Pour un audit (« fais un audit de sécurité de mon site … »), il suit une méthode en 5 étapes puis fait un rapport.
+
+**Raccourcis**
+- `Entrée` : envoyer · `Ctrl+J` ou `\\` puis `Entrée` : nouvelle ligne
+- `↑` / `↓` : historique de tes messages
+- `Esc` : interrompre la réponse · `Esc` `Esc` (saisie vide) : revenir à un message précédent
+- `Ctrl+C` : copier la sélection, sinon interrompre ; deux fois de suite pour quitter
+- `PgUp` / `PgDn` ou molette : faire défiler la conversation
+"""
+
+# Les couleurs viennent de theme.py. Le fond, les panneaux ($surface) et les ascenseurs suivent le thème Textual
+# choisi par /theme : peints par l'application, ou laissés au terminal.
+CSS = f"""
+Screen {{ layout: vertical; }}
+#chat {{ height: 1fr; padding: 0 1; scrollbar-size-vertical: 1; }}
+Logo {{ height: auto; width: auto; margin: 1 0 0 1; }}
+Accueil {{
+    border: round {OR}; padding: 0 1; margin: 1 0 0 0; width: auto; max-width: 100%; height: auto; background: $surface;
+}}
+.etat {{
+    border: round {OR}; border-title-color: {OR_CLAIR}; border-title-style: bold; border-subtitle-color: {DIM};
+    padding: 0 1; margin: 1 0 0 0; width: auto; max-width: 100%; height: auto; background: $surface;
+}}
+.user {{ margin: 1 0 0 0; height: auto; color: {DIM}; }}
+AssistantMessage {{ margin: 1 0 0 0; height: auto; }}
+AssistantMessage .bullet {{ width: 2; height: 1; color: {ORANGE}; }}
+AssistantMessage .body {{ width: 1fr; height: auto; }}
+AssistantMessage Markdown {{ margin: 0; padding: 0; height: auto; }}
+ToolCallView {{ margin: 1 0 0 0; height: auto; }}
+ToolCallView Static {{ height: auto; }}
+SearchView {{ margin: 1 0 0 0; height: auto; }}
+SearchView Static {{ height: auto; }}
+AgentView {{ margin: 1 0 0 0; height: auto; }}
+AgentView Static {{ height: auto; }}
+AgentView .agent-body {{ height: auto; padding: 0 0 0 2; }}
+AgentView .agent-body ToolCallView {{ margin: 0; }}
+.notice {{ margin: 1 0 0 0; padding: 0 0 0 2; height: auto; }}
+.notice-md {{ margin: 1 0 0 2; padding: 0; height: auto; }}
+#bottom {{ height: auto; }}
+#spinner {{ height: 1; padding: 0 2; display: none; }}
+#spinner.-active {{ display: block; }}
+#input-box {{ border: round {DIM}; height: auto; margin: 0 1; padding: 0 1; background: $surface; }}
+#input-box:focus-within {{ border: round {ORANGE}; }}
+#input-box.-plan, #input-box.-plan:focus-within {{ border: round {PLAN_COLOR}; }}
+#input-box.-shell, #input-box.-shell:focus-within {{ border: round {SHELL_COLOR}; }}
+#input-box.-shell #prompt-char {{ color: {SHELL_COLOR}; }}
+#input-box.-memory, #input-box.-memory:focus-within {{ border: round {MEMORY_COLOR}; }}
+#input-box.-memory #prompt-char {{ color: {MEMORY_COLOR}; }}
+#input-box.-agent, #input-box.-agent:focus-within {{ border: round {AGENT_COLOR}; }}
+#input-box.-agent #prompt-char {{ color: {AGENT_COLOR}; }}
+#completions {{ height: auto; padding: 0 2; display: none; }}
+#tasks {{ height: auto; padding: 0 2; margin: 1 0 0 0; display: none; }}
+#prompt-char {{ width: 2; height: 1; color: {ORANGE}; text-style: bold; }}
+PromptInput {{ height: auto; max-height: 12; width: 1fr; border: none; padding: 0; background: transparent; }}
+ChoicePrompt {{ border: round {ORANGE}; height: auto; margin: 0 1; padding: 0 1; background: $surface; }}
+ChoicePrompt.-danger {{ border: round {RED}; }}
+#status-line {{ height: 1; padding: 0 2; }}
+#hints {{ width: 1fr; color: {DIM}; }}
+#status {{ width: auto; color: {DIM}; }}
+"""