@mostajs/kind-catalog 0.1.1 → 0.3.0

package/CHANGELOG.md

@@ -2,6 +2,92 @@
 
 **Auteur** : Dr Hamid MADANI <drmdh@msn.com>
 
+## 0.3.0 — 2026-09-04
+
+### Ajouté — `diagnostiquer()` : le tranchant « AMÉLIORER »
+
+Lire le plan d'une application et lui dire **ce qui lui manque**. Livrable en une heure, sur un
+plan qu'on nous donne, sans toucher au code.
+
+> *« Votre plan porte quatre exigences de périmètre. La fiche en connaît six erreurs. Trois ne sont
+> mentionnées nulle part chez vous — voici lesquelles, et ce qu'elles coûtent. »*
+
+**Les deux sorties sont DÉCOUPLÉES, et c'est le point.** Elles n'ont pas le même optimum, et les
+lier faisait taire l'une pour l'autre :
+
+- les **occurrences** proposées demandent de la **précision** — à deux mots communs, le diagnostic
+  proposait **vingt-sept** occurrences pour une seule règle : personne ne confirme vingt-sept
+  lignes. Seuil porté à cinq, liste courte ;
+- les **erreurs non couvertes** demandent du **rappel** — c'est le livrable, et taire celle qui
+  manque coûte bien plus que d'en proposer une déjà couverte. Elles sont cherchées dans **tout** le
+  plan, et rendues **même quand aucune exigence n'a pu être rapprochée**.
+
+Une règle **transverse** rend ses erreurs dans tous les cas ; une règle **métier** seulement si une
+exigence l'a désignée — sinon un plan universitaire recevrait les pièges de l'apiculture.
+
+**Il propose, il n'applique pas** (`T-KC-21`), et **chaque candidat rend les mots qui l'ont
+désigné** (`T-KC-17`) : un score opaque ne se conteste pas, donc il ne se corrige jamais. C'est
+`KIND-ECRITURE-GARDEE-01` appliqué à l'outil lui-même.
+
+**Il ne modifie pas le plan qu'il lit** (`T-KC-20`).
+
+### Enrichi — l'âge d'une donnée, et non son effacement
+
+`KIND-CHIFFRE-SANS-SOURCE-01` gagne **TicketFlow 2.0** et **`@mostajs/paiement-tpe`** — quatre
+projets indépendants — et deux erreurs que ces projets ont fait apparaître :
+
+- **la valeur périmée est présentée sans son âge** → *elle a l'air normale, donc personne ne la
+  vérifie. Un affichage périmé qui a l'air normal coûte plus cher qu'un affichage qui avoue son
+  âge : le second se corrige, le premier se propage en décision.*
+- **la valeur périmée est simplement effacée** → *on perd la dernière valeur CONNUE, souvent
+  utile. Les deux remèdes ne se valent pas : DATER conserve l'information, BASCULER la jette.*
+
+C'est la nuance que CollabTrax (« bascule en sans données ») et TicketFlow (« file au 04/09 à
+11h12 ») ont résolue différemment. La fiche porte désormais les deux, avec leur compromis.
+
+`@mostajs/paiement-tpe` y entre par son `sonder()` qui rend `'inconnu'` et jamais `false` — *« qui
+ferait croire l'appareil en panne alors qu'on n'en sait rien »*.
+
+**21 fiches · 86 erreurs cataloguées · 38 incidents · 32 essais.**
+
+## 0.2.0 — 2026-09-03
+
+### Ajouté — `enrichir()` : projeter pour CRÉER, enrichir pour EXPLOITER
+
+Le passage à qatrax a rendu visible une faute de modèle, et le critère qui la tranche :
+
+> **Dans le RÉFÉRENTIEL, une même règle deux fois est une duplication. Dans une APPLICATION, la
+> même règle appliquée à un objet précis est une OCCURRENCE d'exploitation — et il en faut autant
+> qu'il y a d'objets.**
+
+`toDevtest` projetait la règle **générique** dans le plan de l'application : ni référentiel, ni
+occurrence — **la règle recopiée**. ATC portait déjà **quatre** occurrences du périmètre (le
+portail, le coaching, l'e-learning, le cumul de rôles) et recevait une cinquième exigence qui ne
+parlait de rien. RestoTrax de même, avec `PIL-10` à `PIL-13`.
+
+```js
+enrichir(plan, { kind, specRefs: ['SPEC-POR-01', 'SPEC-COA-01', 'SPEC-ELE-01', 'SPEC-ROL-02'] })
+```
+
+Les erreurs connues de la fiche descendent dans les exigences **que l'application a déjà**.
+**Aucune exigence, aucun essai n'est ajouté** — ce qui referme *par construction* le défaut que
+qatrax avait signalé : des cas de plan que rien ne peut exécuter, parce qu'ils prétendaient qu'un
+essai portant un autre nom les couvrait.
+
+`toDevtest` garde son emploi : une application **neuve**, sans aucune exigence, à qui la fiche
+donne les siennes.
+
+**Rejouable** (`T-KC-14`) : le bloc est borné par un marqueur et se remplace au lieu de s'empiler —
+le script d'une application se relance à chaque montée du catalogue.
+
+**Refuse plutôt que de faire semblant** (`T-KC-15`) : une exigence introuvable — renommée, le plus
+souvent — est une erreur, pas un avertissement ; et enrichir sans rien désigner est refusé, parce
+que c'est ne rien faire tout en croyant l'avoir fait.
+
+`retirerProjection()` reprend ce qu'une projection avait posé, pour les applications qui basculent.
+
+27 essais.
+
 ## 0.1.1 — 2026-09-03
 
 ### Ajouté — `bind` : lier une épreuve à l'essai qui la couvre DÉJÀ

package/docs/DEVTEST-PLAN.kind-catalog.json

@@ -41,6 +41,18 @@
       "title": "Le corpus livré est valide, sourcé et lisible",
       "priority": "critical",
       "status": "verified"
+    },
+    {
+      "ref": "SPEC-KC-08",
+      "title": "ENRICHIR les occurrences existantes plutôt que RECOPIER la règle dans le plan de l'application",
+      "priority": "critical",
+      "status": "verified"
+    },
+    {
+      "ref": "SPEC-KC-09",
+      "title": "DIAGNOSTIQUER un plan existant : proposer les occurrences, NOMMER les erreurs qu'il ne mentionne pas",
+      "priority": "critical",
+      "status": "verified"
     }
   ],
   "realisations": [
@@ -97,6 +109,24 @@
       "artifact": "src/",
       "progress": 100,
       "status": "done"
+    },
+    {
+      "ref": "REL-KC-08",
+      "specRef": "SPEC-KC-08",
+      "kind": "feature",
+      "title": "enrichir() · retirerProjection()",
+      "artifact": "src/enrichir.js",
+      "progress": 100,
+      "status": "done"
+    },
+    {
+      "ref": "REL-KC-09",
+      "specRef": "SPEC-KC-09",
+      "kind": "feature",
+      "title": "diagnostiquer() · rapportDiagnostic()",
+      "artifact": "src/diagnostic.js",
+      "progress": 100,
+      "status": "done"
     }
   ],
   "tests": [
@@ -421,6 +451,132 @@
           "expected": "la liée est `automated` avec son renvoi ; l'autre est `manual` sans renvoi — la déclarer automatisée prétendrait qu'un essai la couvre, et ouvrirait un trou dans la porte qualité de l'application"
         }
       ]
