@mostajs/kind-catalog 0.1.0

package/docs/articles/01-ARTICLE-KIND-CATALOG.md

@@ -0,0 +1,229 @@
+# Le catalogue qu'il manquait aux exigences
+
+*Ce que vingt ans de catalogues d'erreurs nous apprennent, et pourquoi personne ne l'avait appliqué
+aux exigences.*
+
+**Auteur** : Dr Hamid MADANI <drmdh@msn.com> · **Date** : 2026-09-02
+**Livrable #17** (DEVRULES §9) · module `@mostajs/kind-catalog` 0.1.0
+
+---
+
+## Résumé
+
+En une semaine, sur deux applications en production, nous avons trouvé cinq défauts. Aucun ne
+plantait ; tous étaient silencieux ; **aucun n'était nouveau**. Chacun avait une littérature, un
+nom, parfois une norme — et rien ne les attendait dans le projet suivant.
+
+La sécurité applicative a résolu ce problème il y a vingt ans avec CWE : un catalogue d'erreurs
+connues, chacune portant **sa conséquence**, nourri par des faits observés, et **branché aux
+outils**. L'ingénierie des exigences, elle, n'a jamais eu son CWE — le meilleur catalogue de
+patrons d'exigences existant, celui de Withall (2007), n'est branché à rien et est resté un livre.
+
+`@mostajs/kind-catalog` occupe cet écart : des fiches d'exigence réutilisables portant l'énoncé, les
+critères de succès, les **erreurs connues avec leur conséquence** et les épreuves — et qui **se
+projettent dans le plan de test du projet**, au format que l'outil de suivi lit déjà. Le module
+n'exécute rien et ne stocke rien. Livré avec **12 fiches, 39 erreurs cataloguées, 10 domaines,
+50 % d'éprouvé**.
+
+---
+
+## 1 · État de l'art des outils à implémentation commune
+
+Cinq familles d'outils cataloguent quelque chose de proche. Aucune ne catalogue l'ensemble.
+
+**Les patrons d'exigences.** *Software Requirement Patterns* (Withall, 2007) est l'ancêtre direct :
+un catalogue de gabarits réutilisables, avec exemples et « considérations » — c'est-à-dire les
+pièges. Il prouve qu'une exigence se catalogue. **Il n'est branché à aucun outil**, et c'est sa
+limite décisive.
+
+**La syntaxe contrainte.** EARS (Mavin *et al.*, 2009) impose cinq formes de phrase et réduit
+l'ambiguïté. Elle contraint **l'énoncé** — ni l'épreuve, ni le mode de défaillance, ni le réemploi.
+
+**Les normes.** ISO/IEC/IEEE 29148 fixe les attributs d'une exigence, dont la **vérifiabilité** :
+une exigence non vérifiable n'en est pas une. Elle normalise la forme d'un **document**, pas un
+corpus partagé.
+
+**Les catalogues d'erreurs.** CWE, CAPEC, ATT&CK, OWASP Top 10. C'est le modèle le plus proche de
+ce que nous construisons, et il enseigne trois choses : chaque entrée porte sa **conséquence** ; le
+catalogue est nourri par des **faits observés** ; et **la brièveté fait la lecture** — CWE compte
+plus de mille entrées, et ce que les équipes lisent est le Top 10.
+
+**Les décisions d'architecture.** Les ADR (Nygard, 2011) démontrent que le bon support d'un
+document qui se **relit** est un **fichier versionné**. C'est l'argument qui a tranché notre
+question de stockage.
+
+**Le raisonnement à partir de cas.** Aamodt & Plaza (1994) : retrouver, réutiliser, **réviser**,
+retenir. La révision est une **étape du cycle**, pas un accident — c'est exactement le geste
+« réutiliser ou affiner ».
+
+---
+
+## 2 · Description des algorithmes
+
+Le module **ne contient aucun algorithme de calcul**, et c'est délibéré. Les moteurs sont ceux de
+`@mostajs/ro-pla` : 23 dialectes répartis en 12 familles — affectation (hongrois, appariement
+stable, couplage général), programmation linéaire et en nombres entiers (simplexe, séparation et
+évaluation, sac à dos), flots (coût minimal, plus court chemin, flot maximal), ordonnancement
+(chemin critique, rangement, ordonnancement de liste), files d'attente, chaînes de Markov,
+décision markovienne, satisfaction de contraintes, métaheuristiques, simulation, multiobjectif.
+
+Ce que le module apporte est d'un autre ordre : **quatre traitements**, tous déterministes et purs.
+
+**La validation d'une fiche.** Contrôle de forme, rendu comme **liste complète** de reproches et non
+au premier échec : corriger un manque pour en découvrir un autre fait abandonner.
+
+**La projection.** Transformation d'une fiche en un plan `mostajs-devtest/1` : une exigence, une
+réalisation, un essai par épreuve déclarée. Le préfixe d'application **isole** deux projets
+reprenant la même fiche. Une fiche seulement `propose` se projette en statut `draft` — jamais
+`verified`.
+
+**L'instanciation.** Application d'un ensemble d'affinages, chacun **exigeant son motif**, suivie
+d'une revalidation : on n'affine pas jusqu'à vider l'exigence de sa substance.
+
+**L'agrégation.** Index inverse des emplois, et statistiques du corpus — dont le **taux éprouvé**,
+le seul chiffre qui engage.
+
+---
+
+## 3 · Motif de sélection
+
+**Pourquoi aucun format nouveau.** Un second format aurait demandé un second validateur, un second
+import, un second écran. Et le jour où les deux divergent, **c'est le catalogue qui aurait raison
+contre les faits**. La projection produit donc du `mostajs-devtest/1`, et l'essai la soumet au
+**parseur officiel** de `@mostajs/qa-engine` — une vérification maison ne prouverait que notre
+accord avec nous-mêmes.
+
+**Pourquoi des fichiers plutôt qu'une base.** Une fiche est un document éditorial : elle se lit, se
+discute, se relit six mois plus tard. Son historique est celui d'un fichier — c'est le modèle ADR.
+Ce qui va en base, c'est ce que produit son **usage** : exécutions, indices, retours, qui
+appartiennent à `@mostajs/skill-library`. **Les deux ne se rangent pas au même endroit parce
+qu'ils n'ont pas la même durée de vie : la fiche se relit, le journal s'entasse.**
+
+**Pourquoi `succes` et `erreurs` sont les seuls champs requis en plus de l'énoncé.** Ce sont ceux
+qu'on omet, et ceux qui servent. Exiger davantage ferait que les fiches ne s'écriraient pas ;
+exiger moins produirait des titres.
+
+**Pourquoi la conséquence est obligatoire.** « Ne pas oublier le périmètre » ne se retient pas ;
+« sans lui, tout parent lit le dossier de tous les élèves » se retient. C'est la leçon de CWE, et
+elle est ici contrainte par le code.
+
+**Pourquoi la provenance a remplacé l'interdiction.** La première règle disait : *aucune fiche avant
+un cas réel*. Elle aurait produit un catalogue vide dans six métiers où le savoir existe depuis des
+décennies — un DTU, une fiche HACCP, un itinéraire technique sont des faits établis par une
+profession entière. La règle a été déplacée sur le **verdict** : une `reference` suffit à entrer en
+`propose` ; `eprouve` exige un `incident` ou un `terrain`. **La contrainte porte sur le galon,
+jamais sur l'entrée.**
+
+---
+
+## 4 · Application localisée
+
+Le corpus initial est tiré de la production de deux applications algériennes : un centre de langues
+à Mostaganem et un restaurant.
+
+**Six fiches éprouvées**, chacune datée et rattachée à son fichier : le périmètre pris pour une
+capacité (trois emplois dans une même application) ; l'écriture d'un champ hors schéma ; la mise à
+jour partielle qui écrase par `undefined` ; l'acquis effacé par la simple consultation ; l'écriture
+faite hors de l'application vivante sur un stockage à image mémoire ; le calcul rendu sur des
+données insuffisantes.
+
+**Six fiches proposées**, adossées aux corpus des métiers visés : formulation au moindre coût
+(problème du régime, Stigler 1945), transhumance apicole, ordonnancement de chantier sous
+ressources finies, traçabilité de lot (HACCP), rotation culturale, diagnostic séquentiel de panne.
+
+**Deux enseignements sont venus des métiers, et aucun domaine informatique ne les aurait donnés.**
+
+Le premier : **un seuil de données s'exprime en cycles, jamais en jours.** Deux saisons complètes
+font deux semaines en restauration, **deux ans** en grande culture, et **quelques jours par an** en
+apiculture. Une fiche transverse a dû être corrigée pour cela.
+
+Le second : **certains métiers posent leurs questions là où le logiciel ne tourne pas** — sur le
+chantier, sur l'équipement embarqué. La fiche a gagné un champ pour distinguer *où la question se
+pose* de *où elle se calcule*.
+
+---
+
+## 5 · Correspondance avec l'image #14
+
+L'image du résultat reprend les quatre stations de l'image de l'objectif — source, fiche,
+projection, applications — et la flèche de retour de l'écart tracé. **Trois différences la
+distinguent**, et elles sont l'histoire du cycle :
+
+- la station 1 montre **trois** sources empilées, non plus un seul incident : c'est la correction de
+  la règle de provenance ;
+- la fiche porte deux cases de plus, **provenance** et **verdict**, avec la mention « on ne se
+  décerne pas l'expérience » ;
+- la bande de domaines compte **dix** pastilles au lieu de neuf : l'apiculture a été demandée en
+  cours de route, et elle s'est révélée le meilleur banc d'essai du refus.
+
+L'encart chiffré — *12 fiches · 39 erreurs · 50 % éprouvé* — est absent de l'image de l'objectif :
+la mesure de l'honnêteté est née avec le produit, pas avec le plan.
+
+---
+
+## 6 · Discussion et projection d'utilisation
+
+**Ce que le dispositif ne peut pas garantir.** La provenance est **déclarative**. Rien n'empêche
+d'écrire `type: 'incident'` sur une origine inventée : le module contrôle la forme, jamais la
+vérité. Le taux éprouvé mesure une **discipline**, pas une preuve. Cela doit être dit au client
+comme à l'investisseur, faute de quoi le chiffre devient exactement ce qu'il prétend combattre.
+
+**Un risque structurel assumé.** Une fiche est un module JavaScript : la charger, c'est l'exécuter.
+Le choix « fichiers versionnés » apporte l'historique et la relecture ; il impose que **toute fiche
+se revoie comme du code**. Un corpus déclaratif fermerait ce risque au prix de la validation au
+montage — la question se rouvrira si des corpus tiers deviennent un cas d'usage.
+
+**Trois usages se dessinent.** *Ouvrir un projet* en instanciant les fiches du domaine avant
+d'écrire la première ligne. *Instruire un incident* en ajoutant l'erreur rencontrée à la fiche
+existante plutôt qu'en créant une fiche de plus. *Argumenter devant un client* en montrant ce que
+l'outil **refusera** de dire — la fiche apicole, qui admet que dix ans d'exploitation font dix
+points incomparables, convainc un homme du métier plus sûrement qu'une promesse de précision.
+
+**Ce qui décidera du succès** n'est pas le nombre de fiches, mais un indicateur unique : **combien
+d'essais issus de la projection ont réellement échoué au moins une fois**. Une fiche qui n'a jamais
+rien attrapé n'a jamais servi. Cet indicateur ne se lit pas dans le module — il se lit dans l'outil
+de suivi, et c'est cohérent : le catalogue ne vaut que branché.
+
+---
+
+## 7 · Conclusion
+
+Vingt ans de catalogues d'erreurs ont établi trois règles que personne n'avait appliquées aux
+exigences : chaque entrée porte **sa conséquence** ; le corpus est nourri par des **faits** ; et il
+ne sert que **branché à l'outillage**.
+
+Un quatrième enseignement est venu des métiers eux-mêmes, et il ne figure dans aucun corpus
+informatique : ce qui fait vivre un catalogue n'est pas la réutilisation à l'identique, **c'est
+l'écart tracé**. L'agronomie adapte l'itinéraire technique au terroir et relève l'écart ; le
+bâtiment amende le DTU par dérogation écrite. Le module l'impose : un affinage sans motif est
+refusé.
+
+Reste la question ouverte, et elle n'est pas technique : un catalogue vit s'il est **nourri**. Douze
+fiches sont un début, pas une preuve. La réponse viendra du premier praticien — agriculteur,
+conducteur de travaux, apiculteur — qui dira *« chez nous, la règle est différente parce que… »*.
+Ce jour-là, l'écart sera enregistré avec son motif, et le catalogue aura commencé à travailler.
+
+---
+
+## 8 · Références
+
+> ⚠️ **Sources citées par titre, auteur et année, sans URL ni pagination** : cet article a été
+> rédigé hors ligne. Leur vérification est un contrôle **bloquant** du plan de publication (#9)
+> avant toute diffusion.
+
+1. Withall, S. — *Software Requirement Patterns*, Microsoft Press, 2007.
+2. Mavin, A. *et al.* — *Easy Approach to Requirements Syntax (EARS)*, 2009.
+3. ISO/IEC/IEEE 29148 — *Systems and software engineering — Requirements engineering*.
+4. ISO/IEC/IEEE 29119 — *Software testing — Test documentation*.
+5. MITRE — *Common Weakness Enumeration (CWE)* ; *CAPEC* ; *ATT&CK*.
+6. OWASP — *Top 10*.
+7. Nygard, M. — *Documenting Architecture Decisions*, 2011.
+8. Aamodt, A. & Plaza, E. — *Case-Based Reasoning: Foundational Issues, Methodological Variations
+   and System Approaches*, AI Communications, 1994.
+9. Rice, J. R. — *The Algorithm Selection Problem*, Advances in Computers, 1976.
+10. Stigler, G. J. — *The Cost of Subsistence*, Journal of Farm Economics, 1945.
+11. Dantzig, G. B. — travaux sur la méthode du simplexe, 1947 et suivants.
+12. Codex Alimentarius — principes **HACCP**.
+13. DTU et CCTG — documents techniques unifiés, marchés de travaux.
+14. Documentation `@mostajs` : `DEVRULES.md`, `ro-pla`, `qa-engine`, `skill-library`,
+    `assistant-pilote`.

package/kinds/acces.kind.mjs

@@ -0,0 +1,48 @@
+// Domaine `acces` — ce qu'une permission ouvre, et ce qu'elle n'ouvre pas.
+// @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+import { defineKind } from '../src/kind.js';
+
+export const kinds = [
+  defineKind({
+    ref: 'KIND-PERIMETRE-01',
+    domaine: 'acces',
+    enonce: 'Une permission ouvre une CAPACITÉ, jamais un PÉRIMÈTRE.',
+    utilisation: 'Toute application où un rôle agit sur des instances qui ne sont pas toutes siennes — dossiers, séances, plans de suivi, commandes, transitions d’automate.',
+    besoins: [{ nom: 'lien d’appartenance', forme: '(agent, instance) => bool' }],
+    succes: [
+      'le porteur agit sur les instances qui lui reviennent',
+      'il est refusé sur celles d’autrui, sans que le refus nomme l’instance',
+      'qui détient le domaine entier agit partout, sans lien à produire',
+      'une TRANSITION d’automate exige la permission ET le périmètre — jamais l’une des deux',
+    ],
+    erreurs: [
+      { titre: 'la capacité est prise pour le périmètre',
+        consequence: 'un enseignant pointe la séance d’un collègue, un parent lit le dossier d’un autre enfant — avec exactement les mêmes droits, et l’écran ne montre rien d’anormal' },
+      { titre: 'le cumul de rôles desserre la garde',
+        consequence: 'ajouter un rôle ÉLARGIT le périmètre — c’est l’inverse de ce qu’une garde doit faire' },
+      { titre: 'le champ porteur est vide',
+        consequence: '`undefined === undefined` vaut vrai : l’instance est donnée à tout le monde, et seuls les enregistrements incomplets sont touchés' },
+      { titre: 'la capacité est accordée sans le périmètre',
+        consequence: 'l’écran s’ouvre sur une liste VIDE, sans message — la capacité sans le périmètre, c’est-à-dire rien' },
+      { titre: 'le refus nomme l’instance refusée',
+        consequence: 'on énumère, de proche en proche, qui est inscrit' },
+      { titre: 'la permission REMPLACE le périmètre sur une transition d’automate',
+        consequence: 'qui a le droit de faire avancer une commande le fait sur CELLE D’UN AUTRE — et l’historique, lui, est immuable' },
+    ],
+    test: [
+      { action: 'agir sur l’instance d’un autre porteur du même rôle', attendu: 'refus, sans nommer l’instance' },
+      { action: 'cumuler un rôle borné et un rôle libre', attendu: 'reste borné' },
+      { action: 'agir sur une instance dont le champ porteur est vide', attendu: 'refus' },
+      { action: 'accorder la capacité sans le périmètre, puis lister', attendu: 'soit une liste utile, soit un message qui explique le vide' },
+      { action: 'faire avancer l’instance d’un autre, en détenant la permission de transition', attendu: 'refus — la permission ne remplace pas le périmètre' },
+    ],
+    verdict: 'eprouve',
+    origine: [
+      { type: 'incident', source: 'ATC — presence.mjs, portail.mjs, coaching.mjs (3 emplois)', date: '2026-09-01' },
+      { type: 'incident', source: 'ATC — secretariat porteur de `parents:read` n’ouvrait aucun dossier', date: '2026-09-01' },
+      { type: 'incident', source: 'CRM/TRADING — gouvernance des transitions : « conserver le périmètre d’instance (assigné) COMBINÉ à la permission » (docs/AUDIT-PERMISSIONS-TRANSITIONS.md §5)', date: '2026-06-15' },
+      { type: 'incident', source: 'LabTrax — « Brancher canScan PORTÉ SUR LA SÉANCE : l’enseignant ne pointe que sa séance ou son cours, jamais celle d’un autre »', date: '2026-08-31' },
+      { type: 'reference', source: 'NIST RBAC / principe de moindre privilège' },
+    ],
+  }),
+];

package/kinds/apprentissage.kind.mjs

@@ -0,0 +1,25 @@
+// Domaine `apprentissage` — ce qu'un apprenant acquiert, et ce qu'il ne doit pas perdre.
+// @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+import { defineKind } from '../src/kind.js';
+
+export default defineKind({
+  ref: 'KIND-ACQUIS-01',
+  domaine: 'apprentissage',
+  enonce: 'Consulter un acquis ne doit jamais l’effacer.',
+  utilisation: 'Toute progression : leçon suivie, niveau atteint, étape franchie, certification.',
+  succes: ['rouvrir une étape terminée la laisse terminée', 'l’avancement ne décroît que sur un geste EXPLICITE'],
+  erreurs: [
+    { titre: 'l’ouverture remet l’étape « en cours »',
+      consequence: 'l’apprenant relit son cours et son avancement retombe — il n’a aucun moyen de comprendre pourquoi, et il n’ose plus relire' },
+    { titre: 'l’avancement compte des lignes de progression, pas des étapes existantes',
+      consequence: 'une étape retirée laisse sa trace : le fait dépasse le total, et le pourcentage franchit 100 %' },
+    { titre: 'achever une étape inexistante est accepté',
+      consequence: 'un avancement est rangé qui ne compte nulle part — invisible à l’écran, et pourtant en base' },
+  ],
+  test: [
+    { action: 'achever une étape puis la rouvrir', attendu: 'l’avancement est inchangé' },
+    { action: 'achever une étape inexistante', attendu: 'refus' },
+  ],
+  verdict: 'eprouve',
+  origine: [{ type: 'incident', source: '@mostajs/elearning 0.1.0 — `start()` redescendait une leçon `done`', date: '2026-09-01' }],
+});

package/kinds/chiffres.kind.mjs

@@ -0,0 +1,80 @@
+// Domaine `decision` — d'où vient un nombre affiché, et ce qu'il vaut.
+// @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+import { defineKind } from '../src/kind.js';
+
+export const kinds = [
+  defineKind({
+    ref: 'KIND-CHIFFRE-SANS-SOURCE-01',
+    domaine: 'decision',
+    enonce: 'Aucun chiffre n’est affiché sans que sa SOURCE ait été interrogée — et il mène à l’assiette qui le compose.',
+    utilisation: 'Tout tableau de bord, tout indicateur, toute vignette de comptage.',
+    besoins: [
+      { nom: 'sources', forme: '[{ id, interroger() }] — déclarées, jamais écrites dans la page' },
+      { nom: 'fraîcheur attendue', forme: 'seuil déclaré par source' },
+    ],
+    succes: [
+      '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 »',
+      'trois états, et trois seulement : non branché · branché sans données · branché réel',
+    ],
+    erreurs: [
+      { titre: 'un nombre est écrit en dur, ou vient d’un jeu d’exemple',
+        consequence: 'la maquette devient la production sans que personne ne s’en aperçoive — le chiffre est stable, plausible, et ne décrit rien' },
+      { titre: 'une source injoignable rend zéro',
+        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: '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é',
+        consequence: 'les deux divergent, et c’est celui qu’on présente qui a tort' },
+    ],
+    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: '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' },
+    ],
+    verdict: 'eprouve',
+    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' },
+    ],
+  }),
+
+  defineKind({
+    ref: 'KIND-REFUS-LISIBLE-01',
+    domaine: 'decision',
+    enonce: 'Un refus NOMME sa cause et offre une issue — sauf quand la nommer renseigne celui qui n’y a pas droit.',
+    utilisation: 'Tout refus rendu à un humain : garde d’accès, validation, calcul impossible, quota.',
+    succes: [
+      'le refus dit CE QUI MANQUE, chiffré quand c’est un compte',
+      'il dit ce qu’il faut FAIRE pour le lever',
+      'lorsqu’il porte sur une instance interdite, il ne révèle NI son existence NI son contenu',
+    ],
+    erreurs: [
+      { titre: 'le refus est générique — « action impossible », « indisponible »',
+        consequence: 'l’utilisateur ressaie à l’identique, indéfiniment. « Pas disponible » n’apprend rien ; « il manque onze jours » se corrige' },
+      { titre: 'le refus désigne la MAUVAISE cause',
+        consequence: 'le pire des cas : on cherche pendant des heures du côté qu’on nous a montré. Un « code refusé » sur un identifiant inconnu envoie ressaisir un code déjà bon' },
+      { titre: 'le refus nomme l’instance à qui n’y a pas droit',
+        consequence: 'confirmer l’existence renseigne déjà : on énumère, de proche en proche, qui est inscrit' },
+      { titre: 'le refus n’offre aucune issue',
+        consequence: 'il devient une impasse : l’utilisateur appelle, et le refus coûte plus cher que l’action' },
+      { titre: 'le refus n’est pas tracé',
+        consequence: 'les tentatives répétées ne se voient pas — ni la gêne d’un utilisateur légitime, ni l’insistance d’un autre' },
+    ],
+    test: [
+      { action: 'refuser sur donnée manquante', attendu: 'le manque est chiffré et l’issue est dite' },
+      { action: 'refuser l’accès à l’instance d’autrui', attendu: 'ni son nom ni son identifiant n’apparaissent dans la réponse' },
+      { action: 'se tromper d’identifiant', attendu: 'le message couvre les DEUX causes sans dire laquelle — et ne désigne pas la mauvaise' },
+    ],
+    verdict: 'eprouve',
+    origine: [
+      { type: 'incident', source: 'LabTrax — « DIRE LA VRAIE RAISON D’UN REFUS, et offrir une issue »', date: '2026-08-31' },
+      { type: 'incident', source: 'RestoTrax — « Identifiant ou code refusé » : le message désignait le CODE, on ressaisissait le bon indéfiniment', date: '2026-09-02' },
+      { type: 'incident', source: 'ATC — le refus du portail ne nomme ni l’élève ni son identifiant (T-POR-2)', date: '2026-09-01' },
+    ],
+  }),
+];

