From 03c628d5e1dfdcef9a643ed0ec04387b66b9a7f6 Mon Sep 17 00:00:00 2001
From: Daniel Allaire <allaire.dan@chezlepro.ca>
Date: Tue, 8 Sep 2026 15:30:08 -0400
Subject: [PATCH] GUI : le formulaire des bases est GENERE depuis le schema
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Etape 3, sur un seul registre — `bases_donnees`, le plus simple et le seul ou
observe et editable coincidaient deja. Les cinq autres gardent leurs formulaires
ecrits a la main : on ne bascule pas six vues d un coup.

CE QUI DISPARAIT DU JAVASCRIPT

Huit `<label>` en dur, trois constructions de `<option>`, et la regle qui
choisissait la source du consommateur selon la portee. Cette derniere ne vivait
que dans le JS ; elle est desormais DECLAREE au schema (`x-source-selon`), donc
lisible et gardee.

Le formulaire rend exactement les memes huit champs qu avant — verifie en
EXECUTANT le moteur sous node avec le schema et des donnees reelles, pas
seulement en passant `node --check`.

LA BOUCLE EST FERMEE DES DEUX COTES

Le chemin de SAUVEGARDE enumerait lui aussi les sept champs en dur. Un champ
ajoute au registre serait apparu au formulaire genere et aurait disparu
SILENCIEUSEMENT a l enregistrement — le pire des deux mondes. Il derive
maintenant du schema, valeurs par defaut comprises (`default`).

LA SEPARATION FORME / COHERENCE, MONTREE

  portee=groupe + consommateur APPLICATION   -> REFUSE par valider_bases
  portee=application + consommateur app      -> ACCEPTE
  secret absent                              -> REFUSE

Le schema a rempli la FORME (les defauts `groupe` et `principale` se sont
poses), le validateur a attrape l INCOHERENCE. Aucune de ces trois regles ne
s exprime en JSON Schema, et vouloir l y mettre creerait la seconde source de
verite que ce depot refuse.

CHAMPS_ECRITS_PAR_GUI COMMENCE A DISPARAITRE

Renomme CHAMPS_ECRITS_A_LA_MAIN, et `bases_donnees` en est SORTIE : sa
couverture se derive du schema. P19 lit desormais `champs_ecrits_par_gui()`, qui
reunit les deux. Le jour ou la table sera vide, elle gardera un mecanisme au
lieu d une liste.

UNE GARDE A CORRIGER AU PASSAGE

`declaration_derive()` verifiait que chaque champ declare apparait dans le
SOURCE du GUI. Pour un registre genere il n y apparait plus — c est le but.
Elle aurait crie sur precisement le progres qu elle devait constater. Les
registres generes en sont exemptes : c est P61 qui tient la promesse pour eux.

make prouver : CONFORME, 60 OK, 0 echec, 1 saute.
P07 (node --check), P19 (couverture), P61 (schema) : verts.

Reste : les cinq autres vues, et le trou de la nomenclature — que le passage au
generateur fermera par construction, puisque le schema decrit deja `categorie`
et `service`.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Crgis8CxCWkAGFA1ecBz3q
---
 docs/audit/preuve-2026-09-08.md |   2 +-
 docs/audit/schema-plan.json     |  69 +++++++++----
 docs/audit/wiki-publie.yml      |   2 +-
 scripts/couverture_gui.py       |  21 ++--
 scripts/inventory_gui.py        | 170 ++++++++++++++++++++++++++++----
 scripts/schema_plan.py          |  66 +++++++++----
 6 files changed, 260 insertions(+), 70 deletions(-)

diff --git a/docs/audit/preuve-2026-09-08.md b/docs/audit/preuve-2026-09-08.md
index 96f068d..2c331f2 100644
--- a/docs/audit/preuve-2026-09-08.md
+++ b/docs/audit/preuve-2026-09-08.md
@@ -72,7 +72,7 @@
 | P57 | Comptes en prose : les chiffres du depot sur lui-meme | — | ✅ OK | Les comptes ecrits en prose correspondent a la mesure (61 preuves, 65 roles, 40 groupes). |
 | P58 | Habilitations : chaque service dit a quel GROUPE, et par quoi | — | ✅ OK | 8 habilitation(s) declarees, toutes nommant un groupe, un mecanisme connu et une raison ; les `role-realm` sont projetees. |
 | P59 | Enumerations annoncees : le nombre correspond a ce qui suit | — | ✅ OK | 2 enumeration(s) annoncee(s) correspondent a ce qu'elles annoncent (formes non ambigues seulement). |
-| P60 | Wiki publie : la forge sert ce que le depot dit | AFF-002 | ✅ OK | Le wiki publie correspond au depot : `wiki/` n'a pas bouge depuis `e2935ed` (publie le 2026-09-08). |
+| P60 | Wiki publie : la forge sert ce que le depot dit | AFF-002 | ✅ OK | Le wiki publie correspond au depot : `wiki/` n'a pas bouge depuis `0eaceb1` (publie le 2026-09-08). |
 | P61 | Schema du plan : il decrit tout ce que les plans contiennent | AFF-033 | ✅ OK | Le schema decrit 42 champ(s) sur 6 registres, et couvre tout ce que les plans reels contiennent ; applications:1, domaines_publics:1, nomenclature:9, serveurs:3 |
 
 ## Couverture des affirmations ✅ du registre
