@mostajs/kind-catalog 0.1.0

package/kinds/ecran-service.kind.mjs

@@ -0,0 +1,71 @@
+// Domaine `donnees` — l'écart entre ce que l'écran envoie et ce que le service attend.
+// @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+import { defineKind } from '../src/kind.js';
+
+export const kinds = [
+  defineKind({
+    ref: 'KIND-FORMULAIRE-ROUTE-01',
+    domaine: 'donnees',
+    enonce: 'Le formulaire RENDU et la route qui le reçoit s’accordent — et cela se vérifie sur l’écran TEL QU’IL EST SERVI.',
+    utilisation: 'Toute application où un écran alimente un service : formulaire HTML, appel d’interface, message.',
+    besoins: [{ nom: 'écran servi', forme: 'le HTML réellement rendu, pas la fonction qui le compose' }],
+    succes: [
+      'chaque formulaire rendu est ACCEPTÉ par sa propre route',
+      'ce que le service exige, l’écran l’envoie — ou le service le DÉRIVE d’une donnée qu’il possède déjà',
+      'l’essai part du rendu, jamais d’un appel direct au service',
+    ],
+    erreurs: [
+      { titre: 'l’essai appelle le service en lui fournissant ce que l’écran ne fournit pas',
+        consequence: 'la suite est verte et l’écran écrit des données amputées. C’est le pire écart possible, parce que la couverture rassure exactement là où le trou se trouve' },
+      { titre: 'le champ manquant est FACULTATIF côté service',
+        consequence: 'aucune erreur nulle part : la donnée naît incomplète, et le défaut se découvre à l’autre bout de l’application — parfois douze écrans plus loin, sans qu’on puisse relier les deux' },
+      { titre: 'le service comble le manque par une valeur par défaut',
+        consequence: 'le défaut devient la valeur réelle, et il a l’air d’une saisie' },
+      { titre: 'la route évolue, le formulaire non — ou l’inverse',
+        consequence: 'rien ne casse tant que le champ reste facultatif ; tout casse le jour où il ne l’est plus, et l’on cherche du côté de la modification récente, pas du formulaire ancien' },
+    ],
+    test: [
+      { action: 'rendre le formulaire, poster EXACTEMENT les champs qu’il porte', attendu: 'la route accepte' },
+      { action: 'relire la donnée écrite par ce chemin', attendu: 'elle est complète — tous les champs que la suite du parcours exigera' },
+    ],
+    verdict: 'eprouve',
+    origine: [
+      { type: 'incident', source: 'ATC — l’écran de notation appelait `noter()` avec la seule séance : `courseId` et `levelId` restaient nuls, et le certificat répondait « aucun niveau atteint » douze écrans plus loin', date: '2026-09-01' },
+      { type: 'incident', source: 'LabTrax — « VERIFIER L IHM TELLE QU ELLE EST SERVIE : chaque formulaire rendu doit être accepté par SA route »', date: '2026-08-31' },
+    ],
+  }),
+
+  defineKind({
+    ref: 'KIND-CONSIGNER-APRES-SUCCES-01',
+    domaine: 'donnees',
+    enonce: 'On ne date, ne numérote et n’annonce qu’APRÈS le succès de l’acte — et l’on relit ce que l’on annonce.',
+    utilisation: 'Envoi de courriel ou de message, attribution d’un numéro officiel, écriture en base, publication d’une pièce.',
+    besoins: [{ nom: 'confirmation', forme: 'le retour de l’acte, attendu — jamais supposé' }],
+    succes: [
+      'la date d’envoi est celle de l’envoi RÉUSSI',
+      'un numéro n’est attribué que si l’enregistrement a abouti',
+      'ce qui est annoncé à l’utilisateur a été RELU depuis la source, pas depuis la mémoire de l’appelant',
+    ],
+    erreurs: [
+      { titre: 'on date avant d’envoyer',
+        consequence: 'un envoi échoué laisse une date qui atteste d’une notification qui n’a pas eu lieu — et comme la date existe, personne ne relance jamais' },
+      { titre: 'la valeur annoncée n’est pas relue',
+        consequence: 'on rend un numéro de pièce à quelqu’un, et la pièce n’existe pas. La page publique répond « introuvable » sur un numéro que le système a pourtant produit' },
+      { titre: 'une promesse non attendue est stockée telle quelle',
+        consequence: 'le champ vaut `{}` ou `[object Promise]` ; la signature couvre ce vide, et la pièce devient invérifiable sans qu’aucune erreur ne soit levée' },
+      { titre: 'le journal consigne l’INTENTION, pas le RÉSULTAT',
+        consequence: 'on relit six mois plus tard une trace d’actions qui n’ont pas eu lieu, et l’on en tire des conclusions' },
+    ],
+    test: [
+      { action: 'faire échouer l’envoi', attendu: 'aucune date d’envoi n’est posée, et l’échec est dit' },
+      { action: 'interrompre la persistance après l’attribution du numéro', attendu: 'aucun numéro n’est rendu à l’utilisateur' },
+      { action: 'relire dans un NOUVEAU processus ce qui vient d’être annoncé', attendu: 'la chose existe' },
+    ],
+    verdict: 'eprouve',
+    origine: [
+      { type: 'incident', source: 'ATC — `certificates` n’attendait pas `numbering.next()` : le numéro valait `{}`, la signature couvrait ce vide, et aucun certificat n’était vérifiable', date: '2026-08-31' },
+      { type: 'incident', source: 'ATC — un certificat annoncé (CERT-2026-0001) n’avait jamais été persisté : la page publique répondait « introuvable » sur un numéro rendu par le système', date: '2026-09-02' },
+      { type: 'incident', source: 'LabTrax — « NOTIFIER RÉELLEMENT le candidat au scellement, ne dater qu’APRÈS l’envoi »', date: '2026-08-31' },
+    ],
+  }),
+];