package/kinds/decision.kind.mjs

@@ -0,0 +1,88 @@
+// Domaine `decision` — ce qu'on peut conclure, et à partir de quand.
+// @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+import { defineKind } from '../src/kind.js';
+
+export const kinds = [
+  defineKind({
+  ref: 'KIND-DONNEE-INSUFFISANTE-01',
+  domaine: 'decision',
+  enonce: 'Un calcul dont la donnée est insuffisante REFUSE, et chiffre ce qui lui manque.',
+  utilisation: 'Tout indicateur, toute prévision, tout conseil tiré d’un historique.',
+  besoins: [
+    { nom: 'volume observé', forme: 'nombre de CYCLES observés' },
+    { nom: 'seuil', forme: 'valeur déclarée, éditable — jamais une constante' },
+  ],
+  succes: [
+    'sous le seuil, le calcul refuse et NOMME ce qui manque, chiffré',
+    'le seuil est une valeur déclarée, visible et modifiable',
+    'la condition est réévaluée à chaque lecture, jamais une fois pour toutes',
+    'trois états sont distingués, et trois seulement : NON BRANCHÉ (aucune source) · BRANCHÉ SANS DONNÉES (source vide ou périmée) · BRANCHÉ RÉEL',
+  ],
+  erreurs: [
+    { titre: 'un chiffre est rendu sur trop peu de points',
+      consequence: 'il a l’air sérieux, il est tiré de rien, et c’est celui qu’on présente au conseil' },
+    { titre: 'le refus dit « indisponible » sans chiffrer',
+      consequence: '« pas disponible » n’apprend rien ; « il manque 11 jours » se corrige' },
+    { titre: 'la condition est évaluée à l’activation seulement',
+      consequence: 'activée en janvier sur des données saines, elle conseille encore en mai sur un référentiel vidé — avec la même assurance' },
+    { titre: 'le seuil est exprimé en JOURS',
+      consequence: 'il ment dès que le cycle change d’échelle : deux saisons font deux semaines en restauration, deux ANS en grande culture, et une poignée de jours par an en apiculture' },
+    { titre: 'le seuil est écrit en dur',
+      consequence: 'personne ne le relit, et il finit tenu pour une loi de la nature' },
+    { titre: '« aucune source » et « source vide » sont confondus',
+      consequence: 'l’exploitant ne sait pas s’il doit BRANCHER quelque chose ou SAISIR quelque chose. Ce sont deux gestes différents, et l’écran les présente pareil' },
+  ],
+  test: [
+    { action: 'demander un calcul sous le seuil', attendu: 'refus chiffrant ce qui manque' },
+    { action: 'vider la donnée sous un calcul déjà activé', attendu: 'il cesse de répondre et le DIT' },
+    { action: 'exprimer le seuil pour un domaine à cycle annuel', attendu: 'le seuil est en cycles, pas en jours' },
+  ],
+  verdict: 'eprouve',
+  origine: [
+    { type: 'incident', source: 'RestoTrax — 237 transitions dormaient au journal sans que rien ne le dise', date: '2026-08-30' },
+    { type: 'incident', source: 'ATC — les 4 questions de l’assistant chiffrent leur manque', date: '2026-09-01' },
+    { type: 'incident', source: 'CollabTrax — « Afficher trois états et trois seulement : non branché / branché sans données / branché réel »', date: '2026-08-03' },
+    { type: 'reference', source: 'Prévision : deux saisons complètes exigées avant toute méthode saisonnière' },
+  ],
+  }),
+
+  defineKind({
+    ref: 'KIND-ECRITURE-GARDEE-01',
+    domaine: 'decision',
+    enonce: 'Une écriture déclenchée par une machine s’obtient en DEUX temps : un aperçu inerte, puis une confirmation explicite.',
+    utilisation: 'Tout geste qu’un assistant, un robot ou une règle automatique produit et qui modifie l’état du métier.',
+    besoins: [
+      { nom: 'catalogue des actions autorisées', forme: '[{ code, paramètres attendus }]' },
+      { nom: 'port d’audit', forme: '(acte, acteur, résultat) => void' },
+    ],
+    succes: [
+      'sans confirmation, l’appel rend un APERÇU et n’écrit RIEN',
+      'avec confirmation ET permission, l’écriture a lieu et elle est auditée',
+      'le brouillon produit est INERTE tant qu’il n’est pas activé',
+      'le refus est audité comme l’accord',
+    ],
+    erreurs: [
+      { titre: 'l’aperçu écrit déjà quelque chose',
+        consequence: 'l’utilisateur croit regarder ; il a déjà agi. C’est la faute la plus grave du dispositif, parce qu’elle détruit la confiance dans tous les aperçus suivants' },
+      { titre: 'la garde est posée dans la VUE',
+        consequence: 'un second appelant — interface de programmation, tâche planifiée, autre écran — la contourne sans le savoir. Un garde posé dans la vue se perd à la vue suivante' },
+      { titre: 'la confirmation vaut pour toute la session',
+        consequence: 'un acte préparé il y a vingt minutes s’exécute sur un contexte qui a changé' },
+      { titre: 'seuls les succès sont audités',
+        consequence: 'un refus tu laisse croire que rien n’a été tenté — et l’on ne voit pas les tentatives répétées' },
+      { titre: 'l’action exécutée n’est pas celle qui a été prévisualisée',
+        consequence: 'l’aperçu devient une formalité : il montre A, il applique B, et personne ne le remarque avant longtemps' },
+    ],
+    test: [
+      { action: 'demander l’acte SANS confirmation, puis compter les lignes du métier avant et après', attendu: 'un aperçu, et AUCUN écart' },
+      { action: 'confirmer sans détenir la permission', attendu: 'refus, audité' },
+      { action: 'confirmer un aperçu produit sur un contexte depuis modifié', attendu: 'refus ou nouvel aperçu — jamais l’exécution silencieuse' },
+    ],
+    verdict: 'eprouve',
+    origine: [
+      { type: 'incident', source: 'CRM/TRADING — copilote : transitions et réassignations, aperçu sans --confirm puis exécution (CARNET motif #2)', date: '2026-06-13' },
+      { type: 'incident', source: 'RestoTrax — l’assistant-pilote n’a que deux écritures, et ce sont des DÉCISIONS (TPIL-7)', date: '2026-08-30' },
+      { type: 'incident', source: 'ATC — l’écran de l’assistant ne porte aucune action métier (T-ASS-9)', date: '2026-09-01' },
+    ],
+  }),
+];

