[IMP] script todo: suivi install — fenêtre des lignes d'erreurs/avertissements

La colonne ⚠ donne le NOMBRE ; on peut désormais LIRE les lignes associées.
Touche « d » (ou indice dans la barre) : ouvre une petite fenêtre modale
(ErrorLinesScreen) listant, pour la VM sélectionnée, les lignes d'erreurs
puis d'avertissements (numéro de ligne + texte), défilable. Échap/q ferme.

- scan_log_error_lines() : mêmes détection + listes d'ignore que la suite de
  tests ERPLibre, mais retient les lignes (bornées à 500) avec leur numéro.
- Scan à la demande à l'ouverture -> toujours à jour (marche même pendant
  l'installation).

Validé headless : modale s'ouvre avec les lignes, se ferme à Échap.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

script/qemu/deploy_qemu.py

@@ -831,10 +831,21 @@ def download_image(
         else "\n  Vérifiez la connectivité (IPv6 ?), réessayez plus tard, ou"
         " fournissez un chemin d'image local en argument positionnel."
     )
+    # Chemin visé + commande prête à copier pour reprendre le téléchargement
+    # manuellement (reprise si un .part existe), puis relancer le déploiement
+    # (l'image complète en cache sera réutilisée). curl -C - reprend, -f
+    # échoue proprement sur une erreur HTTP.
+    resume = (
+        f"\n  Destination : {dest}"
+        f"\n  Reprendre le téléchargement manuellement :"
+        f"\n    sudo curl -fL -C - -o {dest} \\\n      {urls[0]}"
+        "\n  puis relancez le déploiement (l'image en cache sera réutilisée)."
+    )
     sys.exit(
         "\nÉchec du téléchargement depuis tous les miroirs :\n  "
         + "\n  ".join(errors)
         + hint
+        + resume
     )
 
 
@@ -959,6 +970,39 @@ def build_cloud_config(
         "runcmd:",
         "  - systemctl enable --now ssh 2>/dev/null"
         " || systemctl enable --now sshd 2>/dev/null || true",
+        # qemu-guest-agent : installé + activé APRÈS sshd (donc SSH reste
+        # disponible tout de suite, sans attendre le réseau). Tout est
+        # « || true » : si l'installation échoue (réseau lent/absent), le boot
+        # n'est pas bloqué. La plupart des images cloud l'incluent déjà.
+        # Rafraîchit d'abord l'index (les images cloud n'ont PAS de listes apt
+        # -> sinon « Unable to locate package »), puis installe. timeout : un
+        # miroir lent ne bloque JAMAIS cloud-init. Non fatal (|| true).
+        # Sous-shell ( ) et NON accolades { } : « { » est un indicateur YAML.
+        "  - (command -v apt-get >/dev/null && (timeout 120 apt-get update -qq"
+        " || true; timeout 300 apt-get install -y qemu-guest-agent)) ||"
+        " (command -v dnf >/dev/null && timeout 300 dnf install -y"
+        " qemu-guest-agent) || (command -v pacman >/dev/null && timeout 300"
+        " pacman -Sy --noconfirm qemu-guest-agent) || true",
+        # Autorise guest-exec (bloqué par défaut sur certaines distros).
+        # On VIDE la liste de blocage (block-rpcs/blacklist) plutôt que
+        # d'utiliser allow-rpcs (liste BLANCHE : casserait les autres RPC).
+        # Les deux clés couvrent les versions anciennes (blacklist) et
+        # récentes (block-rpcs) de qemu-ga.
+        "  - mkdir -p /etc/qemu && printf '[general]\\nblock-rpcs=\\n"
+        "blacklist=\\n' > /etc/qemu/qemu-ga.conf || true",
+        # Fedora/RHEL bloquent guest-exec via /etc/sysconfig/qemu-ga.
+        # « test -f » et NON « [ -f … ] » : en YAML, «  - [ » démarre une
+        # séquence en flux -> user-data invalide -> cloud-init rejeté (aucun
+        # utilisateur créé, VM figée, login console impossible).
+        "  - test -f /etc/sysconfig/qemu-ga && sed -i"
+        " 's/^BLACKLIST_RPC=.*/BLACKLIST_RPC=/'"
+        " /etc/sysconfig/qemu-ga || true",
+        "  - systemctl enable qemu-guest-agent 2>/dev/null"
+        " || systemctl enable qemu-ga 2>/dev/null || true",
+        # restart (et non enable --now) : recharge la config si l'agent était
+        # déjà démarré par l'image cloud.
+        "  - systemctl restart qemu-guest-agent 2>/dev/null"
+        " || systemctl restart qemu-ga 2>/dev/null || true",
     ]
     return "\n".join(lines) + "\n"
 
@@ -1148,6 +1192,11 @@ def virt_install(
         args.graphics,
         "--console",
         f"pty,target_type={console_target}",
+        # Canal virtio de l'agent invité (org.qemu.guest_agent.0) : permet à
+        # virsh de piloter la VM SANS réseau (ex. étendre le FS invité après
+        # un redimensionnement de disque). Inoffensif si l'agent est absent.
+        "--channel",
+        "unix,target.type=virtio,target.name=org.qemu.guest_agent.0",
     ]
     if args.arch == "s390x":
         # s390x (IBM Z) : machine s390-ccw-virtio, amorçage IPL/zipl depuis le

script/todo/qemu_install_monitor.py