package/kinds/integration.kind.mjs

@@ -0,0 +1,83 @@
+// Domaine `integration` — ce qui casse au bout d'une clé d'API, et comment le nommer.
+// @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+import { defineKind } from '../src/kind.js';
+
+export const kinds = [
+  defineKind({
+  ref: 'KIND-ECHEC-FOURNISSEUR-01',
+  domaine: 'integration',
+  enonce: 'Les échecs d’un fournisseur externe se CLASSENT : authentification, ressource, quota, solde, injoignable.',
+  utilisation: 'Tout service tiers à clé : modèle de langage, courriel, messagerie, paiement, stockage, cartographie.',
+  besoins: [
+    { nom: 'sonde', forme: '(fournisseur) => { classe, message, action conseillée }' },
+    { nom: 'fournisseurs configurés', forme: '[{ id, clé, point d’entrée }]' },
+  ],
+  succes: [
+    'chaque échec est rangé dans une classe NOMMÉE, avec l’action à faire',
+    'un diagnostic dit l’état de CHAQUE fournisseur configuré, pas seulement celui qui vient d’échouer',
+    'un échec temporaire (quota) se distingue d’un échec définitif (clé révoquée)',
+  ],
+  erreurs: [
+    { titre: 'l’échec est rendu comme « ça ne marche pas »',
+      consequence: 'on renouvelle une clé parfaitement valide pendant des heures, alors qu’il manquait du crédit' },
+    { titre: 'une clé valide SANS CRÉDIT est confondue avec une clé invalide',
+      consequence: '400 (solde) et 401 (authentification) demandent deux actions opposées : recharger, ou régénérer. Confondre les deux fait perdre une journée' },
+    { titre: 'un quota temporaire est traité comme une panne définitive',
+      consequence: 'on bascule sur un repli de moindre qualité — et l’on n’y revient jamais, parce que rien ne resonde' },
+    { titre: 'l’ordre de repli est figé dans la configuration',
+      consequence: 'il ne tient aucun compte de ce qui marche réellement ; le premier de la liste est réessayé indéfiniment' },
+    { titre: 'le diagnostic est fait par l’appel métier lui-même',
+      consequence: 'on n’apprend l’état d’un fournisseur qu’en échouant devant un utilisateur' },
+  ],
+  test: [
+    { action: 'simuler successivement 401, 404, 400-solde et 429', attendu: 'quatre classes distinctes, quatre actions conseillées distinctes' },
+    { action: 'sonder l’ensemble des fournisseurs configurés', attendu: 'un état par fournisseur, y compris ceux qu’on n’a pas appelés' },
+    { action: 'lever un quota temporaire', attendu: 'le fournisseur redevient éligible sans intervention' },
+  ],
+  verdict: 'eprouve',
+  origine: [
+    { type: 'incident', source: 'CRM/TRADING — essai en direct : une clé valide sans crédit (400 billing) prise pour une clé invalide (401)', date: '2026-06-13' },
+    { type: 'incident', source: 'CRM/TRADING — docs/CARNET-IDEES-TRANSVERSALES.md motif #4', date: '2026-06-13' },
+  ],
+  }),
+
+  defineKind({
+    ref: 'KIND-DEPENDANCE-DISTANTE-01',
+    domaine: 'integration',
+    enonce: 'La perte du lien avec un service distant n’empêche AUCUN geste local.',
+    utilisation: 'Toute instance qui dépend d’un central : licence, métriques, référentiel, annuaire, télémétrie.',
+    besoins: [
+      { nom: 'ce qui est vérifiable hors ligne', forme: 'jeton ou acte SIGNÉ, opposable sans réseau' },
+      { nom: 'ce qui peut attendre', forme: 'file d’attente locale, rejouée au retour du lien' },
+    ],
+    succes: [
+      'central injoignable : le geste local se fait, et il est daté',
+      'ce qui doit être vérifié l’est par une SIGNATURE, pas par un appel',
+      'l’état dégradé est DIT à l’écran, jamais masqué',
+      'le retour du lien rattrape ce qui attendait, sans intervention',
+    ],
+    erreurs: [
+      { titre: 'le geste local attend une réponse distante',
+        consequence: 'une panne de réseau arrête le travail réel — le pointage à la porte, la délibération, l’encaissement. La dépendance devient une panne métier' },
+      { titre: 'l’autorisation est vérifiée par un APPEL au lieu d’une signature',
+        consequence: 'qui coupe le lien ouvre la porte, ou la ferme — dans les deux cas, c’est le réseau qui décide du droit' },
+      { titre: 'la révocation n’est pas opposable hors ligne',
+        consequence: 'un droit retiré au central reste actif sur l’instance tant qu’elle ne rappelle pas — et rien ne dit quand elle rappellera' },
+      { titre: 'le mode dégradé est silencieux',
+        consequence: 'on croit travailler normalement ; on découvre au retour du lien que la moitié n’est pas partie' },
+      { titre: 'la file d’attente n’est pas bornée',
+        consequence: 'une coupure longue remplit le disque, et la panne de réseau devient une panne de stockage' },
+    ],
+    test: [
+      { action: 'couper le lien, puis accomplir le geste métier', attendu: 'il aboutit, daté, et l’écran dit l’état dégradé' },
+      { action: 'révoquer au central, lien coupé', attendu: 'la révocation signée est opposable sans appel' },
+      { action: 'rétablir le lien', attendu: 'ce qui attendait part, sans geste humain' },
+    ],
+    verdict: 'eprouve',
+    origine: [
+      { 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' },
+    ],
+  }),
+];

package/kinds/metier-optimisation.kind.mjs

@@ -0,0 +1,210 @@
+// Fiches MÉTIER — écrites d'après les corpus établis de chaque profession.
+//
+// ⚠️ TOUTES EN `propose`, ET C'EST LA PART HONNÊTE DU CATALOGUE. Leur provenance est une
+// `reference` : une norme, un guide de bonnes pratiques, un problème classique de la littérature.
+// Elles ne passeront à `eprouve` qu'avec un `incident` ou un `terrain` — c'est-à-dire un défaut
+// constaté ou le dire d'un praticien nommé et daté. On n'entre pas au catalogue sur un galon
+// qu'on ne s'est pas gagné, mais on y entre.
+// @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+import { defineKind } from '../src/kind.js';
+
+export const kinds = [
+  defineKind({
+    ref: 'KIND-FORMULATION-MOINDRE-COUT-01',
+    domaine: 'elevage',
+    enonce: 'Composer une ration au moindre coût, sous contraintes nutritionnelles.',
+    utilisation: 'Élevage (ration du troupeau) et agro-alimentaire (formulation d’un produit) — c’est le même problème.',
+    besoins: [
+      { nom: 'ingrédients', forme: '[{ id, coût unitaire, apports par nutriment }]' },
+      { nom: 'contraintes', forme: '[{ nutriment, min?, max? }]' },
+    ],
+    succes: [
+      'la ration respecte TOUTES les contraintes, ou l’infaisabilité est déclarée',
+      'le coût rendu est celui de la ration proposée, à la même unité que les prix saisis',
+      'les contraintes SERRÉES sont nommées — ce sont elles qui font le prix',
+    ],
+    erreurs: [
+      { titre: 'l’infaisabilité est rendue comme une ration',
+        consequence: 'on distribue une ration qui ne couvre pas les besoins, et le déficit ne se voit qu’à la production, des semaines plus tard' },
+      { titre: 'seul le coût est optimisé, sans borne haute',
+        consequence: 'la solution mathématique concentre un ingrédient bon marché à une dose que l’animal ne supporte pas — le simplexe ne connaît pas la physiologie' },
+      { titre: 'les unités se mélangent (kg, %, MS, brut)',
+        consequence: 'un facteur mille passe inaperçu ; la ration est chiffrée et fausse' },
+      { titre: 'les prix sont figés',
+        consequence: 'une formule optimale en janvier devient la plus chère en juin, et personne ne la recalcule' },
+    ],
+    test: [
+      { action: 'poser des contraintes contradictoires', attendu: 'infaisabilité DÉCLARÉE, pas une ration approchée' },
+      { action: 'omettre une borne haute sur un ingrédient bon marché', attendu: 'la concentration excessive est signalée' },
+      { action: 'faire varier un prix', attendu: 'la formule change, et les contraintes serrées sont nommées' },
+    ],
+    verdict: 'propose',
+    origine: [
+      { type: 'reference', source: 'Problème du régime (Stigler 1945 ; résolu par le simplexe de Dantzig) — l’un des premiers problèmes de programmation linéaire' },
+      { type: 'reference', source: 'Tables de rationnement et besoins nutritionnels par espèce' },
+    ],
+  }),
+
+  defineKind({
+    ref: 'KIND-TRANSHUMANCE-01',
+    domaine: 'apiculture',
+    enonce: 'Placer les ruches là où la miellée les attend — et savoir qu’on ne le saura pas d’avance.',
+    utilisation: 'Conduite d’un rucher : quels lots vers quels emplacements, à quelle date.',
+    besoins: [
+      { nom: 'emplacements', forme: '[{ id, floraison attendue, capacité en ruches, distance }]' },
+      { nom: 'lots', forme: '[{ id, nombre de ruches, état sanitaire }]' },
+    ],
+    succes: [
+      'l’affectation respecte la capacité de chaque emplacement',
+      'le coût de déplacement est rendu séparément du gain espéré',
+      'l’INCERTITUDE de la miellée est dite, jamais absorbée dans le chiffre',
+    ],
+    erreurs: [
+      { titre: 'une prévision de récolte est calculée sur l’historique',
+        consequence: 'dix ans d’exploitation font DIX points, dont aucun n’est comparable à l’autre — floraison, météo et état du cheptel changent tout. Un chiffre y est plus faux qu’ailleurs, et plus crédible' },
+      { titre: 'le sanitaire est traité comme une contrainte souple',
+        consequence: 'déplacer un lot atteint contamine l’emplacement, et la perte dépasse toute optimisation' },
+      { titre: 'le coût de déplacement est fondu dans l’objectif',
+        consequence: 'l’apiculteur ne peut plus arbitrer entre ce qu’il gagne et ce qu’il dépense' },
+    ],
+    test: [
+      { action: 'demander une prévision de récolte sur moins de trois miellées', attendu: 'refus chiffrant ce qui manque' },
+      { action: 'affecter un lot atteint à un emplacement sain', attendu: 'refus, non pénalisation' },
+    ],
+    verdict: 'propose',
+    origine: [
+      { type: 'reference', source: 'Guides de bonnes pratiques apicoles — conduite du rucher et prophylaxie' },
+      { type: 'reference', source: 'Affectation sous capacité (kind `assignment` de @mostajs/ro-pla)' },
+    ],
+  }),
+
+  defineKind({
+    ref: 'KIND-PLANNING-CHANTIER-01',
+    domaine: 'btp',
+    enonce: 'Ordonnancer un chantier sous ressources FINIES, et nommer ce qui tient le délai.',
+    utilisation: 'Conduite de travaux : tâches, prédécesseurs, équipes et engins en nombre limité.',
+    besoins: [
+      { nom: 'tâches', forme: '[{ id, durée, prédécesseurs, ressources }]' },
+      { nom: 'capacités', forme: '{ ressource: nombre }' },
+    ],
+    succes: [
+      'le chemin critique est nommé, avec les marges',
+      'la contrainte de ressource est respectée, pas seulement l’enchaînement',
+      'la règle de priorité employée est RENDUE — elle change le résultat',
+    ],
+    erreurs: [
+      { titre: 'le chemin critique est calculé à ressources INFINIES',
+        consequence: 'le planning est juste sur le papier et faux sur le chantier : un seul grue, quatre tâches qui la demandent' },
+      { titre: 'la règle de priorité est traitée comme un réglage',
+        consequence: 'c’est une DÉCISION : minimiser le retard global, équilibrer la charge ou libérer vite ne donnent pas le même chantier, et aucune ne domine les autres' },
+      { titre: 'la question se pose sur le chantier, la réponse arrive au bureau',
+        consequence: 'un ordonnancement recalculé sans le conducteur de travaux n’est pas appliqué' },
+    ],
+    test: [
+      { action: 'ordonnancer avec une ressource unique demandée par plusieurs tâches', attendu: 'le makespan tient compte de la capacité' },
+      { action: 'changer la règle de priorité', attendu: 'le résultat change, et la règle employée est rendue' },
+    ],
+    verdict: 'propose',
+    seProsePose: 'sur le chantier — la réponse se calcule au bureau, et cet écart fait partie de la fiche',
+    origine: [
+      { type: 'reference', source: 'CPM/PERT ; ordonnancement sous contraintes de ressources (RCPSP)' },
+      { type: 'reference', source: 'DTU et CCTG — clauses types reprises et amendées par dérogation écrite' },
+    ],
+  }),
+
+  defineKind({
+    ref: 'KIND-TRACABILITE-LOT-01',
+    domaine: 'alimentaire',
+    enonce: 'Un lot se remonte et se redescend — de la matière au client, et l’inverse.',
+    utilisation: 'Toute production alimentaire soumise à traçabilité amont/aval.',
+    besoins: [{ nom: 'liens de lot', forme: 'matière → fabrication → lot fini → destinataire' }],
+    succes: [
+      'depuis un lot fini, on nomme toutes les matières qui y sont entrées',
+      'depuis une matière, on nomme tous les lots finis et tous les destinataires',
+      'le retrait se calcule sur ces deux chemins, pas sur une estimation',
+    ],
+    erreurs: [
+      { titre: 'la traçabilité descendante seule est tenue',
+        consequence: 'on sait ce qu’un lot contient, mais pas OÙ il est parti : le retrait devient un rappel général, et le coût est sans commune mesure' },
+      { titre: 'un mélange de lots casse la chaîne',
+        consequence: 'un lot fini issu de trois lots de matière n’en désigne qu’un — les deux autres circulent encore' },
+      { titre: 'la DLC est calculée à la fabrication, pas au lot de matière le plus ancien',
+        consequence: 'la date affichée est plus longue que la réalité' },
+    ],
+    test: [
+      { action: 'depuis un lot fini, remonter aux matières', attendu: 'toutes, y compris en cas de mélange' },
+      { action: 'depuis une matière, descendre aux destinataires', attendu: 'tous' },
+    ],
+    verdict: 'propose',
+    origine: [
+      { type: 'reference', source: 'HACCP et paquet hygiène — traçabilité amont/aval, procédures de retrait-rappel' },
+    ],
+  }),
+
+  defineKind({
+    ref: 'KIND-ROTATION-CULTURALE-01',
+    domaine: 'agronomie',
+    enonce: 'Affecter les cultures aux parcelles dans le respect des rotations pluriannuelles.',
+    utilisation: 'Assolement d’une exploitation, sur plusieurs campagnes.',
+    besoins: [
+      { nom: 'parcelles', forme: '[{ id, surface, historique des cultures }]' },
+      { nom: 'règles de retour', forme: '[{ culture, délai minimal de retour, précédents interdits }]' },
+    ],
+    succes: [
+      'aucun délai de retour n’est enfreint',
+      'les précédents interdits sont respectés',
+      'le plan couvre PLUSIEURS campagnes, pas la prochaine seule',
+    ],
+    erreurs: [
+      { titre: 'l’assolement est optimisé campagne par campagne',
+        consequence: 'chaque année est optimale et la rotation est ruinée — l’optimum local sur trois ans coûte plus que ce qu’il a rapporté sur un' },
+      { titre: 'l’historique de la parcelle est incomplet',
+        consequence: 'un délai de retour est calculé sur ce qu’on sait, et le pathogène, lui, se souvient de tout' },
+      { titre: 'le seuil de données est exprimé en jours',
+        consequence: 'un cycle est ANNUEL : deux saisons complètes, ce sont deux ans — un seuil en jours autorise à conclure sur une seule' },
+    ],
+    test: [
+      { action: 'proposer un assolement sur trois campagnes', attendu: 'aucun délai de retour enfreint sur l’ensemble' },
+      { action: 'fournir un historique incomplet', attendu: 'l’incertitude est dite, la parcelle n’est pas traitée comme vierge' },
+    ],
+    verdict: 'propose',
+    origine: [
+      { type: 'reference', source: 'Itinéraires techniques et règles de rotation — délais de retour par culture' },
+      { type: 'reference', source: 'Satisfaction de contraintes (kind `csp` de @mostajs/ro-pla)' },
+    ],
+  }),
+
+  defineKind({
+    ref: 'KIND-DIAGNOSTIC-PANNE-01',
+    domaine: 'electronique',
+    enonce: 'Ordonner les tests par ce qu’ils ÉLIMINENT, pas par ce qu’ils coûtent.',
+    utilisation: 'Diagnostic d’une carte ou d’un équipement, en production ou en maintenance.',
+    besoins: [
+      { nom: 'pannes possibles', forme: '[{ id, probabilité a priori }]' },
+      { nom: 'tests', forme: '[{ id, coût, pannes discriminées }]' },
+    ],
+    succes: [
+      'la séquence proposée réduit l’incertitude au coût le plus bas',
+      'la probabilité résiduelle est rendue après chaque test',
+      'un test non discriminant est écarté, et on dit pourquoi',
+    ],
+    erreurs: [
+      { titre: 'les tests sont ordonnés par coût croissant',
+        consequence: 'on enchaîne des tests bon marché qui n’éliminent rien — la séquence est la moins chère par étape et la plus chère au total' },
+      { titre: 'les probabilités a priori sont supposées uniformes',
+        consequence: 'le diagnostic ignore que 80 % des pannes viennent de trois causes, et cherche partout' },
+      { titre: 'la question se pose sur l’équipement, le calcul tourne ailleurs',
+        consequence: 'une séquence optimale que le technicien ne reçoit pas au poste n’est jamais suivie' },
+    ],
+    test: [
+      { action: 'ordonner des tests dont le moins cher ne discrimine rien', attendu: 'il n’est pas placé en tête' },
+      { action: 'fournir des probabilités très inégales', attendu: 'la séquence en tient compte' },
+    ],
+    verdict: 'propose',
+    seProsePose: 'au poste de test ou sur l’équipement — le calcul est ailleurs',
+    origine: [
+      { type: 'reference', source: 'Diagnostic séquentiel ; arbres de décision et théorie de l’information' },
+      { type: 'reference', source: 'Chaînes de Markov et décision (kinds `markov`, `decision` de @mostajs/ro-pla)' },
+    ],
+  }),
+];

package/kinds/traces.kind.mjs

@@ -0,0 +1,39 @@
+// Domaine `donnees` — ce qu'on retire, et ce qu'il en reste.
+// @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+import { defineKind } from '../src/kind.js';
+
+export default defineKind({
+  ref: 'KIND-SUPPRESSION-DATEE-01',
+  domaine: 'donnees',
+  enonce: 'Retirer une chose, c’est la DATER — jamais la détruire.',
+  utilisation: 'Toute entité qu’un utilisateur peut « supprimer » : dossier, projet, compte, rôle, activation, solveur.',
+  besoins: [{ nom: 'champs de retrait', forme: '{ retireA, retirePar, motif }' }],
+  succes: [
+    'la ligne SURVIT au retrait et porte sa date, son auteur et son motif',
+    'ce qui est retiré n’apparaît plus dans les listes courantes',
+    'on peut répondre : « cette chose a-t-elle servi, et jusqu’à quand ? »',
+  ],
+  erreurs: [
+    { titre: 'la ligne est effacée',
+      consequence: 'on ne distingue plus « n’a jamais existé » de « a servi trois mois puis a été retiré ». La seconde information est celle qui explique les chiffres du passé, et elle est perdue pour toujours' },
+    { titre: 'le retrait n’est pas motivé',
+      consequence: 'six mois plus tard, personne ne sait si c’était une décision ou une fausse manœuvre — et l’on refait la chose retirée' },
+    { titre: 'le retrait n’est pas attribué',
+      consequence: 'un retrait contesté n’a pas d’auteur : la discussion porte sur le fait, pas sur la décision' },
+    { titre: 'la restauration recrée un objet NEUF',
+      consequence: 'elle perd l’historique de l’ancien, et les rapports antérieurs ne se rattachent plus à rien' },
+    { titre: 'le retrait est un simple drapeau, sans date',
+      consequence: 'on sait que c’est retiré, pas depuis quand : impossible de reconstituer un état passé' },
+  ],
+  test: [
+    { action: 'retirer, puis compter les lignes en base', attendu: 'le compte est INCHANGÉ ; la ligne porte sa date, son auteur et son motif' },
+    { action: 'retirer puis remettre en service', attendu: 'l’historique du retrait subsiste — on lit les deux décisions' },
+    { action: 'lister', attendu: 'ce qui est retiré n’y figure pas' },
+  ],
+  verdict: 'eprouve',
+  origine: [
+    { type: 'incident', source: 'LabTrax — « POUVOIR RETIRER UN DOSSIER sans destruction : pierre tombale datée, attribuée et motivée »', date: '2026-08-31' },
+    { type: 'incident', source: 'qatrax — « supprimer un projet pose une pierre tombale : rien n’est détruit, et la restauration est possible »', date: '2026-08-15' },
+    { type: 'incident', source: '@mostajs/assistant-pilote — la désactivation d’un solveur est datée, la ligne n’est pas effacée (T-AP-8)', date: '2026-09-01' },
+  ],
+});

package/llms.txt

@@ -0,0 +1,34 @@
+# @mostajs/kind-catalog — fiche LLM
+RÔLE
+  Catalogue de KINDS : fiches d'exigence REUTILISABLES, projetables en plan `mostajs-devtest/1`
+  (lu par @mostajs/qa-engine, importé par qatrax). Un kind = une QUESTION qu'un métier se pose,
+  avec ses besoins, son epreuve, ses criteres de succes et ses ERREURS CONNUES (chacune avec sa
+  consequence). N'EXECUTE RIEN, NE STOCKE RIEN — il decrit, valide et projette.
+EXPORTS
+  defineKind(fiche) -> Kind gele ; validateKind(fiche) -> string[] ; VERDICTS, PROVENANCES, DOMAINES
+  toDevtest(kinds, { project, prefix }) -> plan mostajs-devtest/1 ; PLAN_VERSION
+  instantiate(kind, { app, prefix, affine }) -> Instance ; diffInstance(i) ; emplois(instances) ; AFFINABLES
+  loadCatalogue(dir) ; findKinds(kinds, {domaine,verdict,texte}) ; auditCatalogue(kinds) ; statsCatalogue(kinds)
+CHAMPS DE LA FICHE
+  ref (KIND-…) · enonce · domaine · version · besoins · utilisation · succes* · erreurs* · test
+  efficacite · evaluation · verdict · motif · origine* · seProsePose        (* = requis)
+VERDICTS  propose | eprouve | retenu | ecarte
+PROVENANCES  reference (norme, litterature) | terrain (praticien nomme) | incident (defaut constate)
+DOMAINES  acces donnees apprentissage decision integration · btp alimentaire elevage apiculture agronomie electronique
+PIÈGES
+  - `succes` ET `erreurs` sont REQUIS : ce sont les champs qu'on omet, et ceux qui servent.
+  - Chaque erreur porte sa CONSEQUENCE : « ne pas oublier X » ne se retient pas (lecon CWE/OWASP).
+  - `eprouve`/`retenu` EXIGENT une origine `incident` ou `terrain` : on ne se decerne pas
+    l'experience. Une `reference` suffit pour ENTRER au catalogue en `propose` — la contrainte
+    porte sur le galon, jamais sur l'entree.
+  - `ecarte` exige un `motif` et RESTE au catalogue : une fiche ecartee qui disparait sera reinventee.
+  - `instantiate` REFUSE un affinage sans motif : sans lui, « reutiliser » se degrade en « recopier ».
+  - Le `prefix` ISOLE deux applications reprenant la meme fiche dans le meme qatrax.
+  - Une fiche `propose` se projette en statut `draft`, jamais `verified`.
+  - 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.
+  - 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.
+CORPUS LIVRE  21 fiches · 15 eprouvees (71 %) · 84 erreurs cataloguees · 35 incidents · 11 domaines.

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@mostajs/kind-catalog",
+  "version": "0.1.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",
+  "author": "Dr Hamid MADANI <drmdh@msn.com>",
+  "exports": {
+    ".": "./src/index.js",
+    "./kinds": "./src/kinds/index.js"
+  },
+  "files": [
+    "src",
+    "kinds",
+    "docs",
+    "llms.txt",
+    "README.md",
+    "CHANGELOG.md",
+    "!docs/**/*.pdf",
+    "!docs/**/*.pptx",
+    "!docs/**/*.png",
+    "!docs/**/*.html",
+    "!docs/MONITORING-*"
+  ],
+  "scripts": {
+    "test": "bash test-scripts/run-tests.sh"
+  },
+  "devDependencies": {
+    "@mostajs/doc-driver-chrome": "^0.1.0",
+    "@mostajs/doc-driver-pandoc": "^0.1.0",
+    "@mostajs/doc-export": "^0.2.1",
+    "@mostajs/doc-themes": "^0.1.1",
+    "@mostajs/markdown-html": "^0.1.2",
+    "@mostajs/mjs-unit": "^0.6.0",
+    "@mostajs/qa-engine": "^0.7.2"
+  },
+  "keywords": [
+    "mostajs",
+    "kind",
+    "catalogue",
+    "exigence",
+    "devtest",
+    "qatrax",
+    "reuse"
+  ]
+}