+    },
+    {
+      "ref": "T-KC-13",
+      "specRef": "SPEC-KC-08",
+      "type": "automated",
+      "priority": "critical",
+      "title": "T-KC-13 — enrichir dépose les erreurs dans les exigences EXISTANTES, sans rien ajouter",
+      "autoRef": "test-scripts/unit/catalogue.test.mjs::T-KC-13",
+      "steps": [
+        {
+          "action": "enrichir deux exigences d'un plan",
+          "expected": "les descriptions reçoivent les erreurs connues ; aucune exigence ni aucun essai n'est ajouté — c'est ce qui referme le défaut des cas que rien ne peut exécuter"
+        }
+      ]
+    },
+    {
+      "ref": "T-KC-14",
+      "specRef": "SPEC-KC-08",
+      "type": "automated",
+      "priority": "critical",
+      "title": "T-KC-14 — enrichir deux fois ne DOUBLE pas le bloc",
+      "autoRef": "test-scripts/unit/catalogue.test.mjs::T-KC-14",
+      "steps": [
+        {
+          "action": "rejouer l'enrichissement",
+          "expected": "description inchangée — le script d'une application se rejoue à chaque montée du catalogue"
+        }
+      ]
+    },
+    {
+      "ref": "T-KC-15",
+      "specRef": "SPEC-KC-08",
+      "type": "automated",
+      "priority": "critical",
+      "title": "T-KC-15 — enrichir REFUSE une exigence introuvable, et refuse de ne rien désigner",
+      "autoRef": "test-scripts/unit/catalogue.test.mjs::T-KC-15",
+      "steps": [
+        {
+          "action": "exigence renommée, puis liste vide",
+          "expected": "refus des deux — une exigence renommée ferait partir l'enrichissement dans le vide, en silence"
+        }
+      ]
+    },
+    {
+      "ref": "T-KC-16",
+      "specRef": "SPEC-KC-08",
+      "type": "automated",
+      "priority": "critical",
+      "title": "T-KC-16 — `retirerProjection` reprend ce qu'une projection avait posé",
+      "autoRef": "test-scripts/unit/catalogue.test.mjs::T-KC-16",
+      "steps": [
+        {
+          "action": "projeter puis retirer",
+          "expected": "les entrées projetées disparaissent, celles de l'application survivent"
+        }
+      ]
+    },
+    {
+      "ref": "T-KC-17",
+      "specRef": "SPEC-KC-09",
+      "type": "automated",
+      "priority": "critical",
+      "title": "T-KC-17 — le diagnostic PROPOSE une occurrence et rend LES MOTS qui l'ont désignée",
+      "autoRef": "test-scripts/unit/catalogue.test.mjs::T-KC-17",
+      "steps": [
+        {
+          "action": "auditer un plan qui porte une exigence de périmètre",
+          "expected": "l'occurrence est proposée avec les mots communs — un score opaque ne se conteste pas, donc il ne se corrige jamais"
+        }
+      ]
+    },
+    {
+      "ref": "T-KC-18",
+      "specRef": "SPEC-KC-09",
+      "type": "automated",
+      "priority": "critical",
+      "title": "T-KC-18 — il NOMME les erreurs connues que le plan ne mentionne nulle part",
+      "autoRef": "test-scripts/unit/catalogue.test.mjs::T-KC-18",
+      "steps": [
+        {
+          "action": "auditer un plan d'une seule exigence",
+          "expected": "les manques sont nommés, chacun avec sa conséquence"
+        }
+      ]
+    },
+    {
+      "ref": "T-KC-19",
+      "specRef": "SPEC-KC-09",
+      "type": "automated",
+      "priority": "critical",
+      "title": "T-KC-19 — les deux sorties sont DÉCOUPLÉES : une règle transverse parle même sans occurrence",
+      "autoRef": "test-scripts/unit/catalogue.test.mjs::T-KC-19",
+      "steps": [
+        {
+          "action": "auditer un plan sans rapport avec le catalogue",
+          "expected": "les règles transverses rendent leurs erreurs ; les règles métier se taisent — sinon un plan de bordereaux reçoit les pièges de l'apiculture"
+        }
+      ]
+    },
+    {
+      "ref": "T-KC-20",
+      "specRef": "SPEC-KC-09",
+      "type": "automated",
+      "priority": "critical",
+      "title": "T-KC-20 — le diagnostic NE MODIFIE PAS le plan qu'il lit",
+      "autoRef": "test-scripts/unit/catalogue.test.mjs::T-KC-20",
+      "steps": [
+        {
+          "action": "auditer puis comparer le plan",
+          "expected": "intact — un audit qui change son objet ne distingue plus ce qui venait du plan"
+        }
+      ]
+    },
+    {
+      "ref": "T-KC-21",
+      "specRef": "SPEC-KC-09",
+      "type": "automated",
+      "priority": "critical",
+      "title": "T-KC-21 — le rapport dit que les rapprochements sont PROPOSÉS, jamais appliqués",
+      "autoRef": "test-scripts/unit/catalogue.test.mjs::T-KC-21",
+      "steps": [
+        {
+          "action": "relire le rapport rendu",
+          "expected": "la mention y est, ainsi que l'explicabilité — c'est KIND-ECRITURE-GARDEE-01 appliqué à l'outil lui-même"
+        }
+      ]
     }
   ]
 }