diff --git a/docs/audit/schema-plan.json b/docs/audit/schema-plan.json
index 28a2cd4..b075aaf 100644
--- a/docs/audit/schema-plan.json
+++ b/docs/audit/schema-plan.json
@@ -16,13 +16,13 @@
           },
           "groupe": {
             "description": "La capacite appliquee. Doit avoir un playbook homonyme.",
-            "title": "Groupe (role)",
+            "title": "Groupe (rôle)",
             "type": "string",
             "x-source-valeurs": "groupes_operationnels"
           },
           "hote": {
             "description": "Une VM declaree au plan. Un hote inconnu est un « hote fantome » (P06).",
-            "title": "Hote",
+            "title": "Hôte",
             "type": "string",
             "x-source-valeurs": "serveurs"
           },
@@ -59,6 +59,10 @@
         "type": "object"
       },
       "title": "Applications",
+      "x-clef": {
+        "description": "Nom de l'application dans le plan.",
+        "title": "Identifiant"
+      },
       "x-fichier": "plan/applications.yml",
       "x-racine": "applications"
     },
@@ -71,26 +75,36 @@
             "type": "string"
           },
           "consommateur": {
+            "description": "Qui utilise cette base. La liste depend de la portee.",
             "title": "Consommateur",
-            "type": "string"
+            "type": "string",
+            "x-source-selon": {
+              "cas": {
+                "application": "applications",
+                "hote": "serveurs"
+              },
+              "champ": "portee",
+              "defaut": "groupes_operationnels"
+            }
           },
           "portee": {
+            "default": "groupe",
             "description": "Comment le consommateur est designe : par application, par groupe ou par hote.",
             "enum": [
               "application",
               "groupe",
               "hote"
             ],
-            "title": "Portee",
+            "title": "Portée",
             "type": "string"
           },
           "proprietaire": {
-            "title": "Proprietaire",
+            "title": "Propriétaire",
             "type": "string"
           },
           "secret": {
             "description": "NOM d'une variable Vault, jamais une valeur. Le secret ne quitte pas le role.",
-            "title": "Secret (voute)",
+            "title": "Secret (Vault)",
             "type": "string"
           },
           "serveur": {
@@ -99,6 +113,7 @@
             "x-source-valeurs": "serveurs_bd"
           },
           "usage": {
+            "default": "principale",
             "title": "Usage",
             "type": "string"
           }
@@ -113,6 +128,10 @@
         "type": "object"
       },
       "title": "Bases de donnees",
+      "x-clef": {
+        "description": "Nom de l'entree au registre, ex. `bd_forgejo`.",
+        "title": "Identifiant"
+      },
       "x-fichier": "plan/bases-donnees.yml",
       "x-racine": "bases_donnees"
     },
@@ -126,7 +145,7 @@
               "delegue",
               "primaire-cache"
             ],
-            "title": "Autorite DNS",
+            "title": "Autorité DNS",
             "type": "string"
           },
           "dnssec": {
@@ -154,6 +173,10 @@
         "type": "object"
       },
       "title": "Domaines publics",
+      "x-clef": {
+        "description": "Le nom public, ex. `chezlepro.ca`.",
+        "title": "Domaine"
+      },
       "x-fichier": "plan/domaines.yml",
       "x-racine": "domaines_publics"
     },
@@ -167,7 +190,7 @@
               "properties": {
                 "libelle": {
                   "description": "Nom lisible de la zone (Frontiere, Identite...).",
-                  "title": "Libelle",
+                  "title": "Libellé",
                   "type": "string"
                 }
               },
@@ -177,7 +200,7 @@
               "type": "object"
             },
             "description": "Une zone de securite par cle. Le numero derive le 3e octet et le VLAN.",
-            "title": "Categories (zones)",
+            "title": "Catégories (zones)",
             "type": "object"
           },
           "cidr_hote": {
@@ -190,7 +213,7 @@
               "properties": {
                 "categorie": {
                   "description": "La zone. Fixe le 3e octet (15 + categorie) et le VLAN.",
-                  "title": "Categorie",
+                  "title": "Catégorie",
                   "type": "integer"
                 },
                 "service": {
@@ -226,18 +249,18 @@
                   "type": "integer"
                 },
                 "reserve_max": {
-                  "title": "Reserve (max)",
+                  "title": "Réserve (max)",
                   "type": "integer"
                 },
                 "reserve_min": {
-                  "title": "Reserve (min)",
+                  "title": "Réserve (min)",
                   "type": "integer"
                 }
               },
               "type": "object"
             },
             "description": "Adresses soustraites a la derivation dans chaque zone.",
-            "title": "Reservations",
+            "title": "Réservations",
             "type": "object"
           }
         },
@@ -256,7 +279,7 @@
         "properties": {
           "coeurs": {
             "description": "Vide = derive des empreintes des roles.",
-            "title": "Coeurs",
+            "title": "Cœurs",
             "type": "integer"
           },
           "disque": {
@@ -270,7 +293,7 @@
               "actif",
               "planifie"
             ],
-            "title": "Etat",
+            "title": "État",
             "type": "string"
           },
           "fonction": {
@@ -284,17 +307,17 @@
             "items": {
               "type": "string"
             },
-            "title": "Integrations facultatives",
+            "title": "Intégrations facultatives",
             "type": "array"
           },
           "memoire": {
             "description": "Vide = derive des empreintes des roles.",
-            "title": "Memoire (Mo)",
+            "title": "Mémoire (Mo)",
             "type": "integer"
           },
           "noeud": {
             "description": "Surcharge le defaut de `make config`.",
-            "title": "Noeud Proxmox",
+            "title": "Nœud Proxmox",
             "type": "string"
           },
           "stockage": {
@@ -309,6 +332,10 @@
         "type": "object"
       },
       "title": "Serveurs (VM)",