package/src/catalogue.js

@@ -0,0 +1,98 @@
+/**
+ * LE CORPUS — charger, chercher, contrôler.
+ *
+ * ⚠️ SEULE I/O DU MODULE, et elle reçoit son chemin : elle ne le devine pas. Un module qui devine
+ * où sont ses données est un module qu'on ne peut pas monter deux fois.
+ *
+ * ⚠️ LES FICHES SONT DES FICHIERS VERSIONNÉS, pas des lignes en base. Une fiche est un document
+ * éditorial : elle se lit, se discute, se relit six mois plus tard, et son historique est celui
+ * d'un fichier. Ce qui va en base, c'est ce que produit son USAGE — exécutions, indices, retours —
+ * et cela appartient à @mostajs/skill-library et au journal d'@mostajs/assistant-pilote.
+ * 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.
+ *
+ * Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+ */
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { validateKind } from './kind.js';
+
+const propre = (v) => String(v ?? '').trim().toLowerCase();
+
+/**
+ * Charge un corpus depuis un dossier de `*.kind.mjs`.
+ * Chaque fichier exporte `default` (une fiche) ou `kinds` (plusieurs).
+ */
+export async function loadCatalogue(dir) {
+  if (!dir) throw new Error('loadCatalogue: dossier requis');
+  const fichiers = (await readdir(dir)).filter((f) => f.endsWith('.kind.mjs')).sort();
+  const kinds = [];
+  const vues = new Map();
+
+  for (const f of fichiers) {
+    const mod = await import(pathToFileURL(join(dir, f)).href);
+    const lot = mod.kinds ?? (mod.default ? [mod.default] : []);
+    for (const k of lot) {
+      // ⚠️ L'IDENTITÉ EST UNIQUE. `CWE-79` désigne la même chose pour mille projets depuis dix
+      // ans : c'est ce qui rend une référence citable. Deux fiches sous une même `ref`
+      // divergeraient sans que personne ne sache laquelle fait foi.
+      if (vues.has(k.ref)) {
+        throw new Error(`loadCatalogue : \`${k.ref}\` est déclarée deux fois — ${vues.get(k.ref)} et ${f}`);
+      }
+      vues.set(k.ref, f);
+      kinds.push(k);
+    }
+  }
+  return kinds;
+}
+
+/** Chercher — par domaine, par verdict, ou par mot dans l'énoncé et les erreurs. */
+export function findKinds(kinds = [], { domaine = null, verdict = null, texte = null } = {}) {
+  const t = propre(texte);
+  return kinds.filter((k) => {
+    if (domaine && k.domaine !== propre(domaine)) return false;
+    if (verdict && k.verdict !== propre(verdict)) return false;
+    if (!t) return true;
+    const foin = [k.ref, k.enonce, k.utilisation, ...k.succes,
+      ...k.erreurs.flatMap((e) => [e.titre, e.consequence])].join(' ').toLowerCase();
+    return foin.includes(t);
+  });
+}
+
+/**
+ * CONTRÔLE DU CORPUS — ce qui doit être vrai de l'ensemble, et pas seulement de chaque fiche.
+ * Rendu comme liste de reproches : on corrige tout d'un coup.
+ */
+export function auditCatalogue(kinds = []) {
+  const out = [];
+  const vues = new Set();
+  for (const k of kinds) {
+    for (const r of validateKind(k)) out.push(`${k.ref} : ${r}`);
+    if (vues.has(k.ref)) out.push(`${k.ref} : référence en double`);
+    vues.add(k.ref);
+  }
+  return out;
+}
+
+/** L'état du corpus, en un coup d'œil — c'est ce qu'on montre, et c'est ce qui doit être vrai. */
+export function statsCatalogue(kinds = []) {
+  const parVerdict = {};
+  const parDomaine = {};
+  const parProvenance = {};
+  for (const k of kinds) {
+    parVerdict[k.verdict] = (parVerdict[k.verdict] ?? 0) + 1;
+    parDomaine[k.domaine] = (parDomaine[k.domaine] ?? 0) + 1;
+    for (const o of k.origine) parProvenance[o.type] = (parProvenance[o.type] ?? 0) + 1;
+  }
+  const eprouvees = (parVerdict.eprouve ?? 0) + (parVerdict.retenu ?? 0);
+  return {
+    total: kinds.length,
+    eprouvees,
+    // ⚠️ LE TAUX ÉPROUVÉ EST LE SEUL CHIFFRE QUI ENGAGE. Un catalogue se vante de son volume ;
+    // ce qui se vérifie, c'est la part qui a traversé un fait réel.
+    tauxEprouve: kinds.length ? Math.round((eprouvees / kinds.length) * 100) : 0,
+    parVerdict, parDomaine, parProvenance,
+    erreursCataloguees: kinds.reduce((n, k) => n + k.erreurs.length, 0),
+  };
+}

package/src/index.js

@@ -0,0 +1,4 @@
+export { defineKind, validateKind, VERDICTS, PROVENANCES, DOMAINES } from './kind.js';
+export { toDevtest, PLAN_VERSION } from './projection.js';
+export { instantiate, diffInstance, emplois, AFFINABLES } from './instance.js';
+export { loadCatalogue, findKinds, auditCatalogue, statsCatalogue } from './catalogue.js';