@nosserb/prmt 0.0.0-stage → 2.0.0

package/tui/promethee/app/historique.py

@@ -0,0 +1,373 @@
+"""Fin d'un tour, compactage et sessions."""
+from __future__ import annotations
+
+import datetime as dt
+import json
+import os
+import re
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+from rich.text import Text
+from textual import work
+from textual.widget import Widget
+from textual.widgets import Markdown, Static
+
+from ..agents import AGENT_TOOL
+from ..consignes import (
+    EDIT_TOOL, FILE_TOOL_NAMES, READ_TOOL, REPORT_RE, SEARCH_TOOL_NAMES, WRITE_TOOL, unverified_values,
+)
+from ..conversation import (
+    AUTO_COMPACT_PCT, COMPACT_SYSTEM, SESSIONS_DIR, conversation_transcript, describe_when, list_sessions,
+    new_session_id, parse_tool_result,
+)
+from ..fichiers import change_summary, resolve_path, search_desc, show_path
+from ..ollama import OLLAMA, http_error_text
+from ..recherche import OUTIL as WEB_TOOL
+from ..shell import SHELL_TAG
+from ..theme import DIM, GREEN, RED, YELLOW
+from ..widgets import AgentView, AssistantMessage, SearchView, ToolCallView
+
+
+class Historique:
+    """Partie de PrometheeApp : fin d'un tour, compactage et sessions."""
+
+    # ------------------------------------------------------------------ fin d'un tour
+    def finish_agent(self, msgs: list[dict], final: dict | None, error: str | None,
+                     interrupted: bool, denied: bool, produced: bool) -> None:
+        self.generating = False
+        self._spinner(False)
+        self._turn_model = None
+        self.update_status()
+        if self._perm is not None:
+            self.hide_permission()
+        stopped, self._policy_stop = self._policy_stop, False
+        if error and not produced and msgs and msgs[-1]["role"] == "user":
+            msgs = msgs[:-1]  # on retire la question restée sans réponse
+        self.messages = msgs
+        for m in reversed(msgs):
+            if m.get("direct"):
+                self.last_answer = m["content"].split("\n", 1)[-1]  # sans « Rapport de l'agent … : »
+                break
+            if m["role"] == "assistant" and m.get("content", "").strip():
+                self.last_answer = m["content"]
+                break
+        if interrupted:
+            self.add_notice("Interrompu", DIM)
+        elif denied and stopped:
+            self.add_notice("Arrêt : la politique a refusé deux commandes dans cette réponse. /politique pour voir les "
+                            "règles, ou reformule ta demande.", YELLOW)
+        elif denied:
+            self.add_notice("Refusé. Dis à Prométhée quoi faire autrement.", YELLOW)
+        elif error:
+            self.add_notice(f"Erreur : {error}", f"bold {RED}")
+        elif not produced:
+            self.add_notice("(réponse vide)")
+        if final:
+            reported = (final.get("prompt_eval_count") or 0) + (final.get("eval_count") or 0)
+            self.ctx_used = max(reported, self.estimate_tokens())
+            if final.get("eval_duration") and final.get("eval_count"):
+                self.last_tps = final["eval_count"] / (final["eval_duration"] / 1e9)
+        else:
+            self.ctx_used = max(self.ctx_used, self.estimate_tokens())
+        if self.tasks and produced and not interrupted and not error:
+            if self.task_kind == "audit" and REPORT_RE.search(self.last_answer):
+                for t in self.tasks:
+                    if t["pattern"] is None:
+                        t["state"] = "done"  # « Rapport final »
+            elif self.task_kind == "plan" and self.plan_steps_left() == 0 and self.last_answer.strip():
+                for t in self.tasks:
+                    t["state"] = "done"  # il ne restait que le bilan, et la réponse finale le donne
+        self.render_tasks()
+        self.update_status()
+        self.save_session()
+        self.call_after_refresh(self._follow)
+        offer = self._run_plan and produced and not (interrupted or error or denied) and self.plan_mode
+        # Un plan vient d'être proposé : on te demande d'abord si tu l'exécutes. Le compactage automatique attend
+        # la réponse suivante, sinon les deux se lançaient ensemble sur la même conversation.
+        if not interrupted and not error and not offer:
+            self._maybe_auto_compact()
+        if offer:
+            self.call_after_refresh(self.offer_plan)
+
+    def _maybe_auto_compact(self) -> None:
+        """Comme Claude Code : quand le contexte est presque plein, la conversation est résumée automatiquement."""
+        pct = self.context_pct(self.ctx_used)
+        if pct is not None and pct >= AUTO_COMPACT_PCT and len(self.messages) >= 3:
+            self.add_notice(f"Contexte rempli à {pct} % : compactage automatique de la conversation…", YELLOW)
+            self.call_after_refresh(self.start_compact, "", True)
+
+    def context_pct(self, tokens: int) -> int | None:
+        return min(100, round(100 * tokens / self.num_ctx)) if self.num_ctx else None
+
+    # ------------------------------------------------------------------ compactage
+    def start_compact(self, instructions: str = "", auto: bool = False) -> None:
+        if self.generating:
+            self.add_notice("Attends la fin de la réponse avant de compacter (ou Esc pour l'interrompre).", YELLOW)
+            return
+        if not self.messages:
+            self.add_notice("Rien à compacter : la conversation est vide." if not self.summary
+                            else "Rien de nouveau à compacter depuis le dernier résumé.", YELLOW)
+            return
+        self.generating = True
+        self.cancel_event.clear()
+        self._spinner(True, "check", "Compactage de la conversation")
+        before = max(self.ctx_used, self.estimate_tokens())
+        self.compact_conversation(list(self.messages), self.summary, instructions, auto, before)
+
+    @work(thread=True, exclusive=True, group="generate")
+    def compact_conversation(self, messages: list[dict], summary: str, instructions: str, auto: bool, before: int) -> None:
+        transcript = conversation_transcript(messages, summary)
+        system = COMPACT_SYSTEM + (f"\nConsigne de l'utilisateur pour ce résumé : {instructions}" if instructions else "")
+        payload: dict = {"model": self.model, "stream": True, "options": {"temperature": 0.2, "num_predict": 700},
+                         "messages": [{"role": "system", "content": system},
+                                      {"role": "user", "content": f"Conversation à résumer :\n\n{transcript}"}]}
+        if self.supports_thinking:
+            payload["think"] = False
+        text, error = "", None
+        try:
+            text = self._summarize(payload)
+        except urllib.error.HTTPError as err:
+            error = http_error_text(err)
+        except Exception as err:
+            if not self.cancel_event.is_set():
+                error = f"Impossible de joindre Ollama sur {OLLAMA} ({err})."
+        self.call_from_thread(self.finish_compact, messages, text, error, auto, transcript, before)
+
+    def _summarize(self, payload: dict) -> str:
+        req = urllib.request.Request(OLLAMA + "/api/chat", data=json.dumps(payload).encode("utf-8"),
+                                     headers={"Content-Type": "application/json"})
+        parts: list[str] = []
+        with urllib.request.urlopen(req, timeout=600) as resp:
+            self._resp = resp
+            try:
+                for raw in resp:
+                    if self.cancel_event.is_set():
+                        break
+                    if not raw.strip():
+                        continue
+                    chunk = json.loads(raw)
+                    if "error" in chunk:
+                        raise RuntimeError(chunk["error"])
+                    piece = (chunk.get("message") or {}).get("content") or ""
+                    if piece:
+                        parts.append(piece)
+                    if chunk.get("done"):
+                        break
+            finally:
+                self._resp = None
+        return re.sub(r"<think>.*?</think>", "", "".join(parts), flags=re.S).strip()
+
+    def finish_compact(self, messages: list[dict], text: str, error: str | None, auto: bool,
+                       transcript: str, before: int) -> None:
+        self.generating = False
+        self._spinner(False)
+        if self.cancel_event.is_set():
+            self.add_notice("Compactage annulé : la conversation est intacte.", DIM)
+            return
+        if error or not text:
+            self.add_notice(f"Compactage impossible : {error or 'résumé vide'}. La conversation est intacte.", f"bold {RED}")
+            return
+        self.summary = text
+        self.messages = self.messages[len(messages):]  # (rien de neuf normalement : la saisie est bloquée)
+        after = self.estimate_tokens()
+        self.ctx_used = after
+        pb, pa = self.context_pct(before), self.context_pct(after)
+        sizes = f"contexte {pb} % → {pa} %" if pb is not None else f"≈{before} → {after} jetons"
+        self.add_notice(f"Conversation compactée{' automatiquement' if auto else ''} ({sizes}). "
+                        "Prométhée continue avec ce résumé :", GREEN)
+        self.add_notice_md(text)
+        missing = unverified_values(text, transcript)
+        if missing:
+            self.add_notice("À vérifier : ces valeurs du résumé n'apparaissent pas dans la conversation : "
+                            + ", ".join(missing[:8]), YELLOW)
+        self.update_status()
+        self.save_session()
+        self.call_after_refresh(self._follow)
+
+    # ------------------------------------------------------------------ sessions (reprise)
+    def save_session(self) -> None:
+        """Enregistre la conversation après chaque réponse (Documents\\Promethee\\sessions), pour /reprendre."""
+        if not self.messages and not self.summary:
+            return
+        data = {"version": 1, "id": self.session_id, "model": self.model, "cwd": str(self.cwd),
+                "created": self.session_created, "updated": dt.datetime.now().isoformat(timespec="seconds"),
+                "title": self.session_title, "summary": self.summary, "messages": self.messages}
+        try:
+            SESSIONS_DIR.mkdir(parents=True, exist_ok=True)
+            path = SESSIONS_DIR / f"{self.session_id}.json"
+            tmp = path.with_suffix(".tmp")
+            tmp.write_text(json.dumps(data, ensure_ascii=False, indent=1), encoding="utf-8")
+            os.replace(tmp, path)
+        except (OSError, TypeError, ValueError) as err:
+            self.add_notice(f"Sauvegarde automatique impossible : {err}", YELLOW)
+
+    def cmd_resume(self, arg: str = "") -> None:
+        if self.generating:
+            self.add_notice("Attends la fin de la réponse avant de changer de conversation.", YELLOW)
+            return
+        sessions = [s for s in list_sessions(9) if s.get("id") != self.session_id]
+        if not sessions:
+            self.add_notice("Aucune autre conversation enregistrée à reprendre.", YELLOW)
+            return
+        options = []
+        for s in sessions:
+            n = sum(1 for m in s.get("messages") or [] if m.get("role") == "user")
+            title = (s.get("title") or "(sans titre)")[:60]
+            label = f"{describe_when(s.get('updated', ''))} · {title}"
+            if n:
+                label += f" · {n} message{'s' if n > 1 else ''}"
+            if s.get("summary"):
+                label += " · compactée"
+            if s.get("model") and s.get("model") != self.model:
+                label += f" · {s['model']}"
+            options.append((s.get("id", ""), label))
+        options.append(("no", "Annuler (Esc)"))
+        by_id = {s.get("id"): s for s in sessions}
+
+        def chosen(decision: str) -> None:
+            if decision in by_id:
+                self.call_later(self.load_session, by_id[decision])
+
+        self.ask("Reprendre une conversation", None, "Quelle conversation reprendre ?", options, chosen, enter="reprendre")
+
+    async def load_session(self, data: dict) -> None:
+        if self.generating:
+            self.add_notice("Attends la fin de la réponse avant de changer de conversation.", YELLOW)
+            return
+        self.messages = [m for m in data.get("messages") or [] if isinstance(m, dict) and m.get("role")]
+        self.summary = data.get("summary") or ""
+        self.session_id = data.get("id") or new_session_id()
+        self.session_created = data.get("created") or dt.datetime.now().isoformat(timespec="seconds")
+        self.session_title = data.get("title") or ""
+        self.allow_edits = False
+        self.last_output = ""
+        self.tasks = []
+        self.render_tasks()
+        self.last_answer = next((m["content"] for m in reversed(self.messages)
+                                 if m["role"] == "assistant" and (m.get("content") or "").strip()), "")
+        cwd = Path(data.get("cwd") or "")
+        if data.get("cwd") and cwd.is_dir():
+            self.cwd = cwd
+        await self.chat.remove_children()
+        await self.chat.mount_all(list(self._welcome_widgets()))
+        if self.summary:
+            await self.chat.mount(Static(Text.assemble(("⎿  ", DIM), ("Début de la conversation compacté. Résumé :", DIM)),
+                                         classes="notice"))
+            await self.chat.mount(Markdown(self.summary, classes="notice-md"))
+        await self.chat.mount_all(self._replay_widgets())
+        when = describe_when(data.get("updated", ""))
+        self.add_notice(f"Conversation reprise ({when}) : la suite sera enregistrée avec elle.", GREEN)
+        if data.get("model") and data["model"] != self.model:
+            self.add_notice(f"Elle avait été tenue avec le modèle {data['model']} (tu utilises {self.model} ; "
+                            f"/modele {data['model']} pour changer).", YELLOW)
+        self.ctx_used = self.estimate_tokens()
+        self.update_status()
+        self.chat.scroll_end(animate=False)
+        self.call_after_refresh(self._follow)
+
+    def _replay_widgets(self) -> list[Widget]:
+        """Réaffiche une conversation enregistrée : messages, commandes et leurs résultats."""
+        widgets: list[Widget] = []
+        waiting: list[tuple[str, ToolCallView]] = []  # appels d'outils en attente de leur résultat
+        for m in self.messages:
+            role, content = m.get("role"), m.get("content") or ""
+            if role != "tool":
+                waiting.clear()   # les appels restés sans résultat gardent « Non exécutée »
+            if role == "user":
+                widgets.append(self._replay_shell(content) if content.startswith(SHELL_TAG)
+                               else self.user_widget(m.get("display") or content))
+            elif role == "assistant":
+                if content.strip():
+                    widgets.append(AssistantMessage(content))
+                for call in m.get("tool_calls") or []:
+                    fn = call.get("function") or {}
+                    name = fn.get("name") or "?"
+                    args = fn.get("arguments") or {}
+                    if not isinstance(args, dict):
+                        args = {"commande": str(args)}
+                    if name == AGENT_TOOL:
+                        view = AgentView(str(args.get("agent") or "?"), str(args.get("tache") or ""))
+                        view._initial = lambda v: v.set_done(-1, 0, 0, "Non terminé", DIM)
+                        waiting.append((name, view))
+                        widgets.append(view)
+                        continue
+                    if name == WEB_TOOL:
+                        # Recherche web : requête, sources et lieu viennent du message lui-même (clé locale « search »)
+                        search = m.get("search") if isinstance(m.get("search"), dict) else None
+                        view = SearchView(str(args.get("requete") or ""), search, replay=True)
+                        waiting.append((name, view))
+                        widgets.append(view)
+                        continue
+                    if name in SEARCH_TOOL_NAMES:
+                        view = ToolCallView(search_desc(name, args, str(args.get("dossier") or "")), "Chercher", "")
+                    elif name in FILE_TOOL_NAMES:
+                        label = {READ_TOOL: "Lire", WRITE_TOOL: "Écrire", EDIT_TOOL: "Modifier"}[name]
+                        shown = show_path(resolve_path(str(args.get("chemin") or "?"), self.cwd), self.cwd)
+                        view = ToolCallView(shown, label, "")
+                    else:
+                        view = ToolCallView(str(args.get("commande") or ""), "PowerShell", "")
+                    view._initial = lambda v: v.set_skipped("Non exécutée")
+                    waiting.append((name, view))
+                    widgets.append(view)
+            elif role == "tool" and waiting:
+                name, view = waiting.pop(0)
+                if name == WEB_TOOL:
+                    continue   # son résultat est déjà affiché par la vue de la recherche
+                view._initial = self._replayed_result(name, content)
+                report = content.split("\n", 1)[-1]
+                if m.get("direct") and not report.startswith(("L'utilisateur a refusé", "(Agent interrompu")):
+                    widgets.append(AssistantMessage(report))  # rapport d'un agent lancé avec @agent-nom
+        return widgets
+
+    @staticmethod
+    def _replayed_result(name: str, content: str):
+        if name == AGENT_TOOL:
+            report = content.split("\n", 1)[-1]
+            if report.startswith("L'utilisateur a refusé"):
+                return lambda v: v.set_done(-1, 0, 0, "Arrêté : tu as refusé une de ses actions", YELLOW)
+            if report.startswith("(Agent interrompu"):
+                return lambda v: v.set_done(-1, 0, 0, "Interrompu", DIM)
+            return lambda v: v.set_done(-1, 0, 0)
+        first = content.split("\n", 1)[0]
+        if name in SEARCH_TOOL_NAMES:
+            found = re.search(r"\((\d+)", first)
+            if content.startswith(("Fichiers ", "Lignes ")) and found:
+                what = "fichier" if content.startswith("Fichiers ") else "ligne"
+                n = int(found.group(1))
+                return lambda v: v.set_text(f"{n} {what}{'s' if n > 1 else ''} trouvé{'e' if what == 'ligne' else ''}"
+                                            f"{'s' if n > 1 else ''}")
+            return lambda v: v.set_text(first[:140], None, DIM)
+        if content.startswith("L'utilisateur a refusé"):
+            return lambda v: v.set_denied()
+        if content.startswith("Non exécutée : la politique"):
+            reason = re.search(r"Raisons : (.*?)(?: L'utilisateur peut| Ne contourne pas|$)", content, re.S)
+            return lambda v: v.set_refused(reason.group(1).strip() if reason else "")
+        if name in FILE_TOOL_NAMES:
+            if content.startswith("Contenu de "):
+                n = re.search(r"\((\d+) lignes\)", first)
+                return lambda v: v.set_text(f"Lu ({n.group(1)} lignes)" if n else "Lu")
+            if content.startswith("Fichier "):
+                n = re.search(r"\(\+(\d+) −(\d+) lignes\)", first)
+                summary = (change_summary(int(n.group(1)), int(n.group(2)), content.startswith("Fichier créé"))
+                           if n else first.rstrip("."))
+                return lambda v: v.set_text(summary)
+            if content.startswith("Aucun changement"):
+                return lambda v: v.set_text("Aucun changement", None, DIM)
+            return lambda v: v.set_skipped(first[:140] + ("…" if len(first) > 140 else ""))
+        if content.startswith(("Code de sortie", "Commande non terminée")):
+            code, body = parse_tool_result(content)
+            note = re.search(r"\((.+)\)$", first)
+            body = "" if body.strip() == "(aucune sortie)" else body
+            return lambda v: v.set_result(code, body, note.group(1) if note and code is None else "")
+        return lambda v: v.set_skipped(first[:200])
+
+    def _replay_shell(self, content: str) -> Widget:
+        match = re.match(re.escape(SHELL_TAG) + r" `(?P<cmd>.*?)`\n(?:Code de sortie : (?P<code>-?\d+)|Commande non terminée)"
+                         r"(?: \((?P<note>[^\n]*)\))?\n(?P<out>.*)$", content, re.S)
+        if not match:
+            return self.user_widget(content)
+        code = int(match["code"]) if match["code"] is not None else None
+        out = "" if match["out"].strip() == "(aucune sortie)" else match["out"]
+        return ToolCallView(match["cmd"], "!", "", initial=lambda v: v.set_result(code, out, match["note"] or ""))