+      "x-clef": {
+        "description": "Le nom court de la VM. Le rang final derive l'adresse.",
+        "title": "Nom d'hôte"
+      },
       "x-fichier": "plan/serveurs.yml",
       "x-racine": "serveurs"
     },
@@ -322,7 +349,7 @@
             "x-source-valeurs": "groupes_operationnels"
           },
           "hote": {
-            "title": "Hote",
+            "title": "Hôte",
             "type": "string",
             "x-source-valeurs": "serveurs"
           },
@@ -342,6 +369,10 @@
         "type": "object"
       },
       "title": "Serveurs de bases de donnees",
+      "x-clef": {
+        "description": "Nom du serveur de bases, ex. `pg-principal`.",
+        "title": "Nom"
+      },
       "x-fichier": "plan/bases-donnees.yml",
       "x-racine": "serveurs_bd"
     }
diff --git a/docs/audit/wiki-publie.yml b/docs/audit/wiki-publie.yml
index 36d1e0b..e3bcb34 100644
--- a/docs/audit/wiki-publie.yml
+++ b/docs/audit/wiki-publie.yml
@@ -1,5 +1,5 @@
 ---
 # Ecrit par `make wiki-publier`, lu par la preuve P60. Ne pas editer a la main.
 remote: ssh://git@eregion.chezlepro.ca:2222/Alliance-Boreale/Set-OPS-Public.wiki.git
-source: e2935ed
+source: 0eaceb1
 date: 2026-09-08
diff --git a/scripts/couverture_gui.py b/scripts/couverture_gui.py
index 15ff324..5327e54 100644
--- a/scripts/couverture_gui.py
+++ b/scripts/couverture_gui.py
@@ -9,7 +9,7 @@ main, et personne ne s'en apercoit avant de buter dessus.
 Ce script rend le trou VISIBLE et mesurable. Il croise :
   - les champs REELLEMENT presents dans les plans (instance courante + tous les
     modeles decouverts par scripts/modeles.py) ;
-  - `CHAMPS_ECRITS_PAR_GUI` de scripts/inventory_gui.py, qui declare ce que les
+  - `champs_ecrits_par_gui()` de scripts/inventory_gui.py, qui declare ce que les
     fonctions de sauvegarde ecrivent.
 
 Deux sens de verification :
@@ -32,7 +32,7 @@ from pathlib import Path
 
 import yaml
 
-from inventory_gui import CHAMPS_ECRITS_PAR_GUI
+from inventory_gui import REGISTRES_GENERES, champs_ecrits_par_gui
 from modeles import decouvrir as decouvrir_modeles
 
 from inventory_rules import instance_courante, instance_courante  # noqa: E402
@@ -88,11 +88,18 @@ def declaration_derive() -> list[str]:
     """Champs declares au GUI mais introuvables dans son source (declaration qui ment)."""
     src = SOURCE_GUI.read_text(encoding="utf-8")
     # On coupe le tableau lui-meme : sa presence ne prouve rien.
-    debut = src.find("CHAMPS_ECRITS_PAR_GUI")
+    debut = src.find("champs_ecrits_par_gui()")
     fin = src.find("\n}\n", debut)
     ailleurs = src[:debut] + src[fin:] if debut != -1 and fin != -1 else src
     absents = []
-    for registre, champs in CHAMPS_ECRITS_PAR_GUI.items():
+    for registre, champs in champs_ecrits_par_gui().items():
+        # UN REGISTRE GENERE N'A PLUS SES CHAMPS DANS LE SOURCE, et c'est le but : ils
+        # vivent dans le schema, et le formulaire en derive. Chercher `secret` dans le JS
+        # ferait crier cette garde sur precisement le progres qu'elle devrait constater.
+        # Pour ces registres-la, c'est P61 qui tient la promesse — elle verifie que le
+        # schema decrit tout ce que les plans contiennent.
+        if registre in REGISTRES_GENERES:
+            continue
         for champ in sorted(champs):
             if champ not in ailleurs:
                 absents.append(f"{registre}.{champ}")
@@ -112,7 +119,7 @@ def main() -> int:
 
     if args.commande == "lister":
         for registre in sorted(utilises):
-            couverts = CHAMPS_ECRITS_PAR_GUI.get(registre, set())
+            couverts = champs_ecrits_par_gui().get(registre, set())
             print(f"\n== {registre} ==")
             for champ in sorted(utilises[registre]):
                 etat = "GUI" if champ in couverts else "-- hors GUI --"
@@ -125,7 +132,7 @@ def main() -> int:
     for registre, champs in utilises.items():
         if registre in tolere:
             continue
-        couverts = CHAMPS_ECRITS_PAR_GUI.get(registre, set())
+        couverts = champs_ecrits_par_gui().get(registre, set())
         for champ in sorted(set(champs) - couverts):
             trous.append(f"{registre}.{champ}  (vu dans : "
                          f"{', '.join(sorted(champs[champ]))})")
@@ -138,7 +145,7 @@ def main() -> int:
         for t in trous:
             print(f"  - {t}", file=sys.stderr)
     if derive:
