Reprendre la documentation de déploiement, qui vivait dans alpinux-owni

Ce dépôt d'infrastructure décrit la machine ; le déploiement de ce site-ci le regarde lui, et le tenir ailleurs garantissait qu'il divergerait du code qu'il décrit. Repris tel quel depuis alpinux-owni/docs/, où il est supprimé en retour. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01SFbwnJurBwTs7x7t93ecku
Guide installer mint : modification des chemins poir les scripts
2026-09-27 13:00:18 +02:00 · 2026-09-26 00:01:12 +02:00 · 2026-09-26 00:00:52 +02:00 · 2026-09-25 23:02:56 +02:00 · 2026-09-25 22:37:17 +02:00 · 2026-09-24 22:40:10 +00:00
55 changed files with 3204 additions and 237 deletions
--- a/.obsidian/app.json
+++ b/.obsidian/app.json
@ -8,4 +8,4 @@
  "alwaysUpdateLinks": true,
  "useMarkdownLinks": true,
  "newLinkFormat": "relative"
-}
+}
--- a/code/linux/linux-mint/alpi-fiche.sh
+++ b/code/linux/linux-mint/alpi-fiche.sh
@ -0,0 +1,702 @@
 #!/bin/bash
 # Relève la fiche d'une machine, et l'envoie au serveur de l'install party.
 #
 # Ce script vit dans le dépôt du wiki, à côté d'install.sh : il est lu et
 # versionné comme lui, et c'est de là qu'il faut le prendre.
 #
 #     wget https://gitea.alpinux.org/alpinux.cedrica5l/alpinux-wiki/raw/branch/main/code/linux/linux-mint/alpi-fiche.sh
 #     chmod +x alpi-fiche.sh
 #     sudo ./alpi-fiche.sh --check     # depuis la session live, avant d'installer
 #     sudo ./alpi-fiche.sh             # après l'installation
 #
 # Sur le réseau de l'install party, plus court :
 #
 #     wget http://10.0.0.1/alpi-fiche.sh && chmod +x alpi-fiche.sh && sudo ./alpi-fiche.sh --check
 #
 # Pourquoi la garder sur le serveur plutôt que sur le poste : trois semaines
 # plus tard, quand quelqu'un rappelle parce que « ça rame », on n'a plus la
 # machine sous la main. Savoir qu'elle a huit ans, quatre gigaoctets de
 # mémoire et un disque mécanique qui commence à réallouer des secteurs répond
 # à la question avant de l'avoir posée.
 #
 # Ce qui est envoyé : le modèle, le processeur, la mémoire, les disques et
 # leur santé, le système installé.
 #
 # Deux de ces champs touchent à la personne, et il faut le dire plutôt que de
 # prétendre le contraire — la première version de cet en-tête annonçait « rien
 # qui touche à la personne », ce qui était faux :
 #
 #   · le NOM DE LA MACHINE, choisi pendant l'installation, contient très
 #     souvent un prénom ;
 #   · l'ADRESSE MATÉRIELLE de la carte réseau identifie durablement l'appareil.
 #
 # Les deux servent : le nom pour s'y retrouver, l'adresse pour rapprocher la
 # fiche du bail DHCP. Mais ils appartiennent à la personne dont on installe
 # l'ordinateur — il faut le lui dire. Ne sont en revanche jamais envoyés : son
 # nom d'utilisateur, ses fichiers, son historique, ni rien de ce qu'elle a
 # installé. Le numéro de série est tronqué à quatre caractères.
 #
 #     alpi-fiche              relève et envoie
 #     alpi-fiche --montrer    relève et affiche, sans rien envoyer
 #     alpi-fiche --check      relève, envoie, et rend un verdict
 #
 # Le mode « --check » est fait pour tourner **depuis la clé USB, avant
 # d'installer** : c'est le seul moment où l'on peut encore renoncer. Un disque
 # qui se déclare défaillant, on ne passe pas une heure à installer dessus — on
 # le dit à son propriétaire et on cherche une autre solution.
 set -u
 # Bash ne compte les caractères — et non les octets — que si la locale le dit.
 # C'est ce qui aligne les colonnes du tableau des disques.
 export LC_ALL="${LC_ALL:-C.UTF-8}"
 # Le temps que met la collecte, en millisecondes.
 #
 # Une machine n'est relevée qu'une fois quand elle n'a pas connu de session
 # live : il n'y a alors pas d'écart entre deux passages à mesurer. Cette durée-
 # ci existe toujours, et elle se compare — elle dit ce que la machine met à
 # s'interroger elle-même : lire le SMART de ses disques, réveiller ceux qui
 # dorment, énumérer ses barrettes. Un plateau qui rame se voit là.
 #
 # On arrête le chronomètre à la fin de la collecte, avant le verdict : celui-ci
 # attend une touche, et l'on mesurerait la personne devant l'écran.
 DEBUT_NS="$(date +%s%N 2>/dev/null || echo 0)"
 # smartctl et dmidecode vivent dans /usr/sbin, que le PATH d'un shell ordinaire
 # ne contient pas toujours — un « command -v » y échouait alors que le binaire
 # était là.
 PATH="$PATH:/usr/sbin:/sbin"
 SERVEUR="${ALPI_SERVEUR:-http://alpicache.lan}"
 MONTRER=0
 CHECK=0
 case "${1:-}" in
    --montrer) MONTRER=1 ;;
    --check)   CHECK=1 ;;
 esac
 if [ -t 1 ]; then
    V=$'\e[32m'; O=$'\e[33m'; R=$'\e[31m'; B=$'\e[1m'; D=$'\e[2m'; Z=$'\e[0m'
 else
    V=""; O=""; R=""; B=""; D=""; Z=""
 fi
 # Ce dont le relevé a besoin, et qu'il installe lui-même plutôt que de rendre
 # un verdict à trous.
 #
 # « état des disques inconnu » n'aide personne : c'est précisément la réponse
 # qu'on était venu chercher. Les deux paquets pèsent moins de deux mégaoctets,
 # ils sont dans le cache, et l'installation prend deux secondes sur le réseau
 # de l'install party. On ne le fait qu'en root, qu'avec apt, et sans rien
 # demander d'autre.
 completer_outils() {
    [ "$(id -u)" = "0" ] || return 0
    command -v apt-get >/dev/null 2>&1 || return 0
    local manquants=""
    command -v smartctl  >/dev/null 2>&1 || manquants="$manquants smartmontools"
    command -v dmidecode >/dev/null 2>&1 || manquants="$manquants dmidecode"
    [ -z "$manquants" ] && return 0
    echo "==> Installation de ce qui manque au relevé :$manquants"
    # Par le cache s'il répond, directement sinon. « -qq » pour ne pas noyer
    # l'écran : ce n'est pas l'objet de la manœuvre.
    local proxy=""
    if command -v wget >/dev/null 2>&1 \
       && wget -q --spider --timeout=3 "$SERVEUR/" 2>/dev/null; then
        proxy="-o Acquire::http::Proxy=http://apt-proxy:3142"
    fi
    DEBIAN_FRONTEND=noninteractive apt-get $proxy -qq -y install $manquants \
        >/dev/null 2>&1 \
        || echo "   (échec — le relevé se fera sans)"
    # Ce qui vient d'arriver est dans /usr/sbin, que le PATH d'un shell
    # ordinaire ne contient pas toujours.
    PATH="$PATH:/usr/sbin:/sbin"
 }
 completer_outils
 lire_dmi() {
    cat "/sys/class/dmi/id/$1" 2>/dev/null | tr -d '\n' | sed 's/^ *//; s/ *$//'
 }
 echapper() {
    # De quoi écrire du JSON sans rien installer : guillemets, antislashs et
    # sauts de ligne, et c'est tout ce qui peut nous arriver ici.
    printf '%s' "$1" | sed 's/\\/\\\\/g; s/"/\\"/g' | tr -d '\n\r'
 }
 champ() { printf '"%s":"%s"' "$1" "$(echapper "${2:-}")"; }
 # --- La machine ------------------------------------------------------------
 MODELE="$(lire_dmi product_name)"
 MARQUE="$(lire_dmi sys_vendor)"
 SERIE="$(lire_dmi product_serial)"
 # Le numéro de série identifie un objet, pas une personne, mais il n'a rien à
 # faire dans un fichier qu'on partage : on n'en garde que les quatre derniers
 # caractères, assez pour distinguer deux machines du même modèle.
 SERIE="${SERIE: -4}"
 BIOS="$(lire_dmi bios_date)"
 PROCESSEUR="$(awk -F': ' '/^model name/{print $2; exit}' /proc/cpuinfo)"
 COEURS="$(nproc 2>/dev/null || echo '?')"
 MEMOIRE_KO="$(awk '/^MemTotal/{print $2}' /proc/meminfo)"
 SYSTEME=""
 if [ -r /etc/os-release ]; then
    SYSTEME="$(. /etc/os-release; echo "${PRETTY_NAME:-$NAME $VERSION}")"
 fi
 NOYAU="$(uname -r)"
 ARCHITECTURE="$(uname -m)"
 # Sommes-nous sur la clé USB, ou sur le système installé ?
 #
 # La distinction n'est pas cosmétique : les deux relevés répondent à deux
 # questions différentes. Celui de la session live dit « peut-on installer sur
 # cette machine ? » et se fait avant d'effacer quoi que ce soit. Celui d'après
 # dit « qu'avons-nous installé, et sur quoi ». Les garder séparés permet de
 # comparer — un disque qui allait bien le matin et qui se plaint le soir, cela
 # se voit.
 #
 # Le signe qui ne trompe pas est la racine : une session live la monte en
 # overlay au-dessus d'un squashfs, ce qu'aucun système installé ne fait. S'y
 # ajoute « boot=casper » ou « boot=live » sur la ligne de commande du noyau.
 #
 # L'existence de /cdrom ou de /rofs, elle, ne prouve rien : l'installateur de
 # Mint laisse un /cdrom vide derrière lui, et la première version de ce script
 # a donc déclaré « session live » une machine parfaitement installée. On ne les
 # retient que s'ils sont réellement montés.
 MOMENT="post-installation"
 if findmnt -n -o FSTYPE / 2>/dev/null | grep -qE '^(overlay|aufs|squashfs)$' \
   || grep -qE '(^| )boot=(casper|live)( |$)' /proc/cmdline 2>/dev/null \
   || mountpoint -q /rofs 2>/dev/null \
   || { mountpoint -q /cdrom 2>/dev/null \
        && findmnt -n -o FSTYPE /cdrom 2>/dev/null | grep -qE '^(iso9660|squashfs)$'; }; then
    MOMENT="live"
 fi
 # --- La mémoire, barrette par barrette ------------------------------------
 #
 # La question qu'on pose vraiment devant une machine lente : peut-on en
 # ajouter ? Elle demande trois réponses — combien de connecteurs, combien
 # d'occupés, et de quel type. Un slot libre en DDR3 ne se remplit pas avec ce
 # qu'on a dans le tiroir.
 #
 # dmidecode lit cela dans la table du BIOS. Il est présent par défaut sur
 # Debian, Ubuntu et Mint ; s'il manque, on ne prétend rien plutôt que de
 # deviner.
 BARRETTES="["
 SLOTS_TOTAL=0
 SLOTS_PRIS=0
 TYPE_MEMOIRE=""
 VITESSE_MEMOIRE=""
 if command -v dmidecode >/dev/null 2>&1 && [ "$(id -u)" = "0" ]; then
    premier=1
    # Chaque bloc « Memory Device » décrit un connecteur, occupé ou non.
    while IFS= read -r bloc; do
        emplacement="$(printf '%s' "$bloc" | sed -n 's/.*|Locator:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
        taille="$(printf '%s' "$bloc" | sed -n 's/.*|Size:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
        type_="$(printf '%s' "$bloc" | sed -n 's/.*|Type:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
        vitesse="$(printf '%s' "$bloc" | sed -n 's/.*|Speed:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
        forme="$(printf '%s' "$bloc" | sed -n 's/.*|Form Factor:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
        reference="$(printf '%s' "$bloc" | sed -n 's/.*|Part Number:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
        # La vitesse configurée est celle à laquelle la barrette travaille
        # vraiment ; « Speed » n'est que ce dont elle serait capable. L'écart
        # entre les deux explique bien des machines qui « rament » sans raison
        # apparente : une DDR4-3200 bridée à 2133 par la carte mère, ou deux
        # barrettes dépareillées qui s'alignent sur la plus lente.
        vitesse_reelle="$(printf '%s' "$bloc" | sed -n 's/.*|Configured Memory Speed:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
        fabricant="$(printf '%s' "$bloc" | sed -n 's/.*|Manufacturer:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
        rang="$(printf '%s' "$bloc" | sed -n 's/.*|Rank:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
        tension="$(printf '%s' "$bloc" | sed -n 's/.*|Configured Voltage:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
        largeur="$(printf '%s' "$bloc" | sed -n 's/.*|Data Width:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
        detail="$(printf '%s' "$bloc" | sed -n 's/.*|Type Detail:\([^|]*\).*/\1/p' | sed 's/^ *//; s/ *$//')"
        [ -z "$emplacement" ] && continue
        SLOTS_TOTAL=$(( SLOTS_TOTAL + 1 ))
        case "$taille" in
            *"No Module"*|""|"Unknown") taille="" ;;
            *) SLOTS_PRIS=$(( SLOTS_PRIS + 1 ))
               [ -z "$TYPE_MEMOIRE" ] && [ "$type_" != "Unknown" ] && TYPE_MEMOIRE="$type_"
               # Deux barrettes de vitesses différentes s'alignent sur la plus
               # lente : c'est celle-là qu'il faut retenir pour la machine.
               if [ -n "$vitesse_reelle" ] && [ "$vitesse_reelle" != "Unknown" ]; then
                   nombre="${vitesse_reelle%% *}"
                   case "$nombre" in
                       ''|*[!0-9]*) ;;
                       *) if [ -z "$VITESSE_MEMOIRE" ] || [ "$nombre" -lt "$VITESSE_MEMOIRE" ]; then
                              VITESSE_MEMOIRE="$nombre"
                          fi ;;
                   esac
               fi ;;
        esac
        [ "$premier" = 0 ] && BARRETTES="$BARRETTES,"
        premier=0
        BARRETTES="$BARRETTES{$(champ emplacement "$emplacement"),$(champ taille "$taille"),\
 $(champ type "$type_"),$(champ vitesse "$vitesse"),$(champ vitesse_reelle "$vitesse_reelle"),\
 $(champ forme "$forme"),$(champ reference "$reference"),$(champ fabricant "$fabricant"),\
 $(champ rang "$rang"),$(champ tension "$tension"),$(champ largeur "$largeur"),\
 $(champ detail "$detail")}"
    done < <(dmidecode -t memory 2>/dev/null \
             | awk '/^Memory Device$/{bloc=""; dedans=1; next}
                    /^$/{if (dedans && bloc != "") print bloc; dedans=0; bloc=""}
                    dedans {gsub(/^[ \t]+/, ""); bloc = bloc "|" $0}
                    END{if (dedans && bloc != "") print bloc}')
 fi
 BARRETTES="$BARRETTES]"
 TABLE_DISQUES=""
 # Remplir une colonne à la bonne largeur.
 #
 # « printf %-10s » compte les octets, pas les caractères : « mécanique » en
 # pèse dix pour neuf signes, et la colonne suivante glisse d'un cran. Bash,
 # lui, sait compter les caractères quand la locale est en UTF-8 — on lui
 # laisse ce travail, et l'on force la locale plutôt que d'espérer.
 colonne() {
    local texte="$1" largeur="$2" cote="${3:-gauche}" n
    n=${#texte}
    if [ "$n" -gt "$largeur" ]; then
        printf '%s' "${texte:0:$largeur}"
        return
    fi
    local blancs=""
    while [ "$n" -lt "$largeur" ]; do blancs="$blancs "; n=$((n + 1)); done
    if [ "$cote" = droite ]; then printf '%s%s' "$blancs" "$texte"
    else printf '%s%s' "$texte" "$blancs"; fi
 }
 # --- Les disques -----------------------------------------------------------
 #
 # lsblk donne la taille et le type ; le drapeau « rotational » du noyau
 # distingue un disque mécanique d'un SSD sans rien installer. C'est la
 # distinction qui compte : une machine lente avec un disque mécanique de dix
 # ans ne s'arrangera pas avec un système plus léger.
 DISQUES="["
 premier=1
 for chemin in /sys/block/*; do
    nom="$(basename "$chemin")"
    case "$nom" in loop*|ram*|sr*|zram*|dm-*) continue ;; esac
    [ -r "$chemin/size" ] || continue
    taille=$(( $(cat "$chemin/size") * 512 ))
    [ "$taille" -lt 1000000000 ] && continue        # moins d'un Go : pas un disque
    rotatif="$(cat "$chemin/queue/rotational" 2>/dev/null || echo '?')"
    modele="$(cat "$chemin/device/model" 2>/dev/null | sed 's/ *$//')"
    # L'état SMART, s'il est lisible. Sans smartctl on ne prétend rien.
    sante=""
    reallocations=""
    pending=""
    illisibles=""
    heures=""
    usure=""
    ecrit=""
    if command -v smartctl >/dev/null 2>&1; then
        sortie="$(smartctl -H -A "/dev/$nom" 2>/dev/null)"
        sante="$(printf '%s' "$sortie" | grep -iE 'overall-health|SMART Health' \
                 | sed 's/.*: *//' | head -1)"
        reallocations="$(printf '%s' "$sortie" \
                         | awk '/Reallocated_Sector_Ct|Reallocated_Event/{print $10; exit}')"
        # Les secteurs que le disque n'arrive plus à lire. Ils manquaient à la
        # fiche, et c'est ce qui a fait qu'alpicache annonçait « sain » un
        # disque déclaré à remplacer : il ne les avait jamais reçus.
        pending="$(printf '%s' "$sortie" | awk '$2 == "Current_Pending_Sector"{print $10; exit}')"
        illisibles="$(printf '%s' "$sortie" | awk '$2 == "Offline_Uncorrectable"{print $10; exit}')"
        heures="$(printf '%s' "$sortie" | awk '/Power_On_Hours/{print $10; exit}')"
        # L'usure d'un SSD, en pour cent de vie consommée.
        #
        # Un disque mécanique s'use en tournant, un SSD en écrivant : les
        # heures de marche ne disent rien de son état. Chaque constructeur a
        # son attribut, et deux conventions coexistent — les uns comptent ce
        # qui est consommé, les autres ce qui reste. On ramène tout à
        # « consommé », qui est le sens qu'on veut lire. NVMe donne directement
        # « Percentage Used » ; pour les SATA, la colonne VALUE part de 100 et
        # descend.
        usure="$(printf '%s' "$sortie" | awk '/Percentage Used:/{gsub(/[^0-9]/,"",$3); print $3; exit}')"
        if [ -z "$usure" ]; then
            usure="$(printf '%s' "$sortie" | awk '
                /Media_Wearout_Indicator|Wear_Leveling_Count|SSD_Life_Left|Percent_Lifetime_Remain/ {
                    if ($4 ~ /^[0-9]+$/ && $4 <= 100) { print 100 - $4; exit }
                }')"
        fi
        # Ce que le disque a écrit depuis sa mise en service : l'autre façon de
        # juger un SSD, dont les modèles courants tiennent 100 à 600 To.
        ecrit="$(printf '%s' "$sortie" | awk '
            /Total_LBAs_Written|Host_Writes_32MiB|Total_Host_Writes/ {
                if ($10 ~ /^[0-9]+$/) { print $10; exit }
            }
            /Data Units Written:/ { gsub(/[^0-9]/,"",$4); print $4; exit }')"
    fi
    # Les mêmes chiffres, mis en table pour être lus par quelqu'un. Le verdict
    # ne dit que ce qui cloche ; on veut aussi voir ce qui va, et sur quoi le
    # verdict se fonde.
    taille_go="$(awk -v o="$taille" 'BEGIN{printf "%.1f", o/1000000000}' | tr . ,)"
    secteurs="—"
    for valeur in "${pending:-0}" "${illisibles:-0}" "${reallocations:-0}"; do
        case "$valeur" in ''|*[!0-9]*) continue ;; esac
        [ "$valeur" -gt 0 ] && secteurs="!"
    done
    [ "$secteurs" = "!" ] && secteurs="$(printf '%s/%s/%s' \
        "${reallocations:-0}" "${pending:-0}" "${illisibles:-0}")"
    usure_dite="—"
    if [ "$rotatif" = 1 ]; then
        case "$heures" in ''|*[!0-9]*) ;; *)
            usure_dite="$heures h"
            [ "$heures" -ge 8760 ] && usure_dite="$usure_dite ($(( heures / 8760 )),$(( (heures % 8760) * 10 / 8760 )) an)" ;;
        esac
    else
        case "$usure" in ''|*[!0-9]*) ;; *) usure_dite="usé à $usure %" ;; esac
    fi
    TABLE_DISQUES="$TABLE_DISQUES$(
        colonne "$nom" 7; printf ' '
        colonne "${modele:-—}" 20; printf ' '
        colonne "$([ "$rotatif" = 1 ] && echo mécanique || echo SSD)" 10; printf ' '
        colonne "$taille_go Go" 10 droite; printf ' '
        colonne "${sante:-—}" 8; printf ' '
        colonne "$usure_dite" 16; printf ' '
        printf '%s' "$secteurs")"$'\n'
    [ "$premier" = 0 ] && DISQUES="$DISQUES,"
    premier=0
    DISQUES="$DISQUES{$(champ nom "$nom"),$(champ modele "$modele"),\
 \"octets\":$taille,$(champ type "$([ "$rotatif" = 1 ] && echo mécanique || echo SSD)"),\
 $(champ sante "$sante"),$(champ reallocations "$reallocations"),\
 $(champ pending "$pending"),$(champ illisibles "$illisibles"),$(champ heures "$heures"),\
 $(champ usure "$usure"),$(champ ecrit "$ecrit")}"
 done
 DISQUES="$DISQUES]"
 # L'occupation, telle qu'elle est maintenant.
 OCCUPATION="["
 premier=1
 while read -r point taille utilise dispo pourcent; do
    [ "$premier" = 0 ] && OCCUPATION="$OCCUPATION,"
    premier=0
    OCCUPATION="$OCCUPATION{$(champ point "$point"),\"taille\":$taille,\
 \"utilise\":$utilise,$(champ pourcent "$pourcent")}"
 done < <(df -B1 --output=target,size,used,avail,pcent 2>/dev/null \
         | awk 'NR>1 && $2+0 > 1000000000 {print $1, $2, $3, $4, $5}')
 OCCUPATION="$OCCUPATION]"
 # --- Le rapport ------------------------------------------------------------
 # L'adresse matérielle de l'interface par laquelle on sort — celle que le
 # serveur a vue en donnant le bail, donc celle qui permettra de rapprocher
 # cette fiche de la machine servie. « ip -o link » a failli nous donner
 # l'adresse de diffusion, qui est la même pour tout le monde.
 INTERFACE="$(ip -o -4 route show default 2>/dev/null | awk '{print $5; exit}')"
 [ -z "$INTERFACE" ] && INTERFACE="$(ls /sys/class/net 2>/dev/null \
    | grep -v '^lo$' | head -1)"
 MAC="$(cat "/sys/class/net/$INTERFACE/address" 2>/dev/null)"
 RAPPORT="{$(champ machine "$(hostname)"),$(champ mac "$MAC"),\
 $(champ marque "$MARQUE"),$(champ modele "$MODELE"),$(champ serie "$SERIE"),\
 $(champ bios "$BIOS"),$(champ processeur "$PROCESSEUR"),\"coeurs\":${COEURS:-0},\
 \"memoire_ko\":${MEMOIRE_KO:-0},$(champ systeme "$SYSTEME"),$(champ noyau "$NOYAU"),\
 $(champ architecture "$ARCHITECTURE"),$(champ moment "$MOMENT"),\
 $(champ type_memoire "$TYPE_MEMOIRE"),\
 $(champ vitesse_memoire "$VITESSE_MEMOIRE"),\
 \"slots_total\":$SLOTS_TOTAL,\"slots_pris\":$SLOTS_PRIS,\"barrettes\":$BARRETTES,\
 \"disques\":$DISQUES,\"occupation\":$OCCUPATION}"
 DUREE_MS=0
 case "$DEBUT_NS" in
    ''|*[!0-9]*) ;;
    0) ;;
    *) FIN_NS="$(date +%s%N 2>/dev/null || echo 0)"
       case "$FIN_NS" in
           ''|*[!0-9]*|0) ;;
           *) DUREE_MS=$(( (FIN_NS - DEBUT_NS) / 1000000 )) ;;
       esac ;;
 esac
 [ "$DUREE_MS" -lt 0 ] && DUREE_MS=0
 RAPPORT="${RAPPORT%\}},\"duree_releve_ms\":$DUREE_MS}"
 if [ "$MONTRER" = 1 ]; then
    if command -v python3 >/dev/null 2>&1; then
        printf '%s' "$RAPPORT" | python3 -m json.tool 2>/dev/null || printf '%s\n' "$RAPPORT"
    else
        printf '%s\n' "$RAPPORT"
    fi
    exit 0
 fi
 [ "$CHECK" = 1 ] && printf "  %sLa fiche est envoyée à alpicache…%s\n\n" "$D" "$Z"
 echo "Relevé   : $([ "$MOMENT" = live ] && echo "session live, avant installation" \
                    || echo "système installé")"
 echo "Machine  : $MARQUE $MODELE"
 echo "Processeur : $PROCESSEUR ($COEURS cœurs)"
 if [ "$SLOTS_TOTAL" -gt 0 ]; then
    echo "Mémoire  : $(( MEMOIRE_KO / 1024 )) Mo ${TYPE_MEMOIRE:+$TYPE_MEMOIRE }\
 ${VITESSE_MEMOIRE:+à $VITESSE_MEMOIRE MT/s }· \
 $SLOTS_PRIS connecteur(s) occupé(s) sur $SLOTS_TOTAL"
 else
    echo "Mémoire  : $(( MEMOIRE_KO / 1024 )) Mo"
 fi
 echo "Système  : $SYSTEME"
 echo
 MOTIFS=""
 # --- Le verdict ------------------------------------------------------------
 #
 # Trois réponses possibles, et une seule question : peut-on installer sur cette
 # machine ? Les seuils viennent de ce qu'on rencontre en install party, pas
 # d'un idéal — une machine de dix ans avec 4 Go et un disque sain fait très
 # bien l'affaire, et c'est souvent celle qu'on nous apporte.
 # Le verdict sort toujours, live ou non. C'est l'information qu'on est venu
 # chercher : la première version ne le rendait qu'en session live, et le
 # relevé d'après installation défilait sans rien dire de l'état des disques —
 # précisément ce dont on voulait parler au propriétaire.
 [ "$MONTRER" = 1 ] || CHECK=1
 if [ "$CHECK" = 1 ]; then
    GRAVITE=0          # 0 rien à signaler · 1 à surveiller · 2 ne pas installer
    REMARQUES=""
    note() {
        [ "$1" -gt "$GRAVITE" ] && GRAVITE="$1"
        REMARQUES="$REMARQUES$2"$'\n'
        # Le même motif, débarrassé de ses couleurs et de ses retours à la
        # ligne, pour qu'alpicache dise exactement ce qui a été dit ici.
        if [ "$1" -ge 1 ]; then
            # Une note tient sur plusieurs lignes à l'écran ; le motif, lui,
            # est d'un seul tenant — il ira dans une case de tableau.
            nu="$(printf '%s' "$2" | tr '\n' ' ' | sed -e 's/\x1b\[[0-9;]*m//g' \
                                                       -e 's/[[:space:]]\{1,\}/ /g' \
                                                       -e 's/^ *[!?✗·] *//' \
                                                       -e 's/^ *//' -e 's/ *$//')"
            [ -n "$nu" ] && MOTIFS="$MOTIFS$nu"$'\n'
        fi
    }
    # Les disques. C'est pour eux qu'on fait ce contrôle.
    for chemin in /sys/block/*; do
        nom="$(basename "$chemin")"
        case "$nom" in loop*|ram*|sr*|zram*|dm-*) continue ;; esac
        [ -r "$chemin/size" ] || continue
        taille=$(( $(cat "$chemin/size") * 512 ))
        [ "$taille" -lt 1000000000 ] && continue
        if ! command -v smartctl >/dev/null 2>&1; then
            note 1 "  ${O}?${Z} état des disques inconnu — smartmontools n'est pas installé.
      ${D}sudo apt install -y smartmontools${Z} ${D}(il passera par le cache)${Z}"
            break
        fi
        sortie="$(smartctl -H -A "/dev/$nom" 2>/dev/null)"
        if printf '%s' "$sortie" | grep -qiE 'overall-health.*(FAILED|FAILING)'; then
            note 2 "  ${R}✗${Z} ${B}/dev/$nom se déclare défaillant${Z} — ne pas installer dessus."
        fi
        # Les trois attributs ne disent pas la même chose, et les confondre
        # revient à sous-estimer les deux qui comptent.
        #
        #   Reallocated_Sector_Ct   des secteurs déjà remplacés par la réserve
        #                           du disque. Quelques-uns sont de l'usure
        #                           ordinaire ; c'est leur nombre qui parle.
        #   Current_Pending_Sector  des secteurs que le disque n'arrive plus à
        #                           lire et n'a pas encore pu déplacer. Ce
        #                           qu'ils contenaient est en train d'être
        #                           perdu. Un seul suffit à s'inquiéter.
        #   Offline_Uncorrectable   des secteurs définitivement illisibles.
        #
        # Les deux derniers ne sont pas de l'usure mais une panne en cours :
        # on ne les mesure pas à la même aune que le premier.
        for attribut in Reallocated_Sector_Ct Current_Pending_Sector Offline_Uncorrectable; do
            valeur="$(printf '%s' "$sortie" | awk -v a="$attribut" '$2 == a {print $10; exit}')"
            case "$valeur" in ''|*[!0-9]*) continue ;; esac
            [ "$valeur" = "0" ] && continue
            case "$attribut" in
                Reallocated_Sector_Ct)
                    libelle="secteur(s) déjà remplacé(s)"
                    if [ "$valeur" -ge 50 ]; then
                        note 2 "  ${R}✗${Z} /dev/$nom : ${B}$valeur $libelle${Z} — disque à remplacer."
                    else
                        note 1 "  ${O}!${Z} /dev/$nom : $valeur $libelle — à surveiller."
                    fi ;;
                Current_Pending_Sector)
                    note 2 "  ${R}✗${Z} /dev/$nom : ${B}$valeur secteur(s) illisible(s)${Z} en attente.
      ${R}Ce ne sont pas des secteurs usés mais des données que le disque
      n'arrive plus à relire : le disque est en train de lâcher.${Z}
      ${D}Sauvegarder ce qui doit l'être avant toute autre chose, et
      ne rien installer dessus — l'installation ne tiendrait pas.${Z}" ;;
                Offline_Uncorrectable)
                    note 2 "  ${R}✗${Z} /dev/$nom : ${B}$valeur secteur(s) définitivement perdu(s)${Z}.
      ${R}Le disque a renoncé à les relire. À remplacer.${Z}" ;;
            esac
        done
        heures="$(printf '%s' "$sortie" | awk '/Power_On_Hours/{print $10; exit}')"
        rotatif="$(cat "$chemin/queue/rotational" 2>/dev/null)"
        # L'usure, recalculée ici : cette boucle est distincte de celle du
        # relevé et ne voit pas ses variables.
        usure="$(printf '%s' "$sortie" | awk '/Percentage Used:/{gsub(/[^0-9]/,"",$3); print $3; exit}')"
        if [ -z "$usure" ]; then
            usure="$(printf '%s' "$sortie" | awk '
                /Media_Wearout_Indicator|Wear_Leveling_Count|SSD_Life_Left|Percent_Lifetime_Remain/ {
                    if ($4 ~ /^[0-9]+$/ && $4 <= 100) { print 100 - $4; exit }
                }')"
        fi
        # Un disque mécanique se signale toujours, et pas seulement quand il
        # est vieux. C'est le premier frein d'une machine par ailleurs
        # correcte : remplacer un plateau par un SSD fait plus pour elle que
        # n'importe quel réglage, et c'est le genre de conseil qu'on donne
        # pendant qu'on a la machine ouverte devant soi.
        # Les heures de marche, dites en heures et en années de fonctionnement.
        # « 477 j 15 h » se lit mal : on croit à un disque épuisé alors que
        # c'est une année et quelques mois de marche, ce qui est peu.
        marche=""
        case "$heures" in
            ''|*[!0-9]*) ;;
            *) marche="$heures h"
               if [ "$heures" -ge 8760 ]; then
                   marche="$marche, soit $(( heures / 8760 )),$(( (heures % 8760) * 10 / 8760 )) an de marche"
               fi ;;
        esac
        if [ "$rotatif" = "1" ]; then
            # Un disque mécanique se fatigue en tournant. Les constructeurs
            # annoncent 300 000 à 600 000 heures de MTBF, mais le retour du
            # terrain est plus sobre : au-delà de 30 000 heures — trois ans et
            # demi de marche continue — les pannes deviennent sensiblement plus
            # fréquentes, et à 45 000 on est dans le sursis.
            gravite_disque=1
            supplement=""
            case "$heures" in
                ''|*[!0-9]*) ;;
                *) if [ "$heures" -ge 45000 ]; then
                       gravite_disque=2
                       supplement="
      ${R}Au-delà de 45 000 heures : sauvegarder avant toute chose.${Z}"
                   elif [ "$heures" -ge 30000 ]; then
                       supplement="
      ${O}Plus de 30 000 heures de marche : il a fait son temps.${Z}"
                   fi ;;
            esac
            note "$gravite_disque" "  ${O}!${Z} /dev/$nom est un ${B}disque mécanique${Z}${marche:+ · $marche}.
      ${D}Le remplacer par un SSD ferait plus pour cette machine que
      tout le reste réuni — démarrage, ouverture des programmes, réactivité.${Z}$supplement"
        else
            # Un SSD ne s'use pas en tournant mais en écrivant. Les heures de
            # marche ne disent rien de son état : c'est l'usure qu'on regarde.
            case "$usure" in
                ''|*[!0-9]*)
                    [ -n "$marche" ] && note 0 "  ${V}·${Z} /dev/$nom est un SSD · $marche.
      ${D}Usure non déclarée par ce modèle.${Z}" ;;
                *) if [ "$usure" -ge 90 ]; then
                       note 2 "  ${R}✗${Z} /dev/$nom : SSD usé à ${B}${usure} %${Z} — il approche de sa fin.
      ${R}Sauvegarder, et prévoir son remplacement.${Z}"
                   elif [ "$usure" -ge 70 ]; then
                       note 1 "  ${O}!${Z} /dev/$nom : SSD usé à ${usure} %${marche:+ · $marche}.
      ${D}Encore utilisable, mais il faudra y penser.${Z}"
                   else
                       note 0 "  ${V}·${Z} /dev/$nom : SSD usé à ${usure} % seulement${marche:+ · $marche}."
                   fi ;;
            esac
        fi
        if [ "$taille" -lt 32000000000 ]; then
            note 1 "  ${O}!${Z} /dev/$nom ne fait que $(( taille / 1000000000 )) Go — c'est juste."
        fi
    done
    # La mémoire, le processeur.
    MEMOIRE_MO=$(( MEMOIRE_KO / 1024 ))
    if [ "$MEMOIRE_MO" -lt 2048 ]; then
        note 2 "  ${R}✗${Z} ${B}${MEMOIRE_MO} Mo de mémoire${Z} — trop peu pour Mint.
      ${D}Envisager une version légère, ou ajouter de la mémoire.${Z}"
    elif [ "$MEMOIRE_MO" -lt 4096 ]; then
        libres=$(( SLOTS_TOTAL - SLOTS_PRIS ))
        note 1 "  ${O}!${Z} ${MEMOIRE_MO} Mo de mémoire — Mint tournera, mais sans aisance.$(
            [ "$libres" -gt 0 ] && printf '\n      %s' "${D}$libres connecteur(s) ${TYPE_MEMOIRE} libre(s) : la machine est extensible.${Z}")"
    fi
    if [ "$ARCHITECTURE" != "x86_64" ] && [ "$ARCHITECTURE" != "aarch64" ]; then
        note 2 "  ${R}✗${Z} processeur ${ARCHITECTURE} — les versions 64 bits ne s'installeront pas."
    fi
    echo
    case "$GRAVITE" in
        0) printf "  %s%s BON POUR L'INSTALLATION %s\n" "$B$V" "✓" "$Z" ;;
        1) printf "  %s%s INSTALLATION POSSIBLE, AVEC DES RÉSERVES %s\n" "$B$O" "!" "$Z" ;;
        2) printf "  %s%s NE PAS INSTALLER EN L'ÉTAT %s\n" "$B$R" "✗" "$Z" ;;
    esac
    echo
    if [ -n "$TABLE_DISQUES" ]; then
        printf '  %s' "$D"
        colonne "Disque" 7; printf ' '
        colonne "Modèle" 20; printf ' '
        colonne "Type" 10; printf ' '
        colonne "Taille" 10 droite; printf ' '
        colonne "SMART" 8; printf ' '
        colonne "Marche / usure" 16; printf ' '
        printf 'Secteurs R/P/I%s\n' "$Z"
        printf '%s' "$TABLE_DISQUES" | sed "s/^/  /"
        printf "  %sR : remplacés · P : illisibles en attente · I : perdus%s\n" "$D" "$Z"
        echo
    fi
    [ -n "$REMARQUES" ] && printf "%s\n" "$REMARQUES"
    # Une pause, sans quoi tout cela défile et personne ne le lit. Sa durée
    # suit la gravité, et l'on n'attend jamais indéfiniment : le script tourne
    # aussi sans personne devant l'écran, appelé par install.sh.
    if [ -t 0 ]; then
        case "$GRAVITE" in
            2) printf "  %sEn parler au propriétaire AVANT de toucher à quoi que ce soit.%s\n" "$D" "$Z"
               printf "  %sEntrée pour continuer malgré tout%s " "$B" "$Z"
               read -r -t "${ALPI_PAUSE_ALERTE:-120}" _ || echo ;;
            1) printf "  %sEntrée pour continuer (reprise automatique dans %ss)%s " \
                      "$D" "${ALPI_PAUSE:-20}" "$Z"
               read -r -t "${ALPI_PAUSE:-20}" _ || echo ;;
            *) sleep "${ALPI_PAUSE_OK:-3}" ;;
        esac
        echo
    fi
 fi
 # Ce que l'on vient de dire à la personne part avec la fiche.
 #
 # Sans cela, alpicache rejugeait à partir des seuls champs reçus — et ne voyait
 # pas les secteurs en attente, qui ne lui étaient pas envoyés. Il affichait
 # « sain » un disque que ce script venait de déclarer à remplacer. Deux juges,
 # deux verdicts : il n'y en a plus qu'un, et c'est celui-ci.
 VERDICT="ok"
 case "${GRAVITE:-0}" in
    2) VERDICT="alerte" ;;
    1) VERDICT="attention" ;;
 esac
 MOTIFS_JSON="["
 premier=1
 while IFS= read -r ligne; do
    [ -n "$ligne" ] || continue
    [ "$premier" = 0 ] && MOTIFS_JSON="$MOTIFS_JSON,"
    premier=0
    MOTIFS_JSON="$MOTIFS_JSON$(printf '%s' "$ligne" \
        | sed -e 's/\\/\\\\/g' -e 's/"/\\"/g' -e 's/^/"/' -e 's/$/"/')"
 done <<< "${MOTIFS:-}"
 MOTIFS_JSON="$MOTIFS_JSON]"
 RAPPORT="${RAPPORT%\}},$(champ verdict "$VERDICT"),\"motifs\":$MOTIFS_JSON}"
 if command -v curl >/dev/null 2>&1; then
    reponse="$(printf '%s' "$RAPPORT" | curl -s --max-time 15 \
               -H 'Content-Type: application/json' --data-binary @- "$SERVEUR/fiche")"
 elif command -v wget >/dev/null 2>&1; then
    reponse="$(printf '%s' "$RAPPORT" | wget -qO- --timeout=15 \
               --header='Content-Type: application/json' --post-file=- "$SERVEUR/fiche")"
 else
    echo "Ni curl ni wget : la fiche n'a pas pu être envoyée." >&2
    exit 1
 fi
 if [ -n "$reponse" ]; then
    echo "$reponse"
 else
    echo "Le serveur n'a pas répondu — la fiche n'est pas enregistrée." >&2
    exit 1
 fi
--- a/code/linux/linux-mint/install.sh
+++ b/code/linux/linux-mint/install.sh
@ -1,14 +1,39 @@
 #!/bin/bash
 ##################################################
 # Fiche matérielle pour le serveur de l'install party
 #
 # Placée au début, et non à la fin : si un disque faiblit, autant le savoir
 # avant d'avoir passé une heure à installer dessus — c'est le moment où l'on
 # peut encore en parler à son propriétaire. Et si l'installation s'arrête en
 # route, on a tout de même la fiche.
 #
 # Le relevé est le script voisin du dépôt, lu et versionné comme celui-ci :
 # rien n'est téléchargé ni exécuté depuis le réseau. S'il n'est pas là, on
 # passe — la machine d'un particulier qui rejoue ce script chez elle ne doit
 # rien avoir à faire de tout ceci.
 #
 # C'est la seconde passe, celle que « sudo » relance, qui l'exécute :
 # dmidecode et smartctl demandent les droits d'administration.
 ##################################################
 if [ "$(id -u)" = "0" ] && [ -x "$(dirname "$0")/alpi-fiche.sh" ]; then
    "$(dirname "$0")/alpi-fiche.sh" || true
 fi
 # Script de post-installation pour Linux Mint 22.3
 # testé le 25/03/2026
 #
 # utilisation
-# wget https://gitea.alpinux.org/alpinux.cedrica5l/alpinux.site.2026/raw/branch/main/code/linux/linux-mint/install.sh 
+# wget https://gitea.alpinux.org/alpinux.cedrica5l/alpinux-wiki/raw/branch/main/code/linux/linux-mint/install.sh
 #  && chmod +x install.sh
 #  && ./install.sh
 GREEN=$'\e[32m'
 NC=$'\e[0m'
 abort() {
    echo ""
    echo ""
@ -98,7 +123,14 @@ opti_journald() {
 opti_fstab () {
    echo -e "==> Optimisation du montage des disques (noatime)\n"
-    # Replaces relatime with noatime everywhere in the file
+    # Remplace relatime par noatime partout dans le fichier.
    #
    # ATTENTION : sans effet sur une installation Mint 22.3. Le fstab qu'écrit
    # l'installateur ne mentionne ni « relatime » ni « noatime » — il s'en remet
    # à « defaults », et relatime est le comportement par défaut du noyau. Il n'y
    # a donc rien à substituer. Vérifié le 20/09/2026 sur une installation neuve.
    # Pour poser réellement noatime, il faudrait ajouter l'option aux lignes
    # concernées plutôt que d'en remplacer une qui n'y est pas.
    sudo sed -i 's/relatime/noatime/g' /etc/fstab
 }
@ -144,6 +176,7 @@ modif_systeme() {
    microcode
    opti_journald
    opti_fstab
    modif_grub
    mises_a_jour
@ -216,7 +249,7 @@ install_logiciels() {
    DEBIAN_FRONTEND=noninteractive apt install -y ttf-mscorefonts-installer || abort "problème lors de l'installation des polices"
    # mise à jour du système
-    echo "==> Mise à jour du système\n"
+    echo -e "==> Mise à jour du système\n"
    apt update || abort "impossible de récupérer les informations des dépôts"
    apt full-upgrade -y || abort "erreur lors de la mise à jour des paquets"
@ -278,7 +311,7 @@ install_logiciels() {
 # Mises à jour #
 ################
 mises_a_jour() {
-    echo -e "Configuraiton de dconf\n"
+    echo -e "==> Configuration de dconf\n"
    # Configuration de dconf pour permettre de modifier certaines configurations
    # par défaut
    mkdir -p /etc/dconf/profile
@ -326,11 +359,32 @@ configuration_apt() {
 # GRUB : sélection automatique de la dernière entrée utilisée #
 ###############################################################
 modif_grub() {
    # Rien à faire si c'est déjà en place.
    #
    # update-grub lance os-prober, qui part sonder toutes les partitions de la
    # machine à la recherche d'autres systèmes, puis régénère la configuration
    # entière : vingt à trente secondes qu'on ne rattrape pas, et qu'on payait
    # jusqu'ici à chaque exécution, y compris quand il n'y avait rien à
    # changer. Sur une install party de quinze machines, cela se voit.
    if grep -q '^GRUB_DEFAULT=saved' /etc/default/grub \
       && grep -q '^GRUB_SAVEDEFAULT=true' /etc/default/grub; then
        echo -e "==> GRUB est déjà configuré, rien à changer\n"
        return 0
    fi
    echo -e "==> Modification de GRUB\n"
-    # On comment la ligne "GRUB_DEFAULT=0" et on ajoute les "bonnes" options
+    # On commente la ligne d'origine, puis on ajoute les nôtres si elles
-    sed -i '/^GRUB_DEFAULT=0/ i#GRUB_DEFAULT=0\
+    # manquent. Les ajouter plutôt que les insérer règle deux choses : le
-    GRUB_DEFAULT=saved\
+    # fichier ne se retrouve plus avec des lignes indentées — GRUB les accepte,
-    GRUB_SAVEDEFAULT=true' /etc/default/grub
+    # mais elles trompent la lecture quand on vient déboguer —, et la fonction
    # fait toujours son travail lorsque « GRUB_DEFAULT=0 » a disparu, ce qui
    # arrive dès qu'un autre outil est passé avant nous.
    sed -i 's/^GRUB_DEFAULT=0/#&/' /etc/default/grub
    grep -q '^GRUB_DEFAULT=saved' /etc/default/grub \
        || echo 'GRUB_DEFAULT=saved' >> /etc/default/grub
    grep -q '^GRUB_SAVEDEFAULT=true' /etc/default/grub \
        || echo 'GRUB_SAVEDEFAULT=true' >> /etc/default/grub
    # On met à jour GRUB
    update-grub
 }
--- a/code/linux/linux-mint/verif-disque.sh
+++ b/code/linux/linux-mint/verif-disque.sh
@ -0,0 +1,236 @@
 #!/bin/bash
 #
 # Alpinux — état des lieux d'une machine avant d'installer Linux Mint
 #
 # À lancer depuis la session live, AVANT de toucher au disque :
 #   wget https://gitea.alpinux.org/alpinux.cedrica5l/alpinux-wiki/raw/branch/main/code/linux/linux-mint/verif-disque.sh
 #   chmod +x verif-disque.sh
 #   ./verif-disque.sh
 #
 # Ou, sur le réseau de l'install party :
 #   wget http://10.0.0.1/verif-disque.sh && chmod +x verif-disque.sh && ./verif-disque.sh
 #
 # Le script ne modifie RIEN : il lit, il affiche, il conseille. Il peut s'exécuter
 # sans droits d'administration, mais plusieurs vérifications les demandent : il
 # relance alors sudo de lui-même.
 #
 # testé le 20/09/2026 sur Linux Mint 22.3 Cinnamon
 set -u
 VERT=$'\e[32m'; ROUGE=$'\e[31m'; ORANGE=$'\e[33m'; GRAS=$'\e[1m'; RAZ=$'\e[0m'
 titre()   { printf '\n%s%s%s\n' "$GRAS" "$1" "$RAZ"; printf '%s\n' "${1//?/─}"; }
 ok()      { printf '  %s✓%s %s\n' "$VERT" "$RAZ" "$1"; }
 attention(){ printf '  %s!%s %s\n' "$ORANGE" "$RAZ" "$1"; }
 probleme(){ printf '  %s✗%s %s\n' "$ROUGE" "$RAZ" "$1"; }
 info()    { printf '    %s\n' "$1"; }
 # Les alertes collectées en chemin, résumées à la fin.
 AVERTISSEMENTS=()
 BLOQUANTS=()
 if [ "$(id -u)" != "0" ]; then
    echo "Certaines vérifications demandent les droits d'administration."
    exec sudo -- "$0" "$@"
 fi
 printf '%s\n' "════════════════════════════════════════════════════════════"
 printf '%s\n' " Alpinux — état des lieux avant installation"
 printf '%s\n' " $(date '+%d/%m/%Y %H:%M')"
 printf '%s\n' "════════════════════════════════════════════════════════════"
 # ─────────────────────────────────────────────────────────────────────
 titre "La machine"
 MODELE="$(cat /sys/devices/virtual/dmi/id/sys_vendor 2>/dev/null) $(cat /sys/devices/virtual/dmi/id/product_name 2>/dev/null)"
 info "Modèle        : ${MODELE:-inconnu}"
 info "Processeur    : $(grep -m1 'model name' /proc/cpuinfo | cut -d: -f2- | sed 's/^ //')"
 if grep -qw lm /proc/cpuinfo; then
    ok "Processeur 64 bits"
 else
    probleme "Processeur 32 bits : Linux Mint ne s'installera pas"
    BLOQUANTS+=("Processeur 32 bits — voir Debian ou LMDE")
 fi
 RAM_MO=$(( $(grep MemTotal /proc/meminfo | tr -dc '0-9') / 1024 ))
 info "Mémoire vive  : ${RAM_MO} Mo"
 if   [ "$RAM_MO" -lt 2000 ]; then
    probleme "Moins de 2 Go : en dessous du minimum de Linux Mint"
    BLOQUANTS+=("RAM insuffisante (${RAM_MO} Mo)")
 elif [ "$RAM_MO" -lt 4000 ]; then
    attention "Moins de 4 Go : conseillez l'édition Xfce plutôt que Cinnamon"
    AVERTISSEMENTS+=("RAM de ${RAM_MO} Mo — édition Xfce conseillée")
 else
    ok "Mémoire suffisante pour l'édition Cinnamon"
 fi
 # ─────────────────────────────────────────────────────────────────────
 titre "Le mode de démarrage"
 if [ -d /sys/firmware/efi ]; then
    ok "Démarrage en UEFI — le disque sera en GPT, avec une partition EFI"
    MODE=UEFI
    SB=/sys/firmware/efi/efivars/SecureBoot-8be4df61-93ca-11d2-aa0d-00e098032b8c
    if [ -r "$SB" ]; then
        if [ "$(od -An -t u1 "$SB" 2>/dev/null | awk '{print $5}')" = "1" ]; then
            attention "Secure Boot actif : à désactiver si un pilote propriétaire est nécessaire"
            AVERTISSEMENTS+=("Secure Boot actif")
        else
            ok "Secure Boot désactivé"
        fi
    fi
 else
    attention "Démarrage en BIOS hérité — le disque sera en MBR, sans partition EFI"
    MODE=BIOS
    AVERTISSEMENTS+=("Machine démarrée en mode BIOS hérité")
 fi
 # ─────────────────────────────────────────────────────────────────────
 titre "Les disques"
 mapfile -t DISQUES < <(lsblk -dn -o NAME,TYPE | awk '$2=="disk"{print $1}')
 NB_DISQUES=${#DISQUES[@]}
 if [ "$NB_DISQUES" -eq 0 ]; then
    probleme "Aucun disque détecté"
    BLOQUANTS+=("Aucun disque vu par le système — contrôleur SATA en RAID/Intel RST ?")
 elif [ "$NB_DISQUES" -gt 1 ]; then
    attention "$NB_DISQUES disques présents : identifiez le bon avant de partitionner"
    AVERTISSEMENTS+=("$NB_DISQUES disques — risque d'effacer le mauvais")
 fi
 for d in "${DISQUES[@]}"; do
    TAILLE=$(lsblk -dn -o SIZE "/dev/$d" | tr -d ' ')
    ROT=$(cat "/sys/block/$d/queue/rotational" 2>/dev/null)
    TYPE=$([ "$ROT" = "0" ] && echo "SSD/NVMe" || echo "disque mécanique")
    TABLE=$(blkid -p -s PTTYPE -o value "/dev/$d" 2>/dev/null || echo "aucune")
    printf '\n  %s/dev/%s%s — %s, %s, table %s\n' "$GRAS" "$d" "$RAZ" "$TAILLE" "$TYPE" "${TABLE:-aucune}"
    lsblk -o NAME,SIZE,FSTYPE,LABEL,FSUSE%,MOUNTPOINT "/dev/$d" | sed '1d;s/^/      /'
    TAILLE_GO=$(( $(lsblk -dbn -o SIZE "/dev/$d") / 1000000000 ))
    if [ "$TAILLE_GO" -lt 11 ]; then
        probleme "  Moins de 11 Go : l'installateur refusera de démarrer"
        BLOQUANTS+=("/dev/$d trop petit (${TAILLE_GO} Go)")
    elif [ "$TAILLE_GO" -lt 30 ]; then
        attention "  ${TAILLE_GO} Go : installable, mais en dessous des 30 Go conseillés"
        AVERTISSEMENTS+=("/dev/$d de ${TAILLE_GO} Go seulement")
    fi
    if [ "$MODE" = "UEFI" ] && [ "$TABLE" = "dos" ]; then
        attention "  Machine en UEFI mais disque en MBR : table à refaire en GPT"
        AVERTISSEMENTS+=("/dev/$d en MBR alors que la machine démarre en UEFI")
    fi
 done
 # ─────────────────────────────────────────────────────────────────────
 titre "Ce qui est déjà installé"
 TROUVE_WINDOWS=0
 TROUVE_LINUX=0
 while read -r part type; do
    [ -z "$part" ] && continue
    case "$type" in
        BitLocker)
            probleme "$part : partition chiffrée par BitLocker"
            BLOQUANTS+=("$part chiffrée BitLocker — suspendre le chiffrement depuis Windows AVANT de toucher au disque")
            TROUVE_WINDOWS=1
            ;;
        ntfs)
            TROUVE_WINDOWS=1
            ETIQUETTE=$(blkid -s LABEL -o value "$part" 2>/dev/null)
            ok "$part : partition Windows (NTFS)${ETIQUETTE:+ — « $ETIQUETTE »}"
            POINT=$(mktemp -d)
            if mount -o ro,noexec,nosuid "$part" "$POINT" 2>/dev/null; then
                [ -f "$POINT/hiberfil.sys" ] && {
                    attention "  hiberfil.sys présent : Windows est en veille prolongée ou en démarrage rapide"
                    AVERTISSEMENTS+=("$part : désactiver le démarrage rapide de Windows, puis arrêt complet")
                }
                [ -d "$POINT/Windows" ] && info "  Windows installé sur cette partition"
                umount "$POINT" 2>/dev/null
            else
                attention "  Montage impossible en lecture seule : partition sale, chiffrée, ou mal démontée"
                AVERTISSEMENTS+=("$part illisible — Windows mal arrêté ?")
            fi
            rmdir "$POINT" 2>/dev/null
            ;;
        ext4|ext3|btrfs|xfs)
            ETIQUETTE=$(blkid -s LABEL -o value "$part" 2>/dev/null)
            ok "$part : partition Linux ($type)${ETIQUETTE:+ — « $ETIQUETTE »}"
            TROUVE_LINUX=1
            ;;
        vfat)
            if [ "$(blkid -s PARTLABEL -o value "$part" 2>/dev/null)" = "EFI system partition" ] \
               || [ "$(lsblk -no PARTTYPENAME "$part" 2>/dev/null)" = "EFI System" ]; then
                ok "$part : partition EFI existante — à réutiliser, pas à recréer"
            fi
            ;;
        crypto_LUKS)
            attention "$part : partition chiffrée LUKS"
            AVERTISSEMENTS+=("$part chiffrée (LUKS) — récupérer la phrase de passe avant d'effacer")
            ;;
    esac
 done < <(lsblk -pnl -o NAME,FSTYPE | awk 'NF==2 && $1 ~ /[0-9]$/')
 [ "$TROUVE_WINDOWS" = "0" ] && info "Aucune partition Windows détectée."
 if [ "$TROUVE_LINUX" = "1" ]; then
    attention "Un système Linux occupe déjà ce disque"
    AVERTISSEMENTS+=("Linux déjà installé — sauvegarder /home avant de réinstaller")
 fi
 # ─────────────────────────────────────────────────────────────────────
 titre "Santé des disques"
 if command -v smartctl >/dev/null; then
    for d in "${DISQUES[@]}"; do
        SANTE=$(smartctl -H "/dev/$d" 2>/dev/null | grep -Ei 'overall-health|SMART Health' | cut -d: -f2- | sed 's/^ *//')
        case "$SANTE" in
            *PASSED*|*OK*) ok "/dev/$d : $SANTE" ;;
            "")            info "/dev/$d : pas d'information SMART (disque virtuel, USB, ou contrôleur muet)" ;;
            *)             probleme "/dev/$d : $SANTE"
                           BLOQUANTS+=("/dev/$d signalé défaillant par SMART — ne pas installer dessus") ;;
        esac
        REALLOC=$(smartctl -A "/dev/$d" 2>/dev/null | awk '/Reallocated_Sector_Ct/{print $10}')
        if [ -n "${REALLOC:-}" ] && [ "$REALLOC" -gt 0 ] 2>/dev/null; then
            attention "/dev/$d : $REALLOC secteurs réalloués — disque fatigué"
            AVERTISSEMENTS+=("/dev/$d : $REALLOC secteurs réalloués")
        fi
    done
 else
    info "smartmontools absent de la session live."
    info "Pour l'ajouter : sudo apt update && sudo apt install -y smartmontools"
 fi
 # ─────────────────────────────────────────────────────────────────────
 titre "Réseau"
 if ping -c1 -W3 archive.ubuntu.com >/dev/null 2>&1; then
    ok "Connexion à Internet fonctionnelle (mises à jour et codecs téléchargeables)"
 else
    attention "Pas d'accès à Internet : branchez le câble réseau avant d'installer"
    AVERTISSEMENTS+=("Pas de réseau — codecs et mises à jour ne s'installeront pas")
 fi
 # ─────────────────────────────────────────────────────────────────────
 titre "Conclusion"
 if [ ${#BLOQUANTS[@]} -gt 0 ]; then
    printf '  %s%sÀ RÉGLER AVANT D'"'"'INSTALLER%s\n' "$GRAS" "$ROUGE" "$RAZ"
    for b in "${BLOQUANTS[@]}"; do printf '    %s✗%s %s\n' "$ROUGE" "$RAZ" "$b"; done
    echo
 fi
 if [ ${#AVERTISSEMENTS[@]} -gt 0 ]; then
    printf '  %s%sÀ SAVOIR%s\n' "$GRAS" "$ORANGE" "$RAZ"
    for a in "${AVERTISSEMENTS[@]}"; do printf '    %s!%s %s\n' "$ORANGE" "$RAZ" "$a"; done
    echo
 fi
 if [ ${#BLOQUANTS[@]} -eq 0 ] && [ ${#AVERTISSEMENTS[@]} -eq 0 ]; then
    printf '  %s✓%s Rien ne s'"'"'oppose à l'"'"'installation.\n\n' "$VERT" "$RAZ"
 fi
 printf '  Dans le doute, montrez cet écran à un bénévole avant de continuer.\n'
 printf '  Guide complet : https://wiki.alpinux.org/guides/linux-mint-depuis-windows/\n\n'
--- a/docs/alpinux/donnees-personnelles.md
+++ b/docs/alpinux/donnees-personnelles.md
@ -0,0 +1,134 @@
 ---
 description: Comment Alpinux recueille les adresses e-mail, quels messages l'association envoie, combien de temps elle conserve vos données et comment exercer vos droits.
 ---
 # ✉️ Vos données, vos adresses, nos envois
 Alpinux recueille des adresses e-mail pour faire fonctionner ses activités : vous
 inscrire à une install party, vous prévenir qu'un rendez-vous a bougé, vous envoyer
 la lettre d'information, tenir à jour la liste des adhérents. Cette page dit lesquelles, pourquoi, pour combien de temps,
 et ce que vous pouvez exiger de nous.
 **En une phrase :** une adresse donnée à Alpinux ne sert qu'à ce pour quoi elle a été
 donnée. Nous ne la revendons pas, ne la partageons pas, et nous ne vous écrivons que
 pour ce que vous avez demandé.
 ---
 ## Où nous recueillons une adresse
 | Occasion | Ce que nous recueillons |
 |---|---|
 | **Inscription à une install party** | Nom, adresse e-mail, téléphone (facultatif), description de la machine et de ses périphériques, et ce que vous voulez bien nous en dire |
 | **Inscription comme installateur ou installatrice** | Prénom, nom, adresse e-mail, heures de présence annoncées |
 | **Organisation d'une install party** | L'adresse e-mail des personnes à qui l'on confie l'organisation ou l'administration de l'événement |
 | **Adhésion à l'association** | Recueillie par **HelloAsso** au moment de l'adhésion ; les coordonnées des adhérents sont ensuite tenues dans **Dolibarr**, sur le serveur de l'association |
 | **Compte AlpID** | Votre identifiant, votre nom et votre adresse e-mail, conservés par notre service d'authentification |
 | **Un message que vous nous envoyez** | Ce que contient votre message, et l'adresse qui l'a envoyé |
 Aucun de nos sites ne collecte d'adresse à votre insu : il faut toujours l'avoir
 saisie dans un formulaire, ou nous avoir écrit.
 ---
 ## Ce que nous envoyons
 Tous nos messages automatiques viennent de l'application **Install Party**, et partent
 de l'adresse **Alpinux &lt;alpinux@alpinux.org&gt;**. Ce sont des messages en texte
 simple, sans image ni traceur : rien ne nous dit si vous les avez ouverts.
 ### Si vous vous êtes inscrit à une install party
 | Message | Quand il part |
 |---|---|
 | Confirmation d'inscription | Dès l'inscription enregistrée — il porte le lieu, l'horaire et le lien vers votre fiche |
 | Lien vers votre espace | Quand vous demandez à retrouver votre inscription |
 | Votre rendez-vous passe à telle heure | Quand l'organisation déplace votre créneau |
 | Votre fiche d'installation | Le soir (19 h 30) du jour où un bénévole a noté quelque chose sur votre installation — un seul message, même s'il y a eu plusieurs notes |
 ### Si vous êtes bénévole sur une install party
 | Message | Quand il part |
 |---|---|
 | Votre code installateur | À votre inscription comme installateur |
 | Vos heures de présence | Relance quand vos disponibilités manquent encore |
 | Les fiches d'installation sont prêtes | Quand l'organisation ouvre les fiches avant l'événement |
 | Note sur l'installation de telle heure | Quand une note est ajoutée sur une machine dont vous vous occupez |
 | Rendez-vous déplacé | Quand un créneau que vous teniez change d'heure |
 | Nouvel installateur | À l'organisation, quand quelqu'un rejoint l'équipe |
 Chacun de ces messages répond à quelque chose que vous avez fait, ou à un changement
 qui vous concerne directement.
 ---
 ## La lettre d'information
 C'est notre seul envoi régulier : **deux à quatre fois par mois**, un message qui
 annonce les prochains rendez-vous, les install parties, les présentations et ce qui
 occupe l'association. Il part du serveur de l'association.
 **Qui la reçoit.** Les adhérents, et toute personne qui a demandé à la recevoir. Une
 inscription à une install party ne vous y abonne pas : il faut l'avoir demandé. Pour
 la recevoir sans être adhérent, abonnez-vous vous-même sur
 **[messagerie.alpinux.org](https://messagerie.alpinux.org)** — la marche à suivre est
 décrite dans [S'abonner et se désabonner](messagerie-abonnement.md#inscription).
 **Comment s'en aller.** Chaque envoi porte un lien de désinscription, en pied de page
 et dans ses en-têtes. Un clic suffit, il n'y a rien à justifier, et le retrait est
 immédiat. Vous continuerez à recevoir les
 messages liés à vos inscriptions en cours — ce sont deux choses distinctes.
 ---
 ## Ce que nous n'envoyons pas
 - **Pas de démarchage**, ni pour nous, ni pour personne d'autre.
 - **Pas de transmission à des tiers.** Vos coordonnées ne sortent pas de l'association,
  sauf obligation légale.
 - **Pas de revente.** Jamais, à personne, à aucun prix.
 ---
 ## Qui voit votre adresse
 - **Pour une install party** : les personnes qui organisent cet événement-là, et les
  bénévoles qui s'occupent de votre machine. Pas les autres install parties.
 - **Pour une adhésion** : les membres du bureau qui tiennent le registre dans Dolibarr.
 - **Pour un compte AlpID** : nos applications (quiz, administration) voient votre
  adresse le temps de votre session ; elles ne la conservent pas dans leur base.
 ---
 ## Combien de temps nous les gardons
 - **Les données d'une install party** sont conservées **13 mois**, puis supprimées.
  Elles servent à nos statistiques d'activité et à nos obligations d'association
  loi 1901. Vous pouvez demander à les conserver plus longtemps, par exemple pour
  qu'on retrouve l'historique de votre machine à la prochaine install party.
 - **Si vous annulez votre inscription**, tout part immédiatement : votre fiche, vos
  coordonnées, et les photos qui auraient été jointes.
 - **Les données d'adhésion** sont conservées le temps requis pour la tenue des
  comptes et du registre des membres.
 ---
 ## Vos droits
 Vous pouvez à tout moment demander à **accéder** à vos données, à les faire
 **corriger**, ou à les faire **supprimer**.
 - Pour vos données personnelles : **dpo@alpinux.org**
 - Pour toute autre question : **secretaire@alpinux.org**
 Une demande de suppression est traitée dès réception. Si nous devons garder une trace
 pour une obligation légale, nous vous le disons et nous vous disons laquelle.
 ---
 ## Qui traite ces données
 **Alpinux**, association loi 1901, Chambéry (Savoie). Les inscriptions, le registre
 des membres et les envois sont gérés par nos propres applications — Install Party et
 Dolibarr — hébergées sur le serveur de l'association. Seules les adhésions passent par
 **HelloAsso**, qui applique sa propre politique de confidentialité.
--- a/docs/alpinux/index.md
+++ b/docs/alpinux/index.md
@ -13,6 +13,13 @@ L'association propose également des **services numériques** à ses membres.
 [Gérer son adhésion](https://www.helloasso.com/associations/alpinux-le-lug-de-savoie){ .md-button }
 [Install Party](install-party.md){ .md-button }
 ## Vos données
 Ce que nous faisons de votre adresse e-mail, ce que nous vous envoyons, et ce que
 nous ne vous enverrons jamais.
 [Vos données, vos adresses, nos envois](donnees-personnelles.md){ .md-button }
 ## Événements
 [Tous les événements et rendez-vous](evenements.md){ .md-button .md-button--primary }
--- a/docs/alpinux/install-party.md
+++ b/docs/alpinux/install-party.md
@ -58,6 +58,7 @@ Lors de nos **Install Party**, les bénévoles d'**Alpinux** installent Linux av
 ## 🧰 Après l'installation
 - 🩹 [**Trousse de premiers secours Linux Mint**](../guides/linux-mint-trousse.md) — les réflexes utiles des premiers jours.
 - 🖧 [**Le serveur qu'on emporte**](../technique/serveur-install-party.md) — le réseau de la salle, le cache de paquets, et ce qu'un bénévole doit en savoir.
 - 🗣️ [**Ateliers et rencontres**](evenements.md) — pour progresser et échanger avec la communauté.
 ---
--- a/docs/alpinux/installparty-benevole.md
+++ b/docs/alpinux/installparty-benevole.md
@ -0,0 +1,113 @@
 ---
 description: Pour les bénévoles installateurs d'Alpinux : retrouver ses accès, annoncer ses heures de présence, préparer les machines et répondre aux participants.
 ---
 # 🔧 J'aide comme bénévole installateur
 Cette page est pour l'équipe qui installe. Les autres usages du site ont
 [leur propre page](installparty-mode-emploi.md).
 ---
 ## Retrouver ses accès
 ![L'écran où l'on donne son adresse](../assets/installparty/03-espace-connexion.png)
 [installparty.alpinux.org/party/moi](https://installparty.alpinux.org/party/moi)
 est le seul endroit où l'on saisit son adresse. Vous y recevez un lien — valable
 une demi-heure — qui ouvre tout ce que cette adresse ouvre.
 ![L'espace personnel : ce que votre adresse ouvre](../assets/installparty/04-espace-personnel.png)
 On y trouve son **code installateur**, les machines dont on s'occupe, et le lien
 vers sa grille.
 ## Entrer dans son espace : deux codes
 ![L'écran qui demande le code à quatre chiffres](../assets/installparty/07-deux-codes.png)
 - **Le code installateur**, quatre caractères, donné par l'organisation ;
 - **un code à quatre chiffres**, que vous choisissez.
 Le premier se dicte au téléphone, donc il se devine ; le second le protège.
 ### À votre première venue
 Saisissez votre code installateur et laissez le second champ vide : un lien part
 vers votre boîte et vous fait choisir vos quatre chiffres.
 ![Le choix du code à quatre chiffres](../assets/installparty/08-choisir-son-code.png)
 Le lien vaut une demi-heure. Oublié votre code ? Demandez-en un autre depuis la
 page de connexion — le nouveau remplace l'ancien.
 !!! tip "Faites-le avant le jour J"
    Le choix du code passe par votre boîte aux lettres. Le faire tranquillement
    chez soi vaut mieux que de s'y prendre en salle, un samedi matin.
 ## Annoncer ses heures
 ![La grille des heures de présence et les rendez-vous du jour](../assets/installparty/05-espace-installateur.png)
 !!! warning "Vos heures ouvrent les places"
    Le nombre de créneaux proposés au public **se calcule à partir des heures
    annoncées**. Une grille vide n'ouvre aucune place : ce n'est pas une
    formalité, c'est ce qui décide du nombre de personnes qu'on pourra recevoir.
 Cochez les heures où vous serez là. L'enregistrement est automatique, et vous
 pouvez y revenir autant de fois que votre journée change — l'organisation le
 voit aussitôt.
 Le tableau **« Où en est la journée ? »** montre, heure par heure, combien
 d'installateurs sont annoncés, combien seront occupés et combien restent
 disponibles. Une colonne dégarnie se comble en cochant une heure de plus.
 ## Préparer les installations
 Sous les rendez-vous du jour, vous voyez qui vient, avec quelle machine et ce que
 la personne a signalé — **sans ses coordonnées** : s'il faut joindre quelqu'un,
 c'est l'organisation qui s'en charge.
 Vous pouvez :
 - **écrire ce qu'il y a à prévoir** dans la note « À prévoir avant
  l'installation » : un dongle, un pilote, un point à vérifier ;
 - **vous charger d'une machine**, pour que l'équipe sache qui s'en occupe. Votre
  nom s'affiche alors à côté du rendez-vous ;
 - **répondre** aux questions du participant, et joindre un document ou une photo.
 !!! danger "La personne inscrite lit cette note"
    « À prévoir avant l'installation » s'affiche sur sa fiche, sous le titre
    « Informations importantes », et un message l'avertit le soir même.
    Écrivez-la comme si elle la lisait, parce qu'elle la lira.
 Les versions précédentes de la note restent consultables, avec leur auteur : on
 peut voir ce qui a été modifié, et reprendre une version antérieure si besoin.
 ## Le jour de l'install party
 La **fiche d'installation** — les points à cocher — s'ouvre le jour même. D'ici
 là, il n'y a rien à y noter.
 Pour l'ouvrir, deux chemins : depuis votre espace si vous vous êtes déjà chargé
 de la machine, ou en donnant le **numéro de réservation** que la personne annonce
 à l'accueil.
 ---
 ## Questions courantes
 ??? question "Je me suis inscrit par un lien, et je ne vois aucun rendez-vous"
    Votre inscription attend d'être confirmée par l'équipe. En attendant, vous
    pouvez cocher vos heures — c'est même le plus utile. Vous recevrez un message
    quand ce sera fait.
 ??? question "Je me suis trompé plusieurs fois de code"
    Au bout de quelques essais, l'accès se ferme quelques minutes. Cela ne
    concerne que vous : vos collègues, même sur le même réseau, ne sont pas
    gênés.
 ??? question "Puis-je laisser une machine à quelqu'un d'autre ?"
    Oui, tant que vous n'avez rien écrit sur sa fiche : le bouton « Je ne m'en
    occupe plus » la rend disponible. Une fois que vous y avez noté quelque
    chose, votre nom y reste — une fiche doit pouvoir dire qui l'a remplie.
--- a/docs/alpinux/installparty-mode-emploi.md
+++ b/docs/alpinux/installparty-mode-emploi.md
@ -0,0 +1,47 @@
 ---
 description: Le mode d'emploi du site des install parties d'Alpinux, selon que vous venez faire installer Linux, que vous aidez comme bénévole ou que vous organisez la journée.
 ---
 # 🐧 Le site des install parties
 Les install parties d'<span class="alpinux-brand">A<strong>l</strong>p<strong>inux</strong></span>
 se tiennent avec un outil à nous : **[installparty.alpinux.org](https://installparty.alpinux.org)**.
 On y réserve son créneau, on y suit ce qui a été fait sur sa machine, et les
 bénévoles y préparent leur journée.
 !!! info "Pas de compte, pas de mot de passe"
    Il n'y a rien à créer et rien à retenir. Tout passe par des liens reçus par
    courriel et, pour les bénévoles, par un code personnel. Une adresse donnée
    ici ne sert qu'à l'install party.
 ---
 ## Trois façons d'utiliser le site
 ### 💻 [Je viens faire installer Linux](installparty-participant.md)
 Choisir son créneau, s'inscrire, et suivre la fiche de sa machine avant, pendant
 et après l'install party. Vous pouvez aussi y écrire aux bénévoles.
 ### 🔧 [J'aide comme bénévole installateur](installparty-benevole.md)
 Retrouver ses accès, annoncer ses heures de présence — ce sont elles qui ouvrent
 les places —, préparer les machines qu'on prendra et répondre aux questions.
 ### 📋 [J'organise une install party](installparty-organisateur.md)
 Tenir la journée : horaires, places, équipe, fiches. Et ce qu'il faut savoir sur
 les liens d'accès, qui valent mot de passe.
 ---
 ## Où trouver quoi
 | Vous cherchez | Adresse |
 |---|---|
 | La prochaine install party, et s'y inscrire | [installparty.alpinux.org](https://installparty.alpinux.org) |
 | Vos accès : code installateur, liens, inscriptions | [/party/moi](https://installparty.alpinux.org/party/moi) |
 | La fiche de votre machine | le lien personnel reçu à l'inscription |
 Une question à laquelle ces pages ne répondent pas ? Écrivez-nous — l'adresse
 figure au bas des messages que vous recevez.
--- a/docs/alpinux/installparty-organisateur.md
+++ b/docs/alpinux/installparty-organisateur.md
@ -0,0 +1,107 @@
 ---
 description: Pour les organisateurs d'une install party Alpinux : tenir la journée, gérer l'équipe et les créneaux, et les règles à connaître sur les liens d'accès.
 ---
 # 📋 J'organise une install party
 Cette page est pour qui tient une install party de bout en bout. Les autres
 usages du site ont [leur propre page](installparty-mode-emploi.md).
 ---
 ## L'espace d'organisation
 ![L'espace d'organisation : horaires, places, équipe](../assets/installparty/09-organisation.png)
 Tout s'y tient : les horaires et leurs places, l'équipe et ses heures, les
 inscrits et leurs fiches, la check-list.
 !!! danger "Le lien vaut mot de passe"
    L'adresse de cette page contient une clé. Quiconque l'a peut voir les
    inscrits, les modifier et les supprimer.
    - Ne la publiez **jamais** : ni sur une affiche, ni dans un code QR, ni dans
      un message à plusieurs. Voir
      [Liens et codes QR](../communication/liens-et-codes-qr.md).
    - Elle **cesse de valoir trente minutes** après votre dernière action. On en
      redemande une depuis [/party/moi](https://installparty.alpinux.org/party/moi),
      ce qui remplace l'ancienne.
 ## Les places se calculent
 Le nombre de places d'un créneau n'est pas saisi : il se **déduit** des
 installateurs annoncés présents pendant toute la durée d'une installation,
 pondérés par la charge que vous fixez.
 - Huit installateurs présents, charge à 90 % : sept places.
 - Baisser la charge garde de la marge — le temps d'accueillir, de dépanner un
  voisin, de souffler.
 - Vous pouvez ajouter ou retirer une place à la main ; l'écart est conservé même
  si l'équipe change.
 Une conséquence : **relancer les installateurs qui n'ont pas coché leurs heures
 ouvre des places**. Le bouton est sur la page, à côté de ceux qui manquent.
 ## L'équipe
 Deux façons d'entrer dans l'équipe :
 - **vous ajoutez quelqu'un** : il reçoit son code, et voit tout aussitôt ;
 - **quelqu'un s'inscrit** par le lien d'inscription des installateurs : il
  attend votre confirmation avant de voir les rendez-vous, et ses heures
  n'ouvrent pas de place d'ici là. La page le signale par « inscrit lui-même ·
  à confirmer ».
 Cette différence est voulue : le lien d'inscription circule sur les listes de
 diffusion, et s'inscrire ne doit pas suffire à voir chez qui l'on va installer.
 ## Les coordonnées ne s'affichent pas
 L'adresse et le téléphone de chaque inscrit sont masqués. Un bouton les demande,
 et **chaque demande est inscrite au journal**.
 ![L'historique : ce qui a été fait, et depuis où](../assets/installparty/10-historique.png)
 La page **Historique** montre, pour votre install party : quand, quoi, sur qui,
 depuis quelle adresse et avec quel navigateur. Elle sert à une chose — savoir ce
 qui a été consulté si un accès venait à fuiter.
 Les adresses IP s'effacent d'elles-mêmes au bout de six mois.
 ## Avant la journée
 - **Composer la check-list** que suivront les installateurs : un modèle existe,
  à adapter.
 - **Annoncer que les fiches sont prêtes** : un bouton prévient toute l'équipe
  qu'elle peut préparer les machines.
 - **Écrire ce qu'il y a à prévoir** sur les fiches que vous connaissez déjà —
  ce que la personne a dit au téléphone, par exemple.
 - **Vérifier l'écran de salle** : il affiche les rendez-vous à l'accueil, sans
  aucune coordonnée. Sa clé est distincte de la vôtre, parce qu'un écran se
  photographie.
 ## Le jour même
 - Les participants annoncent leur **numéro de réservation** à l'accueil.
 - Un rendez-vous peut être **déplacé** d'un créneau à l'autre : la personne et
  les installateurs concernés en sont prévenus, et la fiche suit.
 - Les fiches se remplissent ; vous pouvez les relire et les corriger.
 ---
 ## Questions courantes
 ??? question "J'ai perdu le lien de mon install party"
    [/party/moi](https://installparty.alpinux.org/party/moi), avec l'adresse
    enregistrée pour cette install party. Si personne ne l'a plus, écrivez à
    l'association.
 ??? question "Une clé a été publiée par erreur"
    Renouvelez-la immédiatement en redemandant votre lien, puis regardez
    l'Historique pour savoir ce qui a été consulté. La marche à suivre complète
    est dans [Liens et codes QR](../communication/liens-et-codes-qr.md).
 ??? question "Comment ouvrir une nouvelle install party ?"
    Votre adresse doit y être autorisée. Depuis
    [/party/moi](https://installparty.alpinux.org/party/moi), un bouton
    « Ouvrir une install party » apparaît si c'est le cas.
--- a/docs/alpinux/installparty-participant.md
+++ b/docs/alpinux/installparty-participant.md
@ -0,0 +1,130 @@
 ---
 description: S'inscrire à une install party Alpinux, comprendre ce qu'on vous demande, et suivre la fiche de votre machine avant, pendant et après la journée.
 ---
 # 💻 Je viens faire installer Linux
 Cette page suit votre parcours, de l'inscription au compte rendu de
 l'installation. Les autres usages du site ont
 [leur propre page](installparty-mode-emploi.md).
 ---
 ## 1. Choisir son créneau
 Depuis [installparty.alpinux.org](https://installparty.alpinux.org), vous arrivez
 sur la liste des install parties à venir.
 ![La liste des install parties ouvertes aux inscriptions](../assets/installparty/01-liste-publique.png)
 Chaque carte indique la date, le lieu et s'il reste de la place. Un clic sur
 **S'inscrire** ouvre le formulaire.
 ## 2. S'inscrire
 ![Le formulaire d'inscription, avec le choix de l'heure](../assets/installparty/02-inscription.png)
 Ce qu'on vous demande, et pourquoi :
 | Ce qu'on demande | À quoi cela sert |
 |---|---|
 | Votre nom | vous accueillir, et retrouver votre machine dans la journée |
 | Votre adresse électronique | vous envoyer votre confirmation et le suivi |
 | Votre téléphone | vous joindre le jour même si besoin — facultatif |
 | La machine et son âge | préparer ce qu'il faut : une clé, un pilote, un adaptateur |
 | Ce que vous signalez | tout ce que vous jugez utile : un bruit, une lenteur, un doute |
 | L'heure de passage | les créneaux restants s'affichent seuls |
 Deux cases sont à cocher : **vos sauvegardes sont faites** et vous avez lu la
 décharge.
 !!! danger "Les sauvegardes ne sont pas une formalité"
    Une installation efface le disque. Copiez vos documents, vos photos et vos
    mots de passe sur un disque externe ou une clé **avant** de venir. Les
    bénévoles vous aideront volontiers à le faire, mais cela prend du temps —
    autant arriver prêt.
 ## 3. Après l'inscription
 Vous recevez un courriel avec :
 - **votre numéro de réservation**, à annoncer à l'accueil le jour J ;
 - **un lien personnel** vers la fiche de votre machine. Gardez-le : c'est par
  lui qu'on la retrouve, pendant **douze mois après l'install party**.
 ## 4. Suivre la fiche de sa machine
 ![La fiche d'installation vue par le participant](../assets/installparty/06-fiche-participant.png)
 Cette page vit avant, pendant et après l'install party.
 Pour l'ouvrir, cliquez sur votre lien : la page vous propose de vous envoyer
 une clé, et un message arrive aussitôt.
 **Avant**, les bénévoles y notent ce qu'il faudra prévoir pour votre machine —
 sous « Informations importantes ». Lisez-le : on vous y demande parfois
 d'apporter un câble, de retrouver un mot de passe ou de préciser un détail.
 **Pendant**, elle se remplit au fur et à mesure : ce qui a été vérifié, ce qui a
 été installé, ce qui reste à faire.
 **Après**, elle reste consultable pendant douze mois. C'est le compte rendu de
 ce qui a été fait sur votre machine : si vous y tenez, imprimez-la ou
 enregistrez-la avant la fin de ce délai.
 Un message vous prévient le soir quand quelque chose a changé.
 ## 5. Écrire aux bénévoles
 Le bloc **« Répondre »**, en bas de votre fiche, envoie votre message aux
 bénévoles qui préparent votre passage : un doute sur ce qu'on vous demande
 d'apporter, une machine de plus, un empêchement.
 Vous pouvez y joindre une **photo ou une capture d'écran** — un message d'erreur
 se montre mieux qu'il ne se décrit.
 !!! info "Une clé vous est envoyée à chaque visite"
    Votre lien dit **quelle** fiche vous demandez ; il ne l'ouvre pas. Nous
    envoyons une clé à l'adresse de votre inscription : elle ouvre la fiche pour
    une demi-heure, le temps de la lire et de répondre. Tant que vous y êtes,
    rien ne vous est redemandé.
    Pourquoi : un lien qu'on garde finit par traîner — dans une archive, une
    boîte partagée, un téléphone changé. Ce qu'on a noté sur votre machine ne
    regarde que vous.
 !!! warning "Ne répondez pas au courriel"
    Les messages que le site vous envoie partent d'une adresse automatique.
    Une réponse n'atteindrait pas les bénévoles et se perdrait : utilisez le bloc
    « Répondre » de votre fiche.
 ---
 ## Questions courantes
 ??? question "J'ai perdu le lien de ma fiche"
    Rendez-vous sur [installparty.alpinux.org/party/moi](https://installparty.alpinux.org/party/moi),
    donnez l'adresse avec laquelle vous vous êtes inscrit, et tout ce que cette
    adresse ouvre vous est renvoyé — la fiche comprise.
 ??? question "Ma clé ne fonctionne plus"
    Une clé reçue par courriel vaut une demi-heure — comme toutes celles que
    nous envoyons. Redemandez-en une depuis votre lien : elle repart aussitôt.
 ??? question "Mon lien ne fonctionne plus"
    Les fiches se ferment douze mois après l'install party. Passé ce délai, le
    lien ne mène plus à rien : ce qui a été fait sur votre machine ne nous
    regarde plus, et nous n'avons pas de raison de le garder consultable
    indéfiniment.
 ??? question "Je ne peux plus venir"
    Dites-le nous : votre place sera rendue à quelqu'un d'autre, et vos
    informations effacées si vous le souhaitez. L'adresse figure au bas des
    messages que vous avez reçus.
 ??? question "Qui voit mes coordonnées ?"
    L'organisation, et seulement en les demandant — chaque consultation est
    inscrite au journal de l'install party. Les bénévoles installateurs, eux,
    voient votre nom, votre machine et ce que vous avez signalé, mais **ni votre
    adresse ni votre téléphone**. Voir
    [Vos données, vos adresses, nos envois](donnees-personnelles.md).
--- a/docs/alpinux/messagerie-abonnement.md
+++ b/docs/alpinux/messagerie-abonnement.md
@ -0,0 +1,130 @@
 ---
 description: Comment s'abonner à une liste de diffusion d'Alpinux, confirmer son adresse, se désabonner, et lire les messages déjà envoyés.
 ---
 # ✉️ S'abonner et se désabonner
 Ce guide s'adresse à toute personne qui veut **recevoir les annonces de
 l'association**, ou cesser de les recevoir. Aucun compte n'est nécessaire.
 **En une phrase :** vous vous abonnez et vous vous désabonnez vous-même, personne ne
 peut le faire à votre place, et rien ne part vers une adresse qui ne l'a pas
 demandé.
 ---
 ## S'abonner { #inscription }
 Rendez-vous sur la page d'accueil de la messagerie de l'association.
 ![La page d'accueil : votre adresse, la liste, et c'est tout](../assets/messagerie/abonnement-01-accueil.png)
 Indiquez votre adresse de courriel, choisissez la liste qui vous intéresse, puis
 **Continuer**.
 L'écran suivant affiche un **code** — de la forme `ALPX-7K3M9Q` — et vous demande de
 faire une chose, une seule :
 !!! tip "Envoyez-nous un message depuis l'adresse que vous venez de saisir"
    Destinataire : **messagerie@alpinux.org**
    Objet : **le code affiché**, recopié tel quel
    Corps du message : ce que vous voulez, il n'est pas lu
 ![Le code à recopier, l'adresse où écrire, et l'heure limite](../assets/messagerie/abonnement-02-code.png)
 Un bouton **Ouvrir mon logiciel de messagerie** prépare le message pour vous. Il ne
 l'envoie pas : c'est à vous de le faire.
 Vous avez **trente minutes**. Passé ce délai, le code ne vaut plus rien et la demande
 s'efface d'elle-même — sans aucune conséquence, vous pouvez recommencer.
 Dans la minute qui suit votre envoi, vous recevez une réponse qui confirme
 l'inscription, rappelle la liste, et porte déjà le lien pour partir.
 ![La réponse reçue une fois le code envoyé](../assets/messagerie/abonnement-03-confirmation.png)
 ### Pourquoi est-ce à moi d'écrire ?
 D'habitude, un site vous envoie un courriel de confirmation. Ici, c'est l'inverse.
 Trois raisons.
 - **Rien ne part vers une adresse non vérifiée.** Écrire à des adresses non
  confirmées est ce qui abîme le plus la réputation d'un expéditeur — et quand elle
  est abîmée, ce sont les messages de toute l'association qui finissent en
  indésirable, chez tout le monde.
 - **Inscrire l'adresse de quelqu'un d'autre ne lui envoie rien.** La demande reste en
  attente puis s'efface. Personne ne peut vous abonner à votre insu, ni se servir de
  ce formulaire pour vous faire parvenir un message.
 - **Un message venu de votre boîte prouve mieux que vous la possédez** qu'un clic sur
  un lien : certains antivirus d'entreprise cliquent les liens tout seuls.
 La contrepartie, c'est une manipulation à faire. Elle est assumée.
 ### Je me suis déjà abonné, ou désabonné, par le passé
 Le parcours est le même. C'est d'ailleurs **le seul moyen de revenir** : l'association
 ne réinscrit jamais personne de sa propre initiative.
 ### Je n'ai pas reçu la confirmation
 Trois choses à vérifier, dans cet ordre :
 1. **Avez-vous écrit depuis l'adresse que vous aviez saisie ?** Le code ne vaut que
   présenté depuis celle-ci. Un message envoyé depuis une autre boîte est refusé.
 2. **Les trente minutes sont-elles passées ?** Recommencez, c'est sans conséquence.
 3. **Le code était-il bien dans l'objet ?** Il est aussi reconnu dans le corps du
   message, mais l'objet est le plus sûr.
 ---
 ## Se désabonner { #desabonnement }
 **Chaque message reçu porte un lien de désabonnement**, à deux endroits : en pied de
 page, et dans les en-têtes techniques du message.
 C'est ce second emplacement qui fait apparaître un bouton **Se désabonner** en haut
 du message dans les logiciels modernes — Gmail, Outlook, Thunderbird, Apple Mail. Un
 clic suffit.
 ![Le bouton « Se désabonner » qu'affiche votre logiciel de messagerie](../assets/messagerie/abonnement-04-bouton-desabonner.png)
 La page qui s'ouvre vous laisse choisir :
 - quitter **cette liste seulement** ;
 - ou quitter **toutes les listes** de l'association d'un coup.
 ![Quitter cette liste, ou toutes](../assets/messagerie/abonnement-05-desabonnement.png)
 Aucune justification n'est demandée. Le retrait est immédiat, et il n'y a personne à
 qui écrire.
 !!! note "Vous n'avez plus aucun message sous la main ?"
    Reprenez simplement le parcours d'inscription : il vous renverra un message, qui
    portera le lien.
 ---
 ## Lire ce qui a déjà été envoyé { #archives }
 Les listes ouvertes au public ont des **archives** consultables sans compte. C'est
 utile avant de s'abonner, pour voir à quoi on s'engage.
 ![Les envois passés d'une liste publique](../assets/messagerie/abonnement-06-archives.png)
 Seuls y figurent les messages **réellement envoyés** : ni les brouillons, ni les
 envois annulés.
 !!! info "Aucune adresse de courriel n'apparaît dans les archives"
    Les adresses citées dans le corps d'un message — signature, contact d'un
    événement, adresse d'un partenaire — y sont masquées : `s****@a****.xxx`. On voit
    qu'un contact existait, sans pouvoir le reconstituer ni même savoir chez quel
    fournisseur il est hébergé. Leurs titulaires n'ont pas consenti à une publication
    sur le web, où un robot les ramasserait pour en faire du spam.
 ---
 ## Voir aussi
 - [Vos données, vos adresses, nos envois](donnees-personnelles.md)
 - [Écrire et recevoir des messages](messagerie-membre.md) — la messagerie entre
  membres, qui est autre chose que les listes.
--- a/docs/alpinux/messagerie-gestionnaire.md
+++ b/docs/alpinux/messagerie-gestionnaire.md
@ -0,0 +1,300 @@
 ---
 description: Guide du gestionnaire de listes Alpinux — créer une liste, préparer et envoyer un message, gérer les abonnés, comprendre les adresses désactivées et surveiller la réputation d'envoi.
 ---
 # 📣 Gérer une liste de diffusion
 Ce guide s'adresse aux personnes qui **écrivent à toute une liste** : le bureau, et
 les administrateurs de l'outil.
 **En une phrase :** vous rédigez un brouillon, vous le mettez en file d'envoi, et un
 automate le distribue en lissant le débit pendant que vous faites autre chose.
 !!! warning "N'envoyez plus de message en copie cachée depuis votre logiciel de messagerie"
    Les deux méthodes ne se coordonnent pas : l'outil ne saurait rien de ce qui est
    parti par l'autre chemin, ni des rebonds que cela aurait provoqués. Et c'est
    précisément ce mode d'envoi qui saturait le serveur — au-delà d'un certain
    nombre de messages par heure, il refuse les suivants et une partie de l'envoi
    est perdue sans que personne le voie.
 ---
 ## Envoyer un message à une liste { #envoyer }
 ### 1. Rédiger
 Menu **Listes → Campagnes**, puis **Nouvelle campagne**.
 ![La rédaction, avec l'aperçu de ce qui partira](../assets/messagerie/gestionnaire-01-redaction.png)
 Choisissez la liste destinataire, écrivez l'objet et le corps.
 Le corps s'écrit en **Markdown** — la même syntaxe que ce wiki, voir
 [Écrire en Markdown](../contribuer/markdown.md). Un aperçu s'affiche à côté ; le
 bouton **Enregistrer et actualiser l'aperçu** le rafraîchit.
 Trois variables sont remplacées à l'envoi, pour chaque destinataire :
 | Variable | Remplacée par |
 |---|---|
 | `{{nom}}` | le nom de l'abonné, s'il est connu |
 | `{{email}}` | son adresse |
 | `{{desabonnement}}` | le lien de désabonnement qui lui est propre |
 **Enregistrer le brouillon** vous permet de revenir plus tard : rien ne part tant que
 vous n'avez rien demandé.
 !!! danger "Le lien de désabonnement n'est pas optionnel"
    Si vous ne placez pas `{{desabonnement}}` vous-même, un lien est ajouté
    automatiquement en pied de message. Ce comportement ne se désactive pas : un
    envoi de masse sans lien de désabonnement est signalé comme spam, et c'est
    ensuite toute l'association qui n'arrive plus à écrire à personne.
 ### 2. Vérifier avant d'envoyer
 Relisez l'aperçu. C'est le dernier moment confortable : une fois la file remplie, ce
 qui est parti est parti.
 Deux choses valent le coup d'œil :
 - **les liens** — un lien faux dans un message envoyé à toute la liste ne se
  rattrape pas ;
 - **le nombre de destinataires**, affiché sur la fiche de la liste.
 ### 3. Envoyer
 Bouton **Mettre en file d'envoi…**. Une confirmation vous est demandée, avec le
 nombre de destinataires.
 ![Le dernier écran avant que la file se remplisse](../assets/messagerie/gestionnaire-02-confirmation.png)
 L'envoi se fait ensuite tout seul, une minute sur l'autre, **sous un plafond horaire**
 fixé pour ne pas saturer le serveur. Une liste de quelques centaines de personnes
 part en une heure environ.
 Vous pouvez fermer la page : l'envoi continue.
 ### 4. Suivre
 La fiche de la campagne affiche la progression : envoyés, en attente, échecs.
 ![L'envoi en cours : remis, en attente, échecs](../assets/messagerie/gestionnaire-03-progression.png)
 Si le compteur semble figé, c'est probablement le plafond horaire : l'envoi reprend
 de lui-même à l'heure suivante.
 ### Arrêter, recommencer
 - **Annuler les envois restants…** abandonne ce qui n'est pas encore parti. Ce qui
  est déjà distribué ne revient pas.
 - **Dupliquer en brouillon** recrée une copie modifiable d'un envoi passé — pratique
  pour une lettre dont la structure ne change pas d'un mois sur l'autre.
 - **Supprimer ce brouillon…** efface un brouillon abandonné. Une confirmation est
  demandée, et il n'y a pas de corbeille. Seul un brouillon se supprime : une
  campagne partie reste, puisque des gens l'ont reçue et qu'elle figure dans les
  archives.
 ---
 ## Créer une liste { #creer }
 Menu **Listes → Listes de diffusion**, puis le formulaire de création.
 ![Créer une liste : le nom et la description suffisent](../assets/messagerie/gestionnaire-04-creer-liste.png)
 Seuls **le nom** et **la description** sont demandés. Le reste est automatique :
 - l'**identifiant technique** se déduit du nom ;
 - l'**expéditeur** est celui de l'association, suivi du nom de l'auteur à
  l'envoi — « Alpinux (de la part de Prénom Nom) » ;
 - les **réponses** reviennent à l'adresse d'expédition, qui est relevée.
 Rien de cela ne se règle liste par liste : l'association écrit sous une seule
 identité. Multiplier les expéditeurs éparpille la réputation du domaine autant que
 cela désoriente les destinataires.
 !!! note "Le nom d'une liste n'est pas modifiable après création"
    Relisez-le avant de valider.
 ---
 ## Gérer les abonnés { #abonnes }
 Menu **Listes → Listes de diffusion**, puis la liste voulue.
 ![La fiche d'une liste, adresses masquées par défaut](../assets/messagerie/gestionnaire-05-fiche-liste.png)
 Quatre compteurs résument l'état : destinataires joignables, inscrits au total,
 désabonnés, adresses mortes.
 ### Les adresses sont masquées
 Elles s'affichent sous la forme `c••••••e@exemple.fr`. Le domaine reste lisible — il
 suffit au diagnostic — sans étaler à l'écran un carnet d'adresses exploitable.
 Un lien **Afficher les adresses en clair** lève le masque quand c'est nécessaire.
 ### Ajouter des abonnés
 Deux moyens, dans le volet **Ajouter des abonnés** :
 - **coller une liste d'adresses**, une par ligne. Les formes `nom@exemple.fr`,
  `nom@exemple.fr;Prénom Nom` et `Prénom Nom <nom@exemple.fr>` sont acceptées ;
 - **importer depuis Dolibarr** les adhérents à jour de cotisation.
 !!! danger "Un import ne réactive jamais une adresse partie"
    Désabonnée, morte, ou ayant signalé un spam : l'outil refuse de la remettre en
    service, même si elle figure dans le fichier importé. Seule la personne
    concernée peut revenir, par le parcours d'inscription.
    Réinscrire quelqu'un qui est parti est le meilleur moyen de se faire signaler
    comme spam — et cette fois définitivement.
 ---
 ## Ouvrir une liste au public { #publique }
 *Réservé aux administrateurs.*
 Sur la fiche de la liste, cochez **Liste publique** et enregistrez.
 ![Ouvrir une liste à l'inscription libre](../assets/messagerie/gestionnaire-06-liste-publique.png)
 Trois conséquences, à peser avant de cocher :
 - n'importe qui peut **demander à s'abonner** depuis la page d'accueil ;
 - les envois passés deviennent **lisibles publiquement** dans les archives ;
 - le **nom et la description** de la liste sont visibles de tout visiteur.
 Ce dernier point n'est pas anodin pour une liste interne. Le geste est enregistré
 dans le journal de l'outil.
 ### Les demandes en attente
 Quand une liste est publique, la fiche affiche les **demandes d'inscription en
 attente de confirmation**, avec leur heure d'expiration.
 ![Les demandes en attente de confirmation](../assets/messagerie/gestionnaire-07-demandes.png)
 Ces adresses **ne sont pas inscrites** et ne le seront que si leurs titulaires
 confirment depuis leur propre boîte. Il n'y a rien à faire : celles qui restent
 s'effacent seules.
 ---
 ## Les adresses désactivées { #desactivees }
 Menu **Listes → Adresses désactivées**.
 L'écran comporte deux tableaux, et la différence entre les deux est importante.
 ### Rejets définitifs et plaintes
 Ces adresses ont été retirées de **toutes** les listes : le serveur d'en face a
 répondu que la boîte n'existait pas, ou la personne nous a signalés comme spam.
 ![Les rejets définitifs, avec le texte exact du refus](../assets/messagerie/gestionnaire-08-rejets.png)
 La colonne de droite affiche **le texte exact du refus**, extrait du rapport reçu —
 « utilisateur inconnu », « boîte pleine », le nom d'une liste noire. Le rapport
 complet est dépliable si vous voulez tout lire.
 Continuer à écrire à ces adresses abîmerait la réputation du serveur pour tous les
 autres envois. C'est pourquoi l'outil les écarte sans demander.
 ### Blocages d'opérateur
 **Ces adresses-là sont conservées**, et c'est délibéré.
 Le message a été refusé non pas parce que la boîte a disparu, mais parce qu'un
 opérateur refuse *notre* serveur — un grand fournisseur de messagerie qui nous a mis
 sur une liste d'attente, ou un serveur qui interroge une liste noire.
 ![Les blocages d'opérateur : ces adresses restent inscrites](../assets/messagerie/gestionnaire-09-blocages.png)
 La distinction est vitale. Une part notable des abonnés d'une association tient ses
 adresses chez deux ou trois grands fournisseurs : les traiter comme mortes parce que
 l'un d'eux nous bloque un jour ferait perdre d'un coup une fraction de la liste, en
 silence, pour une faute qui n'est pas la leur.
 Quand cette section se remplit, ce n'est donc pas un problème d'abonnés mais de
 réputation d'envoi. Le délistage se demande auprès de l'opérateur concerné.
 ---
 ## Surveiller la réputation d'envoi { #postmaster }
 *Réservé aux administrateurs.* Menu **Configuration → Postmaster**.
 Les grands opérateurs de messagerie envoient chaque jour un rapport disant **quelles
 adresses IP ont émis du courrier au nom du domaine de l'association**, et si ces
 envois étaient correctement signés. L'outil les dépouille tout seul.
 ![Qui émet au nom du domaine, et si c'est aligné](../assets/messagerie/gestionnaire-10-postmaster.png)
 Deux lectures valent le détour :
 - **une adresse IP inconnue dans la liste** : quelqu'un émet en notre nom. Usurpation,
  ou service de l'association qu'on avait oublié ;
 - **une adresse IP connue mais jamais alignée** : elle émet sans être autorisée par
  nos enregistrements, et ses messages tombent en indésirable chez tout le monde.
 Le second tableau liste le courrier reçu à l'adresse *postmaster* que l'automate n'a
 pas su traiter — avis d'opérateur, signalement — et qui attend une lecture humaine.
 Le bouton **Marquer comme lu** le retire de la liste une fois traité.
 ---
 ## Attribuer les rôles { #droits }
 *Réservé aux administrateurs.* Menu **Configuration → Droits**.
 ![Les trois rôles, cumulables](../assets/messagerie/gestionnaire-11-droits.png)
 Trois rôles indépendants, cumulables :
 | Rôle | Donne accès à |
 |---|---|
 | Rédacteur | la section **Listes** : campagnes et abonnés |
 | Administrateur | les listes publiques, les imports, **Droits** et **Postmaster** |
 | Messagerie interne | la section **Messagerie** |
 Un administrateur ne peut pas se retirer lui-même l'administration : l'outil refuse
 de se retrouver sans personne pour le gérer. Demandez-le à un autre administrateur.
 ---
 ## Questions fréquentes
 ??? question "Mon envoi semble arrêté à mi-parcours"
    C'est le plafond horaire. L'envoi reprend de lui-même à l'heure suivante, et la
    fiche de la campagne affiche ce qui reste en attente.
 ??? question "Une adresse apparaît comme désactivée alors qu'elle fonctionne"
    Regardez dans quel tableau elle se trouve. Dans **Blocages d'opérateur**, elle
    n'est pas désactivée et il n'y a rien à faire de ce côté. Dans **Rejets
    définitifs**, lisez le texte du refus : il dit précisément ce que le serveur
    distant a répondu.
 ??? question "Quelqu'un veut revenir après s'être désabonné"
    Il doit refaire le parcours d'inscription lui-même. Ne le réinscrivez pas à la
    main : l'outil l'interdit, et pour de bonnes raisons.
 ??? question "Puis-je renvoyer exactement le même message plus tard ?"
    Oui, **Dupliquer en brouillon** sur la campagne passée. Vérifiez les dates et les
    liens avant de renvoyer : ce qui était vrai il y a un mois ne l'est plus
    forcément.
 ??? question "Comment savoir qui a ouvert le message ?"
    On ne le sait pas, et c'est voulu. Les messages ne contiennent ni image de suivi
    ni lien piégé. Ce que l'on sait, c'est ce qui a été **remis** et ce qui a
    **rebondi**.
 ---
 ## Voir aussi
 - [S'abonner et se désabonner](messagerie-abonnement.md) — ce que voient les
  personnes à qui vous écrivez.
 - [Vos données, vos adresses, nos envois](donnees-personnelles.md)
 - [Écrire en Markdown](../contribuer/markdown.md)
--- a/docs/alpinux/messagerie-membre.md
+++ b/docs/alpinux/messagerie-membre.md
@ -0,0 +1,120 @@
 ---
 description: La messagerie interne d'Alpinux — écrire à un autre membre sans connaître son adresse, lire ses messages, régler ses avis par courriel.
 ---
 # 💬 Écrire et recevoir des messages
 Ce guide s'adresse aux **membres** de l'association qui veulent s'écrire entre eux.
 C'est autre chose que les listes de diffusion : ici, personne ne diffuse à tout le
 monde. On écrit à une personne, et elle seule.
 **En une phrase :** vous écrivez à quelqu'un sans connaître son adresse, et il vous
 répond sans connaître la vôtre.
 !!! info "Il faut être connecté"
    La messagerie interne demande le **compte de l'association**, le même que pour
    le portail. Le rôle correspondant est attribué par un administrateur.
 ---
 ## Lire mes messages { #boite }
 Menu **Messagerie → Mes messages**.
 ![La boîte de réception ; les messages non lus sont en gras](../assets/messagerie/membre-01-boite.png)
 Le nombre de messages non lus apparaît à côté du mot **Messagerie** dans le menu :
 vous le voyez donc depuis n'importe quel écran, sans avoir à aller voir.
 Un message s'ouvre d'un clic sur son objet. Il est marqué lu à ce moment-là.
 ---
 ## Écrire à quelqu'un { #ecrire }
 Menu **Messagerie → Écrire**.
 ![Le destinataire se choisit dans l'annuaire, sans connaître son adresse](../assets/messagerie/membre-02-ecrire.png)
 Choisissez le destinataire dans la liste proposée : c'est l'annuaire des membres.
 **Vous n'avez pas besoin de son adresse** — vous ne la verrez pas, et il ne verra pas
 la vôtre.
 Écrivez l'objet et le message, puis envoyez.
 ### Ce que reçoit votre destinataire
 Un **avis** par courriel, qui dit qu'un message l'attend, de la part de qui, et sur
 quel sujet. **Le texte du message n'est pas recopié dans cet avis** : il faut se
 connecter pour le lire.
 C'est volontaire. Un avis qui recopierait le message rendrait la messagerie interne
 inutile — autant s'écrire directement.
 ---
 ## Régler mes avis par courriel { #avis }
 Menu **Configuration → Mon profil**.
 ![Les avis par courriel et le résumé quotidien se règlent ici](../assets/messagerie/membre-03-profil.png)
 Vous y choisissez :
 - **si** vous voulez être prévenu par courriel quand un message arrive ;
 - **à quelle adresse** ces avis doivent partir.
 ### Le résumé quotidien
 Si des messages restent non lus, un **résumé** part une fois par jour — et seulement
 les jours où quelque chose est arrivé. Il dit qui vous a écrit et sur quels sujets.
 Ni le corps des messages, ni les adresses des auteurs n'y figurent.
 Il se coupe depuis le même écran que les avis.
 ---
 ## Emporter mes messages { #export }
 Menu **Messagerie → Copie de mes messages**.
 Vous téléchargez l'ensemble de vos messages — reçus et envoyés — dans une archive.
 Chaque message y est au format standard des courriels, lisible par n'importe quel
 logiciel de messagerie.
 C'est ce qu'il faut utiliser pour garder une trace hors de l'outil, ou pour exercer
 votre droit d'accès à vos données.
 ---
 ## Questions fréquentes
 ??? question "Mon correspondant verra-t-il mon adresse ?"
    Non. Les messages ne circulent pas par courriel entre vous : ils restent dans
    l'outil. Seuls les **avis** partent par courriel, et chacun part vers l'adresse
    de son propre destinataire.
 ??? question "Puis-je répondre depuis mon logiciel de messagerie ?"
    Non. L'avis est une notification, pas le message. Il faut se connecter pour lire
    et répondre — c'est la contrepartie de ne pas divulguer les adresses.
 ??? question "Je ne reçois plus d'avis"
    Vérifiez d'abord **Configuration → Mon profil** : les avis y sont peut-être
    coupés. S'ils sont actifs et que rien n'arrive, c'est probablement que votre
    adresse a rebondi ; l'outil suspend alors les avis pour ne pas s'acharner.
    Signalez-le à un administrateur, qui le verra dans ses écrans.
 ??? question "Puis-je écrire à quelqu'un qui n'est pas dans l'annuaire ?"
    Non. L'annuaire ne contient que les membres à qui un rôle a été attribué. Pour
    écrire à quelqu'un d'autre, il faut son adresse et un logiciel de messagerie
    ordinaire.
 ---
 ## Voir aussi
 - [S'abonner et se désabonner](messagerie-abonnement.md) — les listes de diffusion,
  qui sont autre chose.
 - [Vos données, vos adresses, nos envois](donnees-personnelles.md)
--- a/docs/alpinux/messagerie.md
+++ b/docs/alpinux/messagerie.md
@ -0,0 +1,50 @@
 ---
 description: La messagerie d'Alpinux — trois guides selon que vous voulez vous abonner, écrire aux membres, ou gérer une liste de diffusion.
 ---
 # 📬 La messagerie d'Alpinux
 La messagerie de l'association sert à deux choses qu'il ne faut pas confondre :
 - **les listes de diffusion**, par lesquelles le bureau écrit à tout le monde ;
 - **la messagerie interne**, par laquelle les membres s'écrivent entre eux sans se
  communiquer leurs adresses.
 Selon ce que vous voulez faire, la suite n'est pas la même.
 ---
 ## Je veux…
 | Ce que vous voulez faire | Le guide qu'il vous faut |
 |---|---|
 | Recevoir les annonces de l'association, ou arrêter de les recevoir | [S'abonner et se désabonner](messagerie-abonnement.md) |
 | Lire ce qui a déjà été envoyé | [S'abonner et se désabonner](messagerie-abonnement.md#archives) |
 | Écrire à un autre membre, ou lire mes messages | [Écrire et recevoir des messages](messagerie-membre.md) |
 | Envoyer un message à toute une liste | [Gérer une liste de diffusion](messagerie-gestionnaire.md) |
 | Ajouter des abonnés, ouvrir une liste au public | [Gérer une liste de diffusion](messagerie-gestionnaire.md) |
 | Comprendre pourquoi une adresse ne reçoit plus rien | [Gérer une liste de diffusion](messagerie-gestionnaire.md#desactivees) |
 ---
 ## Qui peut quoi
 L'accès aux écrans dépend d'un rôle, attribué par un administrateur dans
 **Configuration → Droits**.
 | Vous êtes… | Vous voyez… |
 |---|---|
 | Une personne sans compte | l'inscription et les archives des listes publiques |
 | Membre | la section **Messagerie** |
 | Rédacteur | la section **Listes** |
 | Administrateur | tout, plus **Configuration → Droits** et **Configuration → Postmaster** |
 Une même personne peut cumuler les trois.
 ---
 ## Voir aussi
 - [Vos données, vos adresses, nos envois](donnees-personnelles.md) — ce que
  l'association recueille, combien de temps elle le garde, et ce que vous pouvez
  exiger.
--- a/docs/assets/installparty/01-liste-publique.png
+++ b/docs/assets/installparty/01-liste-publique.png
--- a/docs/assets/installparty/02-inscription.png
+++ b/docs/assets/installparty/02-inscription.png
--- a/docs/assets/installparty/03-espace-connexion.png
+++ b/docs/assets/installparty/03-espace-connexion.png
--- a/docs/assets/installparty/04-espace-personnel.png
+++ b/docs/assets/installparty/04-espace-personnel.png
--- a/docs/assets/installparty/05-espace-installateur.png
+++ b/docs/assets/installparty/05-espace-installateur.png
--- a/docs/assets/installparty/06-fiche-participant.png
+++ b/docs/assets/installparty/06-fiche-participant.png
--- a/docs/assets/installparty/07-deux-codes.png
+++ b/docs/assets/installparty/07-deux-codes.png
--- a/docs/assets/installparty/08-choisir-son-code.png
+++ b/docs/assets/installparty/08-choisir-son-code.png
--- a/docs/assets/installparty/09-organisation.png
+++ b/docs/assets/installparty/09-organisation.png
--- a/docs/assets/installparty/10-historique.png
+++ b/docs/assets/installparty/10-historique.png
--- a/docs/assets/messagerie/abonnement-01-accueil.png
+++ b/docs/assets/messagerie/abonnement-01-accueil.png
--- a/docs/assets/messagerie/abonnement-02-code.png
+++ b/docs/assets/messagerie/abonnement-02-code.png
--- a/docs/assets/messagerie/abonnement-03-confirmation.png
+++ b/docs/assets/messagerie/abonnement-03-confirmation.png
--- a/docs/assets/messagerie/abonnement-04-bouton-desabonner.png
+++ b/docs/assets/messagerie/abonnement-04-bouton-desabonner.png
--- a/docs/assets/messagerie/abonnement-05-desabonnement.png
+++ b/docs/assets/messagerie/abonnement-05-desabonnement.png
--- a/docs/assets/messagerie/abonnement-06-archives.png
+++ b/docs/assets/messagerie/abonnement-06-archives.png
--- a/docs/assets/messagerie/gestionnaire-01-redaction.png
+++ b/docs/assets/messagerie/gestionnaire-01-redaction.png
--- a/docs/assets/messagerie/gestionnaire-02-confirmation.png
+++ b/docs/assets/messagerie/gestionnaire-02-confirmation.png
--- a/docs/assets/messagerie/gestionnaire-03-progression.png
+++ b/docs/assets/messagerie/gestionnaire-03-progression.png
--- a/docs/assets/messagerie/gestionnaire-04-creer-liste.png
+++ b/docs/assets/messagerie/gestionnaire-04-creer-liste.png
--- a/docs/assets/messagerie/gestionnaire-05-fiche-liste.png
+++ b/docs/assets/messagerie/gestionnaire-05-fiche-liste.png
--- a/docs/assets/messagerie/gestionnaire-06-liste-publique.png
+++ b/docs/assets/messagerie/gestionnaire-06-liste-publique.png
--- a/docs/assets/messagerie/gestionnaire-07-demandes.png
+++ b/docs/assets/messagerie/gestionnaire-07-demandes.png
--- a/docs/assets/messagerie/gestionnaire-08-rejets.png
+++ b/docs/assets/messagerie/gestionnaire-08-rejets.png
--- a/docs/assets/messagerie/gestionnaire-09-blocages.png
+++ b/docs/assets/messagerie/gestionnaire-09-blocages.png
--- a/docs/assets/messagerie/gestionnaire-10-postmaster.png
+++ b/docs/assets/messagerie/gestionnaire-10-postmaster.png
--- a/docs/assets/messagerie/gestionnaire-11-droits.png
+++ b/docs/assets/messagerie/gestionnaire-11-droits.png
--- a/docs/assets/messagerie/membre-01-boite.png
+++ b/docs/assets/messagerie/membre-01-boite.png
--- a/docs/assets/messagerie/membre-02-ecrire.png
+++ b/docs/assets/messagerie/membre-02-ecrire.png
--- a/docs/assets/messagerie/membre-03-profil.png
+++ b/docs/assets/messagerie/membre-03-profil.png
--- a/docs/communication/liens-et-codes-qr.md
+++ b/docs/communication/liens-et-codes-qr.md
@ -0,0 +1,109 @@
 ---
 description: Quelles adresses de l'outil d'install party se publient sur une affiche, un article ou un code QR, lesquelles ne se publient jamais, et comment le vérifier avant impression.
 ---
 # 🔗 Liens et codes QR : ce qui se publie
 Affiche, flyer, article de presse, message sur une liste de diffusion,
 publication d'une commune : dès qu'une adresse sort de l'équipe, elle est
 publique pour de bon. Une affiche s'imprime, un article se reprend, un code QR
 se scanne des semaines plus tard.
 Cette page existe parce qu'un code QR a déjà mené à la page d'organisation d'une
 install party au lieu de la page d'inscription — et que rien ne distingue les
 deux à l'œil nu.
 ---
 ## La règle, en une phrase
 !!! danger "À retenir"
    **Une adresse qui contient `key=` ou `jeton=` ne se publie jamais.**
 Ces deux mots signalent une clé d'accès. Elles valent mot de passe et sont
 faites pour une seule personne.
 ---
 ## Les adresses qui se publient
 | Pour | Adresse |
 |---|---|
 | **Le public** — affiches, articles, codes QR | `https://installparty.alpinux.org` |
 | **S'inscrire** directement à une install party | `https://installparty.alpinux.org/party/<uid>/register` |
 | Voir les **install parties à venir** | `https://installparty.alpinux.org/party/` |
 | **Retrouver ses accès** (organisateur, installateur, inscrit) | `https://installparty.alpinux.org/party/moi` |
 Aucune ne contient de clé : ce sont les seules à faire figurer sur un support.
 !!! tip "Sur une affiche, c'est la première qu'il faut"
    `https://installparty.alpinux.org` est courte, se retient, se lit à voix
    haute et ne vieillit pas : elle mène à la page qui annonce la prochaine
    install party et porte le bouton d'inscription. Une adresse qui contient
    l'identifiant d'une install party, elle, ne vaudra plus rien à la
    suivante — et une affiche dure plus longtemps qu'un événement.
 ## Les adresses qui ne se publient pas
 | Ce que c'est | À quoi on la reconnaît | Ce qu'elle ouvre |
 |---|---|---|
 | Espace d'organisation | `/status/?key=…` | les inscrits et leurs coordonnées, avec de quoi les modifier |
 | Écran de salle | `/accueil?key=…` | prénoms, machines et heures de la journée |
 | Inscription des installateurs | `/benevole/inscription?key=…` | le formulaire par lequel on rejoint l'équipe |
 | Fiche d'un participant | `/fiche/…?jeton=…` | ses données et la conversation le concernant |
 ---
 ## Avant d'envoyer un support à l'impression
 1. **Relire l'adresse en entier** — pas son début : la clé est à la fin.
 2. **Scanner soi-même le code QR** avec son téléphone et regarder où il mène.
   C'est la seule vérification qui porte sur ce qui sera réellement diffusé,
   et non sur ce qu'on croit y avoir mis.
 3. **Faire regarder par quelqu'un d'autre.** Celui qui a fabriqué le code voit
   ce qu'il voulait faire, pas ce qu'il a fait.
 4. **Demander le fichier final** à qui publie — commune, imprimeur, journal —
   et le vérifier avant parution, pas après.
 ### Décoder un code QR depuis une image
 ```sh
 zbarimg affiche.png
 ```
 La commande affiche l'adresse encodée. `sudo apt install zbar-tools` si elle
 manque.
 ### Fabriquer le bon code
 ```sh
 qrencode -o installparty.png -s 12 -m 3 "https://installparty.alpinux.org"
 ```
 En SVG pour l'impression, où le code doit rester net à toute taille :
 ```sh
 qrencode -t SVG -o installparty.svg -s 12 -m 3 "https://installparty.alpinux.org"
 ```
 `sudo apt install qrencode` si la commande manque.
 ---
 ## Si une clé a été publiée malgré tout
 !!! warning "Agir le jour même"
    1. **Renouveler la clé.** Pour l'espace d'organisation, il suffit de
       redemander son lien depuis `/party/moi` : la clé publiée est remplacée.
       Pour l'écran de salle et l'inscription des installateurs, un bouton
       existe sur la page d'organisation.
    2. **Regarder les journaux du serveur** pour savoir qui a consulté, et
       depuis quand.
    3. **Prévenir les personnes concernées** si leurs données ont été
       exposées, et notifier la CNIL — le délai est de 72 heures à compter de
       la découverte.
 Une clé d'organisation cesse de valoir trente minutes après la dernière action
 de son détenteur : une clé publiée ne reste donc pas utilisable indéfiniment.
 Ce n'est pas une raison d'en publier une — quelques jours d'exposition
 suffisent à ce qu'elle serve.
--- a/docs/deploiement.md
+++ b/docs/deploiement.md
@ -0,0 +1,23 @@
 # wiki.alpinux.org
 Documentation publique Alpinux — MkDocs Material.
 ## Déploiement
 ```bash
 cd org.alpinux.owni/wiki
 mkdocs build --strict
 rsync -rlcz --delete site/ alpinux.org:/var/www/wiki.alpinux.org/web/
 ```
 ## Développement local
 ```bash
 pip install mkdocs-material
 mkdocs serve    # http://localhost:8000
 ```
 ## Notes
 - Pas de service systemd — site statique servi directement par Apache
 - Les docs publiques sont dans `wiki/docs/technique/`
--- a/docs/guides/linux-mint-depuis-windows.md
+++ b/docs/guides/linux-mint-depuis-windows.md
@ -9,12 +9,22 @@ l'ordinateur rendu à son propriétaire. Il sert aussi bien au bénévole qui in
 personne qui veut recommencer chez elle.
 !!! info "État du document"
-    Vérifié le **19/09/2026** par alpinux.cedrica5l, sur **Linux Mint 22.3 Cinnamon**.
+    Procédure **rejouée de bout en bout le 20/09/2026 sur Linux Mint 22.3 Cinnamon**, de
    la clé USB au premier démarrage : les libellés et les captures de l'installation sont
    ceux de la 22.3. Restent d'anciennes captures pour les écrans Windows — qui n'ont pas
    changé — et pour la post-installation.
    Pendant une Install Party, la checklist de suivi est le document numérique
    [installparty.alpinux.org/party/moi](https://installparty.alpinux.org/party/moi).
    Vos [remarques et suggestions](../alpinux/evenements.md) sont bienvenues pour
    l'améliorer.
 !!! tip "Quatre pages, quatre moments"
    - **Cette page** — l'installation elle-même, de la clé USB à l'ordinateur rendu.
    - [Régler Linux Mint après l'installation](linux-mint-parametres.md) — le premier démarrage : mises à jour, langue, pilotes.
    - [Trousse de premiers secours](linux-mint-trousse.md) — les gestes de base, en format court et imprimable.
    - [Utiliser Linux Mint](utiliser-linux-mint.md) — la vie courante : paramètres, matériel, logiciels, entretien.
 ---
 ## 1. Préparer Windows
@ -94,10 +104,6 @@ Clic droit sur **Démarrer** → *Terminal (administrateur)*, puis :
 powercfg /hibernate off
 ```
 !!! tip "Le dernier arrêt de Windows"
    Au moment d'éteindre Windows pour insérer la clé USB, maintenez **Maj (Shift)**
    enfoncée en cliquant sur *Démarrer → Arrêter*. Cela force un arrêt complet.
 ### Gestion de l'alimentation de la carte Wi-Fi
 Certaines cartes Wi-Fi (puces Realtek ou Broadcom notamment) restent dans l'état de basse
@ -178,6 +184,8 @@ Linux. Il faut le basculer sur **AHCI**, dans la section *Storage*, *SATA Config
    conserver Windows, faites le changement avec un bénévole. Si Windows est de toute
    façon remplacé, la bascule est sans conséquence.
 ---
 ## 2. Préparer son support d'installation
@ -236,8 +244,11 @@ Avec [Ventoy](ventoy.md), la préparation tient en un copier-coller :
 ### Branchements
 - Insérez la clé Ventoy dans un **port USB de la machine**, en évitant les hubs.
- **Branchez un câble Ethernet.** Mint pourra télécharger mises à jour, codecs et paquets
+- **Branchez un câble Ethernet.** Le script install.sh de Alpinux effectue des tests.
-  de langue pendant l'installation — cela évite beaucoup de réglages ensuite.
+
 !!! tip "Le dernier arrêt de Windows - Comment arrêter Windows pour démarrer sur la clé USB"
    Au moment d'éteindre Windows pour insérer la clé USB, maintenez **Maj (Shift)**
    enfoncée en cliquant sur *Démarrer → Arrêter*. Cela force un arrêt complet.
 ### Accéder au menu de démarrage
@ -257,7 +268,7 @@ constructeur :
 ### Le menu Ventoy
-![Le menu isolinux, en mode BIOS](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-011009.png)
+![Le menu isolinux, en mode BIOS](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/01-menu-demarrage-ventoy-grub.png)
 Sur l'écran de Ventoy, sélectionnez l'ISO de Linux Mint avec les flèches, **Entrée**, puis
 **Boot in normal mode**.
@ -270,10 +281,11 @@ machines d'avant 2012.
 ![L'écran de démarrage de Linux Mint](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-011515.png)
-Un second menu apparaît, le GRUB de Mint : choisissez **Start Linux Mint (64-bit)**. Le
+Un second menu apparaît, le GRUB de Mint : choisissez
 **Start Linux Mint 22.3 Cinnamon 64-bit**. Le
 logo « LM » s'affiche en blanc sur fond vert, puis le bureau.
-![Le bureau de la session live](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-011723.png)
+![Le bureau de la session live](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/02-bureau-session-live.png)
 Une notification confirme la connexion : *« Vous êtes maintenant connecté au réseau filaire
 1 »*. Vous êtes dans une session **live**, qui tourne entièrement en mémoire vive :
@ -320,29 +332,123 @@ Si un élément important — le Wi-Fi par exemple — ne fonctionne pas du tout
 demandez l'aide d'un bénévole avant de lancer l'installation. Dans la grande majorité des
 cas il s'agit d'un pilote propriétaire à activer, mais mieux vaut le savoir maintenant.
 ### Faire l'état des lieux du disque
 **C'est l'étape qu'on oublie, et c'est celle qui coûte le plus cher.** Avant de toucher au
 partitionnement, il faut savoir ce qu'il y a dans la machine : un seul disque ou deux, un
 Windows chiffré par BitLocker, une partition de récupération du constructeur, un disque
 fatigué. On ne le découvre pas au milieu du partitionnement.
 En session live, taper les commandes une à une est fastidieux. Un script d'Alpinux fait
 l'inventaire et rend un verdict :
 **Sur le réseau de l'install party**, où les scripts sont servis par
 [le serveur qu'Alpinux emporte](../technique/serveur-install-party.md) :
 ```bash
 wget http://alpicache.lan/verif-disque.sh && chmod +x verif-disque.sh && ./verif-disque.sh
 ```
 !!! tip "Si le nom ne répond pas"
    Le serveur répond aussi à `alpicache`, `apt-proxy` et `10.0.0.1` — cette
    dernière adresse fonctionne même quand la résolution de noms n'est pas encore
    en place :
    `wget http://10.0.0.1/verif-disque.sh`
 **Ailleurs, depuis Internet :**
 ```bash
 wget https://gitea.alpinux.org/alpinux.cedrica5l/alpinux.scripts/raw/branch/stable/poste/verif-disque.sh
 chmod +x verif-disque.sh
 ./verif-disque.sh
 ```
 Il **ne modifie rien** — il lit, il affiche, il conseille. Il demande le mot de passe pour
 les vérifications qui le nécessitent, puis passe en revue :
 - la **machine** : processeur 64 bits, mémoire vive, et l'édition à conseiller en dessous
  de 4 Go ;
 - le **mode de démarrage** réel (UEFI ou BIOS hérité) et l'état du **Secure Boot** ;
 - les **disques** : nombre, taille, SSD ou mécanique, table de partition, et l'alerte si
  la machine démarre en UEFI alors que le disque est en MBR ;
 - ce qui est **déjà installé** : Windows, Linux, partition EFI existante à réutiliser ;
 - les **pièges** : BitLocker, chiffrement LUKS, `hiberfil.sys` laissé par le démarrage
  rapide de Windows ;
 - la **santé SMART** des disques, et l'**accès à Internet**.
 Il finit par deux listes : *à régler avant d'installer*, et *à savoir*.
 ### Relever la fiche de la machine
 En install party, un second script complète l'état des lieux : il relève la **fiche
 matérielle** — modèle, processeur, mémoire et ses connecteurs, disques et leur santé —
 et l'envoie au serveur de l'association.
 ```bash
 wget http://alpicache.lan/alpi-fiche.sh && chmod +x alpi-fiche.sh && sudo ./alpi-fiche.sh --check
 ```
 Hors réseau de l'install party, il se prend sur Internet :
 ```bash
 wget https://gitea.alpinux.org/alpinux.cedrica5l/alpinux.scripts/raw/branch/stable/poste/alpi-fiche.sh
 ```
 Il n'aura alors aucun serveur à qui remettre la fiche : il l'affiche, et c'est tout.
 Lancé depuis la session live, il rend en plus un verdict en trois états : **bon pour
 l'installation**, **possible avec des réserves**, ou **ne pas installer en l'état** — un
 disque qui se déclare défaillant, des secteurs réalloués, moins de 2 Go de mémoire, un
 processeur 32 bits. C'est le dernier moment où l'on peut encore renoncer et en parler au
 propriétaire.
 Le même script, relancé après l'installation (sans `--check`), enregistre ce qui a
 finalement été installé. Les deux relevés se comparent : un disque qui allait bien le
 matin et se plaint le soir, cela se voit.
 !!! warning "Dites-le à la personne dont vous installez la machine"
    La fiche part sur le réseau local, vers le serveur de l'association, et n'en sort
    pas. Elle ne contient ni fichiers, ni historique, ni nom d'utilisateur — mais elle
    contient le **nom de la machine**, souvent un prénom, et l'**adresse matérielle** de
    la carte réseau. C'est son ordinateur : cela se demande, cela ne se suppose pas.
 !!! danger "BitLocker : ne touchez à rien"
    Si le script annonce une partition chiffrée par BitLocker, **arrêtez-vous là**. Le
    chiffrement doit être suspendu depuis Windows — *Paramètres → Confidentialité et
    sécurité → Chiffrement de l'appareil* — et la clé de récupération mise à l'abri.
    Redimensionner ou effacer une partition BitLocker sans cette précaution rend les
    données définitivement illisibles.
 ---
 ## 5. Installer le système
-![L'icône « Install Linux Mint » sur le bureau](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-012911.png)
+![L'icône « Install Linux Mint » sur le bureau](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/02-bureau-session-live.png)
 Double-cliquez sur **Install Linux Mint**.
-![Le choix de la langue](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-013009.png)
+![Le choix de la langue](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/03-choix-de-la-langue.png)
 **Langue** : sélectionnez **Français** dans la colonne de gauche, puis **Continuer**.
-![La disposition du clavier](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-013133.png)
+![La disposition du clavier](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/04-disposition-du-clavier.png)
-**Disposition du clavier** : choisissez **Français** à gauche, et à droite **Français
+**Disposition du clavier** : choisissez **French** dans la colonne de gauche. La colonne de
-(variante)** ou **Français (variante, AltGr morte)**. Étape à ne pas bâcler — un clavier mal
+droite liste les variantes, en anglais elles aussi : **French - French (legacy, alt.)** est
-choisi se paie au premier mot de passe. Testez dans la zone de saisie en bas : le `²`, le
+proposée par défaut et convient à un clavier AZERTY français ordinaire. Les autres entrées
-`@`, les accents.
+couvrent les cas particuliers — *(BEPO, AFNOR)*, *(Dvorak)*, *(Macintosh)*, *(no dead
 keys)* pour un clavier sans touches mortes.
-![Les codecs multimédia](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-013250.png)
+Étape à ne pas bâcler — un clavier mal choisi se paie au premier mot de passe. Testez dans
 le champ **« Saisissez du texte ici pour tester votre clavier »** : le `²`, le `@`, les
 accents. Le bouton **Détecter la disposition du clavier** fait deviner la disposition en
 demandant d'appuyer sur quelques touches.
-**Codecs multimédia** : cochez la case. Ces composants, parfois propriétaires, sont
+![Les codecs multimédia](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/05-codecs-multimedia.png)
-indispensables pour lire du MP3, du MP4 ou les vidéos de nombreux sites.
+
 **Codecs multimédia** : cochez **Installer les codecs multimédias**, décochée par défaut.
 Ces composants, parfois propriétaires, sont indispensables pour lire du MP3, du MP4 ou les
 vidéos de nombreux sites.
 !!! info "Pourquoi ces codecs ne sont-ils pas installés d'office ?"
    Certains formats, comme le MP3 ou le H.264, sont couverts par des brevets. Linux Mint
@ -353,9 +459,13 @@ indispensables pour lire du MP3, du MP4 ou les vidéos de nombreux sites.
 ## 6. Créer les partitions
-![Le type d'installation](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-013612.png)
+![Le type d'installation](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/06-type-installation.png)
-À l'écran *Type d'installation*, choisissez **Autre chose**, puis **Continuer**.
+![L'écran de partitionnement, disque vierge](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/07-partitionnement-disque-vierge.png)
 À l'écran *Type d'installation*, choisissez **Autre chose** — la première option,
 *Effacer le disque et installer Linux Mint*, est sélectionnée par défaut — puis cliquez sur
 **Installer maintenant** (et non « Continuer », comme aux écrans précédents).
 !!! danger "Plusieurs disques ?"
    Si la fenêtre montre plusieurs disques (`sda`, `sdb`, `nvme0n1`), ne prenez aucun
@ -364,16 +474,26 @@ indispensables pour lire du MP3, du MP4 ou les vidéos de nombreux sites.
 ### Préparer le disque
-![La table de partition](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-013806.png)
+![La table de partition](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/08-nouvelle-table-de-partition.png)
- **Disque vierge** : cliquez sur **Nouvelle table de partition…** — **GPT** en UEFI,
+- **Disque vierge** : cliquez sur **Nouvelle table de partition…**, puis **Continuer** dans
-  **MBR** en BIOS hérité.
+  le message d'avertissement. L'installateur choisit seul le format adapté au mode de
  démarrage — GPT en UEFI, MBR en BIOS hérité — sans rien demander.
 - **Anciennes partitions Windows** : supprimez-les une à une avec le bouton **-** pour
  obtenir un grand *espace libre*, ou repartez d'une nouvelle table de partition.
 ### Les partitions à créer
-Cliquez sur l'espace libre, puis sur **+** pour chacune.
+Cliquez sur l'espace libre, puis sur **+** pour chacune. La fenêtre **Créer une
 partition** demande la taille, le type, l'emplacement, l'usage et le point de montage :
 ![La fenêtre « Créer une partition »](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/09-creer-une-partition.png)
 La liste **Utiliser comme** contient tout ce dont vous aurez besoin — *système de fichiers
 journalisé ext4*, *espace d'échange (« swap »)*, *Partition système EFI*, et *Zone
 réservée pour le chargeur d'amorçage BIOS* :
 ![La liste des systèmes de fichiers](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/10-utiliser-comme-partition-efi.png)
 **Selon le mode de démarrage :**
@ -389,7 +509,7 @@ Cliquez sur l'espace libre, puis sur **+** pour chacune.
 1. **Le swap** (espace d'échange) — environ 1,5 fois la mémoire vive : pour 4 ou 8 Go de
   RAM, indiquez 8000 Mo, et *Utiliser comme* → **espace d'échange (« swap »)**.
-    ![La création du swap](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-013914.png)
+    ![La création du swap](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/12-creation-du-swap.png)
 2. **La racine `/`** — 30 à 150 Go selon le disque, *Utiliser comme* → **système de
   fichiers journalisé ext4**, point de montage `/`.
@ -403,16 +523,18 @@ Cliquez sur l'espace libre, puis sur **+** pour chacune.
 ### Lancer l'écriture
-![Le tableau des partitions](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-014316.png)
+![Le tableau des partitions](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/13-table-de-partitions-complete.png)
-Vérifiez que le *périphérique où sera installé le chargeur d'amorçage* est bien le disque
+Vérifiez que le **Périphérique où sera installé le programme de démarrage** est bien le
-principal (`/dev/sda`, `/dev/nvme0n1`…), puis **Installer maintenant**.
+disque principal (`/dev/sda`, `/dev/nvme0n1`…), puis **Installer maintenant**. Un dialogue
 récapitule alors les partitions qui seront formatées : c'est le dernier écran avant
 écriture.
 ![L'avertissement EFI](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-014445.png)
 Un message peut signaler une particularité EFI : lisez-le, puis **Continuer**.
-![Le dernier avertissement](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-014709.png)
+![Le dernier avertissement](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/14-appliquer-les-changements.png)
 Le dernier écran récapitule les changements. **Après ce clic, les données des partitions
 concernées sont définitivement effacées.**
@ -421,11 +543,11 @@ concernées sont définitivement effacées.**
 ## 7. Compte utilisateur et fin de l'installation
-![Le choix du fuseau horaire](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-014835.png)
+![Le choix du fuseau horaire](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/15-fuseau-horaire.png)
 **Où êtes-vous ?** — choisissez le fuseau horaire.
-![La création du compte](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-015439.png)
+![La création du compte](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/16-compte-utilisateur.png)
 Pendant que les fichiers se copient, créez le compte principal :
@ -436,20 +558,24 @@ Pendant que les fichiers se copient, créez le compte principal :
  (*jean*).
 - **Mot de passe** : en Install Party, nous utilisons le mot de passe temporaire
  `alpinux73`, remplacé avant de rendre la machine.
- Cochez **Demander mon mot de passe pour ouvrir une session**. L'option *Chiffrer mon
+- Laissez **Demander mon mot de passe pour ouvrir une session**, sélectionné par défaut :
-  dossier personnel* existe, mais un mot de passe oublié rend alors les données
+  l'autre choix, *Ouvrir la session automatiquement*, laisse l'ordinateur accessible à qui
-  définitivement irrécupérables.
+  l'allume. L'option *Chiffrer mon dossier personnel* existe, mais un mot de passe oublié
  rend alors les données définitivement irrécupérables.
 - Le nom d'ordinateur et le nom d'utilisateur se remplissent tout seuls dès que vous
  saisissez votre nom : le nom proposé pour la machine est souvent long et technique, il
  gagne à être remplacé par quelque chose de court.
-![L'installation en cours](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-015337.png)
+![L'installation en cours](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/17-installation-en-cours.png)
 Comptez **10 à 30 minutes** selon le disque et la connexion : Mint en profite pour
 récupérer les mises à jour de sécurité et les paquets de langue française.
-![Installation terminée](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-015957.png)
+![Installation terminée](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/18-installation-terminee.png)
 À la fin, la fenêtre **Installation terminée** propose **Redémarrer maintenant**.
-![Retirer le support d'installation](https://static.alpinux.org/wiki/technique/pratique/pasted/20231118-020022.png)
+![Retirer le support d'installation](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/19-retirer-le-support.png)
 !!! warning "Ne retirez pas la clé trop tôt"
    L'écran devient noir, puis affiche *« Please remove the installation medium, then press
@ -459,42 +585,85 @@ récupérer les mises à jour de sécurité et les paquets de langue française.
 ---
-## 8. Opérations de post-installation
+## 8. Le premier démarrage
 ![L'écran de connexion](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/20-ecran-de-connexion.png)
 L'écran de connexion s'affiche en français, avec le nom saisi pendant l'installation. La
 disposition du clavier retenue est rappelée en haut à droite — `fr` et `latin9` pour un
 clavier français ordinaire : vérifiez-la avant de taper le mot de passe.
 ![L'écran de bienvenue](https://static.alpinux.org/wiki/guides/linux-mint-depuis-windows/21-ecran-de-bienvenue.png)
 La session s'ouvre sur l'écran **Bienvenue**. Sa rubrique **Premiers pas** enchaîne les
 réglages que Mint juge prioritaires, chacun avec son bouton *Lancer* : couleurs du bureau,
 **instantanés du système**, gestionnaire de pilotes, gestionnaire de mises à jour. C'est un
 bon fil à suivre — et il recoupe ce qui suit.
 La case *Afficher cette fenêtre au démarrage*, en bas, permet de ne plus la revoir une fois
 le tour fait.
 ---
 ## 9. Opérations de post-installation
 Le système est installé ; quelques réglages le rendent réellement utilisable.
 ### Le script de post-installation Alpinux
 Il automatise ce qui manque presque toujours après une installation standard. Ouvrez un
-terminal (`Ctrl + Alt + T`) et récupérez-le — **sur le réseau local de l'Install Party** :
+terminal (`Ctrl + Alt + T`) et récupérez-le — **sur le réseau local de l'Install Party**,
 où [le serveur d'Alpinux](../technique/serveur-install-party.md) le sert et met en cache
 tout ce que la machine téléchargera ensuite :
 ```bash
-wget http://10.0.0.1/install.sh
+wget http://alpicache.lan/install.sh http://alpicache.lan/alpi-fiche.sh
 ```
 **ou depuis Internet :**
 ```bash
-wget https://gitea.alpinux.org/alpinux.cedrica5l/alpinux-wiki/raw/branch/main/code/linux/linux-mint/install.sh
+wget https://gitea.alpinux.org/alpinux.cedrica5l/alpinux.scripts/raw/branch/stable/poste/install.sh \
     https://gitea.alpinux.org/alpinux.cedrica5l/alpinux.scripts/raw/branch/stable/poste/alpi-fiche.sh
 ```
 Puis, dans les deux cas :
 ```bash
-chmod +x install.sh
+chmod +x install.sh alpi-fiche.sh
 ./install.sh
 ```
 !!! note "Pourquoi deux fichiers"
    `install.sh` commence par relever la fiche matérielle, et il ne le fait **que s'il
    trouve `alpi-fiche.sh` à côté de lui** — il ne va rien chercher sur le réseau de
    lui-même. Téléchargé seul, il s'installera très bien, simplement sans relevé. En
    install party, prenez les deux.
 Le mot de passe est demandé au passage (`alpinux73` en Install Party) : les caractères ne
 s'affichent pas, c'est normal.
 Ce que le script met en place :
- **Logithèque enrichie** : polices Microsoft, outils de gravure, application de webcam,
+- **Le français partout** : paquets de langue manquants, dictionnaires LibreOffice
-  gestionnaire de mots de passe, utilitaires de sauvegarde.
+  (`hunspell-fr`, `mythes-fr`, `hyphen-fr`) et préférences Firefox globales — interface,
- **Confort matériel** : `numlockx`, pour le pavé numérique dès le démarrage.
+  correcteur, langue demandée aux sites, et lecture des contenus protégés (Netflix,
- **Mises à jour automatiques** : les correctifs de sécurité s'installent sans intervention.
+  Prime).
- **Paquets de langue** : les traductions manquantes de LibreOffice, Firefox et consorts.
+- **Une logithèque prête à l'emploi** : polices Microsoft, VLC, GParted, Shotwell, Cheese,
  pdfarranger, tesseract-ocr en français, backintime, stacer, `numlockx` pour le pavé
  numérique — plus Flathub, avec KeePassXC et Flatseal en Flatpak.
 - **Des réglages système** : microcode processeur Intel ou AMD, journaux plafonnés, cache
  APT allégé, proxy APT détecté automatiquement sur le réseau de l'install party, Timeshift
  désactivé, et GRUB qui redémarre sur la dernière entrée utilisée.
 - **Les mises à jour** appliquées dans la foulée.
 Le script s'efface lui-même une fois terminé.
 !!! note "Comptez vingt minutes, et une connexion qui tient"
    Le script installe les polices Microsoft (leur licence est acceptée automatiquement),
    puis applique la mise à jour complète du système — plusieurs centaines de paquets sur
    une installation neuve. Il demande le mot de passe au début, pour se relancer avec les
    droits d'administration, puis se déroule seul.
 !!! info "Pourquoi installer les polices Microsoft ?"
    Linux utilise des polices libres. Un document reçu en *Arial* ou *Times New Roman*
@ -617,7 +786,7 @@ Video.
 ---
-## 9. Tests matériels finaux
+## 10. Tests matériels finaux
 Avant de considérer l'installation comme terminée, éprouvez chaque composant : c'est ainsi
 qu'on détecte un pilote manquant pendant que les bénévoles sont encore là.
@ -649,7 +818,7 @@ qu'on détecte un pilote manquant pendant que les bénévoles sont encore là.
 ---
-## 10. Rendre l'ordinateur
+## 11. Rendre l'ordinateur
 Une **vérification par une autre personne** que celle qui a installé conclut la séance :
 un regard neuf repère ce que l'habitude a fait oublier.
--- a/docs/guides/linux-mint-parametres.md
+++ b/docs/guides/linux-mint-parametres.md
@ -14,7 +14,13 @@ son bureau pour la première fois.
    21 : les fenêtres ont pu changer d'allure, les chemins et les boutons décrits restent
    ceux de la 22.3.
-!!! tip "Vous sortez d'une Install Party ?"
+!!! tip "Quatre pages, quatre moments"
    - [Installer Linux Mint depuis Windows](linux-mint-depuis-windows.md) — l'installation elle-même, de la clé USB à l'ordinateur rendu.
    - **Cette page** — le premier démarrage : mises à jour, langue, pilotes.
    - [Trousse de premiers secours](linux-mint-trousse.md) — les gestes de base, en format court et imprimable.
    - [Utiliser Linux Mint](utiliser-linux-mint.md) — la vie courante : paramètres, matériel, logiciels, entretien.
 !!! note "Vous sortez d'une Install Party ?"
    Le [guide d'installation](linux-mint-depuis-windows.md) couvre déjà ces réglages dans
    le fil de l'installation, avec le script de post-installation d'Alpinux qui en
    automatise une partie. Cette page reprend les mêmes points, en détail et dans l'ordre
@ -67,7 +73,8 @@ Thunderbird ont leurs propres paquets, téléchargés après coup.
 Dans la même fenêtre, le bouton **Installer / Supprimer des langues** signale par un
 avertissement les paquets qui manquent pour le français.
-Le même constat remonte dans **Relevés du système**, l'outil de diagnostic de Mint :
+Le même constat remonte dans **Renseignements sur le système**, l'outil de diagnostic de
 Mint, à sa rubrique *Relevés du système* :
 ![Relevés du système — installer des paquets de langue](https://static.alpinux.org/wiki/technique/pratique/pasted/20221213-230255.png)
@ -86,22 +93,31 @@ Si des mises à jour complémentaires sont proposées au passage, acceptez-les.
 ---
-## 3. Lire ce que « Relevés du système » signale
+## 3. Lire ce que le système signale
 ![Relevés du système](https://static.alpinux.org/wiki/technique/pratique/pasted/20221213-230516.png)
-**Menu → Relevés du système** est l'outil qui centralise ce que Mint a remarqué sur votre
+**Menu → Renseignements sur le système** centralise ce que Mint a remarqué sur votre
-machine : paquets de langue incomplets, pilotes propriétaires disponibles, rapports de
+machine. Son menu latéral donne, dans l'ordre : l'identité de la machine (modèle, version
-plantage, et informations système utiles quand on demande de l'aide.
+de Mint, noyau, processeur, carte graphique, mémoire, disques, environnement de bureau),
 puis *USB*, *Processeur graphique*, *PCI*, *BIOS*, et enfin les deux rubriques qui
 signalent quelque chose — **Relevés du système** (paquets de langue incomplets, pilotes
 disponibles) et **Relevés de plantage**.
 !!! tip "Le bouton qui fait gagner un quart d'heure"
    La page d'accueil porte un bouton **Copier** : il met tout le résumé matériel dans le
    presse-papiers, prêt à coller dans un message au LUG ou sur le forum. C'est la
    première chose qu'un bénévole vous demandera.
 Prenez l'habitude d'y passer après une installation, puis à chaque fois que quelque chose
-se comporte bizarrement : c'est la première chose qu'un bénévole vous demandera d'ouvrir.
+se comporte bizarrement.
 ---
 ## 4. Activer les pilotes du matériel
-Toujours dans **Relevés du système**, la rubrique *Installer des pilotes de périphériques*
+Toujours dans **Renseignements sur le système**, la rubrique *Installer des pilotes de
 périphériques*
 ouvre le **Gestionnaire de pilotes** — accessible aussi par **Menu → Gestionnaire de
 pilotes**.
@ -153,7 +169,7 @@ contrôler ce que votre navigateur annonce réellement aux sites.
 - [ ] *Langues* indique **Français, France UTF-8** pour la langue, la région et l'heure
 - [ ] **Appliquer à tout le système** a été cliqué, et l'écran de connexion est en français
 - [ ] Les paquets de langue manquants sont installés
- [ ] *Relevés du système* ne signale plus rien d'urgent
+- [ ] *Renseignements sur le système* ne signale plus rien d'urgent
 - [ ] Le pilote recommandé est activé, la machine a redémarré derrière
 - [ ] Firefox est en français et souligne les fautes de frappe
 - [ ] Le son, le Wi-Fi et le Bluetooth ont été essayés au moins une fois
@ -162,8 +178,7 @@ contrôler ce que votre navigateur annonce réellement aux sites.
 ## Et ensuite
- [Installer Linux Mint depuis Windows](linux-mint-depuis-windows.md) — le parcours
+- [Utiliser Linux Mint](utiliser-linux-mint.md) — la suite directe de cette page : les
-  complet, y compris la restauration du profil Firefox et les tests matériels.
+  Paramètres système, le confort du bureau, le matériel qui résiste, l'entretien.
- [Trousse de premiers secours](linux-mint-trousse.md) — les gestes des premiers jours,
+- [Trousse de premiers secours](linux-mint-trousse.md) — les mêmes gestes en images, à
-  en format court et imprimable.
+  imprimer pour une install party.
 - [Utiliser Linux Mint](utiliser-linux-mint.md) — la prise en main au quotidien.
--- a/docs/guides/linux-mint-trousse.md
+++ b/docs/guides/linux-mint-trousse.md
@ -1,6 +1,23 @@
-# Linux Mint 21 (Vanessa), Trousse de premiers secours
+---
 description: Trousse de premiers secours Linux Mint — les gestes des premiers jours en images : wifi, bluetooth, mises à jour, clé USB, installer et désinstaller un logiciel.
 ---
-[Télécharger la trousse de premiers secours Linux Mint 21 (PDF)](https://static.alpinux.org/wiki/technique/pratique/premiers_secours.pdf){ .md-button }
+# Trousse de premiers secours
 Les gestes des tout premiers jours, en images, pour qui découvre Linux Mint. Rien de plus :
 chaque sujet est traité en détail ailleurs, et les liens y mènent.
 !!! tip "Quatre pages, quatre moments"
    - [Installer Linux Mint depuis Windows](linux-mint-depuis-windows.md) — l'installation elle-même, de la clé USB à l'ordinateur rendu.
    - [Régler Linux Mint après l'installation](linux-mint-parametres.md) — le premier démarrage : mises à jour, langue, pilotes.
    - **Cette page** — les gestes de base, en format court et imprimable.
    - [Utiliser Linux Mint](utiliser-linux-mint.md) — la vie courante : paramètres, matériel, logiciels, entretien.
 !!! info "État du document"
    Captures et PDF réalisés sous **Linux Mint 21 (Vanessa)**. Les fenêtres ont changé
    d'allure depuis, les gestes décrits restent les mêmes en 22.3.
 [Télécharger la trousse de premiers secours (PDF, Mint 21)](https://static.alpinux.org/wiki/technique/pratique/premiers_secours.pdf){ .md-button }
 ## Modifier l'arrière plan du bureau
 ![](https://static.alpinux.org/wiki/technique/pratique/pasted/20221112-070510.png)
@ -21,6 +38,9 @@ Choisir votre box et entrer la clé wifi. Elle est généralement inscrite sur l
 ## Faire les mises à jour
 Les mises à jour sont importantes parce qu'elles protègent votre ordinateur, éliminent les bogues et peuvent même ajouter de nouvelles fonctions à votre système d'exploitation. L'icône des mises à jour se trouve en bas à droite de votre écran.
 Le fonctionnement du gestionnaire, les notifications et les réglages utiles sont expliqués
 dans [Utiliser Linux Mint](utiliser-linux-mint.md#le-gestionnaire-de-mises-a-jour).
 ![](https://static.alpinux.org/wiki/technique/pratique/pasted/20221112-071144.png)
 ## Enlever proprement une clé USB ou un disque dur externe
@ -32,7 +52,8 @@ Clic droit sur le volume que l'on veut enlever **Ejecter** pour une clé USB ou
 ![](https://static.alpinux.org/wiki/technique/pratique/pasted/20221112-071411.png)
 ## Installer des logiciels
-Pour être sûr d'installer un logiciel compatible avec votre système, il faut utiliser le gestionnaire de logiciels.
+Pour être sûr d'installer un logiciel compatible avec votre système, il faut utiliser le gestionnaire de logiciels. La différence entre les logiciels des dépôts et les Flatpak est
 expliquée dans [Utiliser Linux Mint](utiliser-linux-mint.md#installer-des-logiciels).
 ![](https://static.alpinux.org/wiki/technique/pratique/pasted/20221112-071503.png)
--- a/docs/guides/utiliser-linux-mint.md
+++ b/docs/guides/utiliser-linux-mint.md
@ -1,53 +1,313 @@
 ---
 description: Utiliser Linux Mint au quotidien — les Paramètres système, les réglages à faire une fois, le confort du bureau, le matériel qui résiste, l'installation de logiciels et les mises à jour.
 ---
 # Utiliser Linux Mint
 ## Logiciels
 Libre Office - suite bureautique : tableur, traitement de texte...
-VLC - lecteur de vidéo
+Le système est installé et réglé : cette page est celle de la vie courante. Où changer
 quoi, quoi installer, comment tenir la machine à jour, et quoi faire quand un périphérique
 refuse de coopérer.
-Firefox - navigateur Internet
+!!! tip "Quatre pages, quatre moments"
    - [Installer Linux Mint depuis Windows](linux-mint-depuis-windows.md) — l'installation
      elle-même, de la clé USB à l'ordinateur rendu.
    - [Régler Linux Mint après l'installation](linux-mint-parametres.md) — le premier
      démarrage : mises à jour, langue, pilotes.
    - [Trousse de premiers secours](linux-mint-trousse.md) — les gestes de base, en format
      court et imprimable.
    - **Cette page** — tout ce qui vient ensuite.
-Chromium - navigateur Internet
+---
-## Maintenir son système à jour
+## Les Paramètres système
 Les mises à jour du système d'exploitation sont destinées à ajouter de nouvelles fonctionnalités, à corriger des bugues de fonctionnement et/ou des failles de sécurité. Votre système doit donc impérativement être mis à jour. Sous Linux, les mises à jour ne concernent pas uniquement le système d'exploitation, mais également les logiciels et pilotes installés avec la distribution.  
-Pour votre information, le système d’exploitation Linux Mint reposent sur l’utilisation de paquets logiciels via un gestionnaire de paquets.  
+Tout se règle au même endroit : **Menu → Paramètres système**, dont la fenêtre s'intitule
-Un paquet Archives (fichier compressé) contenant les données et informations nécessaires à l’installation d’un logiciel.  
+**Paramètres du système**. Une quarantaine de rubriques, rangées en quatre familles :
 Un gestionnaire de paquets est un ensemble d’outils logiciels permettant d’automatiser l’installation et la gestion de paquets logiciels.
-Les mises à jour peuvent cependant entraîner des régressions, c’est-à-dire qu’elles peuvent rendre certains logiciels instables, entraîner la perte de certaines fonctions, perturber le bon fonctionnement d’autres logiciels, perdre la compatibilité avec certains matériels (Wifi, webcam…), etc.  
+| Famille | Ce qu'on y trouve |
-Pour certains logiciels isolés, ces régressions seront sans conséquences sur l’ensemble du système d’exploitation, mais pour d’autres paquets plus sensibles, les perturbations peuvent être très handicapantes pour l’utilisation du système. Nous appelons les mises à jour concernant ces derniers paquets « Mises à jour sensibles ».  
+| --- | --- |
-Afin d’aider à identifier les différents types de mise à jour (fonctionnelle ou de sécurité) et quel est le niveau de risques concernant les possibles régressions, Linux Mint propose un gestionnaire de mise à jour permettant de gérer au mieux son système d’exploitation et ses paquets.  
+| **Apparence** | Choix des polices, Effets, Fonds d'écran, Thèmes |
-Son utilisation est donc recommandée pour les utilisateurs non experts ainsi que pour ceux souhaitant disposer d’un récapitulatif graphique des informations essentielles concernant les mises à jour disponibles avant de les appliquer.
+| **Préférences** | Accessibilité, Applets, Applications lancées au démarrage, Applications par défaut, Comptes en ligne, Date et heure, Détails du compte, Économiseur d'écran, Espaces de travail, Fenêtres, Gestes, Langues… |
 | **Matériel** | Affichage, Bluetooth, Clavier, Disques, Gestion de l'alimentation, Imprimantes, Réseau, Son, Souris et pavé tactile, Renseignements sur le système |
 | **Administration** | Fenêtre de connexion, Gestionnaire de pilotes, Pare-feu, Sources des logiciels, Administration du système |
-****Paramétrage du gestionnaire de mises à jour****
+Deux réflexes font gagner beaucoup de temps :
 Lors de la première installation de Linux Mint, il vous sera demandé de choisir quel degré de mises à jour vous entendez appliquer.  
 Pour les novices, il est plus prudent de ne cocher que le niveau 2 ( Niveau par défaut - Faible impact sur le système ).  
 Il vous sera possible de modifier ces choix plus tard en allant sur le gestionnaire de mises à jour / Menu Édition / Niveaux /  
 Les quatre possibilités de niveau d'impact des mises à jour sur votre système sont les suivants :  
 - **Niveau 1** : Minimal - Aucun impact sur le système ou sur d'autres programmes.  
 - **Niveau 2** : Normal - Habituellement faible impact sur le système.  
 - **Niveau 3** : Grand - Impact sur plusieurs applications.  
 - **Niveau 4** : Sensible - Impact sur les parties sensibles du système.  
-****Procédure de mise à jour Linux Mint par le gestionnaire de mises à jour****
+- **la barre de recherche en haut** de cette fenêtre : tapez « écran », « son », « heure »
  plutôt que de chercher l'icône ;
 - **la recherche du menu** : la même chose depuis le menu principal, sans ouvrir les
  paramètres.
-****QUAND ?****  
+!!! note "Paramètres système ou Gestionnaire de logiciels ?"
-Votre système Linux Mint est conçu pour vous prévenir de la présence de nouvelles mises à jour. L'applet des mises à jour modifie automatiquement son apparence pour mettre en évidence l'état du système. Il se trouve à droite de votre barre de tâches et représente un bouclier.
+    Les **Paramètres système** règlent le comportement de l'ordinateur — ce qui est déjà
    là. Le **Gestionnaire de logiciels** installe et retire des applications. Deux outils
    différents, deux icônes différentes : la confusion entre les deux est la première
    source d'égarement.
- ****Bouclier avec un V vert**** : Votre système est à jour.
+---
 - ****Bouclier avec un ! bleu**** : Des mises à jour sont disponibles. Cliquez sur l'applet pour les installer.
 - ****Bouclier vide et gris****   : Le système est occupé. Soit il effectue une recherche de mises à jour, soit il ne parvient pas à se connecter au réseau pour vérifier les mises à jour.
 - ****Bouclier avec une X rouge**** : Une erreur est survenue. Veuillez réessayer plus tard. Si vous ne parvenez pas à installer les mises à jour après plusieurs tentatives, mettez-vous en contact avec le LUG ( Groupe d'Utilisateurs Linux - En anglais **L**inux **U**ser **G**roup ) près de chez vous.
-****COMMENT ?****  
+## Les réglages à faire une fois
 - En cliquant sur l'applet, la liste des mises à jour apparaît.  
 - Cliquez sur le bouton Installer les mises à jour.  
 - Entrez votre mot de passe.  
 - Les mises à jour se téléchargent et s'installent automatiquement.  
 - A la fin du processus, le gestionnaire des mises à jour vous indique que votre système est à jour.  
 - Vous pouvez alors fermer la fenêtre du gestionnaire.
-### Références
+### Le gestionnaire de mises à jour
- https://link-zilla.blogspot.com/2020/05/linux-mint-gestionnaire-mises-a-jour.html
+
- https://forum-francophone-linuxmint.fr/viewtopic.php?t=8953
+Les mises à jour ajoutent des fonctions, corrigent des bogues et bouchent des failles de
 sécurité. Sous Linux elles ne concernent pas que le système : les logiciels et les pilotes
 installés avec la distribution passent par le même canal.
 Linux Mint repose sur des **paquets** — des archives contenant un logiciel et les
 informations nécessaires à son installation — gérés par un **gestionnaire de paquets**,
 qui automatise l'ensemble.
 Une mise à jour peut aussi provoquer une régression : logiciel instable, fonction perdue,
 matériel qui cesse d'être reconnu (Wi-Fi, webcam).
 !!! warning "Les « niveaux » de mise à jour n'existent plus"
    Jusqu'à Mint 19, le gestionnaire classait les mises à jour en quatre niveaux, et l'on
    conseillait aux débutants de s'en tenir au niveau 2. **Ce système a disparu** : sur
    Mint 22.3, il n'y a plus ni menu *Édition → Niveaux*, ni réglage correspondant.
    Vérifié sur une installation 22.3 en septembre 2026 — si vous trouvez un tutoriel qui
    en parle, il décrit une version ancienne.
    La réponse de Mint au risque de régression est ailleurs : **les instantanés système**,
    que le gestionnaire met en avant dès son premier lancement (voir *Prendre des
    instantanés avec Timeshift*, plus bas).
 **Au premier lancement**
 Le gestionnaire commence par un écran d'accueil qui distingue trois choses : les **mises à
 jour de sécurité**, les **mises à jour logicielles** et les **instantanés système**. Il
 propose ensuite d'utiliser un **miroir de dépôts local**, plus rapide que le serveur par
 défaut : acceptez. Il peut enfin se mettre à jour lui-même avant d'afficher le reste.
 **Quand mettre à jour ?**
 L'applet en forme de bouclier, à droite de la barre des tâches, change d'aspect selon
 l'état du système :
 | Bouclier | Signification |
 | --- | --- |
 | **V vert** | Le système est à jour |
 | **! bleu** | Des mises à jour sont disponibles — cliquez pour les installer |
 | **Gris, vide** | Le système cherche les mises à jour, ou n'arrive pas à joindre le réseau |
 | **X rouge** | Une erreur est survenue ; réessayez plus tard, et voyez avec le LUG si elle persiste |
 **Comment ?** Cliquez sur l'applet, puis sur **Installer les mises à jour**, saisissez
 votre mot de passe, et laissez faire. Le gestionnaire annonce à la fin que le système est
 à jour.
 **Ce que contient le menu Édition** : *Préférences*, *Instantanés système* et *Sources de
 logiciels* — rien d'autre.
 Les **Préférences** s'organisent en trois onglets :
 | Onglet | Ce qu'on y règle |
 | --- | --- |
 | **Options** | L'interface (cacher la fenêtre après installation, afficher une icône de notification), l'actualisation automatique de la liste, et les notifications — dont *N'afficher que les notifications des mises à jour de sécurité et des noyaux* |
 | **Paquets** | Ce qui apparaît dans la liste : mises à jour de Cinnamon, paquets Flatpak, noyaux |
 | **Automatisation** | Les mises à jour appliquées sans intervention |
 !!! tip "Le piège du `/boot` plein"
    Les anciens noyaux s'accumulent et finissent par saturer la partition de démarrage,
    ce qui bloque toute nouvelle mise à jour. L'onglet *Automatisation* permet de
    programmer leur suppression ; à défaut, passez de temps en temps par
    **Affichage → Noyaux Linux**, qui les liste et permet de retirer les plus anciens.
 !!! warning "Changer de noyau n'est pas anodin"
    La même fenêtre *Noyaux Linux* s'ouvre sur un avertissement qu'il vaut la peine de
    lire : un noyau plus récent peut faire disparaître le Wi-Fi, l'accélération graphique,
    ou donner un écran noir au démarrage — surtout avec des pilotes propriétaires.
    La sortie de secours tient en quatre gestes, à connaître **avant** d'en installer un :
    redémarrer, maintenir **Maj** pour afficher le menu GRUB, choisir *Advanced options*
    puis un noyau antérieur, et désinstaller le plus récent une fois revenu.
 ### Activer le pare-feu
 Le pare-feu est installé, mais **désactivé par défaut**. Pour un ordinateur portable qui
 se connecte à des réseaux publics, il vaut mieux l'allumer :
 **Paramètres du système → Pare-feu** (famille *Administration*). L'ouverture demande votre
 mot de passe, puis il suffit de basculer **État** sur *Activé*.
 Le profil proposé par défaut, **Domestique**, convient : les deux lignes en dessous
 annoncent la règle appliquée — *Entrant : Refuser*, *Sortant : Autoriser*. Autrement dit,
 rien ne rentre sans y avoir été invité, tout ce que vous lancez sort normalement. Les
 profils *Bureau* et *Public* servent à mémoriser d'autres jeux de règles ; sans besoin
 précis, n'y touchez pas.
 ### Vérifier ses pilotes
 **Paramètres du système → Gestionnaire de pilotes** (famille *Administration*) liste le
 matériel pour lequel un pilote propriétaire existe. Si la case cochée est celle d'un pilote libre alors qu'un pilote recommandé est
 proposé, essayez ce dernier, puis redémarrez.
 !!! warning "Prudence avec la carte graphique"
    Changer un pilote graphique peut mener à un écran noir au redémarrage. Faites-le quand
    vous avez le temps de revenir en arrière — et de préférence après avoir pris un
    instantané Timeshift.
 ### Alléger le démarrage
 **Paramètres du système → Applications lancées au démarrage** montre ce qui se lance à
 l'ouverture de session. Désactivez ce que vous n'utilisez pas : chaque entrée retarde l'arrivée du
 bureau. Dans le doute, désactivez plutôt que de supprimer.
 ### Prendre des instantanés avec Timeshift
 **Menu → Timeshift** photographie le système à intervalles réguliers et permet de revenir
 en arrière après une mise à jour malheureuse ou une fausse manœuvre.
 - Choisissez **RSYNC** à la première ouverture.
 - Gardez peu d'instantanés — deux ou trois — sur un petit disque.
 - Timeshift sauvegarde le **système**, pas vos documents : pour ces derniers, voyez
  *Menu → Sauvegarde*, ou une copie sur disque externe.
 !!! tip "Des instantanés qui grossissent trop"
    Les applications Flatpak sont volumineuses et changent souvent : elles peuvent faire
    gonfler les instantanés hors de proportion. Dans *Timeshift → Paramètres → Filtres*,
    excluez `/var/lib/flatpak` si l'espace disque devient un souci.
 ---
 ## Le confort du bureau
 ### Écrans
 **Paramètres du système → Affichage** gère la disposition d'un deuxième écran (à gauche, à
 droite, en miroir), la résolution et la fréquence.
 Sur un portable récent à écran très fin — 13 ou 14 pouces en haute définition — tout
 paraît minuscule. C'est le réglage d'**échelle de l'interface** qu'il faut modifier, dans
 la même fenêtre, et non la résolution : baisser la résolution rend l'image floue, alors
 que l'échelle agrandit proprement.
 ### Apparence
 **Paramètres du système → Thèmes** change l'aspect général, y compris le mode sombre —
 Mint 22.3 démarre d'ailleurs en thème sombre. **Choix des polices** règle la taille du
 texte partout à la fois, plus efficace que d'agrandir chaque application séparément.
 ### Panneau et menu
 Clic droit sur la barre des tâches → **Configurer** : hauteur, position (en haut plutôt
 qu'en bas, par exemple), et **Ajouter des applets** pour la météo, la charge, ou un
 sélecteur de fenêtres.
 Clic droit sur une application dans le menu → **Ajouter aux favoris** pour l'épingler.
 ### Énergie et veille
 **Paramètres du système → Gestion de l'alimentation** décide de ce qui se passe quand on
 ferme le capot, au bout de combien de temps l'écran s'éteint, et si la machine se met en
 veille. Sur un ordinateur de bureau, mettre la veille sur *Jamais* évite bien des retours
 d'écran capricieux.
 ### Clavier
 **Paramètres du système → Clavier** contient deux réglages qui rendent service :
 - la **touche compose**, dans *Options*, qui donne accès aux caractères absents du clavier
  (œ, æ, ©, majuscules accentuées) ;
 - les **raccourcis**, pour ouvrir un terminal ou changer de bureau sans la souris.
 Pour que le **pavé numérique** soit actif dès l'écran de connexion :
 *Paramètres du système → Fenêtre de connexion → Paramètres → Activer le verrouillage
 numérique*.
 ### Pavé tactile
 **Paramètres du système → Souris et pavé tactile** : défilement à deux doigts, clic par
 tapotement, désactivation pendant la frappe — le réglage qui évite le curseur qui saute
 au milieu d'une phrase.
 ---
 ## Quand le matériel résiste
 Trois sujets reviennent sans cesse sur les forums francophones, et valent d'être connus
 avant de chercher.
 ### Imprimante
 **Paramètres du système → Imprimantes → Ajouter**. La plupart des imprimantes réseau sont
 détectées seules ; les modèles USB aussi, une fois allumés et branchés.
 Si l'imprimante apparaît mais imprime de travers, ou se présente comme « imprimante
 générique », le pilote générique ne suffit pas : certains constructeurs — **Canon** en
 particulier — publient des pilotes Linux à télécharger sur leur site et à installer à la
 main. Un passage par le [forum
 francophone](https://forum-francophone-linuxmint.fr/) évite souvent une heure de
 tâtonnement : le modèle a généralement déjà été traité.
 ### Bluetooth
 L'adaptateur peut être éteint au démarrage : l'applet Bluetooth de la barre des tâches
 permet de l'allumer, et *Paramètres du système → Bluetooth* de gérer les appareils
 appairés.
 Un casque qui ne se reconnecte pas tout seul se règle le plus souvent en le supprimant de
 la liste puis en le réappairant. Si l'adaptateur n'apparaît pas du tout, c'est un pilote
 manquant : voyez le gestionnaire de pilotes, puis demandez de l'aide avec le modèle exact
 de la machine.
 ### Son
 **Paramètres du système → Son** liste les sorties disponibles. Le cas classique : le son
 reste dans les haut-parleurs alors qu'un casque est branché — il suffit de choisir la
 bonne sortie dans cette fenêtre. Même chose pour le micro, dans l'onglet *Entrée*, où le
 niveau peut être à zéro.
 ---
 ## Installer des logiciels
 Le **Gestionnaire de logiciels** (*Menu → Gestionnaire de logiciels*) est la bonne porte
 d'entrée : il cherche, installe et désinstalle proprement. La
 [trousse de premiers secours](linux-mint-trousse.md) en montre les écrans pas à pas.
 Deux origines coexistent, et le gestionnaire indique laquelle il propose :
 | Origine | Ce que c'est |
 | --- | --- |
 | **Dépôts système** (apt) | Les paquets intégrés à Mint, testés avec votre version. À préférer par défaut. |
 | **Flatpak** | Des applications autonomes, souvent plus récentes, qui embarquent ce dont elles ont besoin. Utile quand la version des dépôts est trop ancienne. |
 !!! note "Et Snap ?"
    Mint **bloque volontairement** l'installation de `snapd`, le format concurrent poussé
    par Ubuntu. Ce n'est pas un bogue : un équivalent Flatpak existe pour à peu près tout.
    N'essayez pas de le contourner sans raison précise.
 Quelques logiciels installés d'office, pour situer : **LibreOffice** (traitement de texte,
 tableur, présentation), **Firefox** (navigateur), **Thunderbird** (courriel), **VLC**
 (vidéo et audio), **GIMP** (retouche d'images), **Timeshift** (instantanés système).
 ---
 ## Entretenir la machine
 Quelques gestes, quelques minutes par mois :
 - [ ] Installer les mises à jour proposées par l'applet bouclier
 - [ ] Redémarrer après une mise à jour du noyau (l'applet le signale)
 - [ ] Vérifier l'espace disque restant (*Menu → Analyseur d'utilisation des disques*)
 - [ ] Vider la corbeille et le dossier des téléchargements
 - [ ] Contrôler que les instantanés Timeshift sont récents — et qu'ils ne saturent pas le
      disque
 - [ ] Sauvegarder ses documents ailleurs que sur la machine
 !!! tip "Une question sans réponse ici ?"
    Les réunions Alpinux ont lieu les 1er et 3e jeudis du mois, et le
    [forum francophone Linux Mint](https://forum-francophone-linuxmint.fr/) traite déjà la
    plupart des cas. Donnez toujours votre version de Mint — *Menu → Renseignements sur le
    système*, bouton **Copier** —,
    le modèle de la machine, et le message d'erreur exact.
 ---
 ## Références
 - [Paramétrer Linux Mint — InfoLibre](https://infolib.re/Parametrer_Linux_Mint)
 - [Le panneau de paramètres système — TuxLibre](https://lewinux.over-blog.fr/2020/12/linux-mint-le-panneau-de-parametres-systeme.html)
 - [Instantanés système — guide d'installation officiel de Linux Mint](https://linuxmint-installation-guide.readthedocs.io/en/latest/timeshift.html)
 - [Gestionnaire de mises à jour — Link-Zilla](https://link-zilla.blogspot.com/2020/05/linux-mint-gestionnaire-mises-a-jour.html)
 - [Forum francophone Linux Mint](https://forum-francophone-linuxmint.fr/)
--- a/docs/technique/deploiement-wiki.md
+++ b/docs/technique/deploiement-wiki.md
@ -181,45 +181,53 @@ Une exécution réussie encadre le build par une ligne `Deploy started` et une l
 ---
-## Ce que le build publie pour la page d'accueil
+## Ce que le build publie pour alpinux.org
-Chaque build écrit, à la racine du site, un fichier
+Chaque build écrit deux fichiers à la racine du site, avec pour chaque page son titre,
-**[`derniers-articles.json`](https://wiki.alpinux.org/derniers-articles.json)** : les
+son adresse et la date du commit qui a touché son contenu :
 vingt dernières pages créées ou modifiées, avec leur titre, leur URL et la date du commit
 qui a touché leur contenu. C'est ce fichier que lit la page d'accueil
 [alpinux.org](https://alpinux.org) pour afficher « Le wiki, fraîchement mis à jour ».
-Il est produit par le hook `hooks/derniers_articles.py`, déclaré dans `mkdocs.yml`. Trois
+| Fichier | Ce qu'il porte | Qui le lit |
-choses à savoir :
+|---|---|---|
 | `derniers-articles.json` | Les vingt dernières pages créées ou modifiées | L'accueil d'alpinux.org, section « Le wiki, fraîchement mis à jour » |
 | `toutes-les-pages.json` | Toutes les pages, sans limite, avec leur rubrique | La page des mises à jour d'alpinux.org |
- **Un déplacement n'est pas une mise à jour.** Les dates viennent de `git log` avec suivi
+Le second est la liste entière, le premier son début : un seul parcours de l'historique
-  des renommages : déplacer `guides/truc.md` ne fait pas remonter l'article en tête de
+git les produit tous les deux, et ils portent la même date de génération.
  liste, seule une modification de son texte le fait.
 - **Seules les pages de la navigation sont annoncées.** Une page hors `nav` — typiquement
  la redirection laissée derrière un article déplacé — n'apparaît jamais dans la liste.
 - **Le hook n'échoue jamais.** Sans historique git, il n'écrit rien et le build continue ;
  l'accueil d'alpinux.org masque alors simplement sa section wiki. Ses messages sont pour
  cela de niveau *info* et jamais *warning* : le déploiement construit avec `--strict`, où
  un seul avertissement suffit à interrompre le build et donc la publication.
-!!! warning "Deux conditions côté serveur"
+Ils sont produits par le hook `hooks/derniers_articles.py`, déclaré dans `mkdocs.yml`.
-    **Le clone doit avoir son historique.** Un clone `--depth 1` ne porte qu'un commit :
+Trois choses à savoir :
    toutes les pages sembleraient modifiées le même jour. Le hook le détecte et le
    signale dans le journal du build, sans rien casser.
-    **Le `.htaccess` du DocumentRoot est réécrit à chaque déploiement.** Le hook le
+- **Un déplacement n'est pas une mise à jour.** Les dates viennent de `git log` avec
-    dépose dans le staging, que `rsync --delete` recopie intégralement : un `.htaccess`
+  suivi des renommages : déplacer `guides/truc.md` ne fait pas remonter l'article en
-    qui aurait été posé à la main sur le serveur serait effacé au premier build. S'il
+  tête de liste, seule une modification de son texte le fait.
-    faut d'autres règles Apache, ajoutez-les dans le hook — c'est désormais lui qui fait
+- **Seules les pages de la navigation sont annoncées.** Une page absente de `nav` —
-    foi.
+  typiquement la redirection laissée derrière un article déplacé — n'apparaît jamais
  dans la liste.
 - **Le hook n'échoue jamais.** Sans historique git, il n'écrit rien et le build
  continue ; alpinux.org masque alors simplement ce qu'il ne peut pas remplir. Ses
  messages sont pour cela de niveau *info* et jamais *warning* : le déploiement
  construit avec `--strict`, où un seul avertissement suffit à interrompre le build,
  et donc la publication.
-Le même hook dépose un `.htaccess` d'une ligne utile : il autorise les autres sous-domaines
+Le même hook pose l'en-tête `Access-Control-Allow-Origin` sur ces deux fichiers, et
-à lire ce seul fichier JSON (`Access-Control-Allow-Origin`). Sans lui, le navigateur
+sur eux seuls, au moyen d'un `.htaccess` déposé à la racine du site construit. Sans
-refuserait à alpinux.org le droit de lire une réponse venue de wiki.alpinux.org.
+lui, le navigateur refuserait à alpinux.org le droit de lire une réponse venue de
 wiki.alpinux.org.
 !!! warning "Deux conditions"
    **Le clone doit avoir son historique.** Un clone `--depth 1` ne porte qu'un
    commit : toutes les pages sembleraient modifiées le même jour. Le hook le détecte
    et le signale dans le journal du build, sans rien casser.
    **Un `.htaccess` posé à la main sur le serveur est effacé au déploiement suivant**,
    puisque le staging est recopié avec `rsync --delete`. Pour ajouter des règles
    Apache durables, placez-les dans `docs/.htaccess` : MkDocs le recopie dans le site
    construit, et le hook **ajoute** son bloc à la suite au lieu de le remplacer.
 ```bash
 # vérifier ce que le dernier build a publié
 curl -s https://wiki.alpinux.org/derniers-articles.json | head -20
 curl -s https://wiki.alpinux.org/toutes-les-pages.json | head -20
 ```
 ---
@ -256,4 +264,5 @@ Ouvrez [http://localhost:8000](http://localhost:8000) — MkDocs recharge automa
 | Déployer à la main (webhook en panne) | `deploy-wiki.sh`, sur le serveur |
 | Voir le journal des déploiements | `tail -20 /var/log/wiki-deploy.log` |
 | Vérifier la liste envoyée à l'accueil | `curl -s https://wiki.alpinux.org/derniers-articles.json` |
 | Vérifier l'inventaire complet publié | `curl -s https://wiki.alpinux.org/toutes-les-pages.json` |
 | Régénérer les fichiers du logo (poste local) | `python3 scripts/build-assets.py` |
--- a/docs/technique/serveur-install-party.md
+++ b/docs/technique/serveur-install-party.md
@ -0,0 +1,169 @@
 ---
 description: Le serveur qu'Alpinux emporte en install party — partage de connexion, réseau local, cache de paquets APT, page de santé, et ce qu'un bénévole doit en savoir sur place.
 ---
 # Le serveur qu'on emporte en install party
 Quinze ordinateurs qui s'installent le même matin, c'est quinze fois les mêmes
 cinq cents mégaoctets tirés par la ligne de la salle — quand il y en a une. Alpinux
 apporte donc sa propre machine, **alpicache**, qui partage l'accès à Internet, sert un
 réseau local aux postes en cours d'installation, et **garde en cache les paquets déjà
 téléchargés**.
 !!! note "Pour qui est cette page"
    Pour les bénévoles qui installent, et pour qui prépare la salle. La configuration
    complète de la machine — interfaces, services, dépannage détaillé — vit dans son
    propre dépôt, `alpinux.alpicache`, et non ici.
 ---
 ## Le réseau de la salle
 ```mermaid
 flowchart LR
  A[Prise murale<br/>ou box de la salle] --> B[alpicache<br/>10.0.0.1]
  B --> C[Switch]
  C --> D[Poste 1]
  C --> E[Poste 2]
  C --> F[Poste n]
 ```
 La machine tient les deux bouts : d'un côté elle demande un accès à la salle, de l'autre
 elle distribue un réseau en **10.0.0.x** aux postes branchés sur le switch. Les rôles ne
 sont pas figés à l'avance : elle désigne comme sortie la première prise où on lui répond,
 et sert le réseau local sur l'autre.
 !!! warning "Les postes se branchent sur le switch, jamais sur la box"
    Un poste branché directement sur la box de la salle reçoit une adresse de la salle :
    il ne voit plus le cache, ne trouve plus les scripts, et fait tomber les compteurs à
    zéro. C'est l'erreur la plus fréquente, et elle ne se voit pas tout de suite.
 ---
 ## Ce que la machine offre, une fois branchée
 | Adresse | À quoi ça sert |
 | --- | --- |
 | **<http://alpicache.lan/>** | La page de santé : réseau, disques, machines servies, cache |
 | **`http://apt-proxy:3142`** | Le cache de paquets, à déclarer comme mandataire |
 | **`http://10.0.0.1/`** | Les scripts d'Alpinux, servis sur place — dont `verif-disque.sh` et `install.sh` |
 La page de santé se rafraîchit seule ; c'est le tableau de bord de la journée. Quatre
 cartes à surveiller :
 | Carte | Ce qu'on veut y voir |
 | --- | --- |
 | **Réseau** | une sortie *et* un réseau local nommés, « Internet joignable » |
 | **Disques** | le disque du cache présent, avec de la place |
 | **Machines servies** | le nombre grandit à mesure que les postes arrivent |
 | **Cache de paquets** | « Économisé » qui monte au fil de la matinée |
 **« Machines servies » qui reste à zéro** alors que des postes sont branchés, c'est le
 signe que le réseau local ne distribue pas d'adresses : prévenez la personne qui tient la
 machine plutôt que de chercher sur le poste du participant.
 ---
 ## Faire passer une installation par le cache
 C'est là que tout se joue, et le geste n'est pas le même selon le système.
 ### Debian
 L'installateur demande un mandataire à l'écran **« Configurer le miroir de l'archive
 Debian »**. Saisissez-y :
 ```
 http://apt-proxy:3142
 ```
 C'est **le seul moment** où on peut le faire, et c'est celui qui compte : toute
 l'installation passe alors par le cache.
 ### Linux Mint et Ubuntu
 Leur installateur ne demande pas de mandataire : l'installation elle-même sortira sur
 Internet. Le gain arrive juste après — sur les mises à jour et les logiciels ajoutés,
 c'est-à-dire sur l'essentiel du volume.
 Une fois la machine redémarrée sur son nouveau système :
 ```bash
 sudo apt install auto-apt-proxy
 ```
 Ce paquet cherche un cache sur le réseau local et s'en sert quand il en trouve un — sans
 rien à configurer, et sans gêner la machine une fois rentrée chez son propriétaire.
 !!! tip "Le script de post-installation le fait déjà"
    Le [script d'Alpinux](../guides/linux-mint-depuis-windows.md#le-script-de-post-installation-alpinux)
    installe `auto-apt-proxy` parmi ses réglages : si vous le lancez, c'est fait.
 ---
 ## Ce qui coince, et la parade
 **La salle n'a pas de réseau.** Un téléphone Android en partage de connexion USB fait
 l'affaire : branché sur la machine, il devient la sortie. Prévoyez le câble.
 **Le disque du cache n'est pas vu.** Il doit être branché **avant** d'allumer la machine.
 Après coup, le cache démarre sans rien dire et ne garde rien — la carte *Disques* de la
 page de santé le montre tout de suite.
 **Un poste n'obtient pas d'adresse.** Vérifiez d'abord le câble et le switch, puis la
 carte *Machines servies*. Une adresse en `169.254.x.x` signifie que le poste n'a reçu
 aucune réponse : il s'en est inventé une.
 **`apt` renvoie des « 503 Connection closed » en série.** Le cache accepte la requête mais
 ne sait pas où aller la chercher — c'est arrivé le 24/09/2026, et une installation Mint
 s'y est arrêtée. Le piège est qu'**interroger le cache directement répond parfaitement** :
 les deux chemins ne suivent pas la même route à l'intérieur du serveur. Ne cherchez donc
 pas sur la machine du participant : prévenez la personne qui tient le serveur.
 ---
 ## Pour préparer une install party
 La veille, la machine s'allume chez quelqu'un, sur une ligne rapide, et l'on garnit le
 cache avec ce qu'on va installer — si la version de Mint a changé depuis la dernière
 sortie, autant la tirer maintenant.
 !!! warning "Le cache ne sert que ce qu'il connaît"
    Le pré-chargement vise des versions nommées, et une version absente de la liste ne
    profite à personne. Le 24/09/2026, la première Mint 22.3 de la soirée a tiré **1,3 Go
    d'Internet pour 82 Mo servis par le cache** : le pré-chargeur couvrait encore les
    versions précédentes.
    Avant chaque sortie, vérifiez donc que la liste des versions pré-chargées correspond à
    celle que vous allez réellement installer. C'est par le **nom de code** que le
    pré-chargement les désigne, et un décalage d'un cran suffit à garnir le cache de la
    mauvaise version :
    | Version | Nom de code |
    |---|---|
    | Mint 22 | `wilma` |
    | Mint 22.1 | `xia` |
    | Mint 22.2 | `zara` |
    | Mint 22.3 | `zena` |
    Pour mémoire, la série précédente : `vanessa` (21), `vera` (21.1), `victoria` (21.2),
    `virginia` (21.3).
 Sur place, l'ordre de branchement n'est pas une superstition : le disque externe d'abord,
 puis le câble Internet **seul**, puis la machine, et seulement ensuite le switch et les
 postes. Brancher la sortie seule d'abord, c'est ôter à la machine toute occasion de se
 tromper de rôle.
 La procédure complète — ce qu'on emporte, les vérifications, le dépannage, la fiche à
 cocher pour chaque participant et l'affiche à scotcher près du switch — est dans le dépôt
 `alpinux.alpicache`. Demandez-la à un membre du bureau avant une sortie.
 ---
 ## Voir aussi
 - [Install Party](../alpinux/install-party.md) — les dates, et comment y participer
 - [Installer Linux Mint depuis Windows](../guides/linux-mint-depuis-windows.md) — le guide
  suivi sur place
 - [Préparation d'un serveur Debian 13](serveur-debian-13.md) — pour la machine, la base
  système est la même
--- a/hooks/derniers_articles.py
+++ b/hooks/derniers_articles.py
@ -1,68 +1,88 @@
-"""Publie « derniers-articles.json » : les pages récemment créées ou modifiées.
+"""Publie ce que le wiki a écrit ou repris, pour qui l'affiche ailleurs.
-Le fichier est écrit à la racine du site construit, à côté de `sitemap.xml`, et sert
+Deux fichiers, écrits à chaque build à côté des pages et servis avec l'en-tête CORS
-la page d'accueil de https://www.alpinux.org — d'où le petit `.htaccess` qui l'ouvre
+sans lequel un autre domaine ne peut pas les lire :
 aux requêtes venues d'un autre sous-domaine.
-Les dates viennent de git, pas du système de fichiers : c'est la date du commit qui a
+- `derniers-articles.json` — les vingt dernières pages touchées, que la page d'accueil
-touché le contenu de la page. **Un déplacement n'est pas une mise à jour** — renommer
+  d'alpinux.org lit pour sa section « Le wiki, fraîchement mis à jour » ;
-`guides/truc.md` ne fait pas remonter l'article ; seule une modification de son texte
+- `toutes-les-pages.json` — le même inventaire, sans limite de nombre et avec la
-le fait.
+  rubrique de chaque page, pour la page des mises à jour d'alpinux.org.
-Le hook n'échoue jamais : sans git, ou en cas d'erreur, il n'écrit simplement rien et
+Les deux sortent du même calcul : le second est la liste entière, le premier son
-le build continue (le site reste valide, la page d'accueil garde ses tuiles statiques).
+début.
-Ses messages sont volontairement de niveau *info* et jamais *warning* : le déploiement
+Les dates viennent de git, pas du système de fichiers : un `git clone` repose tous les
-construit le site avec `--strict`, où le moindre avertissement interrompt le build. Un
+fichiers à la même seconde, et une page recopiée depuis Obsidian aurait l'air neuve.
-hook d'agrément ne doit pas pouvoir empêcher la publication du wiki.
+Les renommages sont ignorés (`-M`, statut `R` écarté) — déplacer un article ne le rend
 pas nouveau.
 """
 from __future__ import annotations
 import json
 import logging
 import subprocess
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from urllib.parse import urljoin
-log = logging.getLogger("mkdocs.hooks.derniers_articles")
+from mkdocs.plugins import log
-FICHIER = "derniers-articles.json"
+FICHIER_RECENTS = "derniers-articles.json"
-NB_MAX = 20                  # articles retenus dans le JSON
+FICHIER_TOUTES  = "toutes-les-pages.json"
-JOURS_NOUVEAU = 45           # en deçà, l'article est signalé comme nouveau
+
-EXCLUS = {"index.md"}        # l'accueil du wiki n'est pas un article
+# Ce que le premier fichier porte au plus. L'accueil n'en affiche que six, mais le
 # fichier sert aussi à qui voudrait en faire autre chose. Le second ne plafonne pas.
 NB_MAX = 20
 # En deçà, un article est annoncé comme « publié » plutôt que « mis à jour ».
 JOURS_NOUVEAU = 45
 # Les pages d'accueil de section n'annoncent rien : elles listent ce qu'il y a dessous.
 EXCLUS = {"index.md"}
 # Pages construites, remplies au fil du build : chemin source -> titre et URL.
 _pages: dict[str, dict[str, str]] = {}
 # Pages réellement présentes dans la navigation : les seules annoncées.
 _dans_la_nav: set[str] = set()
 _rubriques: dict[str, str] = {}
 def _rubrique_par_page(items, rubrique=""):
    """Associe chaque page de la navigation au titre de la section qui la porte.
    On garde la section de premier niveau — « Guides », « Contribuer » — plutôt que la
    plus proche : c'est l'échelle à laquelle un lecteur range les pages.
    """
    for item in items:
        if item.is_section:
            yield from _rubrique_par_page(item.children, rubrique or item.title)
        elif item.is_page:
            yield item.file.src_uri, rubrique
 def on_nav(nav, config, files):
-    """Retient les pages de la navigation.
+    """Retient les pages de la navigation, et sous quelle rubrique elles vivent.
    Ce qui en est absent — les redirections laissées derrière un article déplacé, par
    exemple — n'a pas à être annoncé comme une nouveauté.
    """
    _dans_la_nav.clear()
    _dans_la_nav.update(page.file.src_uri for page in nav.pages)
-    return nav
+
    _rubriques.clear()
    _rubriques.update(_rubrique_par_page(nav.items))
 def on_page_context(context, page, config, nav):
    """Retient le titre et l'URL de chaque page rendue."""
    _pages[page.file.src_uri] = {
-        "titre": page.title or page.file.src_uri,
+        "titre": page.title,
        "url": urljoin(config["site_url"] or "", page.url),
    }
    return context
 def _git(depot: Path, *args: str) -> str:
    return subprocess.run(
        ["git", "-C", str(depot), *args],
-        capture_output=True, text=True, check=True, timeout=30,
+        capture_output=True, text=True, check=True,
    ).stdout
@ -75,115 +95,141 @@ def _est_superficiel(depot: Path) -> bool:
 def _historique(depot: Path, dossier: str) -> tuple[dict, dict]:
-    """Retourne (dernière modification, date de création) par chemin actuel.
+    """Rend deux tables chemin → date ISO : dernière écriture, et première.
-    Le journal est parcouru du plus récent au plus ancien. Les renommages sont suivis
+    `git log` remonte le temps : la première date vue pour un fichier est la plus
-    — pour rattacher l'histoire d'un article déplacé à son chemin actuel — mais ne
+    récente, la dernière est celle de sa création.
    comptent pas comme une modification.
    """
    sortie = _git(
-        depot, "log", "--no-merges", "-M", "--name-status",
+        depot, "log", "--no-merges", "-M", "--name-status", "--format=%x01%aI",
-        "--format=%x01%aI", "--", dossier,
+        "--", dossier,
    )
-    alias: dict[str, str] = {}      # chemin d'alors -> chemin actuel
+    modifiees: dict[str, str] = {}
-    modifiees: dict[str, str] = {}  # chemin actuel -> date de la dernière modification
+    creees: dict[str, str] = {}
    creees: dict[str, str] = {}     # chemin actuel -> date de création
    date = ""
    for ligne in sortie.splitlines():
        if ligne.startswith("\x01"):
            date = ligne[1:].strip()
            continue
-        if not ligne.strip() or not date:
+        if not ligne or not date:
            continue
        champs = ligne.split("\t")
        statut = champs[0]
-
+        if statut.startswith("R"):     # renommage : le contenu n'a pas bougé
        if statut.startswith("R") and len(champs) >= 3:
            ancien, nouveau = champs[1], champs[2]
            alias[ancien] = alias.pop(nouveau, nouveau)
            continue
-
+        chemin = champs.pop()
        chemin = alias.get(champs[-1], champs[-1])
        if not chemin.endswith(".md"):
            continue
-        if statut.startswith("A"):
+        modifiees.setdefault(chemin, date)
-            creees[chemin] = date
+        if statut == "A":
-        if statut.startswith(("A", "M")):
+            creees[chemin] = date      # on remonte le temps : le dernier vu est le bon
            modifiees.setdefault(chemin, date)
    return modifiees, creees
 def _autoriser_la_lecture_croisee(site_dir: Path, fichiers: list[str]) -> None:
    """Pose l'en-tête CORS sur les seuls fichiers qui en ont besoin.
    Ils sont lus depuis alpinux.org : sans cet en-tête, le navigateur refuse la
    réponse et la section reste masquée. Le bloc s'ajoute à un `.htaccess` déjà là
    plutôt que de le remplacer — on ne sait pas ce qu'il porte d'autre — et n'est
    écrit que pour les fichiers qui n'y figurent pas encore.
    """
    fichier = site_dir / ".htaccess"
    existant = fichier.read_text(encoding="utf-8") if fichier.exists() else ""
    manquants = [nom for nom in fichiers if nom not in existant]
    if not manquants:
        return
    bloc = "<IfModule mod_headers.c>\n"
    for nom in manquants:
        bloc += (
            f'  <Files "{nom}">\n'
            '    Header set Access-Control-Allow-Origin "*"\n'
            "  </Files>\n"
        )
    bloc += "</IfModule>\n"
    separateur = "\n" if existant and not existant.endswith("\n") else ""
    fichier.write_text(existant + separateur + bloc, encoding="utf-8")
 def on_post_build(config):
    site_dir = Path(config["site_dir"])
    docs_dir = Path(config["docs_dir"])
    depot = docs_dir.parent
    dossier = docs_dir.name
    try:
-        modifiees, creees = _historique(depot, dossier)
+        modifiees, creees = _historique(depot, docs_dir.name)
    except (OSError, subprocess.SubprocessError) as erreur:
-        log.info("derniers-articles : historique git illisible (%s), fichier non écrit", erreur)
+        log.info("derniers-articles : historique git illisible (%s), fichier non écrit",
                 erreur)
        return
    if _est_superficiel(depot):
        log.info("derniers-articles : clone superficiel, les dates ne sont pas fiables")
-    limite = datetime.now(timezone.utc) - timedelta(days=JOURS_NOUVEAU)
+    seuil = datetime.now(timezone.utc) - timedelta(days=JOURS_NOUVEAU)
-    articles = []
+    pages = []
-    for chemin, date in modifiees.items():
+    for chemin, modifiee in modifiees.items():
-        source = chemin[len(dossier) + 1:] if chemin.startswith(dossier + "/") else chemin
+        prefixe = docs_dir.name + "/"
-        page = _pages.get(source)
+        if not chemin.startswith(prefixe):
-        if page is None or source in EXCLUS or source not in _dans_la_nav:
+            continue
-            continue  # page supprimée, hors navigation, ou volontairement écartée
+        src_uri = chemin[len(prefixe):]
-        creation = creees.get(chemin, date)
+        page = _pages.get(src_uri)
        if page is None or Path(src_uri).name in EXCLUS or src_uri not in _dans_la_nav:
            continue
        creee = creees.get(chemin, modifiee)
        try:
-            nouveau = datetime.fromisoformat(creation) >= limite
+            nouveau = datetime.fromisoformat(creee) >= seuil
        except ValueError:
            nouveau = False
-        articles.append({
+        pages.append({
-            "titre": page["titre"],
+            "titre":    page["titre"],
-            "url": page["url"],
+            "url":      page["url"],
-            "date": date,
+            "date":     creee if nouveau else modifiee,
-            "nouveau": nouveau,
+            "nouveau":  nouveau,
            "rubrique": _rubriques.get(src_uri, ""),
        })
-    if not articles:
+    if not pages:
        log.info("derniers-articles : aucune page datée, fichier non écrit")
        return
-    articles.sort(key=lambda a: a["date"], reverse=True)
+    pages.sort(key=lambda page: page["date"], reverse=True)
-    articles = articles[:NB_MAX]
+
    genere = datetime.now(timezone.utc).replace(microsecond=0).isoformat()
    # L'accueil lit ce fichier depuis longtemps : il garde ses quatre clés, sans la
    # rubrique dont il n'a que faire.
    recents = [
        {clef: page[clef] for clef in ("titre", "url", "date", "nouveau")}
        for page in pages[:NB_MAX]
    ]
    ecrits = {
        FICHIER_RECENTS: {"genere": genere, "articles": recents},
        FICHIER_TOUTES:  {"genere": genere, "pages": pages},
    }
    try:
-        (site_dir / FICHIER).write_text(
+        for nom, contenu in ecrits.items():
-            json.dumps(
+            texte = json.dumps(contenu, ensure_ascii=False, indent=2) + "\n"
-                {"genere": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+            (site_dir / nom).write_text(texte, encoding="utf-8")
-                 "articles": articles},
+        _autoriser_la_lecture_croisee(site_dir, list(ecrits))
                ensure_ascii=False, indent=2,
            ) + "\n",
            encoding="utf-8",
        )
        # La page d'accueil est sur un autre sous-domaine : sans cet en-tête, le
        # navigateur refuse de lui laisser lire le fichier.
        (site_dir / ".htaccess").write_text(
            "<IfModule mod_headers.c>\n"
            f'  <Files "{FICHIER}">\n'
            '    Header set Access-Control-Allow-Origin "*"\n'
            "  </Files>\n"
            "</IfModule>\n",
            encoding="utf-8",
        )
    except OSError as erreur:
-        log.info("derniers-articles : écriture impossible (%s), fichier non écrit", erreur)
+        log.info("derniers-articles : écriture impossible (%s), fichier non écrit",
                 erreur)
        return
-    log.info("derniers-articles : %d article(s) publié(s) dans %s", len(articles), FICHIER)
+    log.info("derniers-articles : %d page(s) publiée(s) dans %s, %d dans %s",
             len(pages), FICHIER_TOUTES, len(recents), FICHIER_RECENTS)
--- a/mkdocs.yml
+++ b/mkdocs.yml
@ -29,9 +29,6 @@ theme:
  icon:
    repo: fontawesome/brands/git-alt
 hooks:
  - hooks/derniers_articles.py
 extra_css:
  - stylesheets/alpinux.css
@ -69,6 +66,10 @@ extra:
 copyright: "© Alpinux — LUG de Savoie | <a href='https://portail.alpinux.org'>Portail</a>"
 hooks:
  # Écrit derniers-articles.json, que lit la page d'accueil d'alpinux.org.
  - hooks/derniers_articles.py
 nav:
  - Accueil: index.md
  - Contribuer:
@ -81,8 +82,19 @@ nav:
    - alpinux/index.md
    - FAQ: alpinux/faq.md
    - Install Party: alpinux/install-party.md
    - Le site des install parties:
      - alpinux/installparty-mode-emploi.md
      - Je viens faire installer Linux: alpinux/installparty-participant.md
      - J'aide comme bénévole: alpinux/installparty-benevole.md
      - J'organise une install party: alpinux/installparty-organisateur.md
    - Présentations passées: alpinux/presentations.md
    - Événements & RDV: alpinux/evenements.md
    - Messagerie et listes:
      - alpinux/messagerie.md
      - S'abonner et se désabonner: alpinux/messagerie-abonnement.md
      - Écrire et recevoir des messages: alpinux/messagerie-membre.md
      - Gérer une liste de diffusion: alpinux/messagerie-gestionnaire.md
    - Vos données, vos adresses, nos envois: alpinux/donnees-personnelles.md
  - Présentations:
    - presentations/libreoffice.md
    - presentations/kicad.md
@ -107,6 +119,9 @@ nav:
    - technique/matrix.md
    - technique/arduino-ide.md
    - technique/serveur-debian-13.md
    - technique/serveur-install-party.md
    - technique/bigbluebutton.md
    - technique/ateliers.md
-  - Communication: communication/index.md
+  - Communication:
    - communication/index.md
    - Liens et codes QR: communication/liens-et-codes-qr.md