Déploiement : dossiers objects/00 à ff créés sur le VPS avec le bit setgid

tests/GameLauncher.Tests/Publishing/PublishingTests.cs : nouveau test sur les droits des dossiers objects/ et objects/xx.
tests/GameLauncher.Tests/Admin/PublishPanelTests.cs : test du bandeau rendu stable (le refus 429 tombe sur un petit envoi).
tests/GameLauncher.Tests/Server/ChangelogModuleTests.cs : le faux dossier du jeu ne redemande pas le setgid s’il l’a déjà.

GameLauncher.sln

@@ -40,8 +40,12 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "deploy", "deploy", "{1F9FBD
 	ProjectSection(SolutionItems) = preProject
 		server\deploy\LISEZMOI.md = server\deploy\LISEZMOI.md
 		server\deploy\installer-api.sh = server\deploy\installer-api.sh
+		server\deploy\launcher-api-catalog.conf = server\deploy\launcher-api-catalog.conf
+		server\deploy\launcher-api-games.conf = server\deploy\launcher-api-games.conf
 		server\deploy\launcher-api.service = server\deploy\launcher-api.service
 		server\deploy\nginx-api.conf = server\deploy\nginx-api.conf
+		server\deploy\nginx-catalog.conf = server\deploy\nginx-catalog.conf
+		server\deploy\nginx-publications.conf = server\deploy\nginx-publications.conf
 	EndProjectSection
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{266A4FF5-5752-46BA-803C-09E351720DB2}"
@@ -56,6 +60,10 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AdminKeyTool", "tools\Admin
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GameLauncher.Tests", "tests\GameLauncher.Tests\GameLauncher.Tests.csproj", "{DBAE3BFF-DAA8-4BB0-BDA3-3F31AC5C542F}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GameLauncher.Modules", "src\GameLauncher.Modules\GameLauncher.Modules.csproj", "{9EBFA383-7928-46F6-8958-F4B38287E380}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GameLauncher.Modules.Admin", "src\GameLauncher.Modules.Admin\GameLauncher.Modules.Admin.csproj", "{E4FD522A-F44B-4401-9A18-542D42136E6B}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -136,6 +144,22 @@ Global
 		{DBAE3BFF-DAA8-4BB0-BDA3-3F31AC5C542F}.Release|Any CPU.Build.0 = Release|Any CPU
 		{DBAE3BFF-DAA8-4BB0-BDA3-3F31AC5C542F}.Release|x64.ActiveCfg = Release|x64
 		{DBAE3BFF-DAA8-4BB0-BDA3-3F31AC5C542F}.Release|x64.Build.0 = Release|x64
+		{9EBFA383-7928-46F6-8958-F4B38287E380}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9EBFA383-7928-46F6-8958-F4B38287E380}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9EBFA383-7928-46F6-8958-F4B38287E380}.Debug|x64.ActiveCfg = Debug|x64
+		{9EBFA383-7928-46F6-8958-F4B38287E380}.Debug|x64.Build.0 = Debug|x64
+		{9EBFA383-7928-46F6-8958-F4B38287E380}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9EBFA383-7928-46F6-8958-F4B38287E380}.Release|Any CPU.Build.0 = Release|Any CPU
+		{9EBFA383-7928-46F6-8958-F4B38287E380}.Release|x64.ActiveCfg = Release|x64
+		{9EBFA383-7928-46F6-8958-F4B38287E380}.Release|x64.Build.0 = Release|x64
+		{E4FD522A-F44B-4401-9A18-542D42136E6B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E4FD522A-F44B-4401-9A18-542D42136E6B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E4FD522A-F44B-4401-9A18-542D42136E6B}.Debug|x64.ActiveCfg = Debug|x64
+		{E4FD522A-F44B-4401-9A18-542D42136E6B}.Debug|x64.Build.0 = Debug|x64
+		{E4FD522A-F44B-4401-9A18-542D42136E6B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E4FD522A-F44B-4401-9A18-542D42136E6B}.Release|Any CPU.Build.0 = Release|Any CPU
+		{E4FD522A-F44B-4401-9A18-542D42136E6B}.Release|x64.ActiveCfg = Release|x64
+		{E4FD522A-F44B-4401-9A18-542D42136E6B}.Release|x64.Build.0 = Release|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -151,6 +175,8 @@ Global
 		{CC6B01D4-258E-4552-BBB4-1D3CA8E2BE55} = {6EFB114A-05DF-49C9-B0EF-26BDF7EFE881}
 		{DBAE3BFF-DAA8-4BB0-BDA3-3F31AC5C542F} = {266A4FF5-5752-46BA-803C-09E351720DB2}
 		{1F9FBD8B-7A86-4F7B-A2ED-E18F5B014CDF} = {E23AAB8F-1D5C-41C9-AFA3-4246B035CD4C}
+		{9EBFA383-7928-46F6-8958-F4B38287E380} = {A93779E6-3B93-42B8-B256-5FBC273E7C28}
+		{E4FD522A-F44B-4401-9A18-542D42136E6B} = {A93779E6-3B93-42B8-B256-5FBC273E7C28}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {E2F3A4B5-C6D7-4E8F-9A0B-1C2D3E4F5A6B}

README.md

@@ -32,11 +32,13 @@ Vous obtenez un `GameLauncher.exe` autonome (aucun runtime à installer) + `laun
 | Projet | Rôle |
 |---|---|
 | `src/GameLauncher` | Application WPF (fenêtres, thème, ViewModels, registre, raccourci) |
-| `src/GameLauncher.Core` | Logique pure, sans WPF : manifest, téléchargement, installation, mise à jour, vérification, désinstallation |
+| `src/GameLauncher.Core` | Logique pure, sans WPF : manifest, téléchargement, installation, mise à jour, vérification, désinstallation, catalogue des jeux (`Catalog/`) |
 | `tools/ManifestBuilder` | Outil console de publication : génère `manifest.json`, l'archive ZIP et le dossier `objects/` |
 | `tools/LauncherPublisher` | Outil console de publication **du launcher** : clés de signature, `launcher-update.json` signé (voir §7) |
-| `src/GameLauncher.Contracts` | Protocole partagé launcher ⇄ Launcher API : routes, échanges, rôles, messages signés (voir §8) |
+| `src/GameLauncher.Contracts` | Protocole partagé launcher ⇄ Launcher API : routes, échanges, rôles, messages signés, catalogue, notes de version (modèle et limites), contrôle des manifests publiés (voir §8) |
 | `src/GameLauncher.ApiClient` | Client de la Launcher API : connexion par clé, requêtes signées, fichier de clé chiffré |
+| `src/GameLauncher.Modules` | Socle des modules du launcher (sans WPF) : contrat d'un module, pages du menu d'administration, MVVM commun |
+| `src/GameLauncher.Modules.Admin` | Module « Administration » : clés, connexion, invitation, verrouillage, tableau de bord ; modules « Catalogue des jeux » (`Catalog/`, page « Jeux »), « Notes de version » (`Changelog/`) et « Publication » (`Publishing/`) (vues dans `src\GameLauncher\Views\Admin` et `Themes\Admin.xaml`) |
 | `server/GameLauncher.Server` | **Launcher API** (ASP.NET Core) : serveur d'administration, déployé sur le VPS (voir §8) |
 | `tools/AdminKeyTool` | Clé d'administrateur et gestion des administrateurs en ligne de commande (`tools\admin-key.bat`) |
 | `tests/GameLauncher.Tests` | Tests automatisés (xUnit) : Test › Explorateur de tests › Exécuter tout |
@@ -47,14 +49,17 @@ src/GameLauncher/
 ├─ launcher.json            Configuration éditeur : un jeu, ou plusieurs (voir launcher.multi-jeux.example.json)
 ├─ Assets/                  background.png (thème par défaut), Themes/exovival-background.jpg, launcher.ico
 ├─ Themes/                  Default.xaml et Exovival.xaml (thèmes), Icons.xaml (icônes), Controls.xaml (styles),
-│                           Changelog.xaml (modèles des notes de version)
+│                           Changelog.xaml (modèles des notes de version), Admin.xaml (menu d'administration,
+│                           dont les pages « Jeux », « Notes de version » et « Publier une version »)
 ├─ Views/                   MainWindow (+ liste des jeux), InstallDialog, SettingsWindow, ChangelogWindow, ModernDialog, TrayMenuWindow
+│  └─ Admin/                AdminWindow, LoginView, EnrollView (menu d'administration ; ViewModels dans GameLauncher.Modules.Admin)
 ├─ ViewModels/              LauncherViewModel (jeux, thème actif, paramètres du launcher),
 │                           GameViewModel (machine à états d'un jeu),
 │                           LauncherSettingsViewModel / GameSettingsViewModel (les deux fenêtres de paramètres)
 ├─ Services/                ThemeManager, RegistryService, ShortcutService, InstanceChannel (raccourci → launcher
-│                           déjà ouvert), GameScopedServices, interfaces
-└─ Platform/                DialogService, WindowService (implémentations WPF), TrayIcon (zone de notification)
+│                           déjà ouvert), GameScopedServices, AdminWindowService (menu d'administration), interfaces
+└─ Platform/                DialogService, WindowService (implémentations WPF), TrayIcon (zone de notification),
+                            ModuleDialogs, WpfUiDispatcher (services offerts aux modules)
 ```
 
 ## 3. Publier une version du jeu (ManifestBuilder)
@@ -67,12 +72,25 @@ dotnet run --project tools\ManifestBuilder -c Release -- ^
     --exe     MonJeu.exe           ^
     --game-id MonJeu               ^
     --notes   notes.txt            ^
+    --remote-manifest https://launcher.example/monjeu/manifest.json ^
     --exclude "*.pdb;*.log"
 ```
 
 L'historique des notes est conservé d'une version à l'autre (30 versions) et affiché dans le
 launcher (panneau « Notes de version », bouton **Agrandir** pour les lire en grand).
 
+`--remote-manifest` (recommandé, déjà dans `tools\publish-example.bat`) : l'historique est repris du
+manifest **en ligne**, et non du `manifest.json` local. Les notes corrigées depuis le menu
+d'administration (page « Notes de version », §8) ne sont donc pas écrasées à la publication
+suivante. Pas de manifest en ligne (première publication) : historique local. Serveur injoignable :
+la publication s'arrête (rien n'est perdu ; réessayez, ou retirez l'option). Envoyez ensuite les
+fichiers sans attendre. Republier une version sans `--notes` garde ses notes existantes.
+
+**Mise en ligne** : depuis le menu d'administration, page **Publier une version** (§8) : choisissez le
+`manifest.json` du dossier `--output`, puis « Publier ». Seuls les fichiers absents du serveur sont
+envoyés, l'envoi reprend après une coupure, et le manifest est mis en ligne en dernier. WinSCP reste
+possible (objects/ et l'archive d'abord, `manifest.json` en dernier), mais pas les deux en même temps.
+
 ### Format de `notes.txt`
 
 Texte simple, à écrire comme une note de mise à jour (exemple complet : `tools/notes.txt`) :
@@ -328,7 +346,7 @@ fait au démarrage suivant. Les entrées *Applications installées* (`Uninstall\
 | Vignette d'un jeu (liste des jeux) | `launcher.json` → `"icon"` (image carrée) ; sinon fond du thème + initiales |
 | Icône | Remplacez `Assets/launcher.ico` |
 | Icônes de l'interface | `Themes/Icons.xaml` (tracés 24×24, compatibles [Material Design Icons](https://pictogrammers.com/library/mdi/)) |
-| Textes | `launcher.json` (nom, accroche), `ViewModels/GameViewModel.cs` |
+| Textes | `launcher.json` (nom, accroche), `ViewModels/GameViewModel.cs` ; sans recompiler : menu d'administration › **Jeux** (§8) |
 | Fréquence des recherches de mises à jour | `launcher.json` → `updateCheckIntervalMinutes` |
 | Dossier des données du jeu Unity (« Société\Produit ») | `launcher.json` → `gameDataFolder` |
 
@@ -371,7 +389,7 @@ liste des jeux apparaît alors à gauche de la fenêtre (masquée s'il n'y a qu'
 |---|---|
 | `--game <GameId>` | Ouvre le launcher sur ce jeu, vérifie les mises à jour puis lance le jeu s'il est prêt ; si le launcher est déjà ouvert, lui demande de lancer ce jeu (voir « Raccourcis du Bureau ») |
 | `--uninstall [GameId]` | Désinstallation (utilisée par Windows) |
-| `--config <fichier>` | Utilise un autre `launcher.json` (tests) |
+| `--config <fichier>` | Utilise un autre `launcher.json` (tests). En Release, ses `apiUrl` et `catalogUrl` sont ignorées (seules celles intégrées à l'exe comptent) |
 | `--capture <dossier>` | Enregistre une capture PNG par jeu (+ ses paramètres, + paramètres du launcher), sans rien installer, puis quitte |
 | `--updated <pid> <événement> <version>` | Interne : démarrage de la nouvelle version après une mise à jour du launcher (§7). Le jeu de `--game` n'est alors lancé que si `--launch` est aussi présent (mise à jour faite au démarrage depuis un raccourci), jamais après une mise à jour demandée depuis les paramètres |
 
@@ -467,9 +485,63 @@ launcher distribué : c'est l'identifiant de produit vérifié lors des mises à
 ## 8. Administration (Launcher API)
 
 Chantier en cours, découpé en phases : architecture, sécurité et planning dans
-**`docs/ADMIN-ARCHITECTURE.md`**. Phase 1 livrée : le serveur d'administration et ses outils ;
-le menu d'administration du launcher arrive en phase 2 (rien ne change pour les joueurs d'ici là).
+**`docs/ADMIN-ARCHITECTURE.md`**. Phase 1 livrée : le serveur d'administration et ses outils.
+Phase 2 livrée : le **menu d'administration** du launcher (connexion, invitation, tableau de bord).
+Phase 3 livrée : la page **Jeux** (catalogue des jeux, voir plus bas). Phase 4 livrée : la page
+**Notes de version**. Phase 5 livrée : la page **Publier une version**. Les pages « Administrateurs »
+et « Journal d'audit » arrivent à la phase 6.
 
+* **Ouvrir le menu** : `Ctrl+Maj+Alt+A` dans la fenêtre du launcher, ou **5 clics rapides** (en
+  moins de 3 s) sur le logo en haut à gauche. Accès discret, pas secret : seule la connexion par clé,
+  vérifiée par le serveur, protège l'administration.
+* **Adresse du serveur** : `"apiUrl"` dans `src\GameLauncher\launcher.json` (racine du fichier,
+  https). En Release, seule la valeur **intégrée à l'exe** est utilisée ; en Debug, celle du
+  `launcher.json` utilisé (ex. `--config` avec `http://127.0.0.1:5080/api/` pour un serveur local).
+  Sans `apiUrl`, le menu indique qu'il n'est relié à aucun serveur.
+* **Se connecter** : choisir sa clé (dossier `%USERPROFILE%\.launcher-keys`, ou « Choisir un autre
+  fichier de clé… »), saisir sa phrase de passe. Verrouillage automatique après 10 min sans activité,
+  quand Windows est verrouillé, ou avec `Ctrl+L` ; fermer la fenêtre efface la clé de la mémoire.
+* **« J'ai une invitation »** : crée la clé sur ce PC et l'enregistre avec le code reçu, puis
+  affiche l'**empreinte** à dicter à la personne qui approuve. Sans code : clé seule (premier
+  propriétaire, à déclarer sur le VPS). Deux rangements au choix :
+  * **fichier chiffré** (phrase de passe, 12 caractères min.) : copiable et sauvegardable ;
+  * **puce de sécurité (TPM 2.0) de ce PC** (code PIN, 6 caractères min.) : la clé est créée dans la
+    puce et ne peut pas être copiée. Proposé seulement après vérification réelle de la puce. Elle
+    disparaît avec la puce (carte mère, réinitialisation, Windows réinstallé) : gardez aussi une
+    clé fichier de secours. Sur le disque : `admin.tpmkey` (référence, sans secret) et `admin.pub`.
+    Écran de connexion : « Supprimer cette clé de la puce » (puis révoquer la clé sur le serveur) ;
+    après trop de codes PIN faux, un décompte indique quand la puce acceptera de nouveau un code.
+
+* **Page « Jeux »** (permission `games.edit`) : nom affiché, accroche, description, liens (Discord,
+  YouTube…), site, thème intégré, icône et fond, fréquence des recherches de mise à jour, jeu masqué,
+  nom du launcher, jeu affiché au premier lancement, ordre des jeux. Champ vide = valeur de
+  `launcher.json`. « Publier » contrôle les valeurs puis écrit `catalog.json` sur le serveur (requête
+  signée) ; si quelqu'un a publié entre-temps, rien n'est écrasé et la page propose de recharger.
+  Les jeux eux-mêmes (identifiant, manifest, exécutable, dossiers) restent dans `launcher.json` ;
+  le nom affiché ne change ni le raccourci, ni le registre, ni les dossiers.
+* **Page « Notes de version »** (permission `changelog.edit`) : corrige les notes des versions **déjà
+  publiées** dans le `manifest.json` du serveur. Liste des versions, en-tête (titre, sous-titre,
+  introduction), sections › éléments (modification ou commentaire, étiquette, sous-points, note),
+  boutons ↑ ↓ pour l'ordre, **Aperçu** avec la présentation exacte du launcher. Mêmes limites que le
+  launcher, vérifiées avant l'envoi. « Enregistrer » ne change que les notes (fichiers, archive,
+  version et exécutable restent identiques) ; si le manifest a changé entre-temps (nouvelle version
+  publiée), rien n'est écrasé et la page propose de recharger. Une nouvelle version et ses notes se
+  publient toujours avec ManifestBuilder (§3, `--remote-manifest`). Installation sur le VPS :
+  `server/deploy/LISEZMOI.md`, étape 3 ter.
+* **Page « Publier une version »** (permission `releases.publish` : propriétaires et administrateurs) :
+  choix du `manifest.json` produit par le .bat (ManifestBuilder), contrôle du dossier (mêmes règles
+  que le serveur : chemins sûrs, archive et fichiers présents), version en ligne rappelée (avertissement
+  si même numéro ou version inférieure), puis envoi : manifest, fichiers **absents du serveur**
+  seulement (petits fichiers par lots, gros par morceaux), archive par morceaux de 4 Mo, chaque fichier
+  vérifié (SHA-256) des deux côtés, et mise en ligne avec le manifest **en dernier** (historique des
+  notes du serveur conservé). « Interrompre » garde ce qui a été envoyé : « Publier » reprend. Pas de
+  verrouillage pour inactivité pendant l'envoi. Installation sur le VPS : `server/deploy/LISEZMOI.md`,
+  étape 3 quater.
+* **Catalogue côté joueur** : `"catalogUrl"` dans `launcher.json` (racine, https ; en Release, seule
+  la valeur intégrée à l'exe compte). Lu au démarrage sans le retarder (2,5 s au plus, sinon appliqué
+  au démarrage suivant), mis en cache (fonctionne hors ligne), toute valeur invalide ignorée. Images :
+  PNG/JPEG du même serveur, déposées dans `catalog/images/` (nouveau nom à chaque changement).
+  Installation sur le VPS : `server/deploy/LISEZMOI.md`, étape 3 bis.
 * **Principe** : le launcher étant public, la sécurité est assurée par le **serveur**. Chaque
   administrateur possède une **clé privée** (sur son PC, chiffrée) ; le serveur ne connaît que les
   clés publiques. Connexion par défi signé, sessions courtes, et **toute modification signée** par
@@ -484,5 +556,5 @@ le menu d'administration du launcher arrive en phase 2 (rien ne change pour les
 |---|---|
 | Installer le serveur sur le VPS, créer le premier propriétaire, récupération | `server/deploy/LISEZMOI.md` |
 | Publier le serveur | `tools\publish-server.bat` (Linux x64 autonome + empreinte SHA-256) |
-| Créer sa clé, tester la connexion, inviter/approuver | `tools\admin-key.bat` (`help` pour la liste) |
+| Créer sa clé, tester la connexion, inviter/approuver | `tools\admin-key.bat` (`help` pour la liste) ; créer sa clé et se connecter : aussi depuis le launcher |
 | Lancer le serveur en local (F5) | Projet `GameLauncher.Server`, profil *Development* : `http://127.0.0.1:5080/api/` |

docs/ADMIN-ARCHITECTURE.md

@@ -51,9 +51,9 @@ Conséquences :
 ┌──────────────────────────────┐   HTTPS   ┌─────────────────────────────────────────────┐
 │ GameLauncher.exe             │──────────►│ nginx (TLS, limites, fichiers statiques)     │
 │  ├─ Module « Administration »│           │  ├─ /exovivalzombie/…  manifest, zip, objects│
-│  │   clé privée (Windows     │           │  ├─ /launcher/…        mise à jour launcher  │
-│  │   Hello/TPM ou fichier    │           │  ├─ /catalog/…         infos des jeux (ph. 3)│
-│  │   chiffré)                │           │  └─ /api/ ──► Launcher API (127.0.0.1:5080)  │
+│  │   clé privée : fichier    │           │  ├─ /launcher/…        mise à jour launcher  │
+│  │   chiffré, ou puce TPM    │           │  ├─ /catalog/…         infos des jeux (ph. 3)│
+│  │   du PC (non exportable)  │           │  └─ /api/ ──► Launcher API (127.0.0.1:5080)  │
 │  └─ GameLauncher.ApiClient   │           │       ASP.NET Core, service systemd durci    │
 └──────────────────────────────┘           │       données : /var/lib/launcher-api (700)  │
                                            └─────────────────────────────────────────────┘
@@ -64,9 +64,11 @@ Conséquences :
 
 | Projet | Cible | Rôle |
 |---|---|---|
-| `src/GameLauncher` | net8.0-windows (WPF) | Application ; hôte des modules ; module Administration (phase 2) |
-| `src/GameLauncher.Core` | net8.0 | Logique du jeu (inchangée) : manifest, téléchargement, installation… |
-| `src/GameLauncher.Contracts` | net8.0 | **Nouveau.** Protocole partagé launcher ⇄ serveur : routes, DTO, rôles et permissions, messages signés, contrôle des clés publiques |
+| `src/GameLauncher` | net8.0-windows (WPF) | Application ; hôte des modules ; **affichage** des modules (vues WPF du menu d'administration : `Views/Admin`, `Themes/Admin.xaml`) |
+| `src/GameLauncher.Modules` | net8.0 | **Nouveau (phase 2).** Socle des modules, sans WPF : `ILauncherModule`, registre, pages d'administration, boîtes de dialogue abstraites, MVVM commun |
+| `src/GameLauncher.Modules.Admin` | net8.0 | **Nouveau (phase 2).** Module « Administration » : services (clés, connexion, invitation, verrouillage) et ViewModels, testés sans interface |
+| `src/GameLauncher.Core` | net8.0 | Logique du jeu : manifest, téléchargement, installation… ; **phase 3** : lecture, cache et application du catalogue (`Catalog/`) |
+| `src/GameLauncher.Contracts` | net8.0 | **Nouveau.** Protocole partagé launcher ⇄ serveur : routes, DTO, rôles et permissions, messages signés, contrôle des clés publiques ; catalogue (phase 3) ; modèle et bornes des notes de version (phase 4) |
 | `src/GameLauncher.ApiClient` | net8.0 | **Nouveau.** Client HTTP de l'API (connexion par défi signé, requêtes signées), fichier de clé chiffré |
 | `server/GameLauncher.Server` | net8.0 (ASP.NET Core) | **Nouveau.** Launcher API : modules serveur, authentification, administrateurs, audit, outil en ligne de commande |
 | `tools/AdminKeyTool` | net8.0 | **Nouveau.** Crée une clé d'administrateur (fichier chiffré) et teste une connexion à l'API |
@@ -74,7 +76,9 @@ Conséquences :
 | `tests/GameLauncher.Tests` | net8.0 (xUnit) | **Nouveau.** Tests unitaires + tests de bout en bout (serveur démarré en mémoire) |
 
 Dépendances : `Contracts` ne dépend de rien ; `ApiClient` → `Contracts` ; `Server` → `Contracts`
-(+ `Core` à partir de la phase 3) ; `GameLauncher` → `Core`, `Contracts`, `ApiClient`.
+(uniquement : le serveur n'utilise pas `Core`) ; `Core` → `Contracts` (règles du catalogue, phase 3) ;
+`Modules` → `Core`, `ApiClient` ; `Modules.Admin` → `Modules` ; `GameLauncher` → `Core`, `Modules`,
+`Modules.Admin`.
 Aucun paquet NuGet n'est nécessaire en dehors du projet de tests (xUnit).
 
 ## 5. Modules
@@ -96,35 +100,44 @@ Modules livrés en phase 1 : `System` (infos, santé), `Auth` (défi, connexion,
 (`AdminPermissions`), protège ses routes avec `.RequirePermission(...)` et ses modifications avec
 `.RequireSignedRequest()`.
 
-### 5.2 Côté launcher (phase 2)
+### 5.2 Côté launcher (phase 2 ✅)
+
+La logique d'un module (services, ViewModels) est une bibliothèque **net8.0 sans WPF**, testée sans
+interface ; le launcher WPF n'en fournit que l'**affichage** (un `DataTemplate` par type de page).
 
 ```csharp
 public interface ILauncherModule
 {
-    string Id { get; }                       // "admin", "news", "friends"…
+    string Id { get; }                       // "admin", puis "news", "friends"…
+    string DisplayName { get; }
     void Register(IModuleRegistry registry);
 }
 
 public interface IModuleRegistry
 {
-    void AddResources(Uri resourceDictionary);              // modèles WPF du module (DataTemplate)
     void AddAdminPanel(AdminPanelDescriptor panel);         // page du menu d'administration
-    void AddPage(PageDescriptor page);                      // section de la fenêtre principale (futur)
-    void AddService<T>(T service) where T : class;          // services partagés
+    // Plus tard : AddPage (section de la fenêtre principale), services partagés…
 }
 
 public sealed record AdminPanelDescriptor(
-    string Id, string Title, string IconKey, string RequiredPermission, int Order,
-    Func<IAdminContext, AdminPanelViewModel> CreateViewModel);
+    string Id, string Title, string Description, string IconKey,
+    string? RequiredPermission,                              // null : toute personne connectée
+    int Order, Func<IAdminContext, AdminPanelViewModel> CreateViewModel);
 ```
 
-* Le **menu d'administration** est une fenêtre « coquille » : navigation à gauche (pages fournies
-  par les modules, **filtrées selon les permissions** renvoyées par le serveur), en-tête avec
-  l'administrateur connecté, durée de session restante et bouton « Verrouiller ».
-* `IAdminContext` donne à chaque page : la session (`AdminSession` : requêtes signées), les jeux
-  déclarés dans `launcher.json`, les boîtes de dialogue, le journal.
-* Les modules futurs ajoutent leurs pages joueurs (`AddPage`) **et** leurs pages d'administration
-  (`AddAdminPanel`) : ils s'intègrent au menu admin sans le modifier.
+* `ModuleCatalog` rassemble les modules (déclarés dans `App.CreateModules()`), vérifie l'unicité des
+  identifiants et le format des permissions, et donne les pages **autorisées par les permissions**
+  renvoyées par le serveur (le serveur reste seul juge : masquer une page n'est qu'un confort).
+* Le **menu d'administration** est une fenêtre « coquille » : à gauche l'administrateur connecté, les
+  pages des modules, le temps restant avant verrouillage et le bouton « Verrouiller » ; à droite la
+  page choisie.
+* `IAdminContext` donne à chaque page : la session (`AdminSession` : requêtes signées), le client de
+  l'API, les jeux déclarés dans `launcher.json`, les boîtes de dialogue (`IModuleDialogs`), la
+  navigation entre pages et le signalement d'une session perdue (retour à la connexion).
+  `AdminPanelViewModel.RunAsync` gère « occupé », les messages d'erreur et la session expirée.
+* Ajouter une page à un module futur : une classe `AdminPanelViewModel` + son descripteur dans le
+  module, et son `DataTemplate` dans `Themes/Admin.xaml` (ou un dictionnaire dédié fusionné dans
+  `App.xaml`). La fenêtre d'administration elle-même ne change pas.
 
 ## 6. Authentification par clé publique/privée
 
@@ -135,11 +148,39 @@ public sealed record AdminPanelDescriptor(
 * `keyId` = 16 premiers caractères hexadécimaux du SHA-256 de la clé publique (SPKI).
 * **Empreinte** affichée aux humains : 5 groupes de 4 caractères (`AB12 CD34 EF56 7890 1A2B`, 80 bits),
   calculée avec une séparation de domaine : elle ne se déduit pas du `keyId`, visible dans les listes.
-* Stockage de la clé privée sur le PC de l'administrateur (phase 2) :
-  * **Windows Hello / TPM** si disponible : clé non exportable, liée au PC, déverrouillée par le
-    code PIN Windows (un PC = une clé ; un administrateur peut enregistrer plusieurs PC) ;
-  * sinon **fichier chiffré** (PKCS#8, AES-256, PBKDF2-SHA256 600 000 itérations — comme la clé de
-    signature du launcher) déverrouillé par une phrase de passe de 12 caractères minimum.
+* Stockage de la clé privée sur le PC de l'administrateur :
+  * **fichier chiffré** (phase 2 ✅) : PKCS#8, AES-256, PBKDF2-SHA256 600 000 itérations — comme la
+    clé de signature du launcher — déverrouillé par une phrase de passe de 12 caractères minimum.
+    Dossier proposé : `%USERPROFILE%\.launcher-keys` (celui de `tools\admin-key.bat`). La clé de
+    signature du launcher (`launcher-signing*.key`), rangée dans le même dossier, n'est jamais
+    proposée ni acceptée. Une clé n'écrase jamais un fichier existant ;
+  * **puce de sécurité TPM 2.0** (phase 2b ✅, au choix lors de « J'ai une invitation ») : la clé
+    ECDSA P-256 est **générée dans la puce** par le fournisseur Windows « Microsoft Platform Crypto
+    Provider » et n'en sort jamais (non exportable) ; la puce signe elle-même. Clé de l'utilisateur
+    Windows courant, protégée par un **code PIN** (6 caractères minimum, saisi dans le launcher,
+    vérifié par la puce, qui se bloque temporairement après plusieurs codes faux). Sur le disque,
+    seul un fichier de référence `*.tpmkey` (nom de la clé dans la puce + clé publique, aucun
+    secret) et le `.pub` habituel. À la connexion, la clé publique de la puce est comparée à celle
+    de la référence. Le choix n'est **dégrisé qu'après une vérification réelle de la puce**
+    (création, signature et suppression d'une clé de test). Rien ne change côté serveur : même
+    format de clé publique P-256, mêmes signatures. Limites : la clé ne peut pas être sauvegardée
+    et disparaît avec la puce (carte mère, réinitialisation du TPM, Windows réinstallé) — garder
+    une clé « fichier » de secours ; le serveur ne peut pas prouver qu'une clé est dans une puce
+    (pas d'attestation) : c'est une protection pour l'administrateur, pas une règle du serveur ;
+    le blocage anti-essais est commun à toute la puce (les codes faux comptent aussi pour le code
+    PIN Windows Hello) ; avec un profil Windows itinérant, la clé n'est utilisable que sur le PC
+    qui l'a créée. Le fichier `.tpmkey` ne désigne que des clés nommées `GameLauncher.Admin.*`
+    du fournisseur de la puce, et sa clé publique est comparée à celle de la puce avant tout
+    essai du code PIN.
+    Écran de connexion : **« Supprimer cette clé de la puce »** (clés TPM uniquement, après
+    confirmation ; efface la clé de la puce, le `.tpmkey` et le `.pub` — à révoquer aussi sur le
+    serveur ; les clés fichier se suppriment à la main). Après un code faux, le nombre d'essais
+    restants est affiché ; si la puce est bloquée, un **décompte** indique quand elle acceptera de
+    nouveau un code (état lu dans la puce par TPM2_GetCapability via le service TBS : compteur,
+    maximum, intervalle de « guérison » ; estimation, PC allumé). Si cet état n'est pas lisible sur
+    le PC, une explication générale est affichée et un nouvel essai reste possible.
+  * Windows Hello (visage, empreinte) : écarté pour l'instant, son API ne crée que des clés RSA,
+    ce qui demanderait de faire évoluer le serveur.
 
 ### 6.2 Connexion (défi-réponse)
 
@@ -174,6 +215,17 @@ empêchent de réutiliser une signature auprès d'un autre serveur.
   d'inactivité, 8 h au maximum**, 5 sessions par administrateur.
 * À chaque requête : session valide **et** administrateur actif **et** clé active (une révocation
   prend effet immédiatement, y compris depuis l'outil en ligne de commande).
+* **Côté launcher** (phase 2) : la clé déchiffrée n'existe en mémoire que pendant la session. Le menu
+  se **verrouille** (session fermée, clé effacée, retour à la connexion) après **10 min sans activité**
+  dans la fenêtre, à la fin des 8 h, quand la **session Windows est verrouillée** (Win+L, veille),
+  sur `Ctrl+L` ou le bouton « Verrouiller », et si le serveur refuse la session (révocation). Tant
+  que l'administrateur est actif, la session est prolongée sur le serveur toutes les 4 min. Fermer
+  la fenêtre ou le launcher efface la clé, puis déconnecte la session. La phrase de passe n'est
+  jamais conservée (champ effacé dès la tentative de connexion).
+* L'adresse de l'API (`apiUrl`) n'est lue, dans la version Release, que dans le `launcher.json`
+  **intégré à l'exe** : un fichier posé à côté (ou `--config`) ne peut pas envoyer les
+  administrateurs vers un autre serveur. Une valeur invalide est ignorée (le launcher des joueurs
+  démarre toujours) et expliquée à l'ouverture du menu.
 
 ### 6.4 Requêtes signées
 
@@ -236,6 +288,8 @@ Les permissions sont des chaînes « module.action » : un module futur déclare
 4. Il communique son empreinte au propriétaire **par un autre moyen** (téléphone, message).
 5. Le propriétaire approuve en **saisissant cette empreinte** (le serveur ne l'affiche pas pour les
    clés en attente : l'approbation prouve la vérification). Clé et compte deviennent actifs.
+   (Phase 2 : étapes 3 et 4 dans le launcher ; création de l'invitation et approbation avec
+   `tools\admin-key.bat` jusqu'à la page « Administrateurs » de la phase 6.)
 
 **Ajouter un PC** à un compte existant (invitation « nouvel appareil ») : l'administrateur crée
 lui-même l'invitation, enrôle son nouveau PC, puis **approuve depuis un de ses PC déjà actifs**.
@@ -252,8 +306,9 @@ sudo -u deploy /opt/launcher-api/GameLauncher.Server add-owner --name "Nicolas"
 ## 9. Informations fixes et informations modifiables des jeux (phase 3)
 
 Les jeux sont **toujours déclarés dans `launcher.json`** : le serveur ne peut ni ajouter ni retirer
-un jeu, seulement modifier l'affichage des jeux déclarés. Les champs actuels de `launcher.json` se
-répartissent ainsi :
+un jeu, seulement modifier l'affichage des jeux déclarés. Comme `apiUrl`, la liste des jeux que le
+menu d'administration peut modifier est lue, en Release, dans le `launcher.json` intégré à l'exe.
+Les champs de `launcher.json` se répartissent ainsi :
 
 | Champ | Reste dans l'exe | Modifiable (serveur) | Raison |
 |---|:-:|:-:|---|
@@ -276,33 +331,150 @@ validé et borné comme les notes de version, puis **mis en cache** (`%AppData%\
 Sans réseau : dernier cache, sinon valeurs de `launcher.json`. Le serveur écrit `catalog.json`
 seulement via l'API (permission `games.edit`, requête signée).
 
-## 10. Notes de version (phase 4)
+### 9.1 Mise en œuvre (phase 3 ✅)
 
-* Éditeur graphique dans le menu admin : arborescence version › sections › éléments, édition des
-  champs du format enrichi, **aperçu en direct avec les mêmes modèles que le launcher**
-  (`Themes/Changelog.xaml`) et les mêmes bornes (`ChangelogLimits`).
+**Format** (`Contracts/Catalog`) : `{ "format": "gamelauncher-catalog", "version": 1, "revision", "updatedAt",
+"launcher": { "launcherName", "defaultGame", "gameOrder" }, "games": { "<gameId>": { "gameName", "tagline",
+"description", "websiteUrl", "links": [{ "kind", "label", "url" }], "theme", "icon", "background",
+"updateCheckIntervalMinutes", "hidden" } } }`. Un champ absent = valeur de `launcher.json`.
+`CatalogRules` (partagé) borne tout : 48 Ko (sous la limite de 64 Ko des requêtes de l'API), 50 jeux,
+noms 80 caractères, accroche 200, description 2000 caractères / 40 lignes, 8 liens, adresses https
+(500 caractères, sans identifiants), images `.png`/`.jpg` du **même hôte que le catalogue**, thème =
+identifiant (`[a-z0-9-]`, jamais un chemin), intervalle 0 ou 5 à 1440. Le serveur **refuse** une
+valeur invalide (400) ; le launcher l'**ignore** (valeur de `launcher.json`).
+
+**Serveur** (module `Catalog`, `Storage/CatalogStore`) :
+
+* `GET v1/catalog` (administrateur connecté) : catalogue publié, publication activée ou non, adresse publique.
+* `PUT v1/catalog` (`games.edit` + requête signée) : `{ baseRevision, catalog }`. Révision différente
+  de celle publiée → 409 `revision_conflict` (rien n'est écrasé) ; contrôle `CatalogRules` ; écriture
+  de la référence privée (`/var/lib/launcher-api/catalog.json` + `.bak`), puis du **fichier public**
+  (fichier temporaire du même dossier, droits 644 fixés explicitement malgré `UMask=0077`, renommage
+  atomique) ; en cas d'échec du fichier public, la référence privée est remise en état (503) ;
+  historique des 20 dernières versions ; audit `catalog.publish` (jeux modifiés).
+* Réglages `LauncherApi:Catalog:PublicFile` (vide = publication désactivée, 503 `not_configured`) et
+  `PublicUrl` (défaut : `PublicOrigin` + `/catalog/catalog.json`). Au démarrage : chemin absolu `.json`,
+  dossier existant, dossier public et données privées séparés (aucun dans l'autre, liens résolus).
+* VPS : dossier public (ex. `/srv/exovival/www/catalog`) autorisé en écriture par un complément
+  systemd (`ReadWritePaths`), `catalog.json` servi par nginx sans cache (`server/deploy/LISEZMOI.md`, étape 3 bis).
+
+**Launcher (joueur)** (`Core/Catalog`) :
+
+* `catalogUrl` lue, en Release, **uniquement** dans le `launcher.json` intégré (comme `apiUrl`).
+* Démarrage : le cache est appliqué immédiatement ; le catalogue à jour est téléchargé en parallèle
+  de la vérification de mise à jour du launcher et appliqué s'il arrive en 2,5 s (nouvelles images :
+  1,5 s de plus) ; sinon il est mis en cache pour le démarrage suivant.
+* Téléchargements bornés (48 Ko, images 4 Mo), redirections suivies **uniquement** vers le même
+  serveur (aucune requête vers un autre hôte), images contrôlées (signature PNG/JPEG), mises en cache
+  sous l'empreinte de leur adresse (changer d'image = nouveau nom de fichier), fonds réduits à
+  3840 px au chargement.
+* `CatalogMerger` : valeurs de `launcher.json` restaurées avant chaque application ; jeux inconnus
+  ignorés ; thèmes intégrés uniquement ; images du cache uniquement ; jeu masqué toujours affiché s'il
+  est installé ou demandé (raccourci) ; au moins un jeu affiché. Le nom du catalogue est un **nom
+  affiché** : registre, raccourci, dossier d'installation proposé et dossier de données gardent le
+  `gameName` de `launcher.json`.
+* Fiche du jeu : description et boutons de liens (icônes génériques : site, forum, vidéo…).
+
+**Menu d'administration** : module `CatalogAdminModule` (permission `games.edit`), page « Jeux » :
+liste « Launcher » + jeux (ordre ↑ ↓), champs vides = valeur de `launcher.json` (rappelée sous le
+champ), pastille « modifié », contrôle complet avant l'envoi (mêmes règles que le serveur), saisie
+suspendue pendant l'envoi, conflit de révision signalé avec rechargement proposé, bandeau si la
+publication n'est pas configurée.
+
+## 10. Notes de version (phase 4 ✅)
+
+* Éditeur graphique dans le menu admin (page « Notes de version », module `ChangelogAdminModule`,
+  permission `changelog.edit`) : liste des versions › en-tête (titre, sous-titre, introduction) ›
+  sections › éléments (modification ou commentaire, étiquette, sous-points, note), ordre ↑ ↓,
+  **aperçu en direct avec les mêmes modèles que le launcher** (`Themes/Changelog.xaml`) et les mêmes
+  bornes (`ChangelogLimits`). Une version à l'ancien format (liste à plat) est présentée en section(s)
+  sans titre et enregistrée au format enrichi.
 * On édite **les versions existantes** uniquement ; la création d'une version reste au `.bat`.
-* Enregistrement : le launcher envoie le `manifest.json` modifié avec l'empreinte de la version
-  qu'il a lue (concurrence optimiste) ; le serveur vérifie que **seules les notes ont changé**
-  (fichiers, archive, version, exécutable identiques), valide, sauvegarde l'ancien manifest puis
-  remplace atomiquement.
-* **Cohérence avec ManifestBuilder** : aujourd'hui il reprend l'historique des notes depuis le
-  `manifest.json` *local*, ce qui écraserait les corrections faites en ligne. ManifestBuilder
-  recevra une option `--remote-manifest <url>` (ajoutée au `.bat`) : l'historique est repris du
-  serveur, seule la nouvelle version vient de `notes.txt`.
+* **Modèle partagé** : `ChangelogEntry`/`ChangelogSection`/`ChangelogItem` et `ChangelogLimits` sont
+  dans `Contracts` (`GameLauncher.Contracts.Changelog`), utilisés par le launcher, ManifestBuilder, le
+  menu d'administration et le serveur (qui ne référence pas `Core`). `ChangelogLimits.Check` signale
+  les dépassements sans rien tronquer ; `Normalize` tronque (texte + « … » dans la longueur maximale).
+* **API** :
+  * `GET v1/games/{gameId}/changelog` (administrateur connecté) : notes du manifest publié (liste à
+    plat omise quand les sections existent) et **empreinte SHA-256** du manifest lu ;
+  * `PUT v1/games/{gameId}/changelog/{version}` (`changelog.edit` + requête signée) : notes d'**une**
+    version (60 Ko au plus, sous la limite de 64 Ko des requêtes) + empreinte de base. Identifiant et
+    version : caractères sûrs uniquement (jamais utilisés dans un chemin).
+* **Serveur** (`Storage/ChangelogStore`) : manifest configuré par jeu (`LauncherApi:Games:<id>:ManifestFile`,
+  chemin absolu, dossier existant, séparé des données privées ; `gameId` du manifest vérifié).
+  Sous verrou : empreinte comparée (409 `revision_conflict` si le manifest a changé : nouvelle version
+  publiée, autre administrateur), contrôle des bornes (400), entrée de la version remplacée dans
+  l'arbre JSON (numéro, date et champs inconnus conservés, quelle que soit la casse ; liste à plat
+  régénérée pour les anciens launchers), budget de tout l'historique vérifié, copie de l'ancien
+  manifest dans les données privées (20 dernières), écriture d'un fichier temporaire caché du même
+  dossier avec les droits du manifest existant, **empreinte revérifiée juste avant** le renommage
+  atomique. Refus (503) si le manifest est un lien symbolique, ou si le dossier n'a pas le bit setgid
+  alors que nginx lit le manifest par son groupe. Audit `changelog.edit`.
+* **Droits sur le VPS** : le service doit pouvoir écrire dans le dossier du jeu (complément systemd
+  `ReadWritePaths`, `server/deploy/LISEZMOI.md` étape 3 ter). C'est un compromis : un service compromis
+  pourrait alors modifier les fichiers du jeu servis aux joueurs (le manifest n'est pas encore signé,
+  voir phase 7). L'autorisation est limitée au seul dossier du jeu ; sans `LauncherApi:Games`, rien
+  n'est modifiable et le dossier reste en lecture seule pour le service.
+* **Cohérence avec ManifestBuilder** : option `--remote-manifest <url>` (ajoutée à
+  `tools\publish-example.bat`) : l'historique est repris du manifest **en ligne**, seule la nouvelle
+  version vient de `notes.txt`. 404 = première publication (historique local) ; toute autre erreur
+  arrête la publication. Republier une version sans `--notes` garde ses notes existantes.
 
-## 11. Publication d'une version (phase 5)
+## 11. Publication d'une version (phase 5 ✅)
 
-Depuis le menu admin › « Publier une version » : choix du dossier produit par le `.bat`, contrôle
-local (manifest valide, archive et objets présents avec les bonnes empreintes), puis envoi :
+Depuis le menu admin › « Publier une version » (module `PublishAdminModule`, permission
+`releases.publish`) : choix du `manifest.json` produit par le `.bat`, contrôle local (manifest valide,
+archive et objets présents avec la bonne taille), puis envoi :
 
-1. `objects/` : seuls les objets **absents du serveur** (le serveur répond à une liste d'empreintes) ;
-2. l'archive ZIP, **par morceaux** (8 Mo, reprise possible, chaque morceau et le fichier final
-   vérifiés par SHA-256) ;
-3. `manifest.json` **en dernier**, remplacé atomiquement (même règle qu'avec WinSCP).
+1. le manifest (par morceaux), contrôlé par le serveur ; il répond par la liste des objets **absents**
+   de son dossier `objects/` ;
+2. ces objets seulement : petits fichiers **par lots** (une requête pour des centaines de fichiers),
+   gros fichiers par morceaux ;
+3. l'archive ZIP **par morceaux** de 4 Mo (reprise à la position reçue) ;
+4. la mise en ligne : `manifest.json` **en dernier**, remplacé atomiquement (même règle qu'avec WinSCP).
 
-Le serveur vérifie que chaque fichier référencé existe avec la bonne taille et la bonne empreinte
-avant d'accepter le manifest. L'historique des notes du serveur est conservé.
+**Contrôles communs** (`Contracts/Publishing/ManifestCheck`, launcher et serveur) : identifiant de jeu
+et version attendus ; archive = simple nom `.zip` à côté du manifest ; objets dans `objects/` uniquement ;
+chemins relatifs sûrs, sans doublon ; exécutable présent ; 10 000 fichiers, 128 Go d'archive au plus.
+
+**Envoi** (`Storage/PublicationStore`, module `Publishing`) : toutes les requêtes sont **signées** (y
+compris chaque morceau : la signature couvre l'empreinte du corps). Seules les routes d'envoi acceptent
+8 Mo (limite propre à la route, côté Kestrel et nginx) ; le reste de l'API garde 64 Ko. Dépôt dans un
+dossier **caché** du dossier du jeu (`.publish-<id>`, 0700, refusé par nginx) : la mise en ligne ne
+consiste qu'en renommages sur le même disque. Chaque morceau doit suivre exactement ce qui a été reçu
+(409 `offset_mismatch` sinon) ; l'empreinte SHA-256 est calculée au fil des morceaux (recalculée si le
+service a redémarré) et vérifiée avant d'accepter le fichier. Espace disque vérifié (507). Une
+publication par jeu ; celle d'un autre administrateur n'est remplaçable qu'après 30 min sans envoi ;
+abandon au bout de 48 h. Limite de requêtes : les routes d'envoi de morceaux ont leur propre limite
+(`Limits:PublicationUploadsPerMinute`, 1500/min par IP, politique `publication-upload`, à la place de la
+limite générale) ; côté nginx, zone `publication_par_ip` (25/s). Chaque refus 429 du serveur annonce
+son délai (`Retry-After`).
+
+**Mise en ligne** : tout est revérifié, puis contrôles **avant tout déplacement** (liens symboliques,
+droits, dossiers `objects/xx`) ; objets, archive (l'ancienne, de même nom, gardée de côté et remise en
+place si l'écriture du manifest échoue), puis manifest. Refus si les fichiers en ligne ont changé
+pendant l'envoi (empreinte du manifest **hors notes** : une correction de notes reste permise).
+Notes : celles de la version publiée, puis l'historique **du serveur** (corrections en ligne
+conservées), dans les bornes du launcher. Résultat gardé 24 h : une réponse perdue n'empêche pas de
+constater la mise en ligne. Audit : `release.start`, `release.publish`, `release.cancel`.
+Dossiers `objects/xx` manquants : créés **sans demander de bit spécial** (systemd refuse au service toute
+demande de setuid/setgid, `RestrictSUIDSGID=yes`) ; le groupe `www-data` vient du bit setgid de `objects/`,
+et les droits sont ceux du dossier du jeu, mais sans setgid (le fixer sous le masque du service le retire) :
+sans conséquence pour le launcher, qui y déplace des fichiers déjà du bon groupe, mais un fichier déposé
+avec WinSCP y prendrait le groupe `deploy`. D'où l'étape 3 quater : `objects/` et ses 256 sous-dossiers
+créés sur le VPS en `2750`.
+
+**Launcher** (`Modules.Admin/Publishing/ReleaseUploader`) : les empreintes des fichiers sont vérifiées
+pendant leur lecture (un fichier modifié depuis le `.bat` est refusé) ; coupures (réseau, délai,
+429, serveur occupé, position décalée) : l'état est relu sur le serveur et l'envoi continue, après une
+pause affichée sur la page (429 : délai `Retry-After` du serveur, sinon 1 s doublée à chaque refus,
+30 s au plus) ; « Interrompre »
+garde ce qui a été reçu, « Publier » reprend. La mise en ligne elle-même ne s'interrompt pas. Pendant
+l'envoi, `IAdminContext.BeginLongOperation()` évite le verrouillage pour inactivité (verrouillage manuel,
+de Windows et durée maximale de session toujours appliqués).
+
+**VPS** : bloc nginx `server/deploy/nginx-publications.conf`, écriture dans le dossier du jeu
+(`games.conf`, étape 3 ter), dossier `objects` existant avec le bit setgid (`LISEZMOI.md`, étape 3 quater).
 
 ## 12. Signature de bout en bout pour les joueurs (phase 7, recommandée)
 
@@ -324,15 +496,16 @@ Le format des requêtes signées de la phase 1 est déjà compatible avec ce mod
 |---|---|---|
 | **0** | Architecture (ce document) | ✅ |
 | **1** | Contrats partagés ; Launcher API (modules, authentification par clé, sessions, requêtes signées, invitations/enrôlement/approbation/révocation, audit, limites, CLI) ; client API ; outil `AdminKeyTool` ; tests ; fichiers de déploiement (systemd, nginx) | ✅ |
-| **2** | Launcher : hôte de modules, entrée cachée (Ctrl+Maj+Alt+A ou 5 clics sur le logo), fenêtre d'administration (navigation, session, verrouillage auto), stockage de clé (Windows Hello/TPM, fichier chiffré), connexion, « J'ai une invitation », tableau de bord | à faire |
-| **3** | Séparation fixe/modifiable : `catalog.json`, lecture + cache côté joueur, module serveur `Catalog`, page admin « Jeux » | à faire |
-| **4** | Éditeur de notes de version + module serveur `Changelog` + option `--remote-manifest` de ManifestBuilder | à faire |
-| **5** | Publication d'une version depuis le menu admin (envoi par morceaux, reprise, vérifications) | à faire |
+| **2** | Launcher : socle des modules (`GameLauncher.Modules`), module Administration (`GameLauncher.Modules.Admin`), entrée discrète (Ctrl+Maj+Alt+A ou 5 clics sur le logo), fenêtre d'administration (navigation, session, verrouillage auto), clé en fichier chiffré, connexion, « J'ai une invitation », tableau de bord | ✅ |
+| **2b** | Clé dans la puce TPM 2.0 (non exportable, code PIN vérifié par la puce), au choix en plus du fichier chiffré | ✅ |
+| **3** | Séparation fixe/modifiable : `catalog.json`, lecture + cache côté joueur, module serveur `Catalog`, page admin « Jeux » | ✅ |
+| **4** | Éditeur de notes de version + module serveur `Changelog` + option `--remote-manifest` de ManifestBuilder | ✅ |
+| **5** | Publication d'une version depuis le menu admin (envoi par morceaux, reprise, vérifications) | ✅ |
 | **6** | Pages admin « Administrateurs » (invitations, approbation par empreinte, rôles, révocation, appareils) et « Journal d'audit » | à faire |
 | **7** | Signature de bout en bout (trousseau signé par la clé racine, signatures détachées, vérification côté joueur) | recommandée |
 
-Chaque phase compile, est testée et laisse le launcher utilisable : tant que la phase 2 n'est pas
-livrée, rien ne change pour les joueurs.
+Chaque phase compile, est testée et laisse le launcher utilisable. Pour les joueurs, rien ne
+change : le menu d'administration est discret et ne contacte le serveur qu'une fois ouvert.
 
 ## 14. Choix écartés
 

server/GameLauncher.Server/Hosting/IApiModule.cs

@@ -25,7 +25,10 @@ public static class ApiModules
         new Modules.System.SystemModule(),
         new Modules.Auth.AuthModule(),
         new Modules.Admins.AdminsModule(),
-        new Modules.Audit.AuditModule()
+        new Modules.Audit.AuditModule(),
+        new Modules.Catalog.CatalogModule(),
+        new Modules.Changelog.ChangelogModule(),
+        new Modules.Publishing.PublishingModule()
     };
 }
 
@@ -34,4 +37,10 @@ public static class RateLimitPolicies
 {
     public const string Auth = "auth";
     public const string Enrollment = "enrollment";
+
+    /// <summary>
+    /// Morceaux envoyés pendant une publication (manifest, objets, archive) : limite propre, plus haute,
+    /// à la place de la limite générale (un envoi rapide en enchaîne plusieurs par seconde).
+    /// </summary>
+    public const string PublicationUpload = "publication-upload";
 }

server/GameLauncher.Server/Hosting/LauncherApiOptions.cs

@@ -39,6 +39,14 @@ public sealed class LauncherApiOptions
 
     public LimitSettings Limits { get; set; } = new();
 
+    public CatalogSettings Catalog { get; set; } = new();
+
+    /// <summary>
+    /// Jeux dont le manifest.json publié peut être modifié par l'API (notes de version, phase 4), par
+    /// identifiant de jeu (GameId de launcher.json). Absent : notes non modifiables en ligne.
+    /// </summary>
+    public Dictionary<string, GameSettings> Games { get; set; } = new();
+
     /// <summary>Durée de validité d'un défi de connexion.</summary>
     public int ChallengeLifetimeSeconds { get; set; } = 60;
 
@@ -53,6 +61,32 @@ public sealed class LauncherApiOptions
         public int MaxTotal { get; set; } = 500;
     }
 
+    /// <summary>Catalogue des jeux (informations modifiables), publié en fichier statique servi par nginx.</summary>
+    public sealed class CatalogSettings
+    {
+        /// <summary>
+        /// Fichier public écrit par le service (chemin absolu, ex. « /srv/exovival/www/catalog/catalog.json »).
+        /// Vide : publication désactivée (le catalogue reste consultable dans le menu d'administration).
+        /// Le dossier doit exister, appartenir au compte du service, et être autorisé en écriture par
+        /// systemd (ReadWritePaths, voir server/deploy/LISEZMOI.md).
+        /// </summary>
+        public string PublicFile { get; set; } = "";
+
+        /// <summary>Adresse publique du fichier (information). Vide : « PublicOrigin/catalog/catalog.json ».</summary>
+        public string PublicUrl { get; set; } = "";
+    }
+
+    /// <summary>Un jeu publié sur ce serveur.</summary>
+    public sealed class GameSettings
+    {
+        /// <summary>
+        /// manifest.json publié du jeu (chemin absolu dans le dossier servi par nginx, ex.
+        /// « /srv/exovival/www/exovivalzombie/manifest.json »). Son dossier doit être autorisé en écriture
+        /// par systemd (ReadWritePaths, voir server/deploy/LISEZMOI.md).
+        /// </summary>
+        public string ManifestFile { get; set; } = "";
+    }
+
     public sealed class LimitSettings
     {
         /// <summary>Requêtes par minute et par adresse IP, toutes routes confondues.</summary>
@@ -61,6 +95,13 @@ public sealed class LauncherApiOptions
         /// <summary>Défis et connexions par minute et par adresse IP.</summary>
         public int AuthPerMinute { get; set; } = 20;
 
+        /// <summary>
+        /// Morceaux envoyés pendant une publication, par minute et par adresse IP (à la place de
+        /// <see cref="RequestsPerMinute"/> pour ces routes). 1500 morceaux de 4 Mo ≈ 100 Mo/s. Ces requêtes
+        /// exigent une session et le droit de publier : le corps n'est lu qu'après ces contrôles.
+        /// </summary>
+        public int PublicationUploadsPerMinute { get; set; } = 1500;
+
         /// <summary>Enrôlements (codes d'invitation) par heure et par adresse IP.</summary>
         public int EnrollmentsPerHour { get; set; } = 10;
 
@@ -79,6 +120,22 @@ public sealed class LauncherApiOptions
 
     public IReadOnlyList<IPAddress> TrustedProxyAddresses { get; private set; } = Array.Empty<IPAddress>();
 
+    /// <summary>Fichier public du catalogue en chemin absolu (null : publication désactivée), calculé par <see cref="Validate"/>.</summary>
+    public string? CatalogPublicFileFullPath { get; private set; }
+
+    /// <summary>Adresse publique du catalogue, calculée par <see cref="Validate"/>.</summary>
+    public string CatalogPublicUrl { get; private set; } = "";
+
+    /// <summary>
+    /// Hôte de <see cref="CatalogPublicUrl"/> : seul hôte autorisé pour les images du catalogue (le
+    /// launcher n'accepte que des images du même hôte que le catalogue).
+    /// </summary>
+    public string CatalogImageHost { get; private set; } = "";
+
+    /// <summary>manifest.json de chaque jeu configuré (chemins absolus), calculé par <see cref="Validate"/>.</summary>
+    public IReadOnlyDictionary<string, string> GameManifestFiles { get; private set; } =
+        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+
     /// <summary>Vérifie les réglages au démarrage : un serveur mal configuré ne démarre pas.</summary>
     public void Validate(string contentRoot)
     {
@@ -105,17 +162,112 @@ public sealed class LauncherApiOptions
         }
         TrustedProxyAddresses = proxies;
 
+        ValidateCatalog();
+        ValidateGames();
+
         Require(Sessions.IdleMinutes is >= 1 and <= 240, "Sessions:IdleMinutes (1 à 240)");
         Require(Sessions.MaxHours is >= 1 and <= 24, "Sessions:MaxHours (1 à 24)");
         Require(Sessions.MaxPerAdmin is >= 1 and <= 50, "Sessions:MaxPerAdmin (1 à 50)");
         Require(Sessions.MaxTotal is >= 1 and <= 100_000, "Sessions:MaxTotal");
         Require(ChallengeLifetimeSeconds is >= 10 and <= 600, "ChallengeLifetimeSeconds (10 à 600)");
         Require(InvitationLifetimeHours is >= 1 and <= 168, "InvitationLifetimeHours (1 à 168)");
-        Require(Limits.RequestsPerMinute >= 1 && Limits.AuthPerMinute >= 1 && Limits.EnrollmentsPerHour >= 1, "Limits");
+        Require(Limits.RequestsPerMinute >= 1 && Limits.AuthPerMinute >= 1 && Limits.EnrollmentsPerHour >= 1 &&
+                Limits.PublicationUploadsPerMinute >= 1, "Limits");
         Require(Limits.MaxActiveInvitations is >= 1 and <= 1000, "Limits:MaxActiveInvitations");
         Require(Limits.MaxRequestBodyBytes is >= 1024 and <= 16 * 1024 * 1024, "Limits:MaxRequestBodyBytes");
     }
 
+    private void ValidateCatalog()
+    {
+        CatalogPublicFileFullPath = null;
+        if (!string.IsNullOrWhiteSpace(Catalog.PublicFile))
+        {
+            var file = Catalog.PublicFile.Trim();
+            if (!Path.IsPathRooted(file) || !file.EndsWith(".json", StringComparison.OrdinalIgnoreCase))
+                throw new InvalidOperationException($"{Section}:Catalog:PublicFile doit être un chemin absolu vers un fichier .json.");
+            var full = Path.GetFullPath(file);
+            var directory = Path.GetDirectoryName(full);
+            if (directory is null || !Directory.Exists(directory))
+                throw new InvalidOperationException($"{Section}:Catalog:PublicFile : le dossier « {directory} » n'existe pas.");
+            EnsureSeparatedFromData(directory, "Catalog:PublicFile");
+            CatalogPublicFileFullPath = full;
+        }
+
+        if (string.IsNullOrWhiteSpace(Catalog.PublicUrl))
+        {
+            CatalogPublicUrl = NormalizedOrigin + "/catalog/catalog.json";
+        }
+        else if (Uri.TryCreate(Catalog.PublicUrl.Trim(), UriKind.Absolute, out var url) &&
+                 (url.Scheme == Uri.UriSchemeHttps || (url.Scheme == Uri.UriSchemeHttp && url.IsLoopback)))
+        {
+            CatalogPublicUrl = url.AbsoluteUri;
+        }
+        else
+        {
+            throw new InvalidOperationException($"{Section}:Catalog:PublicUrl doit être une adresse https://.");
+        }
+        CatalogImageHost = new Uri(CatalogPublicUrl).Host;
+    }
+
+    private void ValidateGames()
+    {
+        var files = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        foreach (var (gameId, game) in Games)
+        {
+            var name = $"Games:{gameId}:ManifestFile";
+            if (!Contracts.Catalog.CatalogRules.IsValidGameId(gameId))
+                throw new InvalidOperationException($"{Section}:Games : identifiant de jeu invalide « {gameId} ».");
+            if (string.IsNullOrWhiteSpace(game?.ManifestFile)) continue; // jeu déclaré sans manifest : ignoré
+            var file = game.ManifestFile.Trim();
+            if (!Path.IsPathRooted(file) || !file.EndsWith(".json", StringComparison.OrdinalIgnoreCase))
+                throw new InvalidOperationException($"{Section}:{name} doit être un chemin absolu vers le manifest .json du jeu.");
+            var full = Path.GetFullPath(file);
+            var directory = Path.GetDirectoryName(full);
+            if (directory is null || !Directory.Exists(directory))
+                throw new InvalidOperationException($"{Section}:{name} : le dossier « {directory} » n'existe pas.");
+            EnsureSeparatedFromData(directory, name);
+            if (files.Values.Contains(full, StringComparer.Ordinal))
+                throw new InvalidOperationException($"{Section}:{name} : ce manifest est déjà utilisé par un autre jeu.");
+            files[gameId] = full;
+        }
+        GameManifestFiles = files;
+    }
+
+    /// <summary>
+    /// Un dossier public (servi par nginx) et le dossier des données privées ne doivent pas être l'un
+    /// dans l'autre (liens symboliques résolus).
+    /// </summary>
+    private void EnsureSeparatedFromData(string directory, string name)
+    {
+        var publicDirectory = RealPath(directory);
+        var dataDirectory = RealPath(DataDirectoryFullPath);
+        if (IsSameOrInside(publicDirectory, dataDirectory) || IsSameOrInside(dataDirectory, publicDirectory))
+            throw new InvalidOperationException(
+                $"{Section}:{name} : le dossier public et le dossier des données privées doivent être séparés (aucun des deux dans l'autre).");
+    }
+
+    /// <summary>Chemin absolu, dernier élément résolu s'il s'agit d'un lien symbolique.</summary>
+    private static string RealPath(string directory)
+    {
+        var full = Path.GetFullPath(directory).TrimEnd(Path.DirectorySeparatorChar);
+        try
+        {
+            var target = new DirectoryInfo(full).ResolveLinkTarget(returnFinalTarget: true);
+            return target is null ? full : Path.GetFullPath(target.FullName).TrimEnd(Path.DirectorySeparatorChar);
+        }
+        catch (IOException)
+        {
+            return full;
+        }
+    }
+
+    private static bool IsSameOrInside(string path, string parent)
+    {
+        var comparison = OperatingSystem.IsWindows() ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
+        return string.Equals(path, parent, comparison) ||
+               path.StartsWith(parent + Path.DirectorySeparatorChar, comparison);
+    }
+
     private static void Require(bool condition, string name)
     {
         if (!condition) throw new InvalidOperationException($"{Section}:{name} : valeur hors limites.");

server/GameLauncher.Server/Hosting/ServerApp.cs

@@ -1,3 +1,4 @@
+using System.Globalization;
 using System.Threading.RateLimiting;
 using GameLauncher.Contracts;
 using GameLauncher.Contracts.Dtos;
@@ -5,6 +6,7 @@ using GameLauncher.Server.Security;
 using GameLauncher.Server.Storage;
 using Microsoft.AspNetCore.DataProtection;
 using Microsoft.AspNetCore.HttpOverrides;
+using Microsoft.AspNetCore.RateLimiting;
 using Microsoft.Extensions.Options;
 
 namespace GameLauncher.Server.Hosting;
@@ -64,10 +66,20 @@ public static class ServerApp
         builder.Services.AddRateLimiter(limiter =>
         {
             limiter.RejectionStatusCode = StatusCodes.Status429TooManyRequests;
-            limiter.OnRejected = (context, _) => new ValueTask(ApiResults.WriteAsync(context.HttpContext, 429,
-                ApiErrorCodes.RateLimited, "Trop de requêtes : patientez une minute avant de réessayer."));
+            limiter.OnRejected = (context, _) =>
+            {
+                // Délai avant la prochaine fenêtre : le launcher reprend juste à temps au lieu d'attendre à l'aveugle.
+                if (context.Lease.TryGetMetadata(MetadataName.RetryAfter, out var retryAfter))
+                    context.HttpContext.Response.Headers.RetryAfter = ((int)Math.Ceiling(retryAfter.TotalSeconds)).ToString(CultureInfo.InvariantCulture);
+                return new ValueTask(ApiResults.WriteAsync(context.HttpContext, 429,
+                    ApiErrorCodes.RateLimited, "Trop de requêtes : patientez une minute avant de réessayer."));
+            };
             limiter.GlobalLimiter = PartitionedRateLimiter.Create<HttpContext, string>(context =>
-                RateLimitPartition.GetFixedWindowLimiter(context.RateLimitPartition(), _ => Window(options.Limits.RequestsPerMinute, TimeSpan.FromMinutes(1))));
+                IsPublicationUpload(context)
+                    ? RateLimitPartition.GetNoLimiter("publication") // limite propre (politique PublicationUpload)
+                    : RateLimitPartition.GetFixedWindowLimiter(context.RateLimitPartition(), _ => Window(options.Limits.RequestsPerMinute, TimeSpan.FromMinutes(1))));
+            limiter.AddPolicy(RateLimitPolicies.PublicationUpload, context =>
+                RateLimitPartition.GetFixedWindowLimiter(context.RateLimitPartition(), _ => Window(options.Limits.PublicationUploadsPerMinute, TimeSpan.FromMinutes(1))));
             limiter.AddPolicy(RateLimitPolicies.Auth, context =>
                 RateLimitPartition.GetFixedWindowLimiter(context.RateLimitPartition(), _ => Window(options.Limits.AuthPerMinute, TimeSpan.FromMinutes(1))));
             limiter.AddPolicy(RateLimitPolicies.Enrollment, context =>
@@ -112,6 +124,10 @@ public static class ServerApp
         return app;
     }
 
+    /// <summary>Route d'envoi de morceaux d'une publication (politique <see cref="RateLimitPolicies.PublicationUpload"/>).</summary>
+    private static bool IsPublicationUpload(HttpContext context) =>
+        context.GetEndpoint()?.Metadata.GetMetadata<EnableRateLimitingAttribute>()?.PolicyName == RateLimitPolicies.PublicationUpload;
+
     private static FixedWindowRateLimiterOptions Window(int permits, TimeSpan window) => new()
     {
         PermitLimit = permits,

server/GameLauncher.Server/Modules/Catalog/CatalogModule.cs

@@ -0,0 +1,93 @@
+using System.Text.Json;
+using GameLauncher.Contracts;
+using GameLauncher.Contracts.Catalog;
+using GameLauncher.Contracts.Dtos;
+using GameLauncher.Contracts.Security;
+using GameLauncher.Server.Hosting;
+using GameLauncher.Server.Security;
+using GameLauncher.Server.Storage;
+using Microsoft.Extensions.Options;
+
+namespace GameLauncher.Server.Modules.Catalog;
+
+/// <summary>
+/// Catalogue des jeux (informations MODIFIABLES : nom affiché, accroche, présentation, liens, thème
+/// intégré, images, intervalle de mise à jour, ordre et visibilité). Les jeux restent déclarés dans le
+/// launcher.json intégré à l'exe : le launcher ignore les jeux qu'il ne connaît pas.
+///  • GET : tout administrateur connecté (le contenu est public de toute façon) ;
+///  • PUT : permission games.edit, requête signée, contrôle complet (<see cref="CatalogRules"/>),
+///    révision attendue (409 si quelqu'un a publié entre-temps), audit.
+/// </summary>
+public sealed class CatalogModule : IApiModule
+{
+    public string Name => "Catalog";
+
+    public void ConfigureServices(IServiceCollection services, LauncherApiOptions options) =>
+        services.AddSingleton<CatalogStore>();
+
+    public void MapEndpoints(IEndpointRouteBuilder api)
+    {
+        api.MapGet(ApiRoutes.Catalog, Get).RequireAdmin();
+        api.MapPut(ApiRoutes.Catalog, Publish).RequirePermission(AdminPermissions.GamesEdit).RequireSignedRequest();
+    }
+
+    private static IResult Get(CatalogStore store, IOptions<LauncherApiOptions> options) =>
+        Results.Json(State(store.Read(), store, options.Value), ApiJson.Options);
+
+    private static IResult Publish(CatalogUpdateRequest request, HttpContext context, CatalogStore store, AuditLog audit,
+                                   TimeProvider time, IOptions<LauncherApiOptions> options, ILogger<CatalogModule> logger)
+    {
+        if (request.Catalog is null) return ApiResults.BadRequest("Catalogue absent.");
+        if (request.BaseRevision < 0) return ApiResults.BadRequest("Révision invalide.");
+
+        var errors = new List<string>();
+        var catalog = CatalogRules.Normalize(request.Catalog with
+        {
+            Format = CatalogDocument.FormatName,
+            Version = CatalogDocument.CurrentVersion,
+            Revision = 0
+        }, options.Value.CatalogImageHost, errors);
+        if (errors.Count > 0)
+            return ApiResults.BadRequest(string.Join(" ", errors.Take(5)) + (errors.Count > 5 ? $" (+{errors.Count - 5} autres)" : ""));
+
+        CatalogDocument published, previous;
+        try
+        {
+            (published, previous) = store.Publish(catalog, request.BaseRevision, time.GetUtcNow());
+        }
+        catch (IOException ex)
+        {
+            logger.LogError(ex, "Publication du catalogue");
+            return ApiResults.Error(503, ApiErrorCodes.NotConfigured,
+                "Le serveur n'a pas pu écrire le catalogue public : vérifiez le dossier et ses droits (server/deploy/LISEZMOI.md).");
+        }
+
+        var actor = context.Admin();
+        audit.Write("catalog.publish", AuditResults.Ok, actor.Admin.Id, actor.Admin.DisplayName, actor.Key.KeyId, context.ClientIp(),
+            $"révision {published.Revision}", Describe(previous, published));
+        return Results.Json(State(published, store, options.Value), ApiJson.Options);
+    }
+
+    private static CatalogState State(CatalogDocument catalog, CatalogStore store, LauncherApiOptions options) => new()
+    {
+        Catalog = catalog,
+        PublishingEnabled = store.PublishingEnabled,
+        PublicUrl = options.CatalogPublicUrl
+    };
+
+    /// <summary>Résumé pour l'audit : jeux et réglages modifiés.</summary>
+    private static string Describe(CatalogDocument before, CatalogDocument after)
+    {
+        var changed = new List<string>();
+        if (Serialize(before.Launcher) != Serialize(after.Launcher)) changed.Add("launcher");
+        foreach (var id in before.Games.Keys.Union(after.Games.Keys, StringComparer.OrdinalIgnoreCase).Order(StringComparer.OrdinalIgnoreCase))
+        {
+            before.Games.TryGetValue(id, out var a);
+            after.Games.TryGetValue(id, out var b);
+            if (Serialize(a) != Serialize(b)) changed.Add(id);
+        }
+        return changed.Count == 0 ? "aucun changement" : "modifié : " + string.Join(", ", changed.Take(20));
+    }
+
+    private static string Serialize(object? value) => value is null ? "" : JsonSerializer.Serialize(value, ApiJson.Options);
+}

server/GameLauncher.Server/Modules/Changelog/ChangelogModule.cs

@@ -0,0 +1,90 @@
+using GameLauncher.Contracts;
+using GameLauncher.Contracts.Catalog;
+using GameLauncher.Contracts.Changelog;
+using GameLauncher.Contracts.Dtos;
+using GameLauncher.Contracts.Security;
+using GameLauncher.Server.Hosting;
+using GameLauncher.Server.Security;
+using GameLauncher.Server.Storage;
+
+namespace GameLauncher.Server.Modules.Changelog;
+
+/// <summary>
+/// Notes de version des jeux (éditeur du menu d'administration) : modification des versions EXISTANTES
+/// dans le manifest.json publié de chaque jeu (LauncherApi:Games). La création d'une version reste
+/// l'affaire de ManifestBuilder (et de la publication).
+///  • GET : tout administrateur connecté (le manifest est public de toute façon) ;
+///  • PUT (une version) : permission changelog.edit, requête signée, mêmes bornes que le launcher,
+///    empreinte du manifest attendue (409 si le manifest a changé entre-temps), audit.
+/// </summary>
+public sealed class ChangelogModule : IApiModule
+{
+    public string Name => "Changelog";
+
+    public void ConfigureServices(IServiceCollection services, LauncherApiOptions options) =>
+        services.AddSingleton<ChangelogStore>();
+
+    public void MapEndpoints(IEndpointRouteBuilder api)
+    {
+        api.MapGet(ApiRoutes.GameChangelogPattern, Get).RequireAdmin();
+        api.MapPut(ApiRoutes.GameChangelogEntryPattern, Save).RequirePermission(AdminPermissions.ChangelogEdit).RequireSignedRequest();
+    }
+
+    private static IResult Get(string gameId, ChangelogStore store, ILogger<ChangelogModule> logger)
+    {
+        if (!CatalogRules.IsValidGameId(gameId)) return ApiResults.BadRequest("Identifiant de jeu invalide.");
+        try
+        {
+            return Results.Json(store.Read(gameId), ApiJson.Options);
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException)
+        {
+            logger.LogError(ex, "Lecture du manifest de {GameId}", gameId);
+            return ApiResults.Error(503, ApiErrorCodes.NotConfigured, ex is InvalidDataException
+                ? $"Le serveur n'a pas pu lire le manifest de « {gameId} » : {ex.Message}"
+                : $"Le serveur n'a pas pu lire le manifest de « {gameId} » : vérifiez le dossier du jeu et ses droits (server/deploy/LISEZMOI.md, étape 3 ter).");
+        }
+    }
+
+    private static IResult Save(string gameId, string version, ChangelogUpdateRequest request, HttpContext context,
+                                ChangelogStore store, AuditLog audit, ILogger<ChangelogModule> logger)
+    {
+        if (!CatalogRules.IsValidGameId(gameId)) return ApiResults.BadRequest("Identifiant de jeu invalide.");
+        if (!ChangelogLimits.IsEditableVersion(version)) return ApiResults.BadRequest("Numéro de version invalide.");
+        if (request.Entry is null) return ApiResults.BadRequest("Notes de version absentes.");
+        if (string.IsNullOrWhiteSpace(request.BaseSha256) || request.BaseSha256.Length != 64)
+            return ApiResults.BadRequest("Empreinte du manifest absente ou invalide.");
+        if (!string.Equals(request.Entry.Version, version, StringComparison.Ordinal))
+            return ApiResults.BadRequest("La version des notes ne correspond pas à l'adresse.");
+
+        var errors = ChangelogLimits.Check(request.Entry);
+        if (errors.Count > 0)
+            return ApiResults.BadRequest(string.Join(" ", errors.Take(5)) + (errors.Count > 5 ? $" (+{errors.Count - 5} autres)" : ""));
+
+        ChangelogState state;
+        ChangelogEntry previous;
+        try
+        {
+            (state, previous) = store.Save(gameId, version, request.Entry, request.BaseSha256);
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException)
+        {
+            logger.LogError(ex, "Modification des notes de {GameId} {Version}", gameId, version);
+            return ApiResults.Error(503, ApiErrorCodes.NotConfigured, ex switch
+            {
+                InvalidDataException => $"Le serveur n'a pas pu lire le manifest : {ex.Message}",
+                ManifestWriteRefusedException => $"Modification refusée : {ex.Message} (server/deploy/LISEZMOI.md, étape 3 ter).",
+                _ => "Le serveur n'a pas pu modifier le manifest : vérifiez le dossier du jeu et ses droits (server/deploy/LISEZMOI.md, étape 3 ter)."
+            });
+        }
+
+        var actor = context.Admin();
+        var after = state.Entries.FirstOrDefault(e => e.Version == version);
+        audit.Write("changelog.edit", AuditResults.Ok, actor.Admin.Id, actor.Admin.DisplayName, actor.Key.KeyId, context.ClientIp(),
+            $"{state.GameId} {version}",
+            $"{Count(previous)} → {Count(after)} élément(s), manifest {state.ManifestSha256[..12]}");
+        return Results.Json(state, ApiJson.Options);
+    }
+
+    private static int Count(ChangelogEntry? entry) => entry is null ? 0 : ChangelogLimits.DisplayedItems(entry);
+}

server/GameLauncher.Server/Modules/Publishing/PublishingModule.cs

@@ -0,0 +1,126 @@
+using GameLauncher.Contracts;
+using GameLauncher.Contracts.Catalog;
+using GameLauncher.Contracts.Dtos;
+using GameLauncher.Contracts.Publishing;
+using GameLauncher.Contracts.Security;
+using GameLauncher.Server.Hosting;
+using GameLauncher.Server.Security;
+using GameLauncher.Server.Storage;
+
+namespace GameLauncher.Server.Modules.Publishing;
+
+/// <summary>
+/// Publication d'une version depuis le menu d'administration (phase 5) : permission releases.publish,
+/// TOUTES les requêtes signées (y compris chaque morceau de fichier), audit du début, de la mise en
+/// ligne et de l'abandon. Les routes d'envoi acceptent des corps jusqu'à 8 Mo (les autres : 64 Ko).
+/// </summary>
+public sealed class PublishingModule : IApiModule
+{
+    public string Name => "Publishing";
+
+    public void ConfigureServices(IServiceCollection services, LauncherApiOptions options) =>
+        services.AddSingleton<PublicationStore>();
+
+    public void MapEndpoints(IEndpointRouteBuilder api)
+    {
+        const string permission = AdminPermissions.ReleasesPublish;
+        api.MapPost(ApiRoutes.PublicationStartPattern, Start).RequirePermission(permission).RequireSignedRequest();
+        api.MapGet(ApiRoutes.PublicationPattern, GetState).RequirePermission(permission);
+        api.MapDelete(ApiRoutes.PublicationPattern, Cancel).RequirePermission(permission).RequireSignedRequest();
+        api.MapPut(ApiRoutes.PublicationManifestPattern, Manifest).RequirePermission(permission).RequireSignedRequest()
+           .WithBodyLimit(PublishingLimits.MaxUploadRequestBytes).RequireRateLimiting(RateLimitPolicies.PublicationUpload);
+        api.MapPut(ApiRoutes.PublicationArchivePattern, Archive).RequirePermission(permission).RequireSignedRequest()
+           .WithBodyLimit(PublishingLimits.MaxUploadRequestBytes).RequireRateLimiting(RateLimitPolicies.PublicationUpload);
+        api.MapPut(ApiRoutes.PublicationObjectPattern, UploadObject).RequirePermission(permission).RequireSignedRequest()
+           .WithBodyLimit(PublishingLimits.MaxUploadRequestBytes).RequireRateLimiting(RateLimitPolicies.PublicationUpload);
+        api.MapPost(ApiRoutes.PublicationObjectsPattern, UploadObjects).RequirePermission(permission).RequireSignedRequest()
+           .WithBodyLimit(PublishingLimits.MaxUploadRequestBytes).RequireRateLimiting(RateLimitPolicies.PublicationUpload);
+        api.MapPost(ApiRoutes.PublicationCommitPattern, Commit).RequirePermission(permission).RequireSignedRequest();
+    }
+
+    private static IResult Start(string gameId, PublicationStartRequest request, HttpContext context, PublicationStore store, AuditLog audit,
+                                 ILogger<PublishingModule> logger)
+    {
+        if (!CatalogRules.IsValidGameId(gameId)) return ApiResults.BadRequest("Identifiant de jeu invalide.");
+        var actor = context.Admin();
+        return Guard(logger, () =>
+        {
+            var (state, replaced) = store.Start(gameId, request, actor.Admin.Id, actor.Admin.DisplayName);
+            if (replaced is not null)
+                Audit(audit, context, "release.cancel", replaced.GameId, replaced.Version, $"remplacée par la version {state.Version}");
+            if (!state.Resumed)
+                Audit(audit, context, "release.start", state.GameId, state.Version, $"version en ligne : {Display(state.PublishedVersion)}");
+            return Results.Json(state, ApiJson.Options);
+        });
+    }
+
+    private static IResult GetState(string id, HttpContext context, PublicationStore store, ILogger<PublishingModule> logger) =>
+        Guard(logger, () => Results.Json(store.GetState(id, context.Admin().Admin.Id), ApiJson.Options));
+
+    private static IResult Cancel(string id, HttpContext context, PublicationStore store, AuditLog audit, ILogger<PublishingModule> logger) =>
+        Guard(logger, () =>
+        {
+            var record = store.Cancel(id, context.Admin().Admin.Id);
+            Audit(audit, context, "release.cancel", record.GameId, record.Version, "abandonnée par l'administrateur");
+            return Results.NoContent();
+        });
+
+    private static IResult Manifest(string id, long offset, HttpContext context, PublicationStore store, ILogger<PublishingModule> logger) =>
+        Guard(logger, () => Results.Json(store.AppendManifest(id, context.Admin().Admin.Id, offset, context.CapturedBody()), ApiJson.Options));
+
+    private static IResult Archive(string id, long offset, HttpContext context, PublicationStore store, ILogger<PublishingModule> logger) =>
+        Guard(logger, () => Results.Json(store.AppendArchive(id, context.Admin().Admin.Id, offset, context.CapturedBody()), ApiJson.Options));
+
+    private static IResult UploadObject(string id, string sha256, long offset, HttpContext context, PublicationStore store, ILogger<PublishingModule> logger)
+    {
+        if (!PublishingLimits.IsValidSha256(sha256)) return ApiResults.BadRequest("Empreinte d'objet invalide.");
+        return Guard(logger, () =>
+            Results.Json(store.AppendObject(id, context.Admin().Admin.Id, sha256, offset, context.CapturedBody()), ApiJson.Options));
+    }
+
+    private static IResult UploadObjects(string id, HttpContext context, PublicationStore store, ILogger<PublishingModule> logger) =>
+        Guard(logger, () => Results.Json(store.AddObjects(id, context.Admin().Admin.Id, context.CapturedBody()), ApiJson.Options));
+
+    private static IResult Commit(string id, HttpContext context, PublicationStore store, AuditLog audit, ILogger<PublishingModule> logger) =>
+        Guard(logger, () =>
+        {
+            var (result, record) = store.Commit(id, context.Admin().Admin.Id);
+            if (record is null) return Results.Json(result, ApiJson.Options); // déjà en ligne (réponse précédente perdue)
+            Audit(audit, context, "release.publish", result.GameId, result.Version,
+                $"version précédente : {Display(result.PreviousVersion)} ; {result.ObjectsAdded} fichier(s) ajouté(s)" +
+                (result.ArchiveAdded ? ", archive ajoutée" : "") + $" ; manifest {result.ManifestSha256[..12]}");
+            return Results.Json(result, ApiJson.Options);
+        });
+
+    /// <summary>Erreurs de fichiers → 503 avec un message sans chemin (le détail va dans journalctl).</summary>
+    private static IResult Guard(ILogger logger, Func<IResult> action)
+    {
+        try
+        {
+            return action();
+        }
+        catch (ManifestWriteRefusedException ex)
+        {
+            return ApiResults.Error(503, ApiErrorCodes.NotConfigured, $"Publication refusée : {ex.Message} (server/deploy/LISEZMOI.md, étape 3 ter).");
+        }
+        catch (InvalidDataException ex)
+        {
+            return ApiResults.Error(503, ApiErrorCodes.NotConfigured, $"Le serveur n'a pas pu lire le manifest en ligne : {ex.Message}");
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            logger.LogError(ex, "Publication d'une version");
+            return ApiResults.Error(503, ApiErrorCodes.NotConfigured,
+                "Le serveur n'a pas pu écrire dans le dossier du jeu : vérifiez ses droits et l'espace disque (server/deploy/LISEZMOI.md, étape 3 ter).");
+        }
+    }
+
+    private static void Audit(AuditLog audit, HttpContext context, string action, string gameId, string version, string details)
+    {
+        var actor = context.Admin();
+        audit.Write(action, AuditResults.Ok, actor.Admin.Id, actor.Admin.DisplayName, actor.Key.KeyId, context.ClientIp(),
+            $"{gameId} {version}", details);
+    }
+
+    private static string Display(string version) => string.IsNullOrEmpty(version) ? "aucune" : version;
+}

server/GameLauncher.Server/Security/SignedRequests.cs

@@ -24,15 +24,43 @@ public static class SignedRequests
         if (!HttpMethods.IsGet(context.Request.Method) && !HttpMethods.IsHead(context.Request.Method) &&
             !HttpMethods.IsOptions(context.Request.Method))
         {
-            using var buffer = new MemoryStream();
-            await context.Request.Body.CopyToAsync(buffer, context.RequestAborted);
-            var body = buffer.ToArray();
+            // Routes d'envoi de fichiers (publication) : limite propre, plus grande que celle des autres requêtes.
+            if (context.GetEndpoint()?.Metadata.GetMetadata<RequestBodyLimit>() is { } limit &&
+                context.Features.Get<Microsoft.AspNetCore.Http.Features.IHttpMaxRequestBodySizeFeature>() is { IsReadOnly: false } feature)
+                feature.MaxRequestBodySize = limit.MaxBytes;
+
+            byte[] body;
+            var maxBody = context.Features.Get<Microsoft.AspNetCore.Http.Features.IHttpMaxRequestBodySizeFeature>()?.MaxRequestBodySize;
+            if (context.Request.ContentLength is { } announced && maxBody is { } max && announced > max)
+                throw new BadHttpRequestException("Requête trop volumineuse.", StatusCodes.Status413PayloadTooLarge);
+            if (context.Request.ContentLength is { } length and > 0 and <= int.MaxValue && maxBody is not null)
+            {
+                // Taille annoncée (bornée par Kestrel) : lecture directe, sans copie intermédiaire.
+                body = new byte[length];
+                await context.Request.Body.ReadExactlyAsync(body, context.RequestAborted);
+                if (await context.Request.Body.ReadAsync(new byte[1], context.RequestAborted) != 0)
+                    throw new BadHttpRequestException("Corps plus long que annoncé.");
+            }
+            else
+            {
+                using var buffer = new MemoryStream();
+                await context.Request.Body.CopyToAsync(buffer, context.RequestAborted);
+                body = buffer.ToArray();
+            }
             context.Items[BodyKey] = body;
             context.Request.Body = new MemoryStream(body, writable: false);
         }
         await next();
     });
 
+    /// <summary>Corps de la requête (déjà lu et vérifié par la signature) : routes qui reçoivent des données brutes.</summary>
+    public static byte[] CapturedBody(this HttpContext context) =>
+        context.Items.TryGetValue(BodyKey, out var captured) && captured is byte[] bytes ? bytes : Array.Empty<byte>();
+
+    /// <summary>La route accepte un corps plus grand que la limite générale (envoi de fichiers).</summary>
+    public static TBuilder WithBodyLimit<TBuilder>(this TBuilder builder, long maxBytes) where TBuilder : IEndpointConventionBuilder =>
+        builder.WithMetadata(new RequestBodyLimit(maxBytes));
+
     /// <summary>La route exige une requête signée par la clé de la session (à placer après RequireAdmin/RequirePermission).</summary>
     public static TBuilder RequireSignedRequest<TBuilder>(this TBuilder builder) where TBuilder : IEndpointConventionBuilder =>
         builder.AddEndpointFilter(async (invocation, next) =>
@@ -94,3 +122,6 @@ public static class SignedRequests
         return null;
     }
 }
+
+/// <summary>Taille maximale du corps d'une route (métadonnée lue par <see cref="SignedRequests.UseRequestBodyCapture"/>).</summary>
+public sealed record RequestBodyLimit(long MaxBytes);

server/GameLauncher.Server/Storage/CatalogStore.cs

@@ -0,0 +1,173 @@
+using System.Text;
+using System.Text.Json;
+using GameLauncher.Contracts.Catalog;
+using GameLauncher.Contracts.Dtos;
+using GameLauncher.Server.Hosting;
+using Microsoft.Extensions.Options;
+
+namespace GameLauncher.Server.Storage;
+
+/// <summary>
+/// Catalogue des jeux (informations modifiables).
+///  • Référence : catalog.json dans le dossier des données privées (+ historique des 20 dernières révisions).
+///  • Publication : copie dans le fichier PUBLIC servi par nginx (LauncherApi:Catalog:PublicFile),
+///    écrite atomiquement (fichier temporaire du même dossier puis renommage), lisible par tous (0644).
+///  • Contrôle des modifications concurrentes : une publication précise la révision sur laquelle elle
+///    a été préparée ; si quelqu'un a publié entre-temps, elle est refusée (409).
+/// </summary>
+public sealed class CatalogStore
+{
+    public const string FileName = "catalog.json";
+    private const string HistoryFolder = "catalog-history";
+    private const int HistoryLength = 20;
+
+    private static readonly JsonSerializerOptions Json = CatalogRules.PublishedJson;
+    private static readonly TimeSpan LockTimeout = TimeSpan.FromSeconds(5);
+    private const UnixFileMode PublicFileMode =
+        UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.GroupRead | UnixFileMode.OtherRead;
+
+    private readonly string _path;
+    private readonly string _lockPath;
+    private readonly string _historyDirectory;
+    private readonly string? _publicFile;
+    private readonly object _writeLock = new();
+
+    public CatalogStore(IOptions<LauncherApiOptions> options)
+        : this(options.Value.DataDirectoryFullPath, options.Value.CatalogPublicFileFullPath) { }
+
+    public CatalogStore(string dataDirectory, string? publicFile)
+    {
+        SecureFiles.EnsureDirectory(dataDirectory);
+        _path = Path.Combine(dataDirectory, FileName);
+        _lockPath = _path + ".lock";
+        _historyDirectory = Path.Combine(dataDirectory, HistoryFolder);
+        _publicFile = publicFile;
+    }
+
+    public bool PublishingEnabled => _publicFile is not null;
+
+    /// <summary>Catalogue actuel (vide, révision 0, s'il n'a jamais été publié).</summary>
+    public CatalogDocument Read()
+    {
+        if (!File.Exists(_path)) return new CatalogDocument();
+        var text = File.ReadAllText(_path);
+        var document = JsonSerializer.Deserialize<CatalogDocument>(text, Json)
+                       ?? throw new InvalidDataException($"{FileName} est vide.");
+        var errors = new List<string>();
+        return CatalogRules.Normalize(document, imageHost: null, errors) with { Revision = document.Revision };
+    }
+
+    /// <summary>
+    /// Publie un catalogue déjà contrôlé (<see cref="CatalogRules.Normalize"/>) : révision suivante,
+    /// fichier public, puis référence privée et historique.
+    /// </summary>
+    /// <returns>Le catalogue publié et le précédent.</returns>
+    public (CatalogDocument Published, CatalogDocument Previous) Publish(CatalogDocument catalog, long baseRevision, DateTimeOffset now)
+    {
+        if (_publicFile is null)
+            throw new ApiRejection(503, ApiErrorCodes.NotConfigured,
+                "Publication du catalogue non configurée sur le serveur (LauncherApi:Catalog:PublicFile).");
+
+        lock (_writeLock)
+        using (SecureFiles.AcquireLock(_lockPath, LockTimeout))
+        {
+            var current = Read();
+            if (current.Revision != baseRevision)
+                throw ApiRejection.Conflict(
+                    $"Le catalogue a été publié entre-temps (révision {current.Revision}) : rechargez-le, puis refaites vos modifications.",
+                    ApiErrorCodes.RevisionConflict);
+
+            var published = catalog with
+            {
+                Format = CatalogDocument.FormatName,
+                Version = CatalogDocument.CurrentVersion,
+                Revision = current.Revision + 1,
+                UpdatedAt = now
+            };
+            var json = JsonSerializer.Serialize(published, Json);
+            if (Encoding.UTF8.GetByteCount(json) > CatalogRules.MaxFileBytes)
+                throw ApiRejection.BadRequest($"Catalogue trop volumineux (au plus {CatalogRules.MaxFileBytes / 1024} Ko).");
+
+            // 1. Référence privée (+ .bak) : c'est elle qui porte la révision.
+            var previousText = File.Exists(_path) ? File.ReadAllText(_path) : null;
+            SecureFiles.WriteAllTextAtomic(_path, json, keepBackup: true);
+
+            // 2. Fichier public. En cas d'échec, la référence privée est remise dans son état précédent :
+            //    les joueurs et le serveur restent sur la même révision (rien n'est publié à moitié).
+            try
+            {
+                WritePublic(json);
+            }
+            catch (IOException)
+            {
+                RestorePrivate(previousText);
+                throw;
+            }
+
+            // 3. Historique (aide uniquement).
+            WriteHistory(published.Revision, json);
+            return (published, current);
+        }
+    }
+
+    private void WritePublic(string json)
+    {
+        var directory = Path.GetDirectoryName(_publicFile!)!;
+        var temp = Path.Combine(directory, $".{Path.GetFileName(_publicFile)}.{Guid.NewGuid():N}.tmp");
+        try
+        {
+            var options = new FileStreamOptions { Mode = FileMode.CreateNew, Access = FileAccess.Write, Share = FileShare.None };
+            if (!OperatingSystem.IsWindows()) options.UnixCreateMode = PublicFileMode;
+            using (var stream = new FileStream(temp, options))
+            {
+                stream.Write(new UTF8Encoding(encoderShouldEmitUTF8Identifier: false).GetBytes(json));
+                stream.Flush(flushToDisk: true);
+            }
+            // Le masque du service (UMask=0077) s'applique à la création : droits fixés explicitement
+            // pour que nginx puisse lire le fichier (lecture seule pour tous, écriture par le service seul).
+            if (!OperatingSystem.IsWindows()) File.SetUnixFileMode(temp, PublicFileMode);
+            File.Move(temp, _publicFile!, overwrite: true); // renommage atomique dans le même dossier
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            try
+            {
+                File.Delete(temp);
+            }
+            catch (Exception cleanup) when (cleanup is IOException or UnauthorizedAccessException)
+            {
+                // fichier temporaire laissé : sans conséquence (nom unique)
+            }
+            throw new IOException($"Écriture du catalogue public impossible ({_publicFile}) : {ex.Message}", ex);
+        }
+    }
+
+    private void RestorePrivate(string? previousText)
+    {
+        try
+        {
+            if (previousText is null) File.Delete(_path);
+            else SecureFiles.WriteAllTextAtomic(_path, previousText, keepBackup: false);
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            // Très improbable (le dossier privé vient d'être écrit) : la révision suivante sera alors
+            // refusée (409) jusqu'au rechargement de la page, sans rien écraser.
+        }
+    }
+
+    private void WriteHistory(long revision, string json)
+    {
+        try
+        {
+            SecureFiles.EnsureDirectory(_historyDirectory);
+            SecureFiles.WriteAllTextAtomic(Path.Combine(_historyDirectory, $"catalog-{revision:D6}.json"), json, keepBackup: false);
+            foreach (var old in Directory.GetFiles(_historyDirectory, "catalog-*.json").OrderByDescending(f => f, StringComparer.Ordinal).Skip(HistoryLength))
+                File.Delete(old);
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            // L'historique est une aide : son échec n'annule pas la publication.
+        }
+    }
+}

server/GameLauncher.Server/Storage/ChangelogStore.cs

@@ -0,0 +1,165 @@
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using GameLauncher.Contracts.Changelog;
+using GameLauncher.Contracts.Dtos;
+using GameLauncher.Server.Hosting;
+using Microsoft.Extensions.Options;
+
+namespace GameLauncher.Server.Storage;
+
+/// <summary>
+/// Notes de version des jeux, dans le manifest.json PUBLIÉ de chaque jeu (LauncherApi:Games:&lt;id&gt;:ManifestFile).
+///  • Seule l'entrée « changelog » de la version demandée est remplacée : le reste du manifest (fichiers,
+///    archive, version, exécutable…) est recopié tel quel. Numéro et date de la version sont conservés.
+///  • Contrôle des modifications concurrentes : empreinte SHA-256 du manifest lu par l'éditeur ; si le
+///    fichier a changé (nouvelle version publiée, autre administrateur), la modification est refusée (409).
+///    L'empreinte est vérifiée une seconde fois juste avant le remplacement.
+///  • Écriture atomique (fichier temporaire caché du même dossier puis renommage), droits du manifest
+///    existant conservés ; l'ancienne version est copiée dans les données privées (20 dernières).
+/// </summary>
+public sealed class ChangelogStore
+{
+    /// <summary>Taille maximale d'un manifest lu ou écrit (même borne que le launcher).</summary>
+    public const long MaxManifestBytes = PublishedFiles.MaxManifestBytes;
+
+    /// <summary>Champs d'une entrée « changelog » modifiés par l'éditeur (jamais « version » ni « date »).</summary>
+    private static readonly string[] EditableFields = { "title", "subtitle", "introduction", "sections", "changes" };
+
+    private readonly IReadOnlyDictionary<string, string> _manifests;
+    private readonly string _dataDirectory;
+    private readonly object _writeLock = new();
+
+    public ChangelogStore(IOptions<LauncherApiOptions> options)
+        : this(options.Value.GameManifestFiles, options.Value.DataDirectoryFullPath) { }
+
+    public ChangelogStore(IReadOnlyDictionary<string, string> manifests, string dataDirectory)
+    {
+        _manifests = manifests;
+        _dataDirectory = dataDirectory;
+    }
+
+    /// <summary>Notes de version publiées du jeu.</summary>
+    public ChangelogState Read(string gameId)
+    {
+        var (path, key) = Locate(gameId);
+        var bytes = ReadManifest(path);
+        var root = Parse(bytes, key);
+        return State(key, root, bytes);
+    }
+
+    /// <summary>
+    /// Remplace les notes d'UNE version existante (déjà contrôlées par <see cref="ChangelogLimits.Check"/>).
+    /// </summary>
+    /// <returns>Le nouvel état et les notes remplacées (audit).</returns>
+    public (ChangelogState State, ChangelogEntry Previous) Save(string gameId, string version, ChangelogEntry entry, string baseSha256)
+    {
+        var (path, key) = Locate(gameId);
+        lock (_writeLock)
+        using (PublishedFiles.LockGame(_dataDirectory, key))
+        {
+            var bytes = ReadManifest(path);
+            if (!string.Equals(Sha256(bytes), baseSha256, StringComparison.OrdinalIgnoreCase))
+                throw Conflict();
+
+            var root = Parse(bytes, key);
+            var changelog = ChangelogArray(root)
+                            ?? throw ApiRejection.NotFound($"Le manifest de « {key} » ne contient aucune note de version.");
+            var index = -1;
+            for (var i = 0; i < changelog.Count; i++)
+                if (changelog[i] is JsonObject candidate && string.Equals(PublishedFiles.StringValue(candidate, "version"), version, StringComparison.Ordinal))
+                {
+                    index = i;
+                    break;
+                }
+            if (index < 0)
+                throw ApiRejection.NotFound($"La version {version} n'a pas de notes dans le manifest publié (seules les versions existantes se modifient).");
+
+            var old = (JsonObject)changelog[index]!;
+            var previous = Entries(new JsonArray(old.DeepClone())).FirstOrDefault() ?? new ChangelogEntry();
+
+            // Notes nettoyées et bornées (mêmes règles que le launcher) ; liste à plat régénérée pour les
+            // anciens launchers ; numéro et date de la version repris du manifest.
+            var clean = ChangelogLimits.Normalize(new[] { entry }).FirstOrDefault()
+                        ?? throw ApiRejection.BadRequest("Les notes de version ne peuvent pas être vides.");
+            if (clean.Sections.Count > 0) clean.Changes = clean.ToFlatChanges();
+            // Entrée existante recopiée (numéro, date, propriétés inconnues de ce serveur conservés, quelle
+            // que soit la casse des noms), puis seuls les champs des notes sont remplacés.
+            var replacement = old.DeepClone().AsObject();
+            var edited = JsonSerializer.SerializeToNode(clean, PublishedFiles.ManifestJson)!.AsObject();
+            foreach (var name in EditableFields) PublishedFiles.SetProperty(replacement, name, edited[name]?.DeepClone());
+            changelog[index] = replacement;
+
+            // Budget de tout l'historique : au-delà, le launcher tronquerait les versions les plus anciennes.
+            var total = Entries(changelog).OfType<ChangelogEntry>().Sum(ChangelogLimits.DisplayedItems);
+            if (total > ChangelogLimits.MaxTotalItems)
+                throw ApiRejection.BadRequest(
+                    $"Historique trop long : {total} éléments pour toutes les versions ({ChangelogLimits.MaxTotalItems} au plus).");
+
+            var newBytes = PublishedFiles.Serialize(root);
+            PublishedFiles.Backup(_dataDirectory, key, bytes);
+            PublishedFiles.WriteManifest(path, newBytes, baseSha256, Conflict);
+            return (State(key, root, newBytes), previous);
+        }
+    }
+
+    // ------------------------------------------------------------------ Lecture
+
+    private (string Path, string GameId) Locate(string gameId)
+    {
+        foreach (var (key, path) in _manifests)
+            if (string.Equals(key, gameId, StringComparison.OrdinalIgnoreCase))
+                return (path, key);
+        throw PublishedFiles.NotConfigured(gameId, "Modification des notes de version");
+    }
+
+    private static byte[] ReadManifest(string path) =>
+        PublishedFiles.ReadManifest(path) ?? throw ApiRejection.NotFound("Aucun manifest publié pour ce jeu (publiez d'abord une version).");
+
+    internal static JsonObject Parse(byte[] bytes, string gameId)
+    {
+        var root = PublishedFiles.ParseObject(PublishedFiles.StripBom(bytes), "Manifest");
+
+        // Garde-fou de configuration : le fichier configuré doit bien être celui de ce jeu.
+        var manifestGameId = PublishedFiles.StringValue(root, "gameId");
+        if (!string.IsNullOrEmpty(manifestGameId) && !string.Equals(manifestGameId, gameId, StringComparison.OrdinalIgnoreCase))
+            throw new ApiRejection(503, ApiErrorCodes.NotConfigured,
+                $"Le manifest configuré pour « {gameId} » est celui du jeu « {manifestGameId} » : vérifiez LauncherApi:Games sur le serveur.");
+        return root;
+    }
+
+    private static ChangelogState State(string gameId, JsonObject root, byte[] bytes)
+    {
+        var entries = ChangelogLimits.Normalize(Entries(ChangelogArray(root)));
+        // Liste à plat (anciens launchers) inutile à l'éditeur quand les sections existent : réponse allégée.
+        foreach (var entry in entries.Where(e => e.Sections.Count > 0)) entry.Changes = new List<string>();
+        return new ChangelogState
+        {
+            GameId = gameId,
+            ManifestVersion = PublishedFiles.StringValue(root, "version") ?? "",
+            ManifestSha256 = Sha256(bytes),
+            Entries = entries
+        };
+    }
+
+    /// <summary>Entrées du manifest ; une entrée illisible (date ou type invalide) rend le manifest illisible.</summary>
+    internal static List<ChangelogEntry?> Entries(JsonArray? changelog)
+    {
+        try
+        {
+            return changelog?.Deserialize<List<ChangelogEntry?>>(PublishedFiles.ManifestJson) ?? new List<ChangelogEntry?>();
+        }
+        catch (Exception ex) when (ex is JsonException or InvalidOperationException or FormatException)
+        {
+            throw new InvalidDataException($"Notes de version illisibles dans le manifest : {ex.Message}", ex);
+        }
+    }
+
+    /// <summary>Tableau « changelog » du manifest (nom insensible à la casse, comme pour le launcher).</summary>
+    internal static JsonArray? ChangelogArray(JsonObject root) => PublishedFiles.Property(root, "changelog") as JsonArray;
+
+    public static string Sha256(byte[] bytes) => PublishedFiles.Sha256(bytes);
+
+    private static ApiRejection Conflict() => ApiRejection.Conflict(
+        "Le manifest a changé sur le serveur depuis son chargement (nouvelle version publiée ou autre administrateur) : rechargez les notes.",
+        ApiErrorCodes.RevisionConflict);
+}

server/GameLauncher.Server/Storage/PublicationStore.cs

@@ -0,0 +1,838 @@
+using System.Collections.Concurrent;
+using System.Security.Cryptography;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using GameLauncher.Contracts;
+using GameLauncher.Contracts.Changelog;
+using GameLauncher.Contracts.Dtos;
+using GameLauncher.Contracts.Publishing;
+using GameLauncher.Server.Hosting;
+using Microsoft.Extensions.Options;
+
+namespace GameLauncher.Server.Storage;
+
+/// <summary>
+/// Publication d'une version depuis le menu d'administration (phase 5).
+///  • Dépôt : dossier CACHÉ « .publish-&lt;id&gt; » dans le dossier du jeu (même disque : la mise en ligne
+///    finale n'est qu'une suite de renommages ; nginx refuse les chemins commençant par un point), droits
+///    0700 ; description (version, plan) dans les données privées.
+///  • Envoi : manifest, puis objets absents du serveur (par lots, ou par morceaux pour les gros), puis
+///    archive par morceaux ; chaque fichier est reçu à la suite (position vérifiée : reprise possible
+///    après une coupure) puis vérifié (SHA-256) avant d'être accepté.
+///  • Mise en ligne (commit) : tout est revérifié AVANT de déplacer quoi que ce soit ; objets puis archive
+///    installés, manifest en DERNIER (comme avec WinSCP), historique des notes du serveur conservé ; si
+///    l'écriture du manifest échoue, l'archive remplacée est remise en place. Jamais si les fichiers en
+///    ligne ont changé pendant l'envoi (autre publication, WinSCP).
+///  • Une publication par jeu ; abandonnée au bout de 48 h sans envoi ; résultat conservé 24 h (une
+///    réponse perdue n'empêche pas de constater que la version est en ligne).
+/// </summary>
+public sealed class PublicationStore
+{
+    private const string RecordsFolder = "publications";
+    private const string StagingPrefix = ".publish-";
+    private const string DoneSuffix = ".done";
+    private const long FreeSpaceMargin = 256L * 1024 * 1024;
+    private static readonly TimeSpan DoneLifetime = TimeSpan.FromHours(24);
+    private static readonly TimeSpan CleanUpEvery = TimeSpan.FromMinutes(10);
+    private const UnixFileMode PrivateDirectory = UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute;
+    private const UnixFileMode PrivateFile = UnixFileMode.UserRead | UnixFileMode.UserWrite;
+
+    private readonly IReadOnlyDictionary<string, string> _manifests;
+    private readonly string _dataDirectory;
+    private readonly string _recordsDirectory;
+    private readonly TimeProvider _time;
+    private readonly object _startLock = new();
+    private readonly ConcurrentDictionary<string, object> _locks = new(StringComparer.Ordinal);
+    private readonly ConcurrentDictionary<string, HashProgress> _hashes = new(StringComparer.Ordinal);
+    private DateTimeOffset _lastCleanUp = DateTimeOffset.MinValue;
+
+    public PublicationStore(IOptions<LauncherApiOptions> options, TimeProvider time)
+        : this(options.Value.GameManifestFiles, options.Value.DataDirectoryFullPath, time) { }
+
+    public PublicationStore(IReadOnlyDictionary<string, string> manifests, string dataDirectory, TimeProvider time)
+    {
+        _manifests = manifests;
+        _dataDirectory = dataDirectory;
+        _recordsDirectory = Path.Combine(dataDirectory, RecordsFolder);
+        _time = time;
+    }
+
+    // ================================================================== Début, état, abandon
+
+    /// <summary>
+    /// Début d'une publication, ou reprise si le même manifest était en cours d'envoi. Une publication
+    /// d'un autre administrateur, active depuis moins de 30 min, n'est pas remplacée (409).
+    /// </summary>
+    /// <returns>L'état, et la publication remplacée (audit) le cas échéant.</returns>
+    public (PublicationState State, PublicationRecord? Replaced) Start(string gameId, PublicationStartRequest request, Guid adminId, string adminName)
+    {
+        var (manifestPath, key) = Locate(gameId);
+        if (!ManifestCheck.IsValidVersion(request.Version)) throw ApiRejection.BadRequest("Numéro de version invalide.");
+        if (!PublishingLimits.IsValidSha256(request.ManifestSha256)) throw ApiRejection.BadRequest("Empreinte du manifest invalide.");
+        if (request.ManifestSize is <= 0 or > PublishingLimits.MaxManifestBytes) throw ApiRejection.BadRequest("Taille du manifest invalide.");
+
+        lock (_startLock)
+        {
+            CleanUp(force: true);
+            PublicationRecord? replaced = null;
+            foreach (var existing in Records().Where(r => string.Equals(r.GameId, key, StringComparison.OrdinalIgnoreCase)).ToList())
+            {
+                if (existing.AdminId == adminId && existing.Version == request.Version &&
+                    string.Equals(existing.ManifestSha256, request.ManifestSha256, StringComparison.OrdinalIgnoreCase))
+                {
+                    Touch(existing.Id);
+                    return (Lock(existing.Id, () => State(Current(existing.Id), resumed: true)), null);
+                }
+                var idle = _time.GetUtcNow() - LastActivity(existing.Id);
+                if (existing.AdminId != adminId && idle < PublishingLimits.TakeoverAfter)
+                    throw ApiRejection.Conflict(
+                        $"{existing.AdminName} publie la version {existing.Version} de ce jeu (dernier envoi il y a " +
+                        $"{Math.Max(1, (int)idle.TotalMinutes)} min). Réessayez plus tard.", ApiErrorCodes.PublicationInProgress);
+                Lock(existing.Id, () =>
+                {
+                    Delete(existing);
+                    return 0;
+                });
+                replaced = existing;
+            }
+
+            var current = PublishedFiles.ReadManifest(manifestPath);
+            var currentRoot = current is null ? null : ChangelogStore.Parse(current, key);
+            var record = new PublicationRecord
+            {
+                Id = Convert.ToHexString(RandomNumberGenerator.GetBytes(16)).ToLowerInvariant(),
+                GameId = key,
+                Version = request.Version,
+                ManifestSha256 = request.ManifestSha256.ToLowerInvariant(),
+                ManifestSize = request.ManifestSize,
+                AdminId = adminId,
+                AdminName = adminName,
+                CreatedAt = _time.GetUtcNow(),
+                PublishedVersion = currentRoot is null ? "" : PublishedFiles.StringValue(currentRoot, "version") ?? "",
+                PublishedContentSha256 = ContentSignature(currentRoot)
+            };
+            CreateStaging(record);
+            Save(record);
+            return (Lock(record.Id, () => State(record, resumed: false)), replaced);
+        }
+    }
+
+    public PublicationState GetState(string id, Guid adminId)
+    {
+        Find(id, adminId);
+        return Lock(id, () =>
+        {
+            EnsurePlan(Current(id));
+            return State(Current(id), resumed: false);
+        });
+    }
+
+    /// <summary>Abandon : dépôt supprimé, rien n'est publié.</summary>
+    public PublicationRecord Cancel(string id, Guid adminId)
+    {
+        Find(id, adminId);
+        return Lock(id, () =>
+        {
+            var record = Current(id);
+            Delete(record);
+            return record;
+        });
+    }
+
+    // ================================================================== Envoi
+
+    public ChunkResult AppendManifest(string id, Guid adminId, long offset, byte[] data)
+    {
+        Find(id, adminId);
+        return Lock(id, () =>
+        {
+            var record = Current(id);
+            var staging = Staging(record);
+            var result = Append(Path.Combine(staging, "manifest.part"), Path.Combine(staging, "manifest.json"), offset, data,
+                                record.ManifestSize, record.ManifestSha256, "manifest");
+            Touch(id);
+            if (result.Complete) EnsurePlan(record);
+            return result;
+        });
+    }
+
+    public ChunkResult AppendArchive(string id, Guid adminId, long offset, byte[] data)
+    {
+        Find(id, adminId);
+        return Lock(id, () =>
+        {
+            var record = Current(id);
+            var plan = RequirePlan(record);
+            if (!plan.ArchiveNeeded) return new ChunkResult { Received = plan.ArchiveSize, Complete = true };
+            var staging = Staging(record);
+            var result = Append(Path.Combine(staging, "archive.part"), Path.Combine(staging, "archive.zip"), offset, data,
+                                plan.ArchiveSize, plan.ArchiveSha256, "archive");
+            Touch(id);
+            return result;
+        });
+    }
+
+    /// <summary>Gros objet, par morceaux.</summary>
+    public ChunkResult AppendObject(string id, Guid adminId, string sha256, long offset, byte[] data)
+    {
+        Find(id, adminId);
+        var sha = sha256.ToLowerInvariant();
+        return Lock(id, () =>
+        {
+            var record = Current(id);
+            var plan = RequirePlan(record);
+            if (!plan.Pending.TryGetValue(sha, out var size))
+                throw ApiRejection.BadRequest("Cet objet n'est pas attendu par cette publication.");
+            var objects = StagingObjects(record);
+            var result = Append(Path.Combine(objects, sha + ".part"), Path.Combine(objects, sha + ".bin"), offset, data, size, sha, "objet");
+            Touch(id);
+            return result;
+        });
+    }
+
+    /// <summary>Lot de petits objets (chacun vérifié) ; renvoie le nombre d'objets enregistrés.</summary>
+    public ChunkResult AddObjects(string id, Guid adminId, byte[] body)
+    {
+        Find(id, adminId);
+        List<(string Sha256, ReadOnlyMemory<byte> Data)> batch;
+        try
+        {
+            batch = ObjectBatch.Read(body, PublishingLimits.MaxObjectsPerBatch);
+        }
+        catch (InvalidDataException ex)
+        {
+            throw ApiRejection.BadRequest(ex.Message);
+        }
+
+        return Lock(id, () =>
+        {
+            var record = Current(id);
+            var plan = RequirePlan(record);
+            var objects = StagingObjects(record);
+            var saved = 0;
+            foreach (var (sha, data) in batch)
+            {
+                if (!plan.Pending.TryGetValue(sha, out var size))
+                    throw ApiRejection.BadRequest("Un objet du lot n'est pas attendu par cette publication.");
+                if (data.Length != size) throw ApiRejection.BadRequest($"Objet {sha[..12]}… : taille différente de celle du manifest.");
+                if (PublishedFiles.Sha256(data.Span) != sha)
+                    throw ApiRejection.BadRequest($"Objet {sha[..12]}… : contenu différent de son empreinte (fichier modifié ou abîmé).");
+                var done = Path.Combine(objects, sha + ".bin");
+                if (!File.Exists(done))
+                {
+                    var temp = Path.Combine(objects, $"{sha}.{Guid.NewGuid():N}.tmp");
+                    PublishedFiles.WriteNew(temp, data.Span, PrivateFile);
+                    File.Move(temp, done, overwrite: true);
+                }
+                saved++;
+            }
+            Touch(id);
+            return new ChunkResult { Received = saved, Complete = true };
+        });
+    }
+
+    // ================================================================== Mise en ligne
+
+    /// <summary>
+    /// Met la version en ligne : objets, archive, puis manifest (historique des notes du serveur conservé).
+    /// Déjà faite (réponse précédente perdue) : le même résultat est renvoyé.
+    /// </summary>
+    /// <returns>Le résultat, et l'enregistrement (null si la mise en ligne avait déjà eu lieu).</returns>
+    public (PublicationResult Result, PublicationRecord? Record) Commit(string id, Guid adminId)
+    {
+        if (!PublishingLimits.IsValidPublicationId(id)) throw ApiRejection.NotFound("Publication introuvable.");
+        if (Load(id) is null && LoadDone(id) is { } done && done.AdminId == adminId) return (done.Result, null);
+        Find(id, adminId);
+        return Lock(id, () =>
+        {
+            if (Load(id) is null && LoadDone(id) is { } finished && finished.AdminId == adminId) return (finished.Result, (PublicationRecord?)null);
+            var record = Current(id);
+            var (manifestPath, gameId) = Locate(record.GameId);
+            var gameDirectory = Path.GetDirectoryName(manifestPath)!;
+            var plan = RequirePlan(record);
+            var state = State(record, resumed: false);
+            if (state.PendingObjects.Count > 0 || !state.ArchiveComplete)
+                throw ApiRejection.Conflict(
+                    $"Envoi incomplet : {state.PendingObjects.Count} fichier(s) et {(state.ArchiveComplete ? "aucune archive" : "l'archive")} restent à envoyer.");
+
+            var staging = Staging(record);
+            var manifestBytes = File.ReadAllBytes(Path.Combine(staging, "manifest.json"));
+            var errors = new List<string>();
+            var summary = ManifestCheck.Check(manifestBytes, gameId, record.Version, errors)
+                          ?? throw ApiRejection.BadRequest(string.Join(" ", errors.Take(5)));
+
+            using (PublishedFiles.LockGame(_dataDirectory, gameId))
+            {
+                var current = PublishedFiles.ReadManifest(manifestPath);
+                var currentRoot = current is null ? null : ChangelogStore.Parse(current, gameId);
+                var currentVersion = currentRoot is null ? "" : PublishedFiles.StringValue(currentRoot, "version") ?? "";
+                // Fichiers en ligne changés pendant l'envoi (autre publication, WinSCP) : jamais écrasés. Une
+                // correction des notes (page Notes de version) ne change que « changelog » : elle est permise.
+                if (ContentSignature(currentRoot) != record.PublishedContentSha256)
+                    throw ApiRejection.Conflict(
+                        $"La version en ligne a changé pendant l'envoi ({Display(record.PublishedVersion)} → {Display(currentVersion)}) : " +
+                        "vérifiez avant de publier la vôtre, puis recommencez.", ApiErrorCodes.RevisionConflict);
+
+                // Nouveau manifest : celui reçu, avec l'historique des notes du serveur (corrections en ligne).
+                var root = PublishedFiles.ParseObject(PublishedFiles.StripBom(manifestBytes), "Manifest");
+                PublishedFiles.SetProperty(root, "changelog", MergeChangelog(root, currentRoot, record.Version));
+                var newBytes = PublishedFiles.Serialize(root);
+
+                // 0. Contrôles AVANT tout déplacement : droits, liens symboliques, dossiers objects/xx.
+                if (new FileInfo(manifestPath).LinkTarget is not null)
+                    throw new ManifestWriteRefusedException("le manifest publié est un lien symbolique : le remplacer romprait le lien.");
+                var archiveTarget = Path.Combine(gameDirectory, summary.ArchiveName);
+                if (new FileInfo(archiveTarget).LinkTarget is not null)
+                    throw new ManifestWriteRefusedException("l'archive publiée est un lien symbolique : la remplacer romprait le lien.");
+                var mode = PublishedFiles.PublicMode(gameDirectory, current is null ? null : manifestPath);
+                var objectsDirectory = Path.Combine(gameDirectory, "objects");
+                PublishedFiles.EnsurePublicDirectory(objectsDirectory, gameDirectory, keepSetGid: true);
+                foreach (var prefix in plan.Pending.Keys.Select(sha => sha[..2]).Distinct())
+                    PublishedFiles.EnsurePublicDirectory(Path.Combine(objectsDirectory, prefix), gameDirectory, keepSetGid: false);
+
+                // 1. Objets (contenu adressé par l'empreinte : un objet présent est le bon s'il a la bonne taille).
+                var added = 0;
+                foreach (var (sha, size) in plan.Pending)
+                {
+                    var staged = Path.Combine(StagingObjects(record), sha + ".bin");
+                    var target = Path.Combine(gameDirectory, ManifestCheck.ObjectPath(sha));
+                    if (ObjectPresent(target, size))
+                    {
+                        PublishedFiles.TryDelete(staged);
+                        continue;
+                    }
+                    if (!OperatingSystem.IsWindows()) File.SetUnixFileMode(staged, mode);
+                    File.Move(staged, target, overwrite: true);
+                    added++;
+                }
+                foreach (var (sha, size) in summary.Objects)
+                    if (!ObjectPresent(Path.Combine(gameDirectory, ManifestCheck.ObjectPath(sha)), size))
+                        throw ApiRejection.Conflict(
+                            $"Le fichier {ManifestCheck.ObjectPath(sha)} a disparu du serveur pendant l'envoi : abandonnez puis recommencez la publication.");
+
+                // 2. Archive : l'ancienne (même nom : republication) est gardée de côté jusqu'à l'écriture du manifest.
+                var stagedArchive = Path.Combine(staging, "archive.zip");
+                string? previousArchive = null;
+                var archiveAdded = false;
+                if (File.Exists(stagedArchive))
+                {
+                    if (!OperatingSystem.IsWindows()) File.SetUnixFileMode(stagedArchive, mode);
+                    if (File.Exists(archiveTarget))
+                    {
+                        previousArchive = PublishedFiles.TempPath(archiveTarget);
+                        File.Move(archiveTarget, previousArchive);
+                    }
+                    File.Move(stagedArchive, archiveTarget);
+                    archiveAdded = true;
+                }
+                else if (!File.Exists(archiveTarget) || new FileInfo(archiveTarget).Length != summary.ArchiveSize)
+                {
+                    throw ApiRejection.Conflict("L'archive a disparu du serveur pendant l'envoi : abandonnez puis recommencez la publication.");
+                }
+
+                // 3. Manifest en dernier : les launchers ne voient jamais une version incomplète.
+                try
+                {
+                    if (current is not null) PublishedFiles.Backup(_dataDirectory, gameId, current);
+                    PublishedFiles.WriteManifest(manifestPath, newBytes, current is null ? null : PublishedFiles.Sha256(current),
+                        () => ApiRejection.Conflict("Le manifest a été modifié pendant la mise en ligne : recommencez.", ApiErrorCodes.RevisionConflict));
+                }
+                catch
+                {
+                    // Archive remise dans le dépôt (pas besoin de la renvoyer), l'ancienne remise en ligne.
+                    if (archiveAdded)
+                    {
+                        File.Move(archiveTarget, stagedArchive, overwrite: true);
+                        if (previousArchive is not null) File.Move(previousArchive, archiveTarget);
+                    }
+                    throw;
+                }
+                if (previousArchive is not null) PublishedFiles.TryDelete(previousArchive);
+
+                var result = new PublicationResult
+                {
+                    GameId = gameId,
+                    Version = record.Version,
+                    PreviousVersion = currentVersion,
+                    ManifestSha256 = PublishedFiles.Sha256(newBytes),
+                    ObjectsAdded = added,
+                    ArchiveAdded = archiveAdded
+                };
+                SaveDone(new PublicationDone { Id = id, AdminId = record.AdminId, Result = result, At = _time.GetUtcNow() });
+                Delete(record);
+                return (result, (PublicationRecord?)record);
+            }
+        });
+    }
+
+    /// <summary>
+    /// Notes : celles de la version publiée (du manifest reçu ; à défaut, celles déjà en ligne), puis
+    /// l'historique du SERVEUR (qui contient les corrections faites en ligne), dans les bornes du launcher
+    /// (30 versions ; les plus anciennes retirées si l'ensemble est trop long).
+    /// Sans manifest en ligne : les notes du manifest reçu.
+    /// </summary>
+    private static JsonArray? MergeChangelog(JsonObject uploaded, JsonObject? current, string version)
+    {
+        var received = ChangelogStore.ChangelogArray(uploaded);
+        if (current is null) return received?.DeepClone().AsArray();
+
+        static bool Is(JsonNode? node, string version) =>
+            node is JsonObject entry && PublishedFiles.StringValue(entry, "version") == version;
+
+        var history = ChangelogStore.ChangelogArray(current) ?? new JsonArray();
+        var merged = new JsonArray();
+        var head = received?.FirstOrDefault(n => Is(n, version)) ?? history.FirstOrDefault(n => Is(n, version));
+        if (head is not null) merged.Add(head.DeepClone());
+        foreach (var entry in history)
+        {
+            if (merged.Count >= ChangelogLimits.MaxEntries) break;
+            if (entry is JsonObject && !Is(entry, version)) merged.Add(entry.DeepClone());
+        }
+        // Budget de tout l'historique (contrôle de lecture en même temps : une entrée illisible empêche la publication).
+        while (merged.Count > 1 &&
+               ChangelogStore.Entries(merged).OfType<ChangelogEntry>().Sum(ChangelogLimits.DisplayedItems) > ChangelogLimits.MaxTotalItems)
+            merged.RemoveAt(merged.Count - 1);
+        return merged;
+    }
+
+    /// <summary>Empreinte du manifest en ligne SANS les notes (fichiers, archive, version…) ; vide s'il n'existe pas.</summary>
+    private static string ContentSignature(JsonObject? root)
+    {
+        if (root is null) return "";
+        var copy = root.DeepClone().AsObject();
+        PublishedFiles.SetProperty(copy, "changelog", null);
+        return PublishedFiles.Sha256(System.Text.Encoding.UTF8.GetBytes(copy.ToJsonString()));
+    }
+
+    // ================================================================== Plan (après réception du manifest)
+
+    /// <summary>Manifest complet : contrôle, puis liste des objets et de l'archive à envoyer.</summary>
+    private void EnsurePlan(PublicationRecord record)
+    {
+        if (record.Plan is not null) return;
+        var staging = Staging(record);
+        var manifest = Path.Combine(staging, "manifest.json");
+        if (!File.Exists(manifest)) return;
+
+        var (manifestPath, gameId) = Locate(record.GameId);
+        var gameDirectory = Path.GetDirectoryName(manifestPath)!;
+        var errors = new List<string>();
+        var summary = ManifestCheck.Check(File.ReadAllBytes(manifest), gameId, record.Version, errors);
+        if (summary is null)
+        {
+            Delete(record); // manifest refusé : la publication est abandonnée (à refaire avec un manifest corrigé)
+            throw ApiRejection.BadRequest("Manifest refusé : " + string.Join(" ", errors.Take(5)) +
+                                          (errors.Count > 5 ? $" (+{errors.Count - 5} autres)" : ""));
+        }
+
+        var pending = summary.Objects
+            .Where(o => !ObjectPresent(Path.Combine(gameDirectory, ManifestCheck.ObjectPath(o.Key)), o.Value))
+            .ToDictionary(o => o.Key, o => o.Value, StringComparer.Ordinal);
+        // Archive déjà en ligne (même nom, même taille, même empreinte DANS le manifest en ligne) : pas renvoyée.
+        // Aucune lecture du fichier (plusieurs Go) pendant la requête.
+        var archiveTarget = new FileInfo(Path.Combine(gameDirectory, summary.ArchiveName));
+        var archiveNeeded = !(archiveTarget.Exists && archiveTarget.LinkTarget is null && archiveTarget.Length == summary.ArchiveSize &&
+                              PublishedArchive(manifestPath, gameId) is { } online &&
+                              string.Equals(online.Name, summary.ArchiveName, StringComparison.Ordinal) && online.Sha256 == summary.ArchiveSha256);
+
+        var needed = pending.Values.Sum() + (archiveNeeded ? summary.ArchiveSize : 0);
+        var free = new DriveInfo(gameDirectory).AvailableFreeSpace;
+        if (free < needed + FreeSpaceMargin)
+            throw new ApiRejection(507, ApiErrorCodes.InsufficientStorage,
+                $"Espace disque insuffisant sur le serveur : {needed / (1024 * 1024)} Mo à recevoir, {free / (1024 * 1024)} Mo libres.");
+
+        Save(record with
+        {
+            Plan = new PublicationPlan
+            {
+                ArchiveName = summary.ArchiveName,
+                ArchiveSize = summary.ArchiveSize,
+                ArchiveSha256 = summary.ArchiveSha256,
+                ArchiveNeeded = archiveNeeded,
+                Pending = pending,
+                ObjectCount = summary.Objects.Count,
+                ObjectsOnServer = summary.Objects.Count - pending.Count
+            }
+        });
+    }
+
+    /// <summary>Archive référencée par le manifest en ligne (nom, empreinte), sans la lire.</summary>
+    private static (string Name, string Sha256)? PublishedArchive(string manifestPath, string gameId)
+    {
+        var bytes = PublishedFiles.ReadManifest(manifestPath);
+        if (bytes is null) return null;
+        var root = ChangelogStore.Parse(bytes, gameId);
+        if (PublishedFiles.Property(root, "archive") is not JsonObject archive) return null;
+        var name = PublishedFiles.StringValue(archive, "url");
+        var sha = PublishedFiles.StringValue(archive, "sha256");
+        return name is null || sha is null ? null : (name, sha.ToLowerInvariant());
+    }
+
+    private PublicationPlan RequirePlan(PublicationRecord record)
+    {
+        EnsurePlan(record);
+        return Current(record.Id).Plan ?? throw ApiRejection.Conflict("Envoyez d'abord le manifest.");
+    }
+
+    private PublicationState State(PublicationRecord record, bool resumed)
+    {
+        var staging = Staging(record);
+        var manifestDone = File.Exists(Path.Combine(staging, "manifest.json"));
+        var plan = record.Plan;
+        var pending = new List<string>();
+        var partial = new Dictionary<string, long>(StringComparer.Ordinal);
+        long archiveReceived = 0;
+        var archiveComplete = false;
+        if (plan is not null)
+        {
+            var (manifestPath, _) = Locate(record.GameId);
+            var gameDirectory = Path.GetDirectoryName(manifestPath)!;
+            var objects = Path.Combine(staging, "objects");
+            foreach (var (sha, size) in plan.Pending)
+            {
+                if (File.Exists(Path.Combine(objects, sha + ".bin")) ||
+                    ObjectPresent(Path.Combine(gameDirectory, ManifestCheck.ObjectPath(sha)), size))
+                    continue;
+                pending.Add(sha);
+                var part = new FileInfo(Path.Combine(objects, sha + ".part"));
+                if (part.Exists && part.Length > 0) partial[sha] = part.Length;
+            }
+            archiveComplete = !plan.ArchiveNeeded || File.Exists(Path.Combine(staging, "archive.zip"));
+            archiveReceived = archiveComplete ? plan.ArchiveSize : Length(Path.Combine(staging, "archive.part"));
+        }
+
+        return new PublicationState
+        {
+            PublicationId = record.Id,
+            GameId = record.GameId,
+            Version = record.Version,
+            PublishedVersion = record.PublishedVersion,
+            Resumed = resumed,
+            ManifestSize = record.ManifestSize,
+            ManifestReceived = manifestDone ? record.ManifestSize : Length(Path.Combine(staging, "manifest.part")),
+            ManifestAccepted = plan is not null,
+            ObjectCount = plan?.ObjectCount ?? 0,
+            ObjectsOnServer = plan?.ObjectsOnServer ?? 0,
+            PendingObjects = pending,
+            PartialObjects = partial,
+            ArchiveName = plan?.ArchiveName,
+            ArchiveSize = plan?.ArchiveSize ?? 0,
+            ArchiveReceived = archiveReceived,
+            ArchiveComplete = archiveComplete,
+            ExpiresAt = LastActivity(record.Id) + PublishingLimits.IdleExpiry
+        };
+    }
+
+    // ================================================================== Réception d'un fichier
+
+    /// <summary>
+    /// Ajoute un morceau à la suite de ce qui a été reçu (position vérifiée), puis vérifie l'empreinte
+    /// quand le fichier est complet (calculée au fil des morceaux ; recalculée après un redémarrage).
+    /// </summary>
+    private ChunkResult Append(string partPath, string donePath, long offset, byte[] data, long size, string sha256, string what)
+    {
+        if (File.Exists(donePath)) return new ChunkResult { Received = size, Complete = true };
+        var received = Length(partPath);
+        if (offset != received)
+            throw ApiRejection.Conflict($"Position d'envoi {offset} inattendue ({what} : {received} octets déjà reçus).", ApiErrorCodes.OffsetMismatch);
+        if (received + data.LongLength > size) throw ApiRejection.BadRequest($"Données en trop ({what} : {size} octets attendus).");
+        if (data.Length == 0 && size > 0) throw ApiRejection.BadRequest("Morceau vide.");
+
+        var options = new FileStreamOptions { Mode = FileMode.Append, Access = FileAccess.Write, Share = FileShare.None };
+        if (!OperatingSystem.IsWindows()) options.UnixCreateMode = PrivateFile;
+        using (var stream = new FileStream(partPath, options))
+        {
+            stream.Write(data);
+            stream.Flush(flushToDisk: true);
+        }
+
+        HashProgress? progress;
+        if (received == 0)
+        {
+            RemoveHash(partPath);
+            progress = _hashes[partPath] = new HashProgress();
+        }
+        else if (!_hashes.TryGetValue(partPath, out progress) || progress.Offset != received)
+        {
+            RemoveHash(partPath);
+            progress = null;
+        }
+        progress?.Add(data);
+        received += data.Length;
+        if (received < size) return new ChunkResult { Received = received };
+
+        var actual = progress is not null && progress.Offset == size ? progress.Finish() : HashFile(partPath);
+        RemoveHash(partPath);
+        if (actual != sha256)
+        {
+            PublishedFiles.TryDelete(partPath);
+            throw ApiRejection.BadRequest($"Empreinte différente pour {what} : fichier abîmé ou modifié pendant l'envoi ; il sera renvoyé.");
+        }
+        File.Move(partPath, donePath, overwrite: true);
+        return new ChunkResult { Received = size, Complete = true };
+    }
+
+    private void RemoveHash(string key)
+    {
+        if (_hashes.TryRemove(key, out var progress)) progress.Dispose();
+    }
+
+    private sealed class HashProgress : IDisposable
+    {
+        private readonly IncrementalHash _hash = IncrementalHash.CreateHash(HashAlgorithmName.SHA256);
+        public long Offset { get; private set; }
+
+        public void Add(byte[] data)
+        {
+            _hash.AppendData(data);
+            Offset += data.Length;
+        }
+
+        public string Finish() => Convert.ToHexString(_hash.GetHashAndReset()).ToLowerInvariant();
+
+        public void Dispose() => _hash.Dispose();
+    }
+
+    // ================================================================== Enregistrements, dépôt
+
+    public sealed record PublicationRecord
+    {
+        public string Id { get; init; } = "";
+        public string GameId { get; init; } = "";
+        public string Version { get; init; } = "";
+        public string ManifestSha256 { get; init; } = "";
+        public long ManifestSize { get; init; }
+        public Guid AdminId { get; init; }
+        public string AdminName { get; init; } = "";
+        public DateTimeOffset CreatedAt { get; init; }
+
+        /// <summary>Version en ligne au début (vide : aucune).</summary>
+        public string PublishedVersion { get; init; } = "";
+
+        /// <summary>Empreinte du manifest en ligne SANS les notes, au début : la mise en ligne est refusée si elle a changé.</summary>
+        public string PublishedContentSha256 { get; init; } = "";
+
+        public PublicationPlan? Plan { get; init; }
+    }
+
+    public sealed record PublicationPlan
+    {
+        public string ArchiveName { get; init; } = "";
+        public long ArchiveSize { get; init; }
+        public string ArchiveSha256 { get; init; } = "";
+        public bool ArchiveNeeded { get; init; }
+
+        /// <summary>Objets absents du serveur quand le manifest a été reçu (empreinte → taille).</summary>
+        public Dictionary<string, long> Pending { get; init; } = new(StringComparer.Ordinal);
+
+        public int ObjectCount { get; init; }
+        public int ObjectsOnServer { get; init; }
+    }
+
+    /// <summary>Publication terminée : résultat gardé 24 h (réponse perdue, nouvel essai).</summary>
+    public sealed record PublicationDone
+    {
+        public string Id { get; init; } = "";
+        public Guid AdminId { get; init; }
+        public PublicationResult Result { get; init; } = new();
+        public DateTimeOffset At { get; init; }
+    }
+
+    private (string Path, string GameId) Locate(string gameId)
+    {
+        foreach (var (key, path) in _manifests)
+            if (string.Equals(key, gameId, StringComparison.OrdinalIgnoreCase))
+                return (path, key);
+        throw PublishedFiles.NotConfigured(gameId, "Publication");
+    }
+
+    /// <summary>Publication de cet administrateur, encore valable (sinon 404/403).</summary>
+    private PublicationRecord Find(string id, Guid adminId)
+    {
+        if (!PublishingLimits.IsValidPublicationId(id)) throw ApiRejection.NotFound("Publication introuvable.");
+        CleanUp(force: false);
+        var record = Load(id) ?? throw ApiRejection.NotFound("Publication introuvable (terminée, abandonnée ou expirée).");
+        if (record.AdminId != adminId)
+            throw new ApiRejection(403, ApiErrorCodes.Forbidden, $"Cette publication a été lancée par {record.AdminName}.");
+        return record;
+    }
+
+    /// <summary>Relue sous le verrou : abandonnée entre-temps → 404.</summary>
+    private PublicationRecord Current(string id) =>
+        Load(id) ?? throw ApiRejection.NotFound("Publication introuvable (terminée, abandonnée ou expirée).");
+
+    private string RecordPath(string id) => Path.Combine(_recordsDirectory, id + ".json");
+
+    private string DonePath(string id) => Path.Combine(_recordsDirectory, id + DoneSuffix + ".json");
+
+    private PublicationRecord? Load(string id) => Read<PublicationRecord>(RecordPath(id));
+
+    private PublicationDone? LoadDone(string id) => Read<PublicationDone>(DonePath(id));
+
+    private static T? Read<T>(string path) where T : class
+    {
+        if (!File.Exists(path)) return null;
+        try
+        {
+            return JsonSerializer.Deserialize<T>(File.ReadAllText(path), ApiJson.Options);
+        }
+        catch (Exception ex) when (ex is JsonException or IOException)
+        {
+            return null;
+        }
+    }
+
+    private IEnumerable<PublicationRecord> Records()
+    {
+        if (!Directory.Exists(_recordsDirectory)) yield break;
+        foreach (var file in Directory.GetFiles(_recordsDirectory, "*.json"))
+        {
+            var id = Path.GetFileNameWithoutExtension(file);
+            if (PublishingLimits.IsValidPublicationId(id) && Load(id) is { } record) yield return record;
+        }
+    }
+
+    private void Save(PublicationRecord record)
+    {
+        SecureFiles.EnsureDirectory(_recordsDirectory);
+        SecureFiles.WriteAllTextAtomic(RecordPath(record.Id), JsonSerializer.Serialize(record, ApiJson.Options), keepBackup: false);
+    }
+
+    private void SaveDone(PublicationDone done)
+    {
+        SecureFiles.EnsureDirectory(_recordsDirectory);
+        SecureFiles.WriteAllTextAtomic(DonePath(done.Id), JsonSerializer.Serialize(done, ApiJson.Options), keepBackup: false);
+    }
+
+    /// <summary>Dernier envoi : date de modification de l'enregistrement (mise à jour à chaque morceau).</summary>
+    private DateTimeOffset LastActivity(string id)
+    {
+        var path = RecordPath(id);
+        return File.Exists(path) ? new DateTimeOffset(File.GetLastWriteTimeUtc(path), TimeSpan.Zero) : DateTimeOffset.MinValue;
+    }
+
+    private void Touch(string id)
+    {
+        try
+        {
+            File.SetLastWriteTimeUtc(RecordPath(id), _time.GetUtcNow().UtcDateTime);
+        }
+        catch (IOException)
+        {
+            // simple indication d'activité
+        }
+    }
+
+    private string Staging(PublicationRecord record) =>
+        Path.Combine(Path.GetDirectoryName(Locate(record.GameId).Path)!, StagingPrefix + record.Id);
+
+    private string StagingObjects(PublicationRecord record)
+    {
+        var objects = Path.Combine(Staging(record), "objects");
+        if (!Directory.Exists(objects)) CreatePrivateDirectory(objects);
+        return objects;
+    }
+
+    private void CreateStaging(PublicationRecord record)
+    {
+        var staging = Staging(record);
+        if (new DirectoryInfo(Path.GetDirectoryName(staging)!).LinkTarget is not null)
+            throw new ManifestWriteRefusedException("le dossier du jeu est un lien symbolique.");
+        CreatePrivateDirectory(staging);
+    }
+
+    private static void CreatePrivateDirectory(string path)
+    {
+        if (OperatingSystem.IsWindows()) Directory.CreateDirectory(path);
+        else Directory.CreateDirectory(path, PrivateDirectory);
+    }
+
+    private void Delete(PublicationRecord record)
+    {
+        foreach (var key in _hashes.Keys.Where(k => k.Contains(StagingPrefix + record.Id, StringComparison.Ordinal)).ToList())
+            RemoveHash(key);
+        try
+        {
+            var staging = Staging(record);
+            if (Directory.Exists(staging)) Directory.Delete(staging, recursive: true);
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or ApiRejection)
+        {
+            // dépôt laissé : supprimé au prochain nettoyage
+        }
+        PublishedFiles.TryDelete(RecordPath(record.Id));
+        _locks.TryRemove(record.Id, out _);
+    }
+
+    /// <summary>
+    /// Publications sans envoi depuis 48 h, résultats de plus de 24 h et dépôts orphelins : supprimés
+    /// (au début d'une publication, et au plus toutes les 10 minutes lors des envois).
+    /// </summary>
+    private void CleanUp(bool force)
+    {
+        var now = _time.GetUtcNow();
+        lock (_locks)
+        {
+            if (!force && now - _lastCleanUp < CleanUpEvery) return;
+            _lastCleanUp = now;
+        }
+        var known = new HashSet<string>(StringComparer.Ordinal);
+        foreach (var record in Records().ToList())
+        {
+            if (now - LastActivity(record.Id) > PublishingLimits.IdleExpiry)
+                Lock(record.Id, () =>
+                {
+                    Delete(record);
+                    return 0;
+                });
+            else known.Add(record.Id);
+        }
+        if (Directory.Exists(_recordsDirectory))
+            foreach (var done in Directory.GetFiles(_recordsDirectory, "*" + DoneSuffix + ".json"))
+                if (now - new DateTimeOffset(File.GetLastWriteTimeUtc(done), TimeSpan.Zero) > DoneLifetime)
+                    PublishedFiles.TryDelete(done);
+        foreach (var manifest in _manifests.Values)
+        {
+            var directory = Path.GetDirectoryName(manifest)!;
+            if (!Directory.Exists(directory)) continue;
+            foreach (var staging in Directory.GetDirectories(directory, StagingPrefix + "*"))
+            {
+                var id = Path.GetFileName(staging)[StagingPrefix.Length..];
+                if (known.Contains(id) || now - Directory.GetLastWriteTimeUtc(staging) <= PublishingLimits.IdleExpiry) continue;
+                try
+                {
+                    Directory.Delete(staging, recursive: true);
+                }
+                catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+                {
+                    // nouvel essai au prochain nettoyage
+                }
+            }
+        }
+    }
+
+    private T Lock<T>(string id, Func<T> action)
+    {
+        lock (_locks.GetOrAdd(id, _ => new object())) return action();
+    }
+
+    private static bool ObjectPresent(string path, long size)
+    {
+        var info = new FileInfo(path);
+        return info.Exists && info.LinkTarget is null && info.Length == size;
+    }
+
+    private static long Length(string path)
+    {
+        var info = new FileInfo(path);
+        return info.Exists ? info.Length : 0;
+    }
+
+    private static string HashFile(string path)
+    {
+        using var stream = File.OpenRead(path);
+        return Convert.ToHexString(SHA256.HashData(stream)).ToLowerInvariant();
+    }
+
+    private static string Display(string version) => string.IsNullOrEmpty(version) ? "aucune" : version;
+}

server/GameLauncher.Server/Storage/PublishedFiles.cs

@@ -0,0 +1,281 @@
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.Encodings.Web;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using System.Text.Json.Serialization;
+using GameLauncher.Contracts.Dtos;
+using GameLauncher.Server.Hosting;
+
+namespace GameLauncher.Server.Storage;
+
+/// <summary>
+/// Fichiers PUBLICS d'un jeu (dossier servi par nginx : manifest.json, archive, objects/), communs aux
+/// notes de version (phase 4) et à la publication d'une version (phase 5) :
+///  • même verrou par jeu (une seule écriture du manifest à la fois, service et outils confondus) ;
+///  • même présentation JSON que ManifestBuilder ;
+///  • écriture atomique : fichier temporaire caché (refusé par nginx) dans le même dossier, puis renommage ;
+///  • droits : ceux du manifest existant (sinon 0640 avec le groupe du dossier setgid, ou 0644) ;
+///    refus si le dossier n'a pas le bit setgid alors que nginx lit les fichiers par leur groupe,
+///    ou si le manifest est un lien symbolique.
+/// </summary>
+internal static class PublishedFiles
+{
+    /// <summary>Taille maximale d'un manifest lu ou écrit (même borne que le launcher).</summary>
+    public const long MaxManifestBytes = 64L * 1024 * 1024;
+
+    public static readonly TimeSpan LockTimeout = TimeSpan.FromSeconds(10);
+
+    private const string HistoryFolder = "manifest-history";
+    private const int HistoryLength = 20;
+
+    private const UnixFileMode GroupReadable = UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.GroupRead;
+    private const UnixFileMode AllReadable = GroupReadable | UnixFileMode.OtherRead;
+
+    /// <summary>Même présentation que ManifestBuilder (indenté, camelCase, accents non échappés).</summary>
+    public static readonly JsonSerializerOptions ManifestJson = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        PropertyNameCaseInsensitive = true,
+        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+        WriteIndented = true,
+        Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
+        MaxDepth = 64
+    };
+
+    public static readonly JsonDocumentOptions ReadOptions = new()
+    {
+        CommentHandling = JsonCommentHandling.Skip,
+        AllowTrailingCommas = true,
+        MaxDepth = 64
+    };
+
+    /// <summary>Verrou d'écriture du manifest d'un jeu (fichier dans les données privées).</summary>
+    public static FileStream LockGame(string dataDirectory, string gameId) =>
+        SecureFiles.AcquireLock(Path.Combine(dataDirectory, $"manifest-{gameId.ToLowerInvariant()}.lock"), LockTimeout);
+
+    public static string Sha256(ReadOnlySpan<byte> bytes) => Convert.ToHexString(SHA256.HashData(bytes)).ToLowerInvariant();
+
+    public static ReadOnlySpan<byte> StripBom(byte[] bytes) =>
+        bytes.AsSpan().StartsWith(new byte[] { 0xEF, 0xBB, 0xBF }) ? bytes.AsSpan(3) : bytes;
+
+    /// <summary>Manifest publié (null s'il n'existe pas encore).</summary>
+    public static byte[]? ReadManifest(string path)
+    {
+        var info = new FileInfo(path);
+        if (!info.Exists) return null;
+        if (info.Length > MaxManifestBytes) throw new InvalidDataException("Manifest trop volumineux.");
+        return File.ReadAllBytes(path);
+    }
+
+    public static JsonObject ParseObject(ReadOnlySpan<byte> bytes, string what)
+    {
+        try
+        {
+            return JsonNode.Parse(bytes, documentOptions: ReadOptions) as JsonObject
+                   ?? throw new InvalidDataException($"{what} : objet JSON attendu.");
+        }
+        catch (Exception ex) when (ex is JsonException or ArgumentException)
+        {
+            throw new InvalidDataException($"{what} illisible : {ex.Message}", ex);
+        }
+    }
+
+    /// <summary>Propriété d'un objet JSON, nom insensible à la casse (comme pour le launcher).</summary>
+    public static JsonNode? Property(JsonObject node, string name)
+    {
+        foreach (var (key, value) in node)
+            if (string.Equals(key, name, StringComparison.OrdinalIgnoreCase))
+                return value;
+        return null;
+    }
+
+    public static string? StringValue(JsonObject node, string name) =>
+        Property(node, name) is JsonValue v && v.TryGetValue<string>(out var text) ? text : null;
+
+    /// <summary>Remplace une propriété (toutes casses confondues) ; null la retire.</summary>
+    public static void SetProperty(JsonObject node, string name, JsonNode? value)
+    {
+        foreach (var existing in node.Select(p => p.Key).Where(k => string.Equals(k, name, StringComparison.OrdinalIgnoreCase)).ToList())
+            node.Remove(existing);
+        if (value is not null) node[name] = value;
+    }
+
+    public static byte[] Serialize(JsonObject root)
+    {
+        var bytes = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false).GetBytes(root.ToJsonString(ManifestJson));
+        if (bytes.LongLength > MaxManifestBytes) throw ApiRejection.BadRequest("Manifest trop volumineux.");
+        return bytes;
+    }
+
+    /// <summary>Copie de l'ancien manifest dans les données privées (aide à la récupération ; 20 dernières).</summary>
+    public static void Backup(string dataDirectory, string gameId, byte[] bytes)
+    {
+        try
+        {
+            var directory = Path.Combine(dataDirectory, HistoryFolder, gameId.ToLowerInvariant());
+            SecureFiles.EnsureDirectory(Path.Combine(dataDirectory, HistoryFolder));
+            SecureFiles.EnsureDirectory(directory);
+            var name = $"manifest-{DateTime.UtcNow:yyyyMMdd-HHmmss}-{Sha256(bytes)[..8]}.json";
+            SecureFiles.WriteAllTextAtomic(Path.Combine(directory, name), Encoding.UTF8.GetString(StripBom(bytes)), keepBackup: false);
+            foreach (var old in Directory.GetFiles(directory, "manifest-*.json").OrderByDescending(f => f, StringComparer.Ordinal).Skip(HistoryLength))
+                File.Delete(old);
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            // La copie est une aide : son échec n'empêche pas l'écriture.
+        }
+    }
+
+    /// <summary>
+    /// Droits d'un nouveau fichier public du dossier : ceux du manifest existant, sinon lisible par le
+    /// groupe du dossier (setgid) ou par tous. Refus si nginx risque de perdre l'accès.
+    /// </summary>
+    public static UnixFileMode PublicMode(string directory, string? referenceFile)
+    {
+        if (OperatingSystem.IsWindows()) return AllReadable;
+        var directoryMode = File.GetUnixFileMode(directory);
+        var setgid = directoryMode.HasFlag(UnixFileMode.SetGroup);
+        var mode = referenceFile is not null && File.Exists(referenceFile)
+            ? File.GetUnixFileMode(referenceFile)
+            : setgid ? GroupReadable : AllReadable;
+        // Le fichier créé appartient au compte du service, avec le groupe du dossier SEULEMENT si celui-ci
+        // a le bit setgid : sinon nginx (groupe www-data) ne pourrait plus lire un fichier lisible par le groupe.
+        if (!mode.HasFlag(UnixFileMode.OtherRead) && mode.HasFlag(UnixFileMode.GroupRead) && !setgid)
+            throw new ManifestWriteRefusedException(
+                "le dossier du jeu n'a pas le bit setgid (chmod g+s) : les fichiers écrits ne seraient plus lisibles par nginx.");
+        // Fichier existant : ses droits sont repris tels quels (rw des comptes compris) ; nouveau fichier : lecture.
+        return mode & (UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute |
+                       UnixFileMode.GroupRead | UnixFileMode.GroupWrite | UnixFileMode.GroupExecute |
+                       UnixFileMode.OtherRead | UnixFileMode.OtherWrite | UnixFileMode.OtherExecute);
+    }
+
+    /// <summary>
+    /// Sous-dossier public (objects, objects/ab) : droits du dossier du jeu, fixés explicitement (le masque
+    /// du service, UMask=0077, retirerait l'accès de nginx). Refus s'il s'agit d'un lien symbolique.
+    /// <paramref name="keepSetGid"/> : dossier qui en contiendra d'autres (objects) ; son bit setgid doit être
+    /// conservé pour que les sous-dossiers créés ensuite aient le groupe lu par nginx. (Un dossier
+    /// « feuille » garde de toute façon le groupe hérité à sa création, comme les fichiers qui y sont déplacés.)
+    /// </summary>
+    public static void EnsurePublicDirectory(string path, string gameDirectory, bool keepSetGid)
+    {
+        var info = new DirectoryInfo(path);
+        if (info.LinkTarget is not null)
+            throw new ManifestWriteRefusedException($"« {Path.GetFileName(path)} » est un lien symbolique dans le dossier du jeu.");
+        if (info.Exists) return;
+        if (OperatingSystem.IsWindows())
+        {
+            Directory.CreateDirectory(path);
+            return;
+        }
+        var gameMode = File.GetUnixFileMode(gameDirectory);
+        var permissions = gameMode & PermissionBits;
+        var needSetGid = keepSetGid && gameMode.HasFlag(UnixFileMode.SetGroup);
+        // Jamais de bit spécial demandé : systemd l'interdit au service (RestrictSUIDSGID=yes, refus EPERM).
+        // Dans un dossier setgid, le noyau transmet de lui-même le bit setgid et le groupe (www-data).
+        Directory.CreateDirectory(path, permissions);
+        if ((File.GetUnixFileMode(path) & PermissionBits) != permissions) // réduits par le masque du service (UMask=0077)
+        {
+            try
+            {
+                // Fixer les droits retire le setgid hérité : sans conséquence pour un dossier « feuille » (son
+                // groupe reste celui hérité) ; « objects » doit le redemander, ce que systemd peut refuser.
+                File.SetUnixFileMode(path, needSetGid ? permissions | UnixFileMode.SetGroup : permissions);
+            }
+            catch (UnauthorizedAccessException) when (needSetGid)
+            {
+                // traité ci-dessous
+            }
+        }
+        // Sans setgid (ou si le compte du service n'appartient pas au groupe du dossier, Linux le retire), les
+        // sous-dossiers créés ensuite n'auraient plus le groupe lu par nginx.
+        if (needSetGid && File.GetUnixFileMode(path) != (permissions | UnixFileMode.SetGroup))
+        {
+            TryDeleteDirectory(path);
+            throw new ManifestWriteRefusedException(
+                "le dossier « objects » n'existe pas encore et le service ne peut pas le créer avec le bit setgid et l'accès de nginx : " +
+                "créez-le sur le VPS (server/deploy/LISEZMOI.md, étape 3 quater).");
+        }
+    }
+
+    /// <summary>Droits rwx des trois classes, sans setuid, setgid ni sticky.</summary>
+    private const UnixFileMode PermissionBits =
+        UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute |
+        UnixFileMode.GroupRead | UnixFileMode.GroupWrite | UnixFileMode.GroupExecute |
+        UnixFileMode.OtherRead | UnixFileMode.OtherWrite | UnixFileMode.OtherExecute;
+
+    private static void TryDeleteDirectory(string path)
+    {
+        try
+        {
+            Directory.Delete(path);
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            // laissé : vide, sans conséquence
+        }
+    }
+
+    /// <summary>
+    /// Remplace (ou crée) le manifest publié. <paramref name="expectedSha256"/> : empreinte du manifest
+    /// sur lequel l'écriture a été préparée (null : il ne devait pas exister) ; revérifiée juste avant le
+    /// renommage, pour ne jamais écraser un envoi (WinSCP…) fait entre-temps.
+    /// </summary>
+    public static void WriteManifest(string path, byte[] bytes, string? expectedSha256, Func<ApiRejection> conflict)
+    {
+        var directory = Path.GetDirectoryName(path)!;
+        if (new FileInfo(path).LinkTarget is not null)
+            throw new ManifestWriteRefusedException("le manifest publié est un lien symbolique : le remplacer romprait le lien.");
+        var mode = PublicMode(directory, path);
+        var temp = TempPath(path);
+        try
+        {
+            WriteNew(temp, bytes, mode);
+            var current = ReadManifest(path);
+            if (current is null ? expectedSha256 is not null : !string.Equals(Sha256(current), expectedSha256, StringComparison.OrdinalIgnoreCase))
+                throw conflict();
+            File.Move(temp, path, overwrite: true);
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or ApiRejection)
+        {
+            TryDelete(temp);
+            if (ex is ApiRejection or ManifestWriteRefusedException) throw;
+            throw new IOException($"Écriture du manifest impossible ({path}) : {ex.Message}", ex);
+        }
+    }
+
+    /// <summary>Fichier temporaire caché du même dossier (nginx refuse les noms commençant par un point).</summary>
+    public static string TempPath(string path) =>
+        Path.Combine(Path.GetDirectoryName(path)!, $".{Path.GetFileName(path)}.{Guid.NewGuid():N}.tmp");
+
+    public static void WriteNew(string path, ReadOnlySpan<byte> bytes, UnixFileMode mode)
+    {
+        using (var stream = new FileStream(path, new FileStreamOptions { Mode = FileMode.CreateNew, Access = FileAccess.Write, Share = FileShare.None }))
+        {
+            stream.Write(bytes);
+            stream.Flush(flushToDisk: true);
+        }
+        if (!OperatingSystem.IsWindows()) File.SetUnixFileMode(path, mode);
+    }
+
+    public static void TryDelete(string path)
+    {
+        try
+        {
+            File.Delete(path);
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            // laissé en place : sans conséquence (nom unique, caché)
+        }
+    }
+
+    public static ApiRejection NotConfigured(string gameId, string what) => new(503, ApiErrorCodes.NotConfigured,
+        $"{what} impossible pour « {gameId} » : manifest non configuré sur le serveur (LauncherApi:Games:{gameId}:ManifestFile).");
+}
+
+/// <summary>Écriture refusée par précaution (configuration du dossier à corriger) ; message sans chemin.</summary>
+public sealed class ManifestWriteRefusedException : IOException
+{
+    public ManifestWriteRefusedException(string message) : base(message) { }
+}

server/GameLauncher.Server/appsettings.json

@@ -24,8 +24,21 @@
     },
     "ChallengeLifetimeSeconds": 60,
     "InvitationLifetimeHours": 24,
+    // Catalogue des jeux (phase 3) : fichier public écrit par le service, servi par nginx.
+    // Vide : publication désactivée. À renseigner dans appsettings.Production.json sur le VPS
+    // (voir server/deploy/LISEZMOI.md), ex. « /srv/exovival/www/catalog/catalog.json ».
+    "Catalog": {
+      "PublicFile": "",
+      "PublicUrl": ""
+    },
+    // Notes de version modifiables en ligne (phase 4) : manifest.json publié de chaque jeu, par
+    // identifiant (GameId de launcher.json). À renseigner dans appsettings.Production.json sur le VPS
+    // (voir server/deploy/LISEZMOI.md), ex. « "EZR": { "ManifestFile": "/srv/exovival/www/exovivalzombie/manifest.json" } ».
+    "Games": {},
     "Limits": {
       "RequestsPerMinute": 300,
+      // Morceaux de 4 Mo envoyés pendant une publication (à la place de RequestsPerMinute) : 1500 ≈ 100 Mo/s.
+      "PublicationUploadsPerMinute": 1500,
       "AuthPerMinute": 20,
       "EnrollmentsPerHour": 10,
       "MaxActiveInvitations": 20,

server/deploy/LISEZMOI.md

@@ -65,6 +65,168 @@ Le script installe les binaires dans `/opt/launcher-api` (propriétaire root), l
    différente de l'adresse utilisée, corrige `PublicOrigin` (étape 2) : sinon toutes les
    signatures seront refusées.
 
+## 3 bis. Catalogue des jeux (VPS)
+
+La page **Jeux** du menu d'administration publie `catalog.json` (nom affiché, accroche, description,
+liens, thème, images, ordre des jeux), que les launchers des joueurs lisent au démarrage à l'adresse
+`catalogUrl` de `launcher.json`. Le serveur l'écrit dans **un seul** dossier, servi par nginx, séparé
+de ses données privées. Exemple ci-dessous avec le site de « Serveur de téléchargement Exovival »
+(`/srv/exovival/www`) : adapte le chemin à la racine réelle de ton site.
+
+1. Crée le dossier public (propriétaire `deploy`, groupe `www-data` pour nginx) :
+
+   ```
+   sudo install -d -m 2750 -o deploy -g www-data /srv/exovival/www/catalog /srv/exovival/www/catalog/images
+   ```
+2. Indique le fichier au serveur dans `/opt/launcher-api/appsettings.Production.json` (à fusionner
+   avec tes autres réglages) :
+
+   ```
+   { "LauncherApi": { "Catalog": { "PublicFile": "/srv/exovival/www/catalog/catalog.json" } } }
+   ```
+
+   L'adresse publique est déduite de `PublicOrigin` (`https://launcher.lanisys.fr/catalog/catalog.json`) ;
+   sinon, ajoute `"PublicUrl"`. Elle doit être **identique** à `catalogUrl` dans `launcher.json`.
+   Le serveur refuse de démarrer si le dossier n'existe pas, ou si le dossier public et
+   `/var/lib/launcher-api` sont l'un dans l'autre.
+3. Autorise le service à écrire dans ce dossier, et seulement lui (le reste du système reste en
+   lecture seule) :
+
+   ```
+   sudo mkdir -p /etc/systemd/system/launcher-api.service.d
+   sudo nano /etc/systemd/system/launcher-api.service.d/catalog.conf
+   ```
+
+   Colle le contenu de `server/deploy/launcher-api-catalog.conf` (ligne `ReadWritePaths=` adaptée),
+   puis :
+
+   ```
+   sudo systemctl daemon-reload && sudo systemctl restart launcher-api
+   ```
+
+   Ce fichier est conservé lors des mises à jour du serveur.
+4. nginx : colle le bloc `location = /catalog/catalog.json { … }` de `server/deploy/nginx-catalog.conf`
+   dans le bloc HTTPS du site, avant `location / {`, puis `sudo nginx -t && sudo systemctl reload nginx`.
+5. Publie depuis la page **Jeux**, puis vérifie depuis ton PC :
+
+   ```
+   PS> curl.exe -sI https://launcher.lanisys.fr/catalog/catalog.json
+   ```
+
+   Attendu : `200 OK` et `Cache-Control: no-cache, no-store, must-revalidate`. Le fichier est en
+   lecture seule pour tous (`-rw-r--r--`) : seul le service le modifie.
+
+**Images** (icône, fond) : envoie-les en SFTP (compte `deploy`) dans `www/catalog/images/`, en PNG
+ou JPEG de 4 Mo au plus, puis saisis leur adresse dans la page Jeux, par ex.
+`https://launcher.lanisys.fr/catalog/images/fond-halloween.jpg`. Les launchers gardent chaque image
+en cache : pour changer une image, envoie-la sous un **nouveau nom**. Les images d'un autre
+serveur sont refusées.
+
+Sans l'étape 2, la page Jeux reste consultable mais la publication est désactivée (bandeau orange).
+
+## 3 ter. Notes de version modifiables en ligne (VPS)
+
+La page **Notes de version** du menu d'administration corrige les notes des versions déjà publiées,
+directement dans le `manifest.json` du jeu (rien d'autre n'y est modifié). Exemple ci-dessous avec le
+dossier du jeu de « Serveur de téléchargement Exovival » (`/srv/exovival/www/exovivalzombie`) : adapte
+le chemin au dossier réel, celui de `manifestUrl` dans `launcher.json`.
+
+> **Compromis de sécurité** : le service pourra écrire dans le dossier du jeu (il remplace le manifest
+> par renommage dans ce dossier). Un service compromis pourrait donc modifier les fichiers du jeu de ce
+> dossier. L'autorisation se limite à ce seul dossier ; sans cette étape, rien n'est modifiable en ligne.
+
+1. Vérifie que le dossier du jeu a le **bit setgid** (le `s` de `drwxr-s---`), pour que le manifest
+   remplacé garde le groupe `www-data` lu par nginx :
+
+   ```
+   stat -c '%A %U:%G' /srv/exovival/www/exovivalzombie
+   sudo chmod g+s /srv/exovival/www/exovivalzombie      # seulement s'il manque
+   ```
+
+   Sans lui, le serveur refuse la modification plutôt que de rendre le manifest illisible.
+2. Indique le manifest au serveur dans `/opt/launcher-api/appsettings.Production.json` (à fusionner
+   avec tes autres réglages ; la clé est le `gameId` de `launcher.json`) :
+
+   ```
+   { "LauncherApi": { "Games": { "EZR": { "ManifestFile": "/srv/exovival/www/exovivalzombie/manifest.json" } } } }
+   ```
+3. Autorise le service à écrire dans ce dossier, et seulement lui :
+
+   ```
+   sudo nano /etc/systemd/system/launcher-api.service.d/games.conf
+   ```
+
+   Colle le contenu de `server/deploy/launcher-api-games.conf` (ligne `ReadWritePaths=` adaptée,
+   une par jeu), puis :
+
+   ```
+   sudo systemctl daemon-reload && sudo systemctl restart launcher-api
+   ```
+
+   Ce fichier est conservé lors des mises à jour du serveur.
+4. Sur ton PC, ajoute `--remote-manifest <adresse du manifest>` à ton script de publication
+   (déjà dans `tools\publish-example.bat`) : sans lui, la publication suivante écraserait les notes
+   corrigées en ligne avec celles du `manifest.json` local.
+5. Teste : menu d'administration › **Notes de version**, corrige une faute, **Enregistrer**. L'ancien
+   manifest est copié dans `/var/lib/launcher-api/manifest-history/`.
+
+N'enregistre pas de notes pendant l'envoi d'une nouvelle version avec WinSCP : le serveur le détecte
+(empreinte du manifest) et refuse sans rien écraser ; recharge simplement la page ensuite.
+
+## 3 quater. Publier une version depuis le launcher (VPS)
+
+La page **Publier une version** du menu d'administration remplace l'envoi avec WinSCP : seuls les
+fichiers absents du serveur sont envoyés, l'envoi reprend après une coupure, et le manifest est mis
+en ligne en dernier. Prérequis : l'étape 3 ter (dossier du jeu déclaré dans `LauncherApi:Games`,
+complément `games.conf`, bit setgid).
+
+1. nginx : ajoute la zone de limite des envois dans `/etc/nginx/conf.d/securite.conf`, à côté de
+   `api_par_ip` (un envoi enchaîne plusieurs morceaux de 4 Mo par seconde ; avec la limite générale de
+   l'API, il serait bridé et ferait des pauses) :
+
+   ```
+   limit_req_zone $binary_remote_addr zone=publication_par_ip:10m rate=25r/s;
+   ```
+
+   Puis colle le bloc `location ^~ /api/v1/publications/ { … }` de `server/deploy/nginx-publications.conf`
+   dans le bloc HTTPS du site, à côté du bloc `/api/`, et recharge :
+
+   ```
+   sudo nginx -t && sudo systemctl reload nginx
+   ```
+
+   Seules ces routes acceptent des envois de 8 Mo ; le reste de l'API reste limité à 64 Ko. Vérifie
+   aussi que le site contient toujours la règle `location ~ /\. { deny all; }` : les fichiers en cours
+   d'envoi sont rangés dans un dossier caché (`.publish-…`) du dossier du jeu.
+2. Crée le dossier `objects` du jeu **et ses 256 sous-dossiers** (`00` à `ff`), avec le groupe et le bit
+   setgid du dossier du jeu (sans risque s'ils existent déjà : leurs droits sont simplement remis en état) :
+
+   ```
+   JEU=/srv/exovival/www/exovivalzombie
+   sudo install -d -m 2750 -o deploy -g www-data "$JEU/objects"
+   for i in $(seq 0 255); do sudo install -d -m 2750 -o deploy -g www-data "$JEU/objects/$(printf %02x $i)"; done
+   ```
+
+   Pourquoi : systemd interdit au service de demander le bit setgid (`RestrictSUIDSGID=yes`, gardé). Un
+   sous-dossier qui manquerait serait créé par le service en `drwxr-x---` (groupe `www-data`, lisible par
+   nginx) mais **sans setgid** : un fichier déposé ensuite dedans **avec WinSCP** prendrait le groupe
+   `deploy` et ne serait plus lisible par nginx. Relance la boucle si `stat` montre un `drwxr-x---`.
+3. Espace disque : l'envoi est stocké sur le même disque que le jeu jusqu'à la mise en ligne. Prévois la
+   taille de l'archive et des nouveaux fichiers (le serveur refuse l'envoi s'il manque de place).
+4. Teste : lance le .bat de publication (ManifestBuilder) sur ton PC, puis menu d'administration ›
+   **Publier une version** › « Choisir le manifest.json… » (dossier `--output`) › **Publier**.
+
+> **Déjà fait avant la correction des pauses ?** Ajoute la ligne `limit_req_zone … publication_par_ip …`
+> ci-dessus, remplace dans le bloc `/api/v1/publications/` du site `limit_req zone=api_par_ip burst=20 nodelay;`
+> par `limit_req zone=publication_par_ip burst=50 nodelay;`, recharge nginx, puis mets à jour le serveur
+> (étape 8) : il a désormais sa propre limite pour les envois (`LauncherApi:Limits:PublicationUploadsPerMinute`,
+> 1500 par minute par défaut, rien à ajouter dans `appsettings.Production.json`).
+
+Une publication interrompue (fermeture du launcher, coupure) reprend quand tu cliques de nouveau sur
+« Publier » avec le même dossier ; sans reprise, elle est supprimée au bout de 48 h. WinSCP reste
+possible, mais n'envoie pas une version avec les deux en même temps : le serveur refuse alors de
+mettre la sienne en ligne plutôt que d'écraser l'autre.
+
 ## 4. Créer ta clé d'administrateur (PC)
 
 Double-clique `tools\admin-key.bat`. Choisis une phrase de passe (12 caractères minimum). Il crée :
@@ -76,7 +238,13 @@ Double-clique `tools\admin-key.bat`. Choisis une phrase de passe (12 caractères
 
 Note l'**empreinte** affichée (`AB12 CD34 EF56 7890 1A2B`).
 
-> Phase 2 : le launcher saura créer la clé lui-même (Windows Hello / TPM) et importer ce fichier.
+> Depuis la phase 2, le launcher sait aussi créer la clé : menu d'administration (Ctrl+Maj+Alt+A,
+> ou 5 clics rapides sur le logo) › « J'ai une invitation », **sans code** → clé seule, même dossier,
+> même format. Une clé créée par `admin-key.bat` est reconnue par le launcher, et inversement.
+> Le launcher peut aussi créer la clé **dans la puce de sécurité (TPM) du PC** (non copiable,
+> code PIN) : il écrit alors `admin.tpmkey` (référence, sans secret) et `admin.pub` ; c'est ce
+> `.pub` qu'on déclare ci-dessous. Une clé TPM ne fonctionne que dans le launcher, sur ce PC
+> (`admin-key.bat` n'utilise que des clés fichier) : garde une clé fichier de secours (§ 9, `add-key`).
 
 ## 5. Te déclarer propriétaire (PC puis VPS, une seule fois)
 
@@ -102,12 +270,15 @@ Résultat attendu : `Connexion réussie : Nicolas (Propriétaire)` et la liste d
 
 ## 7. Ajouter un administrateur
 
-En attendant le menu d'administration du launcher (phases 2 et 6), avec `tools\admin-key.bat` :
+Depuis la phase 2, la personne invitée peut créer et enregistrer sa clé **dans le launcher** (menu
+d'administration › « J'ai une invitation », code collé) : l'étape 2 ci-dessous se fait alors sans
+ligne de commande, et le launcher affiche l'empreinte à te dicter. Inviter et approuver se font avec
+`tools\admin-key.bat` jusqu'à la page « Administrateurs » du launcher (phase 6) :
 
 1. **Toi** : `admin-key.bat invite --api https://launcher.lanisys.fr/api/ --name "Paul" --role editor`
    (rôles : `owner`, `admin`, `editor`, voir `docs/ADMIN-ARCHITECTURE.md` § 7). Transmets le code affiché (valable 24 h, usage unique).
-2. **Paul** : `admin-key.bat` (création de sa clé), puis
-   `admin-key.bat enroll --api https://launcher.lanisys.fr/api/ --code <code>` ; il te communique
+2. **Paul** : launcher › menu d'administration › « J'ai une invitation » (ou `admin-key.bat`, puis
+   `admin-key.bat enroll --api https://launcher.lanisys.fr/api/ --code <code>`) ; il te communique
    **par téléphone ou message** l'empreinte affichée.
 3. **Toi** : `admin-key.bat admins --api …` (repère l'identifiant de Paul et de sa clé), puis
    `admin-key.bat approve --api … --admin <id> --key-id <clé> --fingerprint "<empreinte dictée par Paul>"`.
@@ -123,7 +294,8 @@ d'autre ne peut approuver une clé à son nom. S'il a perdu tous ses PC : voir
 ## 8. Mettre à jour le serveur
 
 Refais les étapes 1 et 2. Les administrateurs, l'audit et `appsettings.Production.json` sont
-conservés ; les sessions ouvertes sont fermées (reconnexion). Si la nouvelle version ne démarre
+conservés, ainsi que les compléments systemd (`launcher-api.service.d/catalog.conf` et `games.conf`) ;
+les sessions ouvertes sont fermées (reconnexion). Si la nouvelle version ne démarre
 pas, le script remet la précédente en place.
 
 ## 9. Récupération (VPS)
@@ -132,6 +304,7 @@ pas, le script remet la précédente en place.
 |---|---|
 | Voir les administrateurs, clés et empreintes | `sudo -u deploy /opt/launcher-api/GameLauncher.Server list` |
 | PC perdu ou volé | `sudo -u deploy /opt/launcher-api/GameLauncher.Server revoke-key --key <identifiant>` |
+| Clé TPM supprimée dans le launcher (« Supprimer cette clé de la puce ») | Même commande `revoke-key`, avec l'identifiant affiché par le launcher |
 | Retirer un administrateur | `sudo -u deploy /opt/launcher-api/GameLauncher.Server revoke-admin --id <identifiant>` |
 | Un administrateur a perdu tous ses PC | Il crée une nouvelle clé et t'envoie son `.pub`, puis `sudo -u deploy /opt/launcher-api/GameLauncher.Server add-key --admin <identifiant> --public-key /tmp/paul.pub` (vérifie l'empreinte avec lui) |
 | Toutes tes clés perdues | Nouvelle clé (étape 4), puis `add-owner` (étape 5) ; révoque ensuite les anciennes clés |
@@ -171,6 +344,15 @@ recréer les administrateurs.
 ├─ admins.json (+ .bak)                administrateurs, clés publiques, invitations (empreintes)
 ├─ server-id                           identifiant aléatoire du serveur
 ├─ audit/audit-AAAA-MM.jsonl           journal d'audit
+├─ catalog.json (+ .bak)               catalogue publié (référence de la révision)
+├─ catalog-history/                    20 dernières versions publiées
+├─ manifest-history/<jeu>/             manifests remplacés (notes de version, publications ; 20 derniers)
+├─ publications/                       publications en cours (version, fichiers restant à envoyer)
 └─ data-protection/                    clés internes d'ASP.NET Core (inutilisées par l'API)
+/srv/exovival/www/catalog/             (exemple) dossier public servi par nginx (deploy:www-data, 2750)
+├─ catalog.json                        catalogue lu par les launchers (écrit par le service, 644)
+└─ images/                             images du catalogue (envoyées en SFTP)
 /etc/systemd/system/launcher-api.service
+/etc/systemd/system/launcher-api.service.d/catalog.conf   écriture du dossier public (conservé)
+/etc/systemd/system/launcher-api.service.d/games.conf     écriture du dossier de chaque jeu (conservé)
 ```

server/deploy/launcher-api-catalog.conf

@@ -0,0 +1,14 @@
+# =============================================================================
+#  Launcher API : autorisation d'écrire le catalogue des jeux (LISEZMOI.md, étape 3 bis).
+#    /etc/systemd/system/launcher-api.service.d/catalog.conf
+#
+#  Le service est enfermé en lecture seule (ProtectSystem=strict) : ce complément l'autorise à
+#  écrire dans UN SEUL dossier, celui du fichier public du catalogue (LauncherApi:Catalog:PublicFile).
+#  Fichier séparé : il est conservé lors des mises à jour du serveur (installer-api.sh remplace
+#  launcher-api.service, pas ce dossier).
+#
+#  Adapter le chemin au dossier réellement servi par nginx (exemple de la documentation ci-dessous),
+#  puis :  sudo systemctl daemon-reload && sudo systemctl restart launcher-api
+# =============================================================================
+[Service]
+ReadWritePaths=/srv/exovival/www/catalog

server/deploy/launcher-api-games.conf

@@ -0,0 +1,17 @@
+# =============================================================================
+#  Launcher API : autorisation de modifier le manifest.json des jeux (LISEZMOI.md, étape 3 ter).
+#    /etc/systemd/system/launcher-api.service.d/games.conf
+#
+#  Le service est enfermé en lecture seule (ProtectSystem=strict) : ce complément l'autorise à
+#  écrire dans le dossier de chaque jeu configuré (LauncherApi:Games:<id>:ManifestFile), et
+#  seulement là. Le remplacement du manifest se fait par renommage dans ce dossier : c'est le dossier
+#  entier qui doit être autorisé (pas le seul fichier).
+#  Compromis : un service compromis pourrait alors modifier les fichiers du jeu de ce dossier.
+#  Sans ce complément (et sans LauncherApi:Games), les notes ne sont pas modifiables en ligne.
+#
+#  Fichier séparé : conservé lors des mises à jour du serveur. Adapter le chemin au dossier du jeu
+#  réellement servi par nginx (exemple de la documentation ci-dessous ; une ligne par jeu), puis :
+#    sudo systemctl daemon-reload && sudo systemctl restart launcher-api
+# =============================================================================
+[Service]
+ReadWritePaths=/srv/exovival/www/exovivalzombie

server/deploy/launcher-api.service

@@ -6,6 +6,10 @@
 #  terminal), enfermé par systemd : système en lecture seule, pas d'accès à /home, aucun privilège.
 #  Ses binaires (/opt/launcher-api) appartiennent à root : il ne peut pas se modifier lui-même.
 #  Données privées : /var/lib/launcher-api (créé par systemd, droits 700).
+#  Catalogue des jeux : écriture autorisée dans son seul dossier public par le complément
+#  /etc/systemd/system/launcher-api.service.d/catalog.conf (launcher-api-catalog.conf, LISEZMOI.md).
+#  Notes de version : écriture dans le dossier de chaque jeu par le complément games.conf
+#  (launcher-api-games.conf, LISEZMOI.md étape 3 ter).
 #
 #  Vérifier le durcissement :  systemd-analyze security launcher-api
 #  Journal :                   journalctl -u launcher-api -f

server/deploy/nginx-catalog.conf

@@ -0,0 +1,20 @@
+# =============================================================================
+#  Catalogue des jeux (écrit par la Launcher API) — un ajout (voir LISEZMOI.md, étape 3 bis) :
+#
+#  Dans le bloc HTTPS (port 443) du site /etc/nginx/sites-available/dl-exovival,
+#  AVANT « location / { … } » :  (le bloc ci-dessous)
+#
+#  Puis :  sudo nginx -t && sudo systemctl reload nginx
+#
+#  Les images du catalogue (catalog/images/*.png|jpg) sont servies par « location / » ; les
+#  fichiers temporaires de la Launcher API (.catalog.json.….tmp) par la règle des fichiers cachés
+#  (refusés).
+# =============================================================================
+
+# Catalogue : toujours relu sur le serveur (les launchers le lisent au démarrage).
+location = /catalog/catalog.json {
+    limit_except GET { deny all; }
+    default_type application/json;
+    add_header Cache-Control "no-cache, no-store, must-revalidate" always;
+    add_header X-Content-Type-Options "nosniff" always;
+}

server/deploy/nginx-publications.conf

@@ -0,0 +1,39 @@
+# =============================================================================
+#  Publication d'une version depuis le launcher — deux ajouts (voir LISEZMOI.md, étape 3 quater) :
+#
+#  1) Dans /etc/nginx/conf.d/securite.conf, à côté de la zone « api_par_ip » :
+#
+#       limit_req_zone $binary_remote_addr zone=publication_par_ip:10m rate=25r/s;
+#
+#     Un envoi enchaîne plusieurs morceaux de 4 Mo par seconde : la zone « api_par_ip » (5 par seconde)
+#     briderait l'envoi vers 20 Mo/s et provoquerait des pauses. 25 par seconde ≈ 100 Mo/s ; ces routes
+#     exigent une session d'administrateur et le droit de publier.
+#
+#  2) Dans le bloc HTTPS (port 443) du site /etc/nginx/sites-available/dl-exovival, à côté du bloc
+#     « location ^~ /api/ { … } » (nginx-api.conf) : (le bloc ci-dessous)
+#
+#  Puis :  sudo nginx -t && sudo systemctl reload nginx
+#
+#  Seules ces routes acceptent de gros envois (morceaux de 4 Mo, 8 Mo au plus) ; toutes les autres
+#  routes de l'API restent limitées à 64 Ko. Le préfixe le plus long l'emporte sur « /api/ ».
+#  Les fichiers en cours d'envoi sont rangés dans un dossier caché (.publish-…) du dossier du jeu :
+#  la règle « location ~ /\. { deny all; } » du site doit être présente (elle l'est dans le guide).
+# =============================================================================
+
+location ^~ /api/v1/publications/ {
+    limit_req zone=publication_par_ip burst=50 nodelay;
+    limit_req_status 429;
+
+    client_max_body_size 9m;
+
+    proxy_pass http://127.0.0.1:5080;
+    proxy_http_version 1.1;
+    proxy_set_header Connection "";
+    proxy_set_header Host $host;
+    proxy_set_header X-Forwarded-For $remote_addr;
+    proxy_set_header X-Forwarded-Proto $scheme;
+
+    proxy_connect_timeout 5s;
+    proxy_send_timeout 180s;
+    proxy_read_timeout 180s;
+}

src/GameLauncher.ApiClient/AdminKeyFile.cs

@@ -36,8 +36,26 @@ public static class AdminKeyFile
         using (var writer = new StreamWriter(stream))
             writer.Write(pem);
 
+        // Clé publique : jamais écrasée non plus ; en cas d'échec, la clé privée qui vient d'être créée est retirée.
         var publicPath = Path.ChangeExtension(path, PublicKeyExtension);
-        File.WriteAllText(publicPath, AdminKeys.ToPem(key.ExportSubjectPublicKeyInfo()));
+        try
+        {
+            using var stream = new FileStream(publicPath, FileMode.CreateNew, FileAccess.Write, FileShare.None);
+            using var writer = new StreamWriter(stream);
+            writer.Write(AdminKeys.ToPem(key.ExportSubjectPublicKeyInfo()));
+        }
+        catch
+        {
+            try
+            {
+                File.Delete(path);
+            }
+            catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+            {
+                // clé chiffrée laissée en place : sans danger
+            }
+            throw;
+        }
         return publicPath;
     }
 

src/GameLauncher.ApiClient/AdminSession.cs

@@ -1,5 +1,8 @@
 using System.Security.Cryptography;
 using GameLauncher.Contracts;
+using GameLauncher.Contracts.Catalog;
+using GameLauncher.Contracts.Changelog;
+using GameLauncher.Contracts.Publishing;
 using GameLauncher.Contracts.Dtos;
 using GameLauncher.Contracts.Security;
 
@@ -32,6 +35,9 @@ public sealed class AdminSession : IAsyncDisposable
     }
 
     public string ServerId { get; }
+
+    /// <summary>Écart entre l'horloge du serveur et celle du PC (heure serveur = heure du PC + écart), mesuré à la connexion.</summary>
+    public TimeSpan ClockOffset => _clockOffset;
     public string SessionId { get; }
     public AdminProfile Profile { get; private set; }
     public DateTimeOffset ExpiresAt { get; }
@@ -104,6 +110,77 @@ public sealed class AdminSession : IAsyncDisposable
         return GetAsync<AuditPage>(route, ct);
     }
 
+    // ------------------------------------------------------------------ Catalogue (informations modifiables des jeux)
+
+    public Task<CatalogState> GetCatalogAsync(CancellationToken ct = default) =>
+        GetAsync<CatalogState>(ApiRoutes.Catalog, ct);
+
+    /// <summary>Publie le catalogue (409 « revision_conflict » si quelqu'un a publié depuis <paramref name="baseRevision"/>).</summary>
+    public Task<CatalogState> PublishCatalogAsync(CatalogDocument catalog, long baseRevision, CancellationToken ct = default) =>
+        SendSignedAsync<CatalogState>(HttpMethod.Put, ApiRoutes.Catalog,
+            new CatalogUpdateRequest { BaseRevision = baseRevision, Catalog = catalog }, ct);
+
+    // ------------------------------------------------------------------ Notes de version (manifest.json publié)
+
+    /// <summary>Notes de version publiées d'un jeu, avec l'empreinte du manifest lu.</summary>
+    public Task<ChangelogState> GetChangelogAsync(string gameId, CancellationToken ct = default) =>
+        GetAsync<ChangelogState>(ApiRoutes.GameChangelog(CheckGameId(gameId)), ct);
+
+    /// <summary>
+    /// Remplace les notes d'UNE version existante (requête signée). <paramref name="baseSha256"/> : empreinte
+    /// du manifest sur lequel la modification a été préparée (409 revision_conflict s'il a changé).
+    /// </summary>
+    public Task<ChangelogState> SaveChangelogEntryAsync(string gameId, ChangelogEntry entry, string baseSha256, CancellationToken ct = default)
+    {
+        if (!ChangelogLimits.IsEditableVersion(entry.Version))
+            throw new ArgumentException($"Version « {entry.Version} » non modifiable en ligne.", nameof(entry));
+        return SendSignedAsync<ChangelogState>(HttpMethod.Put, ApiRoutes.GameChangelogEntry(CheckGameId(gameId), entry.Version),
+            new ChangelogUpdateRequest { BaseSha256 = baseSha256, Entry = entry }, ct);
+    }
+
+    // ------------------------------------------------------------------ Publication d'une version
+
+    /// <summary>Délai d'une requête d'envoi de fichier (morceau de 4 Mo sur une connexion lente).</summary>
+    public static readonly TimeSpan UploadTimeout = TimeSpan.FromMinutes(3);
+
+    public Task<PublicationState> StartPublicationAsync(string gameId, PublicationStartRequest request, CancellationToken ct = default) =>
+        SendSignedAsync<PublicationState>(HttpMethod.Post, ApiRoutes.PublicationStart(CheckGameId(gameId)), request, ct);
+
+    public Task<PublicationState> GetPublicationAsync(string id, CancellationToken ct = default) =>
+        GetAsync<PublicationState>(ApiRoutes.Publication(CheckPublicationId(id)), ct);
+
+    public Task CancelPublicationAsync(string id, CancellationToken ct = default) =>
+        SendSignedAsync<NoContent>(HttpMethod.Delete, ApiRoutes.Publication(CheckPublicationId(id)), null, ct);
+
+    public Task<ChunkResult> UploadManifestAsync(string id, long offset, byte[] data, CancellationToken ct = default) =>
+        SendSignedBytesAsync<ChunkResult>(HttpMethod.Put, ApiRoutes.PublicationManifest(CheckPublicationId(id), offset), data,
+            PublishingLimits.BinaryContentType, UploadTimeout, ct);
+
+    public Task<ChunkResult> UploadArchiveAsync(string id, long offset, byte[] data, CancellationToken ct = default) =>
+        SendSignedBytesAsync<ChunkResult>(HttpMethod.Put, ApiRoutes.PublicationArchive(CheckPublicationId(id), offset), data,
+            PublishingLimits.BinaryContentType, UploadTimeout, ct);
+
+    public Task<ChunkResult> UploadObjectAsync(string id, string sha256, long offset, byte[] data, CancellationToken ct = default) =>
+        SendSignedBytesAsync<ChunkResult>(HttpMethod.Put,
+            ApiRoutes.PublicationObject(CheckPublicationId(id), PublishingLimits.IsValidSha256(sha256) ? sha256.ToLowerInvariant()
+                : throw new ArgumentException("Empreinte invalide.", nameof(sha256)), offset), data,
+            PublishingLimits.BinaryContentType, UploadTimeout, ct);
+
+    public Task<ChunkResult> UploadObjectBatchAsync(string id, byte[] batch, CancellationToken ct = default) =>
+        SendSignedBytesAsync<ChunkResult>(HttpMethod.Post, ApiRoutes.PublicationObjects(CheckPublicationId(id)), batch,
+            PublishingLimits.ObjectBatchContentType, UploadTimeout, ct);
+
+    /// <summary>Mise en ligne (délai long : renommages et écriture du manifest sur le serveur).</summary>
+    public Task<PublicationResult> CommitPublicationAsync(string id, CancellationToken ct = default) =>
+        SendCoreAsync<PublicationResult>(HttpMethod.Post, ApiRoutes.PublicationCommit(CheckPublicationId(id)), null, signed: true, ct,
+            timeout: UploadTimeout);
+
+    private static string CheckPublicationId(string id) =>
+        PublishingLimits.IsValidPublicationId(id) ? id : throw new ArgumentException("Identifiant de publication invalide.", nameof(id));
+
+    private static string CheckGameId(string gameId) =>
+        CatalogRules.IsValidGameId(gameId) ? gameId : throw new ArgumentException($"Identifiant de jeu invalide : « {gameId} ».", nameof(gameId));
+
     // ------------------------------------------------------------------ Requêtes génériques (modules)
 
     public Task<T> GetAsync<T>(string route, CancellationToken ct = default) =>
@@ -113,7 +190,13 @@ public sealed class AdminSession : IAsyncDisposable
     public Task<T> SendSignedAsync<T>(HttpMethod method, string route, object? body, CancellationToken ct = default) =>
         SendCoreAsync<T>(method, route, body is null ? null : LauncherApiClient.Serialize(body), signed: true, ct);
 
-    private async Task<T> SendCoreAsync<T>(HttpMethod method, string route, byte[]? body, bool signed, CancellationToken ct)
+    /// <summary>Requête qui modifie avec un corps binaire (morceau de fichier), signée par la clé.</summary>
+    public Task<T> SendSignedBytesAsync<T>(HttpMethod method, string route, byte[] body, string contentType, TimeSpan timeout,
+                                           CancellationToken ct = default) =>
+        SendCoreAsync<T>(method, route, body, signed: true, ct, contentType, timeout);
+
+    private async Task<T> SendCoreAsync<T>(HttpMethod method, string route, byte[]? body, bool signed, CancellationToken ct,
+                                           string contentType = "application/json", TimeSpan? timeout = null)
     {
         var token = _token ?? throw new ApiException(401, ApiErrorCodes.Unauthorized, "Session fermée : reconnectez-vous.");
 
@@ -139,7 +222,7 @@ public sealed class AdminSession : IAsyncDisposable
                     request.Headers.Add(SignedRequestHeaders.Nonce, s.Nonce);
                     request.Headers.Add(SignedRequestHeaders.Signature, Convert.ToBase64String(s.Signature));
                 }
-            }, ct).ConfigureAwait(false);
+            }, ct, contentType, timeout).ConfigureAwait(false);
         }
         catch (ApiException ex) when (ex.Status == 401 && ex.Code == ApiErrorCodes.Unauthorized)
         {

src/GameLauncher.ApiClient/ApiException.cs

@@ -17,5 +17,8 @@ public sealed class ApiException : Exception
     /// <summary>Code stable (<see cref="ApiErrorCodes"/>).</summary>
     public string Code { get; }
 
+    /// <summary>Délai annoncé par le serveur avant un nouvel essai (en-tête Retry-After), s'il y en a un.</summary>
+    public TimeSpan? RetryAfter { get; init; }
+
     public bool IsUnauthorized => Status == 401;
 }

src/GameLauncher.ApiClient/IAdminSigner.cs

@@ -6,7 +6,7 @@ namespace GameLauncher.ApiClient;
 /// <summary>
 /// Clé privée d'un administrateur, vue par le client : elle signe, elle ne sort jamais.
 /// Implémentations : <see cref="EcdsaAdminSigner"/> (clé en mémoire, déverrouillée depuis un fichier
-/// chiffré) ; Windows Hello / TPM dans le launcher (phase 2).
+/// chiffré) ; clé de la puce TPM dans le launcher (Platform\TpmKeyStore, phase 2b).
 /// </summary>
 public interface IAdminSigner
 {

src/GameLauncher.ApiClient/LauncherApiClient.cs

@@ -41,7 +41,8 @@ public sealed class LauncherApiClient : IDisposable
             PooledConnectionLifetime = TimeSpan.FromMinutes(5)
         }, disposeHandler: handler is null)
         {
-            Timeout = RequestTimeout
+            // Délai propre à chaque requête (SendAsync) : 30 s par défaut, plus pour l'envoi de fichiers.
+            Timeout = Timeout.InfiniteTimeSpan
         };
         _http.DefaultRequestHeaders.UserAgent.ParseAdd(userAgent);
         _http.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
@@ -129,33 +130,50 @@ public sealed class LauncherApiClient : IDisposable
     public static readonly TimeSpan MaxClockOffset = TimeSpan.FromHours(1);
 
     internal async Task<T> SendAsync<T>(HttpMethod method, string route, byte[]? body,
-                                        Action<HttpRequestMessage>? prepare, CancellationToken ct)
+                                        Action<HttpRequestMessage>? prepare, CancellationToken ct,
+                                        string contentType = "application/json", TimeSpan? timeout = null)
     {
         using var request = new HttpRequestMessage(method, Resolve(route));
         if (body is not null)
         {
             request.Content = new ByteArrayContent(body);
-            request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json") { CharSet = "utf-8" };
+            request.Content.Headers.ContentType = contentType == "application/json"
+                ? new MediaTypeHeaderValue(contentType) { CharSet = "utf-8" }
+                : new MediaTypeHeaderValue(contentType);
         }
         prepare?.Invoke(request);
 
+        using var deadline = CancellationTokenSource.CreateLinkedTokenSource(ct);
+        deadline.CancelAfter(timeout ?? RequestTimeout);
         HttpResponseMessage response;
         try
         {
-            response = await _http.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, ct).ConfigureAwait(false);
+            response = await _http.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, deadline.Token).ConfigureAwait(false);
         }
         catch (HttpRequestException ex)
         {
             throw new ApiException(0, "unreachable", $"Serveur d'administration injoignable ({ex.Message}).", ex);
         }
-        catch (TaskCanceledException ex) when (!ct.IsCancellationRequested)
+        catch (OperationCanceledException ex) when (!ct.IsCancellationRequested)
         {
             throw new ApiException(0, "timeout", "Le serveur d'administration ne répond pas.", ex);
         }
 
         using (response)
         {
-            var bytes = await ReadBoundedAsync(response, ct).ConfigureAwait(false);
+            byte[] bytes;
+            try
+            {
+                bytes = await ReadBoundedAsync(response, deadline.Token).ConfigureAwait(false);
+            }
+            catch (OperationCanceledException ex) when (!ct.IsCancellationRequested)
+            {
+                throw new ApiException(0, "timeout", "Le serveur d'administration ne répond pas.", ex);
+            }
+            catch (HttpRequestException ex)
+            {
+                throw new ApiException(0, "unreachable", $"Connexion au serveur d'administration interrompue ({ex.Message}).", ex);
+            }
             if (!response.IsSuccessStatusCode) throw ToException(response, bytes);
             if (typeof(T) == typeof(NoContent)) return (T)(object)NoContent.Value;
             try
@@ -191,25 +209,36 @@ public sealed class LauncherApiClient : IDisposable
     private static ApiException ToException(HttpResponseMessage response, byte[] body)
     {
         var status = (int)response.StatusCode;
+        var retryAfter = RetryAfterOf(response);
         try
         {
             if (body.Length > 0 && JsonSerializer.Deserialize<ApiError>(body, ApiJson.Options) is { Message.Length: > 0 } error)
-                return new ApiException(status, error.Code, error.Message);
+                return new ApiException(status, error.Code, error.Message) { RetryAfter = retryAfter };
         }
         catch (JsonException)
         {
             // réponse d'erreur non JSON (nginx, proxy…)
         }
-        return status switch
+        var (code, message) = status switch
         {
-            401 => new ApiException(status, ApiErrorCodes.Unauthorized, "Session expirée : reconnectez-vous."),
-            403 => new ApiException(status, ApiErrorCodes.Forbidden, "Action non autorisée."),
-            404 => new ApiException(status, ApiErrorCodes.NotFound, "Adresse inconnue sur le serveur (version de l'API ?)."),
-            413 => new ApiException(status, ApiErrorCodes.InvalidRequest, "Requête trop volumineuse."),
-            429 => new ApiException(status, ApiErrorCodes.RateLimited, "Trop de requêtes : patientez une minute."),
-            >= 500 => new ApiException(status, ApiErrorCodes.Error, $"Erreur du serveur ({status})."),
-            _ => new ApiException(status, ApiErrorCodes.Error, $"Réponse inattendue du serveur ({status}).")
+            401 => (ApiErrorCodes.Unauthorized, "Session expirée : reconnectez-vous."),
+            403 => (ApiErrorCodes.Forbidden, "Action non autorisée."),
+            404 => (ApiErrorCodes.NotFound, "Adresse inconnue sur le serveur (version de l'API ?)."),
+            413 => (ApiErrorCodes.InvalidRequest,
+                "Requête trop volumineuse pour le serveur (envoi de fichiers : vérifiez nginx-publications.conf sur le VPS)."),
+            429 => (ApiErrorCodes.RateLimited, "Trop de requêtes : patientez une minute."),
+            >= 500 => (ApiErrorCodes.Error, $"Erreur du serveur ({status})."),
+            _ => (ApiErrorCodes.Error, $"Réponse inattendue du serveur ({status}).")
         };
+        return new ApiException(status, code, message) { RetryAfter = retryAfter };
+    }
+
+    /// <summary>En-tête Retry-After (en secondes ou en date) ; absent ou incohérent : null.</summary>
+    private static TimeSpan? RetryAfterOf(HttpResponseMessage response)
+    {
+        var header = response.Headers.RetryAfter;
+        var delay = header?.Delta ?? (header?.Date is { } date ? date - DateTimeOffset.UtcNow : null);
+        return delay is { } value && value >= TimeSpan.Zero ? value : null;
     }
 
     /// <summary>Le serveur doit annoncer la même origine que celle configurée (sinon les signatures seraient refusées).</summary>

src/GameLauncher.Contracts/ApiRoutes.cs

@@ -36,4 +36,36 @@ public static class ApiRoutes
 
     // ------------------------------------------------------------------ Audit
     public const string Audit = "v1/audit";
+
+    // ------------------------------------------------------------------ Catalogue (informations modifiables des jeux)
+    public const string Catalog = "v1/catalog";
+
+    // ------------------------------------------------------------------ Notes de version (manifest.json de chaque jeu)
+    public const string GameChangelogPattern = "v1/games/{gameId}/changelog";
+    public const string GameChangelogEntryPattern = "v1/games/{gameId}/changelog/{version}";
+
+    /// <summary>Notes de version d'un jeu (identifiant et version : caractères sûrs uniquement, rien à encoder).</summary>
+    public static string GameChangelog(string gameId) => $"v1/games/{gameId}/changelog";
+
+    public static string GameChangelogEntry(string gameId, string version) => $"v1/games/{gameId}/changelog/{version}";
+
+    // ------------------------------------------------------------------ Publication d'une version
+    public const string PublicationStartPattern = "v1/games/{gameId}/publications";
+    public const string PublicationPattern = "v1/publications/{id}";
+    public const string PublicationManifestPattern = "v1/publications/{id}/manifest";
+    public const string PublicationArchivePattern = "v1/publications/{id}/archive";
+    public const string PublicationObjectsPattern = "v1/publications/{id}/objects";
+    public const string PublicationObjectPattern = "v1/publications/{id}/objects/{sha256}";
+    public const string PublicationCommitPattern = "v1/publications/{id}/commit";
+
+    /// <summary>Préfixe des routes d'envoi (limite de taille propre, voir nginx-publications.conf).</summary>
+    public const string PublicationsPrefix = "v1/publications/";
+
+    public static string PublicationStart(string gameId) => $"v1/games/{gameId}/publications";
+    public static string Publication(string id) => $"v1/publications/{id}";
+    public static string PublicationManifest(string id, long offset) => $"v1/publications/{id}/manifest?offset={offset}";
+    public static string PublicationArchive(string id, long offset) => $"v1/publications/{id}/archive?offset={offset}";
+    public static string PublicationObjects(string id) => $"v1/publications/{id}/objects";
+    public static string PublicationObject(string id, string sha256, long offset) => $"v1/publications/{id}/objects/{sha256}?offset={offset}";
+    public static string PublicationCommit(string id) => $"v1/publications/{id}/commit";
 }

src/GameLauncher.Contracts/Catalog/CatalogDocument.cs

@@ -0,0 +1,126 @@
+namespace GameLauncher.Contracts.Catalog;
+
+/// <summary>
+/// Informations MODIFIABLES des jeux (catalog.json, publié par le serveur et lu par les launchers).
+/// Les jeux restent déclarés dans launcher.json (intégré à l'exe) : une entrée pour un jeu non déclaré
+/// est ignorée par le launcher. Toute valeur absente (null) = valeur de launcher.json.
+/// Ce fichier est PUBLIC : il ne contient que de l'affichage (aucun nom d'administrateur).
+/// </summary>
+public sealed record CatalogDocument
+{
+    public const string FormatName = "gamelauncher-catalog";
+    public const int CurrentVersion = 1;
+
+    public string Format { get; init; } = FormatName;
+    public int Version { get; init; } = CurrentVersion;
+
+    /// <summary>Numéro de version du contenu, augmenté à chaque publication (contrôle des modifications concurrentes).</summary>
+    public long Revision { get; init; }
+
+    public DateTimeOffset? UpdatedAt { get; init; }
+
+    public CatalogLauncher? Launcher { get; init; }
+
+    /// <summary>Par identifiant de jeu (GameId de launcher.json).</summary>
+    public Dictionary<string, CatalogGame> Games { get; init; } = new(StringComparer.OrdinalIgnoreCase);
+}
+
+/// <summary>Réglages d'affichage du launcher (liste des jeux).</summary>
+public sealed record CatalogLauncher
+{
+    public string? LauncherName { get; init; }
+
+    /// <summary>Jeu affiché au premier lancement.</summary>
+    public string? DefaultGame { get; init; }
+
+    /// <summary>Ordre des jeux dans la liste (les jeux non cités suivent, dans l'ordre de launcher.json).</summary>
+    public List<string>? GameOrder { get; init; }
+}
+
+/// <summary>Informations modifiables d'un jeu (null : valeur de launcher.json).</summary>
+public sealed record CatalogGame
+{
+    /// <summary>Nom AFFICHÉ (le nom de launcher.json reste celui du raccourci, du registre et des dossiers).</summary>
+    public string? GameName { get; init; }
+
+    public string? Tagline { get; init; }
+
+    /// <summary>Texte de présentation (plusieurs lignes, texte brut).</summary>
+    public string? Description { get; init; }
+
+    public string? WebsiteUrl { get; init; }
+
+    public List<CatalogLink>? Links { get; init; }
+
+    /// <summary>Thème INTÉGRÉ au launcher (« default », « exovival »…), jamais un fichier.</summary>
+    public string? Theme { get; init; }
+
+    /// <summary>Image https (PNG ou JPEG) du même serveur que le catalogue.</summary>
+    public string? Icon { get; init; }
+
+    /// <summary>Image de fond https (PNG ou JPEG) du même serveur que le catalogue.</summary>
+    public string? Background { get; init; }
+
+    /// <summary>0 (désactivé) ou 5 à 1440 minutes.</summary>
+    public int? UpdateCheckIntervalMinutes { get; init; }
+
+    /// <summary>Masqué de la liste (un jeu installé sur le PC reste toujours affiché).</summary>
+    public bool? Hidden { get; init; }
+}
+
+/// <summary>Lien affiché sous la présentation du jeu (Discord, YouTube…).</summary>
+public sealed record CatalogLink
+{
+    /// <summary>Voir <see cref="CatalogLinkKinds"/> (choisit l'icône intégrée).</summary>
+    public string Kind { get; init; } = CatalogLinkKinds.Website;
+
+    public string? Label { get; init; }
+
+    public string Url { get; init; } = "";
+}
+
+public static class CatalogLinkKinds
+{
+    public const string Website = "website";
+    public const string Discord = "discord";
+    public const string YouTube = "youtube";
+    public const string X = "x";
+    public const string Twitch = "twitch";
+    public const string Steam = "steam";
+    public const string Other = "other";
+
+    public static readonly IReadOnlyList<string> All = new[] { Website, Discord, YouTube, X, Twitch, Steam, Other };
+
+    /// <summary>Libellé par défaut d'un lien.</summary>
+    public static string DefaultLabel(string kind) => kind switch
+    {
+        Website => "Site web",
+        Discord => "Discord",
+        YouTube => "YouTube",
+        X => "X (Twitter)",
+        Twitch => "Twitch",
+        Steam => "Steam",
+        _ => "Lien"
+    };
+}
+
+/// <summary>Publication du catalogue depuis le menu d'administration (requête signée, permission games.edit).</summary>
+public sealed record CatalogUpdateRequest
+{
+    /// <summary>Révision sur laquelle les modifications ont été faites (refus si quelqu'un a publié entre-temps).</summary>
+    public long BaseRevision { get; init; }
+
+    public CatalogDocument Catalog { get; init; } = new();
+}
+
+/// <summary>Catalogue tel que connu du serveur, pour le menu d'administration.</summary>
+public sealed record CatalogState
+{
+    public CatalogDocument Catalog { get; init; } = new();
+
+    /// <summary>Faux : la publication n'est pas configurée sur le serveur (LauncherApi:Catalog:PublicFile).</summary>
+    public bool PublishingEnabled { get; init; }
+
+    /// <summary>Adresse publique du catalogue (pour information).</summary>
+    public string? PublicUrl { get; init; }
+}

src/GameLauncher.Contracts/Catalog/CatalogRules.cs

@@ -0,0 +1,274 @@
+using System.Text;
+using System.Text.Json;
+using System.Text.RegularExpressions;
+
+namespace GameLauncher.Contracts.Catalog;
+
+/// <summary>
+/// Contrôle et nettoyage du catalogue, communs au serveur (refus de toute valeur invalide) et au
+/// launcher des joueurs (valeur invalide ignorée : la valeur de launcher.json s'applique).
+/// Tout est borné : textes, nombre de jeux et de liens, adresses (https uniquement), images (même
+/// serveur que le catalogue, PNG ou JPEG), thème (identifiant d'un thème intégré, jamais un fichier).
+/// </summary>
+public static partial class CatalogRules
+{
+    /// <summary>
+    /// Taille maximale de catalog.json. Inférieure à la taille maximale d'une requête de l'API (64 Ko :
+    /// Limits:MaxRequestBodyBytes et client_max_body_size de nginx), qui n'est donc pas à augmenter.
+    /// </summary>
+    public const int MaxFileBytes = 48 * 1024;
+
+    /// <summary>Format du fichier publié (JSON indenté, écrit par le serveur).</summary>
+    public static readonly JsonSerializerOptions PublishedJson = new(ApiJson.Options) { WriteIndented = true };
+
+    /// <summary>Taille (octets) du fichier publié pour ce catalogue.</summary>
+    public static int PublishedSize(CatalogDocument catalog) =>
+        Encoding.UTF8.GetByteCount(JsonSerializer.Serialize(catalog, PublishedJson));
+    public const int MaxGames = 50;
+    public const int MaxGameNameLength = 80;
+    public const int MaxLauncherNameLength = 80;
+    public const int MaxTaglineLength = 200;
+    public const int MaxDescriptionLength = 2000;
+    public const int MaxDescriptionLines = 40;
+    public const int MaxLinks = 8;
+    public const int MaxLinkLabelLength = 40;
+    public const int MaxUrlLength = 500;
+    public const int MinUpdateInterval = 5;
+    public const int MaxUpdateInterval = 1440;
+
+    [GeneratedRegex(@"\A[A-Za-z0-9_.\-]{1,64}\z")]
+    private static partial Regex GameIdRegex();
+
+    [GeneratedRegex(@"\A[a-z0-9][a-z0-9\-]{0,31}\z")]
+    private static partial Regex ThemeRegex();
+
+    public static bool IsValidGameId(string? id) => id is not null && GameIdRegex().IsMatch(id);
+
+    public static bool IsValidTheme(string? theme) => theme is not null && ThemeRegex().IsMatch(theme);
+
+    /// <summary>
+    /// Nettoie le catalogue. Chaque valeur invalide est retirée (null) et décrite dans <paramref name="errors"/> :
+    /// le serveur refuse la publication s'il y en a, le launcher ignore simplement ces valeurs.
+    /// </summary>
+    /// <param name="imageHost">Hôte autorisé pour les images (celui du catalogue) ; null : https suffit.</param>
+    public static CatalogDocument Normalize(CatalogDocument input, string? imageHost, List<string> errors)
+    {
+        if (input.Format != CatalogDocument.FormatName) errors.Add("Format de catalogue inconnu.");
+        if (input.Version != CatalogDocument.CurrentVersion) errors.Add($"Version de catalogue non prise en charge ({input.Version}).");
+        if (input.Revision < 0) errors.Add("Révision invalide.");
+
+        var games = new Dictionary<string, CatalogGame>(StringComparer.OrdinalIgnoreCase);
+        foreach (var (id, game) in input.Games ?? new Dictionary<string, CatalogGame>())
+        {
+            if (!IsValidGameId(id))
+            {
+                errors.Add($"Identifiant de jeu invalide : « {Truncate(id)} ».");
+                continue;
+            }
+            if (games.ContainsKey(id))
+            {
+                errors.Add($"Jeu « {id} » présent plusieurs fois.");
+                continue;
+            }
+            if (games.Count >= MaxGames)
+            {
+                errors.Add($"Trop de jeux (au plus {MaxGames}).");
+                break;
+            }
+            if (game is null) continue;
+            var cleaned = NormalizeGame(id, game, imageHost, errors);
+            if (!IsEmpty(cleaned)) games[id] = cleaned;
+        }
+
+        return new CatalogDocument
+        {
+            Revision = Math.Max(0, input.Revision),
+            UpdatedAt = input.UpdatedAt,
+            Launcher = NormalizeLauncher(input.Launcher, errors),
+            Games = games
+        };
+    }
+
+    private static CatalogLauncher? NormalizeLauncher(CatalogLauncher? launcher, List<string> errors)
+    {
+        if (launcher is null) return null;
+        var name = Line(launcher.LauncherName, MaxLauncherNameLength, "Nom du launcher", errors);
+        string? defaultGame = null;
+        if (!string.IsNullOrWhiteSpace(launcher.DefaultGame))
+        {
+            if (IsValidGameId(launcher.DefaultGame.Trim())) defaultGame = launcher.DefaultGame.Trim();
+            else errors.Add("Jeu par défaut : identifiant invalide.");
+        }
+
+        List<string>? order = null;
+        if (launcher.GameOrder is { Count: > 0 })
+        {
+            order = new List<string>();
+            foreach (var id in launcher.GameOrder)
+            {
+                if (!IsValidGameId(id))
+                {
+                    errors.Add($"Ordre des jeux : identifiant invalide « {Truncate(id)} ».");
+                    continue;
+                }
+                if (order.Count >= MaxGames)
+                {
+                    errors.Add($"Ordre des jeux : au plus {MaxGames} jeux.");
+                    break;
+                }
+                if (!order.Contains(id, StringComparer.OrdinalIgnoreCase)) order.Add(id);
+            }
+            if (order.Count == 0) order = null;
+        }
+
+        return name is null && defaultGame is null && order is null
+            ? null
+            : new CatalogLauncher { LauncherName = name, DefaultGame = defaultGame, GameOrder = order };
+    }
+
+    private static CatalogGame NormalizeGame(string id, CatalogGame game, string? imageHost, List<string> errors)
+    {
+        var prefix = $"Jeu « {id} »";
+        int? interval = null;
+        if (game.UpdateCheckIntervalMinutes is { } minutes)
+        {
+            if (minutes == 0 || minutes is >= MinUpdateInterval and <= MaxUpdateInterval) interval = minutes;
+            else errors.Add($"{prefix} : intervalle de recherche des mises à jour invalide (0, ou {MinUpdateInterval} à {MaxUpdateInterval} minutes).");
+        }
+
+        string? theme = null;
+        if (!string.IsNullOrWhiteSpace(game.Theme))
+        {
+            var value = game.Theme.Trim();
+            if (IsValidTheme(value)) theme = value;
+            else errors.Add($"{prefix} : thème invalide (identifiant d'un thème intégré au launcher).");
+        }
+
+        return new CatalogGame
+        {
+            GameName = Line(game.GameName, MaxGameNameLength, $"{prefix} : nom", errors),
+            Tagline = Line(game.Tagline, MaxTaglineLength, $"{prefix} : accroche", errors),
+            Description = Text(game.Description, $"{prefix} : présentation", errors),
+            WebsiteUrl = Url(game.WebsiteUrl, $"{prefix} : site web", errors),
+            Links = Links(game.Links, prefix, errors),
+            Theme = theme,
+            Icon = Image(game.Icon, imageHost, $"{prefix} : icône", errors),
+            Background = Image(game.Background, imageHost, $"{prefix} : image de fond", errors),
+            UpdateCheckIntervalMinutes = interval,
+            Hidden = game.Hidden == true ? true : null
+        };
+    }
+
+    private static List<CatalogLink>? Links(List<CatalogLink>? links, string prefix, List<string> errors)
+    {
+        if (links is not { Count: > 0 }) return null;
+        var result = new List<CatalogLink>();
+        foreach (var link in links)
+        {
+            if (link is null) continue;
+            if (result.Count >= MaxLinks)
+            {
+                errors.Add($"{prefix} : au plus {MaxLinks} liens.");
+                break;
+            }
+            var kind = CatalogLinkKinds.All.Contains(link.Kind) ? link.Kind : null;
+            if (kind is null)
+            {
+                errors.Add($"{prefix} : type de lien inconnu « {Truncate(link.Kind)} ».");
+                continue;
+            }
+            var url = Url(link.Url, $"{prefix} : lien {CatalogLinkKinds.DefaultLabel(kind)}", errors);
+            if (url is null)
+            {
+                if (string.IsNullOrWhiteSpace(link.Url)) errors.Add($"{prefix} : lien {CatalogLinkKinds.DefaultLabel(kind)} sans adresse.");
+                continue;
+            }
+            var label = Line(link.Label, MaxLinkLabelLength, $"{prefix} : libellé de lien", errors);
+            result.Add(new CatalogLink { Kind = kind, Label = label, Url = url });
+        }
+        return result.Count == 0 ? null : result;
+    }
+
+    // ------------------------------------------------------------------ Valeurs
+
+    private static string? Line(string? value, int maxLength, string field, List<string> errors)
+    {
+        if (string.IsNullOrWhiteSpace(value)) return null;
+        var cleaned = ApiText.CleanLine(value, maxLength);
+        if (cleaned is null) errors.Add($"{field} : {maxLength} caractères au plus, sans caractère spécial invisible.");
+        return cleaned;
+    }
+
+    /// <summary>Texte de plusieurs lignes : fins de ligne normalisées, sans caractère de contrôle ou invisible.</summary>
+    private static string? Text(string? value, string field, List<string> errors)
+    {
+        if (string.IsNullOrWhiteSpace(value)) return null;
+        var lines = value.Replace("\r\n", "\n").Replace('\r', '\n').Split('\n');
+        var sb = new StringBuilder(value.Length);
+        for (var i = 0; i < lines.Length; i++)
+        {
+            if (i > 0) sb.Append('\n');
+            var line = lines[i].TrimEnd();
+            if (line.Length == 0) continue;
+            // Indentation conservée (espaces de tête), le reste nettoyé comme une ligne simple.
+            var indent = line.Length - line.TrimStart(' ').Length;
+            var cleaned = ApiText.CleanLine(line, MaxDescriptionLength);
+            if (cleaned is null)
+            {
+                errors.Add($"{field} : caractère spécial invisible ou de contrôle interdit.");
+                return null;
+            }
+            sb.Append(' ', Math.Min(indent, 8)).Append(cleaned);
+        }
+        var text = sb.ToString().Trim('\n');
+        if (text.Length > MaxDescriptionLength || text.Count(c => c == '\n') + 1 > MaxDescriptionLines)
+        {
+            errors.Add($"{field} : {MaxDescriptionLength} caractères et {MaxDescriptionLines} lignes au plus.");
+            return null;
+        }
+        return text.Length == 0 ? null : text;
+    }
+
+    /// <summary>Adresse https absolue, sans identifiants, bornée.</summary>
+    public static string? Url(string? value, string field, List<string> errors)
+    {
+        if (string.IsNullOrWhiteSpace(value)) return null;
+        var text = value.Trim();
+        if (text.Length > MaxUrlLength || !Uri.TryCreate(text, UriKind.Absolute, out var uri) ||
+            uri.Scheme != Uri.UriSchemeHttps || !string.IsNullOrEmpty(uri.UserInfo) || string.IsNullOrEmpty(uri.Host) ||
+            text.Any(char.IsWhiteSpace) || text.Any(char.IsControl))
+        {
+            errors.Add($"{field} : adresse https:// complète attendue ({MaxUrlLength} caractères au plus).");
+            return null;
+        }
+        return uri.AbsoluteUri;
+    }
+
+    /// <summary>Image https PNG ou JPEG, sur l'hôte du catalogue.</summary>
+    private static string? Image(string? value, string? imageHost, string field, List<string> errors)
+    {
+        var url = Url(value, field, errors);
+        if (url is null) return null;
+        var uri = new Uri(url);
+        var path = uri.AbsolutePath;
+        if (!(path.EndsWith(".png", StringComparison.OrdinalIgnoreCase) || path.EndsWith(".jpg", StringComparison.OrdinalIgnoreCase) ||
+              path.EndsWith(".jpeg", StringComparison.OrdinalIgnoreCase)) || !string.IsNullOrEmpty(uri.Query))
+        {
+            errors.Add($"{field} : image .png ou .jpg attendue (sans paramètres).");
+            return null;
+        }
+        if (imageHost is not null && !string.Equals(uri.Host, imageHost, StringComparison.OrdinalIgnoreCase))
+        {
+            errors.Add($"{field} : l'image doit être sur le serveur du catalogue ({imageHost}).");
+            return null;
+        }
+        return url;
+    }
+
+    private static bool IsEmpty(CatalogGame game) =>
+        game is { GameName: null, Tagline: null, Description: null, WebsiteUrl: null, Links: null, Theme: null, Icon: null,
+                  Background: null, UpdateCheckIntervalMinutes: null, Hidden: null };
+
+    private static string Truncate(string? value) =>
+        value is null ? "" : value.Length <= 40 ? value : value[..40] + "…";
+}

src/GameLauncher.Contracts/Changelog/Changelog.cs

@@ -1,11 +1,14 @@
+using System.Globalization;
 using System.Text;
 using System.Text.Json.Serialization;
-using GameLauncher.Core.Utils;
+using System.Text.RegularExpressions;
 
-namespace GameLauncher.Core.Models;
+namespace GameLauncher.Contracts.Changelog;
 
 /// <summary>
 /// Notes d'une version du jeu (manifest.json → "changelog").
+/// Partagé par le launcher (affichage), ManifestBuilder (notes.txt), le menu d'administration
+/// (éditeur) et la Launcher API (contrôle avant d'écrire le manifest) : mêmes champs, mêmes bornes.
 ///
 /// Format enrichi (launcher 1.2+) : titre, sous-titre, introduction, puis des sections
 /// (« PROGRESSION », « ÉNIGMES »…) contenant des modifications, des commentaires,
@@ -31,8 +34,10 @@ public sealed class ChangelogEntry
     /// <summary>Format historique : une modification par ligne (compatibilité avec les anciens launchers).</summary>
     public List<string> Changes { get; set; } = new();
 
+    private static readonly CultureInfo French = CultureInfo.GetCultureInfo("fr-FR");
+
     [JsonIgnore]
-    public string DateText => Date == default ? "" : Date.ToLocalTime().ToString("d MMMM yyyy", Format.Culture);
+    public string DateText => Date == default ? "" : Date.ToLocalTime().ToString("d MMMM yyyy", French);
 
     [JsonIgnore]
     public bool HasSubtitle => !string.IsNullOrWhiteSpace(Subtitle);
@@ -142,6 +147,69 @@ public static class ChangelogLimits
     public const int MaxTitleLength = 200;
     public const int MaxTagLength = 24;
     public const int MaxTextLength = 2000;
+    public const int MaxVersionLength = 64;
+
+    /// <summary>
+    /// Taille maximale d'une modification envoyée à la Launcher API (UNE version à la fois) : sous la
+    /// limite de 64 Ko des requêtes (Limits:MaxRequestBodyBytes et nginx), qui n'est pas à augmenter.
+    /// </summary>
+    public const int MaxEditRequestBytes = 60 * 1024;
+
+    private static readonly Regex VersionRegex = new(@"\A[A-Za-z0-9._\-]{1,64}\z", RegexOptions.CultureInvariant);
+
+    /// <summary>Numéro de version modifiable en ligne (lettres, chiffres, « . », « _ », « - ») : il figure dans l'adresse de l'API.</summary>
+    public static bool IsEditableVersion(string? version) => version is not null && VersionRegex.IsMatch(version);
+
+    /// <summary>
+    /// Limites dépassées par une version, sans rien tronquer (contrairement à <see cref="Normalize"/>) :
+    /// messages affichés par l'éditeur du menu d'administration, refus (400) par le serveur.
+    /// </summary>
+    public static List<string> Check(ChangelogEntry entry)
+    {
+        var errors = new List<string>();
+        void Length(string? value, int max, string what)
+        {
+            if (value is not null && value.Trim().Length > max) errors.Add($"{what} : {max} caractères au plus.");
+        }
+
+        Length(entry.Title, MaxTitleLength, "Titre");
+        Length(entry.Subtitle, MaxTitleLength * 2, "Sous-titre");
+        var introduction = (entry.Introduction ?? new List<string>()).OfType<string>().ToList();
+        if (introduction.Count > MaxIntroductionParagraphs)
+            errors.Add($"Introduction : {MaxIntroductionParagraphs} paragraphes au plus.");
+        foreach (var paragraph in introduction) Length(paragraph, MaxTextLength, "Introduction (paragraphe)");
+
+        var sections = (entry.Sections ?? new List<ChangelogSection>()).OfType<ChangelogSection>().ToList();
+        if (sections.Count > MaxSectionsPerEntry) errors.Add($"{MaxSectionsPerEntry} sections au plus.");
+        var items = 0;
+        for (var s = 0; s < sections.Count; s++)
+        {
+            var section = sections[s];
+            var where = $"Section {s + 1}";
+            Length(section.Title, MaxTitleLength, $"{where} (titre)");
+            var sectionItems = (section.Items ?? new List<ChangelogItem>()).OfType<ChangelogItem>().ToList();
+            if (sectionItems.Count > MaxItemsPerSection) errors.Add($"{where} : {MaxItemsPerSection} éléments au plus.");
+            items += sectionItems.Count;
+            for (var i = 0; i < sectionItems.Count; i++)
+            {
+                var item = sectionItems[i];
+                var at = $"{where}, élément {i + 1}";
+                Length(item.Text, MaxTextLength, at);
+                Length(item.Tag, MaxTagLength, $"{at} (étiquette)");
+                Length(item.Note, MaxTextLength, $"{at} (note)");
+                var details = (item.Details ?? new List<string>()).OfType<string>().ToList();
+                if (details.Count > MaxDetailsPerItem) errors.Add($"{at} : {MaxDetailsPerItem} sous-points au plus.");
+                foreach (var detail in details) Length(detail, MaxTextLength, $"{at} (sous-point)");
+            }
+        }
+        if (items > MaxItemsPerEntry) errors.Add($"{MaxItemsPerEntry} éléments au plus par version ({items} actuellement).");
+        if (sections.Count == 0 && (entry.Changes?.Count ?? 0) > MaxFlatChanges)
+            errors.Add($"{MaxFlatChanges} modifications au plus.");
+        return errors.Distinct().ToList();
+    }
+
+    /// <summary>Nombre d'éléments affichés (budget <see cref="MaxTotalItems"/> de tout l'historique).</summary>
+    public static int DisplayedItems(ChangelogEntry entry) => entry.DisplaySections.Sum(s => s.Items.Count);
 
     public static List<ChangelogEntry> Normalize(IEnumerable<ChangelogEntry?>? entries)
     {
@@ -229,7 +297,8 @@ public static class ChangelogLimits
 
         var text = sb.ToString().Trim();
         if (text.Length == 0) return null;
-        if (text.Length > maxLength) text = text[..maxLength].TrimEnd() + "…";
+        // « … » compris dans la longueur maximale : un texte tronqué reste dans les limites (Check).
+        if (text.Length > maxLength) text = text[..Math.Max(0, maxLength - 1)].TrimEnd() + "…";
         return text;
     }
 

src/GameLauncher.Contracts/Changelog/ChangelogDtos.cs

@@ -0,0 +1,34 @@
+namespace GameLauncher.Contracts.Changelog;
+
+/// <summary>
+/// Notes de version d'un jeu telles que publiées dans son manifest.json (sur le serveur), pour
+/// l'éditeur du menu d'administration.
+/// </summary>
+public sealed record ChangelogState
+{
+    public string GameId { get; init; } = "";
+
+    /// <summary>Version du jeu actuellement publiée (champ « version » du manifest).</summary>
+    public string ManifestVersion { get; init; } = "";
+
+    /// <summary>
+    /// Empreinte SHA-256 du manifest lu, à renvoyer avec une modification : si le manifest a changé
+    /// entre-temps (nouvelle version publiée, autre administrateur), la modification est refusée (409).
+    /// </summary>
+    public string ManifestSha256 { get; init; } = "";
+
+    /// <summary>Notes de chaque version, de la plus récente à la plus ancienne (bornées par <see cref="ChangelogLimits"/>).</summary>
+    public List<ChangelogEntry> Entries { get; init; } = new();
+}
+
+/// <summary>
+/// Modification des notes d'UNE version existante. Le serveur ne change que cette entrée du manifest
+/// (numéro et date de version conservés) : fichiers, archive, version et exécutable restent identiques.
+/// </summary>
+public sealed record ChangelogUpdateRequest
+{
+    /// <summary>Empreinte du manifest sur lequel la modification a été préparée (<see cref="ChangelogState.ManifestSha256"/>).</summary>
+    public string BaseSha256 { get; init; } = "";
+
+    public ChangelogEntry? Entry { get; init; }
+}

src/GameLauncher.Contracts/Dtos/SystemDtos.cs

@@ -53,4 +53,19 @@ public static class ApiErrorCodes
     public const string SelfAction = "self_action";
     public const string Busy = "busy";
     public const string HttpsRequired = "https_required";
+
+    /// <summary>Quelqu'un a modifié la même donnée entre-temps (révision dépassée) : recharger avant de recommencer.</summary>
+    public const string RevisionConflict = "revision_conflict";
+
+    /// <summary>Fonction non configurée sur le serveur.</summary>
+    public const string NotConfigured = "not_configured";
+
+    /// <summary>Envoi d'un morceau à une position qui n'est pas la fin de ce que le serveur a reçu.</summary>
+    public const string OffsetMismatch = "offset_mismatch";
+
+    /// <summary>Une publication de ce jeu est en cours (autre administrateur).</summary>
+    public const string PublicationInProgress = "publication_in_progress";
+
+    /// <summary>Espace disque insuffisant sur le serveur.</summary>
+    public const string InsufficientStorage = "insufficient_storage";
 }

src/GameLauncher.Contracts/Publishing/ManifestCheck.cs

@@ -0,0 +1,207 @@
+using System.Text.Json;
+using System.Text.RegularExpressions;
+
+namespace GameLauncher.Contracts.Publishing;
+
+/// <summary>Ce que contient un manifest.json contrôlé.</summary>
+/// <param name="Objects">Objets à servir (empreinte en minuscules → taille), une fois chacun.</param>
+public sealed record ManifestSummary(
+    string GameId,
+    string Version,
+    string Executable,
+    string ArchiveName,
+    long ArchiveSize,
+    string ArchiveSha256,
+    IReadOnlyDictionary<string, long> Objects,
+    int FileCount,
+    long TotalSize,
+    string? NotesTitle);
+
+/// <summary>
+/// Contrôle d'un manifest.json produit par ManifestBuilder, AVANT de le publier : par le launcher
+/// (dossier choisi) et par le serveur (manifest reçu). Mêmes règles des deux côtés ; le serveur ne fait
+/// confiance à rien de ce qu'il reçoit.
+///  • identifiant de jeu et version attendus ;
+///  • archive : simple nom de fichier .zip (jamais un chemin), taille et empreinte valides ;
+///  • objets dans « objects/ » (seul dossier écrit par la publication) ;
+///  • chemins des fichiers relatifs et sûrs (ni « .. », ni chemin absolu, ni « : »), sans doublon ;
+///  • exécutable présent parmi les fichiers ; tailles et nombre de fichiers bornés.
+/// </summary>
+public static partial class ManifestCheck
+{
+    [GeneratedRegex(@"\A[A-Za-z0-9._+\-]{1,64}\z")]
+    private static partial Regex VersionRegex();
+
+    [GeneratedRegex(@"\A[A-Za-z0-9][A-Za-z0-9._+\-]{0,127}\.zip\z", RegexOptions.IgnoreCase)]
+    private static partial Regex ArchiveNameRegex();
+
+    private static readonly JsonDocumentOptions ReadOptions = new()
+    {
+        CommentHandling = JsonCommentHandling.Skip,
+        AllowTrailingCommas = true,
+        MaxDepth = 64
+    };
+
+    public static bool IsValidVersion(string? version) => version is not null && VersionRegex().IsMatch(version);
+
+    /// <summary>Contrôle ; null (et <paramref name="errors"/> rempli) si le manifest n'est pas publiable.</summary>
+    public static ManifestSummary? Check(ReadOnlySpan<byte> json, string expectedGameId, string? expectedVersion, List<string> errors)
+    {
+        if (json.StartsWith(new byte[] { 0xEF, 0xBB, 0xBF })) json = json[3..];
+        if (json.Length > PublishingLimits.MaxManifestBytes)
+        {
+            errors.Add("Manifest trop volumineux.");
+            return null;
+        }
+
+        JsonDocument document;
+        try
+        {
+            document = JsonDocument.Parse(json.ToArray(), ReadOptions);
+        }
+        catch (JsonException ex)
+        {
+            errors.Add($"Manifest illisible : {ex.Message}");
+            return null;
+        }
+
+        using (document)
+        {
+            var root = document.RootElement;
+            if (root.ValueKind != JsonValueKind.Object)
+            {
+                errors.Add("Manifest illisible : objet JSON attendu.");
+                return null;
+            }
+
+            if (Get(root, "formatVersion") is { } format && (format.ValueKind != JsonValueKind.Number || format.GetDouble() != 1))
+                errors.Add("Format de manifest non pris en charge (formatVersion 1 attendu).");
+
+            var gameId = Text(root, "gameId");
+            if (!string.Equals(gameId, expectedGameId, StringComparison.OrdinalIgnoreCase))
+                errors.Add($"Ce manifest est celui du jeu « {gameId} », pas de « {expectedGameId} ».");
+
+            var version = Text(root, "version");
+            if (!IsValidVersion(version))
+                errors.Add($"Version « {version} » invalide (lettres, chiffres, « . », « _ », « + », « - »).");
+            else if (expectedVersion is not null && !string.Equals(version, expectedVersion, StringComparison.Ordinal))
+                errors.Add($"Le manifest est celui de la version {version}, pas {expectedVersion}.");
+
+            var objectsBase = Text(root, "objectsBaseUrl");
+            if (!string.IsNullOrEmpty(objectsBase) && objectsBase is not ("objects/" or "objects"))
+                errors.Add($"« objectsBaseUrl » doit être « objects/ » (manifest produit par ManifestBuilder), pas « {objectsBase} ».");
+
+            // Archive (installation initiale)
+            string archiveName = "", archiveSha = "";
+            long archiveSize = 0;
+            if (Get(root, "archive") is { ValueKind: JsonValueKind.Object } archive)
+            {
+                archiveName = Text(archive, "url") ?? "";
+                archiveSha = (Text(archive, "sha256") ?? "").ToLowerInvariant();
+                archiveSize = Number(archive, "size");
+                if (!ArchiveNameRegex().IsMatch(archiveName))
+                    errors.Add($"Archive « {archiveName} » : simple nom de fichier .zip attendu (à côté du manifest).");
+                if (!PublishingLimits.IsValidSha256(archiveSha)) errors.Add("Archive : empreinte SHA-256 invalide.");
+                if (archiveSize <= 0 || archiveSize > PublishingLimits.MaxArchiveBytes) errors.Add("Archive : taille invalide.");
+            }
+            else
+            {
+                errors.Add("Archive absente du manifest.");
+            }
+
+            // Fichiers du jeu
+            var objects = new Dictionary<string, long>(StringComparer.Ordinal);
+            var paths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+            long totalSize = 0;
+            var fileCount = 0;
+            if (Get(root, "files") is { ValueKind: JsonValueKind.Array } files)
+            {
+                fileCount = files.GetArrayLength();
+                if (fileCount == 0) errors.Add("Aucun fichier dans le manifest.");
+                if (fileCount > PublishingLimits.MaxFiles) errors.Add($"Trop de fichiers ({fileCount} ; {PublishingLimits.MaxFiles} au plus).");
+                else
+                {
+                    var index = 0;
+                    foreach (var file in files.EnumerateArray())
+                    {
+                        index++;
+                        if (errors.Count > 20) break;
+                        if (file.ValueKind != JsonValueKind.Object)
+                        {
+                            errors.Add($"Fichier n° {index} invalide.");
+                            continue;
+                        }
+                        var path = Text(file, "path") ?? "";
+                        var sha = (Text(file, "sha256") ?? "").ToLowerInvariant();
+                        var size = Number(file, "size");
+                        if (!IsSafeRelativePath(path)) errors.Add($"Chemin non autorisé : « {path} ».");
+                        else if (!paths.Add(path.Replace('\\', '/'))) errors.Add($"Fichier en double : « {path} ».");
+                        if (!PublishingLimits.IsValidSha256(sha)) errors.Add($"« {path} » : empreinte SHA-256 invalide.");
+                        else if (size < 0 || size > PublishingLimits.MaxObjectBytes) errors.Add($"« {path} » : taille invalide.");
+                        else if (objects.TryGetValue(sha, out var known) && known != size)
+                            errors.Add($"« {path} » : même empreinte qu'un autre fichier mais taille différente.");
+                        else
+                        {
+                            objects[sha] = size;
+                            totalSize += size;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                errors.Add("Liste des fichiers absente du manifest.");
+            }
+
+            var executable = (Text(root, "executable") ?? "").Replace('\\', '/');
+            if (string.IsNullOrWhiteSpace(executable)) errors.Add("Exécutable absent du manifest.");
+            else if (!paths.Contains(executable)) errors.Add($"L'exécutable « {executable} » ne fait pas partie des fichiers.");
+
+            if (Get(root, "changelog") is { } changelog && changelog.ValueKind is not (JsonValueKind.Array or JsonValueKind.Null))
+                errors.Add("Notes de version (« changelog ») : liste attendue.");
+
+            if (errors.Count > 0) return null;
+            return new ManifestSummary(gameId!, version!, executable, archiveName, archiveSize, archiveSha, objects, fileCount, totalSize,
+                                       NotesTitle(root, version!));
+        }
+    }
+
+    /// <summary>Chemin relatif sûr (mêmes règles que le launcher pour l'installation).</summary>
+    public static bool IsSafeRelativePath(string path)
+    {
+        if (string.IsNullOrWhiteSpace(path) || path.Length > 1024 || path.Any(char.IsControl)) return false;
+        var p = path.Replace('\\', '/');
+        if (p.StartsWith('/') || p.Contains(':')) return false;
+        return p.Split('/').All(s => s.Length > 0 && s != "." && s != "..");
+    }
+
+    /// <summary>Chemin d'un objet sous le dossier du manifest : « objects/ab/abcdef….bin ».</summary>
+    public static string ObjectPath(string sha256)
+    {
+        var h = sha256.ToLowerInvariant();
+        return $"objects/{h[..2]}/{h}.bin";
+    }
+
+    private static string? NotesTitle(JsonElement root, string version)
+    {
+        if (Get(root, "changelog") is not { ValueKind: JsonValueKind.Array } changelog) return null;
+        foreach (var entry in changelog.EnumerateArray())
+            if (entry.ValueKind == JsonValueKind.Object && Text(entry, "version") == version)
+                return Text(entry, "title");
+        return null;
+    }
+
+    private static JsonElement? Get(JsonElement element, string name)
+    {
+        foreach (var property in element.EnumerateObject())
+            if (string.Equals(property.Name, name, StringComparison.OrdinalIgnoreCase))
+                return property.Value;
+        return null;
+    }
+
+    private static string? Text(JsonElement element, string name) =>
+        Get(element, name) is { ValueKind: JsonValueKind.String } value ? value.GetString() : null;
+
+    private static long Number(JsonElement element, string name) =>
+        Get(element, name) is { ValueKind: JsonValueKind.Number } value && value.TryGetInt64(out var number) ? number : -1;
+}

src/GameLauncher.Contracts/Publishing/PublishingDtos.cs

@@ -0,0 +1,160 @@
+using System.Text.RegularExpressions;
+
+namespace GameLauncher.Contracts.Publishing;
+
+/// <summary>
+/// Bornes de la publication d'une version depuis le menu d'administration. Les requêtes d'envoi
+/// (morceaux de fichiers) sont les seules à dépasser 64 Ko : elles ont leur propre limite, côté
+/// serveur et côté nginx (server/deploy/nginx-publications.conf).
+/// </summary>
+public static partial class PublishingLimits
+{
+    /// <summary>Taille d'un morceau envoyé par le launcher.</summary>
+    public const int ChunkBytes = 4 * 1024 * 1024;
+
+    /// <summary>Taille maximale d'un corps de requête d'envoi accepté par le serveur (morceau ou lot d'objets).</summary>
+    public const long MaxUploadRequestBytes = 8L * 1024 * 1024 + 64 * 1024;
+
+    /// <summary>Objets de cette taille au plus : envoyés par lots ; au-delà, en morceaux.</summary>
+    public const int BatchObjectMaxBytes = 2 * 1024 * 1024;
+
+    public const int MaxObjectsPerBatch = 500;
+    public const int MaxFiles = 10_000;
+    public const long MaxManifestBytes = 64L * 1024 * 1024;
+    public const long MaxObjectBytes = 32L * 1024 * 1024 * 1024;
+    public const long MaxArchiveBytes = 128L * 1024 * 1024 * 1024;
+
+    /// <summary>Publication abandonnée (aucun envoi) au-delà de cette durée : supprimée par le serveur.</summary>
+    public static readonly TimeSpan IdleExpiry = TimeSpan.FromHours(48);
+
+    /// <summary>Publication d'un autre administrateur sans envoi depuis cette durée : peut être remplacée.</summary>
+    public static readonly TimeSpan TakeoverAfter = TimeSpan.FromMinutes(30);
+
+    /// <summary>Type du corps d'un lot d'objets (voir <see cref="ObjectBatch"/>).</summary>
+    public const string ObjectBatchContentType = "application/vnd.gamelauncher.objects";
+
+    public const string BinaryContentType = "application/octet-stream";
+
+    [GeneratedRegex(@"\A[0-9a-f]{32}\z")]
+    private static partial Regex PublicationIdRegex();
+
+    [GeneratedRegex(@"\A[0-9a-fA-F]{64}\z")]
+    private static partial Regex Sha256Regex();
+
+    public static bool IsValidPublicationId(string? id) => id is not null && PublicationIdRegex().IsMatch(id);
+
+    public static bool IsValidSha256(string? value) => value is not null && Sha256Regex().IsMatch(value);
+}
+
+/// <summary>Début (ou reprise) de la publication d'une version : le manifest est envoyé ensuite.</summary>
+public sealed record PublicationStartRequest
+{
+    public string Version { get; init; } = "";
+
+    /// <summary>Empreinte du manifest.json à publier : même manifest = reprise d'un envoi interrompu.</summary>
+    public string ManifestSha256 { get; init; } = "";
+
+    public long ManifestSize { get; init; }
+}
+
+/// <summary>État d'une publication en cours (ce qui reste à envoyer).</summary>
+public sealed record PublicationState
+{
+    public string PublicationId { get; init; } = "";
+    public string GameId { get; init; } = "";
+    public string Version { get; init; } = "";
+
+    /// <summary>Version en ligne au début de la publication (vide : aucune).</summary>
+    public string PublishedVersion { get; init; } = "";
+
+    /// <summary>Vrai si un envoi interrompu de ce même manifest est repris.</summary>
+    public bool Resumed { get; init; }
+
+    public long ManifestSize { get; init; }
+    public long ManifestReceived { get; init; }
+
+    /// <summary>Manifest reçu et contrôlé : la liste des objets à envoyer est connue.</summary>
+    public bool ManifestAccepted { get; init; }
+
+    /// <summary>Fichiers (objets) du manifest ; ceux déjà présents sur le serveur ne sont pas renvoyés.</summary>
+    public int ObjectCount { get; init; }
+    public int ObjectsOnServer { get; init; }
+
+    /// <summary>Empreintes des objets restant à envoyer.</summary>
+    public List<string> PendingObjects { get; init; } = new();
+
+    /// <summary>Objets envoyés en partie (empreinte → octets reçus) : l'envoi reprend à cet endroit.</summary>
+    public Dictionary<string, long> PartialObjects { get; init; } = new();
+
+    public string? ArchiveName { get; init; }
+    public long ArchiveSize { get; init; }
+    public long ArchiveReceived { get; init; }
+    public bool ArchiveComplete { get; init; }
+
+    public DateTimeOffset ExpiresAt { get; init; }
+}
+
+/// <summary>Réponse à l'envoi d'un morceau (ou d'un lot d'objets).</summary>
+public sealed record ChunkResult
+{
+    /// <summary>Octets reçus pour ce fichier (ou nombre d'objets enregistrés pour un lot).</summary>
+    public long Received { get; init; }
+
+    /// <summary>Fichier complet et vérifié (SHA-256).</summary>
+    public bool Complete { get; init; }
+}
+
+/// <summary>Version publiée.</summary>
+public sealed record PublicationResult
+{
+    public string GameId { get; init; } = "";
+    public string Version { get; init; } = "";
+    public string PreviousVersion { get; init; } = "";
+    public string ManifestSha256 { get; init; } = "";
+    public int ObjectsAdded { get; init; }
+    public bool ArchiveAdded { get; init; }
+}
+
+/// <summary>
+/// Lot d'objets dans un seul corps de requête (petits fichiers : une requête pour des centaines de
+/// fichiers) : pour chaque objet, empreinte SHA-256 (32 octets bruts), taille (8 octets, gros-boutiste)
+/// puis contenu.
+/// </summary>
+public static class ObjectBatch
+{
+    public const int HeaderBytes = 32 + 8;
+
+    public static byte[] Write(IReadOnlyList<(string Sha256, byte[] Data)> objects)
+    {
+        var total = objects.Sum(o => (long)HeaderBytes + o.Data.Length);
+        var buffer = new byte[total];
+        var position = 0;
+        foreach (var (sha, data) in objects)
+        {
+            Convert.FromHexString(sha).CopyTo(buffer, position);
+            System.Buffers.Binary.BinaryPrimitives.WriteInt64BigEndian(buffer.AsSpan(position + 32, 8), data.Length);
+            data.CopyTo(buffer, position + HeaderBytes);
+            position += HeaderBytes + data.Length;
+        }
+        return buffer;
+    }
+
+    /// <summary>Lecture bornée ; <see cref="InvalidDataException"/> si le lot est mal formé.</summary>
+    public static List<(string Sha256, ReadOnlyMemory<byte> Data)> Read(ReadOnlyMemory<byte> body, int maxObjects)
+    {
+        var result = new List<(string, ReadOnlyMemory<byte>)>();
+        var position = 0;
+        while (position < body.Length)
+        {
+            if (result.Count >= maxObjects) throw new InvalidDataException($"Lot trop grand ({maxObjects} objets au plus).");
+            if (body.Length - position < HeaderBytes) throw new InvalidDataException("Lot d'objets tronqué.");
+            var span = body.Span;
+            var sha = Convert.ToHexString(span.Slice(position, 32)).ToLowerInvariant();
+            var length = System.Buffers.Binary.BinaryPrimitives.ReadInt64BigEndian(span.Slice(position + 32, 8));
+            if (length < 0 || length > body.Length - position - HeaderBytes) throw new InvalidDataException("Lot d'objets tronqué.");
+            result.Add((sha, body.Slice(position + HeaderBytes, (int)length)));
+            position += HeaderBytes + (int)length;
+        }
+        return result;
+    }
+}

src/GameLauncher.Core/Catalog/CatalogMerger.cs

@@ -0,0 +1,87 @@
+using System.Runtime.CompilerServices;
+using GameLauncher.Contracts.Catalog;
+using GameLauncher.Core.Models;
+using GameLauncher.Core.Utils;
+
+namespace GameLauncher.Core.Catalog;
+
+/// <summary>
+/// Applique le catalogue aux jeux déclarés dans launcher.json — affichage uniquement :
+///  • jeux inconnus de launcher.json : ignorés (le serveur ne peut ni ajouter ni retirer un jeu) ;
+///  • nom AFFICHÉ seulement (raccourci, registre et dossier des données gardent le nom de launcher.json) ;
+///  • thème : seulement un thème intégré au launcher ;
+///  • images : seulement des fichiers du cache local (téléchargés et contrôlés par <see cref="CatalogService"/>) ;
+///  • jeu masqué : toujours affiché s'il est installé sur le PC ou demandé (raccourci, désinstallation),
+///    et au moins un jeu reste affiché.
+/// Peut être appliqué plusieurs fois (cache au démarrage, puis version à jour) : les valeurs de
+/// launcher.json sont rétablies avant chaque application.
+/// </summary>
+public static class CatalogMerger
+{
+    /// <summary>Valeurs de launcher.json avant toute application du catalogue.</summary>
+    private sealed record Baseline(string Tagline, string? WebsiteUrl, string Theme, string? Icon, string? Background, int UpdateCheckIntervalMinutes);
+
+    private static readonly ConditionalWeakTable<LauncherConfig, Baseline> Baselines = new();
+
+    /// <param name="builtInThemes">Thèmes intégrés au launcher (les autres valeurs sont ignorées).</param>
+    /// <param name="localImage">Fichier local d'une image du catalogue (null : pas encore en cache → image par défaut).</param>
+    /// <param name="mustStayVisible">Jeu installé sur ce PC, ou demandé en ligne de commande : jamais masqué.</param>
+    public static void Apply(LauncherCatalog launcher, CatalogDocument catalog, IReadOnlyCollection<string> builtInThemes,
+                             Func<string?, string?> localImage, Func<LauncherConfig, bool> mustStayVisible)
+    {
+        var declared = launcher.DeclaredGames;
+        foreach (var game in declared)
+        {
+            Restore(game);
+            if (!catalog.Games.TryGetValue(game.GameId, out var entry)) continue;
+
+            if (entry.GameName is { } name) game.DisplayName = name;
+            if (entry.Tagline is { } tagline) game.Tagline = tagline;
+            if (entry.Description is { } description) game.Description = description;
+            if (entry.WebsiteUrl is { } website) game.WebsiteUrl = website;
+            if (entry.Links is { Count: > 0 } links)
+                game.Links = links.Select(l => new GameLink(l.Kind, l.Label ?? CatalogLinkKinds.DefaultLabel(l.Kind), l.Url)).ToList();
+            if (entry.Theme is { } theme)
+            {
+                if (builtInThemes.Contains(theme, StringComparer.OrdinalIgnoreCase)) game.Theme = theme;
+                else Log.Warn($"Catalogue : thème « {theme} » inconnu de cette version du launcher ({game.GameId}), ignoré.");
+            }
+            if (localImage(entry.Icon) is { } icon) game.Icon = icon;
+            if (localImage(entry.Background) is { } background) game.Background = background;
+            if (entry.UpdateCheckIntervalMinutes is { } interval) game.UpdateCheckIntervalMinutes = interval;
+        }
+
+        // Ordre : celui du catalogue, puis les autres jeux dans l'ordre de launcher.json.
+        var ordered = new List<LauncherConfig>();
+        foreach (var id in catalog.Launcher?.GameOrder ?? new List<string>())
+            if (declared.FirstOrDefault(g => string.Equals(g.GameId, id, StringComparison.OrdinalIgnoreCase)) is { } game && !ordered.Contains(game))
+                ordered.Add(game);
+        ordered.AddRange(declared.Where(g => !ordered.Contains(g)));
+
+        // Visibilité.
+        var visible = ordered.Where(g => !(catalog.Games.TryGetValue(g.GameId, out var entry) && entry.Hidden == true) || mustStayVisible(g))
+                             .ToList();
+        if (visible.Count == 0) visible.Add(ordered[0]);
+
+        var launcherName = catalog.Launcher?.LauncherName ?? launcher.DeclaredLauncherName;
+        var defaultGame = catalog.Launcher?.DefaultGame is { } requested && visible.Any(g => string.Equals(g.GameId, requested, StringComparison.OrdinalIgnoreCase))
+            ? requested
+            : launcher.DeclaredDefaultGameId;
+        launcher.ApplyDisplay(launcherName, defaultGame, visible);
+    }
+
+    /// <summary>Rétablit les valeurs de launcher.json (enregistrées à la première application).</summary>
+    private static void Restore(LauncherConfig game)
+    {
+        var baseline = Baselines.GetValue(game, g => new Baseline(g.Tagline, g.WebsiteUrl, g.Theme, g.Icon, g.Background, g.UpdateCheckIntervalMinutes));
+        game.DisplayName = null;
+        game.Description = null;
+        game.Links = Array.Empty<GameLink>();
+        game.Tagline = baseline.Tagline;
+        game.WebsiteUrl = baseline.WebsiteUrl;
+        game.Theme = baseline.Theme;
+        game.Icon = baseline.Icon;
+        game.Background = baseline.Background;
+        game.UpdateCheckIntervalMinutes = baseline.UpdateCheckIntervalMinutes;
+    }
+}

src/GameLauncher.Core/Catalog/CatalogService.cs

@@ -0,0 +1,190 @@
+using System.Collections.Concurrent;
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.Json;
+using GameLauncher.Contracts;
+using GameLauncher.Contracts.Catalog;
+using GameLauncher.Core.Services;
+using GameLauncher.Core.Utils;
+
+namespace GameLauncher.Core.Catalog;
+
+/// <summary>
+/// Catalogue des jeux côté joueur : catalog.json (statique, publié depuis le menu d'administration)
+/// téléchargé, contrôlé et borné (<see cref="CatalogRules"/> : une valeur invalide est ignorée), puis
+/// mis en cache dans le dossier des données du launcher. Sans réseau : dernier cache, sinon les
+/// valeurs de launcher.json. Images (icône, fond) : PNG ou JPEG du serveur du catalogue, 4 Mo au plus,
+/// téléchargées une fois puis conservées en cache.
+/// </summary>
+public sealed class CatalogService
+{
+    public const long MaxImageBytes = 4 * 1024 * 1024;
+    private const string FolderName = "catalog";
+
+    private readonly Func<Uri, long, CancellationToken, Task<byte[]>> _download;
+    private readonly Uri _catalogUrl;
+
+    /// <summary>Téléchargements d'images en cours (une même image n'est téléchargée qu'une fois à la fois).</summary>
+    private readonly ConcurrentDictionary<string, Lazy<Task<string?>>> _imageDownloads = new(StringComparer.OrdinalIgnoreCase);
+
+    public CatalogService(HttpDownloader http, string dataDirectory, Uri catalogUrl)
+        : this(http.GetBytesAsync, dataDirectory, catalogUrl) { }
+
+    /// <param name="download">Téléchargement borné (tests : téléchargement simulé).</param>
+    public CatalogService(Func<Uri, long, CancellationToken, Task<byte[]>> download, string dataDirectory, Uri catalogUrl)
+    {
+        _download = download;
+        _catalogUrl = catalogUrl;
+        Directory = Path.Combine(dataDirectory, FolderName);
+        CachePath = Path.Combine(Directory, "catalog.json");
+        ImagesDirectory = Path.Combine(Directory, "images");
+    }
+
+    public string Directory { get; }
+    public string CachePath { get; }
+    public string ImagesDirectory { get; }
+
+    /// <summary>Catalogue du cache (null : absent ou illisible).</summary>
+    public CatalogDocument? LoadCached()
+    {
+        try
+        {
+            if (!File.Exists(CachePath) || new FileInfo(CachePath).Length > CatalogRules.MaxFileBytes) return null;
+            return Parse(File.ReadAllBytes(CachePath), out _);
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or JsonException or InvalidDataException)
+        {
+            Log.Warn($"Catalogue en cache illisible : {ex.Message}");
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Télécharge le catalogue, le contrôle et le met en cache. Null si le serveur ne répond pas ou si
+    /// le fichier est inutilisable (le cache est alors conservé tel quel).
+    /// </summary>
+    public async Task<CatalogDocument?> FetchAsync(CancellationToken ct = default)
+    {
+        try
+        {
+            var bytes = await _download(_catalogUrl, CatalogRules.MaxFileBytes, ct).ConfigureAwait(false);
+            var catalog = Parse(bytes, out var errors);
+            if (catalog is null) return null;
+            foreach (var error in errors.Take(10)) Log.Warn($"Catalogue : valeur ignorée — {error}");
+
+            System.IO.Directory.CreateDirectory(Directory);
+            FileUtil.WriteAllTextAtomic(CachePath, JsonSerializer.Serialize(catalog, ApiJson.Options));
+            return catalog;
+        }
+        catch (OperationCanceledException) when (ct.IsCancellationRequested)
+        {
+            throw;
+        }
+        catch (Exception ex) when (ex is HttpRequestException or TimeoutException or IOException or UnauthorizedAccessException or
+                                       InvalidDataException or JsonException or OperationCanceledException)
+        {
+            Log.Warn($"Catalogue des jeux indisponible ({_catalogUrl.Host}) : {ex.Message}");
+            return null;
+        }
+    }
+
+    /// <summary>Lecture + contrôle (valeurs invalides retirées). Null si le format est inconnu.</summary>
+    private CatalogDocument? Parse(byte[] bytes, out List<string> errors)
+    {
+        errors = new List<string>();
+        var raw = JsonSerializer.Deserialize<CatalogDocument>(Encoding.UTF8.GetString(bytes).TrimStart(''), ApiJson.Options)
+                  ?? throw new InvalidDataException("catalogue vide");
+        if (raw.Format != CatalogDocument.FormatName || raw.Version != CatalogDocument.CurrentVersion)
+        {
+            Log.Warn($"Catalogue ignoré : format « {raw.Format} » version {raw.Version} non pris en charge par cette version du launcher.");
+            return null;
+        }
+        return CatalogRules.Normalize(raw, _catalogUrl.Host, errors);
+    }
+
+    // ------------------------------------------------------------------ Images
+
+    /// <summary>Image déjà en cache (null sinon) : utilisable immédiatement, même hors ligne.</summary>
+    public string? CachedImage(string? url)
+    {
+        if (ImagePath(url) is not { } path) return null;
+        return File.Exists(path) ? path : null;
+    }
+
+    /// <summary>
+    /// Image en cache, sinon téléchargée (PNG ou JPEG contrôlé). Null si indisponible. Appels simultanés
+    /// pour la même image (démarrage, puis arrière-plan) : un seul téléchargement, partagé.
+    /// </summary>
+    public Task<string?> GetImageAsync(string? url)
+    {
+        if (ImagePath(url) is not { } path) return Task.FromResult<string?>(null);
+        if (File.Exists(path)) return Task.FromResult<string?>(path);
+        var download = _imageDownloads.GetOrAdd(path, _ => new Lazy<Task<string?>>(() => DownloadImageAsync(url!, path)));
+        return download.Value;
+    }
+
+    private async Task<string?> DownloadImageAsync(string url, string path)
+    {
+        var temp = $"{path}.{Guid.NewGuid():N}.tmp";
+        try
+        {
+            var bytes = await _download(new Uri(url), MaxImageBytes, CancellationToken.None).ConfigureAwait(false);
+            if (!IsPngOrJpeg(bytes)) throw new InvalidDataException("ce n'est pas une image PNG ou JPEG");
+            System.IO.Directory.CreateDirectory(ImagesDirectory);
+            await File.WriteAllBytesAsync(temp, bytes).ConfigureAwait(false);
+            File.Move(temp, path, overwrite: true);
+            return path;
+        }
+        catch (Exception ex) when (ex is HttpRequestException or TimeoutException or IOException or UnauthorizedAccessException or
+                                       InvalidDataException or OperationCanceledException)
+        {
+            FileUtil.TryDeleteFile(temp);
+            Log.Warn($"Image du catalogue indisponible ({url}) : {ex.Message}");
+            return null;
+        }
+        finally
+        {
+            _imageDownloads.TryRemove(path, out _);
+        }
+    }
+
+    /// <summary>Supprime les images du cache qui ne sont plus utilisées par le catalogue.</summary>
+    public void PruneImages(CatalogDocument catalog)
+    {
+        try
+        {
+            if (!System.IO.Directory.Exists(ImagesDirectory)) return;
+            var used = catalog.Games.Values.SelectMany(g => new[] { g.Icon, g.Background })
+                              .Select(ImagePath).Where(p => p is not null).ToHashSet(StringComparer.OrdinalIgnoreCase);
+            foreach (var file in System.IO.Directory.GetFiles(ImagesDirectory))
+            {
+                if (used.Contains(file)) continue;
+                // Fichier temporaire : peut-être un téléchargement en cours (supprimé s'il est ancien).
+                if (file.EndsWith(".tmp", StringComparison.OrdinalIgnoreCase) &&
+                    DateTime.UtcNow - File.GetLastWriteTimeUtc(file) < TimeSpan.FromHours(1))
+                    continue;
+                FileUtil.TryDeleteFile(file);
+            }
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            Log.Warn($"Nettoyage des images du catalogue : {ex.Message}");
+        }
+    }
+
+    /// <summary>Fichier du cache pour une image (nom = empreinte de l'adresse) ; null si l'adresse est refusée.</summary>
+    private string? ImagePath(string? url)
+    {
+        if (string.IsNullOrWhiteSpace(url) || !Uri.TryCreate(url, UriKind.Absolute, out var uri) ||
+            !string.Equals(uri.Host, _catalogUrl.Host, StringComparison.OrdinalIgnoreCase) ||
+            !(uri.Scheme == Uri.UriSchemeHttps || (uri.Scheme == Uri.UriSchemeHttp && uri.IsLoopback)))
+            return null;
+        var extension = uri.AbsolutePath.EndsWith(".png", StringComparison.OrdinalIgnoreCase) ? ".png" : ".jpg";
+        var name = Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(uri.AbsoluteUri)))[..32].ToLowerInvariant();
+        return Path.Combine(ImagesDirectory, name + extension);
+    }
+
+    internal static bool IsPngOrJpeg(ReadOnlySpan<byte> data) =>
+        data.StartsWith(new byte[] { 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A }) ||
+        data.StartsWith(new byte[] { 0xFF, 0xD8, 0xFF });
+}

src/GameLauncher.Core/GameLauncher.Core.csproj

@@ -13,4 +13,9 @@
     <Platforms>AnyCPU;x64</Platforms>
   </PropertyGroup>
 
+  <ItemGroup>
+    <!-- Catalogue des jeux (catalog.json) : format et règles partagés avec la Launcher API. -->
+    <ProjectReference Include="..\GameLauncher.Contracts\GameLauncher.Contracts.csproj" />
+  </ItemGroup>
+
 </Project>

src/GameLauncher.Core/Models/GameManifest.cs

@@ -1,5 +1,6 @@
 using System.Text.Json.Serialization;
 using System.Text.RegularExpressions;
+using GameLauncher.Contracts.Changelog;
 using GameLauncher.Core.Utils;
 
 namespace GameLauncher.Core.Models;

src/GameLauncher.Core/Models/LauncherCatalog.cs

@@ -15,7 +15,7 @@ namespace GameLauncher.Core.Models;
 /// </summary>
 public sealed class LauncherCatalog
 {
-    private static readonly string[] RootOnlyProperties = { "games", "launcherId", "launcherName", "defaultGame", "launcherUpdateUrl", "dataFolder" };
+    private static readonly string[] RootOnlyProperties = { "games", "launcherId", "launcherName", "defaultGame", "launcherUpdateUrl", "dataFolder", "apiUrl", "catalogUrl" };
 
     /// <summary>Nom par défaut du dossier des données du launcher (%AppData%\&lt;Publisher&gt;\GameLauncher).</summary>
     public const string DefaultDataFolderName = "GameLauncher";
@@ -34,21 +34,34 @@ public sealed class LauncherCatalog
         Publisher = publisher;
         DefaultGameId = defaultGameId;
         Games = games;
+        DeclaredGames = games;
+        DeclaredLauncherName = launcherName;
+        DeclaredDefaultGameId = defaultGameId;
         IsMultiGameFormat = isMultiGameFormat;
     }
 
     /// <summary>Identifiant technique du launcher (dossier de données, instance unique).</summary>
     public string LauncherId { get; }
 
-    /// <summary>Nom affiché dans la barre de titre lorsque plusieurs jeux sont proposés.</summary>
-    public string LauncherName { get; }
+    /// <summary>Nom affiché dans la barre de titre lorsque plusieurs jeux sont proposés (modifiable par le catalogue).</summary>
+    public string LauncherName { get; private set; }
 
     public string Publisher { get; }
 
     /// <summary>Jeu sélectionné au premier lancement (sinon le premier de la liste).</summary>
-    public string? DefaultGameId { get; }
+    public string? DefaultGameId { get; private set; }
 
-    public IReadOnlyList<LauncherConfig> Games { get; }
+    /// <summary>Jeux affichés, dans l'ordre (le catalogue peut changer l'ordre et masquer des jeux non installés).</summary>
+    public IReadOnlyList<LauncherConfig> Games { get; private set; }
+
+    /// <summary>Tous les jeux déclarés dans launcher.json, y compris ceux masqués par le catalogue.</summary>
+    public IReadOnlyList<LauncherConfig> DeclaredGames { get; }
+
+    /// <summary>Nom du launcher selon launcher.json (avant le catalogue).</summary>
+    public string DeclaredLauncherName { get; }
+
+    /// <summary>Jeu par défaut selon launcher.json (avant le catalogue).</summary>
+    public string? DeclaredDefaultGameId { get; }
 
     /// <summary>Vrai si launcher.json utilise le tableau "games" (même avec un seul jeu).</summary>
     public bool IsMultiGameFormat { get; }
@@ -62,6 +75,37 @@ public sealed class LauncherCatalog
     /// </summary>
     public string? LauncherUpdateUrl { get; private set; }
 
+    /// <summary>
+    /// Adresse de la Launcher API (menu d'administration), ex. « https://launcher.lanisys.fr/api/ ».
+    /// Facultatif : sans cette valeur, le menu d'administration est désactivé. Le launcher publié ne
+    /// lit cette valeur que dans le launcher.json INTÉGRÉ à l'exe (voir App) : un fichier posé à côté
+    /// ne peut pas rediriger les administrateurs vers un autre serveur.
+    /// Une valeur invalide ne bloque jamais le launcher des joueurs : elle est ignorée
+    /// (<see cref="ApiUrl"/> null) et expliquée dans <see cref="ApiUrlError"/>.
+    /// </summary>
+    public string? ApiUrl { get; private set; }
+
+    /// <summary>Raison pour laquelle « apiUrl » a été ignorée (valeur invalide), sinon null.</summary>
+    public string? ApiUrlError { get; private set; }
+
+    /// <summary>
+    /// Adresse du catalogue des jeux (catalog.json : informations modifiables publiées depuis le menu
+    /// d'administration), ex. « https://launcher.lanisys.fr/catalog/catalog.json ». Facultatif. Comme
+    /// <see cref="ApiUrl"/>, le launcher publié ne la lit que dans le launcher.json intégré à l'exe.
+    /// </summary>
+    public string? CatalogUrl { get; private set; }
+
+    /// <summary>Raison pour laquelle « catalogUrl » a été ignorée (valeur invalide), sinon null.</summary>
+    public string? CatalogUrlError { get; private set; }
+
+    /// <summary>Affichage modifié par le catalogue (voir Catalog.CatalogMerger).</summary>
+    internal void ApplyDisplay(string launcherName, string? defaultGameId, IReadOnlyList<LauncherConfig> games)
+    {
+        LauncherName = launcherName;
+        DefaultGameId = defaultGameId;
+        Games = games;
+    }
+
     /// <summary>
     /// Nom du dossier des données du launcher et de sa clé de registre (« dataFolder » dans
     /// launcher.json, « GameLauncher » par défaut). Indépendant de <see cref="LauncherId"/>, qui
@@ -202,10 +246,11 @@ public sealed class LauncherCatalog
             ? $@"Local\{Publisher}.{Games[0].GameId}.Launcher"
             : $@"Local\{Publisher}.{LauncherId}";
 
+    /// <summary>Jeu déclaré dans launcher.json (même s'il est masqué par le catalogue).</summary>
     public LauncherConfig? Find(string? gameId) =>
         string.IsNullOrWhiteSpace(gameId)
             ? null
-            : Games.FirstOrDefault(g => string.Equals(g.GameId, gameId, StringComparison.OrdinalIgnoreCase));
+            : DeclaredGames.FirstOrDefault(g => string.Equals(g.GameId, gameId, StringComparison.OrdinalIgnoreCase));
 
     public static LauncherCatalog Load(string path)
     {
@@ -240,6 +285,10 @@ public sealed class LauncherCatalog
                                        new[] { single }, isMultiGameFormat: false)
             {
                 LauncherUpdateUrl = ReadUpdateUrl(root),
+                ApiUrl = ReadApiUrl(root, out var singleApiUrlError),
+                ApiUrlError = singleApiUrlError,
+                CatalogUrl = ReadTrustedUrl(root, "catalogUrl", "https://launcher.exemple.fr/catalog/catalog.json", out var singleCatalogError),
+                CatalogUrlError = singleCatalogError,
                 DataFolderName = ReadDataFolder(root)
             };
         }
@@ -291,6 +340,10 @@ public sealed class LauncherCatalog
         return new LauncherCatalog(launcherId, launcherName, publisher, defaultGame, games, isMultiGameFormat: true)
         {
             LauncherUpdateUrl = ReadUpdateUrl(root),
+            ApiUrl = ReadApiUrl(root, out var apiUrlError),
+            ApiUrlError = apiUrlError,
+            CatalogUrl = ReadTrustedUrl(root, "catalogUrl", "https://launcher.exemple.fr/catalog/catalog.json", out var catalogError),
+            CatalogUrlError = catalogError,
             DataFolderName = ReadDataFolder(root)
         };
     }
@@ -315,6 +368,42 @@ public sealed class LauncherCatalog
         return uri.ToString();
     }
 
+    /// <summary>« apiUrl » : adresse https absolue, sans paramètres (http accepté seulement en local, pour les tests).</summary>
+    /// <summary>Adresse https absolue, sans paramètres ni identifiants (http autorisé seulement en local) ; null si absente ou invalide.</summary>
+    private static string? ReadTrustedUrl(JsonObject root, string name, string example, out string? error)
+    {
+        error = null;
+        var node = Get(root, name);
+        if (node is null) return null;
+        var url = node is JsonValue value && value.TryGetValue<string>(out var text) ? text : null;
+        if (url is not null && string.IsNullOrWhiteSpace(url)) return null;
+        if (url is null || !Uri.TryCreate(url.Trim(), UriKind.Absolute, out var uri) ||
+            !(uri.Scheme == Uri.UriSchemeHttps || (uri.Scheme == Uri.UriSchemeHttp && uri.IsLoopback)) ||
+            !string.IsNullOrEmpty(uri.Query) || !string.IsNullOrEmpty(uri.Fragment) || !string.IsNullOrEmpty(uri.UserInfo))
+        {
+            error = $"launcher.json : {name} ignorée, elle doit être une adresse https:// absolue sans paramètres, ex. \"{example}\".";
+            return null;
+        }
+        return uri.AbsoluteUri;
+    }
+
+    private static string? ReadApiUrl(JsonObject root, out string? error)
+    {
+        error = null;
+        var node = Get(root, "apiUrl");
+        if (node is null) return null;
+        var url = node is JsonValue value && value.TryGetValue<string>(out var text) ? text : null;
+        if (url is not null && string.IsNullOrWhiteSpace(url)) return null;
+        if (url is null || !Uri.TryCreate(url.Trim(), UriKind.Absolute, out var uri) ||
+            !(uri.Scheme == Uri.UriSchemeHttps || (uri.Scheme == Uri.UriSchemeHttp && uri.IsLoopback)) ||
+            !string.IsNullOrEmpty(uri.Query) || !string.IsNullOrEmpty(uri.Fragment) || !string.IsNullOrEmpty(uri.UserInfo))
+        {
+            error = "launcher.json : apiUrl ignorée, elle doit être une adresse https:// absolue sans paramètres, ex. \"https://launcher.exemple.fr/api/\".";
+            return null;
+        }
+        return uri.AbsoluteUri.EndsWith('/') ? uri.AbsoluteUri : uri.AbsoluteUri + "/";
+    }
+
     /// <summary>Lecture d'une propriété sans tenir compte de la casse (gameId / GameId…).</summary>
     private static JsonNode? Get(JsonObject obj, string name)
     {

src/GameLauncher.Core/Models/LauncherConfig.cs

@@ -1,4 +1,5 @@
 using System.Text.Json;
+using System.Text.Json.Serialization;
 using GameLauncher.Core.Utils;
 
 namespace GameLauncher.Core.Models;
@@ -47,6 +48,27 @@ public sealed class LauncherConfig
 	/// <summary>Image de fond remplaçant celle du thème (image, chemin relatif au launcher). Facultatif.</summary>
 	public string? Background { get; set; }
 
+	// ------------------------------------------------------------------ Catalogue (affichage modifiable)
+
+	/// <summary>
+	/// Nom AFFICHÉ, donné par le catalogue. <see cref="GameName"/> reste le nom de launcher.json : celui
+	/// du raccourci du Bureau, de « Applications installées » et du dossier des données du jeu.
+	/// </summary>
+	[JsonIgnore]
+	public string? DisplayName { get; set; }
+
+	/// <summary>Nom à afficher : celui du catalogue, sinon celui de launcher.json.</summary>
+	[JsonIgnore]
+	public string ShownName => string.IsNullOrWhiteSpace(DisplayName) ? GameName : DisplayName;
+
+	/// <summary>Présentation du jeu (catalogue, texte brut de plusieurs lignes).</summary>
+	[JsonIgnore]
+	public string? Description { get; set; }
+
+	/// <summary>Liens affichés sous la présentation (catalogue).</summary>
+	[JsonIgnore]
+	public IReadOnlyList<GameLink> Links { get; set; } = Array.Empty<GameLink>();
+
 	/// <summary>
 	/// Dossier des données du jeu Unity : « Société\Produit » des Player Settings de Unity
 	/// (ex. "LanisysGames\\Exovival Zombie Reborn"). Sert à ouvrir, depuis les paramètres du jeu,
@@ -127,3 +149,7 @@ public sealed class LauncherConfig
 										   part.Trim() == part && part.IndexOfAny(invalid) < 0);
 	}
 }
+
+/// <summary>Lien affiché sous la présentation d'un jeu (Discord, YouTube…), adresse https contrôlée.</summary>
+/// <param name="Kind">Type de lien (icône intégrée) : website, discord, youtube, x, twitch, steam, other.</param>
+public sealed record GameLink(string Kind, string Label, string Url);

src/GameLauncher.Core/SelfUpdate/LauncherRelease.cs

@@ -1,5 +1,6 @@
 using System.Text.Json.Serialization;
 using System.Text.RegularExpressions;
+using GameLauncher.Contracts.Changelog;
 using GameLauncher.Core.Models;
 
 namespace GameLauncher.Core.SelfUpdate;

src/GameLauncher.Core/Services/ChangelogHistory.cs

@@ -0,0 +1,61 @@
+using System.Net;
+using System.Text.Json;
+using GameLauncher.Contracts.Changelog;
+using GameLauncher.Core.Models;
+using GameLauncher.Core.Utils;
+
+namespace GameLauncher.Core.Services;
+
+/// <summary>
+/// Historique des notes de version lors d'une publication (ManifestBuilder). Avec --remote-manifest,
+/// l'historique est repris du manifest EN LIGNE : les corrections faites depuis le menu
+/// d'administration ne sont pas écrasées par le manifest.json local (resté dans son état d'origine).
+/// </summary>
+public static class ChangelogHistory
+{
+    /// <summary>
+    /// Manifest publié (null s'il n'existe pas encore : première publication). Toute autre erreur
+    /// (réseau, fichier illisible) est signalée : publier sans elle perdrait les corrections en ligne.
+    /// </summary>
+    public static async Task<GameManifest?> FetchPublishedAsync(HttpDownloader http, Uri url, CancellationToken ct = default)
+    {
+        if (url.Scheme != Uri.UriSchemeHttps && !(url.Scheme == Uri.UriSchemeHttp && url.IsLoopback))
+            throw new ArgumentException($"Adresse du manifest en ligne : https:// attendu ({url}).");
+
+        string json;
+        try
+        {
+            json = await http.GetStringAsync(url, ct).ConfigureAwait(false);
+        }
+        catch (HttpRequestException ex) when (ex.StatusCode == HttpStatusCode.NotFound)
+        {
+            return null;
+        }
+
+        try
+        {
+            return JsonSerializer.Deserialize<GameManifest>(json, JsonDefaults.Options)
+                   ?? throw new InvalidDataException("manifest vide");
+        }
+        catch (JsonException ex)
+        {
+            throw new InvalidDataException($"manifest illisible : {ex.Message}", ex);
+        }
+    }
+
+    /// <summary>
+    /// Notes de la version publiée en tête, puis l'historique (sans cette version si elle est republiée
+    /// avec de nouvelles notes), bornés comme par le launcher. Sans nouvelles notes (pas de --notes),
+    /// les notes existantes de la version, éventuellement corrigées en ligne, sont conservées.
+    /// </summary>
+    public static List<ChangelogEntry> Build(IEnumerable<ChangelogEntry?>? history, ChangelogEntry entry)
+    {
+        var list = (history ?? Enumerable.Empty<ChangelogEntry?>()).OfType<ChangelogEntry>().ToList();
+        if (!entry.IsEmpty)
+        {
+            list.RemoveAll(c => string.Equals(c.Version, entry.Version, StringComparison.Ordinal));
+            list.Insert(0, entry);
+        }
+        return ChangelogLimits.Normalize(list);
+    }
+}

src/GameLauncher.Core/Services/ChangelogParser.cs

@@ -1,4 +1,5 @@
 using System.Text.RegularExpressions;
+using GameLauncher.Contracts.Changelog;
 using GameLauncher.Core.Models;
 using GameLauncher.Core.Utils;
 

src/GameLauncher.Core/Services/HttpDownloader.cs

@@ -11,8 +11,15 @@ namespace GameLauncher.Core.Services;
 public sealed class HttpDownloader : IDisposable
 {
     private static readonly TimeSpan StallTimeout = TimeSpan.FromSeconds(30);
+    private const int MaxSameHostRedirects = 3;
     private readonly HttpClient _http;
 
+    /// <summary>
+    /// Client SANS redirection automatique (catalogue, images) : une redirection n'est suivie que vers le
+    /// même serveur, après vérification, et aucune requête ne part vers un autre serveur.
+    /// </summary>
+    private readonly HttpClient _strictHttp;
+
     public HttpDownloader(string userAgent)
     {
         var handler = new SocketsHttpHandler
@@ -25,6 +32,15 @@ public sealed class HttpDownloader : IDisposable
         };
         _http = new HttpClient(handler) { Timeout = Timeout.InfiniteTimeSpan };
         _http.DefaultRequestHeaders.UserAgent.ParseAdd(userAgent);
+
+        _strictHttp = new HttpClient(new SocketsHttpHandler
+        {
+            AllowAutoRedirect = false,
+            AutomaticDecompression = DecompressionMethods.None,
+            ConnectTimeout = TimeSpan.FromSeconds(15),
+            PooledConnectionLifetime = TimeSpan.FromMinutes(5)
+        }) { Timeout = Timeout.InfiniteTimeSpan };
+        _strictHttp.DefaultRequestHeaders.UserAgent.ParseAdd(userAgent);
     }
 
     /// <summary>Taille maximale par défaut d'un document texte (manifest du jeu).</summary>
@@ -79,6 +95,64 @@ public sealed class HttpDownloader : IDisposable
         }
     }
 
+    /// <summary>
+    /// Télécharge un petit fichier en mémoire (catalogue, image) sans passer par les caches, en
+    /// refusant toute redirection vers un autre serveur ou vers une adresse non https.
+    /// Au-delà de <paramref name="maxBytes"/> octets, le téléchargement est interrompu.
+    /// </summary>
+    public async Task<byte[]> GetBytesAsync(Uri uri, long maxBytes, CancellationToken ct)
+    {
+        using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct);
+        timeout.CancelAfter(TimeSpan.FromSeconds(30));
+
+        try
+        {
+            var current = uri;
+            HttpResponseMessage response;
+            for (var redirects = 0; ; redirects++)
+            {
+                using var request = new HttpRequestMessage(HttpMethod.Get, current);
+                request.Headers.CacheControl = new CacheControlHeaderValue { NoCache = true, NoStore = true };
+                request.Headers.Pragma.ParseAdd("no-cache");
+                response = await _strictHttp.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, timeout.Token)
+                                            .ConfigureAwait(false);
+                var status = (int)response.StatusCode;
+                if (status is < 300 or > 399 || status == 304) break;
+
+                // Redirection : suivie seulement vers le même serveur (hôte, schéma, port), quelques fois au plus.
+                var location = response.Headers.Location;
+                response.Dispose();
+                var next = location is null ? null : location.IsAbsoluteUri ? location : new Uri(current, location);
+                if (next is null || redirects >= MaxSameHostRedirects ||
+                    !string.Equals(next.Host, uri.Host, StringComparison.OrdinalIgnoreCase) ||
+                    next.Scheme != uri.Scheme || next.Port != uri.Port)
+                    throw new InvalidDataException($"Redirection refusée ({uri.Host} → {next?.Host ?? "?"}).");
+                current = next;
+            }
+
+            using var _ = response;
+            response.EnsureSuccessStatusCode();
+            if (response.Content.Headers.ContentLength > maxBytes)
+                throw new InvalidDataException($"Réponse du serveur trop volumineuse ({uri.AbsolutePath}).");
+
+            await using var stream = await response.Content.ReadAsStreamAsync(timeout.Token).ConfigureAwait(false);
+            using var buffer = new MemoryStream();
+            var chunk = new byte[81920];
+            int read;
+            while ((read = await stream.ReadAsync(chunk, timeout.Token).ConfigureAwait(false)) > 0)
+            {
+                if (buffer.Length + read > maxBytes)
+                    throw new InvalidDataException($"Réponse du serveur trop volumineuse ({uri.AbsolutePath}).");
+                buffer.Write(chunk, 0, read);
+            }
+            return buffer.ToArray();
+        }
+        catch (OperationCanceledException) when (!ct.IsCancellationRequested)
+        {
+            throw new TimeoutException($"Le serveur ne répond pas ({uri.Host}).");
+        }
+    }
+
     /// <summary>
     /// Télécharge <paramref name="uri"/> vers <paramref name="destination"/>.
     /// Si <paramref name="allowResume"/> est vrai et qu'un fichier partiel existe, le
@@ -155,5 +229,9 @@ public sealed class HttpDownloader : IDisposable
             throw new IOException($"Téléchargement incomplet ({Format.Bytes(position)} sur {Format.Bytes(expectedSize)}).");
     }
 
-    public void Dispose() => _http.Dispose();
+    public void Dispose()
+    {
+        _http.Dispose();
+        _strictHttp.Dispose();
+    }
 }

src/GameLauncher.Core/Services/ManifestClient.cs

@@ -1,4 +1,5 @@
 using System.Text.Json;
+using GameLauncher.Contracts.Changelog;
 using GameLauncher.Core.Models;
 using GameLauncher.Core.Utils;
 

src/GameLauncher.Modules.Admin/AdminModule.cs

@@ -0,0 +1,25 @@
+using GameLauncher.Modules.Admin.ViewModels;
+
+namespace GameLauncher.Modules.Admin;
+
+/// <summary>
+/// Module « Administration » : la fenêtre d'administration elle-même (connexion, invitation,
+/// verrouillage) et sa page d'accueil. Les autres pages (Jeux, Notes de version, Publication,
+/// Administrateurs, Audit) seront déclarées par leurs propres modules.
+/// </summary>
+public sealed class AdminModule : ILauncherModule
+{
+    public string Id => "admin";
+
+    public string DisplayName => "Administration";
+
+    public void Register(IModuleRegistry registry) =>
+        registry.AddAdminPanel(new AdminPanelDescriptor(
+            DashboardPanelViewModel.PanelId,
+            "Tableau de bord",
+            "Votre compte, la session en cours et l'état du serveur.",
+            "ViewDashboard",
+            RequiredPermission: null,
+            Order: 0,
+            context => new DashboardPanelViewModel(context)));
+}

src/GameLauncher.Modules.Admin/Catalog/CatalogAdminModule.cs

@@ -0,0 +1,25 @@
+using GameLauncher.Contracts.Security;
+
+namespace GameLauncher.Modules.Admin.Catalog;
+
+/// <summary>
+/// Module « Catalogue des jeux » : page « Jeux » du menu d'administration (informations modifiables
+/// des jeux déclarés dans launcher.json, publiées dans catalog.json). Permission games.edit.
+/// </summary>
+public sealed class CatalogAdminModule : ILauncherModule
+{
+    public string Id => "catalog";
+
+    public string DisplayName => "Catalogue des jeux";
+
+    public void Register(IModuleRegistry registry) =>
+        registry.AddAdminPanel(new AdminPanelDescriptor(
+            GamesPanelViewModel.PanelId,
+            "Jeux",
+            "Ce que le launcher affiche pour chaque jeu : nom, accroche, présentation, liens, apparence, ordre. " +
+            "Les jeux eux-mêmes restent déclarés dans launcher.json.",
+            "Gamepad",
+            AdminPermissions.GamesEdit,
+            Order: 10,
+            context => new GamesPanelViewModel(context)));
+}

src/GameLauncher.Modules.Admin/Catalog/CatalogEditors.cs

@@ -0,0 +1,311 @@
+using System.Collections.ObjectModel;
+using System.Globalization;
+using GameLauncher.Contracts.Catalog;
+using GameLauncher.Core.Models;
+using GameLauncher.Mvvm;
+
+namespace GameLauncher.Modules.Admin.Catalog;
+
+/// <summary>Choix d'une liste (null : valeur par défaut de launcher.json).</summary>
+public sealed record Choice(string? Value, string Label)
+{
+    /// <summary>Texte affiché par les listes déroulantes.</summary>
+    public override string ToString() => Label;
+}
+
+/// <summary>Partie modifiable de la page « Jeux » (réglages du launcher ou un jeu).</summary>
+public abstract class CatalogEditor : ObservableObject
+{
+    private readonly Action _changed;
+
+    protected CatalogEditor(Action changed) => _changed = changed;
+
+    public abstract string Title { get; }
+    public abstract string Subtitle { get; }
+    public abstract string IconKey { get; }
+
+    /// <summary>Modifié depuis la dernière publication (pastille dans la liste).</summary>
+    public bool IsDirty
+    {
+        get => _isDirty;
+        internal set => SetProperty(ref _isDirty, value);
+    }
+    private bool _isDirty;
+
+    protected bool Set<T>(ref T field, T value, [System.Runtime.CompilerServices.CallerMemberName] string? name = null)
+    {
+        if (!SetProperty(ref field, value, name)) return false;
+        _changed();
+        return true;
+    }
+
+    protected void Changed() => _changed();
+
+    protected static string? Clean(string? text) => string.IsNullOrWhiteSpace(text) ? null : text.Trim();
+}
+
+/// <summary>Réglages du launcher : nom, jeu affiché au premier lancement.</summary>
+public sealed class LauncherEditor : CatalogEditor
+{
+    private string _launcherName = "";
+    private Choice _defaultGame;
+
+    public LauncherEditor(string declaredName, string? declaredDefault, IReadOnlyList<LauncherConfig> games, Action changed) : base(changed)
+    {
+        DeclaredName = declaredName;
+        GameChoices = new[] { new Choice(null, declaredDefault is null ? "Par défaut (premier jeu)" : $"Par défaut ({declaredDefault})") }
+            .Concat(games.Select(g => new Choice(g.GameId, $"{g.GameName} ({g.GameId})"))).ToList();
+        _defaultGame = GameChoices[0];
+    }
+
+    public override string Title => "Launcher";
+    public override string Subtitle => "Nom, jeu affiché au démarrage, ordre des jeux";
+    public override string IconKey => "Tune";
+
+    public string DeclaredName { get; }
+    public string DefaultNameHint => $"Vide : « {DeclaredName} » (launcher.json).";
+
+    public string LauncherName
+    {
+        get => _launcherName;
+        set => Set(ref _launcherName, value ?? "");
+    }
+
+    public IReadOnlyList<Choice> GameChoices { get; }
+
+    public Choice DefaultGame
+    {
+        get => _defaultGame;
+        set
+        {
+            if (value is not null) Set(ref _defaultGame, value); // null : liste de l'écran en cours de remplacement
+        }
+    }
+
+    internal void Load(CatalogLauncher? launcher)
+    {
+        _launcherName = launcher?.LauncherName ?? "";
+        _defaultGame = GameChoices.FirstOrDefault(c => c.Value is not null &&
+                           string.Equals(c.Value, launcher?.DefaultGame, StringComparison.OrdinalIgnoreCase)) ?? GameChoices[0];
+        OnPropertyChanged(nameof(LauncherName));
+        OnPropertyChanged(nameof(DefaultGame));
+    }
+
+    internal CatalogLauncher? ToCatalog(IReadOnlyList<string> order, IReadOnlyList<string> declaredOrder)
+    {
+        var name = Clean(LauncherName);
+        var gameOrder = order.SequenceEqual(declaredOrder, StringComparer.OrdinalIgnoreCase) ? null : order.ToList();
+        return name is null && DefaultGame.Value is null && gameOrder is null
+            ? null
+            : new CatalogLauncher { LauncherName = name, DefaultGame = DefaultGame.Value, GameOrder = gameOrder };
+    }
+}
+
+/// <summary>Un jeu déclaré dans launcher.json, et ses informations modifiables.</summary>
+public sealed class GameEditor : CatalogEditor
+{
+    private string _gameName = "", _tagline = "", _description = "", _websiteUrl = "", _icon = "", _background = "", _interval = "";
+    private Choice _theme;
+    private bool _hidden;
+
+    public GameEditor(LauncherConfig declared, IReadOnlyList<string> themes, Action changed) : base(changed)
+    {
+        Declared = declared;
+        _builtInThemeChoices = new[] { new Choice(null, $"Par défaut ({ThemeOf(declared)})") }
+            .Concat(themes.Select(t => new Choice(t, t))).ToList();
+        ThemeChoices = _builtInThemeChoices;
+        _theme = ThemeChoices[0];
+        LinkKinds = CatalogLinkKinds.All.Select(k => new Choice(k, CatalogLinkKinds.DefaultLabel(k))).ToList();
+        AddLinkCommand = new RelayCommand(AddLink, () => Links.Count < CatalogRules.MaxLinks);
+        Links.CollectionChanged += (_, _) =>
+        {
+            AddLinkCommand.RaiseCanExecuteChanged();
+            Changed();
+        };
+    }
+
+    public LauncherConfig Declared { get; }
+    public string GameId => Declared.GameId;
+
+    public override string Title => string.IsNullOrWhiteSpace(GameName) ? Declared.GameName : GameName.Trim();
+    public override string Subtitle => Hidden ? $"{GameId} · masqué" : GameId;
+    public override string IconKey => Hidden ? "EyeOffOutline" : "Gamepad";
+
+    // ------------------------------------------------------------------ Valeurs (vide : launcher.json)
+
+    public string GameName
+    {
+        get => _gameName;
+        set
+        {
+            if (Set(ref _gameName, value ?? "")) OnPropertyChanged(nameof(Title));
+        }
+    }
+
+    public string Tagline { get => _tagline; set => Set(ref _tagline, value ?? ""); }
+    public string Description { get => _description; set => Set(ref _description, value ?? ""); }
+    public string WebsiteUrl { get => _websiteUrl; set => Set(ref _websiteUrl, value ?? ""); }
+    public string Icon { get => _icon; set => Set(ref _icon, value ?? ""); }
+    public string Background { get => _background; set => Set(ref _background, value ?? ""); }
+
+    /// <summary>Minutes entre deux recherches de mise à jour (vide : launcher.json ; 0 : désactivé).</summary>
+    public string UpdateInterval { get => _interval; set => Set(ref _interval, value ?? ""); }
+
+    private readonly IReadOnlyList<Choice> _builtInThemeChoices;
+
+    /// <summary>Thèmes intégrés (+ celui du catalogue publié s'il est inconnu de ce launcher, pour ne pas l'effacer en silence).</summary>
+    public IReadOnlyList<Choice> ThemeChoices { get; private set; }
+
+    public Choice Theme
+    {
+        get => _theme;
+        set
+        {
+            // null : liste des thèmes remplacée à l'écran (rechargement), pas un choix de l'administrateur.
+            if (value is not null) Set(ref _theme, value);
+        }
+    }
+
+    public bool Hidden
+    {
+        get => _hidden;
+        set
+        {
+            if (!Set(ref _hidden, value)) return;
+            OnPropertyChanged(nameof(Subtitle));
+            OnPropertyChanged(nameof(IconKey));
+        }
+    }
+
+    public ObservableCollection<LinkEditor> Links { get; } = new();
+    public IReadOnlyList<Choice> LinkKinds { get; }
+    public RelayCommand AddLinkCommand { get; }
+
+    // ------------------------------------------------------------------ Valeurs de launcher.json (rappel)
+
+    public string NameHint => $"Vide : « {Declared.GameName} ». Le raccourci et « Applications installées » gardent ce nom.";
+    public string TaglineHint => string.IsNullOrWhiteSpace(Declared.Tagline) ? "Vide : aucune accroche." : $"Vide : « {Declared.Tagline} ».";
+    public string WebsiteHint => string.IsNullOrWhiteSpace(Declared.WebsiteUrl) ? "Adresse https. Vide : aucun site." : $"Adresse https. Vide : {Declared.WebsiteUrl}";
+    public string IntervalHint => $"0 : désactivé, ou {CatalogRules.MinUpdateInterval} à {CatalogRules.MaxUpdateInterval} minutes. Vide : {Declared.UpdateCheckIntervalMinutes} (launcher.json).";
+    public string ImageHint => "Image .png ou .jpg (4 Mo au plus) déposée sur le serveur du catalogue, ex. https://…/catalog/images/fond.jpg. " +
+                               "Les launchers gardent l'image en cache : pour la changer, déposez-la sous un NOUVEAU nom. Vide : image de launcher.json.";
+
+    private static string ThemeOf(LauncherConfig config) => string.IsNullOrWhiteSpace(config.Theme) ? "default" : config.Theme;
+
+    private void AddLink()
+    {
+        if (Links.Count >= CatalogRules.MaxLinks) return;
+        Links.Add(new LinkEditor(LinkKinds, CatalogLinkKinds.Website, "", "", Changed, RemoveLink));
+    }
+
+    private void RemoveLink(LinkEditor link) => Links.Remove(link);
+
+    internal void Load(CatalogGame? game)
+    {
+        _gameName = game?.GameName ?? "";
+        _tagline = game?.Tagline ?? "";
+        _description = game?.Description ?? "";
+        _websiteUrl = game?.WebsiteUrl ?? "";
+        _icon = game?.Icon ?? "";
+        _background = game?.Background ?? "";
+        _interval = game?.UpdateCheckIntervalMinutes?.ToString(CultureInfo.InvariantCulture) ?? "";
+        _hidden = game?.Hidden == true;
+        ThemeChoices = _builtInThemeChoices;
+        _theme = ThemeChoices.FirstOrDefault(c => c.Value is not null && string.Equals(c.Value, game?.Theme, StringComparison.OrdinalIgnoreCase))
+                 ?? ThemeChoices[0];
+        if (_theme.Value is null && game?.Theme is { } unknown)
+        {
+            // Publié par une autre version du launcher : conservé (les launchers qui ne le connaissent pas l'ignorent).
+            _theme = new Choice(unknown, $"{unknown} (inconnu de ce launcher)");
+            ThemeChoices = _builtInThemeChoices.Append(_theme).ToList();
+        }
+        Links.Clear();
+        foreach (var link in game?.Links ?? new List<CatalogLink>())
+            Links.Add(new LinkEditor(LinkKinds, link.Kind, link.Label ?? "", link.Url, Changed, RemoveLink));
+        foreach (var name in new[] { nameof(GameName), nameof(Tagline), nameof(Description), nameof(WebsiteUrl), nameof(Icon), nameof(Background),
+                                     nameof(UpdateInterval), nameof(Hidden), nameof(ThemeChoices), nameof(Theme), nameof(Title), nameof(Subtitle), nameof(IconKey) })
+            OnPropertyChanged(name);
+    }
+
+    /// <summary>Valeurs saisies (contrôlées ensuite par <see cref="CatalogRules"/>) ; null si tout est par défaut.</summary>
+    internal CatalogGame? ToCatalog(List<string> errors)
+    {
+        int? interval = null;
+        if (!string.IsNullOrWhiteSpace(UpdateInterval))
+        {
+            if (int.TryParse(UpdateInterval.Trim(), NumberStyles.None, CultureInfo.InvariantCulture, out var minutes)) interval = minutes;
+            else errors.Add($"Jeu « {GameId} » : intervalle de mise à jour : nombre de minutes attendu.");
+        }
+        var links = Links.Where(l => !l.IsEmpty)
+                         .Select(l => new CatalogLink { Kind = l.Kind.Value ?? CatalogLinkKinds.Other, Label = Clean(l.Label), Url = l.Url.Trim() })
+                         .ToList();
+        var game = new CatalogGame
+        {
+            GameName = Clean(GameName),
+            Tagline = Clean(Tagline),
+            Description = Clean(Description),
+            WebsiteUrl = Clean(WebsiteUrl),
+            Links = links.Count == 0 ? null : links,
+            Theme = Theme.Value,
+            Icon = Clean(Icon),
+            Background = Clean(Background),
+            UpdateCheckIntervalMinutes = interval,
+            Hidden = Hidden ? true : null
+        };
+        return game is { GameName: null, Tagline: null, Description: null, WebsiteUrl: null, Links: null, Theme: null, Icon: null,
+                         Background: null, UpdateCheckIntervalMinutes: null, Hidden: null }
+            ? null
+            : game;
+    }
+}
+
+/// <summary>Lien d'un jeu (Discord, YouTube…).</summary>
+public sealed class LinkEditor : ObservableObject
+{
+    private readonly Action _changed;
+    private Choice _kind;
+    private string _label, _url;
+
+    public LinkEditor(IReadOnlyList<Choice> kinds, string kind, string label, string url, Action changed, Action<LinkEditor> remove)
+    {
+        Kinds = kinds;
+        _kind = kinds.FirstOrDefault(k => k.Value == kind) ?? kinds[^1];
+        _label = label;
+        _url = url;
+        _changed = changed;
+        RemoveCommand = new RelayCommand(() => remove(this));
+    }
+
+    public IReadOnlyList<Choice> Kinds { get; }
+
+    public Choice Kind
+    {
+        get => _kind;
+        set
+        {
+            if (value is not null && SetProperty(ref _kind, value)) _changed(); // null : liste de l'écran en cours de remplacement
+        }
+    }
+
+    public string Label
+    {
+        get => _label;
+        set
+        {
+            if (SetProperty(ref _label, value ?? "")) _changed();
+        }
+    }
+
+    public string Url
+    {
+        get => _url;
+        set
+        {
+            if (SetProperty(ref _url, value ?? "")) _changed();
+        }
+    }
+
+    public RelayCommand RemoveCommand { get; }
+
+    internal bool IsEmpty => string.IsNullOrWhiteSpace(Url) && string.IsNullOrWhiteSpace(Label);
+}

src/GameLauncher.Modules.Admin/Catalog/GamesPanelViewModel.cs

@@ -0,0 +1,269 @@
+using System.Collections.ObjectModel;
+using System.Text.Json;
+using GameLauncher.ApiClient;
+using GameLauncher.Contracts;
+using GameLauncher.Contracts.Catalog;
+using GameLauncher.Contracts.Dtos;
+using GameLauncher.Core.Utils;
+using GameLauncher.Mvvm;
+
+namespace GameLauncher.Modules.Admin.Catalog;
+
+/// <summary>
+/// Page « Jeux » : informations modifiables des jeux déclarés dans launcher.json, publiées dans le
+/// catalogue (catalog.json) que les launchers des joueurs lisent au démarrage.
+///  • une liste : « Launcher » (nom, jeu par défaut) puis les jeux, dans l'ordre d'affichage (↑ ↓) ;
+///  • champ vide = valeur de launcher.json (rappelée sous le champ) ;
+///  • « Publier » : contrôle complet (mêmes règles que le serveur), requête signée, révision attendue
+///    (si quelqu'un a publié entre-temps : rechargement proposé, rien n'est écrasé).
+/// </summary>
+public sealed class GamesPanelViewModel : AdminPanelViewModel
+{
+    public const string PanelId = "catalog.games";
+
+    private CatalogState? _state;
+    private CatalogEditor? _selected;
+    private string? _statusMessage;
+    private bool _loading;
+    private string _publishedSnapshot = "";
+    private bool _hasChanges;
+    private bool _hasConflict;
+
+    public GamesPanelViewModel(IAdminContext context) : base(context)
+    {
+        Launcher = new LauncherEditor(context.LauncherName, context.DefaultGameId, context.Games, OnEdited);
+        foreach (var game in context.Games) Games.Add(new GameEditor(game, context.Themes, OnEdited));
+        RebuildItems(Launcher);
+
+        PublishCommand = new AsyncRelayCommand(PublishAsync, () => !IsBusy && HasChanges && PublishingEnabled);
+        ReloadCommand = new AsyncRelayCommand(ReloadAsync, () => !IsBusy);
+        MoveUpCommand = new RelayCommand(() => Move(-1), () => CanMove(-1));
+        MoveDownCommand = new RelayCommand(() => Move(+1), () => CanMove(+1));
+    }
+
+    public LauncherEditor Launcher { get; }
+
+    /// <summary>Jeux dans l'ordre d'affichage du launcher.</summary>
+    public ObservableCollection<GameEditor> Games { get; } = new();
+
+    /// <summary>Liste affichée : « Launcher », puis les jeux.</summary>
+    public ObservableCollection<CatalogEditor> Items { get; } = new();
+
+    public CatalogEditor? Selected
+    {
+        get => _selected;
+        set
+        {
+            if (!SetProperty(ref _selected, value)) return;
+            MoveUpCommand.RaiseCanExecuteChanged();
+            MoveDownCommand.RaiseCanExecuteChanged();
+        }
+    }
+
+    public bool PublishingEnabled => _state?.PublishingEnabled == true;
+    public bool ShowPublishingDisabled => _state is not null && !_state.PublishingEnabled;
+    public string? PublicUrl => _state?.PublicUrl;
+
+    /// <summary>« Révision 12, publiée le 31/10/2026 à 08:42 » / « Jamais publié ».</summary>
+    public string RevisionText => _state?.Catalog is not { } catalog ? "" :
+        catalog.Revision == 0 ? "Jamais publié : le launcher utilise les valeurs de launcher.json."
+        : $"Révision {catalog.Revision}" + (catalog.UpdatedAt is { } at ? $", publiée le {at.ToLocalTime():dd/MM/yyyy à HH:mm}" : "") + ".";
+
+    public bool HasChanges
+    {
+        get => _hasChanges;
+        private set
+        {
+            if (!SetProperty(ref _hasChanges, value)) return;
+            PublishCommand.RaiseCanExecuteChanged();
+        }
+    }
+
+    /// <summary>Quelqu'un a publié entre-temps : il faut recharger.</summary>
+    public bool HasConflict
+    {
+        get => _hasConflict;
+        private set => SetProperty(ref _hasConflict, value);
+    }
+
+    public string? StatusMessage
+    {
+        get => _statusMessage;
+        private set
+        {
+            if (SetProperty(ref _statusMessage, value)) OnPropertyChanged(nameof(HasStatus));
+        }
+    }
+
+    public bool HasStatus => !string.IsNullOrEmpty(StatusMessage);
+
+    public AsyncRelayCommand PublishCommand { get; }
+    public AsyncRelayCommand ReloadCommand { get; }
+    public RelayCommand MoveUpCommand { get; }
+    public RelayCommand MoveDownCommand { get; }
+
+    /// <summary>Faux pendant un chargement ou une publication : la saisie attend la réponse du serveur.</summary>
+    public bool IsEditable => !IsBusy;
+
+    protected override void OnBusyChanged()
+    {
+        OnPropertyChanged(nameof(IsEditable));
+        PublishCommand.RaiseCanExecuteChanged();
+        ReloadCommand.RaiseCanExecuteChanged();
+    }
+
+    protected override Task OnActivatedAsync(bool firstTime) => firstTime ? LoadAsync() : Task.CompletedTask;
+
+    // ------------------------------------------------------------------ Chargement
+
+    public Task LoadAsync() => RunAsync(async () =>
+    {
+        var state = await Context.Session.GetCatalogAsync();
+        Apply(state);
+        StatusMessage = null;
+    });
+
+    private async Task ReloadAsync()
+    {
+        if (HasChanges && !Context.Dialogs.Confirm("Abandonner les modifications ?",
+                "Les modifications non publiées seront perdues : la page affichera le catalogue actuellement publié.",
+                "Abandonner et recharger"))
+            return;
+        await LoadAsync();
+    }
+
+    /// <summary>Affiche un catalogue (chargé ou publié) et en fait la référence « sans modification ».</summary>
+    private void Apply(CatalogState state)
+    {
+        _loading = true;
+        try
+        {
+            _state = state;
+            var catalog = state.Catalog;
+            Launcher.Load(catalog.Launcher);
+            foreach (var game in Games) game.Load(catalog.Games.TryGetValue(game.GameId, out var entry) ? entry : null);
+
+            // Ordre : celui du catalogue, puis les autres jeux dans l'ordre de launcher.json.
+            var ordered = new List<GameEditor>();
+            foreach (var id in catalog.Launcher?.GameOrder ?? new List<string>())
+                if (Games.FirstOrDefault(g => string.Equals(g.GameId, id, StringComparison.OrdinalIgnoreCase)) is { } game && !ordered.Contains(game))
+                    ordered.Add(game);
+            ordered.AddRange(Context.Games.Select(d => Games.First(g => g.Declared == d)).Where(g => !ordered.Contains(g)));
+            var selected = Selected;
+            Games.Clear();
+            foreach (var game in ordered) Games.Add(game);
+            RebuildItems(selected);
+        }
+        finally
+        {
+            _loading = false;
+        }
+
+        _publishedSnapshot = Snapshot(BuildCatalog(new List<string>()));
+        HasConflict = false;
+        RefreshDirty();
+        foreach (var name in new[] { nameof(PublishingEnabled), nameof(ShowPublishingDisabled), nameof(PublicUrl), nameof(RevisionText) })
+            OnPropertyChanged(name);
+        PublishCommand.RaiseCanExecuteChanged();
+    }
+
+    // ------------------------------------------------------------------ Publication
+
+    private Task PublishAsync() => RunAsync(async () =>
+    {
+        if (_state is not { } state) return;
+        var errors = new List<string>();
+        var draft = BuildCatalog(errors);
+        var imageHost = Uri.TryCreate(state.PublicUrl, UriKind.Absolute, out var url) ? url.Host : null;
+        var normalized = CatalogRules.Normalize(draft, imageHost, errors);
+        if (errors.Count == 0 && CatalogRules.PublishedSize(normalized) > CatalogRules.MaxFileBytes)
+            errors.Add($"Catalogue trop volumineux (au plus {CatalogRules.MaxFileBytes / 1024} Ko) : raccourcissez les descriptions.");
+        if (errors.Count > 0)
+        {
+            Context.Dialogs.ShowMessage("Valeurs à corriger", string.Join("\n", errors.Distinct().Take(12)), ModuleMessageKind.Warning);
+            return;
+        }
+
+        try
+        {
+            var published = await Context.Session.PublishCatalogAsync(draft, state.Catalog.Revision);
+            Apply(published);
+            StatusMessage = $"Catalogue publié (révision {published.Catalog.Revision}). Les launchers l'appliquent à leur prochain démarrage.";
+            Log.Info($"Administration : catalogue publié (révision {published.Catalog.Revision}).");
+        }
+        catch (ApiException ex) when (ex.Status == 409 && ex.Code == ApiErrorCodes.RevisionConflict)
+        {
+            HasConflict = true;
+            Context.Dialogs.ShowMessage("Publié entre-temps",
+                "Quelqu'un a publié le catalogue pendant vos modifications. Rechargez la page pour partir de sa version " +
+                "(vos modifications non publiées seront perdues : notez-les si besoin).", ModuleMessageKind.Warning);
+        }
+    });
+
+    /// <summary>Catalogue saisi (ordre affiché, champs non vides).</summary>
+    private CatalogDocument BuildCatalog(List<string> errors)
+    {
+        var games = new Dictionary<string, CatalogGame>(StringComparer.OrdinalIgnoreCase);
+        foreach (var game in Games)
+            if (game.ToCatalog(errors) is { } entry) games[game.GameId] = entry;
+        return new CatalogDocument
+        {
+            Launcher = Launcher.ToCatalog(Games.Select(g => g.GameId).ToList(), Context.Games.Select(g => g.GameId).ToList()),
+            Games = games
+        };
+    }
+
+    // ------------------------------------------------------------------ Modifications
+
+    private void OnEdited()
+    {
+        if (_loading) return;
+        RefreshDirty();
+    }
+
+    private void RefreshDirty()
+    {
+        var errors = new List<string>();
+        var current = BuildCatalog(errors);
+        HasChanges = Snapshot(current) != _publishedSnapshot || errors.Count > 0;
+
+        var published = string.IsNullOrEmpty(_publishedSnapshot) ? null : JsonSerializer.Deserialize<CatalogDocument>(_publishedSnapshot, ApiJson.Options);
+        Launcher.IsDirty = Snapshot(current.Launcher) != Snapshot(published?.Launcher);
+        foreach (var game in Games)
+        {
+            current.Games.TryGetValue(game.GameId, out var now);
+            CatalogGame? before = null;
+            published?.Games.TryGetValue(game.GameId, out before);
+            game.IsDirty = Snapshot(now) != Snapshot(before);
+        }
+    }
+
+    private bool CanMove(int delta) =>
+        Selected is GameEditor game && Games.IndexOf(game) is var index and >= 0 && index + delta >= 0 && index + delta < Games.Count;
+
+    private void Move(int delta)
+    {
+        if (Selected is not GameEditor game || !CanMove(delta)) return;
+        var index = Games.IndexOf(game);
+        Games.Move(index, index + delta);
+        RebuildItems(game);
+        OnEdited();
+    }
+
+    /// <summary>
+    /// Reconstruit la liste affichée puis resélectionne <paramref name="select"/> : la liste de l'écran
+    /// vide sa sélection quand ses éléments sont retirés, la notification la rétablit.
+    /// </summary>
+    private void RebuildItems(CatalogEditor? select)
+    {
+        Items.Clear();
+        Items.Add(Launcher);
+        foreach (var game in Games) Items.Add(game);
+        _selected = select is not null && Items.Contains(select) ? select : Items.FirstOrDefault();
+        OnPropertyChanged(nameof(Selected));
+        MoveUpCommand?.RaiseCanExecuteChanged();
+        MoveDownCommand?.RaiseCanExecuteChanged();
+    }
+
+    private static string Snapshot(object? value) => value is null ? "" : JsonSerializer.Serialize(value, ApiJson.Options);
+}

src/GameLauncher.Modules.Admin/Changelog/ChangelogAdminModule.cs

@@ -0,0 +1,25 @@
+using GameLauncher.Contracts.Security;
+
+namespace GameLauncher.Modules.Admin.Changelog;
+
+/// <summary>
+/// Module « Notes de version » : page du menu d'administration pour corriger les notes des versions
+/// déjà publiées (manifest.json du serveur). Permission changelog.edit.
+/// </summary>
+public sealed class ChangelogAdminModule : ILauncherModule
+{
+    public string Id => "changelog";
+
+    public string DisplayName => "Notes de version";
+
+    public void Register(IModuleRegistry registry) =>
+        registry.AddAdminPanel(new AdminPanelDescriptor(
+            ChangelogPanelViewModel.PanelId,
+            "Notes de version",
+            "Corrigez les notes des versions déjà publiées : texte, sections, étiquettes, sous-points. " +
+            "Une nouvelle version et ses notes se publient toujours avec ManifestBuilder (notes.txt).",
+            "FileDocument",
+            AdminPermissions.ChangelogEdit,
+            Order: 20,
+            context => new ChangelogPanelViewModel(context)));
+}

src/GameLauncher.Modules.Admin/Changelog/ChangelogEditors.cs

@@ -0,0 +1,401 @@
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.Text.Json;
+using GameLauncher.Contracts;
+using GameLauncher.Contracts.Changelog;
+using GameLauncher.Modules.Admin.Catalog;
+using GameLauncher.Mvvm;
+
+namespace GameLauncher.Modules.Admin.Changelog;
+
+/// <summary>
+/// Notes d'une version, en cours de modification : en-tête (titre, sous-titre, introduction), puis
+/// sections › éléments. <see cref="Preview"/> est l'entrée telle que le launcher l'affichera (mêmes
+/// bornes, mêmes modèles d'affichage), recalculée à chaque modification.
+/// </summary>
+public sealed class VersionEditor : ObservableObject
+{
+    private readonly Action _changed;
+    private readonly Func<string, string, bool> _confirm;
+    private string _title = "", _subtitle = "", _introduction = "";
+    private string _snapshot = "";
+    private bool _isDirty, _showPreview, _loading;
+    private ChangelogEntry _preview;
+    private IReadOnlyList<string> _limitErrors = Array.Empty<string>();
+
+    /// <param name="confirm">Confirmation (titre, message) avant de retirer une section qui contient des éléments.</param>
+    /// <param name="changed">Prévient la page (bouton « Enregistrer », pastilles).</param>
+    public VersionEditor(ChangelogEntry published, Func<string, string, bool> confirm, Action changed)
+    {
+        Version = published.Version;
+        Date = published.Date;
+        _confirm = confirm;
+        _changed = changed;
+        _preview = new ChangelogEntry { Version = Version, Date = Date };
+        Sections.CollectionChanged += OnSectionsChanged;
+        AddSectionCommand = new RelayCommand(AddSection, () => Sections.Count < ChangelogLimits.MaxSectionsPerEntry);
+        Load(published);
+    }
+
+    public string Version { get; }
+    public DateTimeOffset Date { get; }
+    public string DateText => Date == default ? "" : _preview.DateText;
+
+    // ------------------------------------------------------------------ En-tête
+
+    public string Title { get => _title; set => Set(ref _title, value ?? ""); }
+
+    /// <summary>Sous-titre : une ou plusieurs lignes.</summary>
+    public string Subtitle { get => _subtitle; set => Set(ref _subtitle, value ?? ""); }
+
+    /// <summary>Paragraphes d'introduction, séparés par une ligne vide.</summary>
+    public string Introduction { get => _introduction; set => Set(ref _introduction, value ?? ""); }
+
+    public ObservableCollection<SectionEditor> Sections { get; } = new();
+    public RelayCommand AddSectionCommand { get; }
+
+    // ------------------------------------------------------------------ État
+
+    /// <summary>Modifié depuis le chargement (ou le dernier enregistrement).</summary>
+    public bool IsDirty
+    {
+        get => _isDirty;
+        private set => SetProperty(ref _isDirty, value);
+    }
+
+    /// <summary>Affichage : modification (faux) ou aperçu tel que le verront les joueurs (vrai).</summary>
+    public bool ShowPreview
+    {
+        get => _showPreview;
+        set
+        {
+            if (!SetProperty(ref _showPreview, value)) return;
+            OnPropertyChanged(nameof(IsEditMode));
+            OnPropertyChanged(nameof(IsPreviewMode));
+        }
+    }
+
+    public bool IsEditMode { get => !_showPreview; set { if (value) ShowPreview = false; } }
+    public bool IsPreviewMode { get => _showPreview; set { if (value) ShowPreview = true; } }
+
+    /// <summary>Notes telles que le launcher les affichera.</summary>
+    public ChangelogEntry Preview
+    {
+        get => _preview;
+        private set => SetProperty(ref _preview, value);
+    }
+
+    /// <summary>Limites dépassées (rien n'est tronqué : à corriger avant d'enregistrer).</summary>
+    public IReadOnlyList<string> LimitErrors
+    {
+        get => _limitErrors;
+        private set
+        {
+            _limitErrors = value;
+            OnPropertyChanged();
+            OnPropertyChanged(nameof(HasLimitErrors));
+        }
+    }
+
+    public bool HasLimitErrors => _limitErrors.Count > 0;
+
+    /// <summary>« 3 sections · 14 éléments ».</summary>
+    public string CountText
+    {
+        get
+        {
+            var items = Sections.Sum(s => s.Items.Count);
+            return $"{Sections.Count} section{(Sections.Count > 1 ? "s" : "")} · {items} élément{(items > 1 ? "s" : "")} " +
+                   $"(au plus {ChangelogLimits.MaxItemsPerEntry})";
+        }
+    }
+
+    // ------------------------------------------------------------------ Chargement, conversion
+
+    /// <summary>Affiche des notes publiées et en fait la référence « sans modification ».</summary>
+    public void Load(ChangelogEntry entry)
+    {
+        _loading = true;
+        try
+        {
+            _title = entry.Title ?? "";
+            _subtitle = entry.Subtitle ?? "";
+            _introduction = string.Join("\n\n", entry.Introduction ?? new List<string>());
+            Sections.Clear();
+            // Ancien format (liste à plat) : présenté en section(s) sans titre, enregistré au format enrichi.
+            var sections = entry.Sections.Count > 0
+                ? entry.Sections
+                : (entry.Changes ?? new List<string>())
+                  .Chunk(ChangelogLimits.MaxItemsPerSection)
+                  .Select(chunk => new ChangelogSection { Items = chunk.Select(c => new ChangelogItem { Text = c }).ToList() })
+                  .ToList();
+            foreach (var section in sections) Sections.Add(new SectionEditor(section, this));
+            foreach (var name in new[] { nameof(Title), nameof(Subtitle), nameof(Introduction) }) OnPropertyChanged(name);
+        }
+        finally
+        {
+            _loading = false;
+        }
+        _snapshot = Snapshot(Normalized(ToEntry()));
+        Refresh();
+    }
+
+    /// <summary>Notes saisies (non tronquées) : c'est ce qui est envoyé au serveur.</summary>
+    public ChangelogEntry ToEntry()
+    {
+        var entry = new ChangelogEntry
+        {
+            Version = Version,
+            Date = Date,
+            Title = Clean(Title),
+            Subtitle = Clean(Subtitle.Replace("\r\n", "\n")),
+            Introduction = Paragraphs(Introduction),
+            Sections = Sections.Select(s => s.ToSection()).ToList()
+        };
+        // Liste à plat des anciens launchers : régénérée par le serveur à l'enregistrement (requête allégée).
+        if (entry.Sections.Count == 0) entry.Changes = new List<string>();
+        return entry;
+    }
+
+    // ------------------------------------------------------------------ Modifications
+
+    internal void Changed()
+    {
+        if (_loading) return;
+        Refresh();
+    }
+
+    private void Refresh()
+    {
+        var entry = ToEntry();
+        var preview = Normalized(entry);
+        var errors = ChangelogLimits.Check(entry);
+        if (preview is null) errors.Insert(0, "Les notes ne peuvent pas être vides : gardez au moins un titre ou un élément.");
+        LimitErrors = errors;
+        Preview = preview ?? new ChangelogEntry { Version = Version, Date = Date };
+        IsDirty = Snapshot(preview) != _snapshot;
+        OnPropertyChanged(nameof(CountText));
+        AddSectionCommand.RaiseCanExecuteChanged();
+        _changed();
+    }
+
+    private bool Set<T>(ref T field, T value, [System.Runtime.CompilerServices.CallerMemberName] string? name = null)
+    {
+        if (!SetProperty(ref field, value, name)) return false;
+        Changed();
+        return true;
+    }
+
+    private void AddSection()
+    {
+        if (Sections.Count >= ChangelogLimits.MaxSectionsPerEntry) return;
+        var section = new SectionEditor(new ChangelogSection(), this);
+        section.AddChangeCommand.Execute(null);
+        Sections.Add(section);
+    }
+
+    internal void MoveSection(SectionEditor section, int delta) => ListMoves.Move(Sections, section, delta);
+
+    internal void RemoveSection(SectionEditor section)
+    {
+        if (section.Items.Any(i => !i.IsEmpty) &&
+            !_confirm("Retirer la section ?", $"La section « {(string.IsNullOrWhiteSpace(section.Title) ? "sans titre" : section.Title.Trim())} » " +
+                                              $"et ses {section.Items.Count} élément(s) seront retirés de ces notes (rien n'est enregistré avant « Enregistrer »)."))
+            return;
+        Sections.Remove(section);
+    }
+
+    private void OnSectionsChanged(object? sender, NotifyCollectionChangedEventArgs e)
+    {
+        foreach (var section in Sections) section.RefreshMoves();
+        Changed();
+    }
+
+    // ------------------------------------------------------------------ Outils
+
+    private static ChangelogEntry? Normalized(ChangelogEntry entry) => ChangelogLimits.Normalize(new[] { entry }).FirstOrDefault();
+
+    private static string Snapshot(ChangelogEntry? entry) => entry is null ? "" : JsonSerializer.Serialize(entry, ApiJson.Options);
+
+    internal static string? Clean(string? text) => string.IsNullOrWhiteSpace(text) ? null : text.Trim();
+
+    /// <summary>Paragraphes séparés par une (ou plusieurs) ligne(s) vide(s) ; retours à la ligne simples gardés en espaces.</summary>
+    private static List<string> Paragraphs(string text) =>
+        System.Text.RegularExpressions.Regex.Split(text.Replace("\r\n", "\n"), @"\n[ \t]*\n")
+              .Select(p => Clean(p.Replace('\n', ' ')))
+              .OfType<string>()
+              .ToList();
+
+    /// <summary>Une ligne par élément (sous-points).</summary>
+    internal static List<string> Lines(string text) =>
+        text.Replace("\r\n", "\n").Split('\n').Select(Clean).OfType<string>().ToList();
+}
+
+/// <summary>Section des notes (titre facultatif) et ses éléments.</summary>
+public sealed class SectionEditor : ObservableObject
+{
+    private readonly VersionEditor _version;
+    private string _title;
+
+    public SectionEditor(ChangelogSection section, VersionEditor version)
+    {
+        _version = version;
+        _title = section.Title ?? "";
+        AddChangeCommand = new RelayCommand(() => Add(comment: false), CanAdd);
+        AddCommentCommand = new RelayCommand(() => Add(comment: true), CanAdd);
+        foreach (var item in section.Items ?? new List<ChangelogItem>()) Items.Add(new ItemEditor(item, this));
+        Items.CollectionChanged += (_, _) =>
+        {
+            foreach (var item in Items) item.RefreshMoves();
+            OnPropertyChanged(nameof(CountText));
+            AddChangeCommand.RaiseCanExecuteChanged();
+            AddCommentCommand.RaiseCanExecuteChanged();
+            _version.Changed();
+        };
+        MoveUpCommand = new RelayCommand(() => _version.MoveSection(this, -1), () => _version.Sections.IndexOf(this) > 0);
+        MoveDownCommand = new RelayCommand(() => _version.MoveSection(this, +1),
+            () => _version.Sections.IndexOf(this) is var i && i >= 0 && i < _version.Sections.Count - 1);
+        RemoveCommand = new RelayCommand(() => _version.RemoveSection(this));
+    }
+
+    /// <summary>Titre de la section (facultatif), ex. « PROGRESSION ».</summary>
+    public string Title
+    {
+        get => _title;
+        set
+        {
+            if (SetProperty(ref _title, value ?? "")) _version.Changed();
+        }
+    }
+
+    public ObservableCollection<ItemEditor> Items { get; } = new();
+
+    public string CountText => $"{Items.Count} élément{(Items.Count > 1 ? "s" : "")}";
+
+    public RelayCommand AddChangeCommand { get; }
+    public RelayCommand AddCommentCommand { get; }
+    public RelayCommand MoveUpCommand { get; }
+    public RelayCommand MoveDownCommand { get; }
+    public RelayCommand RemoveCommand { get; }
+
+    internal VersionEditor Version => _version;
+
+    internal ChangelogSection ToSection() => new()
+    {
+        Title = VersionEditor.Clean(Title),
+        Items = Items.Select(i => i.ToItem()).ToList()
+    };
+
+    internal void RefreshMoves()
+    {
+        MoveUpCommand.RaiseCanExecuteChanged();
+        MoveDownCommand.RaiseCanExecuteChanged();
+    }
+
+    internal void MoveItem(ItemEditor item, int delta) => ListMoves.Move(Items, item, delta);
+
+    internal void RemoveItem(ItemEditor item) => Items.Remove(item);
+
+    private bool CanAdd() => Items.Count < ChangelogLimits.MaxItemsPerSection;
+
+    private void Add(bool comment)
+    {
+        if (!CanAdd()) return;
+        Items.Add(new ItemEditor(new ChangelogItem { Type = comment ? ChangelogItem.CommentType : null }, this));
+    }
+}
+
+/// <summary>Élément d'une section : une modification (étiquette, sous-points, note) ou un commentaire.</summary>
+public sealed class ItemEditor : ObservableObject
+{
+    public static readonly IReadOnlyList<Choice> Kinds = new[]
+    {
+        new Choice(ChangelogItem.ChangeType, "Modification"),
+        new Choice(ChangelogItem.CommentType, "Commentaire")
+    };
+
+    private readonly SectionEditor _section;
+    private Choice _kind;
+    private string _text, _tag, _details, _note;
+
+    public ItemEditor(ChangelogItem item, SectionEditor section)
+    {
+        _section = section;
+        _kind = item.IsComment ? Kinds[1] : Kinds[0];
+        _text = item.Text ?? "";
+        _tag = item.Tag ?? "";
+        _details = string.Join("\n", item.Details ?? new List<string>());
+        _note = item.Note ?? "";
+        MoveUpCommand = new RelayCommand(() => _section.MoveItem(this, -1), () => _section.Items.IndexOf(this) > 0);
+        MoveDownCommand = new RelayCommand(() => _section.MoveItem(this, +1),
+            () => _section.Items.IndexOf(this) is var i && i >= 0 && i < _section.Items.Count - 1);
+        RemoveCommand = new RelayCommand(() => _section.RemoveItem(this));
+    }
+
+    public IReadOnlyList<Choice> KindChoices => Kinds;
+
+    public Choice Kind
+    {
+        get => _kind;
+        set
+        {
+            // null : liste de l'écran en cours de remplacement, pas un choix de l'administrateur.
+            if (value is null || !SetProperty(ref _kind, value)) return;
+            OnPropertyChanged(nameof(IsComment));
+            OnPropertyChanged(nameof(IsChange));
+            _section.Version.Changed();
+        }
+    }
+
+    public bool IsComment => _kind.Value == ChangelogItem.CommentType;
+    public bool IsChange => !IsComment;
+
+    public string Text { get => _text; set => Set(ref _text, value ?? ""); }
+
+    /// <summary>Étiquette en pastille, ex. « NOUVEAU » (modifications uniquement).</summary>
+    public string Tag { get => _tag; set => Set(ref _tag, value ?? ""); }
+
+    /// <summary>Sous-points : un par ligne (modifications uniquement).</summary>
+    public string Details { get => _details; set => Set(ref _details, value ?? ""); }
+
+    /// <summary>Texte de conclusion après les sous-points (modifications uniquement).</summary>
+    public string Note { get => _note; set => Set(ref _note, value ?? ""); }
+
+    public RelayCommand MoveUpCommand { get; }
+    public RelayCommand MoveDownCommand { get; }
+    public RelayCommand RemoveCommand { get; }
+
+    internal bool IsEmpty => string.IsNullOrWhiteSpace(Text) && string.IsNullOrWhiteSpace(Details);
+
+    internal ChangelogItem ToItem() => IsComment
+        ? new ChangelogItem { Type = ChangelogItem.CommentType, Text = Text.Trim() }
+        : new ChangelogItem
+        {
+            Text = Text.Trim(),
+            Tag = VersionEditor.Clean(Tag),
+            Details = VersionEditor.Lines(Details),
+            Note = VersionEditor.Clean(Note)
+        };
+
+    internal void RefreshMoves()
+    {
+        MoveUpCommand.RaiseCanExecuteChanged();
+        MoveDownCommand.RaiseCanExecuteChanged();
+    }
+
+    private void Set(ref string field, string value, [System.Runtime.CompilerServices.CallerMemberName] string? name = null)
+    {
+        if (SetProperty(ref field, value, name)) _section.Version.Changed();
+    }
+}
+
+internal static class ListMoves
+{
+    public static void Move<T>(ObservableCollection<T> list, T item, int delta)
+    {
+        var index = list.IndexOf(item);
+        var target = index + delta;
+        if (index < 0 || target < 0 || target >= list.Count) return;
+        list.Move(index, target);
+    }
+}

src/GameLauncher.Modules.Admin/Changelog/ChangelogPanelViewModel.cs

@@ -0,0 +1,243 @@
+using System.Collections.ObjectModel;
+using System.Text.Json;
+using GameLauncher.ApiClient;
+using GameLauncher.Contracts;
+using GameLauncher.Contracts.Changelog;
+using GameLauncher.Contracts.Dtos;
+using GameLauncher.Core.Utils;
+using GameLauncher.Modules.Admin.Catalog;
+using GameLauncher.Mvvm;
+
+namespace GameLauncher.Modules.Admin.Changelog;
+
+/// <summary>
+/// Page « Notes de version » : modification des notes des versions DÉJÀ publiées, dans le manifest.json
+/// du serveur (la création d'une version reste l'affaire de ManifestBuilder et du .bat).
+///  • liste des versions (pastille « modifié »), éditeur en-tête › sections › éléments, aperçu en
+///    direct avec les modèles d'affichage du launcher (Themes/Changelog.xaml) ;
+///  • mêmes bornes que le launcher, vérifiées avant l'envoi (rien n'est tronqué en silence) ;
+///  • « Enregistrer » : une requête signée par version modifiée, avec l'empreinte du manifest lu
+///    (si le manifest a changé entre-temps, rien n'est écrasé et le rechargement est proposé).
+/// </summary>
+public sealed class ChangelogPanelViewModel : AdminPanelViewModel
+{
+    public const string PanelId = "changelog.notes";
+
+    private ChangelogState? _state;
+    private Choice? _selectedGame;
+    private VersionEditor? _selectedVersion;
+    private bool _hasChanges, _hasConflict;
+    private string? _statusMessage;
+    private int _skippedVersions;
+
+    public ChangelogPanelViewModel(IAdminContext context) : base(context)
+    {
+        GameChoices = context.Games.Select(g => new Choice(g.GameId, $"{g.GameName} ({g.GameId})")).ToList();
+        _selectedGame = GameChoices.FirstOrDefault(g => string.Equals(g.Value, context.DefaultGameId, StringComparison.OrdinalIgnoreCase))
+                        ?? GameChoices.FirstOrDefault();
+        SaveCommand = new AsyncRelayCommand(SaveAsync, () => !IsBusy && HasChanges && !HasConflict && _state is not null);
+        ReloadCommand = new AsyncRelayCommand(ReloadAsync, () => !IsBusy && _selectedGame is not null);
+    }
+
+    // ------------------------------------------------------------------ Jeu
+
+    public IReadOnlyList<Choice> GameChoices { get; }
+    public bool HasSeveralGames => GameChoices.Count > 1;
+
+    public Choice? SelectedGame
+    {
+        get => _selectedGame;
+        set
+        {
+            if (value is null || Equals(value, _selectedGame)) return;
+            if (HasChanges && !Context.Dialogs.Confirm("Abandonner les modifications ?",
+                    "Les notes modifiées de ce jeu n'ont pas été enregistrées : elles seront perdues.", "Abandonner et changer de jeu"))
+            {
+                OnPropertyChanged(); // la liste de l'écran revient au jeu affiché
+                return;
+            }
+            _selectedGame = value;
+            OnPropertyChanged();
+            Clear(); // rien de l'ancien jeu ne reste affiché (ni enregistrable) si le chargement échoue
+            _ = LoadAsync();
+        }
+    }
+
+    // ------------------------------------------------------------------ Versions
+
+    public ObservableCollection<VersionEditor> Versions { get; } = new();
+
+    public VersionEditor? SelectedVersion
+    {
+        get => _selectedVersion;
+        set
+        {
+            // null : la liste de l'écran se vide lors d'un rechargement ; la sélection est rétablie ensuite.
+            if (value is not null) SetProperty(ref _selectedVersion, value);
+        }
+    }
+
+    public bool HasVersions => Versions.Count > 0;
+    public bool ShowNoVersions => _state is not null && Versions.Count == 0;
+
+    /// <summary>« Version publiée : 1.1 · 6 versions avec des notes ».</summary>
+    public string ManifestText => _state is null ? "" :
+        $"Version publiée : {_state.ManifestVersion} · {Versions.Count} version{(Versions.Count > 1 ? "s" : "")} avec des notes" +
+        (_skippedVersions > 0 ? $" ({_skippedVersions} non modifiable{(_skippedVersions > 1 ? "s" : "")} en ligne : numéro avec caractères spéciaux ou en double)" : "");
+
+    // ------------------------------------------------------------------ État
+
+    public bool HasChanges
+    {
+        get => _hasChanges;
+        private set
+        {
+            if (SetProperty(ref _hasChanges, value)) SaveCommand.RaiseCanExecuteChanged();
+        }
+    }
+
+    /// <summary>Le manifest a changé sur le serveur (version publiée, autre administrateur) : il faut recharger.</summary>
+    public bool HasConflict
+    {
+        get => _hasConflict;
+        private set
+        {
+            if (SetProperty(ref _hasConflict, value)) SaveCommand.RaiseCanExecuteChanged();
+        }
+    }
+
+    public string? StatusMessage
+    {
+        get => _statusMessage;
+        private set
+        {
+            if (SetProperty(ref _statusMessage, value)) OnPropertyChanged(nameof(HasStatus));
+        }
+    }
+
+    public bool HasStatus => !string.IsNullOrEmpty(StatusMessage);
+
+    /// <summary>Faux pendant un chargement ou un enregistrement.</summary>
+    public bool IsEditable => !IsBusy;
+
+    public AsyncRelayCommand SaveCommand { get; }
+    public AsyncRelayCommand ReloadCommand { get; }
+
+    protected override void OnBusyChanged()
+    {
+        OnPropertyChanged(nameof(IsEditable));
+        SaveCommand.RaiseCanExecuteChanged();
+        ReloadCommand.RaiseCanExecuteChanged();
+    }
+
+    protected override Task OnActivatedAsync(bool firstTime) => firstTime ? LoadAsync() : Task.CompletedTask;
+
+    // ------------------------------------------------------------------ Chargement
+
+    public Task LoadAsync() => RunAsync(async () =>
+    {
+        if (_selectedGame?.Value is not { } gameId) return;
+        var state = await Context.Session.GetChangelogAsync(gameId);
+        Apply(state);
+        StatusMessage = null;
+    });
+
+    private async Task ReloadAsync()
+    {
+        if (HasChanges && !Context.Dialogs.Confirm("Abandonner les modifications ?",
+                "Les notes non enregistrées seront perdues : la page affichera celles du manifest publié.", "Abandonner et recharger"))
+            return;
+        await LoadAsync();
+    }
+
+    private void Apply(ChangelogState state)
+    {
+        var selected = _selectedVersion?.Version;
+        _state = state;
+        HasConflict = false;
+        Versions.Clear();
+        // Une version présente deux fois n'est modifiable qu'une fois (le serveur modifie la première).
+        var editable = state.Entries.Where(e => ChangelogLimits.IsEditableVersion(e.Version))
+                                    .DistinctBy(e => e.Version, StringComparer.Ordinal).ToList();
+        _skippedVersions = state.Entries.Count - editable.Count;
+        foreach (var entry in editable) Versions.Add(new VersionEditor(entry, Confirm, RefreshChanges));
+        _selectedVersion = Versions.FirstOrDefault(v => v.Version == selected) ?? Versions.FirstOrDefault();
+        foreach (var name in new[] { nameof(SelectedVersion), nameof(HasVersions), nameof(ShowNoVersions), nameof(ManifestText) })
+            OnPropertyChanged(name);
+        RefreshChanges();
+    }
+
+    // ------------------------------------------------------------------ Enregistrement
+
+    private Task SaveAsync() => RunAsync(async () =>
+    {
+        if (_state is null || _selectedGame?.Value is not { } gameId) return;
+        var dirty = Versions.Where(v => v.IsDirty).ToList();
+
+        // Tout est vérifié avant le premier envoi : limites, taille de chaque requête.
+        foreach (var version in dirty)
+        {
+            var entry = version.ToEntry();
+            var errors = version.LimitErrors; // limites + notes vides
+            if (errors.Count > 0)
+            {
+                SelectedVersion = version;
+                Context.Dialogs.ShowMessage($"Notes de la version {version.Version} à corriger",
+                    string.Join("\n", errors.Take(12)), ModuleMessageKind.Warning);
+                return;
+            }
+            var size = JsonSerializer.SerializeToUtf8Bytes(new ChangelogUpdateRequest { BaseSha256 = _state.ManifestSha256, Entry = entry }, ApiJson.Options).Length;
+            if (size > ChangelogLimits.MaxEditRequestBytes)
+            {
+                SelectedVersion = version;
+                Context.Dialogs.ShowMessage("Notes trop longues pour l'édition en ligne",
+                    $"Les notes de la version {version.Version} font {size / 1024} Ko (au plus {ChangelogLimits.MaxEditRequestBytes / 1024} Ko par version). " +
+                    "Raccourcissez-les, ou modifiez notes.txt puis republiez la version.", ModuleMessageKind.Warning);
+                return;
+            }
+        }
+
+        var saved = new List<string>();
+        try
+        {
+            foreach (var version in dirty)
+            {
+                var state = await Context.Session.SaveChangelogEntryAsync(gameId, version.ToEntry(), _state.ManifestSha256);
+                _state = state;
+                if (state.Entries.FirstOrDefault(e => e.Version == version.Version) is { } published) version.Load(published);
+                saved.Add(version.Version);
+            }
+            StatusMessage = $"Notes enregistrées ({string.Join(", ", saved)}). Les launchers les afficheront à leur prochaine recherche de mise à jour.";
+            Log.Info($"Administration : notes de version modifiées ({gameId} {string.Join(", ", saved)}).");
+        }
+        catch (ApiException ex) when (ex.Status == 409 && ex.Code == ApiErrorCodes.RevisionConflict)
+        {
+            HasConflict = true;
+            if (saved.Count > 0) StatusMessage = $"Notes enregistrées : {string.Join(", ", saved)}.";
+            Context.Dialogs.ShowMessage("Manifest modifié entre-temps",
+                "Le manifest du jeu a changé sur le serveur (nouvelle version publiée ou autre administrateur). Rechargez la page " +
+                "pour partir de la version publiée (les modifications non enregistrées seront perdues : notez-les si besoin).",
+                ModuleMessageKind.Warning);
+        }
+    });
+
+    // ------------------------------------------------------------------ Outils
+
+    private void Clear()
+    {
+        _state = null;
+        HasConflict = false;
+        StatusMessage = null;
+        Versions.Clear();
+        _selectedVersion = null;
+        _skippedVersions = 0;
+        foreach (var name in new[] { nameof(SelectedVersion), nameof(HasVersions), nameof(ShowNoVersions), nameof(ManifestText) })
+            OnPropertyChanged(name);
+        RefreshChanges();
+        SaveCommand.RaiseCanExecuteChanged();
+    }
+
+    private void RefreshChanges() => HasChanges = Versions.Any(v => v.IsDirty);
+
+    private bool Confirm(string title, string message) => Context.Dialogs.Confirm(title, message, "Retirer", danger: true);
+}

src/GameLauncher.Modules.Admin/GameLauncher.Modules.Admin.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <!--
+    Module « Administration » du launcher (sans WPF) : clés de l'administrateur, connexion,
+    invitation, verrouillage de session, tableau de bord. Les écrans correspondants sont dans le
+    launcher (Views\Admin, Themes\Admin.xaml). Voir docs\ADMIN-ARCHITECTURE.md.
+  -->
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <RootNamespace>GameLauncher.Modules.Admin</RootNamespace>
+    <AssemblyName>GameLauncher.Modules.Admin</AssemblyName>
+    <Platforms>AnyCPU;x64</Platforms>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\GameLauncher.Modules\GameLauncher.Modules.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <InternalsVisibleTo Include="GameLauncher.Tests" />
+  </ItemGroup>
+
+</Project>

src/GameLauncher.Modules.Admin/Publishing/PublishAdminModule.cs

@@ -0,0 +1,25 @@
+using GameLauncher.Contracts.Security;
+
+namespace GameLauncher.Modules.Admin.Publishing;
+
+/// <summary>
+/// Module « Publication » : page du menu d'administration pour mettre en ligne une version produite par
+/// le .bat (ManifestBuilder), sans WinSCP. Permission releases.publish (propriétaires, administrateurs).
+/// </summary>
+public sealed class PublishAdminModule : ILauncherModule
+{
+    public string Id => "publishing";
+
+    public string DisplayName => "Publication";
+
+    public void Register(IModuleRegistry registry) =>
+        registry.AddAdminPanel(new AdminPanelDescriptor(
+            PublishPanelViewModel.PanelId,
+            "Publier une version",
+            "Mettez en ligne la version préparée par le .bat de publication (ManifestBuilder) : seuls les fichiers absents " +
+            "du serveur sont envoyés, l'envoi reprend après une coupure, et le manifest est publié en dernier.",
+            "CloudUpload",
+            AdminPermissions.ReleasesPublish,
+            Order: 30,
+            context => new PublishPanelViewModel(context)));
+}

src/GameLauncher.Modules.Admin/Publishing/PublishPanelViewModel.cs

@@ -0,0 +1,369 @@
+using GameLauncher.ApiClient;
+using GameLauncher.Contracts.Dtos;
+using GameLauncher.Contracts.Publishing;
+using GameLauncher.Core.SelfUpdate;
+using GameLauncher.Core.Utils;
+using GameLauncher.Modules.Admin.Catalog;
+using GameLauncher.Mvvm;
+
+namespace GameLauncher.Modules.Admin.Publishing;
+
+/// <summary>
+/// Page « Publier une version » : choix du manifest.json produit par le .bat (ManifestBuilder), contrôle
+/// du dossier, puis envoi au serveur et mise en ligne (remplace l'envoi avec WinSCP).
+///  • seuls les fichiers absents du serveur sont envoyés ; l'archive par morceaux ;
+///  • « Interrompre » garde ce qui a été envoyé : « Publier » reprend là où l'envoi s'est arrêté ;
+///  • le manifest est mis en ligne en dernier : les joueurs ne voient jamais une version incomplète.
+/// </summary>
+public sealed class PublishPanelViewModel : AdminPanelViewModel
+{
+    public const string PanelId = "releases.publish";
+
+    private Choice? _selectedGame;
+    private LocalRelease? _release;
+    private string? _manifestPath, _publishedVersion, _statusMessage, _progressText, _speedText;
+    private string _publishedText = "";
+    private IReadOnlyList<string> _warnings = Array.Empty<string>();
+    private bool _isPublishing, _committing;
+    private double _progressValue;
+    private PublicationState? _interrupted;
+    private CancellationTokenSource? _cancellation;
+
+    public PublishPanelViewModel(IAdminContext context) : base(context)
+    {
+        GameChoices = context.Games.Select(g => new Choice(g.GameId, $"{g.GameName} ({g.GameId})")).ToList();
+        _selectedGame = GameChoices.FirstOrDefault(g => string.Equals(g.Value, context.DefaultGameId, StringComparison.OrdinalIgnoreCase))
+                        ?? GameChoices.FirstOrDefault();
+        ChooseCommand = new AsyncRelayCommand(ChooseAsync, () => CanEdit);
+        RecheckCommand = new AsyncRelayCommand(() => InspectAsync(_manifestPath!), () => CanEdit && _manifestPath is not null);
+        PublishCommand = new AsyncRelayCommand(PublishAsync, () => CanEdit && _release is not null);
+        CancelCommand = new RelayCommand(() => _cancellation?.Cancel(), () => _isPublishing && !_committing);
+        AbandonCommand = new AsyncRelayCommand(AbandonAsync, () => CanEdit && _interrupted is not null);
+    }
+
+    // ------------------------------------------------------------------ Jeu, dossier
+
+    public IReadOnlyList<Choice> GameChoices { get; }
+    public bool HasSeveralGames => GameChoices.Count > 1;
+
+    public Choice? SelectedGame
+    {
+        get => _selectedGame;
+        set
+        {
+            if (value is null || Equals(value, _selectedGame) || _isPublishing) return;
+            _selectedGame = value;
+            OnPropertyChanged();
+            SetRelease(null);
+            _ = RefreshPublishedAsync();
+        }
+    }
+
+    public string? ManifestPath
+    {
+        get => _manifestPath;
+        private set
+        {
+            if (SetProperty(ref _manifestPath, value)) RecheckCommand.RaiseCanExecuteChanged();
+        }
+    }
+
+    /// <summary>« Version en ligne : 1.1 » (ou la raison pour laquelle elle est inconnue).</summary>
+    public string PublishedText
+    {
+        get => _publishedText;
+        private set => SetProperty(ref _publishedText, value);
+    }
+
+    // ------------------------------------------------------------------ Version à publier
+
+    public bool HasRelease => _release is not null;
+    public string VersionText => _release is null ? "" : $"Version {_release.Summary.Version}";
+    public string? NotesTitle => _release?.Summary.NotesTitle;
+    public bool HasNotesTitle => !string.IsNullOrWhiteSpace(NotesTitle);
+
+    public string FilesText => _release is null ? "" :
+        $"{_release.Summary.FileCount} fichier(s), {Format.Bytes(_release.Summary.TotalSize)} · exécutable « {_release.Summary.Executable} »";
+
+    public string ArchiveText => _release is null ? "" : $"{_release.Summary.ArchiveName} ({Format.Bytes(_release.Summary.ArchiveSize)})";
+
+    /// <summary>Points d'attention : republication, retour à une version précédente…</summary>
+    public IReadOnlyList<string> Warnings
+    {
+        get => _warnings;
+        private set
+        {
+            _warnings = value;
+            OnPropertyChanged();
+            OnPropertyChanged(nameof(HasWarnings));
+        }
+    }
+
+    public bool HasWarnings => _warnings.Count > 0;
+
+    // ------------------------------------------------------------------ Envoi
+
+    public bool IsPublishing
+    {
+        get => _isPublishing;
+        private set
+        {
+            if (!SetProperty(ref _isPublishing, value)) return;
+            OnPropertyChanged(nameof(HasInterrupted));
+            OnPropertyChanged(nameof(CanEdit));
+            OnPropertyChanged(nameof(ShowBusyBar));
+            RefreshCommands();
+        }
+    }
+
+    /// <summary>Faux pendant un contrôle ou un envoi.</summary>
+    public bool CanEdit => !IsBusy && !_isPublishing;
+
+    /// <summary>Barre d'attente du contrôle du dossier (l'envoi a sa propre barre de progression).</summary>
+    public bool ShowBusyBar => IsBusy && !_isPublishing;
+
+    public double ProgressValue
+    {
+        get => _progressValue;
+        private set => SetProperty(ref _progressValue, value);
+    }
+
+    public string? ProgressText
+    {
+        get => _progressText;
+        private set => SetProperty(ref _progressText, value);
+    }
+
+    public string? SpeedText
+    {
+        get => _speedText;
+        private set => SetProperty(ref _speedText, value);
+    }
+
+    /// <summary>
+    /// Envoi interrompu (annulé, coupure, erreur) : il reprendra à « Publier », ou peut être abandonné (fichiers
+    /// reçus supprimés). Pas pendant l'envoi lui-même : la publication est alors ouverte, pas interrompue.
+    /// </summary>
+    public bool HasInterrupted => _interrupted is not null && !_isPublishing;
+
+    public string InterruptedText => _interrupted is null ? "" :
+        $"L'envoi de la version {_interrupted.Version} a été interrompu. « Publier » le reprend là où il s'est arrêté ; " +
+        "« Abandonner » supprime ce qui a déjà été reçu par le serveur.";
+
+    public string? StatusMessage
+    {
+        get => _statusMessage;
+        private set
+        {
+            if (SetProperty(ref _statusMessage, value)) OnPropertyChanged(nameof(HasStatus));
+        }
+    }
+
+    public bool HasStatus => !string.IsNullOrEmpty(StatusMessage);
+
+    public AsyncRelayCommand ChooseCommand { get; }
+    public AsyncRelayCommand RecheckCommand { get; }
+    public AsyncRelayCommand PublishCommand { get; }
+    public RelayCommand CancelCommand { get; }
+    public AsyncRelayCommand AbandonCommand { get; }
+
+    protected override void OnBusyChanged()
+    {
+        OnPropertyChanged(nameof(CanEdit));
+        OnPropertyChanged(nameof(ShowBusyBar));
+        RefreshCommands();
+    }
+
+    protected override Task OnActivatedAsync(bool firstTime) => firstTime ? RefreshPublishedAsync() : Task.CompletedTask;
+
+    // ------------------------------------------------------------------ Actions
+
+    private async Task ChooseAsync()
+    {
+        var path = Context.Dialogs.PickOpenFile("Manifest de la version à publier (dossier produit par le .bat)",
+            "Manifest de publication (manifest.json)|manifest.json", _manifestPath is null ? null : Path.GetDirectoryName(_manifestPath));
+        if (path is not null) await InspectAsync(path);
+    }
+
+    /// <summary>Contrôle du dossier choisi (hors du fil de l'interface : lecture de nombreux fichiers).</summary>
+    public Task InspectAsync(string manifestPath) => RunAsync(async () =>
+    {
+        ManifestPath = manifestPath;
+        StatusMessage = null;
+        SetRelease(null);
+        if (_selectedGame?.Value is not { } gameId) return;
+        var release = await Task.Run(() => ReleaseUploader.Inspect(manifestPath, gameId));
+        await RefreshPublishedCoreAsync(gameId);
+        SetRelease(release);
+    });
+
+    private async Task PublishAsync()
+    {
+        if (_release is not { } release || _selectedGame?.Value is not { } gameId) return;
+        var online = _publishedVersion switch
+        {
+            null => "version en ligne inconnue",
+            "" => "aucune version en ligne",
+            _ => $"version en ligne : {_publishedVersion}"
+        };
+        if (!Context.Dialogs.Confirm($"Publier la version {release.Summary.Version} ?",
+                $"Les joueurs la recevront à leur prochaine recherche de mise à jour ({online}).\n\n" +
+                "Les fichiers absents du serveur sont envoyés, puis le manifest est mis en ligne en dernier.", "Publier"))
+            return;
+
+        StatusMessage = null;
+        _committing = false;
+        IsPublishing = true;
+        // Créés ici, sur le fil de l'interface : l'envoi les rappelle sur ce fil (boutons, liaisons).
+        var progress = new Progress<UploadProgress>(OnProgress);
+        var started = new Progress<PublicationState>(OnStarted);
+        _cancellation = new CancellationTokenSource();
+        try
+        {
+            using var _ = Context.BeginLongOperation();
+            await RunAsync(async () =>
+            {
+                try
+                {
+                    var result = await ReleaseUploader.PublishAsync(Context.Session, gameId, release, progress, started, _cancellation.Token);
+                    SetInterrupted(null);
+                    _publishedVersion = result.Version;
+                    PublishedText = $"Version en ligne : {result.Version}";
+                    StatusMessage = $"Version {result.Version} publiée ({result.ObjectsAdded} fichier(s) envoyé(s)" +
+                                    (result.ArchiveAdded ? " et l'archive" : "") +
+                                    "). Les launchers la proposeront à leur prochaine recherche de mise à jour.";
+                    UpdateWarnings();
+                    Log.Info($"Administration : version {result.Version} de {gameId} publiée.");
+                }
+                catch (OperationCanceledException) when (_cancellation.IsCancellationRequested)
+                {
+                    StatusMessage = null;
+                    ProgressText = "Envoi interrompu.";
+                }
+            });
+        }
+        finally
+        {
+            _cancellation.Dispose();
+            _cancellation = null;
+            _committing = false;
+            IsPublishing = false;
+            SpeedText = null;
+        }
+    }
+
+    private Task AbandonAsync() => RunAsync(async () =>
+    {
+        if (_interrupted is not { } publication) return;
+        if (!Context.Dialogs.Confirm("Abandonner la publication ?",
+                $"Les fichiers de la version {publication.Version} déjà reçus par le serveur seront supprimés. Rien n'a été mis en ligne.",
+                "Abandonner", danger: true))
+            return;
+        try
+        {
+            await Context.Session.CancelPublicationAsync(publication.PublicationId);
+        }
+        catch (ApiException ex) when (ex.Status == 404)
+        {
+            // déjà terminée ou expirée
+        }
+        SetInterrupted(null);
+        ProgressText = null;
+        ProgressValue = 0;
+    });
+
+    // ------------------------------------------------------------------ Outils
+
+    private Task RefreshPublishedAsync() => _selectedGame?.Value is { } gameId ? RefreshPublishedCoreAsync(gameId) : Task.CompletedTask;
+
+    /// <summary>Version en ligne (manifest du serveur) ; une erreur ici n'empêche pas de continuer.</summary>
+    private async Task RefreshPublishedCoreAsync(string gameId)
+    {
+        try
+        {
+            var state = await Context.Session.GetChangelogAsync(gameId);
+            _publishedVersion = state.ManifestVersion;
+            PublishedText = $"Version en ligne : {Display(state.ManifestVersion)}";
+        }
+        catch (ApiException ex) when (ex.Status == 404)
+        {
+            _publishedVersion = "";
+            PublishedText = "Aucune version en ligne pour l'instant.";
+        }
+        catch (ApiException ex) when (ex.Code == ApiErrorCodes.NotConfigured)
+        {
+            _publishedVersion = null;
+            PublishedText = "Publication non configurée sur le serveur pour ce jeu (LauncherApi:Games, voir server/deploy/LISEZMOI.md).";
+        }
+        catch (Exception ex) when (!ApiErrorText.IsSessionLost(ex))
+        {
+            _publishedVersion = null;
+            PublishedText = $"Version en ligne inconnue : {ApiErrorText.Describe(ex)}";
+        }
+        UpdateWarnings();
+    }
+
+    private void SetRelease(LocalRelease? release)
+    {
+        _release = release;
+        foreach (var name in new[] { nameof(HasRelease), nameof(VersionText), nameof(NotesTitle), nameof(HasNotesTitle), nameof(FilesText), nameof(ArchiveText) })
+            OnPropertyChanged(name);
+        UpdateWarnings();
+        RefreshCommands();
+    }
+
+    private void UpdateWarnings()
+    {
+        var warnings = new List<string>();
+        if (_release is { } release && !string.IsNullOrEmpty(_publishedVersion))
+        {
+            if (release.Summary.Version == _publishedVersion)
+                warnings.Add("Cette version est déjà en ligne : elle sera republiée (fichiers, archive et notes de cette version remplacés).");
+            else if (VersionUtil.TryParse(release.Summary.Version, out var local) && VersionUtil.TryParse(_publishedVersion, out var online) &&
+                     local < online)
+                warnings.Add($"Version inférieure à celle en ligne ({_publishedVersion}) : les joueurs reviendront à la version {release.Summary.Version}.");
+        }
+        if (_release is { Summary.NotesTitle: null })
+            warnings.Add("Aucune note pour cette version dans le manifest (celles déjà en ligne pour ce numéro sont conservées).");
+        Warnings = warnings;
+    }
+
+    private void OnStarted(PublicationState state)
+    {
+        SetInterrupted(state);
+        if (state.Resumed) ProgressText = "Reprise de l'envoi interrompu…";
+    }
+
+    private void SetInterrupted(PublicationState? state)
+    {
+        _interrupted = state;
+        OnPropertyChanged(nameof(HasInterrupted));
+        OnPropertyChanged(nameof(InterruptedText));
+        AbandonCommand.RaiseCanExecuteChanged();
+    }
+
+    private void OnProgress(UploadProgress progress)
+    {
+        if (progress.Step == ReleaseUploader.CommitStep && !_committing)
+        {
+            _committing = true; // la mise en ligne ne s'interrompt pas
+            CancelCommand.RaiseCanExecuteChanged();
+        }
+        ProgressValue = progress.Total > 0 ? Math.Clamp((double)progress.Done / progress.Total, 0, 1) : 0;
+        ProgressText = progress.Total > 0
+            ? $"{progress.Step} — {Format.Bytes(progress.Done)} / {Format.Bytes(progress.Total)}"
+            : progress.Step;
+        SpeedText = progress.BytesPerSecond > 0 ? Format.Speed(progress.BytesPerSecond) : null;
+    }
+
+    private void RefreshCommands()
+    {
+        ChooseCommand.RaiseCanExecuteChanged();
+        RecheckCommand.RaiseCanExecuteChanged();
+        PublishCommand.RaiseCanExecuteChanged();
+        CancelCommand.RaiseCanExecuteChanged();
+        AbandonCommand.RaiseCanExecuteChanged();
+    }
+
+    private static string Display(string version) => string.IsNullOrEmpty(version) ? "aucune" : version;
+}

src/GameLauncher.Modules.Admin/Publishing/ReleaseUploader.cs

@@ -0,0 +1,330 @@
+using System.Diagnostics;
+using System.Security.Cryptography;
+using GameLauncher.ApiClient;
+using GameLauncher.Contracts.Dtos;
+using GameLauncher.Contracts.Publishing;
+
+namespace GameLauncher.Modules.Admin.Publishing;
+
+/// <summary>Version prête à publier : dossier produit par ManifestBuilder (le .bat), contrôlé.</summary>
+public sealed record LocalRelease(string Folder, string ManifestPath, byte[] ManifestBytes, string ManifestSha256, ManifestSummary Summary)
+{
+    public string ArchivePath => Path.Combine(Folder, Summary.ArchiveName);
+
+    public string ObjectFile(string sha256) =>
+        Path.Combine(Folder, ManifestCheck.ObjectPath(sha256).Replace('/', Path.DirectorySeparatorChar));
+}
+
+/// <summary>Avancement de l'envoi.</summary>
+public sealed record UploadProgress(string Step, long Done, long Total, double BytesPerSecond);
+
+/// <summary>Contenu du dossier de publication incorrect (message affiché tel quel).</summary>
+public sealed class ReleaseCheckException : InvalidOperationException
+{
+    public ReleaseCheckException(string message) : base(message) { }
+}
+
+/// <summary>
+/// Publication d'une version : contrôle du dossier local, puis envoi au serveur (manifest, objets absents
+/// du serveur, archive) et mise en ligne. Reprise automatique : après une coupure (réseau, serveur
+/// occupé, trop de requêtes), l'état est relu sur le serveur et l'envoi continue là où il s'est arrêté ;
+/// relancé plus tard avec le même manifest, l'envoi reprend aussi.
+/// </summary>
+public static class ReleaseUploader
+{
+    private const int MaxAttempts = 8;
+
+    /// <summary>Dernière étape (mise en ligne sur le serveur) : elle ne s'interrompt pas.</summary>
+    public const string CommitStep = "Mise en ligne";
+
+    /// <summary>
+    /// Contrôle du dossier : manifest valide (mêmes règles que le serveur), du bon jeu, archive et fichiers
+    /// présents avec la bonne taille (empreintes vérifiées pendant l'envoi).
+    /// </summary>
+    public static LocalRelease Inspect(string manifestPath, string gameId)
+    {
+        var info = new FileInfo(manifestPath);
+        if (!info.Exists) throw new ReleaseCheckException($"Manifest introuvable : {manifestPath}");
+        if (info.Length > PublishingLimits.MaxManifestBytes) throw new ReleaseCheckException("Manifest trop volumineux.");
+        var bytes = File.ReadAllBytes(info.FullName);
+        var errors = new List<string>();
+        var summary = ManifestCheck.Check(bytes, gameId, expectedVersion: null, errors)
+                      ?? throw new ReleaseCheckException("Ce manifest ne peut pas être publié :\n" + string.Join("\n", errors.Take(8)));
+
+        var release = new LocalRelease(info.DirectoryName!, info.FullName, bytes, Convert.ToHexString(SHA256.HashData(bytes)).ToLowerInvariant(), summary);
+        var archive = new FileInfo(release.ArchivePath);
+        if (!archive.Exists) errors.Add($"Archive absente : {summary.ArchiveName}");
+        else if (archive.Length != summary.ArchiveSize) errors.Add($"Archive {summary.ArchiveName} : taille différente de celle du manifest.");
+        var missing = 0;
+        foreach (var (sha, size) in summary.Objects)
+        {
+            var file = new FileInfo(release.ObjectFile(sha));
+            if (file.Exists && file.Length == size) continue;
+            if (++missing <= 5) errors.Add($"{ManifestCheck.ObjectPath(sha)} : {(file.Exists ? "taille différente" : "absent")}.");
+        }
+        if (missing > 5) errors.Add($"… et {missing - 5} autre(s) fichier(s) de objects/.");
+        if (errors.Count > 0)
+            throw new ReleaseCheckException("Dossier de publication incomplet (relancez le .bat de publication) :\n" + string.Join("\n", errors));
+        return release;
+    }
+
+    /// <summary>Envoie ce qui manque puis met la version en ligne.</summary>
+    /// <param name="progress">Avancement ; un <see cref="Progress{T}"/> créé sur le fil de l'interface y est rappelé.</param>
+    /// <param name="started">Publication ouverte sur le serveur (pour l'abandonner si besoin). Comme <paramref name="progress"/>,
+    /// passer un <see cref="Progress{T}"/> : l'envoi se poursuit hors du fil de l'interface (ConfigureAwait(false)).</param>
+    public static async Task<PublicationResult> PublishAsync(AdminSession session, string gameId, LocalRelease release,
+        IProgress<UploadProgress>? progress, IProgress<PublicationState>? started, CancellationToken ct)
+    {
+        var run = new Run(session, release, progress);
+        var state = await Retry(() => session.StartPublicationAsync(gameId, new PublicationStartRequest
+        {
+            Version = release.Summary.Version,
+            ManifestSha256 = release.ManifestSha256,
+            ManifestSize = release.ManifestBytes.LongLength
+        }, ct), ct).ConfigureAwait(false);
+        started?.Report(state);
+
+        var committing = false;
+        for (var attempt = 1; ; attempt++)
+        {
+            var before = run.Done;
+            try
+            {
+                if (!committing)
+                {
+                    if (attempt > 1) state = await session.GetPublicationAsync(state.PublicationId, ct).ConfigureAwait(false);
+                    await run.ManifestAsync(state, ct).ConfigureAwait(false);
+                    if (!state.ManifestAccepted) state = await session.GetPublicationAsync(state.PublicationId, ct).ConfigureAwait(false);
+                    run.Plan(state);
+                    await run.ObjectsAsync(state, ct).ConfigureAwait(false);
+                    await run.ArchiveAsync(state, ct).ConfigureAwait(false);
+                    run.Report(CommitStep);
+                    committing = true;
+                }
+                // Mise en ligne : ni interrompue (elle se termine sur le serveur de toute façon), ni perdue
+                // (réponse perdue : le serveur renvoie le même résultat au nouvel essai).
+                return await session.CommitPublicationAsync(state.PublicationId, CancellationToken.None).ConfigureAwait(false);
+            }
+            catch (ApiException ex) when (IsTransient(ex) && attempt < MaxAttempts)
+            {
+                if (run.Done > before) attempt = 1; // l'envoi avance : les essais repartent de zéro
+                var delay = Backoff(attempt, ex);
+                if (delay > TimeSpan.Zero) run.Waiting(PauseReason(ex), delay);
+                await Task.Delay(delay, committing ? CancellationToken.None : ct).ConfigureAwait(false);
+            }
+        }
+    }
+
+    // ------------------------------------------------------------------ Envoi
+
+    private sealed class Run
+    {
+        private readonly AdminSession _session;
+        private readonly LocalRelease _release;
+        private readonly IProgress<UploadProgress>? _progress;
+        private readonly Stopwatch _clock = Stopwatch.StartNew();
+        private long _total, _done, _sentThisRun;
+
+        public long Done => _done;
+        private string _step = "Préparation";
+
+        public Run(AdminSession session, LocalRelease release, IProgress<UploadProgress>? progress)
+        {
+            _session = session;
+            _release = release;
+            _progress = progress;
+        }
+
+        public async Task ManifestAsync(PublicationState state, CancellationToken ct)
+        {
+            if (state.ManifestReceived >= state.ManifestSize) return;
+            if (_total == 0) _total = state.ManifestSize - state.ManifestReceived;
+            _step = "Envoi du manifest";
+            var bytes = _release.ManifestBytes;
+            for (var offset = state.ManifestReceived; offset < bytes.LongLength;)
+            {
+                var length = (int)Math.Min(PublishingLimits.ChunkBytes, bytes.LongLength - offset);
+                await _session.UploadManifestAsync(state.PublicationId, offset, bytes.AsSpan((int)offset, length).ToArray(), ct).ConfigureAwait(false);
+                offset += length;
+                Sent(length);
+            }
+        }
+
+        /// <summary>Total à envoyer, connu une fois le manifest accepté (calculé une seule fois).</summary>
+        public void Plan(PublicationState state)
+        {
+            if (_total > state.ManifestSize || !state.ManifestAccepted) return;
+            var objects = state.PendingObjects.Sum(sha => Size(sha) - state.PartialObjects.GetValueOrDefault(sha));
+            var archive = state.ArchiveComplete ? 0 : state.ArchiveSize - state.ArchiveReceived;
+            _total = _done + objects + archive;
+            Report(_step);
+        }
+
+        public async Task ObjectsAsync(PublicationState state, CancellationToken ct)
+        {
+            var pending = state.PendingObjects.Select(sha => sha.ToLowerInvariant()).ToList();
+            if (pending.Count == 0) return;
+            var count = 0;
+            void Step() => _step = $"Envoi des fichiers du jeu ({count}/{pending.Count})";
+
+            // Petits fichiers : par lots (une requête pour des centaines de fichiers).
+            var batch = new List<(string Sha, byte[] Data)>();
+            long batchBytes = 0;
+            async Task FlushAsync()
+            {
+                if (batch.Count == 0) return;
+                await _session.UploadObjectBatchAsync(state.PublicationId, ObjectBatch.Write(batch), ct).ConfigureAwait(false);
+                count += batch.Count;
+                Step();
+                Sent(batchBytes);
+                batch.Clear();
+                batchBytes = 0;
+            }
+
+            foreach (var sha in pending.Where(s => Size(s) <= PublishingLimits.BatchObjectMaxBytes))
+            {
+                ct.ThrowIfCancellationRequested();
+                var data = await File.ReadAllBytesAsync(_release.ObjectFile(sha), ct).ConfigureAwait(false);
+                if (Convert.ToHexString(SHA256.HashData(data)).ToLowerInvariant() != sha) throw Changed(ManifestCheck.ObjectPath(sha));
+                batch.Add((sha, data));
+                batchBytes += data.Length;
+                if (batchBytes >= PublishingLimits.ChunkBytes || batch.Count >= PublishingLimits.MaxObjectsPerBatch) await FlushAsync().ConfigureAwait(false);
+            }
+            await FlushAsync().ConfigureAwait(false);
+
+            // Gros fichiers : par morceaux, reprise à la position déjà reçue.
+            foreach (var sha in pending.Where(s => Size(s) > PublishingLimits.BatchObjectMaxBytes))
+            {
+                Step();
+                await FileAsync(_release.ObjectFile(sha), sha, state.PartialObjects.GetValueOrDefault(sha), ManifestCheck.ObjectPath(sha),
+                    (offset, data) => _session.UploadObjectAsync(state.PublicationId, sha, offset, data, ct), ct).ConfigureAwait(false);
+                count++;
+            }
+        }
+
+        public async Task ArchiveAsync(PublicationState state, CancellationToken ct)
+        {
+            if (state.ArchiveComplete) return;
+            _step = $"Envoi de l'archive {_release.Summary.ArchiveName}";
+            await FileAsync(_release.ArchivePath, _release.Summary.ArchiveSha256, state.ArchiveReceived, _release.Summary.ArchiveName,
+                (offset, data) => _session.UploadArchiveAsync(state.PublicationId, offset, data, ct), ct).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Envoi d'un fichier à partir de <paramref name="from"/> ; le fichier est relu en entier pour vérifier
+        /// son empreinte (un fichier modifié depuis la génération est refusé avant la mise en ligne).
+        /// </summary>
+        private async Task FileAsync(string path, string sha256, long from, string name, Func<long, byte[], Task<ChunkResult>> upload,
+                                     CancellationToken ct)
+        {
+            using var hash = IncrementalHash.CreateHash(HashAlgorithmName.SHA256);
+            await using var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, 1 << 16, useAsync: true);
+            var buffer = new byte[PublishingLimits.ChunkBytes];
+            long offset = 0;
+            while (true)
+            {
+                var read = await ReadFullAsync(stream, buffer, ct).ConfigureAwait(false);
+                if (read == 0) break;
+                hash.AppendData(buffer, 0, read);
+                if (offset + read > from)
+                {
+                    var skip = (int)Math.Max(0, from - offset);
+                    var chunk = buffer.AsSpan(skip, read - skip).ToArray();
+                    // Dernier morceau : l'empreinte locale est vérifiée AVANT de l'envoyer.
+                    if (offset + read == stream.Length &&
+                        Convert.ToHexString(hash.GetCurrentHash()).ToLowerInvariant() != sha256.ToLowerInvariant())
+                        throw Changed(name);
+                    await upload(offset + skip, chunk).ConfigureAwait(false);
+                    Sent(chunk.Length);
+                }
+                offset += read;
+            }
+            if (Convert.ToHexString(hash.GetHashAndReset()).ToLowerInvariant() != sha256.ToLowerInvariant()) throw Changed(name);
+        }
+
+        /// <summary>Pause avant un nouvel essai : affichée (sinon l'envoi semble figé), sans changer d'étape.</summary>
+        public void Waiting(string reason, TimeSpan delay) =>
+            _progress?.Report(new UploadProgress($"{_step} — {reason}, reprise dans {Math.Max(1, (int)Math.Ceiling(delay.TotalSeconds))} s…",
+                Math.Min(_done, Math.Max(_total, _done)), Math.Max(_total, _done), 0));
+
+        public void Report(string step)
+        {
+            _step = step;
+            var seconds = _clock.Elapsed.TotalSeconds;
+            _progress?.Report(new UploadProgress(step, Math.Min(_done, Math.Max(_total, _done)), Math.Max(_total, _done),
+                seconds > 0.5 ? _sentThisRun / seconds : 0));
+        }
+
+        private void Sent(long bytes)
+        {
+            _done += bytes;
+            _sentThisRun += bytes;
+            Report(_step);
+        }
+
+        private long Size(string sha) => _release.Summary.Objects.TryGetValue(sha.ToLowerInvariant(), out var size)
+            ? size
+            : throw new ReleaseCheckException("Le serveur attend un fichier absent de ce manifest : relancez la publication.");
+
+        private static ReleaseCheckException Changed(string name) => new(
+            $"« {name} » a changé depuis la génération de la version (son empreinte ne correspond plus au manifest) : relancez le .bat de publication.");
+
+        private static async Task<int> ReadFullAsync(Stream stream, byte[] buffer, CancellationToken ct)
+        {
+            var total = 0;
+            while (total < buffer.Length)
+            {
+                var read = await stream.ReadAsync(buffer.AsMemory(total), ct).ConfigureAwait(false);
+                if (read == 0) break;
+                total += read;
+            }
+            return total;
+        }
+    }
+
+    // ------------------------------------------------------------------ Coupures
+
+    /// <summary>Coupure réseau, délai dépassé, serveur occupé, trop de requêtes, position décalée : on reprend.</summary>
+    private static bool IsTransient(ApiException ex) =>
+        ex.Status is 0 or 429 or 502 or 504 ||
+        (ex.Status == 503 && ex.Code == ApiErrorCodes.Busy) ||
+        (ex.Status == 409 && ex.Code == ApiErrorCodes.OffsetMismatch);
+
+    /// <summary>
+    /// Attente avant un nouvel essai. Trop de requêtes : le délai annoncé par le serveur (Retry-After),
+    /// sinon (limite de nginx, qui se libère en une fraction de seconde) une pause courte qui double à
+    /// chaque refus consécutif.
+    /// </summary>
+    internal static TimeSpan Backoff(int attempt, ApiException ex)
+    {
+        if (ex.Code == ApiErrorCodes.OffsetMismatch) return TimeSpan.Zero;
+        if (ex.Status == 429)
+            return ex.RetryAfter is { } announced
+                ? TimeSpan.FromSeconds(Math.Clamp(Math.Ceiling(announced.TotalSeconds), 1, 60))
+                : TimeSpan.FromSeconds(Math.Min(30, 1 << Math.Min(attempt - 1, 5)));
+        return TimeSpan.FromSeconds(Math.Min(30, 2 * attempt * attempt));
+    }
+
+    private static string PauseReason(ApiException ex) => ex.Status switch
+    {
+        429 => "limite de requêtes du serveur atteinte",
+        0 => "connexion interrompue",
+        503 => "serveur occupé",
+        _ => "serveur indisponible"
+    };
+
+    private static async Task<T> Retry<T>(Func<Task<T>> action, CancellationToken ct)
+    {
+        for (var attempt = 1; ; attempt++)
+        {
+            try
+            {
+                return await action().ConfigureAwait(false);
+            }
+            catch (ApiException ex) when (IsTransient(ex) && attempt < MaxAttempts)
+            {
+                await Task.Delay(Backoff(attempt, ex), ct).ConfigureAwait(false);
+            }
+        }
+    }
+}

src/GameLauncher.Modules.Admin/Services/AdminConnection.cs

@@ -0,0 +1,60 @@
+using GameLauncher.ApiClient;
+using GameLauncher.Contracts.Security;
+using GameLauncher.Core.Utils;
+
+namespace GameLauncher.Modules.Admin.Services;
+
+/// <summary>
+/// Connexion ouverte : session + clé déverrouillée (en mémoire, ou ouverte dans la puce TPM). La fermer
+/// déconnecte la session sur le serveur et libère la clé : il faudra de nouveau la phrase de passe (ou le PIN).
+/// </summary>
+public sealed class AdminConnection : IAsyncDisposable
+{
+    private static readonly TimeSpan LogoutTimeout = TimeSpan.FromSeconds(5);
+
+    private readonly IAdminSigner _signer;
+    private readonly IDisposable _key;
+    private int _disposed;
+
+    /// <param name="key">Ce qui retient la clé (clé en mémoire, poignée de la clé TPM) : libéré à la fermeture.</param>
+    internal AdminConnection(LauncherApiClient client, AdminSession session, IAdminSigner signer, IDisposable key, string keyPath,
+                             bool isTpm = false)
+    {
+        Client = client;
+        Session = session;
+        _signer = signer;
+        _key = key;
+        KeyPath = keyPath;
+        IsTpm = isTpm;
+    }
+
+    public LauncherApiClient Client { get; }
+    public AdminSession Session { get; }
+    public string KeyPath { get; }
+    public string Fingerprint => AdminKeys.ComputeFingerprint(_signer.PublicKey);
+
+    /// <summary>Clé conservée dans la puce de sécurité (TPM) de ce PC.</summary>
+    public bool IsTpm { get; }
+
+    /// <summary>Fin de session (durée maximale), à l'heure du PC.</summary>
+    public DateTimeOffset LocalExpiresAt => Session.ExpiresAt - Session.ClockOffset;
+
+    /// <summary>
+    /// Libère d'abord la clé (la déconnexion n'est pas signée : elle n'en a pas besoin), puis ferme la
+    /// session sur le serveur — au mieux, sans bloquer : injoignable, elle expirera d'elle-même.
+    /// </summary>
+    public async ValueTask DisposeAsync()
+    {
+        if (Interlocked.Exchange(ref _disposed, 1) != 0) return;
+        _key.Dispose();
+        using var timeout = new CancellationTokenSource(LogoutTimeout);
+        try
+        {
+            await Session.LogoutAsync(timeout.Token).ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            Log.Warn($"Administration : déconnexion du serveur impossible ({ex.GetType().Name}) ; la session expirera d'elle-même.");
+        }
+    }
+}

src/GameLauncher.Modules.Admin/Services/AdminEnrollmentService.cs

@@ -0,0 +1,193 @@
+using System.Security.Cryptography;
+using GameLauncher.ApiClient;
+using GameLauncher.Contracts;
+using GameLauncher.Contracts.Dtos;
+using GameLauncher.Contracts.Security;
+
+namespace GameLauncher.Modules.Admin.Services;
+
+/// <summary>Résultat de la création d'une clé (et de son enregistrement auprès du serveur avec une invitation).</summary>
+/// <param name="Enrollment">Réponse du serveur ; null si aucune invitation n'a été utilisée (clé seulement) ou sans réponse.</param>
+/// <param name="EnrollmentUnconfirmed">
+/// Invitation envoyée mais réponse du serveur perdue (délai dépassé, coupure, erreur 5xx) : le serveur a
+/// peut-être enregistré la clé et consommé l'invitation. La clé est donc CONSERVÉE (message expliquant quoi faire).
+/// </param>
+/// <param name="IsTpm">Clé créée dans la puce de sécurité (TPM) de ce PC ; KeyPath est alors son fichier de référence.</param>
+public sealed record AdminKeyCreation(string KeyPath, string PublicKeyPath, string KeyId, string Fingerprint,
+                                      EnrollmentResponse? Enrollment, string? EnrollmentUnconfirmed = null, bool IsTpm = false);
+
+/// <summary>Clé fichier en mémoire, vue comme une clé « libérable » (même contrat que la clé TPM).</summary>
+internal sealed class FileKeySigner : IDisposableAdminSigner
+{
+    private readonly EcdsaAdminSigner _inner;
+
+    public FileKeySigner(EcdsaAdminSigner inner) => _inner = inner;
+
+    public byte[] PublicKey => _inner.PublicKey;
+    public string KeyId => _inner.KeyId;
+    public ValueTask<byte[]> SignAsync(byte[] message, CancellationToken ct = default) => _inner.SignAsync(message, ct);
+    public void Dispose() => _inner.Dispose();
+}
+
+/// <summary>
+/// Création d'une clé d'administrateur sur ce PC — fichier chiffré par une phrase de passe, ou clé
+/// non exportable dans la puce TPM protégée par un code PIN — et, avec un code d'invitation,
+/// enregistrement auprès du serveur (preuve de possession). Si le serveur REFUSE (erreur 4xx), la clé
+/// est supprimée (fichiers, et clé de la puce) ; sans réponse sûre, elle est conservée.
+/// </summary>
+public sealed class AdminEnrollmentService
+{
+    private readonly LauncherApiClient _client;
+    private readonly IAdminTpm? _tpm;
+
+    /// <param name="tpm">Puce de sécurité de ce PC (null : clés TPM indisponibles).</param>
+    public AdminEnrollmentService(LauncherApiClient client, IAdminTpm? tpm = null)
+    {
+        _client = client;
+        _tpm = tpm;
+    }
+
+    /// <param name="keyPath">Fichier .key (clé chiffrée) ou, avec <paramref name="useTpm"/>, fichier de référence .tpmkey.</param>
+    /// <param name="secret">Phrase de passe du fichier (12 caractères au moins) ou code PIN de la clé TPM (6 au moins).</param>
+    /// <param name="useTpm">Vrai : clé créée dans la puce de sécurité (TPM) de ce PC.</param>
+    public async Task<AdminKeyCreation> CreateKeyAsync(string keyPath, string secret, string? invitationCode, string? keyLabel,
+                                                       CancellationToken ct = default, bool useTpm = false)
+    {
+        var minLength = useTpm ? AdminTpmKeyFile.MinPinLength : AdminKeyFile.MinPassphraseLength;
+        if (secret.Length < minLength)
+            throw new ArgumentException(useTpm
+                ? $"Le code PIN doit contenir au moins {minLength} caractères."
+                : $"La phrase de passe doit contenir au moins {minLength} caractères.");
+        string? code = null;
+        if (!string.IsNullOrWhiteSpace(invitationCode))
+            code = InvitationCodes.Normalize(invitationCode)
+                   ?? throw new ArgumentException("Code d'invitation mal saisi : 32 caractères (lettres A à Z, chiffres 2 à 7), tirets facultatifs.");
+        var label = string.IsNullOrWhiteSpace(keyLabel) ? null : ApiText.CleanLine(keyLabel, ApiText.MaxKeyLabelLength)
+            ?? throw new ArgumentException($"Nom du poste invalide ({ApiText.MaxKeyLabelLength} caractères au plus, sans caractère spécial invisible).");
+
+        var fullPath = Path.GetFullPath(keyPath);
+        if (AdminKeyLocator.IsReserved(fullPath))
+            throw new InvalidOperationException($"« {AdminKeyLocator.ReservedFileName} » est réservé à la clé de signature du launcher.");
+        var extension = useTpm ? AdminTpmKeyFile.Extension : AdminKeyFile.PrivateKeyExtension;
+        if (!fullPath.EndsWith(extension, StringComparison.OrdinalIgnoreCase))
+            throw new ArgumentException($"Le fichier de clé doit avoir l'extension {extension}.");
+        var publicPath = Path.ChangeExtension(fullPath, AdminKeyFile.PublicKeyExtension);
+        // Les deux types de clés partagent le même .pub : aucun des trois fichiers ne doit exister.
+        var otherPath = Path.ChangeExtension(fullPath, useTpm ? AdminKeyFile.PrivateKeyExtension : AdminTpmKeyFile.Extension);
+        if (File.Exists(fullPath) || File.Exists(publicPath) || File.Exists(otherPath))
+            throw new IOException($"Une clé existe déjà à cet emplacement : {Path.ChangeExtension(fullPath, null)}. Choisissez un autre nom.");
+        var tpm = useTpm ? _tpm ?? throw new InvalidOperationException("La puce de sécurité (TPM) n'est pas utilisable sur ce PC.") : null;
+
+        // Génération (et chiffrement, ou accès à la puce : lents) hors du fil de l'interface.
+        string? tpmKeyName = null;
+        IDisposableAdminSigner signer;
+        if (tpm is not null)
+        {
+            var keyName = AdminTpmKeyFile.NewKeyName();
+            signer = await BackgroundWork.RunAsync(() =>
+            {
+                var created = tpm.CreateKey(keyName, secret);
+                try
+                {
+                    AdminTpmKeyFile.Save(fullPath, keyName, created.PublicKey);
+                    return created;
+                }
+                catch
+                {
+                    created.Dispose();
+                    DeleteTpmKey(tpm, keyName);
+                    throw;
+                }
+            }, ct).ConfigureAwait(false);
+            tpmKeyName = keyName;
+        }
+        else
+        {
+            signer = await BackgroundWork.RunAsync<IDisposableAdminSigner>(() =>
+            {
+                var key = AdminKeyFile.Generate();
+                try
+                {
+                    AdminKeyFile.Save(key, fullPath, secret);
+                    return new FileKeySigner(new EcdsaAdminSigner(key));
+                }
+                catch
+                {
+                    key.Dispose();
+                    throw;
+                }
+            }, ct).ConfigureAwait(false);
+        }
+
+        try
+        {
+            EnrollmentResponse? enrollment = null;
+            string? unconfirmed = null;
+            if (code is not null)
+            {
+                try
+                {
+                    enrollment = await _client.EnrollAsync(code, signer, label, ct).ConfigureAwait(false);
+                }
+                catch (Exception ex) when (IsDefinitiveRefusal(ex) || ex is CryptographicException or ObjectDisposedException)
+                {
+                    // Refus certain (invitation invalide, expirée, déjà utilisée…), ou signature de la preuve
+                    // impossible (puce bloquée…) avant tout envoi : rien n'a été enregistré.
+                    signer.Dispose();
+                    if (tpmKeyName is not null)
+                    {
+                        AdminTpmKeyFile.DeleteFiles(fullPath);
+                        DeleteTpmKey(tpm!, tpmKeyName);
+                    }
+                    else
+                    {
+                        TryDelete(fullPath);
+                        TryDelete(publicPath);
+                    }
+                    throw;
+                }
+                catch (Exception ex) when (ex is ApiException or OperationCanceledException or HttpRequestException or IOException)
+                {
+                    unconfirmed = $"Le serveur n'a pas confirmé l'enregistrement ({ApiErrorText.Describe(ex)}). " +
+                                  "Votre clé est conservée : communiquez son empreinte à la personne qui vous a invité. " +
+                                  "Si elle ne voit aucune clé en attente à votre nom, demandez-lui une nouvelle invitation.";
+                }
+            }
+            var publicKey = signer.PublicKey;
+            return new AdminKeyCreation(fullPath, publicPath, AdminKeys.ComputeKeyId(publicKey), AdminKeys.ComputeFingerprint(publicKey),
+                                        enrollment, unconfirmed, IsTpm: tpmKeyName is not null);
+        }
+        finally
+        {
+            signer.Dispose();
+        }
+    }
+
+    private static void DeleteTpmKey(IAdminTpm tpm, string keyName)
+    {
+        try
+        {
+            tpm.DeleteKey(keyName);
+        }
+        catch (Exception ex)
+        {
+            Core.Utils.Log.Warn($"Administration : clé {keyName} non supprimée de la puce ({ex.Message}).");
+        }
+    }
+
+    /// <summary>Le serveur a répondu par un refus (4xx), ou la requête n'a pas pu partir (horloge) : rien d'enregistré.</summary>
+    private static bool IsDefinitiveRefusal(Exception ex) => ex is ApiException api &&
+        ((api.Status is >= 400 and < 500 && api.Code != "invalid_response") || api.Code == "clock_skew");
+
+    private static void TryDelete(string path)
+    {
+        try
+        {
+            File.Delete(path);
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            // laissé en place : sans danger (clé chiffrée, jamais enregistrée sur le serveur)
+        }
+    }
+}

src/GameLauncher.Modules.Admin/Services/AdminKeyLocator.cs

@@ -0,0 +1,149 @@
+using GameLauncher.ApiClient;
+using GameLauncher.Contracts.Security;
+
+namespace GameLauncher.Modules.Admin.Services;
+
+/// <summary>Clé d'administrateur trouvée sur ce PC.</summary>
+/// <param name="Path">Chemin complet du fichier .key (clé chiffrée) ou .tpmkey (référence d'une clé TPM).</param>
+/// <param name="Fingerprint">Empreinte (null si inconnue : fichier .pub absent).</param>
+/// <param name="IsTpm">Clé conservée dans la puce de sécurité (TPM) de ce PC : déverrouillée par un code PIN.</param>
+public sealed record AdminKeyEntry(string Path, string? KeyId, string? Fingerprint, bool IsTpm = false)
+{
+    public string Name => System.IO.Path.GetFileNameWithoutExtension(Path);
+
+    public string Detail => Fingerprint is null ? "Empreinte inconnue (fichier .pub absent)" : $"Empreinte {Fingerprint}";
+
+    /// <summary>Libellé du secret demandé à la connexion.</summary>
+    public string SecretLabel => IsTpm ? "Code PIN de la clé (puce TPM)" : "Phrase de passe de la clé";
+}
+
+/// <summary>
+/// Recherche des clés d'administrateur : dossier %USERPROFILE%\.launcher-keys (celui de
+/// tools\admin-key.bat) et fichiers déjà utilisés. La clé de SIGNATURE DU LAUNCHER, rangée dans le
+/// même dossier, n'est jamais proposée : elle sert à autre chose et ne doit pas circuler.
+/// </summary>
+public static class AdminKeyLocator
+{
+    /// <summary>Clé de signature des mises à jour du launcher (tools\keygen-launcher.bat).</summary>
+    public const string ReservedFileName = "launcher-signing.key";
+
+    private const long MaxKeyFileBytes = 16 * 1024;
+
+    public static string DefaultDirectory =>
+        System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".launcher-keys");
+
+    /// <summary>
+    /// Clé de signature du launcher, copies comprises (« launcher-signing - Copie.key »…) : ne doit jamais
+    /// être déverrouillée par le menu d'administration. Chemin normalisé (« launcher-signing.key. »…).
+    /// </summary>
+    public static bool IsReserved(string path)
+    {
+        string name;
+        try
+        {
+            name = System.IO.Path.GetFileName(System.IO.Path.GetFullPath(path)).TrimEnd('.', ' ');
+        }
+        catch (Exception ex) when (ex is ArgumentException or NotSupportedException or PathTooLongException)
+        {
+            return true; // chemin invalide : refusé
+        }
+        return name.StartsWith(System.IO.Path.GetFileNameWithoutExtension(ReservedFileName), StringComparison.OrdinalIgnoreCase);
+    }
+
+    /// <summary>Clés du dossier <paramref name="directory"/> puis des chemins mémorisés (sans doublon).</summary>
+    public static IReadOnlyList<AdminKeyEntry> Find(string directory, IEnumerable<string>? rememberedPaths = null)
+    {
+        var paths = new List<string>();
+        try
+        {
+            if (Directory.Exists(directory))
+                paths.AddRange(Directory.EnumerateFiles(directory, "*" + AdminKeyFile.PrivateKeyExtension, SearchOption.TopDirectoryOnly)
+                                        .Concat(Directory.EnumerateFiles(directory, "*" + AdminTpmKeyFile.Extension, SearchOption.TopDirectoryOnly))
+                                        .OrderBy(p => p, StringComparer.OrdinalIgnoreCase));
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            // dossier illisible : seulement les chemins mémorisés
+        }
+        paths.AddRange(rememberedPaths ?? Enumerable.Empty<string>());
+
+        var result = new List<AdminKeyEntry>();
+        foreach (var path in paths)
+        {
+            // Describe normalise le chemin et ignore les chemins invalides (admin.json modifié à la main…).
+            if (Describe(path) is not { } entry) continue;
+            if (result.Any(e => string.Equals(e.Path, entry.Path, StringComparison.OrdinalIgnoreCase))) continue;
+            result.Add(entry);
+        }
+        return result;
+    }
+
+    /// <summary>Décrit un fichier de clé chiffré ; null s'il n'en est pas un (ou s'il est réservé).</summary>
+    public static AdminKeyEntry? Describe(string path)
+    {
+        try
+        {
+            var full = System.IO.Path.GetFullPath(path);
+            var info = new FileInfo(full);
+            if (!info.Exists || info.Length > MaxKeyFileBytes || IsReserved(full)) return null;
+
+            // Référence d'une clé TPM : empreinte calculée depuis la clé publique qu'elle contient
+            // (comparée à celle de la puce à la connexion).
+            if (AdminTpmKeyFile.IsTpmKeyPath(full))
+            {
+                try
+                {
+                    var reference = AdminTpmKeyFile.Load(full);
+                    return new AdminKeyEntry(full, AdminKeys.ComputeKeyId(reference.PublicKey),
+                                             AdminKeys.ComputeFingerprint(reference.PublicKey), IsTpm: true);
+                }
+                catch (System.Security.Cryptography.CryptographicException)
+                {
+                    return null;
+                }
+            }
+
+            // Clé fichier : reconnue à son contenu (extension .key conseillée, mais pas exigée : admin-key.bat --out).
+            if (!File.ReadAllText(full).Contains("-----BEGIN ENCRYPTED PRIVATE KEY-----", StringComparison.Ordinal)) return null;
+
+            string? keyId = null, fingerprint = null;
+            var publicPath = System.IO.Path.ChangeExtension(full, AdminKeyFile.PublicKeyExtension);
+            if (File.Exists(publicPath) && new FileInfo(publicPath).Length <= MaxKeyFileBytes)
+            {
+                try
+                {
+                    var spki = AdminKeys.ParsePublicKey(File.ReadAllText(publicPath));
+                    keyId = AdminKeys.ComputeKeyId(spki);
+                    fingerprint = AdminKeys.ComputeFingerprint(spki);
+                }
+                catch (System.Security.Cryptography.CryptographicException)
+                {
+                    // .pub illisible : empreinte inconnue (la clé reste utilisable)
+                }
+            }
+            return new AdminKeyEntry(full, keyId, fingerprint);
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or ArgumentException or NotSupportedException)
+        {
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Emplacement libre pour une nouvelle clé : admin, sinon admin-2, admin-3… Le nom est libre pour
+    /// les deux types de clés (.key, .tpmkey) et pour le .pub qu'ils partageraient.
+    /// </summary>
+    /// <param name="tpm">Vrai : chemin d'un fichier de référence de clé TPM (.tpmkey).</param>
+    public static string SuggestNewKeyPath(string directory, bool tpm = false)
+    {
+        var extension = tpm ? AdminTpmKeyFile.Extension : AdminKeyFile.PrivateKeyExtension;
+        for (var i = 1; i < 1000; i++)
+        {
+            var name = System.IO.Path.Combine(directory, i == 1 ? "admin" : $"admin-{i}");
+            if (!File.Exists(name + AdminKeyFile.PrivateKeyExtension) && !File.Exists(name + AdminTpmKeyFile.Extension) &&
+                !File.Exists(name + AdminKeyFile.PublicKeyExtension))
+                return name + extension;
+        }
+        return System.IO.Path.Combine(directory, $"admin-{Guid.NewGuid():N}{extension}");
+    }
+}

src/GameLauncher.Modules.Admin/Services/AdminLoginService.cs

@@ -0,0 +1,73 @@
+using System.Security.Cryptography;
+using GameLauncher.ApiClient;
+
+namespace GameLauncher.Modules.Admin.Services;
+
+/// <summary>
+/// Connexion : ouvre la clé (fichier chiffré déverrouillé en arrière-plan, ou clé de la puce TPM avec
+/// son code PIN), puis défi signé auprès du serveur.
+/// </summary>
+public sealed class AdminLoginService
+{
+    private readonly LauncherApiClient _client;
+    private readonly string _clientName;
+    private readonly IAdminTpm? _tpm;
+
+    /// <param name="clientName">Description du poste pour le journal d'audit, ex. « GameLauncher 1.4.0 (PC-BUREAU) ».</param>
+    /// <param name="tpm">Puce de sécurité de ce PC (null : clés TPM indisponibles).</param>
+    public AdminLoginService(LauncherApiClient client, string clientName, IAdminTpm? tpm = null)
+    {
+        _client = client;
+        _clientName = clientName;
+        _tpm = tpm;
+    }
+
+    /// <param name="keyPath">Fichier .key (clé chiffrée) ou .tpmkey (référence d'une clé TPM).</param>
+    /// <param name="secret">Phrase de passe du fichier, ou code PIN de la clé TPM.</param>
+    public async Task<AdminConnection> LoginAsync(string keyPath, string secret, CancellationToken ct = default)
+    {
+        if (AdminKeyLocator.IsReserved(keyPath))
+            throw new InvalidOperationException("Ce fichier est la clé de signature du launcher : utilisez votre clé d'administrateur.");
+        keyPath = Path.GetFullPath(keyPath);
+        var isTpm = AdminTpmKeyFile.IsTpmKeyPath(keyPath);
+        if (string.IsNullOrEmpty(secret))
+            throw new ArgumentException(isTpm ? "Saisissez le code PIN de la clé." : "Saisissez la phrase de passe de la clé.");
+
+        IAdminSigner signer;
+        IDisposable key;
+        if (isTpm)
+        {
+            var tpm = _tpm ?? throw new InvalidOperationException("La puce de sécurité (TPM) n'est pas utilisable sur ce PC.");
+            var reference = AdminTpmKeyFile.Load(keyPath);
+            var opened = await BackgroundWork.RunAsync(() => tpm.OpenKey(reference.KeyName, reference.PublicKey, secret), ct)
+                                              .ConfigureAwait(false);
+            // Le fichier de référence ne doit pas pouvoir faire utiliser une AUTRE clé que celle annoncée
+            // (déjà vérifié par la puce avant le code PIN ; contrôlé de nouveau ici).
+            if (!opened.PublicKey.AsSpan().SequenceEqual(reference.PublicKey))
+            {
+                opened.Dispose();
+                throw new CryptographicException("La clé de la puce ne correspond pas à ce fichier de référence : fichier modifié ?");
+            }
+            signer = opened;
+            key = opened;
+        }
+        else
+        {
+            // Déchiffrement volontairement lent (PBKDF2, 600 000 itérations) : hors du fil de l'interface.
+            var opened = await BackgroundWork.RunAsync(() => new EcdsaAdminSigner(AdminKeyFile.Load(keyPath, secret)), ct).ConfigureAwait(false);
+            signer = opened;
+            key = opened;
+        }
+
+        try
+        {
+            var session = await _client.LoginAsync(signer, _clientName, ct).ConfigureAwait(false);
+            return new AdminConnection(_client, session, signer, key, keyPath, isTpm);
+        }
+        catch
+        {
+            key.Dispose();
+            throw;
+        }
+    }
+}

src/GameLauncher.Modules.Admin/Services/AdminSessionGuard.cs

@@ -0,0 +1,153 @@
+using GameLauncher.ApiClient;
+using GameLauncher.Contracts.Dtos;
+using GameLauncher.Core.Utils;
+
+namespace GameLauncher.Modules.Admin.Services;
+
+/// <summary>
+/// Surveille la session ouverte :
+///  • verrouillage après <see cref="LockAfter"/> sans activité dans la fenêtre d'administration ;
+///  • verrouillage à la fin de la durée maximale de la session (8 h) ;
+///  • tant que l'administrateur est actif, la session est prolongée sur le serveur (toutes les
+///    <see cref="KeepAliveEvery"/>) ; si le serveur la refuse (expirée, révoquée), verrouillage.
+/// </summary>
+public sealed class AdminSessionGuard : IDisposable
+{
+    public static readonly TimeSpan DefaultLockAfter = TimeSpan.FromMinutes(10);
+    public static readonly TimeSpan KeepAliveEvery = TimeSpan.FromMinutes(4);
+    private static readonly TimeSpan TickEvery = TimeSpan.FromSeconds(15);
+
+    private readonly AdminConnection _connection;
+    private readonly TimeProvider _time;
+    private readonly ITimer? _timer;
+    private DateTimeOffset _lastActivity;
+    private DateTimeOffset _lastKeepAlive;
+    private bool _refreshing;
+    private bool _locked;
+    private bool _disposed;
+
+    public AdminSessionGuard(AdminConnection connection, TimeProvider time, IUiDispatcher ui, TimeSpan? lockAfter = null,
+                             bool startTimer = true)
+    {
+        _connection = connection;
+        _time = time;
+        LockAfter = lockAfter ?? DefaultLockAfter;
+        _lastActivity = _lastKeepAlive = time.GetUtcNow();
+        if (startTimer) _timer = time.CreateTimer(_ => ui.Post(() => _ = TickAsync()), null, TickEvery, TickEvery);
+    }
+
+    public TimeSpan LockAfter { get; }
+
+    /// <summary>Verrouillage demandé (le message explique pourquoi) ; attendu par <see cref="TickAsync"/>.</summary>
+    public Func<string, Task>? LockRequested { get; set; }
+
+    /// <summary>Le temps restant a changé (affichage).</summary>
+    public event Action? Changed;
+
+    /// <summary>Moment du verrouillage prévu (inactivité ou fin de session).</summary>
+    public DateTimeOffset LockAt
+    {
+        get
+        {
+            var idle = _lastActivity + LockAfter;
+            return idle < _connection.LocalExpiresAt ? idle : _connection.LocalExpiresAt;
+        }
+    }
+
+    public TimeSpan Remaining
+    {
+        get
+        {
+            var remaining = LockAt - _time.GetUtcNow();
+            return remaining < TimeSpan.Zero ? TimeSpan.Zero : remaining;
+        }
+    }
+
+    private int _longOperations;
+
+    /// <summary>Opération longue (envoi d'une version) : compte comme une activité jusqu'à sa fin.</summary>
+    public IDisposable BeginLongOperation()
+    {
+        Interlocked.Increment(ref _longOperations);
+        return new LongOperation(this);
+    }
+
+    private sealed class LongOperation : IDisposable
+    {
+        private AdminSessionGuard? _guard;
+
+        public LongOperation(AdminSessionGuard guard) => _guard = guard;
+
+        public void Dispose()
+        {
+            if (Interlocked.Exchange(ref _guard, null) is not { } guard) return;
+            Interlocked.Decrement(ref guard._longOperations);
+            guard._lastActivity = guard._time.GetUtcNow(); // 10 minutes à compter de la fin de l'opération
+        }
+    }
+
+    /// <summary>Activité de l'administrateur (souris, clavier) dans la fenêtre d'administration.</summary>
+    public void NotifyActivity()
+    {
+        var now = _time.GetUtcNow();
+        if (now - _lastActivity < TimeSpan.FromSeconds(1)) return;
+        _lastActivity = now;
+    }
+
+    /// <summary>Vérification périodique (minuterie) ; publique pour les tests.</summary>
+    public async Task TickAsync()
+    {
+        if (_locked || _disposed) return;
+        var now = _time.GetUtcNow();
+        if (Volatile.Read(ref _longOperations) > 0) _lastActivity = now;
+        if (now >= _connection.LocalExpiresAt)
+        {
+            await LockAsync("La session a atteint sa durée maximale : reconnectez-vous.");
+            return;
+        }
+        if (now - _lastActivity >= LockAfter)
+        {
+            await LockAsync($"Verrouillé après {LockAfter.TotalMinutes:0} minutes d'inactivité.");
+            return;
+        }
+
+        if (!_refreshing && now - _lastKeepAlive >= KeepAliveEvery && _lastActivity > _lastKeepAlive)
+        {
+            _refreshing = true;
+            try
+            {
+                await _connection.Session.RefreshAsync();
+                _lastKeepAlive = _time.GetUtcNow();
+            }
+            catch (ApiException ex) when (ex.Status == 401 && ex.Code == ApiErrorCodes.Unauthorized)
+            {
+                await LockAsync("Session expirée ou révoquée sur le serveur : reconnectez-vous.");
+                return;
+            }
+            catch (Exception ex)
+            {
+                // Serveur momentanément injoignable, délai dépassé… : nouvel essai au prochain passage.
+                // L'inactivité et la durée maximale restent contrôlées localement.
+                Log.Warn($"Administration : prolongation de la session impossible ({ex.GetType().Name}).");
+            }
+            finally
+            {
+                _refreshing = false;
+            }
+        }
+        Changed?.Invoke();
+    }
+
+    private async Task LockAsync(string reason)
+    {
+        if (_locked) return;
+        _locked = true;
+        if (LockRequested is { } handler) await handler(reason);
+    }
+
+    public void Dispose()
+    {
+        _disposed = true;
+        _timer?.Dispose();
+    }
+}

src/GameLauncher.Modules.Admin/Services/AdminSettings.cs

@@ -0,0 +1,64 @@
+using System.Text.Json;
+using GameLauncher.Core.Utils;
+
+namespace GameLauncher.Modules.Admin.Services;
+
+/// <summary>
+/// Préférences du menu d'administration sur ce PC (%AppData%\…\GameLauncher\admin.json) : chemins
+/// des fichiers de clé utilisés. Aucun secret (les clés restent chiffrées dans leurs fichiers).
+/// </summary>
+public sealed class AdminSettings
+{
+    public const string FileName = "admin.json";
+    private const int MaxRememberedKeys = 10;
+
+    public string? LastKeyPath { get; set; }
+
+    public List<string> KeyPaths { get; set; } = new();
+
+    public static AdminSettings Load(string path)
+    {
+        try
+        {
+            if (!File.Exists(path) || new FileInfo(path).Length > 64 * 1024) return new AdminSettings();
+            var settings = JsonSerializer.Deserialize<AdminSettings>(File.ReadAllText(path), JsonDefaults.Options) ?? new AdminSettings();
+            settings.KeyPaths = (settings.KeyPaths ?? new()).Where(p => !string.IsNullOrWhiteSpace(p)).Take(MaxRememberedKeys).ToList();
+            return settings;
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or JsonException)
+        {
+            Log.Warn($"Préférences d'administration illisibles ({path}) : {ex.Message}");
+            return new AdminSettings();
+        }
+    }
+
+    /// <summary>Oublie une clé (supprimée).</summary>
+    public void Forget(string keyPath)
+    {
+        KeyPaths.RemoveAll(p => string.Equals(p, keyPath, StringComparison.OrdinalIgnoreCase));
+        if (string.Equals(LastKeyPath, keyPath, StringComparison.OrdinalIgnoreCase)) LastKeyPath = null;
+    }
+
+    /// <summary>Mémorise la clé utilisée (en tête de liste).</summary>
+    public void Remember(string keyPath)
+    {
+        var full = Path.GetFullPath(keyPath);
+        LastKeyPath = full;
+        KeyPaths.RemoveAll(p => string.Equals(p, full, StringComparison.OrdinalIgnoreCase));
+        KeyPaths.Insert(0, full);
+        if (KeyPaths.Count > MaxRememberedKeys) KeyPaths.RemoveRange(MaxRememberedKeys, KeyPaths.Count - MaxRememberedKeys);
+    }
+
+    public void Save(string path)
+    {
+        try
+        {
+            Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(path))!);
+            FileUtil.WriteAllTextAtomic(path, JsonSerializer.Serialize(this, JsonDefaults.Options));
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            Log.Warn($"Préférences d'administration non enregistrées ({path}) : {ex.Message}");
+        }
+    }
+}

src/GameLauncher.Modules.Admin/Services/AdminTexts.cs

@@ -0,0 +1,35 @@
+using GameLauncher.Contracts.Security;
+
+namespace GameLauncher.Modules.Admin.Services;
+
+/// <summary>Libellés affichés (français).</summary>
+public static class AdminTexts
+{
+    public static string Permission(string permission) => permission switch
+    {
+        AdminPermissions.AdminsManage => "Gestion des administrateurs",
+        AdminPermissions.AuditRead => "Journal d'audit",
+        AdminPermissions.GamesEdit => "Informations des jeux",
+        AdminPermissions.ChangelogEdit => "Notes de version",
+        AdminPermissions.ReleasesPublish => "Publication des versions",
+        _ => permission
+    };
+
+    public static string Role(string? role) => AdminRoles.DisplayName(role);
+
+    /// <summary>Initiales pour l'avatar : « Nicolas Deville » → « ND ».</summary>
+    public static string Initials(string? name)
+    {
+        var parts = (name ?? "").Split(' ', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+        var initials = string.Concat(parts.Take(2).Select(p => char.ToUpperInvariant(p[0])));
+        return initials.Length == 0 ? "?" : initials;
+    }
+
+    /// <summary>Durée lisible : « 9 min », « moins d'une minute », « 2 h 05 ».</summary>
+    public static string Duration(TimeSpan duration)
+    {
+        if (duration < TimeSpan.FromMinutes(1)) return "moins d'une minute";
+        if (duration < TimeSpan.FromHours(1)) return $"{(int)duration.TotalMinutes} min";
+        return $"{(int)duration.TotalHours} h {duration.Minutes:00}";
+    }
+}

src/GameLauncher.Modules.Admin/Services/AdminTpmKeyFile.cs

@@ -0,0 +1,132 @@
+using System.Security.Cryptography;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using System.Text.RegularExpressions;
+using GameLauncher.ApiClient;
+using GameLauncher.Contracts.Security;
+
+namespace GameLauncher.Modules.Admin.Services;
+
+/// <summary>Clé conservée dans la puce TPM, telle que décrite par son fichier de référence.</summary>
+/// <param name="KeyName">Nom de la clé dans la puce de ce PC.</param>
+/// <param name="PublicKey">Clé publique (SPKI DER) attendue : comparée à celle de la puce à l'ouverture.</param>
+public sealed record AdminTpmKeyReference(string KeyName, byte[] PublicKey);
+
+/// <summary>
+/// Fichier de référence d'une clé TPM (« admin.tpmkey ») : il ne contient AUCUN secret, seulement le
+/// nom de la clé dans la puce et sa clé publique. Copié sur un autre PC, il ne sert à rien. Un fichier
+/// .pub est écrit à côté, comme pour une clé fichier (déclaration du premier propriétaire : add-owner).
+/// </summary>
+public static partial class AdminTpmKeyFile
+{
+    public const string Extension = ".tpmkey";
+
+    /// <summary>
+    /// Longueur minimale du code PIN. Plus courte que la phrase de passe d'un fichier (12) : le code
+    /// ne peut être essayé que sur la puce elle-même, qui se bloque après quelques erreurs.
+    /// </summary>
+    public const int MinPinLength = 6;
+
+    /// <summary>Préfixe des noms de clés créées par le launcher (seules ces clés peuvent être ouvertes).</summary>
+    public const string KeyNamePrefix = "GameLauncher.Admin.";
+
+    private const string Format = "gamelauncher-admin-tpm-key";
+    private const int MaxFileBytes = 16 * 1024;
+
+    [GeneratedRegex(@"\AGameLauncher\.Admin\.[0-9a-f]{32}\z")]
+    private static partial Regex KeyNameRegex();
+
+    public static string NewKeyName() => KeyNamePrefix + Guid.NewGuid().ToString("N");
+
+    public static bool IsValidKeyName(string? keyName) => keyName is not null && KeyNameRegex().IsMatch(keyName);
+
+    public static bool IsTpmKeyPath(string path) => path.EndsWith(Extension, StringComparison.OrdinalIgnoreCase);
+
+    /// <summary>Écrit le fichier de référence et le .pub, sans jamais écraser un fichier existant.</summary>
+    /// <returns>Chemin du fichier .pub.</returns>
+    public static string Save(string path, string keyName, byte[] publicKey)
+    {
+        if (!IsValidKeyName(keyName)) throw new ArgumentException("Nom de clé TPM invalide.", nameof(keyName));
+        AdminKeys.ParsePublicKey(Convert.ToBase64String(publicKey)); // P-256 attendue
+        if (!IsTpmKeyPath(path)) throw new ArgumentException($"Le fichier de référence doit avoir l'extension {Extension}.");
+
+        var directory = Path.GetDirectoryName(Path.GetFullPath(path));
+        if (!string.IsNullOrEmpty(directory)) Directory.CreateDirectory(directory);
+
+        var json = new JsonObject
+        {
+            ["format"] = Format,
+            ["version"] = 1,
+            ["provider"] = "Microsoft Platform Crypto Provider",
+            ["keyName"] = keyName,
+            ["publicKey"] = Convert.ToBase64String(publicKey)
+        }.ToJsonString(new JsonSerializerOptions { WriteIndented = true });
+        WriteNew(path, json);
+
+        var publicPath = Path.ChangeExtension(path, AdminKeyFile.PublicKeyExtension);
+        try
+        {
+            WriteNew(publicPath, AdminKeys.ToPem(publicKey));
+        }
+        catch
+        {
+            TryDelete(path);
+            throw;
+        }
+        return publicPath;
+    }
+
+    /// <summary>Lit et contrôle un fichier de référence (<see cref="CryptographicException"/> s'il est invalide).</summary>
+    public static AdminTpmKeyReference Load(string path)
+    {
+        var info = new FileInfo(path);
+        if (!info.Exists) throw new FileNotFoundException($"Clé introuvable : {path}", path);
+        if (info.Length > MaxFileBytes) throw new CryptographicException("Fichier de clé TPM inattendu (trop volumineux).");
+
+        try
+        {
+            var root = JsonNode.Parse(File.ReadAllText(path)) as JsonObject
+                       ?? throw new CryptographicException("Fichier de clé TPM illisible.");
+            if (root["format"]?.GetValue<string>() != Format || root["version"]?.GetValue<int>() != 1)
+                throw new CryptographicException("Ce fichier n'est pas une clé TPM du launcher.");
+            var keyName = root["keyName"]?.GetValue<string>();
+            if (!IsValidKeyName(keyName)) throw new CryptographicException("Fichier de clé TPM invalide (nom de clé).");
+            var publicKey = AdminKeys.ParsePublicKey(root["publicKey"]?.GetValue<string>() ?? "");
+            return new AdminTpmKeyReference(keyName!, publicKey);
+        }
+        catch (Exception ex) when (ex is JsonException or InvalidOperationException or FormatException or ArgumentException)
+        {
+            throw new CryptographicException("Fichier de clé TPM illisible.", ex);
+        }
+    }
+
+    /// <summary>Supprime le fichier de référence et son .pub (clé refusée, création annulée, suppression demandée).</summary>
+    /// <returns>Les fichiers qui n'ont pas pu être supprimés (à supprimer à la main).</returns>
+    internal static IReadOnlyList<string> DeleteFiles(string path)
+    {
+        var left = new List<string>();
+        foreach (var file in new[] { path, Path.ChangeExtension(path, AdminKeyFile.PublicKeyExtension) })
+            if (!TryDelete(file)) left.Add(file);
+        return left;
+    }
+
+    private static void WriteNew(string path, string text)
+    {
+        using var stream = new FileStream(path, FileMode.CreateNew, FileAccess.Write, FileShare.None);
+        using var writer = new StreamWriter(stream);
+        writer.Write(text);
+    }
+
+    private static bool TryDelete(string path)
+    {
+        try
+        {
+            File.Delete(path);
+            return true;
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            return false; // laissé en place : sans danger (aucun secret dans ces fichiers)
+        }
+    }
+}

src/GameLauncher.Modules.Admin/Services/BackgroundWork.cs

@@ -0,0 +1,32 @@
+using System.Runtime.ExceptionServices;
+
+namespace GameLauncher.Modules.Admin.Services;
+
+/// <summary>
+/// Travail lent (chiffrement de clé) hors du fil de l'interface. L'erreur éventuelle est capturée
+/// DANS le travail puis relancée ici, dans la méthode asynchrone appelante : une erreur attendue
+/// (phrase de passe incorrecte…) ne traverse pas Task.Run, ce qui évite que le débogueur de Visual
+/// Studio ne s'arrête sur une « exception non gérée par l'utilisateur » alors qu'elle est bien gérée
+/// (message affiché dans le menu d'administration).
+/// </summary>
+internal static class BackgroundWork
+{
+    public static async Task<T> RunAsync<T>(Func<T> work, CancellationToken ct = default)
+    {
+        ExceptionDispatchInfo? failure = null;
+        var result = await Task.Run(() =>
+        {
+            try
+            {
+                return work();
+            }
+            catch (Exception ex)
+            {
+                failure = ExceptionDispatchInfo.Capture(ex);
+                return default;
+            }
+        }, ct).ConfigureAwait(false);
+        failure?.Throw();
+        return result!;
+    }
+}

src/GameLauncher.Modules.Admin/Services/IAdminTpm.cs

@@ -0,0 +1,83 @@
+using System.Security.Cryptography;
+using GameLauncher.ApiClient;
+
+namespace GameLauncher.Modules.Admin.Services;
+
+/// <summary>Résultat de la vérification de la puce de sécurité (TPM) de ce PC.</summary>
+/// <param name="IsAvailable">Vrai si une clé ECDSA P-256 a pu être créée, utilisée puis supprimée dans la puce.</param>
+/// <param name="Message">Explication affichée (disponible, ou raison de l'indisponibilité).</param>
+public sealed record TpmAvailability(bool IsAvailable, string Message)
+{
+    public static readonly TpmAvailability Unsupported =
+        new(false, "Puce de sécurité (TPM) non prise en charge par ce launcher sur ce système.");
+}
+
+/// <summary>
+/// Protection anti-essais de la puce (compteur COMMUN à toute la puce : codes PIN du launcher, de
+/// Windows Hello…). Au-delà de <see cref="MaxTries"/> erreurs, la puce refuse tout code ; elle
+/// « oublie » une erreur à chaque <see cref="RecoveryInterval"/> écoulé, PC allumé.
+/// </summary>
+public sealed record TpmLockoutInfo(int Failures, int MaxTries, TimeSpan RecoveryInterval, bool InLockout)
+{
+    public bool IsLockedOut => InLockout || (MaxTries > 0 && Failures >= MaxTries);
+
+    /// <summary>Codes faux encore permis avant le blocage.</summary>
+    public int RemainingTries => Math.Max(0, MaxTries - Failures);
+
+    /// <summary>Faux : la puce ne se débloque pas seule (un administrateur du PC doit la réinitialiser).</summary>
+    public bool HealsWithTime => RecoveryInterval > TimeSpan.Zero;
+
+    /// <summary>Attente MAXIMALE avant que la puce accepte de nouveau un code (estimation, PC allumé).</summary>
+    public TimeSpan MaxWait => !IsLockedOut || !HealsWithTime
+        ? TimeSpan.Zero
+        : RecoveryInterval * Math.Max(1, Failures - MaxTries + 1);
+}
+
+/// <summary>Code PIN refusé par la puce, ou puce bloquée par sa protection anti-essais.</summary>
+public sealed class TpmPinException : CryptographicException
+{
+    public TpmPinException(string message, bool isLockedOut, Exception? inner = null) : base(message, inner) =>
+        IsLockedOut = isLockedOut;
+
+    public bool IsLockedOut { get; }
+}
+
+/// <summary>Clé ouverte (dans la puce ou en mémoire) : elle signe, et se libère à la fermeture de la session.</summary>
+public interface IDisposableAdminSigner : IAdminSigner, IDisposable
+{
+}
+
+/// <summary>
+/// Clés d'administrateur conservées dans la puce de sécurité (TPM 2.0) de ce PC : la clé privée est
+/// CRÉÉE dans la puce et n'en sort jamais (non exportable) ; la puce signe elle-même. Chaque usage
+/// exige le code PIN de la clé, vérifié par la puce (blocage temporaire après plusieurs erreurs).
+/// Implémentation Windows dans le launcher (Microsoft Platform Crypto Provider) ; les méthodes sont
+/// lentes (accès à la puce) et sont appelées hors du fil de l'interface.
+/// </summary>
+public interface IAdminTpm
+{
+    /// <summary>Vérifie RÉELLEMENT la puce : création, signature et suppression d'une clé de test.</summary>
+    TpmAvailability Check();
+
+    /// <summary>Crée une clé (non exportable) protégée par <paramref name="pin"/> et l'ouvre.</summary>
+    /// <param name="keyName">Nom de la clé dans la puce (<see cref="AdminTpmKeyFile.NewKeyName"/>).</param>
+    IDisposableAdminSigner CreateKey(string keyName, string pin);
+
+    /// <summary>
+    /// Ouvre une clé existante, vérifie qu'elle a bien la clé publique attendue (AVANT tout essai du
+    /// code, qui consommerait un essai de la protection anti-essais), puis vérifie le code PIN
+    /// (signature de test). <see cref="System.Security.Cryptography.CryptographicException"/> avec un
+    /// message clair si la clé diffère, si le code est faux, si la puce est bloquée ou si la clé
+    /// n'existe pas sur ce PC.
+    /// </summary>
+    IDisposableAdminSigner OpenKey(string keyName, byte[] expectedPublicKey, string pin);
+
+    /// <summary>Supprime la clé de la puce (sans erreur si elle n'existe plus).</summary>
+    void DeleteKey(string keyName);
+
+    /// <summary>
+    /// État de la protection anti-essais (lu dans la puce sans rien modifier), ou null s'il n'est pas
+    /// lisible sur ce PC (Windows peut réserver cette lecture aux administrateurs).
+    /// </summary>
+    TpmLockoutInfo? GetLockoutInfo();
+}

src/GameLauncher.Modules.Admin/ViewModels/AdminEnvironment.cs

@@ -0,0 +1,52 @@
+using GameLauncher.ApiClient;
+using GameLauncher.Core.Models;
+using GameLauncher.Modules.Admin.Services;
+
+namespace GameLauncher.Modules.Admin.ViewModels;
+
+/// <summary>Dépendances de la fenêtre d'administration (fournies par le launcher).</summary>
+public sealed class AdminEnvironment
+{
+    /// <summary>Client de l'API (adresse intégrée à l'exe).</summary>
+    public required LauncherApiClient Client { get; init; }
+
+    public required ModuleCatalog Modules { get; init; }
+
+    /// <summary>Jeux déclarés dans launcher.json (valeurs par défaut, avant le catalogue).</summary>
+    public required IReadOnlyList<LauncherConfig> Games { get; init; }
+
+    /// <summary>Nom du launcher selon launcher.json.</summary>
+    public string LauncherName { get; init; } = "Launcher";
+
+    /// <summary>Jeu par défaut selon launcher.json.</summary>
+    public string? DefaultGameId { get; init; }
+
+    /// <summary>Thèmes intégrés au launcher (seuls choix possibles dans le catalogue).</summary>
+    public IReadOnlyList<string> Themes { get; init; } = new[] { "default" };
+
+    public required IModuleDialogs Dialogs { get; init; }
+
+    public required IUiDispatcher Ui { get; init; }
+
+    /// <summary>Fichier des préférences d'administration (%AppData%\…\GameLauncher\admin.json).</summary>
+    public required string SettingsPath { get; init; }
+
+    public required string LauncherVersion { get; init; }
+
+    public TimeProvider Time { get; init; } = TimeProvider.System;
+
+    /// <summary>Puce de sécurité (TPM) de ce PC ; null : clés TPM non proposées.</summary>
+    public IAdminTpm? Tpm { get; init; }
+
+    /// <summary>Dossier des clés proposé par défaut (%USERPROFILE%\.launcher-keys).</summary>
+    public string KeysDirectory { get; init; } = AdminKeyLocator.DefaultDirectory;
+
+    /// <summary>Verrouillage après inactivité (10 min par défaut).</summary>
+    public TimeSpan? LockAfter { get; init; }
+
+    /// <summary>Faux dans les tests : la surveillance de session est déclenchée à la main.</summary>
+    public bool StartTimers { get; init; } = true;
+
+    /// <summary>Poste, pour le journal d'audit du serveur.</summary>
+    public string ClientName => $"GameLauncher {LauncherVersion} ({System.Environment.MachineName})";
+}

src/GameLauncher.Modules.Admin/ViewModels/AdminShellViewModel.cs

@@ -0,0 +1,136 @@
+using GameLauncher.Core.Utils;
+using GameLauncher.Modules.Admin.Services;
+using GameLauncher.Mvvm;
+
+namespace GameLauncher.Modules.Admin.ViewModels;
+
+/// <summary>
+/// Fenêtre d'administration : un seul écran à la fois — connexion (<see cref="LoginViewModel"/>),
+/// création de clé / invitation (<see cref="EnrollViewModel"/>) ou espace d'administration
+/// (<see cref="AdminWorkspaceViewModel"/>). Verrouiller ferme la session et libère la clé.
+/// </summary>
+public sealed class AdminShellViewModel : ObservableObject, IAsyncDisposable
+{
+    private object _screen;
+    private AdminWorkspaceViewModel? _workspace;
+    private bool _disposed;
+    private Task<TpmAvailability>? _tpmCheck;
+
+    public AdminShellViewModel(AdminEnvironment environment)
+    {
+        Environment = environment;
+        Settings = AdminSettings.Load(environment.SettingsPath);
+        _screen = new LoginViewModel(this, null, null);
+    }
+
+    public AdminEnvironment Environment { get; }
+
+    internal AdminSettings Settings { get; }
+
+    /// <summary>Écran affiché (le launcher choisit la vue selon son type).</summary>
+    public object Screen
+    {
+        get => _screen;
+        private set
+        {
+            var previous = _screen;
+            if (!SetProperty(ref _screen, value)) return;
+            OnPropertyChanged(nameof(IsLoggedIn));
+            if (previous is LoginViewModel login) login.Dispose(); // arrêt de ses minuteries (décompte de la puce)
+        }
+    }
+
+    public bool IsLoggedIn => Screen is AdminWorkspaceViewModel;
+
+    public string ServerHost => Environment.Client.BaseUrl.Host;
+
+    public string WindowTitle => $"Administration — {ServerHost}";
+
+    /// <summary>Souris ou clavier dans la fenêtre : repousse le verrouillage automatique.</summary>
+    public void NotifyActivity() => _workspace?.Guard.NotifyActivity();
+
+    public void ShowLogin(string? status = null, string? selectKeyPath = null)
+    {
+        if (_disposed) return;
+        Screen = new LoginViewModel(this, status, selectKeyPath);
+    }
+
+    /// <summary>Vérification de la puce TPM (une fois par ouverture de la fenêtre, hors du fil de l'interface).</summary>
+    internal Task<TpmAvailability> CheckTpmAsync() => _tpmCheck ??= RunTpmCheckAsync();
+
+    private async Task<TpmAvailability> RunTpmCheckAsync()
+    {
+        if (Environment.Tpm is not { } tpm) return TpmAvailability.Unsupported;
+        try
+        {
+            var availability = await BackgroundWork.RunAsync(tpm.Check);
+            Log.Info($"Administration : puce TPM {(availability.IsAvailable ? "disponible" : "indisponible")} ({availability.Message})");
+            return availability;
+        }
+        catch (Exception ex)
+        {
+            Log.Warn($"Administration : vérification de la puce TPM impossible ({ex.Message}).");
+            return new TpmAvailability(false, $"Puce de sécurité (TPM) inutilisable : {ex.Message}");
+        }
+    }
+
+    public void ShowEnroll()
+    {
+        if (_disposed) return;
+        Screen = new EnrollViewModel(this);
+    }
+
+    internal async Task OpenWorkspaceAsync(AdminConnection connection)
+    {
+        if (_disposed)
+        {
+            await connection.DisposeAsync();
+            return;
+        }
+        AdminWorkspaceViewModel workspace;
+        try
+        {
+            workspace = new AdminWorkspaceViewModel(this, connection);
+        }
+        catch
+        {
+            await connection.DisposeAsync(); // clé effacée, session fermée
+            throw;
+        }
+        _workspace = workspace;
+        Screen = workspace;
+        await workspace.StartAsync();
+    }
+
+    /// <summary>Ferme la session (serveur + clé en mémoire) et revient à l'écran de connexion.</summary>
+    public Task LockAsync(string? reason) => _workspace is { } workspace ? LockAsync(workspace, reason) : Task.CompletedTask;
+
+    /// <summary>
+    /// Verrouillage demandé par un espace donné (minuterie, session perdue) : sans effet s'il n'est plus
+    /// l'espace courant — une requête tardive d'une session fermée ne doit pas verrouiller la suivante.
+    /// </summary>
+    internal async Task LockAsync(AdminWorkspaceViewModel source, string? reason)
+    {
+        if (!ReferenceEquals(_workspace, source)) return;
+        _workspace = null;
+        try
+        {
+            if (!_disposed) ShowLogin(reason, source.KeyPath);
+        }
+        finally
+        {
+            await source.DisposeAsync(); // dans tous les cas : clé effacée, session fermée
+        }
+    }
+
+    /// <summary>Fermeture de la fenêtre : déconnexion.</summary>
+    public async ValueTask DisposeAsync()
+    {
+        if (_disposed) return;
+        _disposed = true;
+        (_screen as LoginViewModel)?.Dispose();
+        var workspace = _workspace;
+        _workspace = null;
+        if (workspace is not null) await workspace.DisposeAsync();
+    }
+}

src/GameLauncher.Modules.Admin/ViewModels/AdminWorkspaceViewModel.cs

@@ -0,0 +1,149 @@
+using System.Collections.ObjectModel;
+using GameLauncher.ApiClient;
+using GameLauncher.Core.Models;
+using GameLauncher.Core.Utils;
+using GameLauncher.Modules.Admin.Services;
+using GameLauncher.Mvvm;
+
+namespace GameLauncher.Modules.Admin.ViewModels;
+
+/// <summary>Page du menu d'administration dans la navigation (ViewModel créé à la première ouverture).</summary>
+public sealed class AdminPanelItem : ObservableObject
+{
+    private AdminPanelViewModel? _viewModel;
+
+    public AdminPanelItem(AdminPanelDescriptor descriptor) => Descriptor = descriptor;
+
+    public AdminPanelDescriptor Descriptor { get; }
+    public string Title => Descriptor.Title;
+    public string Description => Descriptor.Description;
+    public string IconKey => Descriptor.IconKey;
+
+    public AdminPanelViewModel? ViewModel
+    {
+        get => _viewModel;
+        internal set => SetProperty(ref _viewModel, value);
+    }
+}
+
+/// <summary>
+/// Espace d'administration (connecté) : navigation entre les pages des modules autorisées par les
+/// permissions, identité, temps restant avant verrouillage, bouton « Verrouiller ».
+/// </summary>
+public sealed class AdminWorkspaceViewModel : ObservableObject, IAdminContext, IAsyncDisposable
+{
+    private readonly AdminShellViewModel _shell;
+    private readonly AdminConnection _connection;
+    private AdminPanelItem? _selectedPanel;
+    private Task _activation = Task.CompletedTask;
+    private bool _disposed;
+
+    internal AdminWorkspaceViewModel(AdminShellViewModel shell, AdminConnection connection)
+    {
+        _shell = shell;
+        _connection = connection;
+        var environment = shell.Environment;
+
+        Guard = new AdminSessionGuard(connection, environment.Time, environment.Ui, environment.LockAfter, environment.StartTimers);
+        Guard.LockRequested = reason => shell.LockAsync(this, reason);
+        Guard.Changed += () => OnPropertyChanged(nameof(SessionText));
+
+        Panels = environment.Modules.AdminPanelsFor(Session.Profile.Permissions);
+        PanelItems = new ObservableCollection<AdminPanelItem>(Panels.Select(p => new AdminPanelItem(p)));
+        LockCommand = new AsyncRelayCommand(() => shell.LockAsync(this, "Session verrouillée."));
+    }
+
+    internal AdminSessionGuard Guard { get; }
+
+    internal string KeyPath => _connection.KeyPath;
+
+    // ------------------------------------------------------------------ Affichage
+
+    public ObservableCollection<AdminPanelItem> PanelItems { get; }
+
+    public AdminPanelItem? SelectedPanel
+    {
+        get => _selectedPanel;
+        set
+        {
+            if (value is null || ReferenceEquals(value, _selectedPanel)) return;
+            _selectedPanel = value;
+            OnPropertyChanged();
+            OnPropertyChanged(nameof(PanelTitle));
+            OnPropertyChanged(nameof(PanelDescription));
+            _activation = ActivateAsync(value);
+        }
+    }
+
+    public string PanelTitle => SelectedPanel?.Title ?? "";
+    public string PanelDescription => SelectedPanel?.Description ?? "";
+
+    public string DisplayName => Session.Profile.DisplayName;
+    public string Initials => AdminTexts.Initials(Session.Profile.DisplayName);
+    public string RoleText => AdminTexts.Role(Session.Profile.Role);
+    public string KeyLabel => (Session.Profile.KeyLabel ?? Path.GetFileNameWithoutExtension(_connection.KeyPath)) +
+                              (_connection.IsTpm ? " · puce TPM" : "");
+    public string ServerHost => _shell.ServerHost;
+
+    /// <summary>« Verrouillage dans 9 min ».</summary>
+    public string SessionText => $"Verrouillage dans {AdminTexts.Duration(Guard.Remaining)}";
+
+    public AsyncRelayCommand LockCommand { get; }
+
+    /// <summary>Ouvre la première page et attend son chargement initial.</summary>
+    internal Task StartAsync()
+    {
+        SelectedPanel = PanelItems.FirstOrDefault();
+        return _activation;
+    }
+
+    /// <summary>Chargement de la page affichée (tests).</summary>
+    internal Task Activation => _activation;
+
+    private async Task ActivateAsync(AdminPanelItem item)
+    {
+        if (_disposed) return;
+        try
+        {
+            item.ViewModel ??= item.Descriptor.CreateViewModel(this);
+            await item.ViewModel.ActivateAsync();
+        }
+        catch (Exception ex)
+        {
+            Log.Error($"Administration : ouverture de la page {item.Descriptor.Id}", ex);
+            Dialogs.ShowMessage("Page indisponible", ApiErrorText.Describe(ex), ModuleMessageKind.Error);
+        }
+    }
+
+    // ------------------------------------------------------------------ IAdminContext
+
+    public AdminSession Session => _connection.Session;
+    public LauncherApiClient Client => _connection.Client;
+    public IReadOnlyList<LauncherConfig> Games => _shell.Environment.Games;
+    public string LauncherName => _shell.Environment.LauncherName;
+    public string? DefaultGameId => _shell.Environment.DefaultGameId;
+    public IReadOnlyList<string> Themes => _shell.Environment.Themes;
+    public IModuleDialogs Dialogs => _shell.Environment.Dialogs;
+    public string LauncherVersion => _shell.Environment.LauncherVersion;
+    public IReadOnlyList<AdminPanelDescriptor> Panels { get; }
+
+    public IDisposable BeginLongOperation() => Guard.BeginLongOperation();
+
+    public void Navigate(string panelId)
+    {
+        if (PanelItems.FirstOrDefault(p => string.Equals(p.Descriptor.Id, panelId, StringComparison.OrdinalIgnoreCase)) is { } item)
+            SelectedPanel = item;
+    }
+
+    public void ReportSessionLost(string reason) => _ = _shell.LockAsync(this, reason);
+
+    // ------------------------------------------------------------------ Fermeture
+
+    public async ValueTask DisposeAsync()
+    {
+        if (_disposed) return;
+        _disposed = true;
+        Guard.Dispose();
+        await _connection.DisposeAsync();
+    }
+}

src/GameLauncher.Modules.Admin/ViewModels/DashboardPanelViewModel.cs

@@ -0,0 +1,124 @@
+using GameLauncher.Contracts.Security;
+using GameLauncher.Modules.Admin.Services;
+using GameLauncher.Mvvm;
+
+namespace GameLauncher.Modules.Admin.ViewModels;
+
+/// <summary>Jeu déclaré dans launcher.json, tel qu'affiché au tableau de bord.</summary>
+public sealed record DashboardGame(string Name, string GameId, string ManifestHost);
+
+/// <summary>
+/// Page d'accueil : compte connecté et permissions, session, serveur, jeux déclarés et, pour les
+/// propriétaires, les clés en attente d'approbation.
+/// </summary>
+public sealed class DashboardPanelViewModel : AdminPanelViewModel
+{
+    public const string PanelId = "admin.dashboard";
+
+    private string _serverVersion = "…";
+    private string _serverId = "…";
+    private int _pendingApprovals;
+    private int _activeInvitations;
+    private string? _lastRefresh;
+
+    public DashboardPanelViewModel(IAdminContext context) : base(context)
+    {
+        var profile = context.Session.Profile;
+        Permissions = profile.Permissions.Select(AdminTexts.Permission).ToList();
+        Games = context.Games.Select(g => new DashboardGame(g.GameName, g.GameId,
+            Uri.TryCreate(g.ManifestUrl, UriKind.Absolute, out var uri) ? uri.Host : g.ManifestUrl)).ToList();
+        RefreshCommand = new AsyncRelayCommand(RefreshAsync, () => !IsBusy);
+    }
+
+    public string DisplayName => Context.Session.Profile.DisplayName;
+    public string Initials => AdminTexts.Initials(DisplayName);
+    public string RoleText => AdminTexts.Role(Context.Session.Profile.Role);
+    public IReadOnlyList<string> Permissions { get; }
+
+    public string KeyText => $"{Context.Session.Profile.KeyLabel ?? "Clé"} · {Context.Session.Profile.KeyId}";
+
+    /// <summary>« Session ouverte jusqu'à 23:14 au plus tard » (heure du PC).</summary>
+    public string SessionText =>
+        $"Ouverte au plus tard jusqu'à {(Context.Session.ExpiresAt - Context.Session.ClockOffset).ToLocalTime():HH:mm}";
+
+    public string ServerOrigin => Context.Client.Origin;
+
+    public string ServerVersion
+    {
+        get => _serverVersion;
+        private set => SetProperty(ref _serverVersion, value);
+    }
+
+    /// <summary>Identifiant du serveur (début), pour le support.</summary>
+    public string ServerId
+    {
+        get => _serverId;
+        private set => SetProperty(ref _serverId, value);
+    }
+
+    public string LauncherVersion => Context.LauncherVersion;
+
+    public IReadOnlyList<DashboardGame> Games { get; }
+
+    public bool CanManageAdmins => Context.Session.Has(AdminPermissions.AdminsManage);
+
+    public int PendingApprovals
+    {
+        get => _pendingApprovals;
+        private set
+        {
+            if (SetProperty(ref _pendingApprovals, value))
+            {
+                OnPropertyChanged(nameof(HasPendingApprovals));
+                OnPropertyChanged(nameof(PendingText));
+            }
+        }
+    }
+
+    public int ActiveInvitations
+    {
+        get => _activeInvitations;
+        private set
+        {
+            if (SetProperty(ref _activeInvitations, value)) OnPropertyChanged(nameof(PendingText));
+        }
+    }
+
+    public bool HasPendingApprovals => PendingApprovals > 0;
+
+    public string PendingText => PendingApprovals switch
+    {
+        0 => ActiveInvitations == 0 ? "Aucune clé en attente, aucune invitation en cours." : $"Aucune clé en attente · {ActiveInvitations} invitation(s) en cours.",
+        1 => $"1 clé attend votre approbation · {ActiveInvitations} invitation(s) en cours.",
+        var n => $"{n} clés attendent votre approbation · {ActiveInvitations} invitation(s) en cours."
+    };
+
+    public string? LastRefresh
+    {
+        get => _lastRefresh;
+        private set => SetProperty(ref _lastRefresh, value);
+    }
+
+    public AsyncRelayCommand RefreshCommand { get; }
+
+    protected override void OnBusyChanged() => RefreshCommand.RaiseCanExecuteChanged();
+
+    protected override Task OnActivatedAsync(bool firstTime) => firstTime ? RefreshAsync() : Task.CompletedTask;
+
+    public Task RefreshAsync() => RunAsync(async () =>
+    {
+        var info = await Context.Client.GetInfoAsync();
+        ServerVersion = info.ServerVersion;
+        ServerId = info.ServerId.Length > 8 ? info.ServerId[..8] : info.ServerId;
+
+        if (CanManageAdmins)
+        {
+            var admins = await Context.Session.ListAdminsAsync();
+            var invitations = await Context.Session.ListInvitationsAsync();
+            PendingApprovals = admins.Where(a => a.Status != AdminStatus.Revoked)
+                                     .SelectMany(a => a.Keys).Count(k => k.Status == AdminStatus.Pending);
+            ActiveInvitations = invitations.Count;
+        }
+        LastRefresh = $"Actualisé à {DateTime.Now:HH:mm}";
+    });
+}

src/GameLauncher.Modules.Admin/ViewModels/EnrollViewModel.cs

@@ -0,0 +1,266 @@
+using GameLauncher.ApiClient;
+using GameLauncher.Core.Utils;
+using GameLauncher.Modules.Admin.Services;
+using GameLauncher.Mvvm;
+
+namespace GameLauncher.Modules.Admin.ViewModels;
+
+/// <summary>
+/// « J'ai une invitation » : création d'une clé sur ce PC et, avec un code d'invitation,
+/// enregistrement auprès du serveur. Deux rangements au choix :
+///  • fichier chiffré par une phrase de passe (copiable, sauvegardable) — par défaut ;
+///  • puce de sécurité (TPM) de ce PC, protégée par un code PIN (non copiable) — proposé seulement
+///    une fois la puce RÉELLEMENT vérifiée (création, signature et suppression d'une clé de test).
+/// Affiche ensuite l'EMPREINTE à communiquer à la personne qui approuve. Sans code : clé seule
+/// (premier propriétaire, à déclarer sur le VPS).
+/// </summary>
+public sealed class EnrollViewModel : ObservableObject
+{
+    private readonly AdminShellViewModel _shell;
+    private string _invitationCode = "";
+    private string _keyLabel;
+    private string _keyPath;
+    private bool _useTpm;
+    private bool _isBusy;
+    private string? _errorMessage;
+    private AdminKeyCreation? _result;
+    private TpmAvailability? _tpm;
+
+    public EnrollViewModel(AdminShellViewModel shell)
+    {
+        _shell = shell;
+        _keyLabel = System.Environment.MachineName;
+        _keyPath = AdminKeyLocator.SuggestNewKeyPath(shell.Environment.KeysDirectory);
+        BackCommand = new RelayCommand(() => shell.ShowLogin(), () => !IsBusy);
+        ChangePathCommand = new RelayCommand(ChangePath, () => !IsBusy && !IsDone);
+        CopyFingerprintCommand = new RelayCommand(() =>
+        {
+            if (_result is not null) shell.Environment.Dialogs.CopyToClipboard(_result.Fingerprint);
+        });
+        OpenKeyFolderCommand = new RelayCommand(() =>
+        {
+            if (Path.GetDirectoryName(_result?.KeyPath ?? KeyPath) is { } folder && Directory.Exists(folder))
+                shell.Environment.Dialogs.OpenFolder(folder);
+        });
+        ContinueCommand = new RelayCommand(() => shell.ShowLogin(
+            _result is null or { Enrollment: null, EnrollmentUnconfirmed: null } ? null : "Connectez-vous dès que votre clé a été approuvée.",
+            _result?.KeyPath));
+        TpmCheck = CheckTpmAsync();
+    }
+
+    public string InvitationCode
+    {
+        get => _invitationCode;
+        set => SetProperty(ref _invitationCode, value ?? "");
+    }
+
+    /// <summary>Nom de ce PC, visible par les propriétaires (ex. « PC bureau »).</summary>
+    public string KeyLabel
+    {
+        get => _keyLabel;
+        set => SetProperty(ref _keyLabel, value ?? "");
+    }
+
+    public string KeyPath
+    {
+        get => _keyPath;
+        private set => SetProperty(ref _keyPath, value);
+    }
+
+    // ------------------------------------------------------------------ Rangement de la clé
+
+    /// <summary>Vérification de la puce en cours (le choix « puce » reste grisé).</summary>
+    public bool IsCheckingTpm => _tpm is null;
+
+    /// <summary>Puce vérifiée et utilisable.</summary>
+    public bool IsTpmAvailable => _tpm?.IsAvailable == true;
+
+    /// <summary>« Vérification de la puce de sécurité… », « Puce TPM 2.0 disponible… » ou la raison de l'indisponibilité.</summary>
+    public string TpmStatus => _tpm?.Message ?? "Vérification de la puce de sécurité (TPM) de ce PC…";
+
+    /// <summary>Le choix « puce de sécurité » n'est dégrisé qu'après une vérification réussie.</summary>
+    public bool CanChooseTpm => IsTpmAvailable && !IsBusy && !IsDone;
+
+    public bool CanChooseFile => !IsBusy && !IsDone;
+
+    /// <summary>Faux : fichier chiffré (par défaut). Vrai : puce de sécurité (TPM) de ce PC.</summary>
+    public bool UseTpm
+    {
+        get => _useTpm;
+        set
+        {
+            if ((value && !IsTpmAvailable) || IsBusy || IsDone || value == _useTpm)
+            {
+                // Refusé (jamais la puce sans vérification réussie) : l'affichage revient à l'état réel.
+                OnPropertyChanged(nameof(UseTpm));
+                OnPropertyChanged(nameof(UseFile));
+                return;
+            }
+            _useTpm = value;
+            ErrorMessage = null;
+            KeyPath = AdminKeyLocator.SuggestNewKeyPath(Path.GetDirectoryName(KeyPath) ?? _shell.Environment.KeysDirectory, value);
+            foreach (var name in new[] { nameof(UseTpm), nameof(UseFile), nameof(MinSecretLength), nameof(SecretLabel),
+                                         nameof(ConfirmationLabel), nameof(SecretHint), nameof(KeyFileLabel) })
+                OnPropertyChanged(name);
+        }
+    }
+
+    public bool UseFile
+    {
+        get => !_useTpm;
+        set
+        {
+            if (value) UseTpm = false;
+        }
+    }
+
+    public int MinSecretLength => UseTpm ? AdminTpmKeyFile.MinPinLength : AdminKeyFile.MinPassphraseLength;
+
+    public string SecretLabel => UseTpm
+        ? $"Code PIN de la clé (au moins {AdminTpmKeyFile.MinPinLength} caractères)"
+        : $"Phrase de passe (au moins {AdminKeyFile.MinPassphraseLength} caractères)";
+
+    public string ConfirmationLabel => UseTpm ? "Confirmation du code PIN" : "Confirmation";
+
+    public string SecretHint => UseTpm
+        ? "Le code PIN est vérifié par la puce elle-même, qui se bloque temporairement après plusieurs erreurs " +
+          "(ces erreurs comptent aussi pour les autres usages de la puce, comme le code PIN Windows Hello). " +
+          "Cette clé ne peut être ni copiée ni sauvegardée : gardez aussi une clé « fichier » de secours."
+        : "Une phrase de plusieurs mots est plus sûre et plus facile à retenir. Elle ne peut pas être récupérée : " +
+          "en cas d'oubli, il faudra une nouvelle invitation.";
+
+    public string KeyFileLabel => UseTpm
+        ? "Fichier de référence (aucun secret : la clé reste dans la puce)"
+        : "Fichier de la clé";
+
+    // ------------------------------------------------------------------ État
+
+    public bool IsBusy
+    {
+        get => _isBusy;
+        private set
+        {
+            if (!SetProperty(ref _isBusy, value)) return;
+            BackCommand.RaiseCanExecuteChanged();
+            ChangePathCommand.RaiseCanExecuteChanged();
+            OnPropertyChanged(nameof(CanChooseTpm));
+            OnPropertyChanged(nameof(CanChooseFile));
+        }
+    }
+
+    public string? ErrorMessage
+    {
+        get => _errorMessage;
+        private set
+        {
+            if (SetProperty(ref _errorMessage, value)) OnPropertyChanged(nameof(HasError));
+        }
+    }
+
+    public bool HasError => !string.IsNullOrEmpty(ErrorMessage);
+
+    public bool IsDone => _result is not null;
+    public bool IsForm => _result is null;
+
+    /// <summary>Clé enregistrée auprès du serveur (sinon : clé seule).</summary>
+    public bool IsEnrolled => _result?.Enrollment is not null;
+    public bool IsKeyOnly => _result is { Enrollment: null, EnrollmentUnconfirmed: null };
+
+    /// <summary>Invitation envoyée sans réponse sûre du serveur : clé conservée, marche à suivre affichée.</summary>
+    public bool IsUnconfirmed => _result?.EnrollmentUnconfirmed is not null;
+    public string UnconfirmedText => _result?.EnrollmentUnconfirmed ?? "";
+
+    /// <summary>Clé créée dans la puce de sécurité (TPM).</summary>
+    public bool IsTpmKey => _result?.IsTpm == true;
+
+    public string Fingerprint => _result?.Fingerprint ?? "";
+    public string CreatedKeyPath => _result?.KeyPath ?? "";
+    public string PublicKeyPath => _result?.PublicKeyPath ?? "";
+    public string AccountName => _result?.Enrollment?.DisplayName ?? "";
+
+    public RelayCommand BackCommand { get; }
+    public RelayCommand ChangePathCommand { get; }
+    public RelayCommand CopyFingerprintCommand { get; }
+    public RelayCommand OpenKeyFolderCommand { get; }
+    public RelayCommand ContinueCommand { get; }
+
+    /// <summary>Vérification de la puce lancée à l'ouverture de l'écran (tests).</summary>
+    internal Task TpmCheck { get; }
+
+    /// <summary>Crée la clé (et l'enregistre si un code est saisi). La vue efface les secrets après l'appel.</summary>
+    public async Task SubmitAsync(string secret, string confirmation)
+    {
+        if (IsBusy || IsDone) return;
+        if (UseTpm && !IsTpmAvailable)
+        {
+            ErrorMessage = "La puce de sécurité (TPM) n'est pas utilisable sur ce PC : choisissez « Fichier chiffré ».";
+            return;
+        }
+        if (secret.Length < MinSecretLength)
+        {
+            ErrorMessage = UseTpm
+                ? $"Le code PIN doit contenir au moins {MinSecretLength} caractères."
+                : $"La phrase de passe doit contenir au moins {MinSecretLength} caractères.";
+            return;
+        }
+        if (!string.Equals(secret, confirmation, StringComparison.Ordinal))
+        {
+            ErrorMessage = UseTpm ? "Les deux codes PIN sont différents." : "Les deux phrases de passe sont différentes.";
+            return;
+        }
+
+        IsBusy = true;
+        ErrorMessage = null;
+        try
+        {
+            var result = await new AdminEnrollmentService(_shell.Environment.Client, _shell.Environment.Tpm)
+                .CreateKeyAsync(KeyPath, secret, InvitationCode, KeyLabel, useTpm: UseTpm);
+            _shell.Settings.Remember(result.KeyPath);
+            _shell.Settings.Save(_shell.Environment.SettingsPath);
+            var storage = result.IsTpm ? "puce TPM" : "fichier";
+            Log.Info(result switch
+            {
+                { Enrollment: { } enrollment } =>
+                    $"Administration : clé {result.KeyId} ({storage}) enregistrée pour {enrollment.DisplayName}, en attente d'approbation.",
+                { EnrollmentUnconfirmed: not null } => $"Administration : clé {result.KeyId} ({storage}) créée, enregistrement non confirmé par le serveur.",
+                _ => $"Administration : clé créée ({result.KeyId}, {storage})."
+            });
+            _result = result;
+            foreach (var name in new[] { nameof(IsDone), nameof(IsForm), nameof(IsEnrolled), nameof(IsKeyOnly), nameof(IsUnconfirmed),
+                                         nameof(UnconfirmedText), nameof(IsTpmKey), nameof(Fingerprint), nameof(CreatedKeyPath),
+                                         nameof(PublicKeyPath), nameof(AccountName), nameof(CanChooseTpm), nameof(CanChooseFile) })
+                OnPropertyChanged(name);
+            ChangePathCommand.RaiseCanExecuteChanged();
+        }
+        catch (Exception ex)
+        {
+            ErrorMessage = ApiErrorText.Describe(ex);
+            if (ex is ApiException api) Log.Warn($"Administration : enregistrement refusé ({api.Status} {api.Code}).");
+            else if (UseTpm) Log.Warn($"Administration : création de la clé TPM impossible ({ex.Message}).");
+        }
+        finally
+        {
+            IsBusy = false;
+        }
+    }
+
+    private async Task CheckTpmAsync()
+    {
+        var availability = await _shell.CheckTpmAsync();
+        _tpm = availability;
+        foreach (var name in new[] { nameof(IsCheckingTpm), nameof(IsTpmAvailable), nameof(TpmStatus), nameof(CanChooseTpm) })
+            OnPropertyChanged(name);
+    }
+
+    private void ChangePath()
+    {
+        var directory = Path.GetDirectoryName(KeyPath);
+        var extension = UseTpm ? AdminTpmKeyFile.Extension : AdminKeyFile.PrivateKeyExtension;
+        var filter = UseTpm ? "Référence de clé TPM (*.tpmkey)|*.tpmkey" : "Clé d'administrateur (*.key)|*.key";
+        var path = _shell.Environment.Dialogs.PickSaveFile("Emplacement de la nouvelle clé", filter,
+            Path.GetFileName(KeyPath), directory is not null && Directory.Exists(directory) ? directory : null);
+        if (path is null) return;
+        if (!path.EndsWith(extension, StringComparison.OrdinalIgnoreCase)) path += extension;
+        KeyPath = path;
+    }
+}

src/GameLauncher.Modules.Admin/ViewModels/LoginViewModel.cs

@@ -0,0 +1,442 @@
+using System.Collections.ObjectModel;
+using GameLauncher.ApiClient;
+using GameLauncher.Core.Utils;
+using GameLauncher.Modules.Admin.Services;
+using GameLauncher.Mvvm;
+
+namespace GameLauncher.Modules.Admin.ViewModels;
+
+/// <summary>
+/// Écran de connexion : choix de la clé, phrase de passe ou code PIN (transmis par la vue, jamais
+/// stocké dans le ViewModel), connexion par défi signé. Pour les clés de la puce TPM : suppression
+/// de la clé, et aide quand la puce est bloquée par sa protection anti-essais (temps d'attente).
+/// </summary>
+public sealed class LoginViewModel : ObservableObject, IDisposable
+{
+    private static readonly TimeSpan LockoutTick = TimeSpan.FromSeconds(1);
+
+    private readonly AdminShellViewModel _shell;
+    private AdminKeyEntry? _selectedKey;
+    private bool _isBusy;
+    private string? _errorMessage;
+    private string? _statusMessage;
+
+    // Protection anti-essais de la puce (commune à toutes les clés TPM de ce PC).
+    private bool _isTpmLocked;
+    private DateTimeOffset? _lockoutUntil;
+    private TimeSpan _lockoutInterval;
+    private bool _lockoutHeals = true;
+    private string? _lockoutText;
+    private ITimer? _lockoutTimer;
+    private bool _disposed;
+
+    public LoginViewModel(AdminShellViewModel shell, string? statusMessage, string? selectKeyPath)
+    {
+        _shell = shell;
+        _statusMessage = statusMessage;
+        BrowseKeyCommand = new RelayCommand(BrowseKey, () => !IsBusy);
+        ShowEnrollCommand = new RelayCommand(shell.ShowEnroll, () => !IsBusy);
+        RefreshCommand = new RelayCommand(() => LoadKeys(SelectedKey?.Path), () => !IsBusy);
+        OpenKeysFolderCommand = new RelayCommand(OpenKeysFolder);
+        DeleteTpmKeyCommand = new AsyncRelayCommand(DeleteTpmKeyAsync, () => IsTpmKey && !IsBusy);
+        RecheckLockoutCommand = new AsyncRelayCommand(() => CheckLockoutAsync(knownLocked: false), () => !IsBusy);
+        LoadKeys(selectKeyPath ?? shell.Settings.LastKeyPath);
+    }
+
+    public ObservableCollection<AdminKeyEntry> Keys { get; } = new();
+
+    public AdminKeyEntry? SelectedKey
+    {
+        get => _selectedKey;
+        set
+        {
+            if (!SetProperty(ref _selectedKey, value)) return;
+            OnPropertyChanged(nameof(CanLogin));
+            OnPropertyChanged(nameof(SecretLabel));
+            OnPropertyChanged(nameof(IsTpmKey));
+            OnPropertyChanged(nameof(ShowTpmLockout));
+            DeleteTpmKeyCommand.RaiseCanExecuteChanged();
+            // Clé de la puce : la puce est-elle bloquée ? (affiché avant même de saisir le code)
+            if (value?.IsTpm == true && !_isTpmLocked) _ = CheckLockoutAsync(knownLocked: false, quiet: true);
+        }
+    }
+
+    public bool HasKeys => Keys.Count > 0;
+
+    /// <summary>« Phrase de passe de la clé » ou « Code PIN de la clé (puce TPM) », selon la clé choisie.</summary>
+    public string SecretLabel => SelectedKey?.SecretLabel ?? "Phrase de passe de la clé";
+
+    public bool IsTpmKey => SelectedKey?.IsTpm == true;
+
+    public bool IsBusy
+    {
+        get => _isBusy;
+        private set
+        {
+            if (!SetProperty(ref _isBusy, value)) return;
+            OnPropertyChanged(nameof(CanLogin));
+            BrowseKeyCommand.RaiseCanExecuteChanged();
+            ShowEnrollCommand.RaiseCanExecuteChanged();
+            RefreshCommand.RaiseCanExecuteChanged();
+            DeleteTpmKeyCommand.RaiseCanExecuteChanged();
+            RecheckLockoutCommand.RaiseCanExecuteChanged();
+        }
+    }
+
+    /// <summary>
+    /// Connexion possible. Avec une clé de la puce pendant un blocage dont la fin est connue : non,
+    /// jusqu'à la fin du décompte (un essai serait refusé de toute façon).
+    /// </summary>
+    public bool CanLogin => SelectedKey is not null && !IsBusy && !(IsTpmKey && LockoutBlocksLogin);
+
+    public string? ErrorMessage
+    {
+        get => _errorMessage;
+        private set
+        {
+            if (SetProperty(ref _errorMessage, value)) OnPropertyChanged(nameof(HasError));
+        }
+    }
+
+    public bool HasError => !string.IsNullOrEmpty(ErrorMessage);
+
+    /// <summary>Information (ex. « Verrouillé après 10 minutes d'inactivité », clé supprimée…).</summary>
+    public string? StatusMessage
+    {
+        get => _statusMessage;
+        private set
+        {
+            if (SetProperty(ref _statusMessage, value)) OnPropertyChanged(nameof(HasStatus));
+        }
+    }
+
+    public bool HasStatus => !string.IsNullOrEmpty(StatusMessage);
+
+    public string ServerHost => _shell.ServerHost;
+
+    public string KeysDirectory => _shell.Environment.KeysDirectory;
+
+    // ------------------------------------------------------------------ Blocage de la puce
+
+    /// <summary>La puce refuse les codes PIN (trop d'erreurs) : bandeau d'aide affiché pour les clés TPM.</summary>
+    public bool IsTpmLocked
+    {
+        get => _isTpmLocked;
+        private set
+        {
+            if (!SetProperty(ref _isTpmLocked, value)) return;
+            OnPropertyChanged(nameof(ShowTpmLockout));
+            OnPropertyChanged(nameof(CanLogin));
+        }
+    }
+
+    public bool ShowTpmLockout => IsTpmLocked && IsTpmKey;
+
+    /// <summary>« De nouveau utilisable dans 9 min 30 s au plus… », ou l'explication si la durée est inconnue.</summary>
+    public string? LockoutText
+    {
+        get => _lockoutText;
+        private set => SetProperty(ref _lockoutText, value);
+    }
+
+    private bool LockoutBlocksLogin => _isTpmLocked && _lockoutUntil is { } until && until > _shell.Environment.Time.GetUtcNow();
+
+    public RelayCommand BrowseKeyCommand { get; }
+    public RelayCommand ShowEnrollCommand { get; }
+    public RelayCommand RefreshCommand { get; }
+    public RelayCommand OpenKeysFolderCommand { get; }
+
+    /// <summary>Supprime définitivement la clé de la puce sélectionnée (clés TPM uniquement).</summary>
+    public AsyncRelayCommand DeleteTpmKeyCommand { get; }
+
+    /// <summary>Relit l'état de la protection anti-essais de la puce.</summary>
+    public AsyncRelayCommand RecheckLockoutCommand { get; }
+
+    /// <summary>Dernière lecture de l'état de la puce (tests).</summary>
+    internal Task LockoutCheck { get; private set; } = Task.CompletedTask;
+
+    // ------------------------------------------------------------------ Connexion
+
+    /// <summary>Connexion avec la clé choisie. La vue efface la phrase de passe (ou le code) juste après l'appel.</summary>
+    public async Task LoginAsync(string passphrase)
+    {
+        if (SelectedKey is not { } key || IsBusy) return;
+        if (string.IsNullOrEmpty(passphrase))
+        {
+            ErrorMessage = key.IsTpm ? "Saisissez le code PIN de la clé." : "Saisissez la phrase de passe de la clé.";
+            return;
+        }
+        if (!CanLogin) return;
+
+        IsBusy = true;
+        ErrorMessage = null;
+        AdminConnection? connection = null;
+        TpmPinException? pinError = null;
+        try
+        {
+            var environment = _shell.Environment;
+            connection = await new AdminLoginService(environment.Client, environment.ClientName, environment.Tpm).LoginAsync(key.Path, passphrase);
+        }
+        catch (Exception ex)
+        {
+            ErrorMessage = ApiErrorText.Describe(ex, duringLogin: true);
+            if (ex is ApiException api) Log.Warn($"Administration : connexion refusée ({api.Status} {api.Code}).");
+            pinError = ex as TpmPinException;
+        }
+        finally
+        {
+            IsBusy = false;
+        }
+
+        if (connection is null)
+        {
+            if (pinError is not null) await OnTpmPinRefusedAsync(pinError);
+            return;
+        }
+
+        Log.Info($"Administration : connexion de {connection.Session.Profile.DisplayName} ({connection.Session.Profile.Role}).");
+        _shell.Settings.Remember(key.Path); // chemin déjà normalisé (AdminKeyLocator)
+        _shell.Settings.Save(_shell.Environment.SettingsPath); // erreurs d'écriture journalisées, sans effet
+        try
+        {
+            await _shell.OpenWorkspaceAsync(connection);
+        }
+        catch (Exception ex)
+        {
+            Log.Error("Administration : ouverture de l'espace d'administration", ex);
+            ErrorMessage = ApiErrorText.Describe(ex);
+        }
+    }
+
+    /// <summary>Code refusé : essais restants, ou décompte jusqu'à la fin du blocage.</summary>
+    private async Task OnTpmPinRefusedAsync(TpmPinException error)
+    {
+        var info = await CheckLockoutAsync(error.IsLockedOut);
+        if (_isTpmLocked)
+        {
+            ErrorMessage = null; // le bandeau du blocage explique tout
+            return;
+        }
+        if (info is { MaxTries: > 0 })
+            ErrorMessage = $"Code PIN incorrect. Encore {info.RemainingTries} essai(s) avant le blocage temporaire de la puce " +
+                           "(compteur commun à la puce : les codes faux de Windows Hello comptent aussi).";
+    }
+
+    // ------------------------------------------------------------------ Protection anti-essais
+
+    /// <summary>
+    /// Lit l'état de la puce et met à jour le bandeau : bloquée avec une fin estimée (décompte),
+    /// bloquée sans estimation possible, ou débloquée.
+    /// </summary>
+    /// <param name="knownLocked">La puce vient de répondre « bloquée » (même si l'état n'est pas lisible).</param>
+    /// <param name="quiet">Vérification de fond : rien n'est affiché si la puce n'est pas bloquée.</param>
+    private Task<TpmLockoutInfo?> CheckLockoutAsync(bool knownLocked, bool quiet = false)
+    {
+        // Une lecture à la fois, dans l'ordre des demandes (une lecture de fond ne masque pas un blocage signalé).
+        var task = CheckAfterAsync(LockoutCheck, knownLocked, quiet);
+        LockoutCheck = task;
+        return task;
+    }
+
+    private async Task<TpmLockoutInfo?> CheckAfterAsync(Task previous, bool knownLocked, bool quiet)
+    {
+        try
+        {
+            await previous;
+        }
+        catch (Exception)
+        {
+            // erreur déjà journalisée par la lecture précédente
+        }
+        return await CheckCoreAsync(knownLocked, quiet);
+    }
+
+    private async Task<TpmLockoutInfo?> CheckCoreAsync(bool knownLocked, bool quiet)
+    {
+        if (_shell.Environment.Tpm is not { } tpm || _disposed) return null;
+        TpmLockoutInfo? info = null;
+        try
+        {
+            info = await BackgroundWork.RunAsync(tpm.GetLockoutInfo);
+        }
+        catch (Exception ex)
+        {
+            Log.Warn($"Administration : état de la protection anti-essais de la puce illisible ({ex.Message}).");
+        }
+        if (_disposed) return info;
+
+        var wasLocked = _isTpmLocked;
+        var locked = info?.IsLockedOut ?? knownLocked;
+        if (!locked)
+        {
+            StopLockout();
+            if (wasLocked && !quiet) StatusMessage = "La puce de sécurité accepte de nouveau les codes PIN : vous pouvez réessayer.";
+            return info;
+        }
+
+        var time = _shell.Environment.Time;
+        _lockoutHeals = info?.HealsWithTime ?? true;
+        _lockoutInterval = info?.RecoveryInterval ?? TimeSpan.Zero;
+        _lockoutUntil = info is { HealsWithTime: true } ? time.GetUtcNow() + info.MaxWait : null;
+        IsTpmLocked = true;
+        if (_lockoutUntil is not null && _lockoutTimer is null && _shell.Environment.StartTimers)
+            _lockoutTimer = time.CreateTimer(_ => _shell.Environment.Ui.Post(() => _ = TickLockoutAsync()), null, LockoutTick, LockoutTick);
+        UpdateLockoutText();
+        Log.Info(info is null
+            ? "Administration : puce TPM bloquée (protection anti-essais), durée inconnue."
+            : $"Administration : puce TPM bloquée ({info.Failures}/{info.MaxTries} erreurs, une erreur oubliée toutes les {info.RecoveryInterval}).");
+        return info;
+    }
+
+    /// <summary>Décompte (chaque seconde ; appelé directement par les tests).</summary>
+    internal async Task TickLockoutAsync()
+    {
+        if (!_isTpmLocked || _disposed || !LockoutCheck.IsCompleted) return;
+        UpdateLockoutText();
+        OnPropertyChanged(nameof(CanLogin));
+        // Fin estimée atteinte : la puce le confirme (sinon, nouvelle estimation).
+        if (_lockoutUntil is { } until && _shell.Environment.Time.GetUtcNow() >= until) await CheckLockoutAsync(knownLocked: false);
+    }
+
+    private void UpdateLockoutText()
+    {
+        if (!_lockoutHeals)
+        {
+            LockoutText = "La puce de sécurité est bloquée après trop de codes PIN faux, et ne se débloque pas d'elle-même sur ce PC : " +
+                          "un administrateur de ce PC doit réinitialiser sa protection anti-essais. En attendant, utilisez une clé « fichier ».";
+            return;
+        }
+        if (_lockoutUntil is not { } until)
+        {
+            LockoutText = "La puce de sécurité est temporairement bloquée après trop de codes PIN faux. Elle se débloque d'elle-même " +
+                          "au bout d'un moment (de quelques minutes à quelques heures selon le PC), uniquement PC allumé. " +
+                          "Réessayez plus tard, ou utilisez une clé « fichier ».";
+            return;
+        }
+        var remaining = until - _shell.Environment.Time.GetUtcNow();
+        LockoutText = remaining > TimeSpan.Zero
+            ? $"La puce de sécurité est bloquée après trop de codes PIN faux. Elle sera de nouveau utilisable dans " +
+              $"{FormatWait(remaining)} au plus (une erreur est oubliée toutes les {FormatWait(_lockoutInterval)}, PC allumé)."
+            : "Vérification de la puce…";
+    }
+
+    private void StopLockout()
+    {
+        _lockoutTimer?.Dispose();
+        _lockoutTimer = null;
+        _lockoutUntil = null;
+        LockoutText = null;
+        IsTpmLocked = false;
+    }
+
+    /// <summary>« 9 min 05 s », « 45 s », « 1 h 30 min ».</summary>
+    internal static string FormatWait(TimeSpan wait)
+    {
+        if (wait < TimeSpan.Zero) wait = TimeSpan.Zero;
+        var seconds = (long)Math.Ceiling(wait.TotalSeconds);
+        if (seconds < 60) return $"{seconds} s";
+        if (seconds < 3600) return seconds % 60 == 0 ? $"{seconds / 60} min" : $"{seconds / 60} min {seconds % 60:00} s";
+        var minutes = (seconds + 59) / 60;
+        return minutes % 60 == 0 ? $"{minutes / 60} h" : $"{minutes / 60} h {minutes % 60:00} min";
+    }
+
+    // ------------------------------------------------------------------ Suppression d'une clé TPM
+
+    private async Task DeleteTpmKeyAsync()
+    {
+        if (SelectedKey is not { IsTpm: true } key || IsBusy) return;
+        if (_shell.Environment.Tpm is not { } tpm)
+        {
+            ErrorMessage = "La puce de sécurité (TPM) n'est pas accessible sur ce PC : la clé ne peut pas être supprimée ici.";
+            return;
+        }
+
+        var dialogs = _shell.Environment.Dialogs;
+        if (!dialogs.Confirm("Supprimer la clé de la puce ?",
+                $"La clé « {key.Name} » ({key.Detail}) sera effacée DÉFINITIVEMENT de la puce de sécurité de ce PC, " +
+                $"avec ses fichiers {Path.GetFileName(key.Path)} et {Path.GetFileNameWithoutExtension(key.Path)}.pub.\n\n" +
+                "Elle ne pourra plus jamais servir à se connecter, sur aucun PC. Si c'était votre seule clé, il faudra une " +
+                "nouvelle invitation (ou la commande add-key sur le serveur).\n\n" +
+                $"Pensez aussi à la révoquer sur le serveur (identifiant de clé {key.KeyId ?? "inconnu"}).",
+                "Supprimer définitivement", "Annuler", danger: true))
+            return;
+
+        IsBusy = true;
+        ErrorMessage = null;
+        try
+        {
+            var reference = AdminTpmKeyFile.Load(key.Path);
+            await BackgroundWork.RunAsync(() =>
+            {
+                tpm.DeleteKey(reference.KeyName);
+                return true;
+            });
+            var left = AdminTpmKeyFile.DeleteFiles(key.Path);
+            _shell.Settings.Forget(key.Path);
+            _shell.Settings.Save(_shell.Environment.SettingsPath);
+            Log.Info($"Administration : clé TPM {key.KeyId} supprimée de la puce ({key.Path}).");
+
+            StatusMessage = $"Clé « {key.Name} » supprimée de la puce de ce PC. Révoquez-la aussi sur le serveur " +
+                            $"(identifiant de clé {key.KeyId ?? "inconnu"} : commande revoke-key sur le VPS)." +
+                            (left.Count == 0 ? "" : $" Fichier(s) à supprimer à la main : {string.Join(", ", left)}.");
+            LoadKeys(null);
+        }
+        catch (Exception ex)
+        {
+            Log.Warn($"Administration : suppression de la clé TPM impossible ({ex.Message}).");
+            ErrorMessage = $"Suppression impossible : {ApiErrorText.Describe(ex)}";
+        }
+        finally
+        {
+            IsBusy = false;
+        }
+    }
+
+    // ------------------------------------------------------------------ Clés
+
+    private void LoadKeys(string? select)
+    {
+        Keys.Clear();
+        foreach (var entry in AdminKeyLocator.Find(KeysDirectory, _shell.Settings.KeyPaths)) Keys.Add(entry);
+        SelectedKey = Keys.FirstOrDefault(k => string.Equals(k.Path, select, StringComparison.OrdinalIgnoreCase)) ?? Keys.FirstOrDefault();
+        OnPropertyChanged(nameof(HasKeys));
+    }
+
+    private void BrowseKey()
+    {
+        var path = _shell.Environment.Dialogs.PickOpenFile("Choisir votre clé d'administrateur",
+            "Clé d'administrateur (*.key, *.tpmkey)|*.key;*.tpmkey", Directory.Exists(KeysDirectory) ? KeysDirectory : null);
+        if (path is null) return;
+
+        if (AdminKeyLocator.IsReserved(path))
+        {
+            ErrorMessage = "Ce fichier est la clé de signature du launcher : choisissez votre clé d'administrateur.";
+            return;
+        }
+        if (AdminKeyLocator.Describe(path) is not { } entry)
+        {
+            ErrorMessage = "Ce fichier n'est pas une clé d'administrateur (fichier .key chiffré créé par le launcher ou tools\\admin-key.bat, " +
+                           "ou référence .tpmkey d'une clé de la puce de ce PC).";
+            return;
+        }
+        ErrorMessage = null;
+        _shell.Settings.Remember(entry.Path);
+        _shell.Settings.Save(_shell.Environment.SettingsPath);
+        LoadKeys(entry.Path);
+    }
+
+    private void OpenKeysFolder()
+    {
+        Directory.CreateDirectory(KeysDirectory);
+        _shell.Environment.Dialogs.OpenFolder(KeysDirectory);
+    }
+
+    /// <summary>Écran quitté : arrêt du décompte.</summary>
+    public void Dispose()
+    {
+        if (_disposed) return;
+        _disposed = true;
+        _lockoutTimer?.Dispose();
+        _lockoutTimer = null;
+    }
+}

src/GameLauncher.Modules/Admin/AdminPanelDescriptor.cs

@@ -0,0 +1,18 @@
+namespace GameLauncher.Modules.Admin;
+
+/// <summary>Page du menu d'administration déclarée par un module.</summary>
+/// <param name="Id">Identifiant unique, ex. « admin.dashboard », « catalog.games ».</param>
+/// <param name="Title">Titre affiché dans la navigation.</param>
+/// <param name="Description">Sous-titre affiché en haut de la page.</param>
+/// <param name="IconKey">Icône du launcher (ressource « Icon.&lt;clé&gt; » de Themes/Icons.xaml).</param>
+/// <param name="RequiredPermission">Permission nécessaire (null : tout administrateur connecté).</param>
+/// <param name="Order">Position dans la navigation (croissante).</param>
+/// <param name="CreateViewModel">Crée le ViewModel de la page (son affichage est un DataTemplate du launcher).</param>
+public sealed record AdminPanelDescriptor(
+    string Id,
+    string Title,
+    string Description,
+    string IconKey,
+    string? RequiredPermission,
+    int Order,
+    Func<IAdminContext, AdminPanelViewModel> CreateViewModel);

src/GameLauncher.Modules/Admin/AdminPanelViewModel.cs

@@ -0,0 +1,78 @@
+using GameLauncher.Mvvm;
+
+namespace GameLauncher.Modules.Admin;
+
+/// <summary>Base des pages d'administration : état « occupé », message d'erreur, gestion de la session perdue.</summary>
+public abstract class AdminPanelViewModel : ObservableObject
+{
+    private bool _isBusy;
+    private string? _errorMessage;
+    private bool _activated;
+
+    protected AdminPanelViewModel(IAdminContext context) => Context = context;
+
+    public IAdminContext Context { get; }
+
+    public bool IsBusy
+    {
+        get => _isBusy;
+        protected set
+        {
+            if (SetProperty(ref _isBusy, value)) OnBusyChanged();
+        }
+    }
+
+    /// <summary>« Occupé » a changé : réévaluer les commandes de la page (RaiseCanExecuteChanged).</summary>
+    protected virtual void OnBusyChanged()
+    {
+    }
+
+    public string? ErrorMessage
+    {
+        get => _errorMessage;
+        protected set
+        {
+            if (SetProperty(ref _errorMessage, value)) OnPropertyChanged(nameof(HasError));
+        }
+    }
+
+    public bool HasError => !string.IsNullOrEmpty(ErrorMessage);
+
+    /// <summary>Appelé à chaque affichage de la page ; <paramref name="firstTime"/> au premier.</summary>
+    public Task ActivateAsync()
+    {
+        var first = !_activated;
+        _activated = true;
+        return OnActivatedAsync(first);
+    }
+
+    protected virtual Task OnActivatedAsync(bool firstTime) => Task.CompletedTask;
+
+    /// <summary>
+    /// Exécute une action réseau : « occupé » pendant l'action, erreur affichée en cas d'échec,
+    /// retour à la connexion si la session a expiré. Vrai si l'action a réussi.
+    /// </summary>
+    protected async Task<bool> RunAsync(Func<Task> action)
+    {
+        if (IsBusy) return false;
+        IsBusy = true;
+        ErrorMessage = null;
+        try
+        {
+            await action();
+            return true;
+        }
+        catch (Exception ex)
+        {
+            if (ApiErrorText.IsSessionLost(ex))
+                Context.ReportSessionLost("Session expirée ou révoquée : reconnectez-vous.");
+            else
+                ErrorMessage = ApiErrorText.Describe(ex);
+            return false;
+        }
+        finally
+        {
+            IsBusy = false;
+        }
+    }
+}

src/GameLauncher.Modules/Admin/IAdminContext.cs

@@ -0,0 +1,44 @@
+using GameLauncher.ApiClient;
+using GameLauncher.Core.Models;
+
+namespace GameLauncher.Modules.Admin;
+
+/// <summary>Ce qu'une page d'administration reçoit : session, jeux déclarés, dialogues, navigation.</summary>
+public interface IAdminContext
+{
+    /// <summary>Session ouverte : lectures avec GetAsync, modifications signées avec SendSignedAsync.</summary>
+    AdminSession Session { get; }
+
+    LauncherApiClient Client { get; }
+
+    /// <summary>Jeux déclarés dans launcher.json (les seuls que l'administration peut modifier), valeurs par défaut.</summary>
+    IReadOnlyList<LauncherConfig> Games { get; }
+
+    /// <summary>Nom du launcher selon launcher.json.</summary>
+    string LauncherName { get; }
+
+    /// <summary>Jeu par défaut selon launcher.json.</summary>
+    string? DefaultGameId { get; }
+
+    /// <summary>Thèmes intégrés au launcher.</summary>
+    IReadOnlyList<string> Themes { get; }
+
+    IModuleDialogs Dialogs { get; }
+
+    string LauncherVersion { get; }
+
+    /// <summary>Pages visibles pour cet administrateur.</summary>
+    IReadOnlyList<AdminPanelDescriptor> Panels { get; }
+
+    void Navigate(string panelId);
+
+    /// <summary>La session n'est plus valable : retour à l'écran de connexion avec ce message.</summary>
+    void ReportSessionLost(string reason);
+
+    /// <summary>
+    /// Opération longue en cours (envoi d'une version…) : tant que l'objet renvoyé n'est pas libéré,
+    /// elle compte comme une activité (pas de verrouillage pour inactivité, session prolongée). Le
+    /// verrouillage manuel, celui de Windows et la durée maximale de la session restent appliqués.
+    /// </summary>
+    IDisposable BeginLongOperation();
+}

src/GameLauncher.Modules/ApiErrorText.cs

@@ -0,0 +1,31 @@
+using System.Security.Cryptography;
+using GameLauncher.ApiClient;
+using GameLauncher.Contracts.Dtos;
+
+namespace GameLauncher.Modules;
+
+/// <summary>Message clair (français) pour une erreur survenue dans un module d'administration.</summary>
+public static class ApiErrorText
+{
+    /// <param name="duringLogin">Vrai pendant la connexion : un refus vise la clé, pas la session.</param>
+    public static string Describe(Exception ex, bool duringLogin = false) => ex switch
+    {
+        ApiException { Status: 0, Code: "unreachable" } =>
+            "Serveur d'administration injoignable. Vérifiez votre connexion Internet, puis réessayez.",
+        ApiException { Status: 0, Code: "timeout" } => "Le serveur d'administration ne répond pas. Réessayez dans un instant.",
+        ApiException { Status: 401 } api when duringLogin && api.Code == ApiErrorCodes.Unauthorized =>
+            "Connexion refusée : cette clé n'est pas reconnue par le serveur, est encore en attente d'approbation, ou a été révoquée.",
+        ApiException { Status: 401, Code: ApiErrorCodes.Unauthorized } => "Session expirée : reconnectez-vous.",
+        ApiException api => api.Message,
+        CryptographicException crypto => crypto.Message,
+        FileNotFoundException missing => $"Fichier introuvable : {missing.FileName ?? missing.Message}",
+        IOException or UnauthorizedAccessException => $"Fichier inaccessible : {ex.Message}",
+        ArgumentException or InvalidOperationException => ex.Message,
+        OperationCanceledException => "Opération annulée.",
+        _ => $"Erreur inattendue : {ex.Message}"
+    };
+
+    /// <summary>La session n'est plus valable (expirée, révoquée) : il faut se reconnecter.</summary>
+    public static bool IsSessionLost(Exception ex) =>
+        ex is ApiException { Status: 401, Code: ApiErrorCodes.Unauthorized };
+}

src/GameLauncher.Modules/GameLauncher.Modules.csproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <!--
+    Socle des modules du launcher (sans WPF) : contrat d'un module, registre, pages du menu
+    d'administration, boîtes de dialogue abstraites, MVVM commun. Chaque module (Administration,
+    puis Actualités, Amis…) est une bibliothèque qui référence ce projet : sa logique et ses
+    ViewModels sont testables sans interface ; le launcher (WPF) n'en fournit que l'affichage.
+    Voir docs\ADMIN-ARCHITECTURE.md, § 5.
+  -->
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <RootNamespace>GameLauncher.Modules</RootNamespace>
+    <AssemblyName>GameLauncher.Modules</AssemblyName>
+    <Platforms>AnyCPU;x64</Platforms>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\GameLauncher.Core\GameLauncher.Core.csproj" />
+    <ProjectReference Include="..\GameLauncher.ApiClient\GameLauncher.ApiClient.csproj" />
+  </ItemGroup>
+
+</Project>

src/GameLauncher.Modules/ILauncherModule.cs

@@ -0,0 +1,74 @@
+using GameLauncher.Modules.Admin;
+
+namespace GameLauncher.Modules;
+
+/// <summary>
+/// Module du launcher. Il déclare ce qu'il apporte au registre ; il ne connaît ni les fenêtres ni
+/// les autres modules. Les modules actifs sont listés dans App (launcher WPF).
+/// </summary>
+public interface ILauncherModule
+{
+    /// <summary>Identifiant stable, ex. « admin », « news ».</summary>
+    string Id { get; }
+
+    string DisplayName { get; }
+
+    void Register(IModuleRegistry registry);
+}
+
+/// <summary>Ce qu'un module peut ajouter au launcher.</summary>
+public interface IModuleRegistry
+{
+    /// <summary>Page du menu d'administration (affichée seulement aux administrateurs ayant la permission requise).</summary>
+    void AddAdminPanel(AdminPanelDescriptor panel);
+}
+
+/// <summary>Modules actifs et ce qu'ils ont déclaré.</summary>
+public sealed class ModuleCatalog : IModuleRegistry
+{
+    private readonly List<AdminPanelDescriptor> _adminPanels = new();
+    private ILauncherModule? _registering;
+
+    public ModuleCatalog(IEnumerable<ILauncherModule> modules)
+    {
+        var list = new List<ILauncherModule>();
+        foreach (var module in modules)
+        {
+            if (string.IsNullOrWhiteSpace(module.Id) || list.Any(m => string.Equals(m.Id, module.Id, StringComparison.OrdinalIgnoreCase)))
+                throw new InvalidOperationException($"Identifiant de module invalide ou en double : « {module.Id} ».");
+            list.Add(module);
+            _registering = module;
+            try
+            {
+                module.Register(this);
+            }
+            finally
+            {
+                _registering = null;
+            }
+        }
+        Modules = list;
+    }
+
+    public IReadOnlyList<ILauncherModule> Modules { get; }
+
+    /// <summary>Toutes les pages d'administration, dans l'ordre d'affichage.</summary>
+    public IReadOnlyList<AdminPanelDescriptor> AdminPanels =>
+        _adminPanels.OrderBy(p => p.Order).ThenBy(p => p.Title, StringComparer.CurrentCulture).ToList();
+
+    /// <summary>Pages visibles pour un administrateur (selon ses permissions ; le serveur reste seul juge).</summary>
+    public IReadOnlyList<AdminPanelDescriptor> AdminPanelsFor(IReadOnlyCollection<string> permissions) =>
+        AdminPanels.Where(p => p.RequiredPermission is null || permissions.Contains(p.RequiredPermission)).ToList();
+
+    void IModuleRegistry.AddAdminPanel(AdminPanelDescriptor panel)
+    {
+        ArgumentNullException.ThrowIfNull(panel);
+        if (_registering is null) throw new InvalidOperationException("Les pages se déclarent dans ILauncherModule.Register.");
+        if (string.IsNullOrWhiteSpace(panel.Id) || _adminPanels.Any(p => string.Equals(p.Id, panel.Id, StringComparison.OrdinalIgnoreCase)))
+            throw new InvalidOperationException($"Page d'administration invalide ou en double : « {panel.Id} » (module {_registering.Id}).");
+        if (panel.RequiredPermission is { } permission &&
+            (permission.Length > 64 || permission.Count(c => c == '.') != 1 || permission.StartsWith('.') || permission.EndsWith('.')))
+            throw new InvalidOperationException($"Permission invalide pour la page « {panel.Id} » : « {permission} » (format module.action).");
+        _adminPanels.Add(panel);
+    }
+}

src/GameLauncher.Modules/IModuleDialogs.cs

@@ -0,0 +1,40 @@
+namespace GameLauncher.Modules;
+
+public enum ModuleMessageKind
+{
+    Info,
+    Success,
+    Warning,
+    Error
+}
+
+/// <summary>Boîtes de dialogue et actions système offertes aux modules (implémentées par le launcher WPF).</summary>
+public interface IModuleDialogs
+{
+    void ShowMessage(string title, string message, ModuleMessageKind kind = ModuleMessageKind.Info);
+
+    bool Confirm(string title, string message, string confirmText, string cancelText = "Annuler", bool danger = false);
+
+    /// <param name="filter">Filtre au format Windows, ex. « Clé d'administrateur (*.key)|*.key ».</param>
+    string? PickOpenFile(string title, string filter, string? initialDirectory);
+
+    string? PickSaveFile(string title, string filter, string defaultFileName, string? initialDirectory);
+
+    void CopyToClipboard(string text);
+
+    void OpenFolder(string path);
+}
+
+/// <summary>Exécution sur le fil de l'interface (minuteries, notifications venues d'un autre fil).</summary>
+public interface IUiDispatcher
+{
+    void Post(Action action);
+}
+
+/// <summary>Exécution immédiate (tests, outils en ligne de commande).</summary>
+public sealed class ImmediateDispatcher : IUiDispatcher
+{
+    public static readonly ImmediateDispatcher Instance = new();
+
+    public void Post(Action action) => action();
+}

src/GameLauncher.Modules/Mvvm/RelayCommand.cs

@@ -7,6 +7,7 @@ public sealed class RelayCommand : ICommand
 {
     private readonly Action _execute;
     private readonly Func<bool>? _canExecute;
+    private readonly OwnerThread _owner = OwnerThread.Current();
 
     public RelayCommand(Action execute, Func<bool>? canExecute = null)
     {
@@ -23,7 +24,7 @@ public sealed class RelayCommand : ICommand
         if (CanExecute(parameter)) _execute();
     }
 
-    public void RaiseCanExecuteChanged() => CanExecuteChanged?.Invoke(this, EventArgs.Empty);
+    public void RaiseCanExecuteChanged() => _owner.Run(() => CanExecuteChanged?.Invoke(this, EventArgs.Empty));
 }
 
 /// <summary>Commande asynchrone : désactivée pendant son exécution (pas de double clic).</summary>
@@ -31,6 +32,7 @@ public sealed class AsyncRelayCommand : ICommand
 {
     private readonly Func<Task> _execute;
     private readonly Func<bool>? _canExecute;
+    private readonly OwnerThread _owner = OwnerThread.Current();
     private bool _isRunning;
 
     public AsyncRelayCommand(Func<Task> execute, Func<bool>? canExecute = null)
@@ -43,9 +45,12 @@ public sealed class AsyncRelayCommand : ICommand
 
     public bool CanExecute(object? parameter) => !_isRunning && (_canExecute?.Invoke() ?? true);
 
-    public async void Execute(object? parameter)
+    public async void Execute(object? parameter) => await ExecuteAsync();
+
+    /// <summary>Exécute la commande et attend la fin (tests, enchaînements).</summary>
+    public async Task ExecuteAsync()
     {
-        if (!CanExecute(parameter)) return;
+        if (!CanExecute(null)) return;
         _isRunning = true;
         RaiseCanExecuteChanged();
         try
@@ -64,5 +69,31 @@ public sealed class AsyncRelayCommand : ICommand
         }
     }
 
-    public void RaiseCanExecuteChanged() => CanExecuteChanged?.Invoke(this, EventArgs.Empty);
+    public void RaiseCanExecuteChanged() => _owner.Run(() => CanExecuteChanged?.Invoke(this, EventArgs.Empty));
+}
+
+/// <summary>
+/// Fil qui a créé la commande (celui de l'interface sous WPF). Un bouton n'accepte d'être notifié que
+/// depuis ce fil : appelée d'ailleurs (suite d'un ConfigureAwait(false)…), la notification y est renvoyée
+/// au lieu de lever « un autre thread en est propriétaire ».
+/// </summary>
+internal readonly struct OwnerThread
+{
+    private readonly int _threadId;
+    private readonly SynchronizationContext? _context;
+
+    private OwnerThread(int threadId, SynchronizationContext? context)
+    {
+        _threadId = threadId;
+        _context = context;
+    }
+
+    public static OwnerThread Current() => new(Environment.CurrentManagedThreadId, SynchronizationContext.Current);
+
+    public void Run(Action action)
+    {
+        // Même fil, ou aucun fil d'interface connu (tests, services) : exécution directe.
+        if (_context is null || Environment.CurrentManagedThreadId == _threadId) action();
+        else _context.Post(static state => ((Action)state!)(), action);
+    }
 }

src/GameLauncher/App.xaml

@@ -11,6 +11,8 @@
                 <ResourceDictionary Source="Themes/Controls.xaml" />
                 <!-- Notes de version (format enrichi) : modèles partagés par la fenêtre principale et la fenêtre agrandie -->
                 <ResourceDictionary Source="Themes/Changelog.xaml" />
+                <!-- Menu d'administration : styles et modèles des pages des modules (Views/Admin) -->
+                <ResourceDictionary Source="Themes/Admin.xaml" />
             </ResourceDictionary.MergedDictionaries>
         </ResourceDictionary>
     </Application.Resources>

src/GameLauncher/App.xaml.cs

@@ -5,10 +5,17 @@ using System.Windows;
 using System.Windows.Interop;
 using System.Windows.Media;
 using System.Windows.Threading;
+using GameLauncher.Contracts.Catalog;
+using GameLauncher.Core.Catalog;
 using GameLauncher.Core.Models;
 using GameLauncher.Core.SelfUpdate;
 using GameLauncher.Core.Services;
 using GameLauncher.Core.Utils;
+using GameLauncher.Modules;
+using GameLauncher.Modules.Admin;
+using GameLauncher.Modules.Admin.Catalog;
+using GameLauncher.Modules.Admin.Changelog;
+using GameLauncher.Modules.Admin.Publishing;
 using GameLauncher.Platform;
 using GameLauncher.Services;
 using GameLauncher.ViewModels;
@@ -43,6 +50,9 @@ public partial class App : Application, ILauncherRestartHost
 	private Views.MainWindow? _mainWindow;
 	private HttpDownloader? _http;
 	private LauncherUpdateService? _updates;
+	private AdminWindowService? _admin;
+	private CatalogService? _catalogService;
+	private Task<CatalogDocument?>? _catalogFetch;
 	private string _launcherPath = "";
 	private Version _version = new(1, 0, 0);
 
@@ -147,6 +157,12 @@ public partial class App : Application, ILauncherRestartHost
 			}
 		}
 
+		// Catalogue des jeux (informations modifiables publiées depuis le menu d'administration) :
+		// dernier catalogue en cache appliqué tout de suite ; version à jour téléchargée pendant la
+		// vérification de mise à jour du launcher (pas de téléchargement pour --capture et --uninstall).
+		var catalogStarted = DateTime.UtcNow;
+		StartCatalog(catalog, args, download: args.CaptureDirectory is null && !args.Uninstall);
+
 		// 3. Mise à jour du launcher lui-même : au démarrage, avant la fenêtre principale
 		var normalStart = args.CaptureDirectory is null && !args.Uninstall && args.UpdatedFromPid is null;
 		if (normalStart)
@@ -162,6 +178,8 @@ public partial class App : Application, ILauncherRestartHost
 			}
 		}
 
+		await ApplyFreshCatalogAsync(catalog, args, catalogStarted);
+
 		// 4. Composition des services (un ensemble de services par jeu)
 		Views.MainWindow window;
 		try
@@ -323,12 +341,206 @@ public partial class App : Application, ILauncherRestartHost
 		launcher.SelectedGame = launcher.ResolveInitialGame(requestedGameId); // applique le thème du jeu
 		launcher.AttachTransition(window);
 
+		// Menu d'administration (accès discret : Ctrl+Maj+Alt+A ou 5 clics sur le logo). Pas en mode --capture.
+		if (!readOnly)
+		{
+			var (apiUrl, apiUrlError) = ResolveAdminApiUrl(catalog);
+			_admin = new AdminWindowService(window, CreateModules(), catalog, LoadDeclaredCatalog(catalog), apiUrl, apiUrlError, version,
+				ThemeManager.BuiltInThemes.ToList());
+			window.AdminRequested += _admin.Open;
+		}
+
 		window.DataContext = launcher;
 		window.Closed += (_, _) => Shutdown();
 		window.Show();
 		return window;
 	}
 
+	// ------------------------------------------------------------------ Catalogue des jeux
+
+	/// <summary>Attente maximale du catalogue à jour au démarrage (au-delà : cache, mise à jour au démarrage suivant).</summary>
+	private static readonly TimeSpan CatalogStartupBudget = TimeSpan.FromSeconds(2.5);
+	private static readonly TimeSpan CatalogImagesBudget = TimeSpan.FromSeconds(1.5);
+
+	/// <summary>Applique le catalogue en cache et lance le téléchargement de la version à jour.</summary>
+	private void StartCatalog(LauncherCatalog catalog, CommandLine args, bool download)
+	{
+		var url = ResolveCatalogUrl(catalog);
+		if (url is null || _http is null) return;
+		try
+		{
+			_catalogService = new CatalogService(_http, catalog.DataDirectory, new Uri(url));
+			if (_catalogService.LoadCached() is { } cached) ApplyCatalog(catalog, cached, args);
+			if (download) _catalogFetch = _catalogService.FetchAsync();
+		}
+		catch (Exception ex)
+		{
+			Log.Error("Catalogue des jeux", ex);
+		}
+	}
+
+	/// <summary>
+	/// Attend brièvement le catalogue à jour (et ses nouvelles images) puis l'applique. Trop lent :
+	/// le cache reste appliqué, et le téléchargement se termine en arrière-plan pour le démarrage suivant.
+	/// </summary>
+	private async Task ApplyFreshCatalogAsync(LauncherCatalog catalog, CommandLine args, DateTime started)
+	{
+		if (_catalogFetch is not { } fetch || _catalogService is not { } service) return;
+		try
+		{
+			var remaining = CatalogStartupBudget - (DateTime.UtcNow - started);
+			if (remaining > TimeSpan.Zero) await Task.WhenAny(fetch, Task.Delay(remaining));
+			if (!fetch.IsCompleted)
+			{
+				Log.Info("Catalogue des jeux : serveur lent, catalogue en cache utilisé (mise à jour au prochain démarrage).");
+				_ = FinishCatalogInBackgroundAsync(fetch, service);
+				return;
+			}
+			if (await fetch is not { } fresh) return;
+
+			var missing = fresh.Games.Values.SelectMany(g => new[] { g.Icon, g.Background })
+							   .Where(u => u is not null && service.CachedImage(u) is null).Distinct().ToList();
+			if (missing.Count > 0)
+				await Task.WhenAny(Task.WhenAll(missing.Select(u => service.GetImageAsync(u))), Task.Delay(CatalogImagesBudget));
+
+			ApplyCatalog(catalog, fresh, args);
+			Log.Info($"Catalogue des jeux : révision {fresh.Revision} appliquée.");
+			_ = FinishCatalogInBackgroundAsync(fetch, service);
+		}
+		catch (Exception ex)
+		{
+			Log.Error("Catalogue des jeux", ex);
+		}
+	}
+
+	/// <summary>Fin du téléchargement en arrière-plan : images manquantes, nettoyage du cache d'images.</summary>
+	private static async Task FinishCatalogInBackgroundAsync(Task<CatalogDocument?> fetch, CatalogService service)
+	{
+		try
+		{
+			if (await fetch is not { } fresh) return;
+			foreach (var url in fresh.Games.Values.SelectMany(g => new[] { g.Icon, g.Background }).Where(u => u is not null).Distinct())
+				await service.GetImageAsync(url);
+			service.PruneImages(fresh);
+		}
+		catch (Exception ex)
+		{
+			Log.Warn($"Catalogue des jeux (arrière-plan) : {ex.Message}");
+		}
+	}
+
+	private void ApplyCatalog(LauncherCatalog catalog, CatalogDocument document, CommandLine args)
+	{
+		var requested = new[] { args.GameId, args.UninstallGameId };
+		CatalogMerger.Apply(catalog, document, ThemeManager.BuiltInThemes.ToList(),
+			url => _catalogService?.CachedImage(url),
+			game => requested.Any(id => string.Equals(id, game.GameId, StringComparison.OrdinalIgnoreCase)) || IsInstalled(catalog, game));
+	}
+
+	/// <summary>Jeu installé sur ce PC (registre) : jamais masqué par le catalogue.</summary>
+	private bool IsInstalled(LauncherCatalog catalog, LauncherConfig game)
+	{
+		try
+		{
+			return new RegistryService(game, _launcherPath, catalog.DataFolderName, ownsLauncherInstance: false).Read() is not null;
+		}
+		catch (Exception ex)
+		{
+			Log.Warn($"Lecture du registre ({game.GameId}) : {ex.Message}");
+			return true; // dans le doute, le jeu reste affiché
+		}
+	}
+
+	/// <summary>
+	/// Adresse du catalogue (« catalogUrl »). Comme apiUrl : en Release, seulement celle du
+	/// launcher.json intégré à l'exécutable ; en Debug, celle de la configuration utilisée.
+	/// </summary>
+	private static string? ResolveCatalogUrl(LauncherCatalog catalog)
+	{
+#if DEBUG
+		if (catalog.CatalogUrlError is not null) Log.Warn(catalog.CatalogUrlError);
+		return catalog.CatalogUrl;
+#else
+		try
+		{
+			using var embedded = Assembly.GetExecutingAssembly().GetManifestResourceStream(ConfigFileName);
+			var integrated = embedded is null ? null : LauncherCatalog.Load(embedded);
+			if (catalog.CatalogUrl is not null && !string.Equals(catalog.CatalogUrl, integrated?.CatalogUrl, StringComparison.Ordinal))
+				Log.Warn("« catalogUrl » du launcher.json externe ignorée : seule celle intégrée à l'exécutable est utilisée.");
+			if (integrated?.CatalogUrlError is { } error) Log.Warn(error);
+			return integrated?.CatalogUrl;
+		}
+		catch (Exception ex)
+		{
+			Log.Error("Adresse du catalogue (launcher.json intégré)", ex);
+			return null;
+		}
+#endif
+	}
+
+	/// <summary>
+	/// Jeux tels que déclarés dans launcher.json (valeurs par défaut, avant le catalogue), pour le menu
+	/// d'administration. En Release : le launcher.json INTÉGRÉ à l'exe (un fichier posé à côté ne décide
+	/// pas des jeux que l'administration modifie) ; en Debug : la configuration utilisée.
+	/// </summary>
+	private LauncherCatalog LoadDeclaredCatalog(LauncherCatalog active)
+	{
+		try
+		{
+#if DEBUG
+			return LoadCatalog(_args?.ConfigPath);
+#else
+			using var embedded = Assembly.GetExecutingAssembly().GetManifestResourceStream(ConfigFileName)
+				?? throw new FileNotFoundException($"{ConfigFileName} intégré introuvable.");
+			return LauncherCatalog.Load(embedded);
+#endif
+		}
+		catch (Exception ex)
+		{
+			Log.Error("launcher.json (jeux déclarés, menu d'administration)", ex);
+			return active;
+		}
+	}
+
+	/// <summary>Modules du launcher (pages du menu d'administration…). Les futurs modules s'ajoutent ici.</summary>
+	private static ModuleCatalog CreateModules() => new(new ILauncherModule[]
+	{
+		new AdminModule(),
+		new CatalogAdminModule(),
+		new ChangelogAdminModule(),
+		new PublishAdminModule()
+	});
+
+	/// <summary>
+	/// Adresse de l'API d'administration (« apiUrl »). En Release, elle n'est lue QUE dans le
+	/// launcher.json intégré à l'exécutable : un launcher.json posé à côté de l'exe (ou --config) ne
+	/// peut pas rediriger les administrateurs vers un autre serveur. En Debug, la configuration
+	/// utilisée est suivie (serveur local http://127.0.0.1:5080/api/ pour les tests).
+	/// </summary>
+	/// <returns>L'adresse (ou null) et, si elle a été ignorée car invalide, la raison.</returns>
+	private static (string? ApiUrl, string? Error) ResolveAdminApiUrl(LauncherCatalog catalog)
+	{
+#if DEBUG
+		if (catalog.ApiUrlError is not null) Log.Warn(catalog.ApiUrlError);
+		return (catalog.ApiUrl, catalog.ApiUrlError);
+#else
+		try
+		{
+			using var embedded = Assembly.GetExecutingAssembly().GetManifestResourceStream(ConfigFileName);
+			var integrated = embedded is null ? null : LauncherCatalog.Load(embedded);
+			if (catalog.ApiUrl is not null && !string.Equals(catalog.ApiUrl, integrated?.ApiUrl, StringComparison.Ordinal))
+				Log.Warn("« apiUrl » du launcher.json externe ignorée : seule celle intégrée à l'exécutable est utilisée.");
+			if (integrated?.ApiUrlError is { } error) Log.Warn(error);
+			return (integrated?.ApiUrl, integrated?.ApiUrlError);
+		}
+		catch (Exception ex)
+		{
+			Log.Error("Adresse de l'API d'administration (launcher.json intégré)", ex);
+			return (null, "launcher.json intégré illisible.");
+		}
+#endif
+	}
+
 	/// <summary>Option --capture : une capture PNG par jeu (état réel, sans action automatique), puis fermeture.</summary>
 	private async Task CaptureAsync(Views.MainWindow window, string directory)
 	{
@@ -381,6 +593,8 @@ public partial class App : Application, ILauncherRestartHost
 	{
 		_instanceChannel?.Dispose();
 		_instanceChannel = null;
+		_admin?.Dispose(); // ferme le menu d'administration : clé effacée de la mémoire
+		_admin = null;
 		_trayIcon?.Dispose(); // sinon l'icône resterait affichée jusqu'au survol
 		_trayIcon = null;
 		_launcher?.Dispose();
@@ -432,7 +646,9 @@ public partial class App : Application, ILauncherRestartHost
 	/// <returns>Vrai si le jeu fait partie de ce launcher.</returns>
 	private bool OnLaunchRequestedByAnotherInstance(string gameId)
 	{
-		var known = _catalog?.Find(gameId) is not null;
+		// Jeux AFFICHÉS uniquement (un jeu masqué par le catalogue n'est pas proposé) : sinon la demande
+		// serait acceptée sans que le launcher puisse l'afficher.
+		var known = _catalog?.Games.Any(g => string.Equals(g.GameId, gameId, StringComparison.OrdinalIgnoreCase)) == true;
 		Dispatcher.InvokeAsync(() => HandleLaunchRequest(gameId));
 		return known;
 	}

src/GameLauncher/GameLauncher.csproj

@@ -49,6 +49,9 @@
 
   <ItemGroup>
     <ProjectReference Include="..\GameLauncher.Core\GameLauncher.Core.csproj" />
+    <!-- Modules (SDK commun + menu d'administration) : logique et ViewModels, sans WPF ; les vues sont ici (Views\Admin, Themes\Admin.xaml). -->
+    <ProjectReference Include="..\GameLauncher.Modules\GameLauncher.Modules.csproj" />
+    <ProjectReference Include="..\GameLauncher.Modules.Admin\GameLauncher.Modules.Admin.csproj" />
   </ItemGroup>
 
 </Project>

src/GameLauncher/Platform/ModuleDialogs.cs

@@ -0,0 +1,115 @@
+using System.Diagnostics;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Windows;
+using GameLauncher.Core.Utils;
+using GameLauncher.Modules;
+using GameLauncher.Services;
+using GameLauncher.Views;
+using Microsoft.Win32;
+
+namespace GameLauncher.Platform;
+
+/// <summary>
+/// Boîtes de dialogue offertes aux modules (menu d'administration…) : mêmes fenêtres que le reste
+/// du launcher (ModernDialog), au-dessus de la fenêtre du module.
+/// </summary>
+public sealed class ModuleDialogs : IModuleDialogs
+{
+    private readonly Func<Window?> _owner;
+
+    /// <param name="owner">Fenêtre propriétaire du moment (null : centrée sur l'écran).</param>
+    public ModuleDialogs(Func<Window?> owner) => _owner = owner;
+
+    private Window? Owner => _owner() is { IsLoaded: true, IsVisible: true } window ? window : null;
+
+    public void ShowMessage(string title, string message, ModuleMessageKind kind = ModuleMessageKind.Info) =>
+        ModernDialog.ShowMessage(Owner, title, message, kind switch
+        {
+            ModuleMessageKind.Success => DialogKind.Success,
+            ModuleMessageKind.Warning => DialogKind.Warning,
+            ModuleMessageKind.Error => DialogKind.Error,
+            _ => DialogKind.Info
+        });
+
+    public bool Confirm(string title, string message, string confirmText, string cancelText = "Annuler", bool danger = false) =>
+        ModernDialog.ShowConfirm(Owner, title, message, confirmText, cancelText,
+            danger ? DialogKind.Danger : DialogKind.Question, null).Confirmed;
+
+    public string? PickOpenFile(string title, string filter, string? initialDirectory)
+    {
+        var dialog = new OpenFileDialog
+        {
+            Title = title,
+            Filter = filter,
+            Multiselect = false,
+            CheckFileExists = true,
+            DereferenceLinks = true
+        };
+        if (!string.IsNullOrWhiteSpace(initialDirectory) && Directory.Exists(initialDirectory))
+            dialog.InitialDirectory = initialDirectory;
+        var owner = Owner;
+        var result = owner is null ? dialog.ShowDialog() : dialog.ShowDialog(owner);
+        return result == true ? dialog.FileName : null;
+    }
+
+    public string? PickSaveFile(string title, string filter, string defaultFileName, string? initialDirectory)
+    {
+        var dialog = new SaveFileDialog
+        {
+            Title = title,
+            Filter = filter,
+            FileName = defaultFileName,
+            OverwritePrompt = false, // les services refusent d'écraser un fichier existant (ex. une clé)
+            AddExtension = true
+        };
+        if (!string.IsNullOrWhiteSpace(initialDirectory) && Directory.Exists(initialDirectory))
+            dialog.InitialDirectory = initialDirectory;
+        var owner = Owner;
+        var result = owner is null ? dialog.ShowDialog() : dialog.ShowDialog(owner);
+        return result == true ? dialog.FileName : null;
+    }
+
+    public void CopyToClipboard(string text)
+    {
+        // Le presse-papiers peut être momentanément occupé par une autre application.
+        for (var attempt = 1; ; attempt++)
+        {
+            try
+            {
+                Clipboard.SetText(text);
+                return;
+            }
+            catch (COMException ex) when (attempt < 3)
+            {
+                Log.Warn($"Presse-papiers occupé ({ex.ErrorCode:X8}), nouvel essai.");
+                Thread.Sleep(60);
+            }
+            catch (Exception ex)
+            {
+                Log.Error("Copie dans le presse-papiers impossible", ex);
+                ShowMessage("Copie impossible", "Le presse-papiers est utilisé par une autre application : réessayez.", ModuleMessageKind.Warning);
+                return;
+            }
+        }
+    }
+
+    /// <summary>Dossier LOCAL existant uniquement (jamais une adresse web ni un partage réseau \\serveur\…).</summary>
+    public void OpenFolder(string path)
+    {
+        if (!Path.IsPathFullyQualified(path) || path.StartsWith(@"\\", StringComparison.Ordinal) ||
+            path.StartsWith("//", StringComparison.Ordinal) || !Directory.Exists(path))
+        {
+            Log.Warn($"Ouverture de dossier refusée (chemin local attendu) : {path}");
+            return;
+        }
+        try
+        {
+            Process.Start(new ProcessStartInfo("explorer.exe", $"\"{path}\"") { UseShellExecute = true });
+        }
+        catch (Exception ex)
+        {
+            Log.Error($"Ouverture du dossier impossible : {path}", ex);
+        }
+    }
+}

src/GameLauncher/Platform/TpmKeyStore.cs

@@ -0,0 +1,454 @@
+using System.Buffers.Binary;
+using System.Runtime.InteropServices;
+using System.Runtime.ExceptionServices;
+using System.Security.Cryptography;
+using System.Text;
+using GameLauncher.Contracts.Security;
+using GameLauncher.Core.Utils;
+using GameLauncher.Modules.Admin.Services;
+
+namespace GameLauncher.Platform;
+
+/// <summary>
+/// Clés d'administrateur dans la puce de sécurité (TPM 2.0) de ce PC, via le fournisseur Windows
+/// « Microsoft Platform Crypto Provider » (CNG) :
+///  • la clé ECDSA P-256 est GÉNÉRÉE par la puce ; ce fournisseur ne permet jamais d'exporter la clé
+///    privée (Windows n'en garde qu'une copie chiffrée par la puce elle-même, inutilisable ailleurs) ;
+///  • clé de l'utilisateur Windows courant (un autre compte du PC ne peut pas l'ouvrir) ;
+///  • chaque usage exige le code PIN (« usage authorization » de la clé), vérifié par la puce, qui se
+///    bloque temporairement après plusieurs codes faux (protection anti-essais du TPM) ;
+///  • aucune fenêtre Windows : le code est saisi dans le launcher puis effacé ; la clé est ouverte
+///    en mode silencieux.
+/// </summary>
+public sealed class TpmKeyStore : IAdminTpm
+{
+    /// <summary>Autorisation d'usage de la clé (NCRYPT_PCP_USAGEAUTH_PROPERTY) : SHA-1 du code PIN en UTF-16.</summary>
+    private const string UsageAuthProperty = "PCP_USAGEAUTH";
+
+    private static CngProvider Provider => CngProvider.MicrosoftPlatformCryptoProvider;
+
+    /// <summary>Préfixe des clés de test de <see cref="Check"/> : distinct de celui des vraies clés.</summary>
+    private const string CheckKeyPrefix = "GameLauncher.AdminCheck.";
+
+    public TpmAvailability Check()
+    {
+        if (!OperatingSystem.IsWindowsVersionAtLeast(10))
+            return new TpmAvailability(false, "Clé dans la puce de sécurité : Windows 10 ou plus récent est nécessaire.");
+
+        // Vérification RÉELLE : création d'une clé de test dans la puce, signature, contrôle, suppression.
+        var keyName = CheckKeyPrefix + Guid.NewGuid().ToString("N");
+        var created = false;
+        try
+        {
+            using var key = CreateCore(keyName, Convert.ToHexString(RandomNumberGenerator.GetBytes(16)));
+            created = true;
+            using var signer = new TpmSigner(key);
+            var message = RandomNumberGenerator.GetBytes(32);
+            var signature = signer.SignNow(message);
+            if (!AdminKeys.Verify(signer.PublicKey, message, signature))
+                return new TpmAvailability(false, "La puce de sécurité (TPM) de ce PC a produit une signature invalide.");
+            return new TpmAvailability(true, "Puce de sécurité (TPM 2.0) détectée et vérifiée sur ce PC.");
+        }
+        catch (CryptographicException ex)
+        {
+            Log.Info($"Puce TPM indisponible : {ex.Message} (code 0x{CodeOf(ex):X8})");
+            return new TpmAvailability(false, DescribeUnavailable(ex));
+        }
+        catch (Exception ex) when (ex is PlatformNotSupportedException or NotSupportedException or ArgumentException)
+        {
+            Log.Info($"Puce TPM indisponible : {ex.GetType().Name} {ex.Message}");
+            return new TpmAvailability(false, "Aucune puce de sécurité (TPM 2.0) utilisable sur ce PC.");
+        }
+        finally
+        {
+            if (created) TryDelete(keyName);
+        }
+    }
+
+    public IDisposableAdminSigner CreateKey(string keyName, string pin)
+    {
+        EnsureKeyName(keyName);
+        CngKey key;
+        try
+        {
+            key = CreateCore(keyName, pin);
+        }
+        catch (CryptographicException ex)
+        {
+            throw Wrap(DescribeUnavailable(ex), ex);
+        }
+
+        try
+        {
+            return new TpmSigner(key);
+        }
+        catch (Exception ex)
+        {
+            key.Dispose();
+            TryDelete(keyName); // jamais de clé orpheline dans la puce
+            if (ex is CryptographicException crypto) throw Describe(crypto);
+            throw;
+        }
+    }
+
+    public IDisposableAdminSigner OpenKey(string keyName, byte[] expectedPublicKey, string pin)
+    {
+        EnsureKeyName(keyName);
+        CngKey key;
+        try
+        {
+            key = CngKey.Open(keyName, Provider, CngKeyOpenOptions.Silent);
+        }
+        catch (CryptographicException ex)
+        {
+            throw Describe(ex);
+        }
+
+        TpmSigner? signer = null;
+        try
+        {
+            // Clé publique comparée AVANT tout essai du code : une référence trompeuse ne consomme
+            // aucun essai de la protection anti-essais de la puce.
+            if (!TpmSigner.ReadPublicKey(key).AsSpan().SequenceEqual(expectedPublicKey))
+                throw new CryptographicException("La clé de la puce ne correspond pas à ce fichier de référence : fichier modifié ?");
+            SetUsageAuth(key, pin);
+            signer = new TpmSigner(key);
+            // Le code PIN n'est vérifié par la puce qu'à l'usage : signature de test AVANT de contacter le serveur.
+            signer.SignNow(RandomNumberGenerator.GetBytes(32));
+            return signer;
+        }
+        catch (Exception ex)
+        {
+            if (signer is not null) signer.Dispose();
+            else key.Dispose();
+            if (ex is CryptographicException crypto) throw Describe(crypto);
+            throw;
+        }
+    }
+
+    public void DeleteKey(string keyName)
+    {
+        EnsureKeyName(keyName);
+        DeleteCore(keyName);
+    }
+
+    /// <summary>Crée la clé (code PIN fixé avant la finalisation) et fournit le code pour la poignée ouverte.</summary>
+    private static CngKey CreateCore(string keyName, string pin)
+    {
+        var parameters = new CngKeyCreationParameters
+        {
+            Provider = Provider,
+            KeyCreationOptions = CngKeyCreationOptions.None // clé de l'utilisateur Windows (pas de la machine)
+        };
+        var auth = UsageAuth(pin);
+        try
+        {
+            parameters.Parameters.Add(new CngProperty(UsageAuthProperty, auth, CngPropertyOptions.None));
+        }
+        finally
+        {
+            CryptographicOperations.ZeroMemory(auth);
+        }
+
+        var key = CngKey.Create(CngAlgorithm.ECDsaP256, keyName, parameters);
+        try
+        {
+            SetUsageAuth(key, pin); // une fois finalisée, la clé exige son code pour cette poignée aussi
+            return key;
+        }
+        catch
+        {
+            key.Dispose();
+            TryDelete(keyName);
+            throw;
+        }
+    }
+
+    private static void SetUsageAuth(CngKey key, string pin)
+    {
+        var auth = UsageAuth(pin);
+        try
+        {
+            key.SetProperty(new CngProperty(UsageAuthProperty, auth, CngPropertyOptions.None));
+        }
+        finally
+        {
+            CryptographicOperations.ZeroMemory(auth);
+        }
+    }
+
+    private static void DeleteCore(string keyName)
+    {
+        if (!CngKey.Exists(keyName, Provider, CngKeyOpenOptions.Silent)) return;
+        using var key = CngKey.Open(keyName, Provider, CngKeyOpenOptions.Silent);
+        key.Delete(); // supprime et libère
+    }
+
+    private static void TryDelete(string keyName)
+    {
+        try
+        {
+            DeleteCore(keyName);
+        }
+        catch (Exception ex) when (ex is CryptographicException or PlatformNotSupportedException)
+        {
+            Log.Warn($"Clé {keyName} non supprimée de la puce ({ex.Message}).");
+        }
+    }
+
+    private static void EnsureKeyName(string keyName)
+    {
+        // Seules les clés créées par le launcher peuvent être ouvertes ou supprimées.
+        if (!AdminTpmKeyFile.IsValidKeyName(keyName)) throw new ArgumentException("Nom de clé TPM invalide.", nameof(keyName));
+    }
+
+    /// <summary>SHA-1 du code en UTF-16 (sans zéro final) : format attendu par le fournisseur pour l'autorisation d'usage.</summary>
+    private static byte[] UsageAuth(string pin)
+    {
+        var bytes = Encoding.Unicode.GetBytes(pin);
+        try
+        {
+            return SHA1.HashData(bytes);
+        }
+        finally
+        {
+            CryptographicOperations.ZeroMemory(bytes);
+        }
+    }
+
+    // ------------------------------------------------------------------ Protection anti-essais
+
+    /// <summary>
+    /// Lit l'état de la protection anti-essais par la commande TPM2_GetCapability (lecture seule,
+    /// sans autorisation), envoyée par le service TPM de Windows (TBS). Null si la lecture est
+    /// impossible (pas de puce, commande réservée aux administrateurs sur ce PC…).
+    /// </summary>
+    public TpmLockoutInfo? GetLockoutInfo()
+    {
+        if (!OperatingSystem.IsWindowsVersionAtLeast(10)) return null;
+        var context = IntPtr.Zero;
+        try
+        {
+            var parameters = new TbsContextParams2 { Version = 2, Flags = 1u << 2 }; // TBS_CONTEXT_VERSION_TWO, includeTpm20
+            if (Tbsi_Context_Create(ref parameters, out context) != 0) return null;
+
+            // TPM2_GetCapability(TPM_CAP_TPM_PROPERTIES, TPM_PT_PERMANENT…TPM_PT_LOCKOUT_RECOVERY)
+            const uint FirstProperty = 0x200, PropertyCount = 0x12;
+            var command = new byte[22];
+            BinaryPrimitives.WriteUInt16BigEndian(command.AsSpan(0), 0x8001);     // TPM_ST_NO_SESSIONS
+            BinaryPrimitives.WriteUInt32BigEndian(command.AsSpan(2), 22);         // taille
+            BinaryPrimitives.WriteUInt32BigEndian(command.AsSpan(6), 0x0000017A); // TPM_CC_GetCapability
+            BinaryPrimitives.WriteUInt32BigEndian(command.AsSpan(10), 6);         // TPM_CAP_TPM_PROPERTIES
+            BinaryPrimitives.WriteUInt32BigEndian(command.AsSpan(14), FirstProperty);
+            BinaryPrimitives.WriteUInt32BigEndian(command.AsSpan(18), PropertyCount);
+
+            var response = new byte[512];
+            var length = (uint)response.Length;
+            if (Tbsip_Submit_Command(context, 0, 200, command, (uint)command.Length, response, ref length) != 0) return null;
+            var data = response.AsSpan(0, (int)Math.Min(length, (uint)response.Length));
+            if (data.Length < 19 || BinaryPrimitives.ReadUInt32BigEndian(data[6..]) != 0) return null; // code retour TPM
+            if (BinaryPrimitives.ReadUInt32BigEndian(data[11..]) != 6) return null;
+            var count = BinaryPrimitives.ReadUInt32BigEndian(data[15..]);
+
+            uint? permanent = null, counter = null, maxTries = null, interval = null;
+            for (var i = 0; i < count && 19 + (i + 1) * 8 <= data.Length; i++)
+            {
+                var entry = data.Slice(19 + i * 8, 8);
+                var value = BinaryPrimitives.ReadUInt32BigEndian(entry[4..]);
+                switch (BinaryPrimitives.ReadUInt32BigEndian(entry))
+                {
+                    case 0x200: permanent = value; break; // TPM_PT_PERMANENT
+                    case 0x20E: counter = value; break;   // TPM_PT_LOCKOUT_COUNTER
+                    case 0x20F: maxTries = value; break;  // TPM_PT_MAX_AUTH_FAIL
+                    case 0x210: interval = value; break;  // TPM_PT_LOCKOUT_INTERVAL (secondes)
+                }
+            }
+            if (counter is null || maxTries is null || interval is null) return null;
+            var inLockout = permanent is { } attributes && (attributes & (1u << 2)) != 0; // TPMA_PERMANENT.inLockout
+            return new TpmLockoutInfo((int)Math.Min(counter.Value, int.MaxValue), (int)Math.Min(maxTries.Value, int.MaxValue),
+                                      TimeSpan.FromSeconds(interval.Value), inLockout);
+        }
+        catch (Exception ex) when (ex is DllNotFoundException or EntryPointNotFoundException or ArgumentOutOfRangeException)
+        {
+            return null;
+        }
+        finally
+        {
+            if (context != IntPtr.Zero) Tbsip_Context_Close(context);
+        }
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct TbsContextParams2
+    {
+        public uint Version;
+        public uint Flags;
+    }
+
+    [DllImport("tbs.dll", ExactSpelling = true)]
+    [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
+    private static extern uint Tbsi_Context_Create(ref TbsContextParams2 parameters, out IntPtr context);
+
+    [DllImport("tbs.dll", ExactSpelling = true)]
+    [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
+    private static extern uint Tbsip_Submit_Command(IntPtr context, uint locality, uint priority, byte[] command, uint commandLength,
+                                                    byte[] result, ref uint resultLength);
+
+    [DllImport("tbs.dll", ExactSpelling = true)]
+    [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
+    private static extern uint Tbsip_Context_Close(IntPtr context);
+
+    // ------------------------------------------------------------------ Messages
+
+    private static class Codes
+    {
+        // Code PIN refusé par la puce (codes TPM normalisés, voir Normalize) ou par le fournisseur.
+        public const uint TpmAuthFail = 0x8028008E, TpmBadAuth = 0x802800A2, Tpm12AuthFail = 0x80280001, Tpm12Auth2Fail = 0x8028001D,
+                          PcpAuthenticationFailed = 0x80290408;
+        // Protection anti-essais active.
+        public const uint TpmLockout = 0x80280921, TpmDefendLockRunning = 0x80280803;
+        // Clé absente, ou plus chargeable (puce réinitialisée, profil Windows itinérant…).
+        public const uint BadKeyset = 0x80090016, NoKey = 0x8009000D, NotFound = 0x80090011,
+                          PcpWrongParent = 0x8029040E, PcpKeyNotLoaded = 0x8029040F;
+        // Puce absente, désactivée ou pas prête.
+        public const uint TbsTpmNotFound = 0x8028400F, TbsServiceNotRunning = 0x80284008, TbsServiceDisabled = 0x80284010,
+                          PcpDeviceNotReady = 0x80290401, DeviceNotReady = 0x80090030, DeviceNotFound = 0x80090035,
+                          ProviderNotFound = 0x8009001F, ProviderDllNotFound = 0x8009001D;
+        // Algorithme non géré (TPM 1.2 : pas de courbes elliptiques).
+        public const uint NotSupported = 0x80090029, BadAlgId = 0x80090008, TpmCurve = 0x802800A6;
+    }
+
+    /// <summary>
+    /// Code Windows d'origine (les exceptions décrites ci-dessous enveloppent l'erreur réelle).
+    /// Codes TPM 2.0 « format 1 » (0x8028_0xxx avec le bit 0x080) : les bits qui désignent la session
+    /// ou le paramètre en cause sont retirés (ex. 0x8028098E → 0x8028008E, code PIN refusé).
+    /// </summary>
+    private static uint CodeOf(Exception ex)
+    {
+        for (Exception? current = ex; current is not null; current = current.InnerException)
+        {
+            if (current is not CryptographicException || (uint)current.HResult >> 16 == 0x8013) continue; // code .NET générique
+            var hr = (uint)current.HResult;
+            if ((hr & 0xFFFFF000) == 0x80280000 && (hr & 0x80) != 0) hr = 0x80280000 | 0x80 | (hr & 0x3F);
+            return hr;
+        }
+        return (uint)ex.HResult;
+    }
+
+    /// <summary>Message français, en conservant l'erreur d'origine (et son code) comme cause.</summary>
+    private static CryptographicException Wrap(string message, CryptographicException ex) => new(message, ex);
+
+    private static CryptographicException Describe(CryptographicException ex) => CodeOf(ex) switch
+    {
+        Codes.TpmAuthFail or Codes.TpmBadAuth or Codes.Tpm12AuthFail or Codes.Tpm12Auth2Fail or Codes.PcpAuthenticationFailed =>
+            new TpmPinException("Code PIN incorrect. Après plusieurs erreurs, la puce se bloque temporairement (protection anti-essais).",
+                                isLockedOut: false, ex),
+        Codes.TpmLockout or Codes.TpmDefendLockRunning =>
+            new TpmPinException("Trop de codes PIN faux : la puce de sécurité est temporairement bloquée.", isLockedOut: true, ex),
+        Codes.BadKeyset or Codes.NoKey or Codes.NotFound or Codes.PcpWrongParent or Codes.PcpKeyNotLoaded =>
+            Wrap("Clé introuvable ou inutilisable dans la puce de ce PC (autre PC, autre compte Windows, puce réinitialisée ou " +
+                 "Windows réinstallé ?). Utilisez une autre clé, ou demandez une nouvelle invitation.", ex),
+        _ when ex.InnerException is null && (uint)ex.HResult >> 16 == 0x8013 => ex, // message déjà rédigé ici (ex. clé différente)
+        _ => Wrap(DescribeUnavailable(ex), ex)
+    };
+
+    private static string DescribeUnavailable(CryptographicException ex) => CodeOf(ex) switch
+    {
+        Codes.TbsTpmNotFound or Codes.DeviceNotFound or Codes.ProviderNotFound or Codes.ProviderDllNotFound =>
+            "Aucune puce de sécurité (TPM) détectée sur ce PC.",
+        Codes.TbsServiceNotRunning or Codes.TbsServiceDisabled or Codes.PcpDeviceNotReady or Codes.DeviceNotReady =>
+            "La puce de sécurité (TPM) de ce PC n'est pas prête (désactivée dans le BIOS/UEFI ou service arrêté).",
+        Codes.NotSupported or Codes.BadAlgId or Codes.TpmCurve =>
+            "La puce de sécurité de ce PC ne gère pas les clés ECDSA P-256 (TPM 2.0 nécessaire).",
+        Codes.TpmLockout or Codes.TpmDefendLockRunning =>
+            "La puce de sécurité est temporairement bloquée (protection anti-essais). Réessayez plus tard.",
+        var code => $"Puce de sécurité (TPM) inutilisable : {(ex.InnerException ?? ex).Message} (code 0x{code:X8})."
+    };
+
+    // ------------------------------------------------------------------ Signataire
+
+    /// <summary>Clé ouverte dans la puce : elle signe (dans la puce), la poignée est fermée au verrouillage.</summary>
+    private sealed class TpmSigner : IDisposableAdminSigner
+    {
+        private readonly ECDsaCng _ecdsa;
+        private readonly SemaphoreSlim _gate = new(1, 1);
+        private int _disposed;
+
+        public TpmSigner(CngKey key)
+        {
+            PublicKey = ReadPublicKey(key);
+            KeyId = AdminKeys.ComputeKeyId(PublicKey);
+            _ecdsa = new ECDsaCng(key);
+            key.Dispose(); // ECDsaCng garde sa propre référence sur la même poignée (code PIN compris)
+        }
+
+        public byte[] PublicKey { get; }
+        public string KeyId { get; }
+
+        /// <summary>Signature immédiate (appelant déjà hors du fil de l'interface).</summary>
+        public byte[] SignNow(byte[] message)
+        {
+            ObjectDisposedException.ThrowIf(Volatile.Read(ref _disposed) != 0, this);
+            return _ecdsa.SignData(message, HashAlgorithmName.SHA256); // IEEE P1363, 64 octets
+        }
+
+        /// <summary>
+        /// Signature dans la puce (lente) : hors du fil de l'interface, une à la fois. L'erreur éventuelle
+        /// est relancée ici, pas dans Task.Run (pas d'arrêt du débogueur sur une erreur gérée).
+        /// </summary>
+        public async ValueTask<byte[]> SignAsync(byte[] message, CancellationToken ct = default)
+        {
+            ObjectDisposedException.ThrowIf(Volatile.Read(ref _disposed) != 0, this);
+            await _gate.WaitAsync(ct).ConfigureAwait(false);
+            try
+            {
+                ExceptionDispatchInfo? failure = null;
+                var signature = await Task.Run(() =>
+                {
+                    try
+                    {
+                        return SignNow(message);
+                    }
+                    catch (Exception ex)
+                    {
+                        failure = ExceptionDispatchInfo.Capture(ex is CryptographicException crypto ? Describe(crypto) : ex);
+                        return null;
+                    }
+                }, ct).ConfigureAwait(false);
+                failure?.Throw();
+                return signature!;
+            }
+            finally
+            {
+                _gate.Release();
+            }
+        }
+
+        /// <summary>
+        /// Clé publique lue au format brut de Windows (BCRYPT_ECCKEY_BLOB : « ECS1 », 32, X, Y), puis
+        /// encodée en SPKI : ne dépend pas des propriétés facultatives du fournisseur de la puce.
+        /// </summary>
+        internal static byte[] ReadPublicKey(CngKey key)
+        {
+            const uint EcdsaP256PublicMagic = 0x31534345; // « ECS1 »
+            const uint EcdsaGenericPublicMagic = 0x50444345; // « ECDP »
+            var blob = key.Export(CngKeyBlobFormat.EccPublicBlob);
+            var magic = blob.Length >= 4 ? BinaryPrimitives.ReadUInt32LittleEndian(blob) : 0;
+            if (blob.Length != 8 + 64 || magic is not (EcdsaP256PublicMagic or EcdsaGenericPublicMagic) ||
+                BinaryPrimitives.ReadUInt32LittleEndian(blob.AsSpan(4)) != 32)
+                throw new CryptographicException("La puce n'a pas renvoyé une clé publique ECDSA P-256.");
+            using var ec = ECDsa.Create(new ECParameters
+            {
+                Curve = ECCurve.NamedCurves.nistP256,
+                Q = new ECPoint { X = blob[8..40], Y = blob[40..72] }
+            });
+            return AdminKeys.ParsePublicKey(Convert.ToBase64String(ec.ExportSubjectPublicKeyInfo()));
+        }
+
+        public void Dispose()
+        {
+            if (Interlocked.Exchange(ref _disposed, 1) != 0) return;
+            _ecdsa.Dispose();
+        }
+    }
+}

src/GameLauncher/Platform/WpfUiDispatcher.cs

@@ -0,0 +1,14 @@
+using System.Windows.Threading;
+using GameLauncher.Modules;
+
+namespace GameLauncher.Platform;
+
+/// <summary>Exécution sur le fil de l'interface WPF.</summary>
+public sealed class WpfUiDispatcher : IUiDispatcher
+{
+    private readonly Dispatcher _dispatcher;
+
+    public WpfUiDispatcher(Dispatcher dispatcher) => _dispatcher = dispatcher;
+
+    public void Post(Action action) => _dispatcher.InvokeAsync(action);
+}

src/GameLauncher/Services/AdminWindowService.cs

@@ -0,0 +1,114 @@
+using System.IO;
+using System.Windows;
+using GameLauncher.ApiClient;
+using GameLauncher.Core.Models;
+using GameLauncher.Core.Utils;
+using GameLauncher.Modules;
+using GameLauncher.Modules.Admin.ViewModels;
+using GameLauncher.Platform;
+using GameLauncher.Views;
+using GameLauncher.Views.Admin;
+
+namespace GameLauncher.Services;
+
+/// <summary>
+/// Ouverture du menu d'administration (accès discret depuis la fenêtre principale).
+/// Une seule fenêtre à la fois ; la fermer déconnecte la session et efface la clé de la mémoire.
+/// Sans adresse d'API dans launcher.json (« apiUrl »), le menu n'existe pas.
+/// </summary>
+public sealed class AdminWindowService : IDisposable
+{
+    private readonly Window _owner;
+    private readonly ModuleCatalog _modules;
+    private readonly LauncherCatalog _declared;
+    private readonly IReadOnlyList<string> _themes;
+    private readonly string _settingsPath;
+    private readonly string _launcherVersion;
+    private readonly Uri? _apiUrl;
+    private readonly string? _apiUrlError;
+    private LauncherApiClient? _client;
+    private AdminWindow? _window;
+
+    /// <param name="apiUrl">Adresse de l'API (null : menu indisponible).</param>
+    /// <param name="apiUrlError">Si l'adresse configurée a été ignorée (invalide), la raison, affichée à l'ouverture.</param>
+    /// <param name="catalog">Configuration active (dossier des données du launcher).</param>
+    /// <param name="declared">Jeux déclarés dans launcher.json, avant le catalogue (valeurs par défaut de la page « Jeux »).</param>
+    /// <param name="themes">Thèmes intégrés au launcher (seuls choix possibles dans le catalogue).</param>
+    public AdminWindowService(Window owner, ModuleCatalog modules, LauncherCatalog catalog, LauncherCatalog declared, string? apiUrl,
+                              string? apiUrlError, string launcherVersion, IReadOnlyList<string> themes)
+    {
+        _owner = owner;
+        _modules = modules;
+        _declared = declared;
+        _themes = themes;
+        _settingsPath = Path.Combine(catalog.DataDirectory, "admin.json");
+        _launcherVersion = launcherVersion;
+        _apiUrl = apiUrl is null ? null : new Uri(apiUrl, UriKind.Absolute);
+        _apiUrlError = apiUrlError;
+    }
+
+    public bool IsAvailable => _apiUrl is not null;
+
+    /// <summary>Ouvre la fenêtre (ou la ramène au premier plan si elle est déjà ouverte).</summary>
+    public void Open()
+    {
+        if (_window is not null)
+        {
+            if (_window.WindowState == WindowState.Minimized) _window.WindowState = WindowState.Normal;
+            _window.Activate();
+            return;
+        }
+
+        if (_apiUrl is null)
+        {
+            Log.Info("Administration demandée, mais aucune adresse d'API (apiUrl) dans launcher.json.");
+            ModernDialog.ShowMessage(_owner.IsVisible ? _owner : null, "Administration indisponible",
+                _apiUrlError ?? "Ce launcher n'est relié à aucun serveur d'administration (« apiUrl » absent de launcher.json).",
+                _apiUrlError is null ? DialogKind.Info : DialogKind.Warning);
+            return;
+        }
+
+        try
+        {
+            _client ??= new LauncherApiClient(_apiUrl, $"GameLauncher/{_launcherVersion}");
+            AdminWindow? window = null;
+            var shell = new AdminShellViewModel(new AdminEnvironment
+            {
+                Client = _client,
+                Modules = _modules,
+                Games = _declared.DeclaredGames,
+                LauncherName = _declared.DeclaredLauncherName,
+                DefaultGameId = _declared.DeclaredDefaultGameId,
+                Themes = _themes,
+                Dialogs = new ModuleDialogs(() => window),
+                Ui = new WpfUiDispatcher(_owner.Dispatcher),
+                Tpm = new TpmKeyStore(), // clés dans la puce de sécurité : proposées après vérification réelle de la puce
+                SettingsPath = _settingsPath,
+                LauncherVersion = _launcherVersion
+            });
+            window = new AdminWindow(shell);
+            if (_owner.IsVisible) window.Owner = _owner;
+            else window.WindowStartupLocation = WindowStartupLocation.CenterScreen;
+            window.Closed += (_, _) => _window = null;
+            _window = window;
+            Log.Info("Ouverture du menu d'administration.");
+            window.Show();
+            window.Activate();
+        }
+        catch (Exception ex)
+        {
+            _window = null;
+            Log.Error("Ouverture du menu d'administration", ex);
+            ModernDialog.ShowMessage(_owner.IsVisible ? _owner : null, "Administration indisponible", ex.Message, DialogKind.Error);
+        }
+    }
+
+    /// <summary>Fermeture du launcher : la fenêtre se ferme (déconnexion, clé effacée).</summary>
+    public void Close() => _window?.Close();
+
+    /// <remarks>
+    /// Le client HTTP n'est pas libéré ici : la déconnexion du serveur, lancée par la fermeture de la
+    /// fenêtre, a ainsi une chance de partir avant la fin du processus (la clé, elle, est déjà effacée).
+    /// </remarks>
+    public void Dispose() => Close();
+}

src/GameLauncher/Services/ThemeManager.cs

@@ -61,8 +61,16 @@ public static class ThemeManager
         return dictionary.Contains(key) ? dictionary[key] : null;
     }
 
+    /// <summary>
+    /// Plus grande dimension (pixels) d'une image de fond une fois chargée : une image plus grande
+    /// (fond du catalogue, par exemple) est réduite au chargement pour borner la mémoire utilisée.
+    /// </summary>
+    public const int MaxBackgroundSize = 3840;
+
     /// <summary>Charge une image depuis un chemin (absolu ou relatif au launcher). Null si absente/invalide.</summary>
-    public static ImageSource? LoadImage(string? path, int decodeWidth = 0)
+    /// <param name="decodeWidth">Largeur imposée au chargement (0 : taille de l'image).</param>
+    /// <param name="maxSize">Sans largeur imposée : plus grande dimension autorisée (0 : aucune limite).</param>
+    public static ImageSource? LoadImage(string? path, int decodeWidth = 0, int maxSize = 0)
     {
         if (string.IsNullOrWhiteSpace(path)) return null;
         try
@@ -78,7 +86,22 @@ public static class ThemeManager
             image.BeginInit();
             image.CacheOption = BitmapCacheOption.OnLoad; // ne garde pas le fichier ouvert
             image.UriSource = new Uri(full, UriKind.Absolute);
-            if (decodeWidth > 0) image.DecodePixelWidth = decodeWidth;
+            if (decodeWidth > 0)
+            {
+                image.DecodePixelWidth = decodeWidth;
+            }
+            else if (maxSize > 0)
+            {
+                // Dimensions lues dans l'en-tête, sans décoder l'image : réduction proportionnelle si besoin.
+                int width, height;
+                using (var stream = File.OpenRead(full))
+                {
+                    var frame = BitmapDecoder.Create(stream, BitmapCreateOptions.DelayCreation, BitmapCacheOption.None).Frames[0];
+                    (width, height) = (frame.PixelWidth, frame.PixelHeight);
+                }
+                if (width >= height && width > maxSize) image.DecodePixelWidth = maxSize;
+                else if (height > width && height > maxSize) image.DecodePixelHeight = maxSize;
+            }
             image.EndInit();
             image.Freeze();
             return image;
@@ -108,7 +131,7 @@ public static class ThemeManager
             if (specific is not null) result.MergedDictionaries.Add(specific);
         }
 
-        var background = LoadImage(backgroundOverride);
+        var background = LoadImage(backgroundOverride, maxSize: MaxBackgroundSize);
         if (background is not null) result["BackgroundImage"] = background;
 
         Cache[cacheKey] = result;

src/GameLauncher/Themes/Controls.xaml

@@ -459,6 +459,170 @@
         </Setter>
     </Style>
 
+    <!-- Champ texte sur plusieurs lignes (description) : même apparence que ModernTextBoxStyle -->
+    <Style x:Key="ModernMultilineTextBoxStyle" TargetType="TextBox" BasedOn="{StaticResource ModernTextBoxStyle}">
+        <Setter Property="Height" Value="Auto" />
+        <Setter Property="MinHeight" Value="96" />
+        <Setter Property="MaxHeight" Value="220" />
+        <Setter Property="Padding" Value="12,10" />
+        <Setter Property="AcceptsReturn" Value="True" />
+        <Setter Property="TextWrapping" Value="Wrap" />
+        <Setter Property="VerticalContentAlignment" Value="Top" />
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="TextBox">
+                    <Border x:Name="Bd" CornerRadius="12" Background="{TemplateBinding Background}"
+                            BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="1">
+                        <ScrollViewer x:Name="PART_ContentHost" Margin="{TemplateBinding Padding}" Focusable="False"
+                                      HorizontalScrollBarVisibility="Disabled" VerticalScrollBarVisibility="Auto" />
+                    </Border>
+                    <ControlTemplate.Triggers>
+                        <Trigger Property="IsMouseOver" Value="True">
+                            <Setter TargetName="Bd" Property="BorderBrush" Value="#55FFFFFF" />
+                        </Trigger>
+                        <Trigger Property="IsKeyboardFocused" Value="True">
+                            <Setter TargetName="Bd" Property="BorderBrush" Value="{DynamicResource Accent2Brush}" />
+                        </Trigger>
+                    </ControlTemplate.Triggers>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <!-- ============================================================ Liste déroulante arrondie -->
+    <Style x:Key="ModernComboBoxItemStyle" TargetType="ComboBoxItem">
+        <Setter Property="Foreground" Value="{DynamicResource TextPrimaryBrush}" />
+        <Setter Property="FontSize" Value="13" />
+        <Setter Property="Cursor" Value="Hand" />
+        <Setter Property="FocusVisualStyle" Value="{x:Null}" />
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="ComboBoxItem">
+                    <Border x:Name="Bd" CornerRadius="9" Padding="10,8" Margin="0,1" Background="Transparent">
+                        <ContentPresenter VerticalAlignment="Center" />
+                    </Border>
+                    <ControlTemplate.Triggers>
+                        <Trigger Property="IsHighlighted" Value="True">
+                            <Setter TargetName="Bd" Property="Background" Value="{DynamicResource SurfaceHoverBrush}" />
+                        </Trigger>
+                        <Trigger Property="IsSelected" Value="True">
+                            <Setter TargetName="Bd" Property="Background" Value="{DynamicResource SurfaceAltBrush}" />
+                            <Setter Property="Foreground" Value="{DynamicResource Accent2Brush}" />
+                        </Trigger>
+                    </ControlTemplate.Triggers>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <Style x:Key="ModernComboBoxToggleStyle" TargetType="ToggleButton">
+        <Setter Property="Focusable" Value="False" />
+        <Setter Property="ClickMode" Value="Press" />
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="ToggleButton">
+                    <Border x:Name="Bd" CornerRadius="12" Background="{DynamicResource InputBrush}"
+                            BorderBrush="{DynamicResource BorderStrongBrush}" BorderThickness="1">
+                        <Path x:Name="Arrow" Width="10" Height="10" Margin="0,0,14,0" Stretch="Uniform"
+                              HorizontalAlignment="Right" VerticalAlignment="Center"
+                              Fill="{DynamicResource TextSecondaryBrush}" Data="M 0 0 L 5 5 L 10 0 Z" />
+                    </Border>
+                    <ControlTemplate.Triggers>
+                        <Trigger Property="IsMouseOver" Value="True">
+                            <Setter TargetName="Bd" Property="BorderBrush" Value="#55FFFFFF" />
+                        </Trigger>
+                        <Trigger Property="IsChecked" Value="True">
+                            <Setter TargetName="Bd" Property="BorderBrush" Value="{DynamicResource Accent2Brush}" />
+                            <Setter TargetName="Arrow" Property="Fill" Value="{DynamicResource Accent2Brush}" />
+                        </Trigger>
+                    </ControlTemplate.Triggers>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <Style x:Key="ModernComboBoxStyle" TargetType="ComboBox">
+        <Setter Property="Foreground" Value="{DynamicResource TextPrimaryBrush}" />
+        <Setter Property="FontSize" Value="13" />
+        <Setter Property="Height" Value="40" />
+        <Setter Property="Cursor" Value="Hand" />
+        <Setter Property="FocusVisualStyle" Value="{x:Null}" />
+        <Setter Property="ItemContainerStyle" Value="{StaticResource ModernComboBoxItemStyle}" />
+        <Setter Property="MaxDropDownHeight" Value="280" />
+        <Setter Property="ScrollViewer.CanContentScroll" Value="False" />
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="ComboBox">
+                    <Grid>
+                        <ToggleButton x:Name="Toggle" Style="{StaticResource ModernComboBoxToggleStyle}"
+                                      IsChecked="{Binding IsDropDownOpen, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}" />
+                        <ContentPresenter Margin="12,0,34,0" VerticalAlignment="Center" HorizontalAlignment="Left" IsHitTestVisible="False"
+                                          Content="{TemplateBinding SelectionBoxItem}"
+                                          ContentTemplate="{TemplateBinding SelectionBoxItemTemplate}"
+                                          ContentTemplateSelector="{TemplateBinding ItemTemplateSelector}"
+                                          ContentStringFormat="{TemplateBinding SelectionBoxItemStringFormat}" />
+                        <Popup x:Name="PART_Popup" Placement="Bottom" AllowsTransparency="True" Focusable="False"
+                               PopupAnimation="Fade" VerticalOffset="4"
+                               IsOpen="{Binding IsDropDownOpen, RelativeSource={RelativeSource TemplatedParent}}">
+                            <Border Margin="0,0,8,10" Padding="5" CornerRadius="12" SnapsToDevicePixels="True"
+                                    MinWidth="{Binding ActualWidth, RelativeSource={RelativeSource TemplatedParent}}"
+                                    MaxHeight="{TemplateBinding MaxDropDownHeight}"
+                                    Background="{DynamicResource MenuBrush}" BorderBrush="{DynamicResource BorderStrongBrush}" BorderThickness="1">
+                                <Border.Effect>
+                                    <DropShadowEffect BlurRadius="18" ShadowDepth="4" Direction="270" Opacity="0.5" Color="Black" />
+                                </Border.Effect>
+                                <ScrollViewer VerticalScrollBarVisibility="Auto" HorizontalScrollBarVisibility="Disabled">
+                                    <ItemsPresenter KeyboardNavigation.DirectionalNavigation="Contained" />
+                                </ScrollViewer>
+                            </Border>
+                        </Popup>
+                    </Grid>
+                    <ControlTemplate.Triggers>
+                        <Trigger Property="IsEnabled" Value="False">
+                            <Setter Property="Opacity" Value="0.45" />
+                        </Trigger>
+                    </ControlTemplate.Triggers>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <!-- Champ de phrase de passe : même apparence que ModernTextBoxStyle (administration) -->
+    <Style x:Key="ModernPasswordBoxStyle" TargetType="PasswordBox">
+        <Setter Property="Foreground" Value="{DynamicResource TextPrimaryBrush}" />
+        <Setter Property="Background" Value="{DynamicResource InputBrush}" />
+        <Setter Property="BorderBrush" Value="{DynamicResource BorderStrongBrush}" />
+        <Setter Property="CaretBrush" Value="{DynamicResource TextPrimaryBrush}" />
+        <Setter Property="SelectionBrush" Value="{DynamicResource AccentBrush}" />
+        <Setter Property="FontSize" Value="13" />
+        <Setter Property="Padding" Value="12,0" />
+        <Setter Property="Height" Value="40" />
+        <Setter Property="VerticalContentAlignment" Value="Center" />
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="PasswordBox">
+                    <Border x:Name="Bd" CornerRadius="12" Background="{TemplateBinding Background}"
+                            BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="1">
+                        <ScrollViewer x:Name="PART_ContentHost" Margin="{TemplateBinding Padding}"
+                                      VerticalAlignment="Center" Focusable="False"
+                                      HorizontalScrollBarVisibility="Hidden" VerticalScrollBarVisibility="Hidden" />
+                    </Border>
+                    <ControlTemplate.Triggers>
+                        <Trigger Property="IsMouseOver" Value="True">
+                            <Setter TargetName="Bd" Property="BorderBrush" Value="#55FFFFFF" />
+                        </Trigger>
+                        <Trigger Property="IsKeyboardFocused" Value="True">
+                            <Setter TargetName="Bd" Property="BorderBrush" Value="{DynamicResource Accent2Brush}" />
+                        </Trigger>
+                        <Trigger Property="IsEnabled" Value="False">
+                            <Setter Property="Opacity" Value="0.5" />
+                        </Trigger>
+                    </ControlTemplate.Triggers>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
     <!-- ============================================================ Menu contextuel arrondi -->
     <Style TargetType="ContextMenu">
         <Setter Property="Foreground" Value="{DynamicResource TextPrimaryBrush}" />

src/GameLauncher/Themes/Icons.xaml

@@ -44,4 +44,51 @@
     <Geometry x:Key="Icon.ArrowRight">M4,11V13H16L10.5,18.5L11.92,19.92L19.84,12L11.92,4.08L10.5,5.5L16,11H4Z</Geometry>
     <Geometry x:Key="Icon.LinkOff">M17,7H13V8.9H17C18.71,8.9 20.1,10.29 20.1,12C20.1,13.43 19.12,14.63 17.79,15L19.25,16.44C20.88,15.61 22,13.95 22,12A5,5 0 0,0 17,7M16,11H13.81L15.81,13H16V11M2,4.27L5.11,7.38C3.29,8.12 2,9.91 2,12A5,5 0 0,0 7,17H11V15.1H7C5.29,15.1 3.9,13.71 3.9,12C3.9,10.41 5.11,9.1 6.66,8.93L8.73,11H8V13H10.73L13,15.27V17H14.73L18.74,21L20,19.74L3.27,3L2,4.27Z</Geometry>
 
+    <!-- Administration (module Admin) -->
+    <Geometry x:Key="Icon.ShieldAccount">M12,1L3,5V11C3,16.55 6.84,21.74 12,23C17.16,21.74 21,16.55 21,11V5L12,1M12,5A3,3 0 0,1 15,8A3,3 0 0,1 12,11A3,3 0 0,1 9,8A3,3 0 0,1 12,5M17.13,17C15.92,18.85 14.11,20.24 12,20.92C9.89,20.24 8.08,18.85 6.87,17C6.53,16.5 6.24,16 6,15.47C6,13.82 8.71,12.47 12,12.47C15.29,12.47 18,13.79 18,15.47C17.76,16 17.47,16.5 17.13,17Z</Geometry>
+    <Geometry x:Key="Icon.Lock">M12,17A2,2 0 0,0 14,15C14,13.89 13.1,13 12,13A2,2 0 0,0 10,15A2,2 0 0,0 12,17M18,8A2,2 0 0,1 20,10V20A2,2 0 0,1 18,22H6A2,2 0 0,1 4,20V10C4,8.89 4.9,8 6,8H7V6A5,5 0 0,1 12,1A5,5 0 0,1 17,6V8H18M12,3A3,3 0 0,0 9,6V8H15V6A3,3 0 0,0 12,3Z</Geometry>
+    <Geometry x:Key="Icon.LockOpenVariant">M18 1C15.24 1 13 3.24 13 6V8H4C2.9 8 2 8.89 2 10V20C2 21.11 2.9 22 4 22H16C17.11 22 18 21.11 18 20V10C18 8.9 17.11 8 16 8H15V6C15 4.34 16.34 3 18 3C19.66 3 21 4.34 21 6V8H23V6C23 3.24 20.76 1 18 1M10 13C11.1 13 12 13.89 12 15C12 16.11 11.11 17 10 17C8.9 17 8 16.11 8 15C8 13.9 8.9 13 10 13Z</Geometry>
+    <Geometry x:Key="Icon.KeyVariant">M22,18V22H18V19H15V16H12L9.74,13.74C9.19,13.91 8.61,14 8,14A6,6 0 0,1 2,8A6,6 0 0,1 8,2A6,6 0 0,1 14,8C14,8.61 13.91,9.19 13.74,9.74L22,18M7,5A2,2 0 0,0 5,7A2,2 0 0,0 7,9A2,2 0 0,0 9,7A2,2 0 0,0 7,5Z</Geometry>
+    <Geometry x:Key="Icon.KeyPlus">M7.5 3C9.5 3 11.1 4.2 11.7 6H21V9H18V12H15V9H11.7C11.1 10.8 9.4 12 7.5 12C5 12 3 10 3 7.5S5 3 7.5 3M7.5 6C6.7 6 6 6.7 6 7.5S6.7 9 7.5 9 9 8.3 9 7.5 8.3 6 7.5 6M8 17H11V14H13V17H16V19H13V22H11V19H8V17Z</Geometry>
+    <Geometry x:Key="Icon.FileKey">M11 16C11 16.6 10.6 17 10 17S9 16.6 9 16C9 15.4 9.4 15 10 15S11 15.4 11 16M20 8V20C20 21.1 19.1 22 18 22H6C4.9 22 4 21.1 4 20V4C4 2.9 4.9 2 6 2H14M18 15H12.8C12.2 13.4 10.5 12.6 9 13.2C7.4 13.8 6.6 15.5 7.2 17S9.5 19.4 11 18.8C11.9 18.5 12.5 17.8 12.8 17H14V19H16V17H18M18.5 9L13 3.5V9H18.5Z</Geometry>
+    <Geometry x:Key="Icon.AccountCircle">M12,19.2C9.5,19.2 7.29,17.92 6,16C6.03,14 10,12.9 12,12.9C14,12.9 17.97,14 18,16C16.71,17.92 14.5,19.2 12,19.2M12,5A3,3 0 0,1 15,8A3,3 0 0,1 12,11A3,3 0 0,1 9,8A3,3 0 0,1 12,5M12,2A10,10 0 0,0 2,12A10,10 0 0,0 12,22A10,10 0 0,0 22,12C22,6.47 17.5,2 12,2Z</Geometry>
+    <Geometry x:Key="Icon.Login">M11 7L9.6 8.4L12.2 11H2V13H12.2L9.6 15.6L11 17L16 12L11 7M20 19H12V21H20C21.1 21 22 20.1 22 19V5C22 3.9 21.1 3 20 3H12V5H20V19Z</Geometry>
+    <Geometry x:Key="Icon.Logout">M17 7L15.59 8.41L18.17 11H8V13H18.17L15.59 15.58L17 17L22 12M4 5H12V3H4C2.9 3 2 3.9 2 5V19C2 20.1 2.9 21 4 21H12V19H4V5Z</Geometry>
+    <Geometry x:Key="Icon.ViewDashboard">M13,3V9H21V3M13,21H21V11H13M3,21H11V15H3M3,13H11V3H3V13Z</Geometry>
+    <Geometry x:Key="Icon.Server">M4,1H20A1,1 0 0,1 21,2V6A1,1 0 0,1 20,7H4A1,1 0 0,1 3,6V2A1,1 0 0,1 4,1M4,9H20A1,1 0 0,1 21,10V14A1,1 0 0,1 20,15H4A1,1 0 0,1 3,14V10A1,1 0 0,1 4,9M4,17H20A1,1 0 0,1 21,18V22A1,1 0 0,1 20,23H4A1,1 0 0,1 3,22V18A1,1 0 0,1 4,17M9,5H10V3H9V5M9,13H10V11H9V13M9,21H10V19H9V21M5,3V5H7V3H5M5,11V13H7V11H5M5,19V21H7V19H5Z</Geometry>
+    <Geometry x:Key="Icon.ContentCopy">M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z</Geometry>
+    <Geometry x:Key="Icon.Fingerprint">M17.81,4.47C17.73,4.47 17.65,4.45 17.58,4.41C15.66,3.42 14,3 12,3C10.03,3 8.15,3.47 6.44,4.41C6.2,4.54 5.9,4.45 5.76,4.21C5.63,3.97 5.72,3.66 5.96,3.53C7.82,2.5 9.86,2 12,2C14.14,2 16,2.47 18.04,3.5C18.29,3.65 18.38,3.95 18.25,4.19C18.16,4.37 18,4.47 17.81,4.47M3.5,9.72C3.4,9.72 3.3,9.69 3.21,9.63C3,9.47 2.93,9.16 3.09,8.93C4.08,7.53 5.34,6.43 6.84,5.66C10,4.04 14,4.03 17.15,5.65C18.65,6.42 19.91,7.5 20.9,8.9C21.06,9.12 21,9.44 20.78,9.6C20.55,9.76 20.24,9.71 20.08,9.5C19.18,8.22 18.04,7.23 16.69,6.54C13.82,5.07 10.15,5.07 7.29,6.55C5.93,7.25 4.79,8.25 3.89,9.5C3.81,9.65 3.66,9.72 3.5,9.72M9.75,21.79C9.62,21.79 9.5,21.74 9.4,21.64C8.53,20.77 8.06,20.21 7.39,19C6.7,17.77 6.34,16.27 6.34,14.66C6.34,11.69 8.88,9.27 12,9.27C15.12,9.27 17.66,11.69 17.66,14.66A0.5,0.5 0 0,1 17.16,15.16A0.5,0.5 0 0,1 16.66,14.66C16.66,12.24 14.57,10.27 12,10.27C9.43,10.27 7.34,12.24 7.34,14.66C7.34,16.1 7.66,17.43 8.27,18.5C8.91,19.66 9.35,20.15 10.12,20.93C10.31,21.13 10.31,21.44 10.12,21.64C10,21.74 9.88,21.79 9.75,21.79M16.92,19.94C15.73,19.94 14.68,19.64 13.82,19.05C12.33,18.04 11.44,16.4 11.44,14.66A0.5,0.5 0 0,1 11.94,14.16A0.5,0.5 0 0,1 12.44,14.66C12.44,16.07 13.16,17.4 14.38,18.22C15.09,18.7 15.92,18.93 16.92,18.93C17.16,18.93 17.56,18.9 17.96,18.83C18.23,18.78 18.5,18.96 18.54,19.24C18.59,19.5 18.41,19.77 18.13,19.82C17.56,19.93 17.06,19.94 16.92,19.94M14.91,22C14.87,22 14.82,22 14.78,22C13.19,21.54 12.15,20.95 11.06,19.88C9.66,18.5 8.89,16.64 8.89,14.66C8.89,13.04 10.27,11.72 11.97,11.72C13.67,11.72 15.05,13.04 15.05,14.66C15.05,15.73 16,16.6 17.13,16.6C18.28,16.6 19.21,15.73 19.21,14.66C19.21,10.89 15.96,7.83 11.96,7.83C9.12,7.83 6.5,9.41 5.35,11.86C4.96,12.67 4.76,13.62 4.76,14.66C4.76,15.44 4.83,16.67 5.43,18.27C5.53,18.53 5.4,18.82 5.14,18.91C4.88,19 4.59,18.87 4.5,18.62C4,17.31 3.77,16 3.77,14.66C3.77,13.46 4,12.37 4.45,11.42C5.78,8.63 8.73,6.82 11.96,6.82C16.5,6.82 20.21,10.33 20.21,14.65C20.21,16.27 18.83,17.59 17.13,17.59C15.43,17.59 14.05,16.27 14.05,14.65C14.05,13.58 13.12,12.71 11.97,12.71C10.82,12.71 9.89,13.58 9.89,14.65C9.89,16.36 10.55,17.96 11.76,19.16C12.71,20.1 13.62,20.62 15.03,21C15.3,21.08 15.45,21.36 15.38,21.62C15.33,21.85 15.12,22 14.91,22Z</Geometry>
+    <Geometry x:Key="Icon.TicketAccount">M20,12A2,2 0 0,0 22,14V18A2,2 0 0,1 20,20H4A2,2 0 0,1 2,18V14C3.11,14 4,13.1 4,12A2,2 0 0,0 2,10V6C2,4.89 2.9,4 4,4H20A2,2 0 0,1 22,6V10A2,2 0 0,0 20,12M16.5,16.25C16.5,14.75 13.5,14 12,14C10.5,14 7.5,14.75 7.5,16.25V17H16.5V16.25M12,12.25A2.25,2.25 0 0,0 14.25,10A2.25,2.25 0 0,0 12,7.75A2.25,2.25 0 0,0 9.75,10A2.25,2.25 0 0,0 12,12.25Z</Geometry>
+    <Geometry x:Key="Icon.ClockOutline">M12,20A8,8 0 0,0 20,12A8,8 0 0,0 12,4A8,8 0 0,0 4,12A8,8 0 0,0 12,20M12,2A10,10 0 0,1 22,12A10,10 0 0,1 12,22C6.47,22 2,17.5 2,12A10,10 0 0,1 12,2M12.5,7V12.25L17,14.92L16.25,16.15L11,13V7H12.5Z</Geometry>
+    <Geometry x:Key="Icon.FolderKey">M4 4C2.9 4 2 4.9 2 6V18C2 19.1 2.9 20 4 20H20C21.1 20 22 19.1 22 18V8C22 6.9 21.1 6 20 6H12L10 4M11 10C12.3 10 13.4 10.8 13.8 12H20V14H18V16H16V14H13.8C13.4 15.2 12.3 16 11 16C9.3 16 8 14.7 8 13S9.3 10 11 10M11 12C10.4 12 10 12.4 10 13C10 13.6 10.4 14 11 14C11.6 14 12 13.6 12 13S11.6 12 11 12Z</Geometry>
+    <Geometry x:Key="Icon.ArrowLeft">M20,11V13H8L13.5,18.5L12.08,19.92L4.16,12L12.08,4.08L13.5,5.5L8,11H20Z</Geometry>
+    <Geometry x:Key="Icon.ChevronRight">M8.59,16.58L13.17,12L8.59,7.41L10,6L16,12L10,18L8.59,16.58Z</Geometry>
+    <Geometry x:Key="Icon.AccountGroup">M12,5.5A3.5,3.5 0 0,1 15.5,9A3.5,3.5 0 0,1 12,12.5A3.5,3.5 0 0,1 8.5,9A3.5,3.5 0 0,1 12,5.5M5,8C5.56,8 6.08,8.15 6.53,8.42C6.38,9.85 6.8,11.27 7.66,12.38C7.16,13.34 6.16,14 5,14A3,3 0 0,1 2,11A3,3 0 0,1 5,8M19,8A3,3 0 0,1 22,11A3,3 0 0,1 19,14C17.84,14 16.84,13.34 16.34,12.38C17.2,11.27 17.62,9.85 17.47,8.42C17.92,8.15 18.44,8 19,8M5.5,18.25C5.5,16.18 8.41,14.5 12,14.5C15.59,14.5 18.5,16.18 18.5,18.25V20H5.5V18.25M0,20V18.5C0,17.11 1.89,15.94 4.45,15.6C3.86,16.28 3.5,17.22 3.5,18.25V20H0M24,20H20.5V18.25C20.5,17.22 20.14,16.28 19.55,15.6C22.11,15.94 24,17.11 24,18.5V20Z</Geometry>
+    <Geometry x:Key="Icon.AccountKey">M11 10V12H9V14H7V12H5.8C5.4 13.2 4.3 14 3 14C1.3 14 0 12.7 0 11S1.3 8 3 8C4.3 8 5.4 8.8 5.8 10H11M3 10C2.4 10 2 10.4 2 11S2.4 12 3 12 4 11.6 4 11 3.6 10 3 10M16 14C18.7 14 24 15.3 24 18V20H8V18C8 15.3 13.3 14 16 14M16 12C13.8 12 12 10.2 12 8S13.8 4 16 4 20 5.8 20 8 18.2 12 16 12Z</Geometry>
+    <Geometry x:Key="Icon.ShieldKey">M12,8A1,1 0 0,1 13,9A1,1 0 0,1 12,10A1,1 0 0,1 11,9A1,1 0 0,1 12,8M21,11C21,16.55 17.16,21.74 12,23C6.84,21.74 3,16.55 3,11V5L12,1L21,5V11M12,6A3,3 0 0,0 9,9C9,10.31 9.83,11.42 11,11.83V18H13V16H15V14H13V11.83C14.17,11.42 15,10.31 15,9A3,3 0 0,0 12,6Z</Geometry>
+    <Geometry x:Key="Icon.EmailOutline">M22 6C22 4.9 21.1 4 20 4H4C2.9 4 2 4.9 2 6V18C2 19.1 2.9 20 4 20H20C21.1 20 22 19.1 22 18V6M20 6L12 11L4 6H20M20 18H4V8L12 13L20 8V18Z</Geometry>
+    <Geometry x:Key="Icon.Chip">M6,4H18V5H21V7H18V9H21V11H18V13H21V15H18V17H21V19H18V20H6V19H3V17H6V15H3V13H6V11H3V9H6V7H3V5H6V4M11,15V18H12V15H11M13,15V18H14V15H13M15,15V18H16V15H15Z</Geometry>
+    <Geometry x:Key="Icon.FileLockOutline">M18 13C16.6 13 15.2 14.1 15.2 15.5V17C14.6 17 14 17.6 14 18.2V21.7C14 22.4 14.6 23 15.2 23H20.7C21.4 23 22 22.4 22 21.8V18.3C22 17.6 21.4 17 20.8 17V15.5C20.8 14.1 19.4 13 18 13M18 14.2C18.8 14.2 19.5 14.7 19.5 15.5V17H16.5V15.5C16.5 14.7 17.2 14.2 18 14.2M6 2C4.9 2 4 2.9 4 4V20C4 21.1 4.9 22 6 22H12V20H6V4H13V9H18V11C18.7 11 19.4 11.2 20 11.4V8L14 2H6Z</Geometry>
+    <Geometry x:Key="Icon.BadgeAccountHorizontal">M22,4H14V7H10V4H2A2,2 0 0,0 0,6V20A2,2 0 0,0 2,22H22A2,2 0 0,0 24,20V6A2,2 0 0,0 22,4M8,9A2,2 0 0,1 10,11A2,2 0 0,1 8,13A2,2 0 0,1 6,11A2,2 0 0,1 8,9M12,17H4V16C4,14.67 6.67,14 8,14C9.33,14 12,14.67 12,16V17M20,18H14V16H20V18M20,14H14V12H20V14M20,10H14V8H20V10M13,6H11V2H13V6Z</Geometry>
+
+    <!-- Catalogue des jeux (liens, page « Jeux ») : icônes génériques, pas de logos de marques -->
+    <Geometry x:Key="Icon.Forum">M17,12V3A1,1 0 0,0 16,2H3A1,1 0 0,0 2,3V17L6,13H16A1,1 0 0,0 17,12M21,6H19V15H6V17A1,1 0 0,0 7,18H18L22,22V7A1,1 0 0,0 21,6Z</Geometry>
+    <Geometry x:Key="Icon.PlayCircleOutline">M12,20C7.59,20 4,16.41 4,12C4,7.59 7.59,4 12,4C16.41,4 20,7.59 20,12C20,16.41 16.41,20 12,20M12,2A10,10 0 0,0 2,12A10,10 0 0,0 12,22A10,10 0 0,0 22,12A10,10 0 0,0 12,2M10,16.5L16,12L10,7.5V16.5Z</Geometry>
+    <Geometry x:Key="Icon.At">M12,15C12.81,15 13.5,14.7 14.11,14.11C14.7,13.5 15,12.81 15,12C15,11.19 14.7,10.5 14.11,9.89C13.5,9.3 12.81,9 12,9C11.19,9 10.5,9.3 9.89,9.89C9.3,10.5 9,11.19 9,12C9,12.81 9.3,13.5 9.89,14.11C10.5,14.7 11.19,15 12,15M12,2C14.75,2 17.1,3 19.05,4.95C21,6.9 22,9.25 22,12V13.45C22,14.45 21.65,15.3 21,16C20.3,16.67 19.5,17 18.5,17C17.3,17 16.31,16.5 15.56,15.5C14.56,16.5 13.38,17 12,17C10.63,17 9.45,16.5 8.46,15.54C7.5,14.55 7,13.38 7,12C7,10.63 7.5,9.45 8.46,8.46C9.45,7.5 10.63,7 12,7C13.38,7 14.55,7.5 15.54,8.46C16.5,9.45 17,10.63 17,12V13.45C17,13.86 17.16,14.22 17.46,14.53C17.76,14.84 18.11,15 18.5,15C18.92,15 19.27,14.84 19.57,14.53C19.87,14.22 20,13.86 20,13.45V12C20,9.81 19.23,7.93 17.65,6.35C16.07,4.77 14.19,4 12,4C9.81,4 7.93,4.77 6.35,6.35C4.77,7.93 4,9.81 4,12C4,14.19 4.77,16.07 6.35,17.65C7.93,19.23 9.81,20 12,20H17V22H12C9.25,22 6.9,21 4.95,19.05C3,17.1 2,14.75 2,12C2,9.25 3,6.9 4.95,4.95C6.9,3 9.25,2 12,2Z</Geometry>
+    <Geometry x:Key="Icon.Broadcast">M12 10C10.9 10 10 10.9 10 12S10.9 14 12 14 14 13.1 14 12 13.1 10 12 10M18 12C18 8.7 15.3 6 12 6S6 8.7 6 12C6 14.2 7.2 16.1 9 17.2L10 15.5C8.8 14.8 8 13.5 8 12.1C8 9.9 9.8 8.1 12 8.1S16 9.9 16 12.1C16 13.6 15.2 14.9 14 15.5L15 17.2C16.8 16.2 18 14.2 18 12M12 2C6.5 2 2 6.5 2 12C2 15.7 4 18.9 7 20.6L8 18.9C5.6 17.5 4 14.9 4 12C4 7.6 7.6 4 12 4S20 7.6 20 12C20 15 18.4 17.5 16 18.9L17 20.6C20 18.9 22 15.7 22 12C22 6.5 17.5 2 12 2Z</Geometry>
+    <Geometry x:Key="Icon.LinkVariant">M10.59,13.41C11,13.8 11,14.44 10.59,14.83C10.2,15.22 9.56,15.22 9.17,14.83C7.22,12.88 7.22,9.71 9.17,7.76V7.76L12.71,4.22C14.66,2.27 17.83,2.27 19.78,4.22C21.73,6.17 21.73,9.34 19.78,11.29L18.29,12.78C18.3,11.96 18.17,11.14 17.89,10.36L18.36,9.88C19.54,8.71 19.54,6.81 18.36,5.64C17.19,4.46 15.29,4.46 14.12,5.64L10.59,9.17C9.41,10.34 9.41,12.24 10.59,13.41M13.41,9.17C13.8,8.78 14.44,8.78 14.83,9.17C16.78,11.12 16.78,14.29 14.83,16.24V16.24L11.29,19.78C9.34,21.73 6.17,21.73 4.22,19.78C2.27,17.83 2.27,14.66 4.22,12.71L5.71,11.22C5.7,12.04 5.83,12.86 6.11,13.65L5.64,14.12C4.46,15.29 4.46,17.19 5.64,18.36C6.81,19.54 8.71,19.54 9.88,18.36L13.41,14.83C14.59,13.66 14.59,11.76 13.41,10.59C13,10.2 13,9.56 13.41,9.17Z</Geometry>
+    <Geometry x:Key="Icon.OpenInNew">M14,3V5H17.59L7.76,14.83L9.17,16.24L19,6.41V10H21V3M19,19H5V5H12V3H5C3.89,3 3,3.9 3,5V19A2,2 0 0,0 5,21H19A2,2 0 0,0 21,19V12H19V19Z</Geometry>
+    <Geometry x:Key="Icon.ImageOutline">M19,19H5V5H19M19,3H5A2,2 0 0,0 3,5V19A2,2 0 0,0 5,21H19A2,2 0 0,0 21,19V5A2,2 0 0,0 19,3M13.96,12.29L11.21,15.83L9.25,13.47L6.5,17H17.5L13.96,12.29Z</Geometry>
+    <Geometry x:Key="Icon.EyeOffOutline">M2,5.27L3.28,4L20,20.72L18.73,22L15.65,18.92C14.5,19.3 13.28,19.5 12,19.5C7,19.5 2.73,16.39 1,12C1.69,10.24 2.79,8.69 4.19,7.46L2,5.27M12,9A3,3 0 0,1 15,12C15,12.35 14.94,12.69 14.83,13L11,9.17C11.31,9.06 11.65,9 12,9M12,4.5C17,4.5 21.27,7.61 23,12C22.18,14.08 20.79,15.88 19,17.19L17.58,15.76C18.94,14.82 20.06,13.54 20.82,12C19.17,8.64 15.76,6.5 12,6.5C10.91,6.5 9.84,6.68 8.84,7L7.3,5.47C8.74,4.85 10.33,4.5 12,4.5M3.18,12C4.83,15.36 8.24,17.5 12,17.5C12.69,17.5 13.37,17.43 14,17.29L11.72,15C10.29,14.85 9.15,13.71 9,12.28L5.6,8.87C4.61,9.72 3.78,10.78 3.18,12Z</Geometry>
+    <Geometry x:Key="Icon.ArrowUp">M13,20H11V8L5.5,13.5L4.08,12.08L12,4.16L19.92,12.08L18.5,13.5L13,8V20Z</Geometry>
+    <Geometry x:Key="Icon.ArrowDown">M11,4H13V16L18.5,10.5L19.92,11.92L12,19.84L4.08,11.92L5.5,10.5L11,16V4Z</Geometry>
+    <Geometry x:Key="Icon.TextBoxOutline">M5,3C3.89,3 3,3.89 3,5V19C3,20.11 3.89,21 5,21H19C20.11,21 21,20.11 21,19V5C21,3.89 20.11,3 19,3H5M5,5H19V19H5V5M7,7V9H17V7H7M7,11V13H17V11H7M7,15V17H14V15H7Z</Geometry>
+    <Geometry x:Key="Icon.Restore">M13,3A9,9 0 0,0 4,12H1L4.89,15.89L4.96,16.03L9,12H6A7,7 0 0,1 13,5A7,7 0 0,1 20,12A7,7 0 0,1 13,19C11.07,19 9.32,18.21 8.06,16.94L6.64,18.36C8.27,20 10.5,21 13,21A9,9 0 0,0 22,12A9,9 0 0,0 13,3Z</Geometry>
+    <Geometry x:Key="Icon.ContentSaveOutline">M17 3H5C3.89 3 3 3.9 3 5V19C3 20.1 3.89 21 5 21H19C20.1 21 21 20.1 21 19V7L17 3M19 19H5V5H16.17L19 7.83V19M12 12C10.34 12 9 13.34 9 15S10.34 18 12 18 15 16.66 15 15 13.66 12 12 12M6 6H15V10H6V6Z</Geometry>
+
+    <!-- Publication d'une version (phase 5) -->
+    <Geometry x:Key="Icon.CloudUpload">M14,13V17H10V13H7L12,8L17,13M19.35,10.03C18.67,6.59 15.64,4 12,4C9.11,4 6.6,5.64 5.35,8.03C2.34,8.36 0,10.9 0,14A6,6 0 0,0 6,20H19A5,5 0 0,0 24,15C24,12.36 21.95,10.22 19.35,10.03Z</Geometry>
+    <Geometry x:Key="Icon.Pause">M14,19H18V5H14M6,19H10V5H6V19Z</Geometry>
+    <Geometry x:Key="Icon.PackageVariant">M2,10.96C1.5,10.68 1.35,10.07 1.63,9.59L3.13,7C3.24,6.8 3.41,6.66 3.6,6.58L11.43,2.18C11.59,2.06 11.79,2 12,2C12.21,2 12.41,2.06 12.57,2.18L20.47,6.62C20.66,6.72 20.82,6.88 20.91,7.08L22.36,9.6C22.64,10.08 22.47,10.69 22,10.96L21,11.54V16.5C21,16.88 20.79,17.21 20.47,17.38L12.57,21.82C12.41,21.94 12.21,22 12,22C11.79,22 11.59,21.94 11.43,21.82L3.53,17.38C3.21,17.21 3,16.88 3,16.5V10.96C2.7,11.13 2.32,11.14 2,10.96M12,4.15V4.15L12,10.85V10.85L17.96,7.5L12,4.15M5,15.91L11,19.29V12.58L5,9.21V15.91M19,15.91V12.69L14,15.59C13.67,15.77 13.3,15.76 13,15.6V19.29L19,15.91M13.04,13.36L20.03,9.27L19.5,8.35L12.51,12.45L13.04,13.36Z</Geometry>
+
 </ResourceDictionary>

src/GameLauncher/ViewModels/GameViewModel.cs

@@ -3,6 +3,7 @@ using System.Diagnostics;
 using System.IO;
 using System.Net;
 using System.Net.Http;
+using GameLauncher.Contracts.Changelog;
 using GameLauncher.Core.Models;
 using GameLauncher.Core.Services;
 using GameLauncher.Core.Utils;
@@ -111,7 +112,8 @@ public sealed class GameViewModel : ObservableObject, IDisposable
 
     public LauncherConfig Config => _config;
     public string GameId => _config.GameId;
-    public string GameName => _config.GameName;
+    /// <summary>Nom affiché (catalogue, sinon launcher.json). Le raccourci et le registre gardent celui de launcher.json.</summary>
+    public string GameName => _config.ShownName;
     public string ThemeName => string.IsNullOrWhiteSpace(_config.Theme) ? "default" : _config.Theme;
 
     /// <summary>Initiales affichées dans la vignette quand le jeu n'a pas d'icône ("Exovival Zombie Reborn" → "EZR").</summary>
@@ -149,6 +151,17 @@ public sealed class GameViewModel : ObservableObject, IDisposable
     }
     public string Publisher => _config.Publisher;
     public string Tagline => _config.Tagline;
+
+    /// <summary>Présentation du jeu (catalogue).</summary>
+    public string? Description => _config.Description;
+    public bool HasDescription => !string.IsNullOrWhiteSpace(_config.Description);
+
+    /// <summary>Liens du catalogue (Discord, YouTube…), adresses https contrôlées.</summary>
+    public IReadOnlyList<GameLinkItem> Links => _links ??= _config.Links
+        .Select(l => new GameLinkItem(l.Label, l.Url, GameLinkItem.IconFor(l.Kind), new RelayCommand(() => _window.OpenUrl(l.Url))))
+        .ToList();
+    private IReadOnlyList<GameLinkItem>? _links;
+    public bool HasLinks => _config.Links.Count > 0;
     public string LauncherVersion { get; }
     public bool HasWebsite => !string.IsNullOrWhiteSpace(_config.WebsiteUrl);
     public bool IsExitConfirmed { get; private set; }
@@ -692,7 +705,8 @@ public sealed class GameViewModel : ObservableObject, IDisposable
             return;
         }
 
-        var options = _dialogs.AskInstallOptions(GameName,
+        // Nom de launcher.json (jamais celui du catalogue) : il sert aussi au sous-dossier d'installation.
+        var options = _dialogs.AskInstallOptions(_config.GameName,
             _lastInstallDirectory ?? _config.ExpandedDefaultInstallDirectory,
             manifest.Archive.Size, manifest.Archive.Size + manifest.TotalSize);
         if (options is null) return;
@@ -1502,3 +1516,18 @@ public sealed class GameViewModel : ObservableObject, IDisposable
         _lifetime.Dispose();
     }
 }
+
+/// <summary>Lien affiché sous la présentation du jeu (icône intégrée générique, jamais une image distante).</summary>
+public sealed record GameLinkItem(string Label, string Url, string IconKey, System.Windows.Input.ICommand OpenCommand)
+{
+    public static string IconFor(string kind) => kind switch
+    {
+        "website" => "Web",
+        "discord" => "Forum",
+        "youtube" => "PlayCircleOutline",
+        "x" => "At",
+        "twitch" => "Broadcast",
+        "steam" => "Gamepad",
+        _ => "LinkVariant"
+    };
+}

src/GameLauncher/ViewModels/LauncherUpdateViewModel.cs

@@ -1,3 +1,4 @@
+using GameLauncher.Contracts.Changelog;
 using GameLauncher.Core.Models;
 using GameLauncher.Core.SelfUpdate;
 using GameLauncher.Mvvm;

src/GameLauncher/Views/Admin/AdminWindow.xaml

@@ -0,0 +1,164 @@
+<Window x:Class="GameLauncher.Views.Admin.AdminWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:ui="clr-namespace:GameLauncher.Controls"
+        xmlns:local="clr-namespace:GameLauncher.Views.Admin"
+        xmlns:avm="clr-namespace:GameLauncher.Modules.Admin.ViewModels;assembly=GameLauncher.Modules.Admin"
+        Title="{Binding WindowTitle}"
+        Width="1080"
+        Height="720"
+        WindowStyle="None"
+        AllowsTransparency="True"
+        Background="Transparent"
+        ResizeMode="CanMinimize"
+        WindowStartupLocation="CenterOwner"
+        Icon="/Assets/launcher.ico"
+        FontFamily="{DynamicResource UiFont}"
+        Foreground="{DynamicResource TextPrimaryBrush}"
+        UseLayoutRounding="True"
+        TextOptions.TextFormattingMode="Ideal">
+
+    <!--
+        Menu d'administration (accès discret : Ctrl+Maj+Alt+A, ou 5 clics rapides sur le logo).
+        Un seul écran à la fois, selon AdminShellViewModel.Screen :
+          • LoginViewModel        → choix de la clé + phrase de passe ;
+          • EnrollViewModel       → « J'ai une invitation » (création de clé, empreinte à communiquer) ;
+          • AdminWorkspaceViewModel → navigation entre les pages des modules + page affichée.
+    -->
+    <Window.Resources>
+        <DataTemplate DataType="{x:Type avm:LoginViewModel}">
+            <local:LoginView />
+        </DataTemplate>
+
+        <DataTemplate DataType="{x:Type avm:EnrollViewModel}">
+            <local:EnrollView />
+        </DataTemplate>
+
+        <!-- ================================================= Espace d'administration (connecté) -->
+        <DataTemplate DataType="{x:Type avm:AdminWorkspaceViewModel}">
+            <Grid>
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="250" />
+                    <ColumnDefinition Width="*" />
+                </Grid.ColumnDefinitions>
+
+                <!-- Navigation -->
+                <Border Background="{DynamicResource RailBrush}" CornerRadius="0,0,0,20"
+                        BorderBrush="{DynamicResource BorderBrush}" BorderThickness="0,0,1,0">
+                    <DockPanel Margin="16,20,16,18">
+                        <!-- Compte connecté -->
+                        <Grid DockPanel.Dock="Top" Margin="4,0,0,22">
+                            <Grid.ColumnDefinitions>
+                                <ColumnDefinition Width="Auto" />
+                                <ColumnDefinition Width="*" />
+                            </Grid.ColumnDefinitions>
+                            <Border Style="{StaticResource AdminAvatarStyle}">
+                                <TextBlock Text="{Binding Initials}" Style="{StaticResource AdminAvatarTextStyle}" />
+                            </Border>
+                            <StackPanel Grid.Column="1" Margin="12,0,0,0" VerticalAlignment="Center">
+                                <TextBlock Text="{Binding DisplayName}" FontSize="13.5" FontWeight="SemiBold" TextTrimming="CharacterEllipsis" />
+                                <TextBlock Text="{Binding RoleText}" FontSize="11.5" Foreground="{DynamicResource TextMutedBrush}" />
+                            </StackPanel>
+                        </Grid>
+
+                        <!-- Session : verrouillage -->
+                        <StackPanel DockPanel.Dock="Bottom">
+                            <Border Height="1" Background="{DynamicResource BorderBrush}" Margin="0,0,0,14" />
+                            <StackPanel Orientation="Horizontal" Margin="4,0,0,4">
+                                <Path Width="13" Height="13" Stretch="Uniform" Fill="{DynamicResource TextMutedBrush}"
+                                      Data="{StaticResource Icon.ClockOutline}" VerticalAlignment="Center" />
+                                <TextBlock Text="{Binding SessionText}" FontSize="11.5" Margin="8,0,0,0"
+                                           Foreground="{DynamicResource TextMutedBrush}" />
+                            </StackPanel>
+                            <StackPanel Orientation="Horizontal" Margin="4,0,0,14">
+                                <Path Width="13" Height="13" Stretch="Uniform" Fill="{DynamicResource TextMutedBrush}"
+                                      Data="{StaticResource Icon.KeyVariant}" VerticalAlignment="Center" />
+                                <TextBlock Text="{Binding KeyLabel}" FontSize="11.5" Margin="8,0,0,0" TextTrimming="CharacterEllipsis"
+                                           Foreground="{DynamicResource TextMutedBrush}" />
+                            </StackPanel>
+                            <Button Style="{StaticResource SecondaryButtonStyle}" HorizontalAlignment="Stretch" Content="Verrouiller"
+                                    ui:IconAssist.Icon="{StaticResource Icon.Lock}" Command="{Binding LockCommand}"
+                                    ToolTip="Ferme la session et efface la clé de la mémoire (Ctrl+L)" />
+                        </StackPanel>
+
+                        <TextBlock DockPanel.Dock="Top" Text="ADMINISTRATION" Style="{StaticResource SectionTitleStyle}" Margin="6,0,0,10" />
+                        <ListBox ItemsSource="{Binding PanelItems}" SelectedItem="{Binding SelectedPanel, Mode=TwoWay}"
+                                 ItemContainerStyle="{StaticResource AdminNavItemStyle}"
+                                 Background="Transparent" BorderThickness="0" Padding="0"
+                                 ScrollViewer.HorizontalScrollBarVisibility="Disabled"
+                                 ScrollViewer.VerticalScrollBarVisibility="Auto" />
+                    </DockPanel>
+                </Border>
+
+                <!-- Page affichée -->
+                <DockPanel Grid.Column="1" Margin="32,22,18,18">
+                    <StackPanel DockPanel.Dock="Top" Margin="0,0,14,18">
+                        <TextBlock Text="{Binding PanelTitle}" FontSize="22" FontWeight="SemiBold" />
+                        <TextBlock Text="{Binding PanelDescription}" FontSize="12.5" Margin="0,4,0,0" TextWrapping="Wrap"
+                                   Foreground="{DynamicResource TextSecondaryBrush}" />
+                    </StackPanel>
+                    <ScrollViewer VerticalScrollBarVisibility="Auto" Focusable="False" Padding="0,0,14,0">
+                        <!-- Modèle choisi selon le type de la page (Themes/Admin.xaml) -->
+                        <ContentControl Content="{Binding SelectedPanel.ViewModel}" Focusable="False" />
+                    </ScrollViewer>
+                </DockPanel>
+            </Grid>
+        </DataTemplate>
+    </Window.Resources>
+
+    <Grid Margin="20">
+        <!-- Ombre portée -->
+        <Border CornerRadius="20" Background="{DynamicResource BackgroundBrush}">
+            <Border.Effect>
+                <DropShadowEffect BlurRadius="32" ShadowDepth="8" Direction="270" Opacity="0.6" Color="Black" />
+            </Border.Effect>
+        </Border>
+
+        <Border CornerRadius="20" Background="{DynamicResource SurfaceSolidBrush}"
+                BorderBrush="{DynamicResource WindowBorderBrush}" BorderThickness="1">
+            <Grid>
+                <Grid.RowDefinitions>
+                    <RowDefinition Height="64" />
+                    <RowDefinition Height="*" />
+                </Grid.RowDefinitions>
+
+                <!-- Barre de titre -->
+                <Grid Background="Transparent" Margin="22,0,14,0" MouseLeftButtonDown="OnTitleBarMouseDown">
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="*" />
+                        <ColumnDefinition Width="Auto" />
+                    </Grid.ColumnDefinitions>
+                    <Border Width="36" Height="36" CornerRadius="11" Background="{DynamicResource AccentGradientBrush}">
+                        <Path Data="{StaticResource Icon.ShieldAccount}" Fill="{DynamicResource OnAccentBrush}"
+                              Width="19" Height="19" Stretch="Uniform" />
+                    </Border>
+                    <StackPanel Grid.Column="1" Margin="12,0,0,0" VerticalAlignment="Center">
+                        <TextBlock Text="Administration" FontSize="15" FontWeight="SemiBold" />
+                        <TextBlock FontSize="11" Foreground="{DynamicResource TextMutedBrush}">
+                            <Run Text="Serveur" />
+                            <Run Text="{Binding ServerHost, Mode=OneWay}" />
+                        </TextBlock>
+                    </StackPanel>
+                    <StackPanel Grid.Column="2" Orientation="Horizontal" VerticalAlignment="Center">
+                        <Border CornerRadius="10" Padding="10,5" Margin="0,0,12,0" Background="{DynamicResource ChipBrush}"
+                                Visibility="{Binding IsLoggedIn, Converter={StaticResource BoolToVisibility}}">
+                            <StackPanel Orientation="Horizontal">
+                                <Ellipse Width="8" Height="8" Fill="{DynamicResource SuccessBrush}" VerticalAlignment="Center" />
+                                <TextBlock Text="Connecté" FontSize="11.5" Margin="7,0,0,0" />
+                            </StackPanel>
+                        </Border>
+                        <Button Style="{StaticResource IconButtonStyle}" ui:IconAssist.Icon="{StaticResource Icon.Minimize}"
+                                ToolTip="Réduire" Click="OnMinimize" />
+                        <Button Style="{StaticResource CloseButtonStyle}" ui:IconAssist.Icon="{StaticResource Icon.Close}"
+                                ToolTip="Fermer (déconnexion)" Margin="4,0,0,0" Click="OnClose" />
+                    </StackPanel>
+                </Grid>
+                <Border Grid.Row="0" Height="1" VerticalAlignment="Bottom" Background="{DynamicResource BorderBrush}" />
+
+                <!-- Écran courant -->
+                <ContentControl Grid.Row="1" Content="{Binding Screen}" Focusable="False" />
+            </Grid>
+        </Border>
+    </Grid>
+</Window>

src/GameLauncher/Views/Admin/AdminWindow.xaml.cs

@@ -0,0 +1,120 @@
+using System.ComponentModel;
+using System.Windows;
+using System.Windows.Input;
+using GameLauncher.Core.Utils;
+using GameLauncher.Modules.Admin.ViewModels;
+using Microsoft.Win32;
+
+namespace GameLauncher.Views.Admin;
+
+/// <summary>
+/// Fenêtre du menu d'administration. Toute la logique est dans <see cref="AdminShellViewModel"/> ;
+/// la fenêtre signale l'activité (report du verrouillage automatique), verrouille quand la session
+/// Windows est verrouillée, et déconnecte à la fermeture (la clé déchiffrée est effacée de la mémoire).
+/// </summary>
+public partial class AdminWindow : Window
+{
+    private readonly AdminShellViewModel _shell;
+    private bool _closed;
+    private Point? _lastMousePosition;
+    private bool _windowsSessionLocked;
+
+    public AdminWindow(AdminShellViewModel shell)
+    {
+        InitializeComponent();
+        _shell = shell;
+        DataContext = shell;
+
+        PreviewMouseMove += OnPreviewMouseMove;
+        PreviewMouseDown += (_, _) => _shell.NotifyActivity();
+        PreviewMouseWheel += (_, _) => _shell.NotifyActivity();
+        PreviewKeyDown += OnPreviewKeyDown;
+        Loaded += (_, _) => FitToScreen();
+
+        // Session Windows verrouillée (Win+L, mise en veille) : l'administration se verrouille aussi.
+        SystemEvents.SessionSwitch += OnSessionSwitch;
+        // Connexion terminée pendant que Windows était verrouillé : verrouillage immédiat.
+        _shell.PropertyChanged += (_, e) =>
+        {
+            if (e.PropertyName == nameof(AdminShellViewModel.IsLoggedIn) && _shell.IsLoggedIn && _windowsSessionLocked)
+                _ = _shell.LockAsync("Verrouillé avec la session Windows.");
+        };
+    }
+
+    /// <summary>
+    /// Seul un VRAI déplacement compte comme activité : WPF envoie aussi des MouseMove « synthétiques »
+    /// quand la mise en page change sous un curseur immobile (texte du temps restant, animations),
+    /// qui empêcheraient sinon le verrouillage automatique.
+    /// </summary>
+    private void OnPreviewMouseMove(object sender, MouseEventArgs e)
+    {
+        var position = PointToScreen(e.GetPosition(this));
+        if (_lastMousePosition is { } last && Math.Abs(last.X - position.X) < 1 && Math.Abs(last.Y - position.Y) < 1) return;
+        _lastMousePosition = position;
+        _shell.NotifyActivity();
+    }
+
+    /// <summary>Jamais plus haute que la zone utile de l'écran (petits écrans, mise à l'échelle 125-150 %).</summary>
+    private void FitToScreen()
+    {
+        var work = SystemParameters.WorkArea;
+        if (Height > work.Height) Height = work.Height;
+        if (Width > work.Width) Width = work.Width;
+        if (Top < work.Top) Top = work.Top;
+        if (Left < work.Left) Left = work.Left;
+    }
+
+    private void OnPreviewKeyDown(object sender, KeyEventArgs e)
+    {
+        _shell.NotifyActivity();
+        if (e.Key == Key.L && Keyboard.Modifiers == ModifierKeys.Control && _shell.IsLoggedIn)
+        {
+            e.Handled = true;
+            _ = _shell.LockAsync("Session verrouillée.");
+        }
+    }
+
+    private void OnSessionSwitch(object sender, SessionSwitchEventArgs e)
+    {
+        var locked = e.Reason is SessionSwitchReason.SessionLock or SessionSwitchReason.ConsoleDisconnect or SessionSwitchReason.RemoteDisconnect;
+        var unlocked = e.Reason is SessionSwitchReason.SessionUnlock or SessionSwitchReason.ConsoleConnect or SessionSwitchReason.RemoteConnect;
+        if (!locked && !unlocked) return;
+        // Événement reçu sur un autre thread.
+        Dispatcher.InvokeAsync(() =>
+        {
+            _windowsSessionLocked = locked;
+            if (locked && !_closed && _shell.IsLoggedIn) _ = _shell.LockAsync("Verrouillé avec la session Windows.");
+        });
+    }
+
+    private void OnTitleBarMouseDown(object sender, MouseButtonEventArgs e)
+    {
+        if (e.ChangedButton == MouseButton.Left && e.ButtonState == MouseButtonState.Pressed)
+            DragMove();
+    }
+
+    private void OnMinimize(object sender, RoutedEventArgs e) => WindowState = WindowState.Minimized;
+
+    private void OnClose(object sender, RoutedEventArgs e) => Close();
+
+    protected override void OnClosing(CancelEventArgs e)
+    {
+        base.OnClosing(e);
+        if (e.Cancel) return;
+        _closed = true;
+        SystemEvents.SessionSwitch -= OnSessionSwitch; // événement statique : sinon la fenêtre ne serait jamais libérée
+    }
+
+    protected override async void OnClosed(EventArgs e)
+    {
+        base.OnClosed(e);
+        try
+        {
+            await _shell.DisposeAsync(); // clé effacée immédiatement, puis déconnexion du serveur
+        }
+        catch (Exception ex)
+        {
+            Log.Error("Administration : fermeture", ex);
+        }
+    }
+}

src/GameLauncher/Views/Admin/EnrollView.xaml

@@ -0,0 +1,212 @@
+<UserControl x:Class="GameLauncher.Views.Admin.EnrollView"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:ui="clr-namespace:GameLauncher.Controls">
+
+    <!--
+        « J'ai une invitation » : la clé est créée sur ce PC (fichier chiffré par la phrase de passe),
+        seule la clé PUBLIQUE est envoyée au serveur avec le code d'invitation. L'empreinte affichée
+        ensuite est à communiquer à la personne qui approuve, par un autre canal (téléphone…).
+    -->
+    <ScrollViewer VerticalScrollBarVisibility="Auto" Focusable="False">
+        <Grid Width="520" Margin="0,24,0,30" HorizontalAlignment="Center" VerticalAlignment="Center">
+
+            <!-- ================================================= Formulaire -->
+            <StackPanel Visibility="{Binding IsForm, Converter={StaticResource BoolToVisibility}}">
+                <Button Style="{StaticResource LinkButtonStyle}" HorizontalAlignment="Left" FontSize="12.5" Margin="0,0,0,18"
+                        Content="Retour à la connexion" ui:IconAssist.Icon="{StaticResource Icon.ArrowLeft}"
+                        Command="{Binding BackCommand}" />
+
+                <Grid Margin="0,0,0,22">
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="*" />
+                    </Grid.ColumnDefinitions>
+                    <Border Width="52" Height="52" CornerRadius="16" Background="{DynamicResource AccentGradientBrush}">
+                        <Path Data="{StaticResource Icon.KeyPlus}" Fill="{DynamicResource OnAccentBrush}" Width="24" Height="24" Stretch="Uniform" />
+                    </Border>
+                    <StackPanel Grid.Column="1" Margin="16,0,0,0" VerticalAlignment="Center">
+                        <TextBlock Text="Créer ma clé d'administrateur" FontSize="20" FontWeight="SemiBold" />
+                        <TextBlock Text="La clé privée reste sur ce PC (fichier chiffré ou puce de sécurité). Seule la clé publique est envoyée."
+                                   FontSize="12.5" Margin="0,4,0,0" TextWrapping="Wrap" Foreground="{DynamicResource TextSecondaryBrush}" />
+                    </StackPanel>
+                </Grid>
+
+                <TextBlock Text="Code d'invitation" Style="{StaticResource AdminFieldLabelStyle}" />
+                <TextBox Style="{StaticResource ModernTextBoxStyle}" Margin="0,0,0,4" CharacterCasing="Upper" MaxLength="64"
+                         FontFamily="Cascadia Mono, Consolas, Courier New" FontSize="14"
+                         Text="{Binding InvitationCode, UpdateSourceTrigger=PropertyChanged}" />
+                <TextBlock Style="{StaticResource AdminHintStyle}" Margin="2,0,0,16"
+                           Text="Reçu de l'administrateur qui vous invite (utilisable une seule fois, valable 24 h par défaut). Laissez vide pour créer seulement la clé (premier propriétaire, déclaré sur le serveur)." />
+
+                <TextBlock Text="Nom de ce PC (visible par les propriétaires)" Style="{StaticResource AdminFieldLabelStyle}" />
+                <TextBox Style="{StaticResource ModernTextBoxStyle}" Margin="0,0,0,16" MaxLength="64"
+                         Text="{Binding KeyLabel, UpdateSourceTrigger=PropertyChanged}" />
+
+                <!-- Rangement de la clé : la puce n'est proposée qu'une fois RÉELLEMENT vérifiée -->
+                <TextBlock Text="Où ranger ma clé ?" Style="{StaticResource AdminFieldLabelStyle}" />
+                <RadioButton Style="{StaticResource AdminChoiceCardStyle}" GroupName="StorageFile" Margin="0,0,0,8"
+                             IsChecked="{Binding UseFile, Mode=TwoWay}" IsEnabled="{Binding CanChooseFile}"
+                             ui:IconAssist.Icon="{StaticResource Icon.FileLockOutline}" Content="Fichier chiffré"
+                             Tag="Protégé par une phrase de passe. Copiable et sauvegardable (clé USB…) : utilisable sur plusieurs PC." />
+                <RadioButton Style="{StaticResource AdminChoiceCardStyle}" GroupName="StorageTpm" Margin="0,0,0,6"
+                             IsChecked="{Binding UseTpm, Mode=TwoWay}" IsEnabled="{Binding CanChooseTpm}"
+                             ui:IconAssist.Icon="{StaticResource Icon.Chip}" Content="Puce de sécurité (TPM) de ce PC"
+                             Tag="Créée dans la puce, protégée par un code PIN : elle ne peut pas être copiée, même par un virus. Liée à ce PC et à votre compte Windows." />
+                <StackPanel Orientation="Horizontal" Margin="4,0,0,18">
+                    <ProgressBar Style="{StaticResource ModernProgressBarStyle}" Width="16" Height="3" IsIndeterminate="True" Margin="0,0,8,0"
+                                 VerticalAlignment="Center" Visibility="{Binding IsCheckingTpm, Converter={StaticResource BoolToVisibility}}" />
+                    <Path Width="13" Height="13" Stretch="Uniform" Margin="0,1,8,0" VerticalAlignment="Top"
+                          Visibility="{Binding IsCheckingTpm, Converter={StaticResource BoolToVisibility}, ConverterParameter=Invert}">
+                        <Path.Style>
+                            <Style TargetType="Path">
+                                <Setter Property="Data" Value="{DynamicResource Icon.Info}" />
+                                <Setter Property="Fill" Value="{DynamicResource TextMutedBrush}" />
+                                <Style.Triggers>
+                                    <DataTrigger Binding="{Binding IsTpmAvailable}" Value="True">
+                                        <Setter Property="Data" Value="{DynamicResource Icon.CheckCircle}" />
+                                        <Setter Property="Fill" Value="{DynamicResource SuccessBrush}" />
+                                    </DataTrigger>
+                                </Style.Triggers>
+                            </Style>
+                        </Path.Style>
+                    </Path>
+                    <TextBlock Text="{Binding TpmStatus}" Style="{StaticResource AdminHintStyle}" MaxWidth="480" />
+                </StackPanel>
+
+                <TextBlock Text="{Binding KeyFileLabel}" Style="{StaticResource AdminFieldLabelStyle}" />
+                <Border Style="{StaticResource AdminCardStyle}" Padding="14,8" Margin="0,0,0,16">
+                    <DockPanel>
+                        <Button DockPanel.Dock="Right" Style="{StaticResource SmallButtonStyle}" Content="Changer…"
+                                ui:IconAssist.Icon="{StaticResource Icon.FolderOpen}" Command="{Binding ChangePathCommand}" />
+                        <Path Width="15" Height="15" Stretch="Uniform" Fill="{DynamicResource Accent2Brush}"
+                              Data="{StaticResource Icon.FileKey}" VerticalAlignment="Center" />
+                        <TextBlock Text="{Binding KeyPath}" Margin="10,0,12,0" VerticalAlignment="Center" FontSize="12.5"
+                                   TextTrimming="CharacterEllipsis" ToolTip="{Binding KeyPath}" />
+                    </DockPanel>
+                </Border>
+
+                <TextBlock Text="{Binding SecretLabel}" Style="{StaticResource AdminFieldLabelStyle}" />
+                <PasswordBox x:Name="PassphraseBox" Style="{StaticResource ModernPasswordBoxStyle}" Margin="0,0,0,16" />
+                <TextBlock Text="{Binding ConfirmationLabel}" Style="{StaticResource AdminFieldLabelStyle}" />
+                <PasswordBox x:Name="ConfirmationBox" Style="{StaticResource ModernPasswordBoxStyle}" Margin="0,0,0,4"
+                             KeyDown="OnConfirmationKeyDown" />
+                <TextBlock Style="{StaticResource AdminHintStyle}" Margin="2,0,0,18" Text="{Binding SecretHint}" />
+
+                <Border Style="{StaticResource AdminErrorBannerStyle}" Visibility="{Binding HasError, Converter={StaticResource BoolToVisibility}}">
+                    <StackPanel Orientation="Horizontal">
+                        <Path Width="15" Height="15" Stretch="Uniform" Fill="{DynamicResource DangerBrush}" Data="{StaticResource Icon.AlertCircle}"
+                              VerticalAlignment="Top" Margin="0,1,0,0" />
+                        <TextBlock Text="{Binding ErrorMessage}" Margin="10,0,0,0" TextWrapping="Wrap" FontSize="12.5" MaxWidth="450" />
+                    </StackPanel>
+                </Border>
+
+                <ProgressBar Style="{StaticResource ModernProgressBarStyle}" Height="3" Margin="0,0,0,12" IsIndeterminate="{Binding IsBusy}"
+                             Visibility="{Binding IsBusy, Converter={StaticResource BoolToVisibility}}" />
+
+                <Button Style="{StaticResource AccentButtonStyle}" Height="44" HorizontalAlignment="Stretch" Content="Créer ma clé"
+                        ui:IconAssist.Icon="{StaticResource Icon.KeyVariant}" Click="OnSubmitClick" />
+            </StackPanel>
+
+            <!-- ================================================= Résultat -->
+            <StackPanel Visibility="{Binding IsDone, Converter={StaticResource BoolToVisibility}}">
+                <Border Width="64" Height="64" CornerRadius="20" HorizontalAlignment="Center" Background="{DynamicResource AccentGradientBrush}">
+                    <Path Data="{StaticResource Icon.ShieldKey}" Fill="{DynamicResource OnAccentBrush}" Width="28" Height="28" Stretch="Uniform" />
+                </Border>
+
+                <!-- Avec invitation : en attente d'approbation -->
+                <StackPanel Visibility="{Binding IsEnrolled, Converter={StaticResource BoolToVisibility}}">
+                    <TextBlock Text="Clé enregistrée, en attente d'approbation" FontSize="20" FontWeight="SemiBold" Margin="0,18,0,0"
+                               HorizontalAlignment="Center" />
+                    <TextBlock Margin="0,6,0,22" HorizontalAlignment="Center" TextAlignment="Center" TextWrapping="Wrap"
+                               FontSize="12.5" Foreground="{DynamicResource TextSecondaryBrush}">
+                        <Run Text="Compte :" />
+                        <Run Text="{Binding AccountName, Mode=OneWay}" FontWeight="SemiBold" Foreground="{DynamicResource TextPrimaryBrush}" />
+                        <LineBreak />
+                        <Run Text="Communiquez l'empreinte ci-dessous à la personne qui approuve, de vive voix ou par un autre canal que celui de l'invitation. Elle la saisira pour approuver votre clé." />
+                    </TextBlock>
+                </StackPanel>
+
+                <!-- Sans invitation : clé seule -->
+                <StackPanel Visibility="{Binding IsKeyOnly, Converter={StaticResource BoolToVisibility}}">
+                    <TextBlock Text="Clé créée sur ce PC" FontSize="20" FontWeight="SemiBold" Margin="0,18,0,0" HorizontalAlignment="Center" />
+                    <TextBlock Margin="0,6,0,22" HorizontalAlignment="Center" TextAlignment="Center" TextWrapping="Wrap"
+                               FontSize="12.5" Foreground="{DynamicResource TextSecondaryBrush}"
+                               Text="Elle n'est encore associée à aucun compte. Premier propriétaire : déclarez la clé publique (.pub) sur le serveur avec la commande add-owner (docs\ADMIN-ARCHITECTURE.md). Clé perdue ou nouveau PC sans invitation : add-key. Sinon, demandez une invitation." />
+                </StackPanel>
+
+                <!-- Invitation envoyée, réponse du serveur perdue : clé conservée -->
+                <StackPanel Visibility="{Binding IsUnconfirmed, Converter={StaticResource BoolToVisibility}}">
+                    <TextBlock Text="Enregistrement non confirmé" FontSize="20" FontWeight="SemiBold" Margin="0,18,0,14" HorizontalAlignment="Center" />
+                    <Border Style="{StaticResource AdminInfoBannerStyle}" BorderBrush="{DynamicResource WarningBrush}">
+                        <StackPanel Orientation="Horizontal">
+                            <Path Width="15" Height="15" Stretch="Uniform" Fill="{DynamicResource WarningBrush}" Data="{StaticResource Icon.Alert}"
+                                  VerticalAlignment="Top" Margin="0,1,0,0" />
+                            <TextBlock Text="{Binding UnconfirmedText}" Margin="10,0,0,0" TextWrapping="Wrap" FontSize="12.5" MaxWidth="450" />
+                        </StackPanel>
+                    </Border>
+                </StackPanel>
+
+                <!-- Empreinte -->
+                <Border Style="{StaticResource AdminCardStyle}" Padding="20,16">
+                    <Grid>
+                        <Grid.ColumnDefinitions>
+                            <ColumnDefinition Width="Auto" />
+                            <ColumnDefinition Width="*" />
+                            <ColumnDefinition Width="Auto" />
+                        </Grid.ColumnDefinitions>
+                        <Path Width="26" Height="26" Stretch="Uniform" Fill="{DynamicResource Accent2Brush}" Data="{StaticResource Icon.Fingerprint}"
+                              VerticalAlignment="Center" />
+                        <StackPanel Grid.Column="1" Margin="16,0,12,0" VerticalAlignment="Center">
+                            <TextBlock Text="EMPREINTE DE LA CLÉ" Style="{StaticResource SectionTitleStyle}" Margin="0,0,0,4" />
+                            <TextBlock Text="{Binding Fingerprint}" Style="{StaticResource FingerprintTextStyle}" />
+                        </StackPanel>
+                        <Button Grid.Column="2" Style="{StaticResource SmallButtonStyle}" Content="Copier" VerticalAlignment="Center"
+                                ui:IconAssist.Icon="{StaticResource Icon.ContentCopy}" Command="{Binding CopyFingerprintCommand}" />
+                    </Grid>
+                </Border>
+
+                <!-- Fichiers -->
+                <Border Style="{StaticResource AdminCardStyle}" Padding="20,14">
+                    <StackPanel>
+                        <!-- Clé dans la puce -->
+                        <StackPanel Orientation="Horizontal" Margin="0,0,0,10"
+                                    Visibility="{Binding IsTpmKey, Converter={StaticResource BoolToVisibility}}">
+                            <Path Width="15" Height="15" Stretch="Uniform" Fill="{DynamicResource SuccessBrush}" Data="{StaticResource Icon.Chip}"
+                                  VerticalAlignment="Center" />
+                            <TextBlock Text="Clé rangée dans la puce de sécurité (TPM) de ce PC : elle ne peut pas être copiée."
+                                       Margin="8,0,0,0" FontSize="12.5" FontWeight="SemiBold" TextWrapping="Wrap" MaxWidth="440" />
+                        </StackPanel>
+                        <TextBlock Style="{StaticResource AdminHintStyle}"
+                                   Visibility="{Binding IsTpmKey, Converter={StaticResource BoolToVisibility}}">
+                            <Run Text="Fichier de référence (sans secret, inutile sur un autre PC) :" />
+                            <LineBreak />
+                            <Run Text="{Binding CreatedKeyPath, Mode=OneWay}" Foreground="{DynamicResource TextPrimaryBrush}" />
+                            <LineBreak />
+                            <Run Text="Clé publique :" />
+                            <LineBreak />
+                            <Run Text="{Binding PublicKeyPath, Mode=OneWay}" Foreground="{DynamicResource TextPrimaryBrush}" />
+                        </TextBlock>
+                        <TextBlock Style="{StaticResource AdminHintStyle}"
+                                   Visibility="{Binding IsTpmKey, Converter={StaticResource BoolToVisibility}, ConverterParameter=Invert}">
+                            <Run Text="Clé privée (chiffrée, ne la transmettez jamais) :" />
+                            <LineBreak />
+                            <Run Text="{Binding CreatedKeyPath, Mode=OneWay}" Foreground="{DynamicResource TextPrimaryBrush}" />
+                            <LineBreak />
+                            <Run Text="Clé publique :" />
+                            <LineBreak />
+                            <Run Text="{Binding PublicKeyPath, Mode=OneWay}" Foreground="{DynamicResource TextPrimaryBrush}" />
+                        </TextBlock>
+                        <Button Style="{StaticResource LinkButtonStyle}" HorizontalAlignment="Left" Margin="0,10,0,0" FontSize="12.5"
+                                Content="Ouvrir le dossier" ui:IconAssist.Icon="{StaticResource Icon.FolderOpen}"
+                                Command="{Binding OpenKeyFolderCommand}" />
+                    </StackPanel>
+                </Border>
+
+                <Button Style="{StaticResource AccentButtonStyle}" Height="44" HorizontalAlignment="Stretch" Margin="0,6,0,0"
+                        Content="Continuer vers la connexion" ui:IconAssist.Icon="{StaticResource Icon.ArrowRight}"
+                        Command="{Binding ContinueCommand}" />
+            </StackPanel>
+        </Grid>
+    </ScrollViewer>
+</UserControl>

src/GameLauncher/Views/Admin/EnrollView.xaml.cs

@@ -0,0 +1,38 @@
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using GameLauncher.Modules.Admin.ViewModels;
+
+namespace GameLauncher.Views.Admin;
+
+/// <summary>
+/// « J'ai une invitation ». Les phrases de passe restent dans les PasswordBox (jamais liées au
+/// ViewModel) et sont effacées dès qu'elles ont été transmises.
+/// </summary>
+public partial class EnrollView : UserControl
+{
+    public EnrollView()
+    {
+        InitializeComponent();
+    }
+
+    private async void OnSubmitClick(object sender, RoutedEventArgs e) => await SubmitAsync();
+
+    private async void OnConfirmationKeyDown(object sender, KeyEventArgs e)
+    {
+        if (e.Key != Key.Enter) return;
+        e.Handled = true;
+        await SubmitAsync();
+    }
+
+    private async Task SubmitAsync()
+    {
+        if (DataContext is not EnrollViewModel { IsBusy: false, IsForm: true } vm) return;
+        var passphrase = PassphraseBox.Password;
+        var confirmation = ConfirmationBox.Password;
+        PassphraseBox.Clear();
+        ConfirmationBox.Clear();
+        await vm.SubmitAsync(passphrase, confirmation);
+        if (vm.IsForm && IsLoaded) PassphraseBox.Focus();
+    }
+}

src/GameLauncher/Views/Admin/LoginView.xaml

@@ -0,0 +1,135 @@
+<UserControl x:Class="GameLauncher.Views.Admin.LoginView"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:ui="clr-namespace:GameLauncher.Controls">
+
+    <!--
+        Connexion : la clé d'administrateur (fichier chiffré) signe un défi du serveur.
+        La phrase de passe ne quitte jamais cette vue : elle est passée à LoginAsync puis effacée.
+    -->
+    <ScrollViewer VerticalScrollBarVisibility="Auto" Focusable="False">
+        <StackPanel Width="470" Margin="0,30,0,30" HorizontalAlignment="Center" VerticalAlignment="Center">
+            <!-- En-tête -->
+            <Border Width="64" Height="64" CornerRadius="20" HorizontalAlignment="Center" Background="{DynamicResource AccentGradientBrush}">
+                <Path Data="{StaticResource Icon.Lock}" Fill="{DynamicResource OnAccentBrush}" Width="28" Height="28" Stretch="Uniform" />
+            </Border>
+            <TextBlock Text="Connexion administrateur" FontSize="22" FontWeight="SemiBold" Margin="0,18,0,0" HorizontalAlignment="Center" />
+            <TextBlock Margin="0,6,0,24" HorizontalAlignment="Center" TextAlignment="Center" TextWrapping="Wrap"
+                       FontSize="12.5" Foreground="{DynamicResource TextSecondaryBrush}"
+                       Text="Votre clé signe un défi envoyé par le serveur : aucun mot de passe ne circule." />
+
+            <!-- Information (verrouillage, clé à faire approuver…) -->
+            <Border Style="{StaticResource AdminInfoBannerStyle}" Visibility="{Binding HasStatus, Converter={StaticResource BoolToVisibility}}">
+                <StackPanel Orientation="Horizontal">
+                    <Path Width="15" Height="15" Stretch="Uniform" Fill="{DynamicResource InfoBrush}" Data="{StaticResource Icon.Info}"
+                          VerticalAlignment="Top" Margin="0,1,0,0" />
+                    <TextBlock Text="{Binding StatusMessage}" Margin="10,0,0,0" TextWrapping="Wrap" FontSize="12.5" MaxWidth="400" />
+                </StackPanel>
+            </Border>
+
+            <!-- Clé -->
+            <DockPanel Margin="0,0,0,10">
+                <StackPanel DockPanel.Dock="Right" Orientation="Horizontal">
+                    <Button Style="{StaticResource IconButtonStyle}" Width="30" Height="30" Padding="8"
+                            ui:IconAssist.Icon="{StaticResource Icon.Refresh}" ToolTip="Actualiser la liste"
+                            Command="{Binding RefreshCommand}" />
+                    <Button Style="{StaticResource IconButtonStyle}" Width="30" Height="30" Padding="8"
+                            ui:IconAssist.Icon="{StaticResource Icon.FolderKey}" ToolTip="Ouvrir le dossier des clés"
+                            Command="{Binding OpenKeysFolderCommand}" />
+                </StackPanel>
+                <TextBlock Text="VOTRE CLÉ" Style="{StaticResource SectionTitleStyle}" Margin="0" VerticalAlignment="Center" />
+            </DockPanel>
+
+            <ListBox ItemsSource="{Binding Keys}" SelectedItem="{Binding SelectedKey, Mode=TwoWay}"
+                     ItemContainerStyle="{StaticResource AdminKeyItemStyle}" MaxHeight="216"
+                     Background="Transparent" BorderThickness="0" Padding="0"
+                     ScrollViewer.HorizontalScrollBarVisibility="Disabled"
+                     ScrollViewer.VerticalScrollBarVisibility="Auto"
+                     Visibility="{Binding HasKeys, Converter={StaticResource BoolToVisibility}}" />
+
+            <Border Style="{StaticResource AdminCardStyle}" Margin="0,0,0,8"
+                    Visibility="{Binding HasKeys, Converter={StaticResource BoolToVisibility}, ConverterParameter=Invert}">
+                <StackPanel>
+                    <TextBlock Text="Aucune clé trouvée" Style="{StaticResource AdminCardTitleStyle}" />
+                    <TextBlock Style="{StaticResource AdminHintStyle}" Margin="0,4,0,0">
+                        <Run Text="Dossier examiné :" />
+                        <Run Text="{Binding KeysDirectory, Mode=OneWay}" />
+                        <LineBreak />
+                        <Run Text="Choisissez votre fichier .key, ou créez une clé avec « J'ai une invitation »." />
+                    </TextBlock>
+                </StackPanel>
+            </Border>
+
+            <DockPanel Margin="2,2,0,20">
+                <!-- Clés de la puce uniquement (une clé fichier se supprime à la main) -->
+                <Button DockPanel.Dock="Right" Style="{StaticResource LinkButtonStyle}" FontSize="12.5"
+                        Foreground="{DynamicResource DangerBrush}" Content="Supprimer cette clé de la puce"
+                        ui:IconAssist.Icon="{StaticResource Icon.Delete}" Command="{Binding DeleteTpmKeyCommand}"
+                        ToolTip="Efface définitivement la clé de la puce de sécurité de ce PC (après confirmation)"
+                        Visibility="{Binding IsTpmKey, Converter={StaticResource BoolToVisibility}}" />
+                <Button Style="{StaticResource LinkButtonStyle}" HorizontalAlignment="Left" FontSize="12.5"
+                        Content="Choisir un autre fichier de clé…" ui:IconAssist.Icon="{StaticResource Icon.FileKey}"
+                        Command="{Binding BrowseKeyCommand}" />
+            </DockPanel>
+
+            <!-- Puce bloquée par sa protection anti-essais : temps d'attente -->
+            <Border Style="{StaticResource AdminInfoBannerStyle}" BorderBrush="{DynamicResource WarningBrush}"
+                    Visibility="{Binding ShowTpmLockout, Converter={StaticResource BoolToVisibility}}">
+                <Grid>
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="*" />
+                    </Grid.ColumnDefinitions>
+                    <Path Width="16" Height="16" Stretch="Uniform" Fill="{DynamicResource WarningBrush}" Data="{StaticResource Icon.ClockOutline}"
+                          VerticalAlignment="Top" Margin="0,1,0,0" />
+                    <StackPanel Grid.Column="1" Margin="10,0,0,0">
+                        <TextBlock Text="Puce de sécurité bloquée" FontSize="12.5" FontWeight="SemiBold" />
+                        <TextBlock Text="{Binding LockoutText}" FontSize="12.5" Margin="0,3,0,0" TextWrapping="Wrap" />
+                        <Button Style="{StaticResource LinkButtonStyle}" HorizontalAlignment="Left" Margin="0,8,0,0" FontSize="12"
+                                Content="Revérifier maintenant" ui:IconAssist.Icon="{StaticResource Icon.Refresh}"
+                                Command="{Binding RecheckLockoutCommand}" />
+                    </StackPanel>
+                </Grid>
+            </Border>
+
+            <!-- Phrase de passe -->
+            <TextBlock Text="{Binding SecretLabel}" Style="{StaticResource AdminFieldLabelStyle}" />
+            <PasswordBox x:Name="PassphraseBox" Style="{StaticResource ModernPasswordBoxStyle}" Margin="0,0,0,16"
+                         IsEnabled="{Binding HasKeys}" KeyDown="OnPassphraseKeyDown" />
+
+            <!-- Erreur -->
+            <Border Style="{StaticResource AdminErrorBannerStyle}" Visibility="{Binding HasError, Converter={StaticResource BoolToVisibility}}">
+                <StackPanel Orientation="Horizontal">
+                    <Path Width="15" Height="15" Stretch="Uniform" Fill="{DynamicResource DangerBrush}" Data="{StaticResource Icon.AlertCircle}"
+                          VerticalAlignment="Top" Margin="0,1,0,0" />
+                    <TextBlock Text="{Binding ErrorMessage}" Margin="10,0,0,0" TextWrapping="Wrap" FontSize="12.5" MaxWidth="400" />
+                </StackPanel>
+            </Border>
+
+            <ProgressBar Style="{StaticResource ModernProgressBarStyle}" Height="3" Margin="0,0,0,12" IsIndeterminate="{Binding IsBusy}"
+                         Visibility="{Binding IsBusy, Converter={StaticResource BoolToVisibility}}" />
+
+            <Button Style="{StaticResource AccentButtonStyle}" Height="44" HorizontalAlignment="Stretch" Content="Se connecter"
+                    ui:IconAssist.Icon="{StaticResource Icon.Login}" IsEnabled="{Binding CanLogin}" Click="OnLoginClick" />
+
+            <!-- Invitation -->
+            <Border Height="1" Background="{DynamicResource BorderBrush}" Margin="0,26,0,18" />
+            <Grid>
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="Auto" />
+                    <ColumnDefinition Width="*" />
+                    <ColumnDefinition Width="Auto" />
+                </Grid.ColumnDefinitions>
+                <Border Style="{StaticResource AdminIconBadgeStyle}" VerticalAlignment="Center">
+                    <Path Style="{StaticResource AdminIconStyle}" Data="{StaticResource Icon.TicketAccount}" />
+                </Border>
+                <StackPanel Grid.Column="1" Margin="12,0,12,0" VerticalAlignment="Center">
+                    <TextBlock Text="Nouvel administrateur ou nouveau PC ?" FontSize="13" FontWeight="SemiBold" />
+                    <TextBlock Text="Créez votre clé avec le code d'invitation reçu." Style="{StaticResource AdminHintStyle}" />
+                </StackPanel>
+                <Button Grid.Column="2" Style="{StaticResource SmallButtonStyle}" Content="J'ai une invitation"
+                        ui:IconAssist.Icon="{StaticResource Icon.KeyPlus}" Command="{Binding ShowEnrollCommand}" />
+            </Grid>
+        </StackPanel>
+    </ScrollViewer>
+</UserControl>

src/GameLauncher/Views/Admin/LoginView.xaml.cs

@@ -0,0 +1,40 @@
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using GameLauncher.Modules.Admin.ViewModels;
+
+namespace GameLauncher.Views.Admin;
+
+/// <summary>
+/// Écran de connexion. La phrase de passe reste dans le PasswordBox (jamais liée au ViewModel) :
+/// elle est lue au moment de la connexion puis effacée, que la connexion réussisse ou non.
+/// </summary>
+public partial class LoginView : UserControl
+{
+    public LoginView()
+    {
+        InitializeComponent();
+        Loaded += (_, _) =>
+        {
+            if (PassphraseBox.IsEnabled) PassphraseBox.Focus();
+        };
+    }
+
+    private async void OnLoginClick(object sender, RoutedEventArgs e) => await LoginAsync();
+
+    private async void OnPassphraseKeyDown(object sender, KeyEventArgs e)
+    {
+        if (e.Key != Key.Enter) return;
+        e.Handled = true;
+        await LoginAsync();
+    }
+
+    private async Task LoginAsync()
+    {
+        if (DataContext is not LoginViewModel { CanLogin: true } vm) return;
+        var passphrase = PassphraseBox.Password;
+        PassphraseBox.Clear();
+        await vm.LoginAsync(passphrase);
+        if (IsLoaded && PassphraseBox.IsEnabled) PassphraseBox.Focus(); // échec : nouvel essai
+    }
+}