-        print(f"erreur: {len(derive)} champ(s) declare(s) dans CHAMPS_ECRITS_PAR_GUI mais "
+        print(f"erreur: {len(derive)} champ(s) declare(s) dans champs_ecrits_par_gui() mais "
               f"introuvable(s) dans le source du GUI : {', '.join(derive)}", file=sys.stderr)
 
     if trous or derive:
diff --git a/scripts/inventory_gui.py b/scripts/inventory_gui.py
index 1cd0605..795b9bc 100644
--- a/scripts/inventory_gui.py
+++ b/scripts/inventory_gui.py
@@ -464,9 +464,29 @@ def inventaire_api(path: Path) -> dict:
         "integrations_disponibles": integrations_disponibles(),
         "integrations_universelles": integrations_universelles(RACINE),
         "liens_acceptes": catalogue_liens(RACINE),
+        # LE SCHEMA VOYAGE AVEC LES DONNEES. Le navigateur genere ses formulaires depuis
+        # lui plutot que de les porter en dur : un champ ajoute au plan apparait a l'ecran
+        # sans toucher au JS. Genere par `make schema`, garde par P61.
+        "schema": schema_du_plan(),
     }
 
 
+def schema_du_plan() -> dict:
+    """Le JSON Schema des registres, tel que `make schema` l'a ecrit.
+
+    Lu depuis le fichier plutot que recalcule : c'est l'artefact VERSIONNE qui fait foi,
+    et P61 refuse qu'il soit perime. Recalculer ici laisserait l'ecran afficher une forme
+    que personne n'a relue.
+    """
+    f = RACINE / "docs" / "audit" / "schema-plan.json"
+    if not f.is_file():
+        return {}
+    try:
+        return json.loads(f.read_text(encoding="utf-8")).get("registres", {})
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
 def _lire_yaml_dict(path: Path) -> dict:
     if not path.exists():
         return {}
@@ -533,20 +553,46 @@ def intrants_courants() -> dict:
 # A TENIR A JOUR avec sauvegarderServeurs / sauvegarderApplications /
 # sauvegarderBases / sauvegarderDomaines. Le verificateur controle aussi que chaque
 # champ declare ici apparait bien dans le source du GUI (garde anti-derive).
-CHAMPS_ECRITS_PAR_GUI = {
+# CE QUE LE GUI SAIT ECRIRE — ET D'OU IL LE TIENT (2026-09-08).
+#
+# Cette table etait tenue A LA MAIN : quelqu'un devait penser a l'allonger quand un champ
+# arrivait au plan, et P19 confrontait la liste au reel. Une copie gardee reste une copie.
+#
+# `bases_donnees` en est SORTIE la premiere : son formulaire est desormais GENERE depuis
+# `docs/audit/schema-plan.json` (`make schema`), donc la liste s'en deduit au lieu d'etre
+# recopiee. Les registres restants gardent leur declaration manuelle jusqu'a ce que leur
+# formulaire passe au generateur — on ne bascule pas six vues d'un coup.
+#
+# P19 lit `champs_ecrits_par_gui()` et non plus cette constante : le jour ou la table sera
+# vide, elle gardera un mecanisme au lieu d'une liste.
+CHAMPS_ECRITS_A_LA_MAIN = {
     "serveurs": {"fonction", "etat", "noeud", "stockage", "disque", "memoire",
                  "coeurs", "integrations"},
     "applications": {"groupe", "hote", "port", "requiert", "expose", "liens", "websocket"},
-    "bases_donnees": {"serveur", "base", "proprietaire", "secret", "consommateur",
-                      "portee", "usage"},
     "serveurs_bd": {"type", "hote", "port", "groupe"},
     "domaines_publics": {"autorite", "edge", "secondaires", "dnssec", "mail"},
-    # nomenclature : AUCUN champ. Le GUI la LIT (liste des fonctions) sans jamais
-    # l'ecrire — ajouter une fonction exige d'editer le YAML. Trou connu et assume ;
-    # `couverture_gui.py` le signale tant qu'il dure.
+    # nomenclature : AUCUN champ ecrit a la main. Le GUI la LIT (liste des fonctions) sans
+    # jamais l'ecrire — ajouter une fonction exige d'editer le YAML. Trou connu, que le
+    # passage au generateur fermera par construction.
     "nomenclature": set(),
 }
 
+# Les registres dont le formulaire est GENERE : leurs champs viennent du schema.
+REGISTRES_GENERES = {"bases_donnees"}
+
+
+def champs_ecrits_par_gui() -> dict:
+    """Ce que le GUI sait ecrire : declare a la main, plus derive du schema.
+
+    Une seule fonction repond a la question, pour que P19 n'ait pas a savoir lequel des
+    deux mecanismes couvre quel registre.
+    """
+    resultat = {nom: set(champs) for nom, champs in CHAMPS_ECRITS_A_LA_MAIN.items()}
+    for nom, reg in (schema_du_plan() or {}).items():
+        if nom in REGISTRES_GENERES:
+            resultat[nom] = set((reg.get("entite") or {}).get("properties") or {})
+    return resultat
+
 
 def integrations_disponibles() -> list:
     """Roles client_* SELECTIONNABLES : ceux qui restent un choix.
@@ -1967,6 +2013,82 @@ HTML = r"""<!doctype html>
       applicationsModifie = false;
     }
 