package/docs/PLAN-DEV-KIND-CATALOG.md

@@ -100,7 +100,9 @@ ce sont ceux qu'on omet, et ce sont ceux qui servent.
 |---|---|---|
 | **0.1.0** | fiche + validation + projection + instanciation + corpus initial (5 fiches tirées d'incidents réels) | §11.1 : essais mjs-unit verts, plan DEVTEST à trois trous nuls |
 | 0.2.0 | index inverse des emplois (B5), `findKinds` enrichi, premières fiches **agronomie** et **électronique** | corpus ≥ 15 fiches, ≥ 2 applications instanciées |
-| 0.3.0 | pont `assistant-pilote` : une fiche déclare son `kind` ro-pla et devient une question activable | une question née d'une fiche, activée en production |
+| **0.3.0-a** | **AMÉLIORER** — `diagnostiquer(plan, kinds)` : rapproche les exigences d'une application des fiches, **propose** la correspondance, et NOMME les erreurs connues qu'aucune exigence ne mentionne | un audit rendu sur le plan d'une application tierce, sans toucher au code |
+| **0.3.0-b** | **BÂTIR** — `demarrer({ domaines, project, prefix })` : plan de départ complet, épreuves **manuelles** | un projet neuf démarre sur un plan qu'il n'a pas écrit |
+| 0.4.0 | pont `assistant-pilote` : une fiche déclare son `kind` ro-pla et devient une question activable | une question née d'une fiche, activée en production |
 
 ### Le corpus initial de 0.1.0 — **des incidents réels, pas des suppositions**
 
@@ -112,6 +114,55 @@ ce sont ceux qu'on omet, et ce sont ceux qui servent.
 | `KIND-ACQUIS-01` — consulter un acquis ne doit pas l'effacer | `@mostajs/elearning` | `apprentissage` |
 | `KIND-DONNEE-INSUFFISANTE-01` — un calcul sur trop peu de données doit REFUSER, en chiffrant ce qui manque | RestoTrax, ATC | `decision` |
 
+## 4.bis · L'OUTIL À DOUBLE TRANCHANT *(orientation produit, 03/09/2026)*
+
+Le critère « duplication au référentiel / occurrence à l'application » a séparé deux fonctions.
+Elles ne sont pas deux options techniques : ce sont **deux produits, pour deux marchés**.
+
+| | **BÂTIR** | **AMÉLIORER** |
+|---|---|---|
+| fonction | `toDevtest` | `enrichir` |
+| à qui | un projet qui **commence** | un projet qui **tourne** |
+| ce qu'il reçoit | ses exigences de départ, avec leurs épreuves | les erreurs connues, dans ses exigences à lui |
+| ce qu'il évite | écrire un plan de test depuis une page blanche | repayer un défaut qu'un autre a déjà payé |
+| valeur perçue | « on démarre juste » | **« vous avez six erreurs connues que votre plan ne mentionne nulle part »** |
+| marché | projets neufs | **le parc existant — bien plus vaste** |
+
+### Ce que chaque tranchant exige encore
+
+**BÂTIR — il manque la SÉLECTION.** Aujourd'hui l'application nomme ses fiches une par une. Un
+assistant de démarrage part du **domaine** : *« un logiciel de gestion d'élèves »* → les fiches
+`acces`, `donnees`, `decision`, plus le métier. `findKinds({ domaine })` existe ; ce qui manque est
+un `demarrer({ domaines, project, prefix })` qui rende un plan de départ complet, dont les épreuves
+sont **manuelles** — un travail à faire, honnêtement affiché, jamais un plan qui prétend être tenu.
+
+**AMÉLIORER — il manque le DIAGNOSTIC, et c'est le vrai produit.** Aujourd'hui l'humain déclare la
+correspondance (`occurrences: ['SPEC-POR-01', …]`). Ce qui a de la valeur, c'est l'inverse : **lire
+le plan d'une application et lui dire ce qui lui manque**.
+
+> *« Votre plan porte quatre exigences de périmètre. La fiche en connaît six erreurs. Trois ne sont
+> mentionnées nulle part chez vous — voici lesquelles, et ce qu'elles coûtent. »*
+
+C'est un audit livrable **en une heure**, sur un plan qu'on nous donne, sans toucher au code.
+
+### ⚠️ Le diagnostic PROPOSE, il n'applique pas
+
+Un rapprochement automatique entre les exigences d'une application et les fiches du catalogue **se
+trompera** : les intitulés varient, les métiers diffèrent, une ressemblance de mots n'est pas une
+identité de règle. Un outil qui appliquerait ses rapprochements tout seul poserait des blocs
+d'erreurs sur des exigences qui n'ont rien à voir, et ruinerait la confiance dans les blocs justes.
+
+**Il propose une correspondance ; l'humain confirme.** C'est `KIND-ECRITURE-GARDEE-01`, appliqué à
+l'outil lui-même — et c'est la meilleure démonstration possible du catalogue : il tient sa propre
+règle sur son propre produit.
+
+### Ce que cela change à la feuille de route
+
+Le jalon **0.3.0** devient double, et la partie « améliorer » passe devant : c'est elle qui se vend
+sans qu'un projet ait besoin de commencer.
+
+---
+
 ## 5.bis · Les DOMAINES du catalogue
 
 Un `domaine` regroupe les fiches d'un même métier. Le vocabulaire est **ouvert** — un domaine

package/kinds/chiffres.kind.mjs

@@ -16,6 +16,7 @@ export const kinds = [
       'chaque valeur affichée provient d’une source RÉELLEMENT interrogée',
       'chaque compteur est cliquable vers la liste qui le compose',
       'la fraîcheur de chaque valeur est visible, et au-delà du seuil la valeur bascule en « sans données »',
+      'un affichage périmé AVOUE SON ÂGE — « au 04/09 à 11h12 » — plutôt que de présenter un chiffre comme actuel',
       'trois états, et trois seulement : non branché · branché sans données · branché réel',
     ],
     erreurs: [
@@ -25,6 +26,10 @@ export const kinds = [
         consequence: 'zéro est un FAIT ; « je ne sais pas » n’en est pas un. On lit une chute d’activité là où il y a une panne de collecte' },
       { titre: 'la valeur périmée continue d’être servie',
         consequence: 'le tableau de bord affiche avec le même aplomb une mesure d’hier et une d’il y a six mois' },
+      { titre: 'la valeur périmée est présentée SANS SON ÂGE',
+        consequence: 'elle a l’air normale, donc personne ne la vérifie. **Un affichage périmé qui a l’air normal coûte plus cher qu’un affichage qui avoue son âge** — le second se corrige, le premier se propage en décision' },
+      { titre: 'la valeur périmée est simplement effacée au profit de « sans données »',
+        consequence: 'on perd la dernière valeur CONNUE, qui reste souvent utile — mieux vaut « au 04/09 à 11h12 » que rien du tout. Les deux remèdes ne se valent pas : DATER conserve l’information, BASCULER la jette' },
       { titre: 'le compteur ne mène nulle part',
         consequence: 'un chiffre qu’on ne peut pas ouvrir ne se conteste pas — donc il ne se corrige jamais' },
       { titre: 'un second tableau de suivi est tenu à la main à côté',
@@ -32,7 +37,7 @@ export const kinds = [
     ],
     test: [
       { action: 'couper une source, puis afficher', attendu: '« sans données », jamais zéro' },
-      { action: 'vieillir une valeur au-delà du seuil de fraîcheur', attendu: 'elle bascule en « sans données » et le dit' },
+      { action: 'vieillir une valeur au-delà du seuil de fraîcheur', attendu: 'son ÂGE est affiché — « au 04/09 à 11h12 » — ou elle bascule en « sans données » ; jamais présentée comme actuelle' },
       { action: 'chercher dans le rendu un nombre absent des sources', attendu: 'aucun' },
       { action: 'suivre un compteur', attendu: 'il ouvre la liste filtrée qui le compose' },
     ],
@@ -40,6 +45,8 @@ export const kinds = [
     origine: [
       { type: 'incident', source: 'CollabTrax — « N’afficher aucune valeur sans source interrogée : jamais de nombre en dur, jamais de valeur d’exemple » ; trois états ; fraîcheur ; compteur cliquable', date: '2026-08-03' },
       { type: 'incident', source: 'ATC — le pilotage compose @mostajs/reporting ; la vue ne recalcule aucun total (T-PIL-10)', date: '2026-09-01' },
+      { type: 'incident', source: 'TicketFlow 2.0 — la page affiche l’ÂGE de la donnée : « file au 04/09 à 11h12 » quand le site est déconnecté, et non un chiffre présenté comme actuel', date: '2026-09-04' },
+      { type: 'incident', source: '@mostajs/paiement-tpe — `sonder()` rend « inconnu », jamais `false`, qui ferait croire l’appareil en panne alors qu’on n’en sait rien', date: '2026-08-20' },
     ],
   }),
 

package/kinds/integration.kind.mjs

@@ -78,6 +78,7 @@ export const kinds = [
       { type: 'incident', source: 'LabTrax — « Fonctionner central injoignable : la perte du lien n’empêche NI le pointage, NI la délibération »', date: '2026-08-31' },
       { type: 'incident', source: 'SofTrax — « La révocation est signée donc opposable hors ligne, et coupe l’activation »', date: '2026-08-20' },
       { type: 'incident', source: 'LabTraxAdmin — même exigence, côté central : la licence ne se demande pas depuis l’instance', date: '2026-08-25' },
+      { type: 'incident', source: 'TicketFlow 2.0 — site déconnecté : la page le DIT et date la donnée, au lieu de servir un chiffre d’allure normale', date: '2026-09-04' },
     ],
   }),
 ];