@@ -13,9 +13,11 @@ quitter le dashboard n'arrête rien, on peut le rouvrir pour ré-attacher.
 """
 from __future__ import annotations
 
+import asyncio
 import json
 import os
 import shlex
+import shutil
 import subprocess
 import time
 from pathlib import Path
@@ -148,14 +150,23 @@ def launch_installs(vms: list[dict], branch: str, remote_cmd: str) -> str:
 
 
 def read_status(log_path: str) -> tuple[str, int | None]:
-    """(état, code) d'un log : pending / running / done / failed."""
+    """(état, code) d'un log : pending / running / done / failed. Ne lit que
+    la FIN du fichier (le marqueur de sortie est sur la dernière ligne) : lire
+    tout le log de 30 VM chaque seconde saturait la boucle d'événements du TUI
+    (lag, interface figée quand l'I/O ralentit)."""
     try:
-        data = Path(log_path).read_text(errors="replace")
+        size = os.path.getsize(log_path)
+        if size == 0:
+            return "pending", None
+        with open(log_path, "rb") as fh:
+            if size > 4096:
+                fh.seek(-4096, os.SEEK_END)
+            tail = fh.read().decode(errors="replace")
     except OSError:
         return "pending", None
-    if not data.strip():
+    if not tail.strip():
         return "pending", None
-    for line in reversed(data.splitlines()):
+    for line in reversed(tail.splitlines()):
         if EXIT_MARKER in line:
             try:
                 code = int(line.split()[-1])
@@ -165,19 +176,363 @@ def read_status(log_path: str) -> tuple[str, int | None]:
     return "running", None
 
 