+    // ---- FORMULAIRES GENERES DEPUIS LE SCHEMA -------------------------------------
+    //
+    // Le schema (docs/audit/schema-plan.json, `make schema`) decrit la FORME des
+    // registres ; ces trois fonctions la rendent. Un champ ajoute au plan apparait donc
+    // a l'ecran sans qu'on touche a ce fichier — c'est tout l'objet.
+    //
+    // Ce qu'elles ne font PAS : valider. La coherence reste aux `valider_*` du serveur,
+    // qui refusent la sauvegarde. Un formulaire genere ne saurait pas dire qu'un
+    // consommateur designe une application inexistante.
+
+    function sourceDeValeurs(nom) {
+      // Les listes fermees, resolues a l'execution. C'est ce qui rend l'hote fantome
+      // IMPOSSIBLE A SAISIR, au lieu d'etre refuse apres coup.
+      if (nom === 'serveurs') return hotes.map(h => h.nom).filter(Boolean);
+      if (nom === 'applications') return applications.map(x => x.id).filter(Boolean);
+      if (nom === 'groupes_operationnels') return groupes;
+      if (nom === 'serveurs_bd') return bdServeurs.map(x => x.nom).filter(Boolean);
+      if (nom === 'nomenclature.fonctions') return Object.keys((data.nomenclature || {}).fonctions || {});
+      return [];
+    }
+
+    function champDepuisSchema(cle, spec, valeur, entite, surChangement) {
+      const titre = echapper(spec.title || cle);
+      const aide = spec.description ? ` title="${echapper(spec.description)}"` : '';
+      const req = (spec['x-requis'] ? ' <span class="dsn">requis</span>' : '');
+      const appel = (expr) => `${surChangement}('${cle}', ${expr})`;
+
+      // Liste fermee : soit fixe (enum), soit alimentee a l'execution, soit dependante
+      // d'un autre champ de la meme entite.
+      let options = null;
+      if (spec.enum) options = spec.enum;
+      else if (spec['x-source-valeurs']) options = sourceDeValeurs(spec['x-source-valeurs']);
+      else if (spec['x-source-selon']) {
+        const s = spec['x-source-selon'];
+        const pivot = (entite || {})[s.champ];
+        options = sourceDeValeurs((s.cas || {})[pivot] || s.defaut);
+      }
+
+      if (options) {
+        const opts = ['<option value="">—</option>'].concat(options.map(v =>
+          `<option value="${echapper(v)}"${String(v) === String(valeur == null ? '' : valeur) ? ' selected' : ''}>${echapper(v)}</option>`)).join('');
+        return `<label class="champ"${aide}><span>${titre}${req}</span><select onchange="${appel('this.value')}">${opts}</select></label>`;
+      }
+      if (spec.type === 'boolean') {
+        return `<label class="champ"${aide}><span>${titre}${req}</span><input type="checkbox"${valeur ? ' checked' : ''} onchange="${appel('this.checked')}"></label>`;
+      }
+      if (spec.type === 'integer') {
+        return `<label class="champ"${aide}><span>${titre}${req}</span><input type="number" value="${echapper(valeur == null ? '' : valeur)}" oninput="${appel('this.value')}"></label>`;
+      }
+      if (spec.type === 'array') {
+        // Une liste de textes se saisit separee par des virgules : le YAML reste une
+        // liste, la saisie reste lisible.
+        const v = Array.isArray(valeur) ? valeur.join(', ') : '';
+        return `<label class="champ"${aide}><span>${titre}${req}</span><input value="${echapper(v)}" placeholder="a, b" oninput="${appel('this.value.split(\',\').map(x=>x.trim()).filter(Boolean)')}"></label>`;
+      }
+      return `<label class="champ"${aide}><span>${titre}${req}</span><input value="${echapper(valeur == null ? '' : valeur)}" oninput="${appel('this.value')}"></label>`;
+    }
+
+    function formulaireDepuisSchema(nomRegistre, entite, surChangement, cleCourante, surChangementCle) {
+      const reg = ((data.schema || {})[nomRegistre]) || null;
+      if (!reg) return '<div class="vide">Aucun schéma pour ce registre — lancer <code>make schema</code>.</div>';
+      const props = (reg.entite || {}).properties || {};
+      const requis = new Set((reg.entite || {}).required || []);
+      const morceaux = [];
+      if (reg['x-clef'] && surChangementCle) {
+        const k = reg['x-clef'];
+        morceaux.push(`<label class="champ" title="${echapper(k.description || '')}"><span>${echapper(k.title)}</span>` +
+          `<input value="${echapper(cleCourante == null ? '' : cleCourante)}" oninput="(${surChangementCle})(this.value)"></label>`);
+      }
+      Object.keys(props).forEach(cle => {
+        const spec = Object.assign({}, props[cle], {'x-requis': requis.has(cle)});
+        morceaux.push(champDepuisSchema(cle, spec, (entite || {})[cle], entite, surChangement));
+      });
+      return `<div class="grille">${morceaux.join('')}</div>`;
+    }
+
     function dsnBase(a) {
       const s = bdServeurs.find(x => x.nom === a.serveur);
       if (!s) return '(serveur inconnu : ' + echapper(a.serveur || '—') + ')';
@@ -2048,22 +2170,15 @@ HTML = r"""<!doctype html>
       } else {
         const a = bdApplis[info.i];
         if (!a) { cible.innerHTML = '<div class="detail"><div class="vide">Introuvable.</div></div>'; return; }
-        const source = a.portee === 'hote' ? hotes.map(h => h.nom).filter(Boolean) : a.portee === 'application' ? applications.map(x => x.id) : groupes;
-        const optConso = '<option value="">—</option>' + source.map(v => `<option value="${echapper(v)}" ${v === a.consommateur ? 'selected' : ''}>${echapper(v)}</option>`).join('');
-        const optPortee = ['groupe', 'application', 'hote'].map(p => `<option value="${p}" ${p === (a.portee || 'groupe') ? 'selected' : ''}>${p}</option>`).join('');
-        const optServeur = '<option value="">—</option>' + bdServeurs.map(x => `<option value="${echapper(x.nom)}" ${x.nom === a.serveur ? 'selected' : ''}>${echapper(x.nom)}</option>`).join('');
+        // FORMULAIRE GENERE DEPUIS LE SCHEMA (2026-09-08) — plus aucun champ en dur.
+        // Les huit `<label>` qui vivaient ici sont derives de docs/audit/schema-plan.json :
+        // libelles, types, listes fermees, et la source CONDITIONNELLE du consommateur
+        // (elle depend de la portee) que le schema declare desormais au lieu de la laisser
+        // vivre dans ce fichier. Un champ ajoute au registre apparait sans toucher au JS,
+        // et P61 refuse qu'un champ du plan manque au schema.
         cible.innerHTML = `<article class="detail">
           <div class="detail-tete"><div class="detail-nom"><span class="detail-nom-txt">${echapper(a.cle || '(sans id)')}</span></div><span class="grandit"></span><button type="button" class="danger" title="Retirer" onclick="retirerBaseBd()">✕</button></div>
-          <div class="grille">
-            <label class="champ"><span>Identifiant</span><input value="${echapper(a.cle)}" placeholder="bd_forgejo" oninput="definirBaseBd('cle', this.value)"></label>
-            <label class="champ"><span>Portée</span><select onchange="definirBaseBd('portee', this.value)">${optPortee}</select></label>
-            <label class="champ"><span>Consommateur</span><select onchange="definirBaseBd('consommateur', this.value)">${optConso}</select></label>
-            <label class="champ"><span>Serveur</span><select onchange="definirBaseBd('serveur', this.value)">${optServeur}</select></label>
-            <label class="champ"><span>Base</span><input value="${echapper(a.base)}" placeholder="forgejo" oninput="definirBaseBd('base', this.value)"></label>
-            <label class="champ"><span>Propriétaire</span><input value="${echapper(a.proprietaire)}" oninput="definirBaseBd('proprietaire', this.value)"></label>
-            <label class="champ"><span>Usage</span><input value="${echapper(a.usage)}" placeholder="principale" oninput="definirBaseBd('usage', this.value)"></label>
-            <label class="champ"><span>Secret (Vault)</span><input value="${echapper(a.secret)}" placeholder="vault_bd_app" oninput="definirBaseBd('secret', this.value)"></label>
-          </div>
+          ${formulaireDepuisSchema('bases_donnees', a, 'definirBaseBd', a.cle, "definirBaseBd.bind(null,'cle')")}
           <div class="dsn mono" style="margin-top:8px">${echapper(dsnBase(a))}</div>
           ${(() => {
             const srv = bdServeurs.find(x => x.nom === a.serveur);
@@ -2080,7 +2195,20 @@ HTML = r"""<!doctype html>
       const sd = {};
       bdServeurs.forEach(s => { if (String(s.nom).trim()) sd[s.nom] = {type: s.type, hote: s.hote, port: parseInt(s.port, 10) || s.port, ...(s.groupe ? {groupe: s.groupe} : {})}; });
       const bd = {};
-      bdApplis.forEach(a => { if (String(a.cle).trim()) bd[a.cle] = {serveur: a.serveur, base: a.base, proprietaire: a.proprietaire, secret: a.secret, consommateur: a.consommateur, portee: a.portee || 'groupe', usage: a.usage || 'principale'}; });
+      // SAUVEGARDE DERIVEE DU SCHEMA (2026-09-08). Les sept champs etaient enumeres ici
+      // en dur : un champ ajoute au registre serait apparu au formulaire genere et
+      // aurait disparu SILENCIEUSEMENT a l'enregistrement — le pire des deux mondes.
+      // Les valeurs par defaut viennent du schema (`default`), plus du JS.
+      const propsBd = (((data.schema || {}).bases_donnees || {}).entite || {}).properties || {};
+      bdApplis.forEach(a => {
+        if (!String(a.cle).trim()) return;
+        const e = {};
+        Object.keys(propsBd).forEach(cle => {
+          const v = a[cle];
+          e[cle] = (v === undefined || v === '' || v === null) ? (propsBd[cle].default ?? v) : v;
+        });
+        bd[a.cle] = e;
+      });
       const rep = await fetch('/api/bases', {
         method: 'POST', headers: {'Content-Type': 'application/json', 'X-Jeton': JETON}, body: JSON.stringify({serveurs_bd: sd, bases_donnees: bd})
       });
diff --git a/scripts/schema_plan.py b/scripts/schema_plan.py
index b6b71ba..4761d29 100644
--- a/scripts/schema_plan.py
+++ b/scripts/schema_plan.py
@@ -60,25 +60,26 @@ REGISTRES: dict = {
         "titre": "Serveurs (VM)",
         "fichier": "plan/serveurs.yml",
         "racine": "serveurs",
+        "clef": {"libelle": "Nom d'hôte", "aide": "Le nom court de la VM. Le rang final derive l'adresse."},
         "champs": {
             "fonction":     {"type": "string", "requis": True,
                              "libelle": "Fonction",
                              "aide": "Determine VMID, IP, VLAN et passerelle. Doit exister dans la nomenclature.",
                              "source_valeurs": "nomenclature.fonctions"},
             "etat":         {"type": "string", "enum": sorted(ETATS_SERVEUR),
-                             "libelle": "Etat",
+                             "libelle": "État",
                              "aide": "`planifie` = decrit mais pas deploye ; `actif` = joignable par Ansible."},
             "integrations": {"type": "array", "items": {"type": "string"},
-                             "libelle": "Integrations facultatives",
+                             "libelle": "Intégrations facultatives",
                              "aide": "Seulement les facultatives. Les universelles viennent du role et sont refusees ici."},
-            "noeud":        {"type": "string", "libelle": "Noeud Proxmox",
+            "noeud":        {"type": "string", "libelle": "Nœud Proxmox",
                              "aide": "Surcharge le defaut de `make config`."},
             "stockage":     {"type": "string", "libelle": "Stockage", "aide": "Surcharge le defaut."},
             "disque":       {"type": "string", "libelle": "Disque",
                              "aide": "Ex. `32G`. Vide = derive des empreintes des roles."},
-            "memoire":      {"type": "integer", "libelle": "Memoire (Mo)",
+            "memoire":      {"type": "integer", "libelle": "Mémoire (Mo)",
                              "aide": "Vide = derive des empreintes des roles."},
-            "coeurs":       {"type": "integer", "libelle": "Coeurs",
+            "coeurs":       {"type": "integer", "libelle": "Cœurs",
                              "aide": "Vide = derive des empreintes des roles."},
         },
     },
@@ -86,11 +87,12 @@ REGISTRES: dict = {
         "titre": "Applications",
         "fichier": "plan/applications.yml",
         "racine": "applications",
+        "clef": {"libelle": "Identifiant", "aide": "Nom de l'application dans le plan."},
         "champs": {
-            "groupe":    {"type": "string", "requis": True, "libelle": "Groupe (role)",
+            "groupe":    {"type": "string", "requis": True, "libelle": "Groupe (rôle)",
                           "aide": "La capacite appliquee. Doit avoir un playbook homonyme.",
                           "source_valeurs": "groupes_operationnels"},
-            "hote":      {"type": "string", "requis": True, "libelle": "Hote",
+            "hote":      {"type": "string", "requis": True, "libelle": "Hôte",
                           "aide": "Une VM declaree au plan. Un hote inconnu est un « hote fantome » (P06).",
                           "source_valeurs": "serveurs"},
             "port":      {"type": "integer", "libelle": "Port"},
@@ -111,26 +113,38 @@ REGISTRES: dict = {
         "titre": "Bases de donnees",
         "fichier": "plan/bases-donnees.yml",
         "racine": "bases_donnees",
+        "clef": {"libelle": "Identifiant", "aide": "Nom de l'entree au registre, ex. `bd_forgejo`."},
         "champs": {
             "serveur":      {"type": "string", "requis": True, "libelle": "Serveur de BD",
                              "source_valeurs": "serveurs_bd"},
             "base":         {"type": "string", "requis": True, "libelle": "Base"},
-            "proprietaire": {"type": "string", "requis": True, "libelle": "Proprietaire"},
-            "secret":       {"type": "string", "requis": True, "libelle": "Secret (voute)",
+            "proprietaire": {"type": "string", "requis": True, "libelle": "Propriétaire"},
+            "secret":       {"type": "string", "requis": True, "libelle": "Secret (Vault)",
                              "aide": "NOM d'une variable Vault, jamais une valeur. Le secret ne quitte pas le role."},
-            "consommateur": {"type": "string", "requis": True, "libelle": "Consommateur"},
-            "portee":       {"type": "string", "enum": sorted(PORTEES_BD), "libelle": "Portee",
+            # SOURCE CONDITIONNELLE : ce qu'on peut consommer depend de la PORTEE.
+            # Le formulaire ecrit a la main faisait deja ce choix ; le schema le declare
+            # au lieu de le laisser vivre dans le JS. C'est ce qui permet de generer le
+            # champ sans perdre la regle.
+            "consommateur": {"type": "string", "requis": True, "libelle": "Consommateur",
+                             "aide": "Qui utilise cette base. La liste depend de la portee.",
+                             "source_selon": {"champ": "portee",
+                                              "cas": {"hote": "serveurs",
+                                                      "application": "applications"},
+                                              "defaut": "groupes_operationnels"}},
+            "portee":       {"type": "string", "enum": sorted(PORTEES_BD), "libelle": "Portée",
+                             "defaut": "groupe",
                              "aide": "Comment le consommateur est designe : par application, par groupe ou par hote."},
-            "usage":        {"type": "string", "libelle": "Usage"},
+            "usage":        {"type": "string", "libelle": "Usage", "defaut": "principale"},
         },
     },
     "serveurs_bd": {
         "titre": "Serveurs de bases de donnees",
         "fichier": "plan/bases-donnees.yml",
         "racine": "serveurs_bd",
+        "clef": {"libelle": "Nom", "aide": "Nom du serveur de bases, ex. `pg-principal`."},
         "champs": {
             "type":   {"type": "string", "requis": True, "libelle": "Moteur"},
-            "hote":   {"type": "string", "requis": True, "libelle": "Hote", "source_valeurs": "serveurs"},
+            "hote":   {"type": "string", "requis": True, "libelle": "Hôte", "source_valeurs": "serveurs"},
             "port":   {"type": "integer", "libelle": "Port"},
             "groupe": {"type": "string", "libelle": "Groupe", "source_valeurs": "groupes_operationnels"},
         },
@@ -139,8 +153,9 @@ REGISTRES: dict = {
         "titre": "Domaines publics",
         "fichier": "plan/domaines.yml",
         "racine": "domaines_publics",
+        "clef": {"libelle": "Domaine", "aide": "Le nom public, ex. `chezlepro.ca`."},
         "champs": {
-            "autorite":    {"type": "string", "enum": sorted(AUTORITES_DNS), "libelle": "Autorite DNS"},
+            "autorite":    {"type": "string", "enum": sorted(AUTORITES_DNS), "libelle": "Autorité DNS"},
             "edge":        {"type": "string", "libelle": "Edge", "source_valeurs": "serveurs"},
             "secondaires": {"type": "array", "items": {"type": "string"}, "libelle": "Secondaires"},
             "dnssec":      {"type": "boolean", "libelle": "DNSSEC"},
@@ -162,28 +177,28 @@ REGISTRES: dict = {
             # tous les plans et absents du schema — donc un formulaire genere n'aurait
             # jamais su les editer, exactement le trou que la nomenclature avait deja
             # dans `CHAMPS_ECRITS_PAR_GUI` (zero champ declare).
-            "categories":   {"type": "object", "libelle": "Categories (zones)",
+            "categories":   {"type": "object", "libelle": "Catégories (zones)",
                              "aide": "Une zone de securite par cle. Le numero derive le 3e octet et le VLAN.",
                              "entree": {
                                  "libelle": {"type": "string", "requis": True,
-                                             "libelle": "Libelle",
+                                             "libelle": "Libellé",
                                              "aide": "Nom lisible de la zone (Frontiere, Identite...)."}}},
             "fonctions":    {"type": "object", "libelle": "Fonctions",
                              "aide": "categorie + service par fonction. VMID et IP en derivent.",
                              "entree": {
                                  "categorie": {"type": "integer", "requis": True,
-                                               "libelle": "Categorie",
+                                               "libelle": "Catégorie",
                                                "aide": "La zone. Fixe le 3e octet (15 + categorie) et le VLAN."},
                                  "service":   {"type": "integer", "requis": True,
                                                "libelle": "Service",
                                                "aide": "Fixe le bloc d'adresses de l'hote dans la zone."}}},
-            "reservations": {"type": "object", "libelle": "Reservations",
+            "reservations": {"type": "object", "libelle": "Réservations",
                              "aide": "Adresses soustraites a la derivation dans chaque zone.",
                              "entree": {
                                  "passerelle":  {"type": "integer", "libelle": "Passerelle",
                                                  "aide": "Dernier octet de la passerelle. P23 refuse un SVI qui s'en ecarte."},
-                                 "reserve_min": {"type": "integer", "libelle": "Reserve (min)"},
-                                 "reserve_max": {"type": "integer", "libelle": "Reserve (max)"}}},
+                                 "reserve_min": {"type": "integer", "libelle": "Réserve (min)"},
+                                 "reserve_max": {"type": "integer", "libelle": "Réserve (max)"}}},
         },
     },
 }
@@ -198,7 +213,7 @@ def construire() -> dict:
             p = {"type": d["type"], "title": d["libelle"]}
             for cle_src, cle_dst in (("aide", "description"), ("enum", "enum"),
                                      ("items", "items"), ("minimum", "minimum"),
-                                     ("maximum", "maximum")):
+                                     ("maximum", "maximum"), ("defaut", "default")):
                 if cle_src in d:
                     p[cle_dst] = d[cle_src]
             if "entree" in d:
@@ -216,6 +231,10 @@ def construire() -> dict:
                                              "additionalProperties": False}
                 if sous_requis:
                     p["additionalProperties"]["required"] = sorted(sous_requis)
+            if "source_selon" in d:
+                # Meme intention que `x-source-valeurs`, mais la liste change selon la
+                # valeur d'un autre champ de la meme entite.
+                p["x-source-selon"] = d["source_selon"]
             if "source_valeurs" in d:
                 # Extension hors JSON Schema : dit au formulaire d'offrir une LISTE
                 # fermee, alimentee a l'execution. C'est ce qui rend l'hote fantome
@@ -230,6 +249,11 @@ def construire() -> dict:
             entite["required"] = sorted(requis)
         defs[nom] = {"title": reg["titre"], "x-fichier": reg["fichier"],
                      "x-racine": reg["racine"], "entite": entite}
+        if reg.get("clef"):
+            # La CLEF n'est pas une propriete de l'entite — c'est son nom dans la table.
+            # Le formulaire doit pourtant l'offrir : sans elle, on ne peut pas creer.
+            defs[nom]["x-clef"] = {"title": reg["clef"]["libelle"],
+                                   "description": reg["clef"]["aide"]}
     return {
         "$schema": "https://json-schema.org/draft/2020-12/schema",
         "title": "Registres du plan Set-OPS",