package/llms.txt

@@ -28,7 +28,15 @@ PIÈGES
   - Les fiches sont des FICHIERS VERSIONNES (kinds/*.kind.mjs). Ce qui va en base, c'est l'USAGE —
     et cela appartient a @mostajs/skill-library et au journal d'@mostajs/assistant-pilote.
   - AUCUN FORMAT NOUVEAU : la projection produit du mostajs-devtest/1, valide par le parseur officiel.
+  - PROJETER POUR CREER, ENRICHIR POUR EXPLOITER. Dans le REFERENTIEL, une regle deux fois = duplication ;
+    dans une APPLICATION, la regle appliquee a un objet = OCCURRENCE, et il en faut autant qu'il y a d'objets.
+    toDevtest = app NEUVE (elle recoit ses exigences) · enrichir = app EXISTANTE (ses occurrences recoivent
+    les erreurs connues). enrichir n'AJOUTE ni exigence ni essai — sinon qatrax porte des cas inexecutables.
   - loadCatalogue() fait un import() : charger un corpus, c'est EXECUTER du code. Une fiche se revoit
     comme du code, jamais comme un document (docs/15-REVUE-SECURITE).
   - validateKind() applique les memes defauts que defineKind : on peut lui passer un objet BRUT.
+  - DIAGNOSTIC : les deux sorties sont DECOUPLEES. Occurrences = precision (seuil 5 ; a 2 il en proposait
+    27 pour une regle). Erreurs non couvertes = rappel, cherchees dans TOUT le plan, rendues meme sans
+    occurrence. Regle TRANSVERSE parle toujours ; regle METIER seulement si reconnue.
+  - Le diagnostic PROPOSE, il n'applique pas, et il ne modifie pas le plan qu'il lit.
 CORPUS LIVRE  21 fiches · 15 eprouvees (71 %) · 84 erreurs cataloguees · 35 incidents · 11 domaines.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mostajs/kind-catalog",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Catalogue de KINDS — fiches d'exigence réutilisables, projetables en plan mostajs-devtest/1 lisible par qatrax. N'exécute rien, ne stocke rien.",
   "type": "module",
   "license": "AGPL-3.0-or-later",

package/src/diagnostic.js

@@ -0,0 +1,165 @@
+/**
+ * DIAGNOSTIQUER — lire le plan d'une application et lui dire ce qui lui MANQUE.
+ *
+ * ── LE TRANCHANT « AMÉLIORER » ─────────────────────────────────────────────
+ * Le catalogue sert deux fois : à BÂTIR (une application neuve reçoit ses exigences) et à
+ * AMÉLIORER (une application qui tourne reçoit ce que d'autres ont payé). Ce fichier est le
+ * second, et c'est celui qui se rend en une heure, sur un plan qu'on nous donne, sans toucher au
+ * code :
+ *
+ *   « Votre plan porte quatre exigences de périmètre. La fiche en connaît six erreurs.
+ *     Trois ne sont mentionnées nulle part chez vous — voici lesquelles, et ce qu'elles coûtent. »
+ *
+ * ⚠️ IL PROPOSE, IL N'APPLIQUE PAS. Un rapprochement automatique entre les exigences d'une
+ * application et les fiches SE TROMPERA : les intitulés varient, les métiers diffèrent, et une
+ * ressemblance de mots n'est pas une identité de règle. Un outil qui appliquerait ses
+ * rapprochements tout seul poserait des blocs d'erreurs sur des exigences sans rapport, et
+ * ruinerait la confiance dans les blocs justes. C'est `KIND-ECRITURE-GARDEE-01` appliqué à
+ * l'outil lui-même.
+ *
+ * ⚠️ LE RAPPROCHEMENT EST EXPLICABLE, ET C'EST SA SEULE DÉFENSE. Chaque candidat rend LES MOTS
+ * qui l'ont désigné : un score opaque serait pire que pas de score du tout — on ne peut ni le
+ * contester ni le corriger.
+ *
+ * Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+ */
+
+/** Mots vides du français — ils apparaissent partout et ne désignent rien. */
+const VIDES = new Set(`le la les un une des du de d au aux et ou ni mais donc or car que qui quoi
+dont ou sur sous dans par pour avec sans vers chez entre est sont etre ete a ont avoir plus moins
+tres peu tout tous toute toutes meme aussi ainsi alors quand comme si ne pas non oui son sa ses
+leur leurs notre nos votre vos ce cet cette ces cela ceci il elle ils elles on nous vous je tu
+doit doivent peut peuvent faire fait fais rien jamais toujours deja encore apres avant lors
+chaque autre autres bien mal seul seule sauf selon`.split(/\s+/).filter(Boolean));
+
+/** Normalise : minuscules, sans accents, sans ponctuation. */
+export const normaliser = (t) => String(t ?? '')
+  .toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '')
+  .replace(/[^a-z0-9]+/g, ' ').trim();
+
+/** Les mots qui DÉSIGNENT quelque chose — au moins cinq lettres, hors mots vides. */
+export function motsCles(texte) {
+  return new Set(normaliser(texte).split(' ').filter((m) => m.length >= 5 && !VIDES.has(m)));
+}
+
+const commun = (a, b) => [...a].filter((m) => b.has(m));
+
+/** Tout le texte d'une exigence, épreuves comprises : c'est là que la règle se dit. */
+function texteDeSpec(plan, spec) {
+  const essais = (plan.tests ?? []).filter((t) => t.specRef === spec.ref);
+  return [spec.title, spec.description,
+    ...essais.flatMap((t) => [t.title, ...(t.steps ?? []).flatMap((s) => [s.action, s.expected])])]
+    .filter(Boolean).join(' ');
+}
+
+/**
+ * Les domaines TRANSVERSES : leurs règles valent pour tout logiciel, qu'on ait su rapprocher une
+ * exigence ou non. Les domaines MÉTIER, eux, ne concernent que les applications de ce métier.
+ */
+export const TRANSVERSES = new Set(['acces', 'donnees', 'apprentissage', 'decision', 'integration']);
+
+/**
+ * Diagnostique un plan contre un corpus.
+ *
+ * ⚠️ LES DEUX SORTIES SONT DÉCOUPLÉES, ET C'EST LE POINT. Elles n'ont pas le même seuil optimal,
+ * et les lier faisait taire l'une pour l'autre :
+ *
+ *   · les OCCURRENCES proposées demandent de la PRÉCISION — l'humain doit les confirmer, et
+ *     personne ne confirme vingt-sept lignes. Seuil haut, liste courte.
+ *   · les ERREURS NON COUVERTES demandent du RAPPEL — c'est le livrable, et taire celle qui
+ *     manque coûte bien plus que d'en proposer une déjà couverte. Elles sont calculées sur TOUT
+ *     le plan, et rendues même quand aucune exigence n'a pu être rapprochée.
+ *
+ * Une règle TRANSVERSE rend ses erreurs dans tous les cas ; une règle MÉTIER seulement si une
+ * exigence l'a désignée — sinon un plan universitaire recevrait les pièges de l'apiculture.
+ *
+ * @param {object} plan   plan `mostajs-devtest/1` — NON modifié
+ * @param {object[]} kinds
+ * @param {object} [o]
+ * @param {number} [o.minCommuns]  mots communs exigés pour PROPOSER une occurrence (défaut 5)
+ * @returns {object[]} un rapport par fiche
+ */
+export function diagnostiquer(plan, kinds = [], { minCommuns = 5 } = {}) {
+  if (!plan?.specs) throw new Error('diagnostiquer: plan `mostajs-devtest/1` requis');
+  const toutLePlan = motsCles([
+    ...plan.specs.map((s) => `${s.title} ${s.description ?? ''}`),
+    ...(plan.tests ?? []).flatMap((t) => [t.title, ...(t.steps ?? []).flatMap((x) => [x.action, x.expected])]),
+  ].join(' '));
+
+  return kinds.map((k) => {
+    const cles = motsCles(`${k.enonce} ${k.succes.join(' ')} ${k.erreurs.map((e) => e.titre).join(' ')}`);
+
+    // 1 · LES OCCURRENCES CANDIDATES — proposées, jamais posées.
+    const occurrences = [];
+    for (const s of plan.specs) {
+      const c = commun(cles, motsCles(texteDeSpec(plan, s)));
+      if (c.length >= minCommuns) occurrences.push({ specRef: s.ref, titre: s.title, communs: c.sort() });
+    }
+    occurrences.sort((a, b) => b.communs.length - a.communs.length);
+
+    // 2 · LES ERREURS QUE LE PLAN NE MENTIONNE NULLE PART — c'est le livrable.
+    // Une erreur est tenue pour COUVERTE si le plan emploie la moitié de ses mots désignants.
+    // ⚠️ Le seuil est délibérément BAS : mieux vaut proposer une erreur déjà couverte — l'humain
+    // l'écarte en dix secondes — que taire celle qui manque, qu'il ne cherchera jamais.
+    const erreursNonCouvertes = k.erreurs.filter((e) => {
+      const mots = motsCles(`${e.titre} ${e.consequence}`);
+      if (mots.size === 0) return false;
+      return commun(mots, toutLePlan).length < Math.max(2, Math.ceil(mots.size / 2));
+    });
+
+    const transverse = TRANSVERSES.has(k.domaine);
+    return {
+      kind: k.ref, domaine: k.domaine, verdict: k.verdict, enonce: k.enonce,
+      occurrences,
+      couverte: occurrences.length > 0,
+      transverse,
+      erreurs: k.erreurs.length,
+      // Une règle métier non rapprochée ne dit rien : elle ne concerne pas cette application.
+      erreursNonCouvertes: (transverse || occurrences.length) ? erreursNonCouvertes : [],
+    };
+  }).sort((a, b) => b.occurrences.length - a.occurrences.length);
+}
+
+/** Le rapport en texte — c'est lui qu'on présente. */
+export function rapportDiagnostic(diag, { titre = 'Diagnostic', maxOccurrences = 4 } = {}) {
+  const l = [`# ${titre}`, ''];
+  const aTrous = diag.filter((d) => d.erreursNonCouvertes.length);
+  const reconnues = diag.filter((d) => d.couverte);
+  const trous = aTrous.reduce((n, d) => n + d.erreursNonCouvertes.length, 0);
+
+  l.push(`**${trous}** erreur(s) connue(s) que ce plan ne mentionne nulle part, sur **${aTrous.length}** règle(s) · **${reconnues.length}** règle(s) rapprochée(s) d’au moins une exigence.`, '');
+  l.push('> ⚠️ Les rapprochements sont **proposés**, jamais appliqués : une ressemblance de mots n’est pas une identité de règle. Chaque candidat rend **les mots qui l’ont désigné**, pour qu’on puisse le contester.', '');
+  l.push('> Les erreurs, elles, sont cherchées dans **tout** le plan — titres, descriptions et épreuves. Une erreur signalée à tort s’écarte en dix secondes ; une erreur tue ne se cherche jamais.', '');
+
+  l.push('## Ce qui manque', '');
+  if (!aTrous.length) l.push('Aucune erreur connue du catalogue n’est absente de ce plan.', '');
+  for (const d of aTrous) {
+    l.push(`### ${d.kind} — ${d.enonce}`, '');
+    if (d.occurrences.length) {
+      l.push(`*Reconnue dans ${d.occurrences.length} exigence(s) :* ` + d.occurrences.slice(0, maxOccurrences).map((o) => `\`${o.specRef}\``).join(', ')
+        + (d.occurrences.length > maxOccurrences ? ` *(+${d.occurrences.length - maxOccurrences})*` : ''), '');
+    } else {
+      l.push(`*Règle transverse — aucune exigence de ce plan ne la porte explicitement.*`, '');
+    }
+    l.push(`**${d.erreursNonCouvertes.length} sur ${d.erreurs} erreur(s) connue(s) ne sont mentionnées nulle part :**`, '');
+    for (const e of d.erreursNonCouvertes) l.push(`- **${e.titre}** — ${e.consequence}`);
+    l.push('');
+  }
+
+  const propres = reconnues.filter((d) => !d.erreursNonCouvertes.length);
+  if (propres.length) {
+    l.push('## Ce qui est couvert', '');
+    l.push('Ces règles sont reconnues dans le plan, et **toutes** leurs erreurs connues y sont évoquées.', '');
+    for (const d of propres) {
+      l.push(`- \`${d.kind}\` — ${d.enonce}  *(${d.occurrences.slice(0, maxOccurrences).map((o) => o.specRef).join(', ')})*`);
+    }
+    l.push('');
+  }
+  const hors = diag.filter((d) => !d.couverte && !d.erreursNonCouvertes.length);
+  if (hors.length) {
+    l.push('## Hors périmètre apparent', '');
+    l.push('Aucune exigence ne les désigne — elles ne concernent probablement pas cette application.', '');
+    for (const d of hors) l.push(`- \`${d.kind}\` (${d.domaine})`);
+  }
+  return l.join('\n');
+}