package/tui/promethee/app/modele.py

@@ -0,0 +1,108 @@
+"""Chargement, liste et changement de modèle."""
+from __future__ import annotations
+
+import re
+import urllib.error
+
+from textual import work
+
+from ..ollama import OLLAMA, api, context_from_env, http_error_text
+from ..theme import RED
+
+
+class Modele:
+    """Partie de PrometheeApp : chargement, liste et changement de modèle."""
+
+    # ------------------------------------------------------------------ modèle
+    def _set_model_state(self, model: str, state: str) -> None:
+        """État affiché du modèle. Ignoré si tu as changé de modèle entre-temps (deux /modele rapprochés)."""
+        if model == self.model:
+            self.model_state = state
+            self.update_status()
+
+    def read_model(self, model: str) -> tuple[str, str]:
+        """Lit les caractéristiques du modèle auprès d'Ollama (fil de travail).
+        Renvoie ("", "") si tout va bien, sinon (état à afficher, message d'erreur)."""
+        try:
+            info = api("/api/show", {"model": model}, timeout=15)
+        except urllib.error.HTTPError as err:
+            return "introuvable", f"Modèle « {model} » : {http_error_text(err)}. Tape /modele pour voir la liste."
+        except Exception as err:
+            return "Ollama injoignable", (f"Ollama ne répond pas sur {OLLAMA} ({err}). Lance l'application Ollama : "
+                                          "Prométhée réessaiera à ton prochain message.")
+        if model != self.model:
+            return "", ""
+        match = re.search(r"num_ctx\s+(\d+)", info.get("parameters") or "")
+        self.num_ctx = int(match.group(1)) if match else context_from_env()
+        details = info.get("details") or {}
+        self.model_desc = " ".join(x for x in (details.get("parameter_size"), details.get("quantization_level")) if x)
+        self.model_system = info.get("system") or ""
+        self.supports_tools = "tools" in (info.get("capabilities") or [])
+        self.supports_thinking = "thinking" in (info.get("capabilities") or [])
+        self._caps.pop(model, None)
+        return "", ""
+
+    @work(thread=True, exclusive=True, group="model")
+    def load_model(self) -> None:
+        model = self.model
+        state, problem = self.read_model(model)
+        if problem:
+            self.call_from_thread(self._set_model_state, model, state)
+            if model == self.model:
+                self.call_from_thread(self.add_notice, problem, f"bold {RED}")
+            return
+        self.call_from_thread(self._set_model_state, model, "chargement…")
+        try:
+            api("/api/chat", {"model": model, "messages": []}, timeout=300)  # précharge en mémoire GPU
+            self._loaded_model = model
+            self.call_from_thread(self._set_model_state, model, "")
+            self._check_gpu(model)
+        except Exception as err:
+            self.call_from_thread(self._set_model_state, model, "erreur de chargement")
+            if model == self.model:
+                self.call_from_thread(self.add_notice, f"Chargement impossible : {err}", f"bold {RED}")
+
+    @work(thread=True, exclusive=True, group="model")
+    def list_models(self, switch_to: str | None) -> None:
+        try:
+            models = sorted((m for m in api("/api/tags", timeout=10).get("models", []) if m.get("name")),
+                            key=lambda m: m["name"])
+        except Exception as err:
+            self.call_from_thread(self.add_notice, f"Ollama ne répond pas sur {OLLAMA} ({err}).", f"bold {RED}")
+            return
+        names = [m["name"] for m in models]
+        short = [n[:-7] if n.endswith(":latest") else n for n in names]
+        if switch_to:
+            wanted = switch_to[:-7] if switch_to.endswith(":latest") else switch_to
+            if wanted not in short:
+                self.call_from_thread(self.add_notice, f"Modèle « {switch_to} » introuvable. Tape /modele pour voir la liste.", f"bold {RED}")
+                return
+            self.call_from_thread(self._switch_model, wanted)
+            return
+        try:
+            loaded = {m.get("name") for m in api("/api/ps", timeout=6).get("models") or []}
+        except Exception:
+            loaded = set()   # la liste reste utile sans savoir lesquels sont en mémoire
+
+        def detail(m: dict) -> str:
+            d = m.get("details") or {}
+            parts = [x for x in (d.get("parameter_size"), d.get("quantization_level")) if x]
+            if m.get("size"):
+                parts.append(f"{m['size'] / 1e9:.1f} Go".replace(".", ","))
+            if m["name"] in loaded:
+                parts.append("en mémoire")
+            return " · " + " · ".join(parts) if parts else ""
+
+        lines = "\n".join(f"- `{n}`{detail(m)}" + ("  ← actuel" if n == self.model else "")
+                          + ("  ← IA de code" if n == self.code_model and n != self.model else "")
+                          for n, m in zip(short, models))
+        self.call_from_thread(self.add_notice_md, f"**Modèles installés** (change avec `/modele <nom>`)\n\n{lines}")
+
+    def _switch_model(self, name: str) -> None:
+        self.model = name
+        self.num_ctx = None
+        self.last_tps = None
+        self.model_state = "chargement…"
+        self.update_status()
+        self.add_notice(f"Modèle changé : {name} (la conversation continue, /clear pour repartir de zéro)")
+        self.load_model()