+# Listes d'ignore reprises de script/test/run_parallel_test.py (erreurs/
+# avertissements connus et bénins) : on réutilise la MÊME logique de détection
+# que la suite de tests ERPLibre pour analyser les logs d'installation.
+_LST_IGNORE_WARNING = (
+    "have the same label:",
+    "odoo.addons.code_generator.extractor_module_file: Ignore next error about"
+    " ALTER TABLE DROP CONSTRAINT.",
+)
+_LST_IGNORE_ERROR = (
+    "fetchmail_notify_error_to_sender",
+    'odoo.sql_db: bad query: ALTER TABLE "db_backup" DROP CONSTRAINT'
+    ' "db_backup_db_backup_name_unique"',
+    'ERROR: constraint "db_backup_db_backup_name_unique" of relation'
+    ' "db_backup" does not exist',
+    'odoo.sql_db: bad query: ALTER TABLE "db_backup" DROP CONSTRAINT'
+    ' "db_backup_db_backup_days_to_keep_positive"',
+    'ERROR: constraint "db_backup_db_backup_days_to_keep_positive" of relation'
+    ' "db_backup" does not exist',
+    "odoo.addons.code_generator.extractor_module_file: Ignore next error about"
+    " ALTER TABLE DROP CONSTRAINT.",
+)
+
+
+def scan_log_error_lines(log_path: str, cap: int = 500) -> tuple[list, list]:
+    """(lignes_erreur, lignes_avertissement) d'un log, même détection que
+    scan_log_errors mais on RETIENT les lignes (bornées à `cap`) pour les
+    afficher. Chaque ligne est préfixée de son numéro (1-indexé)."""
+    try:
+        text = Path(log_path).read_text(errors="replace")
+    except OSError:
+        return [], []
+    errs, warns = [], []
+    for i, line in enumerate(text.splitlines(), 1):
+        if EXIT_MARKER in line:
+            continue
+        low = line.lower()
+        if (
+            "error" in low
+            and not any(ig in line for ig in _LST_IGNORE_ERROR)
+            and len(errs) < cap
+        ):
+            errs.append(f"{i}: {line}")
+        if (
+            "warning" in low
+            and not any(ig in line for ig in _LST_IGNORE_WARNING)
+            and len(warns) < cap
+        ):
+            warns.append(f"{i}: {line}")
+    return errs, warns
+
+
+def scan_log_errors(log_path: str) -> tuple[int, int]:
+    """(nb_erreurs, nb_avertissements) dans un log d'installation, en
+    réutilisant la détection de la suite de tests ERPLibre : sous-chaîne
+    « error »/« warning » (insensible à la casse) moins les listes d'ignore.
+    Lit le fichier COMPLET (appelé une seule fois, à la complétion d'une VM)."""
+    try:
+        text = Path(log_path).read_text(errors="replace")
+    except OSError:
+        return 0, 0
+    nerr = nwarn = 0
+    for line in text.splitlines():
+        low = line.lower()
+        if EXIT_MARKER in line:
+            continue
+        if "error" in low and not any(
+            ig in line for ig in _LST_IGNORE_ERROR
+        ):
+            nerr += 1
+        if "warning" in low and not any(
+            ig in line for ig in _LST_IGNORE_WARNING
+        ):
+            nwarn += 1
+    return nerr, nwarn
+
+
+def _read_new(path: str, offset: int) -> tuple[str, int]:
+    """Lit le log à partir de `offset` (lecture incrémentale). Renvoie
+    (nouveau_texte, nouvel_offset). Bloquant -> à appeler dans un thread."""
+    try:
+        with open(path, "r", errors="replace") as fh:
+            fh.seek(offset)
+            data = fh.read()
+            return data, fh.tell()
+    except OSError:
+        return "", offset
+
+
+# --------------------------------------------------------------------------- #
+# Télémétrie, historique de durées (ETA), navigateur CLI
+# --------------------------------------------------------------------------- #
+def _stats_path() -> Path:
+    """Fichier d'historique persistant des installations. DÉDIÉ dans
+    .venv.erplibre du dépôt (repli sur ~/.erplibre si le venv est absent)."""
+    try:
+        venv = Path(__file__).resolve().parents[2] / ".venv.erplibre"
+        venv.mkdir(parents=True, exist_ok=True)
+        return venv / "qemu_install_stats.json"
+    except OSError:
+        return session_dir() / "stats.json"
+
+
+def load_stats() -> dict:
+    try:
+        return json.loads(_stats_path().read_text())
+    except (OSError, ValueError):
+        return {}
+
+
+def record_duration(distro, version, arch, secs) -> None:
+    """Enregistre une install (distro + version + archi + durée + horodatage)
+    dans l'historique, pour l'ETA et les moyennes par archi/distro. Garde les
+    500 derniers runs."""
+    data = load_stats()
+    runs = data.setdefault("runs", [])
+    runs.append(
+        {
+            "distro": distro or "?",
+            "version": version or "?",
+            "arch": arch or "?",
+            "seconds": int(secs),
+            "ts": int(time.time()),
+        }
+    )
+    data["runs"] = runs[-500:]
+    try:
+        _stats_path().write_text(json.dumps(data, ensure_ascii=False))
+    except OSError:
+        pass
+
+
+def _runs(stats=None):
+    return (stats or load_stats()).get("runs", []) or []
+
+
+def eta_reference(stats, arch):
+    """Durée d'install de RÉFÉRENCE (médiane) pour cette archi ; repli toutes
+    archis confondues. None si aucun historique."""
+    runs = _runs(stats)
+    secs = [r["seconds"] for r in runs if r.get("arch") == arch]
+    if not secs:
+        secs = [r["seconds"] for r in runs]
+    if not secs:
+        return None
+    s = sorted(secs)
+    return s[len(s) // 2]
+
+
+def _avg(field, value, stats=None):
+    secs = [r["seconds"] for r in _runs(stats) if r.get(field) == value]
+    return (sum(secs) / len(secs)) if secs else None
+
+
+def avg_by_arch(arch, stats=None):
+    """(moyenne_secondes, nb_runs) pour cette archi, ou (None, 0)."""
+    secs = [r["seconds"] for r in _runs(stats) if r.get("arch") == arch]
+    return (sum(secs) / len(secs), len(secs)) if secs else (None, 0)
+
+
+def avg_by_distro(distro, stats=None):
+    """(moyenne_secondes, nb_runs) pour cette distro, ou (None, 0)."""
+    secs = [r["seconds"] for r in _runs(stats) if r.get("distro") == distro]
+    return (sum(secs) / len(secs), len(secs)) if secs else (None, 0)
+
+
+def avg_by_version(distro, version, stats=None):
+    """(moyenne_secondes, nb_runs) pour cette (distro, version), ou (None, 0)."""
+    secs = [
+        r["seconds"]
+        for r in _runs(stats)
+        if r.get("distro") == distro and r.get("version") == version
+    ]
+    return (sum(secs) / len(secs), len(secs)) if secs else (None, 0)
+
+
+def last_run(stats=None):
+    """Dernier run enregistré (dict) ou None."""
+    runs = _runs(stats)
+    return runs[-1] if runs else None
+
+
+def _fmt_size(nbytes) -> str:
+    """Octets -> « 1.2G » / « 345M » / « 12K »."""
+    if nbytes is None:
+        return "-"
+    for unit, div in (("T", 1 << 40), ("G", 1 << 30), ("M", 1 << 20)):
+        if nbytes >= div:
+            return f"{nbytes / div:.1f}{unit}"
+    return f"{nbytes // 1024}K"
+
+
+def _fmt_secs(secs) -> str:
+    """Secondes -> « 45s » / « 12m » / « 1h05 »."""
+    secs = int(secs)
+    if secs < 60:
+        return f"{secs}s"
+    if secs < 3600:
+        return f"{secs // 60}m"
+    return f"{secs // 3600}h{(secs % 3600) // 60:02d}"
+
+
+def vm_disk_path(vm: dict) -> str:
+    """Chemin du qcow2 de la VM (défaut libvirt si non fourni)."""
+    return vm.get("disk") or f"/var/lib/libvirt/images/{vm['name']}.qcow2"
+
+
+def disk_actual_size(path: str) -> int | None:
+    """Taille RÉELLEMENT occupée du qcow2 (creux) via st_blocks."""
+    try:
+        st = os.stat(path)
+        return int(getattr(st, "st_blocks", 0)) * 512
+    except OSError:
+        return None
+
+
+# Navigateurs web en ligne de commande, par ordre de préférence (rendu JS
+# d'abord — utile pour l'UI Odoo — puis navigateurs texte classiques).
+CLI_BROWSERS = ("browsh", "carbonyl", "w3m", "links", "elinks", "lynx")
+
+
+def cli_browser() -> str | None:
+    """Premier navigateur CLI disponible dans le PATH, sinon None."""
+    for name in CLI_BROWSERS:
+        if shutil.which(name):
+            return name
+    return None
+
+
+def _os_id() -> str:
+    """ID de la distribution hôte (/etc/os-release), ex. « ubuntu », « fedora »."""
+    try:
+        for line in open("/etc/os-release", encoding="utf-8"):
+            if line.startswith("ID="):
+                return line.split("=", 1)[1].strip().strip('"').lower()
+    except OSError:
+        pass
+    return ""
+
+
+# Navigateurs CLI installables via apt/dnf/pacman (nom de paquet = binaire).
+# browsh/carbonyl ne sont pas dans les dépôts standard -> non proposés ici.
+INSTALLABLE_BROWSERS = (
+    ("w3m", "w3m — léger, rend un peu de HTML"),
+    ("lynx", "lynx — navigateur texte"),
+    ("links", "links — texte / graphique"),
+    ("elinks", "elinks — texte, onglets"),
+)
+
+
+def browser_install_command(browser="w3m") -> list | None:
+    """Commande d'installation du navigateur CLI `browser` adaptée à l'OS hôte :
+    apt (Ubuntu/Debian), dnf (Fedora), pacman (Arch). None si gestionnaire
+    inconnu."""
+    apt = ["sudo", "apt-get", "install", "-y", browser]
+    dnf = ["sudo", "dnf", "install", "-y", browser]
+    pac = ["sudo", "pacman", "-S", "--needed", "--noconfirm", browser]
+    by_id = {
+        "ubuntu": apt,
+        "debian": apt,
+        "linuxmint": apt,
+        "fedora": dnf,
+        "arch": pac,
+    }
+    cmd = by_id.get(_os_id())
+    if cmd:
+        return cmd
+    if shutil.which("apt-get"):
+        return apt
+    if shutil.which("dnf"):
+        return dnf
+    if shutil.which("pacman"):
+        return pac
+    return None
+
+
+def virsh_domstates() -> dict:
+    """{nom: état} de tous les domaines libvirt (« virsh list --all »). Sert à
+    détecter une VM EN PAUSE ou EFFACÉE pendant le suivi. Un seul appel virsh
+    pour tout le parc (à interroger à intervalle LENT)."""
+    try:
+        res = subprocess.run(
+            ["sudo", "virsh", "list", "--all"],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return {}
+    states = {}
+    for line in res.stdout.splitlines():
+        parts = line.split()
+        # Ignore l'en-tête (« Id Name State ») et le séparateur (« ---- »,
+        # un seul token). Une VM éteinte a « - » en Id : à NE PAS ignorer.
+        if len(parts) < 3 or parts[0] == "Id":
+            continue
+        states[parts[1]] = " ".join(parts[2:])
+    return states
+
+
 # --------------------------------------------------------------------------- #
 # Dashboard Textual
 # --------------------------------------------------------------------------- #
-def run_monitor(manifest_path: str) -> None:
+def run_monitor(manifest_path: str, run_app: bool = True):
-    """Ouvre le dashboard Textual sur un manifeste d'installation."""
+    """Ouvre le dashboard Textual sur un manifeste d'installation. `run_app`
+    à False renvoie l'instance sans la lancer (tests headless)."""
     from textual.app import App, ComposeResult
-    from textual.containers import Horizontal
+    from textual.containers import Horizontal, Vertical
+    from textual.screen import ModalScreen
     from textual.widgets import DataTable, Footer, Header, RichLog, Static
 
     manifest = json.loads(Path(manifest_path).read_text())
     started = manifest.get("started", time.time())
     vms = manifest["vms"]
 
+    class ErrorLinesScreen(ModalScreen):
+        """Petite fenêtre modale : liste les LIGNES d'erreurs/avertissements
+        d'une VM pour les lire (défilable). Échap / q pour fermer."""
+
+        BINDINGS = [
+            ("escape", "dismiss", "Fermer"),
+            ("q", "dismiss", "Fermer"),
+        ]
+
+        def __init__(self, vm_name, errs, warns):
+            super().__init__()
+            self._vm = vm_name
+            self._errs = errs
+            self._warns = warns
+
+        def compose(self) -> ComposeResult:
+            with Vertical(id="errbox"):
+                yield Static(
+                    f"  {self._vm} — ⚠ {len(self._errs)} "
+                    f"{t('errors')} · ⚡ {len(self._warns)} {t('warnings')}"
+                    f"   ({t('Esc to close')})",
+                    id="errtitle",
+                )
+                yield RichLog(
+                    id="errlog", highlight=False, markup=False, wrap=True
+                )
+
+        def on_mount(self) -> None:
+            log = self.query_one("#errlog", RichLog)
+            if self._errs:
+                log.write(f"── {t('errors').capitalize()} ──")
+                for line in self._errs:
+                    log.write(line)
+            if self._warns:
+                log.write(f"── {t('warnings').capitalize()} ──")
+                for line in self._warns:
+                    log.write(line)
+            if not self._errs and not self._warns:
+                log.write(t("No error detected."))
+
+        def action_dismiss(self) -> None:
+            self.dismiss()
+
     ICON = {
         "pending": "⏳",
         "running": "⏳",
@@ -187,15 +542,29 @@ def run_monitor(manifest_path: str) -> None:
 
     class Monitor(App):
         CSS = """
-        DataTable { width: 40; border: solid $accent; }
+        DataTable { width: 74; height: 1fr; overflow-x: auto; border: solid $accent; }
         RichLog { border: solid $accent; }
+        #telemetry { height: 1; color: $text-muted; }
+        #stats { height: 1; color: $accent; }
+        #statsdetail { display: none; height: auto; color: $text-muted; }
         #sshbar { height: 2; color: $text-muted; }
+        ErrorLinesScreen { align: center middle; }
+        #errbox {
+            width: 80%; height: 70%;
+            border: thick $accent; background: $surface;
+        }
+        #errtitle { height: 1; color: $accent; text-style: bold; }
+        #errlog { height: 1fr; border: solid $accent; }
         """
         BINDINGS = [
             ("q", "quit", "Quitter (détaché)"),
             ("s", "ssh", "SSH"),
+            ("w", "web", "Web (navigateur CLI)"),
             ("f", "follow", "Suivre"),
             ("c", "copy_log", "Copier log"),
+            ("d", "details", "Détails erreurs"),
+            ("p", "pause_all", "Pause tout"),
+            ("o", "resume_all", "Reprendre tout"),
         ]
 
         def __init__(self):
@@ -203,28 +572,83 @@ def run_monitor(manifest_path: str) -> None:
             self._offsets = {vm["name"]: 0 for vm in vms}
             self._selected = vms[0]["name"] if vms else None
             self._follow = True
+            # Statuts TERMINAUX mémorisés : une VM finie n'est plus relue
+            # (réduit fortement l'I/O sur un gros parc). Valeur = (état, code,
+            # durée à la complétion).
+            self._final = {}
+            # Cache des cellules AFFICHÉES : on n'appelle update_cell (donc on
+            # ne re-render) que si la valeur CHANGE -> plus de churn de rendu.
+            self._cells = {}
+            # Historique de durées (ETA) + dossier disque à surveiller.
+            self._stats = load_stats()
+            self._disk_dir = os.path.dirname(vm_disk_path(vms[0])) if vms else "/"
+            # État libvirt (running/paused/gone), rafraîchi à intervalle LENT.
+            self._domstate = {}
+            # Erreurs détectées dans le log à la complétion : {nom: (err, warn)}.
+            self._errcount = {}
+            # Sommaire de stats déplié (clic) ou non.
+            self._stats_open = False
+
+        @staticmethod
+        def _fmt(secs):
+            mm, ss = divmod(int(secs), 60)
+            return f"{mm:02d}:{ss:02d}"
+
+        def _set_cell(self, table, name, col, value):
+            key = (name, col)
+            if self._cells.get(key) == value:
+                return
+            self._cells[key] = value
+            table.update_cell(name, col, value)
 
         def compose(self) -> ComposeResult:
             yield Header(show_clock=True)
             table = DataTable(id="vms", cursor_type="row")
             # Clés de colonnes explicites : update_cell() les référence.
-            table.add_column("VM", key="vm")
+            # La colonne « ⚠ » (erreurs détectées) est à GAUCHE d'« État ».
-            table.add_column("État", key="state")
+            # Largeurs FIXES pour les colonnes courtes -> l'État n'est plus
-            table.add_column("Durée", key="elapsed")
+            # tronqué (« ❌ effacée », « ⏸ en pause » lisibles) ; la table
+            # défile horizontalement (overflow-x) pour les noms de VM longs.
+            table.add_column("VM", key="vm", width=26)
+            table.add_column("⚠", key="err", width=4)
+            table.add_column("État", key="state", width=12)
+            table.add_column("Durée", key="elapsed", width=7)
+            table.add_column("Disque", key="disk", width=8)
             for vm in vms:
-                table.add_row(vm["name"], "⏳", "00:00", key=vm["name"])
+                table.add_row(
-            self._log = RichLog(id="log", highlight=False, markup=False)
+                    vm["name"], "", "⏳", "--:--", "-", key=vm["name"]
+                )
+            # max_lines borne la mémoire/rendu (un install verbeux × 30 VM).
+            self._log = RichLog(
+                id="log", highlight=False, markup=False, max_lines=5000
+            )
             with Horizontal():
                 yield table
                 yield self._log
+            # Barre de télémétrie hôte (CPU, disque, ETA parc).
+            yield Static("", id="telemetry")
+            # Sommaire de stats en CHIFFRES (cliquable -> détail).
+            yield Static("", id="stats")
+            yield Static("", id="statsdetail")
             yield Static("", id="sshbar")
             yield Footer()
 
         def on_mount(self) -> None:
-            self.title = "ERPLibre — suivi d'installation"
+            # Le NOMBRE de VM figure dans le titre ; le sous-titre suit la
+            # progression (terminées / total + durée globale).
+            self.title = f"ERPLibre — {t('install monitoring')} ({len(vms)} VM)"
+            self.sub_title = f"0/{len(vms)} {t('completed')}"
             self._refresh_ssh()
             self._load_selected_log(reset=True)
-            self.set_interval(1.0, self._tick)
+            # Table toutes les 2 s (30 lectures de fin de log), suivi du log
+            # sélectionné toutes les 1 s (une seule lecture incrémentale).
+            self.set_interval(2.0, self._tick_table)
+            self.set_interval(1.0, self._tick_log)
+            # État libvirt (pause / effacée) : check LENT (appel virsh) toutes
+            # les 10 s ; le tableau applique le cache à chaque tick (2 s).
+            self.set_interval(10.0, self._tick_domstate)
+            # Premier relevé domstate immédiat (async -> via worker).
+            self.run_worker(self._tick_domstate(), exclusive=False)
 
         # -- helpers -------------------------------------------------------- #
         def _vm_by_name(self, name):
@@ -235,48 +659,239 @@ def run_monitor(manifest_path: str) -> None:
             bar = self.query_one("#sshbar", Static)
             if vm:
                 bar.update(
-                    f"  {vm['ssh']}    (s = SSH · c = copier le log · "
+                    f"  {vm['ssh']}    (s = SSH · w = web :8069 · "
+                    "c = copier le log · d = détails erreurs · "
                     "Maj+glisser = sélectionner)\n"
                     f"  Log : {vm['log']}"
                 )
 
         def _load_selected_log(self, reset=False):
+            # Lecture SYNCHRONE (mount / changement de ligne). Le suivi périodique
+            # passe par _tick_log (async, I/O en thread).
             vm = self._vm_by_name(self._selected)
             if not vm:
                 return
+            name = vm["name"]
             if reset:
                 self._log.clear()
-                self._offsets[vm["name"]] = 0
+                self._offsets[name] = 0
-            try:
+            new, off = _read_new(vm["log"], self._offsets.get(name, 0))
-                data = Path(vm["log"]).read_text(errors="replace")
+            self._offsets[name] = off
-            except OSError:
+            for line in new.splitlines():
-                return
+                if EXIT_MARKER not in line:
-            off = self._offsets[vm["name"]]
+                    self._log.write(line)
-            new = data[off:]
-            if new:
-                for line in new.splitlines():
-                    if EXIT_MARKER not in line:
-                        self._log.write(line)
-                self._offsets[vm["name"]] = len(data)
 
-        def _tick(self):
+        def _collect_tele(self):
-            table = self.query_one("#vms", DataTable)
+            """(THREAD) chaîne de télémétrie hôte : CPU % + disque des images."""
+            try:
+                ncpu = os.cpu_count() or 1
+                load1 = os.getloadavg()[0]
+                du = shutil.disk_usage(self._disk_dir)
+                used_pct = int(du.used / du.total * 100) if du.total else 0
+                return (
+                    f"  ⚙ CPU {min(999, int(load1 / ncpu * 100))}% "
+                    f"(charge {load1:.1f}/{ncpu})   "
+                    f"💽 {self._disk_dir}: {_fmt_size(du.used)}/"
+                    f"{_fmt_size(du.total)} ({used_pct}%) · "
+                    f"libre {_fmt_size(du.free)}"
+                )
+            except Exception:
+                return ""
+
+        def _collect_table(self):
+            """(THREAD) statut + taille disque de chaque VM + télémétrie. AUCUNE
+            mise à jour d'UI ici : uniquement des I/O bloquantes déportées."""
+            disks, status, errors = {}, {}, {}
             for vm in vms:
-                state, code = read_status(vm["log"])
+                name = vm["name"]
-                elapsed = time.time() - started
+                disks[name] = _fmt_size(disk_actual_size(vm_disk_path(vm)))
-                mm, ss = divmod(int(elapsed), 60)
+                if (
-                label = ICON[state]
+                    name not in self._final
-                if state == "failed":
+                    and self._domstate.get(name) != "gone"
-                    label = f"❌ ({code})"
+                ):
-                elif state == "done":
+                    st = read_status(vm["log"])
-                    label = "✅"
+                    status[name] = st
-                table.update_cell(vm["name"], "state", label)
+                    # À la complétion (succès OU échec), on ANALYSE le log
-                if state in ("running", "pending"):
+                    # complet pour signaler les erreurs — même un « succès »
-                    table.update_cell(
+                    # peut contenir des erreurs passées inaperçues.
-                        vm["name"], "elapsed", f"{mm:02d}:{ss:02d}"
+                    if st[0] in ("done", "failed") and name not in errors:
+                        errors[name] = scan_log_errors(vm["log"])
+            return disks, status, self._collect_tele(), errors
+
+        async def _tick_table(self):
+            # I/O (lectures de logs, stat disque, /proc) DÉPORTÉES en thread ->
+            # la boucle d'événements Textual reste fluide même sous forte
+            # charge ou disque lent. Les mises à jour d'UI restent sur la boucle.
+            try:
+                disks, status, tele, errors = await asyncio.to_thread(
+                    self._collect_table
+                )
+            except Exception:
+                return
+            self._errcount.update(errors)
+            try:
+                table = self.query_one("#vms", DataTable)
+                now = time.time()
+                remaining = []
+                for vm in vms:
+                    name = vm["name"]
+                    self._set_cell(table, name, "disk", disks.get(name, "-"))
+                    if name in self._final:
+                        continue
+                    ds = self._domstate.get(name)
+                    if ds == "gone":
+                        self._final[name] = ("deleted", None, now - started)
+                        self._set_cell(
+                            table, name, "state", f"❌ {t('deleted')}"
+                        )
+                        continue
+                    st = status.get(name)
+                    if st is None:
+                        continue
+                    state, code = st
+                    if state in ("done", "failed"):
+                        elapsed = now - started
+                        self._final[name] = (state, code, elapsed)
+                        if state == "done":
+                            record_duration(
+                                vm.get("distro"),
+                                vm.get("version"),
+                                vm.get("arch"),
+                                elapsed,
+                            )
+                            self._stats = load_stats()
+                        lbl = "✅" if state == "done" else f"❌ ({code})"
+                        self._set_cell(table, name, "state", lbl)
+                        self._set_cell(
+                            table, name, "elapsed", self._fmt(elapsed)
+                        )
+                        # Colonne ⚠ (à gauche d'État) : erreurs détectées dans
+                        # le log, y compris pour un « succès ».
+                        self._set_cell(
+                            table, name, "err",
+                            self._err_label(self._errcount.get(name)),
+                        )
+                    elif ds == "paused":
+                        self._set_cell(
+                            table, name, "state", f"⏸ {t('paused')}"
+                        )
+                    else:
+                        self._set_cell(table, name, "state", ICON[state])
+                        ref = eta_reference(self._stats, vm.get("arch"))
+                        if ref is not None:
+                            remaining.append(max(0, ref - (now - started)))
+                done = len(self._final)
+                eta = (
+                    f" · ETA ~{_fmt_secs(max(remaining))}" if remaining else ""
+                )
+                self.sub_title = (
+                    f"{done}/{len(vms)} {t('completed')} · "
+                    f"{self._fmt(now - started)}{eta}"
+                )
+                if tele:
+                    self.query_one("#telemetry", Static).update(tele)
+                self._update_stats()
+            except Exception:
+                pass
+
+        @staticmethod
+        def _err_label(counts):
+            """Libellé de la colonne ⚠ : « ⚠N » si erreurs, « ⚡N » si seulement
+            des avertissements, « ✓ » si log propre."""
+            if not counts:
+                return ""
+            nerr, nwarn = counts
+            if nerr:
+                return f"⚠{nerr}"
+            if nwarn:
+                return f"⚡{nwarn}"
+            return "✓"
+
+        def _stats_counts(self):
+            """Compte par catégorie (terminées, échecs, erreurs, etc.)."""
+            done = fail = deleted = err_vms = warn_vms = 0
+            for name, (state, _code, _el) in self._final.items():
+                if state == "done":
+                    done += 1
+                elif state == "failed":
+                    fail += 1
+                elif state == "deleted":
+                    deleted += 1
+                counts = self._errcount.get(name)
+                if counts:
+                    if counts[0]:
+                        err_vms += 1
+                    elif counts[1]:
+                        warn_vms += 1
+            running = paused = 0
+            for vm in vms:
+                if vm["name"] in self._final:
+                    continue
+                if self._domstate.get(vm["name"]) == "paused":
+                    paused += 1
+                else:
+                    running += 1
+            return {
+                "total": len(vms), "done": done, "fail": fail,
+                "deleted": deleted, "running": running, "paused": paused,
+                "err_vms": err_vms, "warn_vms": warn_vms,
+            }
+
+        def _update_stats(self):
+            c = self._stats_counts()
+            line = (
+                f"  📊 {c['total']} VM · ✅ {c['done']} · ❌ {c['fail']} · "
+                f"⏳ {c['running']} · ⏸ {c['paused']} · 🗑 {c['deleted']} · "
+                f"⚠ {c['err_vms']} · ⚡ {c['warn_vms']}   "
+                f"({t('click to expand')})"
+            )
+            self.query_one("#stats", Static).update(line)
+            if self._stats_open:
+                self.query_one("#statsdetail", Static).update(
+                    self._render_stats_detail()
+                )
+
+        def _render_stats_detail(self):
+            """Détail déplié : VM avec erreurs/avertissements + moyennes hist."""
+            lines = []
+            for name, (state, code, el) in self._final.items():
+                counts = self._errcount.get(name)
+                if counts and (counts[0] or counts[1]):
+                    lines.append(
+                        f"    • {name}: ⚠{counts[0]} erreurs, "
+                        f"⚡{counts[1]} avert. ({self._fmt(el)})"
                     )
-            if self._follow:
+            if not lines:
-                self._load_selected_log()
+                lines.append(f"    {t('No error detected.')}")
+            return "\n".join(lines)
+
+        async def _tick_log(self):
+            if not self._follow:
+                return
+            vm = self._vm_by_name(self._selected)
+            if not vm:
+                return
+            name = vm["name"]
+            try:
+                new, off = await asyncio.to_thread(
+                    _read_new, vm["log"], self._offsets.get(name, 0)
+                )
+            except Exception:
+                return
+            self._offsets[name] = off
+            for line in new.splitlines():
+                if EXIT_MARKER not in line:
+                    self._log.write(line)
+
+        async def _tick_domstate(self):
+            # Relevé LENT (subprocess virsh) DÉPORTÉ en thread : ne bloque plus
+            # la boucle. Une VM absente de « virsh list » est EFFACÉE (« gone »).
+            try:
+                states = await asyncio.to_thread(virsh_domstates)
+            except Exception:
+                return
+            for vm in vms:
+                self._domstate[vm["name"]] = states.get(vm["name"], "gone")
 
         # -- events --------------------------------------------------------- #
         def on_data_table_row_highlighted(self, event) -> None:
@@ -296,6 +911,105 @@ def run_monitor(manifest_path: str) -> None:
             with self.suspend():
                 os.system(f"ssh {SSH_OPTS} erplibre@{vm['ip']} || true")
 
+        def action_web(self) -> None:
+            """Ouvre l'UI web de la VM (Odoo :8069) dans un navigateur CLI
+            (browsh/carbonyl/w3m/links/elinks/lynx). Surtout utile une fois
+            l'installation TERMINÉE."""
+            vm = self._vm_by_name(self._selected)
+            if not vm or not vm.get("ip"):
+                self.notify("Pas d'IP pour cette VM.", title="Web")
+                return
+            browser = self._choose_browser()
+            if not browser:
+                return
+            url = f"http://{vm['ip']}:8069"
+            with self.suspend():
+                print(f"→ {browser} {url}")
+                rc = os.system(f"{browser} {shlex.quote(url)}")
+                # Diagnostic : sinon le navigateur « clignote » et revient au
+                # TUI sans qu'on voie l'erreur (souvent Odoo pas démarré).
+                print(f"\n[{browser}] terminé (code {rc}).")
+                if rc != 0:
+                    print(
+                        "La page ne s'est peut-être pas affichée : Odoo n'est "
+                        "pas démarré sur :8069, ou réseau/pare-feu. Vérifie que "
+                        "le service Odoo tourne dans la VM (make run / systemd)."
+                    )
+                try:
+                    input("Entrée pour revenir au suivi… ")
+                except EOFError:
+                    pass
+
+        def _choose_browser(self):
+            """Offre la LISTE des navigateurs CLI installés et laisse choisir
+            lequel utiliser pour voir la page. Si aucun n'est installé, propose
+            d'en installer un. Renvoie le binaire choisi, ou None."""
+            available = [b for b in CLI_BROWSERS if shutil.which(b)]
+            if not available:
+                browser = self._install_cli_browser()
+                if not browser:
+                    self.notify(
+                        "Aucun navigateur CLI disponible.",
+                        title="Web",
+                        severity="warning",
+                    )
+                return browser
+            with self.suspend():
+                print("Quel navigateur utiliser pour voir la page ?")
+                for i, b in enumerate(available, 1):
+                    print(f"  [{i}] {b}{' *' if i == 1 else ''}")
+                print("  [i] Installer un autre navigateur")
+                sel = input(
+                    f"Choix (numéro, vide = {available[0]}) : "
+                ).strip().lower()
+                if sel == "i":
+                    return self._install_cli_browser()
+                if not sel:
+                    return available[0]
+                try:
+                    idx = int(sel) - 1
+                    if 0 <= idx < len(available):
+                        return available[idx]
+                except ValueError:
+                    pass
+                return available[0]
+
+        def _install_cli_browser(self):
+            """Demande QUEL navigateur CLI installer (w3m/lynx/links/elinks),
+            affiche la commande, l'exécute après validation. Renvoie le binaire
+            désormais disponible, ou None."""
+            with self.suspend():
+                print("Aucun navigateur CLI installé. Lequel installer ?")
+                for i, (b, desc) in enumerate(INSTALLABLE_BROWSERS, 1):
+                    print(f"  [{i}] {desc}{' *' if i == 1 else ''}")
+                sel = input("Choix (numéro, vide = w3m) : ").strip()
+                browser = INSTALLABLE_BROWSERS[0][0]
+                try:
+                    idx = int(sel) - 1
+                    if 0 <= idx < len(INSTALLABLE_BROWSERS):
+                        browser = INSTALLABLE_BROWSERS[idx][0]
+                except ValueError:
+                    pass
+                cmd = browser_install_command(browser)
+                if not cmd:
+                    print(
+                        "Gestionnaire de paquets inconnu : installez "
+                        f"« {browser} » manuellement."
+                    )
+                    input("Entrée… ")
+                    return None
+                printable = " ".join(cmd)
+                print(f"Commande : {printable}")
+                ans = input(
+                    "Installer maintenant ? (o/N) : "
+                ).strip().lower()
+                if ans not in ("o", "oui", "y", "yes"):
+                    return None
+                rc = os.system(printable)
+                print(f"\nInstallation terminée (code {rc}).")
+                input("Entrée pour continuer… ")
+            return cli_browser()
+
         def action_copy_log(self) -> None:
             """Copie le log complet de la VM sélectionnée dans le
             presse-papiers (OSC 52 ; marche aussi à travers SSH)."""
@@ -312,4 +1026,68 @@ def run_monitor(manifest_path: str) -> None:
                 title="Presse-papiers",
             )
 
-    Monitor().run()
+        def action_details(self) -> None:
+            """Ouvre une petite fenêtre avec les LIGNES d'erreurs/avertissements
+            de la VM sélectionnée (scan à la demande -> toujours à jour)."""
+            vm = self._vm_by_name(self._selected)
+            if not vm:
+                return
+            errs, warns = scan_log_error_lines(vm["log"])
+            self.push_screen(ErrorLinesScreen(vm["name"], errs, warns))
+
+        def on_click(self, event) -> None:
+            # Clic sur le sommaire de stats -> déplie / replie le détail.
+            w = getattr(event, "widget", None)
+            if w is not None and getattr(w, "id", None) == "stats":
+                self._stats_open = not self._stats_open
+                self.query_one("#statsdetail").display = self._stats_open
+                self._update_stats()
+
+        # -- pause / reprise de tout le parc -------------------------------- #
+        @staticmethod
+        def _virsh_bulk(action, names):
+            for n in names:
+                try:
+                    subprocess.run(
+                        ["sudo", "virsh", action, n],
+                        capture_output=True,
+                        text=True,
+                        timeout=30,
+                    )
+                except (OSError, subprocess.SubprocessError):
+                    pass
+
+        def action_pause_all(self) -> None:
+            """Met en PAUSE (virsh suspend) toutes les VM en cours d'exécution.
+            L'install reprend là où elle en était après « Reprendre »."""
+            self.run_worker(self._bulk_worker("suspend"), exclusive=False)
+
+        def action_resume_all(self) -> None:
+            """REPREND (virsh resume) toutes les VM en pause ; le suivi des
+            logs continue automatiquement (offsets conservés)."""
+            self.run_worker(self._bulk_worker("resume"), exclusive=False)
+
+        async def _bulk_worker(self, action):
+            want = "running" if action == "suspend" else "paused"
+            targets = [
+                vm["name"]
+                for vm in vms
+                if self._domstate.get(vm["name"]) == want
+            ]
+            if not targets:
+                self.notify(
+                    t("No running VM to pause.")
+                    if action == "suspend"
+                    else t("No paused VM to resume.")
+                )
+                return
+            await asyncio.to_thread(self._virsh_bulk, action, targets)
+            verb = t("paused") if action == "suspend" else t("resumed")
+            self.notify(f"{len(targets)} VM {verb}.")
+            # Rafraîchit tout de suite l'état libvirt (pause/reprise visible).
+            self.run_worker(self._tick_domstate(), exclusive=False)
+
+    app = Monitor()
+    if run_app:
+        app.run()
+    return app