package/src/enrichir.js

@@ -0,0 +1,91 @@
+/**
+ * ENRICHIR — faire descendre les erreurs connues d'une fiche dans les exigences QUE
+ * L'APPLICATION A DÉJÀ.
+ *
+ * ── PROJETER POUR CRÉER, ENRICHIR POUR EXPLOITER ───────────────────────────
+ * `toDevtest` sert à une application NEUVE : elle n'a aucune exigence, la fiche lui donne les
+ * siennes. `enrichir` sert à une application qui EN A DÉJÀ — et c'est le cas courant, puisqu'une
+ * fiche naît précisément de ce que des applications ont éprouvé.
+ *
+ * ⚠️ LE CRITÈRE QUI SÉPARE LES DEUX (décision du 03/09/2026, après un passage à qatrax qui l'a
+ * rendu visible) :
+ *
+ *   · dans le RÉFÉRENTIEL, une même règle deux fois est une DUPLICATION ;
+ *   · dans une APPLICATION, la même règle appliquée à un objet précis est une OCCURRENCE
+ *     d'exploitation, et il en faut autant qu'il y a d'objets.
+ *
+ * D'où la faute que cette fonction répare : projeter la règle GÉNÉRIQUE dans le plan d'une
+ * application ajoutait une exigence qui n'était appliquée à rien. Ni référentiel, ni occurrence :
+ * la règle recopiée. ATC portait déjà QUATRE occurrences du périmètre — le portail, le coaching,
+ * l'e-learning, le cumul de rôles — et recevait une cinquième exigence qui ne parlait de rien.
+ *
+ * ⚠️ ELLE N'AJOUTE NI EXIGENCE NI ESSAI. C'est ce qui referme, par construction, le défaut que
+ * qatrax avait signalé : des cas de plan que rien ne peut exécuter, parce qu'ils prétendaient
+ * qu'un essai portant un autre nom les couvrait.
+ *
+ * Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+ */
+const propre = (v) => String(v ?? '').trim();
+
+/** La borne du bloc ajouté — elle rend l'enrichissement REJOUABLE sans empiler. */
+export const marqueur = (ref) => `⟦${ref}⟧`;
+
+/** Le bloc que la fiche dépose dans une exigence de l'application. */
+export function blocDeFiche(k) {
+  return [
+    marqueur(k.ref),
+    `Fiche ${k.ref} v${k.version} (${k.verdict}) — ce que d'autres projets ont payé :`,
+    ...k.erreurs.map((e) => `⚠ ${e.titre} — ${e.consequence}`),
+  ].join('\n');
+}
+
+/**
+ * Enrichit des exigences EXISTANTES avec les erreurs connues d'une fiche.
+ *
+ * @param {object} plan     plan `mostajs-devtest/1` de l'application — modifié en place
+ * @param {object} o
+ * @param {object} o.kind      la fiche (ou son instance affinée)
+ * @param {string[]} o.specRefs les exigences de l'application qui sont des OCCURRENCES de la règle
+ * @returns {{ enrichies: string[], bloc: string }}
+ */
+export function enrichir(plan, { kind, specRefs = [] } = {}) {
+  if (!plan?.specs) throw new Error('enrichir: plan `mostajs-devtest/1` requis');
+  if (!kind?.ref) throw new Error('enrichir: fiche requise');
+  if (!specRefs.length) {
+    // ⚠️ ENRICHIR SANS DIRE QUOI, C'EST NE RIEN FAIRE — et croire l'avoir fait. On refuse plutôt
+    // que de rendre un rapport vide qui passerait pour un succès.
+    throw new Error(`enrichir(${kind.ref}) : aucune exigence désignée — une fiche s’applique à des OCCURRENCES, nommez-les`);
+  }
+
+  const bloc = blocDeFiche(kind);
+  const enrichies = [];
+  for (const ref of specRefs) {
+    const s = plan.specs.find((x) => x.ref === propre(ref));
+    // ⚠️ UNE EXIGENCE INTROUVABLE EST UNE ERREUR, pas un avertissement : le plus probable est
+    // qu'elle a été renommée, et l'enrichissement partirait alors dans le vide en silence.
+    if (!s) throw new Error(`enrichir(${kind.ref}) : exigence introuvable — ${ref}`);
+    const tete = String(s.description ?? '').split(marqueur(kind.ref))[0].trimEnd();
+    s.description = tete ? `${tete}\n\n${bloc}` : bloc;
+    enrichies.push(s.ref);
+  }
+  return { enrichies, bloc };
+}
+
+/**
+ * Retire d'un plan ce qu'une PROJECTION y avait posé — exigences, réalisations et essais.
+ * Utile une fois : quand une application passe de `toDevtest` à `enrichir`.
+ */
+export function retirerProjection(plan, { kind, prefix } = {}) {
+  const corps = propre(kind?.ref ?? kind).replace(/^KIND-/, '');
+  const p = propre(prefix).toUpperCase();
+  const cible = { specs: `SPEC-${p}-${corps}`, realisations: `REL-${p}-${corps}`, tests: `T-${p}-${corps}-` };
+  const retires = [];
+  for (const [cle, debut] of Object.entries(cible)) {
+    const reste = [];
+    for (const l of plan[cle] ?? []) {
+      if (l.ref === debut || String(l.ref).startsWith(debut)) retires.push(l.ref); else reste.push(l);
+    }
+    plan[cle] = reste;
+  }
+  return retires;
+}

package/src/index.js

@@ -1,4 +1,6 @@
 export { defineKind, validateKind, VERDICTS, PROVENANCES, DOMAINES } from './kind.js';
 export { toDevtest, PLAN_VERSION } from './projection.js';
+export { enrichir, retirerProjection, blocDeFiche, marqueur } from './enrichir.js';
+export { diagnostiquer, rapportDiagnostic, motsCles, normaliser, TRANSVERSES } from './diagnostic.js';
 export { instantiate, diffInstance, emplois, AFFINABLES } from './instance.js';
 export { loadCatalogue, findKinds, auditCatalogue, statsCatalogue } from './catalogue.js';