package/kinds/donnees.kind.mjs

@@ -0,0 +1,108 @@
+// Domaine `donnees` — ce qui s'écrit vraiment, et ce qui disparaît en silence.
+// @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+import { defineKind } from '../src/kind.js';
+
+export const kinds = [
+  defineKind({
+    ref: 'KIND-ECRITURE-HORS-SCHEMA-01',
+    domaine: 'donnees',
+    enonce: 'Un champ écrit sans être déclaré au schéma disparaît en base, et nulle part ailleurs.',
+    utilisation: 'Toute application dont le stockage est déclaré (ORM, schéma, migration) et dont les essais tournent en mémoire.',
+    succes: [
+      'le champ écrit est relu après un redémarrage',
+      'les essais qui écrivent ce champ tournent AUSSI sur le stockage réel',
+    ],
+    erreurs: [
+      { titre: 'l’essai tourne en mémoire, la production sur schéma',
+        consequence: 'la suite est verte et la donnée est perdue — c’est la divergence la plus coûteuse, parce qu’elle rassure' },
+      { titre: 'le champ est ajouté au code sans l’être au schéma',
+        consequence: 'aucune erreur : l’écriture est acceptée puis ignorée' },
+      { titre: 'la liste des schémas est tenue à la main',
+        consequence: 'un module gagne une entité, la table n’est jamais créée, et rien ne le dit jusqu’au premier enregistrement' },
+      { titre: 'le champ est ajouté au schéma, mais la migration ne SAIT PAS altérer une table existante',
+        consequence: 'le schéma est juste, le code est juste, et la colonne n’existe pas en base : sous sqljs, la migration CRÉE les tables neuves et n’ALTÈRE pas les anciennes. Le symptôme est identique à un champ non déclaré, et la cause est ailleurs — d’où des heures perdues à relire un schéma correct' },
+    ],
+    test: [
+      { action: 'écrire un champ, redémarrer, relire', attendu: 'la valeur est là' },
+      { action: 'écrire un champ absent du schéma', attendu: 'refus ou avertissement — jamais une acceptation muette' },
+      { action: 'ajouter une colonne à une entité EXISTANTE, migrer, écrire, relire', attendu: 'la valeur revient — sinon la migration n’altère pas, et il faut une table annexe' },
+    ],
+    verdict: 'eprouve',
+    origine: [
+      { type: 'incident', source: 'ATC — moyen de paiement écrit hors schéma de facture', date: '2026-08-31' },
+      { type: 'incident', source: '@mostajs/coaching — `bookingId` retenu sans être déclaré', date: '2026-09-01' },
+      { type: 'incident', source: 'CRM/TRADING — sous sqljs la migration ne fait pas d’ALTER ; parade retenue : table dédiée (`workflow_layout`) — CARNET motif #5', date: '2026-06-13' },
+    ],
+  }),
+
+  defineKind({
+    ref: 'KIND-MAJ-PARTIELLE-01',
+    domaine: 'donnees',
+    enonce: 'Une mise à jour partielle ne doit écrire QUE ce qui est fourni.',
+    utilisation: 'Tout formulaire où l’on corrige un champ sans ressaisir les autres.',
+    succes: ['corriger un champ laisse les autres intacts', 'effacer un champ est un geste EXPLICITE, distinct de ne pas le fournir'],
+    erreurs: [
+      { titre: '`{...existant, champ: undefined}` est écrit tel quel',
+        consequence: 'le champ non fourni est ÉCRASÉ — on corrige une note et l’on perd le compte-rendu, sans erreur ni trace' },
+      { titre: 'le formulaire envoie une chaîne vide pour un champ non saisi',
+        consequence: 'le module respecte le contrat, et c’est l’application qui détruit la donnée' },
+    ],
+    test: [
+      { action: 'renseigner deux champs, puis n’en corriger qu’un', attendu: 'l’autre survit' },
+      { action: 'envoyer une chaîne vide pour un champ non saisi', attendu: 'le champ n’est pas écrasé' },
+    ],
+    verdict: 'eprouve',
+    origine: [{ type: 'incident', source: '@mostajs/coaching — `report()` écrasait les notes', date: '2026-09-01' }],
+  }),
+
+  defineKind({
+    ref: 'KIND-ECRITURE-HORS-APPLICATION-01',
+    domaine: 'donnees',
+    enonce: 'Sur un stockage à image mémoire, une écriture faite hors de l’application vivante est écrasée.',
+    utilisation: 'Toute reprise de données, migration ou vérification sur une base servie en image mémoire (sqljs, SQLite embarqué, base fichier).',
+    succes: ['la reprise est relue dans un NOUVEAU processus, après que l’application a écrit', 'le script refuse de s’exécuter tant que l’application répond'],
+    erreurs: [
+      { titre: 'le script annonce « n lignes reprises » et son travail disparaît',
+        consequence: 'l’application réécrit le fichier depuis SON image mémoire, qui n’a jamais vu la reprise — sans erreur, et avec un délai qui peut être de plusieurs heures' },
+      { titre: 'la reprise est vérifiée dans le même processus',
+        consequence: 'elle paraît réussie : c’est la mémoire du script qu’on relit, pas la base' },
+    ],
+    test: [
+      { action: 'lancer une reprise application vivante', attendu: 'refus explicite' },
+      { action: 'reprendre application arrêtée, redémarrer, relire ailleurs', attendu: 'la reprise tient' },
+    ],
+    verdict: 'eprouve',
+    origine: [{ type: 'incident', source: 'ATC — reprise des notes effacée, certificat jamais persisté (DB_DIALECT=sqljs)', date: '2026-09-02' }],
+  }),
+
+  defineKind({
+    ref: 'KIND-SORTIE-GENEREE-01',
+    domaine: 'donnees',
+    enonce: 'Une sortie GÉNÉRÉE n’entre dans le système qu’après validation contre un catalogue DÉCLARÉ.',
+    utilisation: 'Tout ce qu’un modèle de langage, un moteur de règles ou un extracteur produit sous forme structurée.',
+    besoins: [{ nom: 'catalogue', forme: 'registre déclaré des valeurs autorisées — événements, conditions, actions, champs' }],
+    succes: [
+      'une valeur hors catalogue est REFUSÉE, et le refus la nomme',
+      'le catalogue est la source UNIQUE : l’invite, le validateur et les exemples en découlent',
+      'une hallucination devient une erreur rattrapable, pas une donnée',
+    ],
+    erreurs: [
+      { titre: 'on fait confiance au texte produit',
+        consequence: 'une valeur inventée entre dans le système. Elle est plausible, elle se propage, et on la découvre là où elle fait du dégât — pas là où elle est née' },
+      { titre: 'le catalogue est décrit dans l’invite mais n’est pas appliqué à la SORTIE',
+        consequence: 'l’invite dit une chose et le code accepte tout : la barrière n’existe que dans la conversation' },
+      { titre: 'deux listes coexistent — une pour l’invite, une pour la validation',
+        consequence: 'elles divergent, et c’est toujours la validation qui perd : on élargit le validateur pour débloquer' },
+      { titre: 'le refus ne nomme pas la valeur fautive',
+        consequence: 'irrattrapable : ni l’utilisateur ni le modèle ne savent quoi corriger' },
+    ],
+    test: [
+      { action: 'produire une valeur absente du catalogue', attendu: 'refus nommant la valeur ET le catalogue attendu' },
+      { action: 'retirer une entrée du catalogue', attendu: 'l’invite et le validateur changent ENSEMBLE — une seule source' },
+    ],
+    verdict: 'eprouve',
+    origine: [
+      { type: 'incident', source: 'CRM/TRADING — validateRule de l’éditeur ECA ; normalizeOffer rejette une offre sans supplier/sourceUrl (CARNET motif #3)', date: '2026-06-13' },
+    ],
+  }),
+];