diff --git a/Glossaire.md b/Glossaire.md
new file mode 100644
index 0000000..15d1fda
--- /dev/null
+++ b/Glossaire.md
@@ -0,0 +1,64 @@
+# Glossaire
+
+Les concepts-clés de Set-OPS, en une phrase chacun. Les mots *en italique* renvoient à une autre
+entrée. Le détail vit dans les **unités d'apprentissage** et le dépôt (`docs/`).
+
+---
+
+**Adressage dérivé** — Les IP, VLAN, VMID, sous-réseaux ne sont pas saisis : ils se **calculent**
+depuis le *seed*. Cf. [Le plan & l'adressage dérivé](Le-plan-et-l-adressage-dérivé).
+
+**Binding (liaison)** — Relation déclarative entre entités du plan (app→app, app→base) résolue par
+le moteur, sans coder de variables à la main. Cf. [Liaisons (bindings)](Liaisons-bindings).
+
+**DIFF VIDE** — État sain où le *plan* reproduit **exactement** l'inventaire généré : la source de
+vérité et l'artefact concordent. Vérifié par `make instancier`.
+
+**Fédération** — Ensemble des *instances* qui cohabitent sur une infrastructure partagée, chacune
+avec son *index* unique. Cf. [Multi-instance & fédération](Multi-instance-et-fédération).
+
+**`federe: false`** — Drapeau marquant un *bac à sable* local, **exclu** du réseau convergé (il ne
+provisionne pas ses VLAN sur les switches de production).
+
+**Hôte fantôme** — Erreur de plan : une application posée sur un hôte **non déclaré** dans les
+serveurs. Refusé par la preuve **P06** et par la création de modèle.
+
+**Idempotence** — Rejouer la même description N fois donne le même résultat (`changed=0` après la
+1ʳᵉ fois). Cf. [Infra as Code & idempotence](Infra-as-Code-et-idempotence).
+
+**Index (seed)** — Le **seul** intrant d'adressage d'une instance. Détermine supernet
+(`10.(10+index)`), VLAN (`1000+index×10+zone`), VMID. Unique par instance fédérée.
+
+**Instance** — Un écosystème réel (un *tenant*) : `../OPS-<nom>`, avec ses valeurs concrètes
+(domaine, *voûte*, index). L'active est celle que pointe le symlink `instance/`.
+
+**ip-miroir** — Schéma de VMID à 9 chiffres où le numéro **contient** l'IP et le tenant
+(`VLAN·octet-hôte·séquence`) — lisible d'un coup d'œil.
+
+**Modèle** — Un *plan* **générique** réutilisable (valeurs *placeholder*, sans *voûte*), dans le
+dépôt privé `Set-OPS-Modeles`. Le socle public en est la preuve libre. On en crée une instance
+(`instance-creer`) ; on en fabrique un (`model-creer`).
+
+**Nomenclature** — Le registre du **modèle réseau** : zones, placement des fonctions, et le *seed*
+`index`. Ne contient **aucun** adressage (il en dérive — preuve P20).
+
+**Le plancher** — La première couche de résolution de noms : `/etc/hosts` posé par le socle, avant
+même que le DNS soit debout. Cf. [DNS & résolution](DNS-et-résolution).
+
+**Plan** — La source unique de vérité (`instance/plan/` : serveurs, applications, bases, domaines,
+nomenclature). On l'édite ; l'inventaire en est **généré**, jamais l'inverse.
+
+**Preuve (Pxx)** — Une vérification rejouable du harnais `make prouver` qui garde une classe
+d'erreur. Cf. [La preuve](La-preuve).
+
+**Socle** — L'infrastructure de base souveraine (DNS, PKI, edge TLS, relais courriel) — le modèle
+minimal public, extensible.
+
+**Tenant** — Synonyme d'*instance* dans le contexte de la *fédération* : un écosystème isolé parmi
+d'autres.
+
+**Voûte (vault)** — Le fichier chiffré des secrets d'une instance (`vault.yml`, Ansible Vault).
+**Jamais** dans un *modèle* ni versionné ; seul le gabarit `vault.yml.example` l'est.
+
+**Zone** — Un domaine de sécurité (un `/24` + un VLAN) : Frontière, Identité, Données,
+Services-infra, Observabilité, Applications. Un pare-feu les sépare.
diff --git a/Home.md b/Home.md
index 9e82df4..ba9eee7 100644
--- a/Home.md
+++ b/Home.md
@@ -15,9 +15,9 @@ des **méthodes 100 % génériques**.
 ## Comment ce wiki est organisé
 | Section | Contenu |
 |---|---|
-| **Unités d'apprentissage** | Un fondamental TIC par page, toujours selon le même moule (ci-dessous). |
+| **Unités d'apprentissage** | Un fondamental TIC par page, toujours selon le même moule (ci-dessous). Des *services* (identité, PKI, courriel…) **et** de la *méthode* (le plan, le multi-instance, la preuve). |
 | **Opérations (runbooks)** | Procédures : ajouter un service, déployer un nœud, restaurer une sauvegarde… |
-| **Glossaire** | Les concepts-clés (liaisons/bindings, le plancher, idempotence…). |
+| **[Glossaire](Glossaire)** | Les concepts-clés en une phrase (seed, bindings, le plancher, hôte fantôme, voûte…). |
 | **Référence technique** | Le *détail du « comment »* vit **dans le dépôt** (`docs/`, README des rôles) — ce wiki y **pointe**, ne le **recopie pas** (pour éviter la dérive). |
 
 ## Le moule d'une unité d'apprentissage
@@ -29,7 +29,11 @@ Chaque unité suit **quatre temps** :
 > **4. À toi de jouer** *(observe · interroge · casse · répare)*
 
 ## Par où commencer
-👉 **[Identité & SSO](Identité-et-SSO)** — l'unité-pilote (authentification, annuaire, SSO, fédération).
+- 👉 **[Identité & SSO](Identité-et-SSO)** — l'unité-pilote côté *services* (SSO, annuaire, OIDC).
+- 🧭 **[Le plan & l'adressage dérivé](Le-plan-et-l-adressage-dérivé)** — l'unité-pilote côté
+  *méthode* : un seed, tout en découle. C'est la clé de voûte du reste.
+- 🌐 **[Multi-instance & fédération](Multi-instance-et-fédération)** — un moteur, N écosystèmes.
+- 🔬 **[La preuve](La-preuve)** — *ne jamais affirmer plus que ce qu'on prouve.*
 
 ---
 *Deux axes sont enseignés partout : le **QUOI** (les concepts) et le **COMMENT** (les méthodes de
diff --git a/La-preuve.md b/La-preuve.md
new file mode 100644
index 0000000..56ce31d
--- /dev/null
+++ b/La-preuve.md
@@ -0,0 +1,82 @@
+# La preuve — prouver, pas affirmer
+
+> **Unité d'apprentissage.** Moule : ① concept → ② Set-OPS → ③ transférable → ④ à toi de jouer.
+
+---
+
+## ① Le concept *(générique)*
+
+Une affirmation sans **vérification rejouable** n'est que du marketing. « C'est sécurisé »,
+« c'est sauvegardé », « ça fonctionne » — *prouve-le*. La discipline se résume à une règle :
+
+> **Ne jamais affirmer plus que ce qu'on prouve.**
+
+Trois idées la portent :
+
+- **Registre d'affirmations** — chaque promesse publique est tracée vers une **commande qui la
+  vérifie**, ou marquée honnêtement « non prouvée ».
+- **Harnais rejouable** — une seule commande rejoue *toutes* les preuves et produit une **pièce
+  justificative datée**. On ne « croit » pas : on **relance**.
+- **Le registre a le droit de perdre** — une preuve qui échoue fait *redescendre* l'affirmation.
+  C'est la seule condition pour qu'un tel registre ait de la valeur.
+
+---
+
+## ② Comment Set-OPS le fait
+
+- **Le registre** : `docs/audit/affirmations.md` — chaque affirmation du dépôt (README, docs,
+  aide `make`, GUI) reliée à une preuve et un statut (✅/🟡/❌/⚪).
+- **Le harnais** : `make prouver` rejoue les preuves automatisables (**P01–P21**) et écrit
+  `docs/audit/preuve-<date>.md`. `make verifier` les inclut : il **échoue** si une preuve échoue.
+- **Chaque preuve garde une classe d'erreur.** Extrait :
+
+| Preuve | Ce qu'elle empêche de mentir |
+|---|---|
+| P03 | l'inventaire n'est pas généré du plan (**diff vide**) |
+| P06 | un registre incohérent (dont l'**hôte fantôme**) |
+| P17 | un **modèle** invalide (tous, pas seulement le socle) |
+| P18 | un **gabarit de voûte** incomplet |
+| P19 | un champ du plan que le **GUI** ne sait pas éditer |
+| P20 | de l'**adressage stocké** (tout doit dériver du seed) |
+| P21 | une **collision d'index** entre instances fédérées |
+
+Ce n'est pas un framework de test parallèle : le harnais **orchestre** l'outillage existant, il ne
+réimplémente aucune validation.
+
+---
+
+## ③ Pourquoi c'est transférable
+
+| Set-OPS | Équivalents ailleurs |
+|---|---|
+| `make prouver` | tests automatisés, **CI/CD**, `terraform validate` |
+| registre d'affirmations | *traçabilité de conformité* (SOC 2, ISO) |
+| pièce justificative datée | *audit trail*, preuve d'audit |
+| « le registre peut perdre » | un test vert n'est utile que s'il peut virer rouge |
+
+Tu as appris **la vérification rejouable, la preuve d'audit, la culture du test** — pas « le
+harnais de Set-OPS ».
+
+---
+
+## ④ À toi de jouer
+
+1. **Produis une preuve.** `make prouver` (voûte exportée). Lis
+   `docs/audit/preuve-<date>.md` : chaque preuve, son verdict, l'affirmation couverte.
+2. **Fais échouer une preuve — exprès.** Introduis un **hôte fantôme** : dans `applications.yml`,
+   pointe une appli vers un hôte qui n'existe pas dans `serveurs.yml`. `make prouver` : **P06
+   échoue**, en nommant l'hôte. Corrige (ou via le `<select>` de la GUI) : vert.
+3. **Une autre.** Remets de l'adressage dans une nomenclature (`vlan: 42`), `make prouver` :
+   **P20 échoue**. Retire-le : vert.
+4. **Lis le registre.** Ouvre `docs/audit/affirmations.md` : trouve une affirmation ⚪
+   (*non prouvable localement*) — vois comment elle est **assumée comme intention**, jamais
+   présentée comme prouvée.
+5. **Comprends la valeur.** Demande-toi : *quelle promesse est-ce que je fais sans preuve ?*
+   C'est exactement ce que ce registre force à regarder en face.
+
+---
+
+## Pour aller plus loin *(dépôt)*
+- Le mode d'emploi : `docs/audit/README.md`.
+- Le registre : `docs/audit/affirmations.md` ; le harnais : `scripts/prouver.py`.
+- L'épreuve humaine (« exploitable sans IA ») : `docs/audit/protocole-operateur-independant.md`.
diff --git a/Le-GUI-console-d-exploitation.md b/Le-GUI-console-d-exploitation.md
new file mode 100644
index 0000000..35dc565
--- /dev/null
+++ b/Le-GUI-console-d-exploitation.md
@@ -0,0 +1,85 @@
+# Le GUI (console d'exploitation)
+
+> **Unité d'apprentissage.** Moule : ① concept → ② Set-OPS → ③ transférable → ④ à toi de jouer.
+
+---
+
+## ① Le concept *(générique)*
+
+Un moteur d'infrastructure a besoin d'une **interface humaine** — sinon il n'est utilisable que
+par son auteur (ou une IA). Le principe fondateur : **un opérateur doit tout piloter seul**, sans
+l'auteur et sans IA (« exploitable sans IA »).
+
+Une bonne console d'exploitation obéit à trois règles :
+
+- **Elle édite la SOURCE, pas l'artefact.** On modifie le *plan* (l'état voulu), jamais l'inventaire
+  généré. La console montre la vérité, elle ne la contourne pas.
+- **Elle prévisualise avant d'agir.** *dry-run* (voir ce qui changerait) avant *apply* (changer).
+- **Elle empêche l'invalide.** Le meilleur garde-fou n'est pas un message d'erreur : c'est une
+  interface où l'erreur est **impossible à saisir**.
+
+---
+
+## ② Comment Set-OPS le fait
+
+`make inventaire-ui` lance une console web **locale** (`127.0.0.1`, protégée par un jeton). Ses vues :
+
+| Vues **éditables** (le plan) | Vues **dérivées** (lecture seule) |
+|---|---|
+| Serveurs · Applications · Bases · Domaines · **Intrants** | Flux · Couches · **Réseau** (flotte + devis) |
+
+Le flux d'exploitation, de bout en bout :
+
+1. **Éditer** une vue du plan → **Sauvegarder** ;
+2. **« Appliquer le plan »** → régénère l'inventaire (VMID/IP/VLAN **dérivés**) ;
+3. **Vérifier** (dry-run) sur un hôte → prévisualise sans rien changer ;
+4. **Déployer** → applique les rôles (confirmation **renforcée** si l'instance est en **PROD**) ;
+5. **Créer la VM** → clone sur Proxmox depuis le plan.
+
+**L'erreur rendue impossible.** Le champ « Hôte » d'une application est un `<select>` qui ne
+propose que des **hôtes réels** : impossible de pointer vers un hôte fantôme. La console couvre le
+schéma du plan — et la preuve **P19** le vérifie.
+
+**La flotte, dans la vue Réseau.** Voir toutes les instances, **basculer** (« Activer »), **créer**
+une instance depuis un modèle, repérer une **collision** d'index. Cf.
+[Multi-instance & fédération](Multi-instance-et-fédération).
+
+---
+
+## ③ Pourquoi c'est transférable
+
+| Set-OPS | Équivalents ailleurs |
+|---|---|
+| GUI au-dessus d'Ansible | **AWX** / Ansible Automation Platform, **Semaphore** |
+| éditer la source de vérité | l'UI de **NetBox** (IPAM/DCIM), une CMDB |
+| dry-run → apply | `terraform plan/apply`, tout panneau IaC |
+| l'invalide impossible à saisir | *validation à la source*, formulaires contraints |
+
+Tu as appris **la console d'exploitation, éditer-la-source, dry-run-avant-apply, la validation à la
+saisie** — pas « le GUI de Set-OPS ».
+
+---
+
+## ④ À toi de jouer
+
+1. **Lance-la.** `make inventaire-ui`, ouvre l'URL affichée. Repère l'inventaire actif et l'état de
+   la flotte (en haut), les onglets, « Appliquer le plan », « Sauvegarder ».
+2. **Édite → prévisualise.** Vue **Serveurs**, change la mémoire d'un hôte, **Sauvegarder**,
+   **Appliquer le plan**, puis **Vérifier** (dry-run) : tu vois ce qui *changerait* avant d'agir.
+3. **Répare un hôte fantôme (l'erreur impossible).** Si une appli pointe un hôte inexistant, ouvre
+   la vue **Applications**, sélectionne-la : le `<select>` « Hôte » ne montre **que des hôtes
+   réels**. Choisis le bon, **Sauvegarder**, **Appliquer**. Tu ne *peux pas* re-saisir le fantôme.
+4. **Bascule d'instance.** Vue **Réseau**, bouton **« Activer »** sur une autre instance. Toutes
+   les vues suivent, sans redémarrer.
+5. **Sens le garde-fou.** Essaie de sauvegarder un plan incohérent (ex. une base dont le
+   consommateur n'existe pas) : la console **refuse** avec une raison. L'invalide ne passe pas.
+6. **Casse & répare.** Édite `hosts.yml` à la main, reviens dans la GUI, « Appliquer le plan » : ta
+   modification est **écrasée** par le plan. La source de vérité, c'est le plan — pas l'inventaire.
+
+---
+
+## Pour aller plus loin *(dépôt)*
+- Lancer : `make inventaire-ui` ; le code : `scripts/inventory_gui.py`.
+- Ce que le GUI sait écrire (et la preuve) : `scripts/couverture_gui.py` (P19).
+- Le flux plan → apply : unité **[Infra as Code & idempotence](Infra-as-Code-et-idempotence)**.
+- La flotte : unité **[Multi-instance & fédération](Multi-instance-et-fédération)**.
diff --git a/Le-plan-et-l-adressage-dérivé.md b/Le-plan-et-l-adressage-dérivé.md
new file mode 100644
index 0000000..bbba9ef
--- /dev/null
+++ b/Le-plan-et-l-adressage-dérivé.md
@@ -0,0 +1,91 @@
+# Le plan & l'adressage dérivé
+
+> **Unité d'apprentissage.** Moule : ① concept → ② Set-OPS → ③ transférable → ④ à toi de jouer.
+
+---
+
+## ① Le concept *(générique)*
+
+Une infrastructure a **beaucoup** de valeurs : adresses IP, VLAN, identifiants de VM,
+sous-réseaux, passerelles, noms d'hôtes… Deux façons de les gérer :
+
+- **Les saisir à la main** — chaque valeur est décidée et écrite quelque part. Fragile : deux
+  endroits finissent par se contredire (l'un dit `10.11.13.11`, l'autre `data-01`), et personne
+  ne sait lequel a raison.
+- **Les DÉRIVER d'une source unique** — on ne saisit qu'un **seed** (une graine), et *tout le
+  reste se calcule*. Il ne peut plus y avoir de contradiction : il n'y a qu'une vérité.
+
+C'est le principe **DRY** (*Don't Repeat Yourself*) appliqué à l'infrastructure, et le principe
+de la **source unique de vérité**. Le plan **déclaratif** décrit *l'état voulu* ; l'adressage n'y
+est pas *écrit*, il en **découle**.
+
+---
+
+## ② Comment Set-OPS le fait
+
+Le **plan** (`instance/plan/`) est la source unique. Cinq registres :
+
+| Registre | Décrit |
+|---|---|
+| `serveurs.yml` | les VM (fonction, état, intégrations) |
+| `applications.yml` | les services et leurs **liens** |
+| `bases-donnees.yml` | les bases et qui les consomme |
+| `domaines.yml` | les zones DNS publiques |
+| `nomenclature.yml` | le **modèle réseau** : zones + placement des fonctions + le **seed `index`** |
+
+**Le seed, c'est `index`.** À partir de lui *seul*, Set-OPS dérive **tout** l'adressage :
+
+| Élément | Formule (modèle 6 zones) |
+|---|---|
+| Supernet | `10.(10+index).0.0/16` |
+| Sous-réseau de zone | `10.(10+index).(15+zone).0/24` |
+| Passerelle | `…(15+zone).1` |
+| VLAN sur le trunk | `1000 + index×10 + zone` |
+| VMID | `VLAN·octet-hôte·séquence` (9 chiffres) |
+
+`make instancier` **génère** `hosts.yml` depuis le plan. **On n'édite jamais `hosts.yml` à la
+main** — c'est un artefact. On édite le plan (ou la GUI), puis « Appliquer le plan ».
+
+La **preuve P20** interdit d'écrire de l'adressage dans la nomenclature : si quelqu'un y remet un
+`supernet` ou un `vlan`, `make prouver` échoue. La règle est *tenue par une machine*, pas par la
+discipline.
+
+---
+
+## ③ Pourquoi c'est transférable
+
+| Set-OPS | Équivalents ailleurs |
+|---|---|
+| adressage dérivé du seed | `cidrsubnet()` de Terraform, IPAM de **NetBox** (dérive les plages) |
+| plan → inventaire généré | tout générateur d'inventaire (`nb_inventory`, CMDB → config) |
+| source unique de vérité | principe universel : une valeur, un seul endroit |
+| DRY | fondamental du génie logiciel |
+
+Tu as appris **la dérivation, DRY, la source unique de vérité, le déclaratif** — pas « la
+nomenclature de Set-OPS ».
+
+---
+
+## ④ À toi de jouer
+
+1. **Observe la dérivation.** Vue **Serveurs** de la GUI : chaque carte montre VMID · IP · VLAN.
+   Aucun n'a été saisi — tous viennent du `index`. Note l'IP d'un hôte.
+2. **Change le seed, regarde tout suivre.** Panneau **Intrants → Réseau**, change `index` (ex.
+   de 1 à 7), « Appliquer le plan ». **Toutes** les IP basculent de `10.11.x` à `10.17.x`, les
+   VLAN de `101x` à `107x` — d'un seul chiffre. Puis remets ta valeur.
+3. **Sens la source unique.** `make instancier` (diff), puis `make instancier-appliquer` :
+   *« DIFF VIDE : le plan reproduit exactement l'inventaire »* — le plan **est** la vérité.
+4. **Casse & répare.** Édite `hosts.yml` à la main (change une IP). Relance `make instancier` :
+   il **signale l'écart**. Ré-applique : le plan **écrase** ta modification. Tu *sens* que
+   `hosts.yml` n'est pas la vérité — le plan l'est.
+5. **Éprouve le garde-fou.** Ajoute une ligne `supernet: 10.99.0.0/16` dans une nomenclature,
+   puis `make prouver` : **P20 échoue** (« adressage stocké »). Retire-la : vert. La règle se
+   *prouve*.
+
+---
+
+## Pour aller plus loin *(dépôt)*
+- Le plan et sa génération : `docs/plan-et-generation.md`.
+- La dérivation, en code : `scripts/inventory_rules.py` (`supernet_de`, `vlan_de`…).
+- Le seed multi-instance : unité **[Multi-instance & fédération](Multi-instance-et-fédération)**.
+- La règle prouvée : unité **[La preuve](La-preuve)** (P20).
diff --git a/Multi-instance-et-fédération.md b/Multi-instance-et-fédération.md
new file mode 100644
index 0000000..1a0e735
--- /dev/null
+++ b/Multi-instance-et-fédération.md
@@ -0,0 +1,83 @@
+# Multi-instance & fédération
+
+> **Unité d'apprentissage.** Moule : ① concept → ② Set-OPS → ③ transférable → ④ à toi de jouer.
+
+---
+
+## ① Le concept *(générique)*
+
+Un même **moteur** peut opérer **plusieurs écosystèmes** (organisations, clients, environnements).
+Trois questions se posent :
+
+- **Isolation** — chaque écosystème (*tenant*) doit être étanche : ses données, son identité, son
+  réseau ne touchent pas ceux des autres.
+- **Cohabitation sans collision** — si plusieurs tenants partagent une infrastructure physique
+  (mêmes switches, même hyperviseur), leurs adresses et VLAN doivent être **uniques globalement**,
+  sinon le réseau se marche dessus.
+- **Découverte** — comment le système sait-il *quels* écosystèmes existent ? Par un **registre**
+  central (qu'il faut tenir à jour) ou par **convention** (ils se reconnaissent d'eux-mêmes) ?
+
+---
+
+## ② Comment Set-OPS le fait
+
+**Un dépôt par écosystème.** L'écosystème actif est celui que pointe le symlink `instance/`. Les
+autres sont des **dépôts frères** (`../OPS-Chezlepro`, `../OPS-Technolibre`…).
+
+**Découverte par convention, pas de registre.** Une instance *est* un dossier frère avec un
+`plan/nomenclature.yml` portant un `index`. Le code fait `glob('../*/plan/nomenclature.yml')` —
+rien à inscrire nulle part. Déposer une instance à côté des autres suffit.
+
+**Le seed garantit l'unicité.** Chaque tenant a un `index` distinct → adressage dérivé sans
+chevauchement possible : VLAN `1000+index×10+zone` (les VLAN de deux index différents ne peuvent
+*mathématiquement* pas se croiser). Plafond : **245** écosystèmes fédérés (borne IPv4).
+
+**Gérer la flotte :**
+- `make instances` — la vue d'ensemble : qui existe, l'active (★), index, VLAN, **collision** ;
+- `make instance-utiliser NOM=…` ou le bouton **« Activer »** de la GUI (vue Réseau) — basculer ;
+- `make instance-creer NOM=… MODELE=…` — créer une instance depuis un modèle ;
+- `make model-creer …` — créer/promouvoir un **modèle** (le produit).
+
+**Garde-fous.** `federe: false` exclut un bac à sable local du réseau convergé. La **preuve P21**
+échoue si deux instances fédérées partagent un `index`.
+
+---
+
+## ③ Pourquoi c'est transférable
+
+| Set-OPS | Équivalents ailleurs |
+|---|---|
+| un moteur, N tenants | **multi-tenancy** SaaS, *cloud accounts/projects* |
+| isolation par VLAN/adressage | VRF, VLAN, *namespaces* Kubernetes, VPC |
+| découverte par convention | *convention over configuration* (Rails, etc.) |
+| tenants NetBox | modèle de source de vérité multi-tenant |
+
+Tu as appris **le multi-tenant, l'isolation réseau, la convention plutôt que la configuration** —
+pas « le symlink de Set-OPS ».
+
+---
+
+## ④ À toi de jouer
+
+1. **Vois la flotte.** `make instances` : l'active (★), les index, les VLAN, le statut
+   fédéré/local. Repère qui est en **production**.
+2. **Bascule.** GUI, vue **Réseau**, bouton **« Activer »** sur une autre instance (ou
+   `make instance-utiliser NOM=…`). Toutes les vues suivent — sans redémarrer.
+3. **Crée une instance.** `make instance-modeles` (les modèles dispo), puis
+   `make instance-creer NOM=OPS-Test MODELE=socle INDEX=4`. Un écosystème neuf, en une commande.
+4. **Éprouve le garde-fou de collision.** Essaie de créer une instance avec un `index` **déjà
+   pris** : refus *avant* toute copie. Puis `make prouver` → **P21** veille sur la fédération.
+5. **Casse & répare.** Donne à deux instances fédérées le **même** index (édite une nomenclature),
+   `make instances` : la **bannière de collision** s'allume ; `make prouver` : P21 échoue.
+   Corrige l'index : tout redevient vert.
+6. **(Avancé) Promeus un produit.** Une instance qui *tourne et se prouve* peut devenir un modèle
+   vendable : `make model-creer MODE=instance SOURCE=OPS-… NOM=…` — elle est **généralisée**
+   (identité → `exemple.*`, secrets retirés) et **validée**.
+
+---
+
+## Pour aller plus loin *(dépôt)*
+- Le guide complet : `docs/multi-instances.md`.
+- Le seed et la dérivation : unité **[Le plan & l'adressage dérivé](Le-plan-et-l-adressage-dérivé)**.
+- L'isolation réseau (VLAN, ACL, OPNsense) : `make devis-reseau` + `scripts/devis_reseau.py`.
+- Les garde-fous prouvés : unité **[La preuve](La-preuve)** (P21).
diff --git a/_Sidebar.md b/_Sidebar.md
index bf6f86b..496289a 100644
--- a/_Sidebar.md
+++ b/_Sidebar.md
@@ -23,14 +23,20 @@
 - [Supervision & impact](Supervision-et-impact)
 
 *Socle & méthode*
+- [Le GUI (console d'exploitation)](Le-GUI-console-d-exploitation)
 - [Virtualisation & clonage](Virtualisation-et-clonage)
 - [Sécurité & durcissement](Sécurité-et-durcissement)
 - [Infra as Code & idempotence](Infra-as-Code-et-idempotence)
+- [Le plan & l'adressage dérivé](Le-plan-et-l-adressage-dérivé)
 - [Liaisons (bindings)](Liaisons-bindings)
 
+*Flotte & preuve*
+- [Multi-instance & fédération](Multi-instance-et-fédération)
+- [La preuve](La-preuve)
+
 **Opérations**
 - Runbooks → dépôt `docs/runbooks-exploitation.md`
 
 **Repères**
-- Glossaire *(à venir)*
+- [Glossaire](Glossaire)
 - Référence technique → dépôt `docs/`