package/tui/promethee/app/notes.py

@@ -0,0 +1,63 @@
+"""Mémoire « # » : enregistrer, afficher, ouvrir."""
+from __future__ import annotations
+
+import os
+import subprocess
+
+from rich.text import Text
+
+from ..config import CREATE_NO_WINDOW
+from ..fichiers import HOME, new_file_format, show_path, write_text_file
+from ..memoire import GLOBAL_MEMORY, MEMORY_HEADER, MEMORY_NAME, add_memory_note, read_memory
+from ..theme import DIM, GREEN, MEMORY_COLOR, RED
+
+
+class Notes:
+    """Partie de PrometheeApp : mémoire « # » : enregistrer, afficher, ouvrir."""
+
+    # ------------------------------------------------------------------ mémoire « # »
+    def ask_memory_target(self, note: str) -> None:
+        local = self.cwd / MEMORY_NAME
+        targets = {"global": ("globale", GLOBAL_MEMORY)}
+        options = [("global", "Mémoire globale : pour toutes les conversations")]
+        body = Text.assemble((f"  {note}\n\n", "bold"), (f"  globale : {GLOBAL_MEMORY}", DIM))
+        if os.path.normcase(str(local)) != os.path.normcase(str(GLOBAL_MEMORY)):
+            targets["local"] = ("du dossier", local)
+            options.append(("local", f"Mémoire de ce dossier : seulement quand tu travailles dans {self.cwd.name or self.cwd}"))
+            body.append(f"\n  dossier : {local}", style=DIM)
+        options.append(("no", "Annuler (Esc)"))
+
+        def chosen(decision: str) -> None:
+            if decision not in targets:
+                return
+            label, path = targets[decision]
+            try:
+                add_memory_note(path, note)
+            except (OSError, ValueError) as err:
+                self.add_notice(f"Impossible d'écrire dans {path} : {err}", f"bold {RED}")
+                return
+            self.add_notice(f"# {note}  →  noté dans la mémoire {label} ({show_path(path, HOME)})", MEMORY_COLOR)
+            self.ctx_used = max(self.ctx_used, self.estimate_tokens())
+            self.update_status()
+
+        self.ask("Ajouter à la mémoire", body, "Où enregistrer cette information ?", options, chosen)
+
+    def show_memory(self) -> None:
+        memory = read_memory(self.cwd)
+        if not memory:
+            self.add_notice(f"Mémoire vide. Ajoute une information en commençant ton message par # (par exemple "
+                            f"« # je suis étudiant en BTS SIO »). Fichier : {GLOBAL_MEMORY}")
+            return
+        parts = [f"**Mémoire {label}** (`{path}`)\n\n{text}" for label, path, text in memory]
+        self.add_notice_md("\n\n".join(parts) + "\n\n*`/memoire ouvrir` pour la modifier · `# …` pour ajouter une ligne*")
+
+    def open_memory(self) -> None:
+        try:
+            if not GLOBAL_MEMORY.is_file():
+                write_text_file(GLOBAL_MEMORY, MEMORY_HEADER, *new_file_format(GLOBAL_MEMORY))
+            subprocess.Popen(["notepad.exe", str(GLOBAL_MEMORY)], creationflags=CREATE_NO_WINDOW)
+        except OSError as err:
+            self.add_notice(f"Impossible d'ouvrir {GLOBAL_MEMORY} : {err}", f"bold {RED}")
+            return
+        self.add_notice(f"Mémoire ouverte dans le Bloc-notes ({GLOBAL_MEMORY}). Les changements comptent dès ton "
+                        "prochain message.", GREEN)