@mostajs/recette 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,53 @@
+# Journal des versions — @mostajs/recette
+
+**Auteur** : Dr Hamid MADANI <drmdh@msn.com>
+
+## 0.1.0 — 2026-09-10
+
+Première version. Le moteur de la recette applicative, extrait du besoin de **déléguer la recette
+au client** sans lui donner les outils du développeur.
+
+### Ce qu'il porte
+
+- **Sept entités** : `Campagne` (sur une `Release` QaTrax **référencée**), `Point`, `Feuillet`,
+  `Releve`, `Anomalie`, `Dossier`, `Certificat`.
+- **Le parcours en six étapes**, sans saut de cran, avec historique immuable des transitions.
+- **La trame** : `trame.synchroniser()` la tire de QaTrax par un port, `trame.importer()` la lit —
+  plan `mostajs-devtest/1`, le format que `@mostajs/qa-engine` sait déjà exporter. Enveloppe
+  `mostajs-recette-trame/1`, signature vérifiée, **import idempotent par `ref`**.
+- **La sélection est dans ValiTrax** : la trame arrive entière, on en retient une partie. C'est le
+  responsable de recette qui sait ce que son client doit éprouver, pas le certificateur.
+- **Le composeur rend la structure du manifeste des feuillets PDF** —
+  `{ ref, libelle, attendu, options: ['ok','ko','er'] }` : papier, écran et moteur parlent une
+  seule langue.
+- **L'anomalie n'est pas un bug** : deux gravités coexistent, celle que le client propose et celle
+  que l'éditeur qualifie. La promotion garde le lien vers QaTrax sans créer le bug.
+- **Le dossier figé porte une empreinte SHA-256**, et le certificat reçu doit s'y adosser.
+- **Le feu d'exploitation dérive du certificat** : il ne se coche pas.
+- **`@mostajs/recette/sceau`** : signature Ed25519 et enveloppe X25519 par `@mostajs/crypto-box`,
+  sur un chemin d'import à part — une app qui n'exporte rien n'installe aucune cryptographie.
+- 13 essais (`@mostajs/mjs-unit`), tous portant sur ce que le moteur **refuse**.
+
+### Trois décisions qui ont façonné le module
+
+**① Un transport ASYMÉTRIQUE.** L'aller — la trame — relie deux de nos serveurs : il est
+**automatique**, tiré par un port injecté. Le retour — le dossier — **passe par le client**, qui
+valide et rend : il voyage donc comme un **fichier signé**, à la main. Ce n'est pas un pis-aller,
+c'est ce qui permet à un client sans accès vers nos serveurs de rendre sa recette. Et la signature
+vaut des deux côtés : un canal direct dit d'où vient la connexion, pas ce que le document contient.
+
+**② L'import n'écrase jamais l'enrichissement.** Une trame se réimporte à chaque version
+candidate. Si l'import régénérait les points, chaque réimport effacerait la formulation écrite
+pour le client, les rôles et l'ordre — **sans lever d'erreur**, et l'on ne s'en apercevrait qu'en
+distribuant les feuillets. Même garde, et même raison, que `seedRbac` dans LabTrax.
+
+**③ Signer et sceller sont deux actes distincts.** On signe avec sa clé PRIVÉE (prouver
+l'origine) ; on scelle avec la clé PUBLIQUE du destinataire (fermer le pli). L'ordre imposé est
+**signer puis sceller** — l'inverse signerait un chiffré, et l'on prouverait avoir transmis une
+boîte, pas ce qu'elle contient.
+
+### Origine
+
+La recette LabTrax du 2026-09-09 : 13 feuillets, 25 exemplaires, près de trois cents observations
+qui vivaient sur du papier et nulle part ailleurs — pendant que 91 essais automatisés étaient au
+vert avec deux écrans cassés qu'aucun d'eux n'atteignait.

package/README.md

@@ -0,0 +1,173 @@
+# @mostajs/recette — validation & recette applicative
+
+**Auteur** : Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+**Niveau** : N3 métier · **Forme** : moteur · **Dépend de** : aucun autre N3
+
+Le moteur de la **recette** : une trame reçue du certificateur, des points enrichis pour le client,
+des feuillets composés, des relevés `ok`/`ko`/`er`, des anomalies déclarées puis qualifiées, un
+dossier figé et **exporté signé** — puis un certificat reçu, vérifié, et un feu d'exploitation qui
+en **dérive**.
+
+Il fait tourner **ValiTrax** (`valitrax.mostajs.dev`), par lequel un éditeur délègue la recette à
+son client ou à son équipe.
+
+## La chaîne, et son transport
+
+```
+DEV → QaTrax ═══ trame signée ═══════════════▶ ValiTrax ───▶ le CLIENT
+                 AUTOMATIQUE (deux de nos serveurs)  │        lit, coche
+      QaTrax ◀── dossier figé, signé (et scellé) ────┘
+        │        À LA MAIN — le document passe par le client
+        │  vérifie · valide le cycle · scelle le PV
+        └──────── certificat signé + le feu ────────▶ ValiTrax → l'expose au client → PROD
+```
+
+**Le transport est ASYMÉTRIQUE, et c'est voulu.**
+
+**L'aller est automatique** : la trame relie deux de vos serveurs, rien n'y justifie une main.
+`trame.synchroniser()` la tire par un port injecté — le moteur ne connaît ni URL ni jeton.
+
+**Le retour est humain**, parce que le document **passe par le client** : c'est lui qui valide, et
+c'est lui qui rend. Ce n'est pas un pis-aller — c'est ce qui permet à un client sans accès vers
+vos serveurs de rendre sa recette.
+
+**La signature vaut dans les deux sens**, y compris sur le canal automatique : un canal direct dit
+d'où vient la *connexion*, pas ce que le *document* contient. Une mauvaise URL injecterait une
+trame étrangère sans bruit, et le client éprouverait autre chose que le spécifié — sans pouvoir
+s'en apercevoir, faute de référentiel.
+
+**QaTrax FAIT le PV. ValiTrax l'EXPOSE.** Le client ne va jamais sur QaTrax : c'est un outil de
+développement, et l'écarter est la raison d'être de ValiTrax.
+
+## Ce qu'il ne fait pas
+
+| il ne fait pas | qui le fait |
+|---|---|
+| tests, exécutions, bugs, version candidate | `@mostajs/qa-engine` — **référencés**, jamais recopiés |
+| produire les formulaires du client | ce module — QaTrax n'envoie que la **trame** |
+| émettre le certificat | le certificateur (QaTrax) — ce module le **reçoit** et le vérifie |
+| implémenter la cryptographie | `@mostajs/crypto-box` — Ed25519, enveloppe X25519 |
+| sceller un PV collégial · le rendre vérifiable par QR | `@mostajs/deliberation` · `@mostajs/certificates` (côté certificateur) |
+| fils, mentions · convocations | `@mostajs/collab` · `@mostajs/notifications` |
+| engendrer les PDF des feuillets | l'outillage de l'application |
+| lire une feuille photographiée | `@mostajs/ocr` |
+
+## Le point de recette — deux moitiés, une frontière
+
+```
+côté TRAME  (vient de QaTrax)        côté ENRICHISSEMENT  (appartient à ValiTrax)
+ref · specRef · titreTrame           libelle · attendu · role · ordre · langue · retenu
+priorite · etapesTrame               ─────────────────────────────────────────────────
+réécrit à chaque import              L'IMPORT N'Y TOUCHE JAMAIS
+```
+
+> « Vérifier que `POST /dossiers` refuse un livrable non accepté » est un **titre de trame**.
+> « Essayez de programmer une soutenance sur un dossier dont un livrable manque — le refus doit
+> dire lequel » est un **libellé de recette**.
+
+Même exigence, deux lecteurs, deux textes. Une trame se réimporte à chaque version candidate ; si
+l'import régénérait les points, chaque réimport effacerait la formulation écrite pour le client,
+les rôles et l'ordre — et l'on ne s'en apercevrait qu'en distribuant les feuillets.
+
+**La sélection se fait dans ValiTrax**, pas chez QaTrax : la trame arrive entière, `points.retenir()`
+en garde une partie. C'est le responsable de recette qui sait ce que SON client doit éprouver.
+
+## Le client n'est pas une machine : il lit, il coche
+
+`feuillets.composer()` rend **exactement la structure du manifeste** des feuillets PDF :
+
+```js
+{ genre: 'action', ref: 'T-APP-9', libelle: 'Programmez la soutenance',
+  attendu: 'le refus nomme le livrable', specRef: 'SPEC-APP-09',
+  enrichi: true, options: ['ok', 'ko', 'er'] }
+```
+
+Papier, écran et moteur parlent **une seule langue**. Un troisième format, et l'on retomberait
+dans la divination : quel rectangle porte quelle réponse ?
+
+`enrichi` dit si le client lira du français de métier ou un titre de cas de test. Un point non
+enrichi reste lisible — mais cela se voit.
+
+## Trois valeurs, plus l'absence
+
+| | ce que ça dit | ce qu'on corrige |
+|---|---|---|
+| `ok` | conforme | rien |
+| `ko` | le logiciel marche, mais **autrement** que le plan l'annonce | le **document** |
+| `er` | exception, panne | le **code** |
+| *rien* | non joué — l'étape précédente bloquait | l'ordonnancement de la séance |
+
+`ko` et `er` n'ont ni le même destinataire ni la même urgence.
+
+## Usage
+
+```js
+import { createRecette, createMemoryRepositories } from '@mostajs/recette';
+import { creerSceau } from '@mostajs/recette/sceau';        // chemin à part : lui seul importe crypto-box
+
+const recette = createRecette({
+  repositories,
+  ports: {
+    trameSource: { lire: ({ projet }) => fetch(`${QATRAX}/trame?p=${projet}`).then((r) => r.json()) },
+    sceau: creerSceau({
+      signature:     { privee: process.env.VALITRAX_CLE_PRIVEE, nom: 'valitrax' },  // NOTRE identité
+      destinataire:  { publique: process.env.QATRAX_CLE_RECEPTION },                // sceller pour eux
+      certificateur: { publique: process.env.QATRAX_CLE_SIGNATURE },                // vérifier leur PV
+    }),
+  },
+});
+
+const c = await recette.campagnes.ouvrir({ releaseRef: 'qatrax:release:42', instanceUrl: 'https://banc…' });
+await recette.trame.synchroniser(c.id, { projet: 'labtrax' });       // tirée de QaTrax, vérifiée, idempotente
+await recette.points.enrichir(pointId, { libelle: '…', attendu: '…', role: 'S' });
+await recette.points.retenir(c.id, ['T-APP-9', 'T-APP-13']);
+await recette.campagnes.avancer(c.id, 'verification');
+const { feuillet, cases } = await recette.feuillets.composer({ campagneId: c.id, role: 'S' });
+// … consigner · rendre · figer · exporter · recevoir le certificat · autoriser l'exploitation
+```
+
+## Signer et sceller ne sont pas la même chose
+
+| | avec quelle clé | ce que ça prouve |
+|---|---|---|
+| **signer** | **notre privée** (Ed25519) | l'**origine** — un document signé se lit par tous |
+| **sceller** | la **publique du destinataire** (X25519) | le **pli fermé** — lui seul ouvre, rien n'est authentifié |
+
+L'ordre est **signer PUIS sceller**. Sceller d'abord signerait un chiffré : on prouverait avoir
+transmis une boîte, pas ce qu'elle contient.
+
+Les verbes du sceau **n'existent que si leur clé existe**. Une clé manquante se voit donc au
+démarrage, et non à la fin de la recette quand tout le monde attend le document.
+
+## Les gardes — c'est par elles qu'il faut juger ce module
+
+1. **Une recette ne se joue pas sur la production** : l'URL est refusée.
+2. **Le parcours ne saute pas de cran** — `candidate → verification → recette → validation → figee
+   → certifiee → exploitation`.
+3. **La trame est vérifiée** : enveloppe `mostajs-recette-trame/1`, plan `mostajs-devtest/1`,
+   signature valide — même sur le canal automatique, sinon refus.
+4. **L'import n'écrase jamais l'enrichissement**, et dit combien il en a préservé.
+5. **On n'enrichit pas par-dessus la trame** : `titreTrame`, `specRef` et consorts sont refusés.
+6. **On ne consigne que sur un feuillet REMIS**, et un `er` porte son **heure**.
+7. **Qualifier n'efface pas la gravité annoncée par le client** — le désaccord reste lisible.
+8. **Écarter une anomalie exige un motif.**
+9. **Le figement refuse et NOMME ce qui manque** : feuillets non rendus, anomalies non qualifiées,
+   bloquantes ni vérifiées ni écartées.
+10. **Un export non signé est refusé** : il ne prouverait rien, et c'est tout ce qu'on lui demande.
+11. **Le certificat doit citer l'EMPREINTE du dossier**, et sa **signature est vérifiée**.
+12. **Le feu dérive du certificat** : pas de certificat, verdict `refuse`, ou certificat sans le
+    feu — l'exploitation reste fermée.
+
+## L'empreinte décide de tout
+
+Le dossier figé porte un **SHA-256 de son contenu**, et le certificat reçu doit la citer. Sans
+elle, un certificat porterait sur « la recette » — c'est-à-dire sur rien de vérifiable. Avec elle,
+il porte sur **ce dossier-là**, et le client peut le prouver seul.
+
+## Essais
+
+```bash
+npm test      # 13 essais — ils éprouvent ce que le moteur REFUSE
+```
+
+Un moteur de recette qui accepte tout ne sert à rien : c'est le document Word qu'il remplace.

package/llms.txt

@@ -0,0 +1,91 @@
+# @mostajs/recette — fiche
+# Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+
+QUESTION À LAQUELLE IL RÉPOND
+  Qui a éprouvé cette version candidate, qu'a-t-il constaté, et sur quel acte repose
+  l'autorisation de la mettre en production ?
+
+NIVEAU N3 · métier · forme : moteur · dépend de : aucun autre N3
+  @mostajs/qa-engine n'est ni importé ni appelé : ce qui circule est un FICHIER SIGNÉ.
+  @mostajs/crypto-box n'est importé que par `@mostajs/recette/sceau`, chemin à part.
+
+ENTITÉS (7)  Campagne · Point · Feuillet · Releve · Anomalie · Dossier · Certificat
+VERBES       ouvrir · synchroniser · importer · enrichir · retenir · composer · remettre · consigner ·
+             declarer · qualifier · figer · exporter · recevoir · autoriser
+
+PARCOURS     candidate → verification → recette → validation → figee → certifiee → exploitation
+             (`abandonnee` : seule sortie latérale ; fermée une fois l'exploitation autorisée —
+              le logiciel est alors en production, « abandonner » n'y veut plus rien dire)
+
+LA CHAÎNE — TRANSPORT ASYMÉTRIQUE
+  ALLER  QaTrax ==trame signée==> ValiTrax : AUTOMATIQUE (deux de nos serveurs, port injecté)
+  puis   ValiTrax --feuillets--> le CLIENT : il lit, il coche
+  RETOUR ValiTrax --dossier figé signé--> QaTrax : À LA MAIN (le document passe par le client)
+  puis   QaTrax --certificat signé + le FEU--> ValiTrax --l'EXPOSE--> le client
+  La signature vaut DANS LES DEUX SENS : un canal direct dit d'où vient la connexion, pas ce que
+  le document contient. Une mauvaise URL injecterait une trame étrangère sans bruit.
+  QaTrax FAIT le PV, ValiTrax l'EXPOSE : le client ne va jamais sur un outil de développement.
+
+LE POINT DE RECETTE — DEUX MOITIÉS
+  TRAME (de QaTrax, réécrite à l'import) : ref · specRef · titreTrame · priorite · etapesTrame
+  ENRICHISSEMENT (à ValiTrax, JAMAIS écrasé) : libelle · attendu · role · ordre · langue · retenu
+  « Vérifier que POST /dossiers refuse un livrable non accepté » = titre de trame.
+  « Essayez de programmer une soutenance sur un dossier dont un livrable manque » = libellé de
+  recette. Même exigence, deux lecteurs, deux textes.
+  LA SÉLECTION EST DANS VALITRAX : la trame arrive entière, on en retient une partie.
+
+LE CLIENT N'EST PAS UNE MACHINE : IL LIT, IL COCHE
+  `feuillets.composer()` rend la structure EXACTE du manifeste des feuillets PDF :
+  { genre:'action', ref, libelle, attendu, specRef, enrichi, options:['ok','ko','er'] }
+  Papier, écran et moteur parlent une seule langue — un troisième format rouvrirait la divination.
+
+TROIS VALEURS, PLUS L'ABSENCE
+  ok = conforme · ko = marche AUTREMENT que le plan (corriger le DOCUMENT) ·
+  er = panne (corriger le CODE) · rien = non joué
+
+CE QU'IL NE FAIT PAS, ET QUI LE FAIT
+  tests / bugs / Release ............ @mostajs/qa-engine (RÉFÉRENCÉS, jamais recopiés)
+  produire les formulaires .......... ce module — QaTrax n'envoie que la trame
+  émettre le certificat ............. le certificateur — ce module le REÇOIT et le VÉRIFIE
+  cryptographie ..................... @mostajs/crypto-box (Ed25519, enveloppe X25519)
+  PV collégial scellé / QR .......... @mostajs/deliberation / @mostajs/certificates
+  fils, mentions / convocations ..... @mostajs/collab / @mostajs/notifications
+  PDF des feuillets ................. l'outillage de l'application
+  feuille photographiée ............. @mostajs/ocr
+
+SIGNER ≠ SCELLER
+  signer  = clé PRIVÉE de l'émetteur   → prouve l'ORIGINE (le document reste lisible par tous)
+  sceller = clé PUBLIQUE du destinataire → ferme le PLI (lui seul ouvre ; rien n'est authentifié)
+  Ordre imposé : signer PUIS sceller. L'inverse signerait un chiffré — on prouverait avoir
+  transmis une boîte, pas ce qu'elle contient.
+  Les verbes du sceau n'existent que si leur clé existe : une clé manquante se voit au démarrage,
+  pas à la fin de la recette quand tout le monde attend le document.
+
+LES GARDES — juger le module par elles
+  · l'URL de production est refusée
+  · le parcours ne saute pas de cran, et ne recule jamais
+  · trame : enveloppe, format ET signature vérifiés — même tirée automatiquement
+  · L'IMPORT N'ÉCRASE JAMAIS L'ENRICHISSEMENT, et dit combien il en a préservé
+  · on n'enrichit pas par-dessus la trame (titreTrame, specRef… refusés)
+  · on ne consigne que sur un feuillet REMIS ; un `er` sans HEURE est refusé
+  · qualifier n'efface pas la gravité annoncée par le client
+  · écarter EXIGE un motif
+  · le figement refuse et NOMME ce qui manque
+  · un export NON SIGNÉ est refusé
+  · le certificat doit citer l'EMPREINTE du dossier, et sa signature est vérifiée
+  · l'exploitation ne s'autorise que sur un certificat portant le feu
+
+L'EMPREINTE DÉCIDE DE TOUT
+  SHA-256 du contenu figé. Le certificat doit la citer. Sans elle il porterait sur « la recette »,
+  c'est-à-dire sur rien de vérifiable.
+
+PIÈGE CONNU
+  Réimporter une trame est le geste le plus fréquent de la vie d'une campagne. Toute évolution qui
+  ferait écrire l'import sur le côté enrichissement détruirait le travail humain SANS ERREUR — on
+  ne s'en apercevrait qu'en distribuant les feuillets. `CHAMPS_TRAME` est la liste blanche ; elle
+  se lit par `trame.champsEcrasables()`.
+
+USAGE       createRecette({ repositories, ports: { sceau, trameSource, audit }, clock, numeroteur })
+            creerSceau({ signature, destinataire, certificateur })  ← @mostajs/recette/sceau
+            engendrerClefs()  ← une fois, à la mise en service ; les clés vont au coffre
+ESSAIS      npm test — 13 essais, tous sur ce que le moteur REFUSE

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@mostajs/recette",
+  "version": "0.1.0",
+  "description": "Validation & recette applicative : trame `mostajs-devtest/1` reçue signée du certificateur, points enrichis POUR LE CLIENT (l'import n'écrase jamais l'enrichissement), feuillets composés à l'image du manifeste PDF (ok/ko/er), anomalies déclarées puis qualifiées, dossier figé et EXPORTÉ SIGNÉ — aucun appel réseau —, certificat reçu et vérifié, feu d'exploitation DÉRIVÉ du certificat. Powers ValiTrax (valitrax.mostajs.dev).",
+  "author": "Dr Hamid MADANI <drmdh@msn.com>",
+  "license": "AGPL-3.0-or-later",
+  "type": "module",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./schemas": "./src/schemas.js",
+    "./register": "./src/register.js",
+    "./sceau": "./src/sceau.js"
+  },
+  "files": [
+    "src",
+    "llms.txt",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "test": "bash test-scripts/run-tests.sh"
+  },
+  "keywords": [
+    "mostajs",
+    "recette",
+    "validation",
+    "uat",
+    "qa",
+    "pv",
+    "certificat"
+  ],
+  "mostajs": {
+    "niveau": "N3",
+    "nature": "metier",
+    "reutilisabilite": "mono-domaine",
+    "depend_de": [],
+    "question": "Qui a éprouvé cette version candidate, qu'a-t-il constaté, et sur quel acte repose l'autorisation de la mettre en production ?",
+    "forme": "moteur",
+    "entites": [
+      "Campagne",
+      "Point",
+      "Feuillet",
+      "Releve",
+      "Anomalie",
+      "Dossier",
+      "Certificat"
+    ],
+    "verbes": [
+      "ouvrir",
+      "importer",
+      "enrichir",
+      "retenir",
+      "composer",
+      "consigner",
+      "qualifier",
+      "figer",
+      "exporter",
+      "recevoir",
+      "autoriser"
+    ],
+    "ne_fait_pas": {
+      "gérer les tests, les exécutions et les bugs": "@mostajs/qa-engine",
+      "modéliser la version candidate": "@mostajs/qa-engine (Release) — référencée, jamais copiée",
+      "émettre le certificat": "l'autorité de certification (QaTrax) — ce module le REÇOIT et refuse ce qui ne s'y adosse pas",
+      "sceller un procès-verbal collégial": "@mostajs/deliberation",
+      "rendre un acte vérifiable par QR": "@mostajs/certificates",
+      "porter les fils de discussion et mentions": "@mostajs/collab",
+      "convoquer et relancer": "@mostajs/notifications",
+      "engendrer les feuillets PDF et leur manifeste": "l'outillage de l'application (voir ValiTrax)",
+      "lire une feuille papier photographiée": "@mostajs/ocr",
+      "implémenter la cryptographie": "@mostajs/crypto-box — Ed25519 pour signer, enveloppe X25519 pour sceller",
+      "déposer le dossier chez le certificateur": "personne : l'export est un FICHIER que le client ou notre service transporte",
+      "produire les formulaires du client": "ce module — QaTrax n'envoie que la TRAME (mostajs-devtest/1) ; la formulation appartient à la recette"
+    }
+  },
+  "peerDependencies": {
+    "@mostajs/mjs-unit": ">=0.4.0",
+    "@mostajs/crypto-box": ">=0.3.0"
+  },
+  "peerDependenciesMeta": {
+    "@mostajs/mjs-unit": {
+      "optional": true
+    },
+    "@mostajs/crypto-box": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@mostajs/crypto-box": "file:../../mosta-kernel-stack/mosta-crypto-box",
+    "@mostajs/mjs-unit": "^0.6.0"
+  }
+}

package/src/index.js

@@ -0,0 +1,14 @@
+// @mostajs/recette — point d'entrée (produit : ValiTrax). Author: Dr Hamid MADANI <drmdh@msn.com>
+//
+// N3 métier, et il ne dépend d'AUCUN autre N3. Son voisin naturel — `@mostajs/qa-engine`, qui
+// possède les tests, les bugs et les versions — est consommé par PORT injecté depuis l'app, et
+// seulement pour DÉPOSER un dossier. Cela évite le couplage latéral et garde le moteur éprouvable
+// seul, sans QaTrax en face.
+// `./sceau` n'est PAS ré-exporté ici : il importe `@mostajs/crypto-box`, et une app qui
+// n'exporte aucun dossier n'a pas à installer de cryptographie. Il s'obtient par le chemin
+// dédié : `import { creerSceau } from '@mostajs/recette/sceau'`.
+export { createRecette } from './recette.js';
+export { createMemoryRepositories } from './memory-repo.js';
+export {
+  CampagneSchema, PointSchema, FeuilletSchema, ReleveSchema, AnomalieSchema, DossierSchema, CertificatSchema, RECETTE_SCHEMAS,
+} from './schemas.js';

package/src/memory-repo.js

@@ -0,0 +1,17 @@
+// @mostajs/recette — dépôts en mémoire pour essais et exemples. Author: Dr Hamid MADANI <drmdh@msn.com>
+//
+// Ils ne servent PAS en exploitation : une app câble @mostajs/orm et ses dix-huit pilotes. Ils
+// existent pour que le moteur s'éprouve SEUL, sans base — c'est ce qui rend ses gardes testables.
+function coll() {
+  const m = new Map();
+  return {
+    async create(d) { const id = d.id || globalThis.crypto.randomUUID(); const now = new Date(); const r = { id, createdAt: now, updatedAt: now, ...d }; m.set(id, r); return { ...r }; },
+    async findById(id) { const r = m.get(id); return r ? { ...r } : null; },
+    async update(id, p) { const r = m.get(id); if (!r) return null; const x = { ...r, ...p, updatedAt: new Date() }; m.set(id, x); return { ...x }; },
+    async find(f = () => true) { return [...m.values()].filter(f).map((r) => ({ ...r })); },
+    async remove(id) { return m.delete(id); },
+  };
+}
+export function createMemoryRepositories() {
+  return { campagnes: coll(), points: coll(), feuillets: coll(), releves: coll(), anomalies: coll(), dossiers: coll(), certificats: coll() };
+}

package/src/recette.js

@@ -0,0 +1,489 @@
+// @mostajs/recette — le moteur. Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+//
+// CE QUE CE MODULE POSSÈDE, ET CE QU'IL NE POSSÈDE PAS.
+//
+// Il possède la RECETTE : la campagne, le feuillet remis à quelqu'un, le relevé d'une
+// observation, l'anomalie déclarée, le dossier figé, et le certificat reçu.
+//
+// Il ne possède NI les tests NI les bugs NI la version : ils vivent chez `@mostajs/qa-engine`.
+// `releaseRef` et `bugRef` sont des références OPAQUES. Deux modules qui modélisent la même chose
+// divergent, et l'on découvre la divergence le jour d'un litige.
+//
+// LE SENS DE LA CHAÎNE, ET SON TRANSPORT — ASYMÉTRIQUE, ET C'EST VOULU.
+//
+// ALLER (QaTrax → ValiTrax) : AUTOMATIQUE. La trame relie deux de NOS serveurs ; rien n'y
+// justifie une main humaine. `trame.synchroniser()` la tire par un port, la vérifie, l'importe.
+//
+// RETOUR (ValiTrax → QaTrax) : HUMAIN, parce que le document PASSE PAR LE CLIENT — c'est lui qui
+// valide, et c'est lui qui rend. `dossiers.exporter()` produit un fichier signé, que le client ou
+// notre service transporte et dépose. Ce n'est pas un pis-aller : c'est ce qui permet à un client
+// sans accès vers nos serveurs de rendre sa recette.
+//
+// LA SIGNATURE VAUT DANS LES DEUX SENS, y compris sur le canal automatique : une mauvaise URL ou
+// un réseau compromis injecterait une trame étrangère SANS BRUIT, et le client éprouverait autre
+// chose que ce qui a été spécifié — sans pouvoir s'en rendre compte, faute de référentiel.
+import { createHash } from 'node:crypto';
+
+/** Les six étapes, dans l'ordre. `abandonnee` est la seule sortie latérale, depuis n'importe où. */
+const PARCOURS = ['candidate', 'verification', 'recette', 'validation', 'figee', 'certifiee', 'exploitation'];
+const rang = (e) => PARCOURS.indexOf(e);
+
+const need = (v, msg) => { if (v === undefined || v === null || v === '') throw new Error(msg); return v; };
+const asDate = (d) => (d ? new Date(d) : null);
+
+export function createRecette({ repositories, ports = {}, clock = () => new Date(), numeroteur } = {}) {
+  const repo = need(repositories, 'repositories requis');
+  for (const c of ['campagnes', 'points', 'feuillets', 'releves', 'anomalies', 'dossiers', 'certificats']) {
+    need(repo[c], `dépôt « ${c} » requis`);
+  }
+  const audit = ports.audit || null;
+  const trace = async (evt, par, data) => { try { await audit?.log?.(evt, { par, ...data }); } catch { /* l'audit n'interrompt jamais un acte */ } };
+  // Le numéro est LISIBLE et se cite dans un courriel : `REC-2026-0007`. Injectable, parce qu'un
+  // établissement a le droit d'avoir sa propre forme.
+  const numero = numeroteur || (async (prefixe, n) => `${prefixe}-${new Date().getFullYear()}-${String(n + 1).padStart(4, '0')}`);
+
+  async function getCampagne(id) {
+    return need(await repo.campagnes.findById(id), `campagne introuvable : ${id}`);
+  }
+
+  /** Une transition n'AVANCE jamais de plus d'un cran, et ne recule jamais. */
+  async function avancer(campagne, vers, { by = null, reason = '' } = {}) {
+    if (vers === 'abandonnee') {
+      // On abandonne de partout, sauf une fois l'exploitation autorisée : à ce moment le logiciel
+      // est en production, et « abandonner la recette » ne veut plus rien dire.
+      if (campagne.state === 'exploitation') throw new Error("l'exploitation est autorisée : la campagne ne s'abandonne plus");
+    } else {
+      const de = rang(campagne.state), a = rang(vers);
+      if (a < 0) throw new Error(`étape inconnue : ${vers}`);
+      if (de < 0) throw new Error(`la campagne ${campagne.no || campagne.id} est ${campagne.state} — aucune transition possible`);
+      if (a !== de + 1) throw new Error(`transition illégale : ${campagne.state} → ${vers} (attendu : ${PARCOURS[de + 1] || 'aucune'})`);
+    }
+    const at = clock();
+    const out = await repo.campagnes.update(campagne.id, {
+      state: vers,
+      stateHistory: [...(campagne.stateHistory || []), { from: campagne.state, to: vers, at, by, reason }],
+      ...(vers === 'exploitation' || vers === 'abandonnee' ? { closeLe: at } : {}),
+    });
+    await trace('recette.campagne.transition', by, { campagneId: campagne.id, from: campagne.state, to: vers });
+    return out;
+  }
+
+  const campagnes = {
+    /** Ouvre la recette d'une version candidate. La version vient de QaTrax : on la RÉFÉRENCE. */
+    async ouvrir({ releaseRef, projet = '', perimetre = '', instanceUrl = '', tenantId = null, by = null } = {}) {
+      need(releaseRef, 'releaseRef requis — la version candidate vit chez QaTrax');
+      // L'INSTANCE ÉPROUVÉE N'EST PAS LA PRODUCTION, et c'est une garde, pas une consigne : une
+      // recette jouée sur la production écrit de fausses données dans le système réel du client.
+      if (/^https?:\/\/(www\.)?prod/i.test(instanceUrl)) throw new Error('une recette ne se joue pas sur la production');
+      const n = (await repo.campagnes.find(() => true)).length;
+      const c = await repo.campagnes.create({
+        no: await numero('REC', n), releaseRef, projet, perimetre, instanceUrl, tenantId,
+        state: 'candidate', stateHistory: [], ouverteLe: clock(),
+      });
+      await trace('recette.campagne.ouvrir', by, { campagneId: c.id, releaseRef });
+      return c;
+    },
+    get: getCampagne,
+    list: (filtre = () => true) => repo.campagnes.find(filtre),
+    avancer: async (id, vers, opts) => avancer(await getCampagne(id), vers, opts),
+  };
+
+  /** Les champs que l'import a le droit d'écrire. Tout le reste appartient à ValiTrax. */
+  const CHAMPS_TRAME = ['specRef', 'titreTrame', 'priorite', 'typeTrame', 'etapesTrame'];
+
+  const trame = {
+    /**
+     * IMPORTER LA TRAME — le `mostajs-devtest/1` que QaTrax exporte.
+     *
+     * SIGNÉE, comme tout ce qui traverse : une trame altérée en chemin ferait éprouver autre
+     * chose que ce qui a été spécifié, et personne ne s'en apercevrait.
+     *
+     * IDEMPOTENT PAR `ref`, et — c'est là que tout se joue — **l'enrichissement n'est jamais
+     * écrasé**. Une trame se réimporte à chaque version candidate ; si l'import régénérait les
+     * points, chaque réimport effacerait la formulation écrite pour le client, les rôles et
+     * l'ordre. On ne s'en apercevrait qu'en distribuant les feuillets.
+     */
+    async importer(campagneId, document, { by = null, signature = null } = {}) {
+      const c = await getCampagne(campagneId);
+      if (rang(c.state) > rang('recette')) throw new Error(`la trame ne s'importe plus à l'étape « ${c.state} »`);
+
+      const plan = typeof document === 'string' ? JSON.parse(document) : document;
+      if (plan?.plan !== 'mostajs-devtest/1') throw new Error(`format inconnu : ${plan?.plan || '(absent)'} — attendu mostajs-devtest/1`);
+      // La signature de la trame se vérifie comme celle du PV. Même clé publique, même hors ligne.
+      if (signature) {
+        if (!ports.sceau?.verifier) throw new Error('trame signée mais aucune clé publique configurée pour la vérifier');
+        if (!(await ports.sceau.verifier(typeof document === 'string' ? document : JSON.stringify(plan), signature))) {
+          throw new Error('signature de la trame INVALIDE — import refusé');
+        }
+      }
+
+      const existants = new Map((await repo.points.find((p) => p.campagneId === campagneId)).map((p) => [p.ref, p]));
+      const bilan = { crees: 0, majTrame: 0, enrichissementsPreserves: 0 };
+      for (const t of plan.tests || []) {
+        if (!t.ref) continue;
+        const cote = {
+          specRef: t.specRef || null, titreTrame: t.title || '', priorite: t.priority || 'medium',
+          typeTrame: t.type || null, etapesTrame: t.steps || [], importeLe: clock(),
+        };
+        const deja = existants.get(t.ref);
+        if (!deja) { await repo.points.create({ campagneId, ref: t.ref, ...cote }); bilan.crees += 1; continue; }
+        // On n'écrit QUE les champs de trame. `libelle`, `attendu`, `role`, `ordre`, `langue`
+        // et `retenu` ne figurent pas dans `cote` — et c'est tout l'objet de cette ligne.
+        await repo.points.update(deja.id, cote);
+        bilan.majTrame += 1;
+        if (deja.libelle || deja.role) bilan.enrichissementsPreserves += 1;
+      }
+      await trace('recette.trame.importer', by, { campagneId, ...bilan });
+      return bilan;
+    },
+    /**
+     * SYNCHRONISER — tirer la trame de QaTrax, automatiquement.
+     *
+     * C'est le SEUL sens automatisé de la chaîne. Le port est injecté : le moteur ne connaît ni
+     * URL, ni jeton, ni transport — l'app câble `GET /trame?p=<projet>` et rien ne remonte ici.
+     *
+     * La vérification de signature n'est PAS allégée parce que le canal est direct. Un canal
+     * direct dit d'où VIENT la connexion, pas ce que le document CONTIENT.
+     */
+    async synchroniser(campagneId, { projet, by = null } = {}) {
+      const source = ports.trameSource;
+      if (!source?.lire) throw new Error("aucune source de trame configurée : rien à synchroniser");
+      const doc = await source.lire({ projet: need(projet, 'projet requis') });
+      const enveloppe = typeof doc === 'string' ? JSON.parse(doc) : doc;
+      if (enveloppe?.type !== 'mostajs-recette-trame/1') {
+        throw new Error(`enveloppe inconnue : ${enveloppe?.type || '(absente)'} — attendu mostajs-recette-trame/1`);
+      }
+      // `enveloppe.plan` est le TEXTE exact qui a été signé, pas un objet reconstruit : deux
+      // sérialisations peuvent différer d'un espace, et la vérification échouerait alors sur un
+      // document intact — le pire des refus, celui qu'on met des heures à comprendre.
+      const bilan = await trame.importer(campagneId, enveloppe.plan, { signature: enveloppe.signature, by });
+      await trace('recette.trame.synchroniser', by, { campagneId, projet, ...bilan });
+      return { ...bilan, emisLe: enveloppe.emisLe || null };
+    },
+
+    /** Ce que l'import a le droit de toucher — rendu, pour qu'on n'ait pas à le deviner. */
+    champsEcrasables: () => [...CHAMPS_TRAME],
+  };
+
+  const points = {
+    /** L'ENRICHISSEMENT : écrire le point POUR LE CLIENT. Refuse de toucher au côté trame. */
+    async enrichir(pointId, patch = {}, { by = null } = {}) {
+      const p = need(await repo.points.findById(pointId), `point introuvable : ${pointId}`);
+      const interdits = Object.keys(patch).filter((k) => CHAMPS_TRAME.includes(k) || k === 'ref' || k === 'campagneId');
+      if (interdits.length) throw new Error(`ces champs viennent de la trame et ne s'enrichissent pas : ${interdits.join(', ')}`);
+      await trace('recette.point.enrichir', by, { pointId });
+      return repo.points.update(p.id, patch);
+    },
+    /** LA SÉLECTION — dans ValiTrax, jamais chez QaTrax. */
+    async retenir(campagneId, refs, { retenu = true, by = null } = {}) {
+      const voulus = new Set(refs);
+      const ps = await repo.points.find((p) => p.campagneId === campagneId && voulus.has(p.ref));
+      const absents = [...voulus].filter((r) => !ps.some((p) => p.ref === r));
+      if (absents.length) throw new Error(`références absentes de la trame : ${absents.join(', ')}`);
+      for (const p of ps) await repo.points.update(p.id, { retenu });
+      await trace('recette.point.retenir', by, { campagneId, n: ps.length, retenu });
+      return ps.length;
+    },
+    of: (campagneId) => repo.points.find((p) => p.campagneId === campagneId),
+    retenus: (campagneId) => repo.points.find((p) => p.campagneId === campagneId && p.retenu),
+  };
+
+  const feuillets = {
+    /** Remettre un feuillet à quelqu'un. C'est l'acte qui autorise ses relevés. */
+    async remettre({ campagneId, role, destinataireId = null, destinataire = '', langue = 'fr', planVersion = '', by = null } = {}) {
+      const c = await getCampagne(need(campagneId, 'campagneId requis'));
+      if (!['verification', 'recette'].includes(c.state)) {
+        throw new Error(`on ne remet pas de feuillet à l'étape « ${c.state} » (attendu : verification ou recette)`);
+      }
+      const f = await repo.feuillets.create({
+        campagneId, role: need(role, 'role requis'), destinataireId, destinataire, langue, planVersion,
+        state: 'remis', remisLe: clock(),
+      });
+      await trace('recette.feuillet.remettre', by, { feuilletId: f.id, campagneId, role });
+      return f;
+    },
+    /** Le testeur rend son feuillet : plus aucun relevé n'y entre. */
+    async rendre(feuilletId, { by = null } = {}) {
+      const f = need(await repo.feuillets.findById(feuilletId), `feuillet introuvable : ${feuilletId}`);
+      if (f.state !== 'remis') throw new Error(`le feuillet est déjà « ${f.state} » — il ne se rend pas deux fois`);
+      const out = await repo.feuillets.update(f.id, { state: 'rendu', renduLe: clock() });
+      await trace('recette.feuillet.rendre', by, { feuilletId });
+      return out;
+    },
+    depouiller: async (feuilletId, { by = null } = {}) => {
+      const f = need(await repo.feuillets.findById(feuilletId), `feuillet introuvable : ${feuilletId}`);
+      if (f.state !== 'rendu') throw new Error(`on ne dépouille qu'un feuillet rendu (celui-ci est « ${f.state} »)`);
+      await trace('recette.feuillet.depouiller', by, { feuilletId });
+      return repo.feuillets.update(f.id, { state: 'depouille' });
+    },
+    of: (campagneId) => repo.feuillets.find((f) => f.campagneId === campagneId),
+
+    /**
+     * COMPOSER un feuillet — et rendre ce que le CLIENT va lire.
+     *
+     * LE CLIENT N'EST PAS UNE MACHINE : il lit, et il coche. La sortie a donc exactement la forme
+     * du manifeste des feuillets PDF — `{ ref, libelle, attendu, options: ['ok','ko','er'] }` —
+     * pour que le papier, l'écran et le moteur parlent UNE langue. Un troisième format ici, et
+     * l'on retomberait dans la divination : quel rectangle porte quelle réponse ?
+     *
+     * Le libellé rendu est l'ENRICHISSEMENT s'il existe, à défaut la matière de la trame. Un
+     * point non enrichi reste lisible — mais il parle le langage du développeur, et cela se voit.
+     */
+    async composer({ campagneId, role, langue = 'fr', destinataire = '', destinataireId = null, planVersion = '', by = null } = {}) {
+      const retenus = (await points.retenus(campagneId))
+        .filter((p) => !p.role || p.role === role)
+        .sort((a, b) => (a.ordre - b.ordre) || String(a.ref).localeCompare(String(b.ref)));
+      if (!retenus.length) throw new Error(`aucun point retenu pour le rôle « ${role} » — rien à composer`);
+      const f = await feuillets.remettre({ campagneId, role, destinataire, destinataireId, langue, planVersion, by });
+      return {
+        feuillet: f,
+        cases: retenus.map((p) => ({
+          genre: 'action',
+          ref: p.ref,
+          libelle: p.libelle || p.titreTrame,
+          attendu: p.attendu || (p.etapesTrame || []).map((e) => e.expected).filter(Boolean).join(' · '),
+          specRef: p.specRef,                    // la couverture reste traçable jusqu'à l'exigence
+          enrichi: Boolean(p.libelle),           // dit si le client lira du français de métier
+          options: ['ok', 'ko', 'er'],
+        })),
+      };
+    },
+  };
+
+  const releves = {
+    /**
+     * Consigner une observation.
+     *
+     * GARDE : le feuillet doit être REMIS et pas encore rendu. Consigner sur un feuillet jamais
+     * distribué, ou déjà rendu, produit une observation que personne n'a faite — et c'est
+     * précisément ce qu'un procès-verbal ne doit pas contenir.
+     */
+    async consigner({ feuilletId, ref, issue, at = null, texte = '', source = 'formulaire', confiance = 1, by = null } = {}) {
+      const f = need(await repo.feuillets.findById(need(feuilletId, 'feuilletId requis')), `feuillet introuvable : ${feuilletId}`);
+      if (f.state !== 'remis') throw new Error(`le feuillet est « ${f.state} » : on n'y consigne plus rien`);
+      if (!['ok', 'ko', 'er'].includes(issue)) throw new Error(`issue inconnue : ${issue} (attendu : ok, ko ou er)`);
+      // L'HEURE d'un `er` n'est pas décorative : c'est elle qui permet de retrouver la trace côté
+      // serveur. Un incident sans heure est une impression.
+      if (issue === 'er' && !at) throw new Error("un `er` se consigne avec son HEURE — c'est elle qui retrouve la trace serveur");
+      const r = await repo.releves.create({
+        feuilletId, campagneId: f.campagneId, ref: need(ref, 'ref requis'), issue,
+        at: asDate(at) || clock(), texte, source, confiance,
+      });
+      await trace('recette.releve.consigner', by, { releveId: r.id, feuilletId, ref, issue });
+      return r;
+    },
+    of: (campagneId) => repo.releves.find((r) => r.campagneId === campagneId),
+    duFeuillet: (feuilletId) => repo.releves.find((r) => r.feuilletId === feuilletId),
+  };
+
+  const anomalies = {
+    /** Ce que le client DÉCLARE. Ce n'est pas encore un bug. */
+    async declarer({ campagneId, titre, description = '', declareePar, graviteProposee = null, feuilletId = null, releveRef = null } = {}) {
+      const c = await getCampagne(need(campagneId, 'campagneId requis'));
+      if (!['verification', 'recette', 'validation'].includes(c.state)) {
+        throw new Error(`on ne déclare pas d'anomalie à l'étape « ${c.state} »`);
+      }
+      const a = await repo.anomalies.create({
+        campagneId, titre: need(titre, 'titre requis'), description,
+        declareePar: need(declareePar, 'declareePar requis'), graviteProposee,
+        feuilletId, releveRef, state: 'declaree',
+      });
+      await trace('recette.anomalie.declarer', declareePar, { anomalieId: a.id, campagneId });
+      return a;
+    },
+    /**
+     * QUALIFIER — l'acte de l'éditeur, qui n'efface pas celui du client.
+     *
+     * `graviteProposee` reste. Effacer la gravité annoncée par le client, c'est effacer le
+     * désaccord — et le désaccord est ce qu'un procès-verbal doit pouvoir montrer.
+     */
+    async qualifier(anomalieId, { gravite, bugRef = null, by = null } = {}) {
+      const a = need(await repo.anomalies.findById(anomalieId), `anomalie introuvable : ${anomalieId}`);
+      if (!['bloquante', 'majeure', 'mineure'].includes(gravite)) throw new Error(`gravité inconnue : ${gravite}`);
+      const out = await repo.anomalies.update(a.id, { graviteQualifiee: gravite, bugRef, state: 'qualifiee', qualifieePar: by, qualifieeLe: clock() });
+      await trace('recette.anomalie.qualifier', by, { anomalieId, gravite, bugRef });
+      return out;
+    },
+    /** Écarter : ce n'est pas un défaut. Le MOTIF est exigé — « ce n'est pas un bug » sans raison
+     *  laisse le client sans réponse, et c'est ainsi qu'une recette se termine mal. */
+    async ecarter(anomalieId, { motif, by = null } = {}) {
+      const a = need(await repo.anomalies.findById(anomalieId), `anomalie introuvable : ${anomalieId}`);
+      need(motif, "un motif est requis pour écarter une anomalie");
+      const out = await repo.anomalies.update(a.id, { state: 'ecartee', motifEcart: motif, qualifieePar: by, qualifieeLe: clock() });
+      await trace('recette.anomalie.ecarter', by, { anomalieId, motif });
+      return out;
+    },
+    /** Le lien vers le bug QaTrax. Ce module ne CRÉE pas le bug : il en garde la référence. */
+    async promouvoir(anomalieId, bugRef, { by = null } = {}) {
+      const a = need(await repo.anomalies.findById(anomalieId), `anomalie introuvable : ${anomalieId}`);
+      if (a.state === 'declaree') throw new Error("une anomalie se qualifie avant d'être promue en bug");
+      await trace('recette.anomalie.promouvoir', by, { anomalieId, bugRef });
+      return repo.anomalies.update(a.id, { bugRef: need(bugRef, 'bugRef requis') });
+    },
+    corriger: (anomalieId, { by = null } = {}) => repo.anomalies.update(anomalieId, { state: 'corrigee' }).then(async (r) => { await trace('recette.anomalie.corriger', by, { anomalieId }); return r; }),
+    verifier: (anomalieId, { by = null } = {}) => repo.anomalies.update(anomalieId, { state: 'verifiee' }).then(async (r) => { await trace('recette.anomalie.verifier', by, { anomalieId }); return r; }),
+    of: (campagneId) => repo.anomalies.find((a) => a.campagneId === campagneId),
+  };
+
+  /** Ce qui EMPÊCHE de figer le dossier — rendu en clair, jamais en booléen. */
+  async function obstaclesAuDepot(campagneId) {
+    const out = [];
+    const fs = await feuillets.of(campagneId);
+    const enAttente = fs.filter((f) => f.state === 'remis');
+    if (enAttente.length) out.push(`${enAttente.length} feuillet(s) non rendu(s) : ${enAttente.map((f) => f.role).join(', ')}`);
+    const as = await anomalies.of(campagneId);
+    const nonQualifiees = as.filter((a) => a.state === 'declaree');
+    if (nonQualifiees.length) out.push(`${nonQualifiees.length} anomalie(s) déclarée(s) et non qualifiée(s)`);
+    // Une BLOQUANTE ne se dépose pas : soit elle est corrigée ET revérifiée, soit le client a
+    // accepté de l'écarter. Déposer un dossier portant une bloquante ouverte, c'est demander un
+    // certificat sur un logiciel qu'on sait inutilisable.
+    const bloquantes = as.filter((a) => a.graviteQualifiee === 'bloquante' && !['verifiee', 'ecartee'].includes(a.state));
+    if (bloquantes.length) out.push(`${bloquantes.length} anomalie(s) BLOQUANTE(s) ni vérifiée(s) ni écartée(s)`);
+    return out;
+  }
+
+  const dossiers = {
+    obstacles: obstaclesAuDepot,
+    /**
+     * FIGER le dossier de recette.
+     *
+     * L'EMPREINTE est ce qui rend le certificat opposable : elle dit sur QUOI il porte. Sans
+     * elle, un certificat porterait sur « la recette », c'est-à-dire sur rien de vérifiable.
+     */
+    async figer(campagneId, { by = null, force = false } = {}) {
+      const c = await getCampagne(campagneId);
+      if (c.state !== 'validation') throw new Error(`le dossier se fige depuis « validation » (la campagne est « ${c.state} »)`);
+      const obstacles = await obstaclesAuDepot(campagneId);
+      if (obstacles.length && !force) throw new Error(`figement refusé — ${obstacles.join(' · ')}`);
+
+      const fs = await feuillets.of(campagneId);
+      const rs = await releves.of(campagneId);
+      const as = await anomalies.of(campagneId);
+      const contenu = {
+        campagne: { no: c.no, releaseRef: c.releaseRef, projet: c.projet, perimetre: c.perimetre, instanceUrl: c.instanceUrl },
+        feuillets: fs.map((f) => ({ role: f.role, langue: f.langue, state: f.state, planVersion: f.planVersion })),
+        releves: rs.map((r) => ({ ref: r.ref, issue: r.issue, at: r.at, source: r.source, confiance: r.confiance, texte: r.texte })),
+        anomalies: as.map((a) => ({ titre: a.titre, graviteProposee: a.graviteProposee, graviteQualifiee: a.graviteQualifiee, state: a.state, bugRef: a.bugRef, motifEcart: a.motifEcart })),
+        compteurs: { ok: rs.filter((r) => r.issue === 'ok').length, ko: rs.filter((r) => r.issue === 'ko').length, er: rs.filter((r) => r.issue === 'er').length },
+        obstaclesAuFigement: obstacles,   // consignés même en `force` : un dossier dit ce qu'il vaut
+      };
+      const empreinte = createHash('sha256').update(JSON.stringify(contenu)).digest('hex');
+      const n = (await repo.dossiers.find(() => true)).length;
+      const d = await repo.dossiers.create({ campagneId, no: await numero('DOS-REC', n), figeLe: clock(), figePar: by, empreinte, contenu });
+      await avancer(c, 'figee', { by, reason: `dossier ${d.no}` });
+      await trace('recette.dossier.figer', by, { campagneId, dossierId: d.id, empreinte });
+      return repo.dossiers.findById(d.id);
+    },
+
+    /**
+     * EXPORTER — le document qui quitte ValiTrax, et le seul.
+     *
+     * Il est SIGNÉ (clé privée de l'instance : il dit d'où il vient) et, si un destinataire est
+     * configuré, SCELLÉ pour lui (sa clé publique : lui seul l'ouvre). Signer et sceller ne sont
+     * pas la même chose et ne se remplacent pas — l'un prouve l'origine, l'autre ferme le pli.
+     *
+     * Un export NON SIGNÉ est refusé : il ne prouverait rien, et c'est pourtant tout ce qu'on lui
+     * demande. Le transport, lui, ne regarde pas ce module : courriel, clé USB, dépôt manuel.
+     */
+    async exporter(campagneId, { by = null, sceller = false } = {}) {
+      const c = await getCampagne(campagneId);
+      if (rang(c.state) < rang('figee')) throw new Error(`rien à exporter : la campagne est « ${c.state} », le dossier n'est pas figé`);
+      const d = need(await dossiers.of(campagneId), 'aucun dossier figé pour cette campagne');
+      const sceau = ports.sceau;
+      if (!sceau?.signer) throw new Error("aucun sceau configuré : un export non signé ne prouve rien, il est refusé");
+
+      const enveloppe = {
+        type: 'mostajs-recette-dossier/1',
+        emisLe: clock().toISOString(),
+        campagne: { no: c.no, releaseRef: c.releaseRef },
+        dossier: { no: d.no, empreinte: d.empreinte, figeLe: d.figeLe },
+        contenu: d.contenu,
+      };
+      const charge = JSON.stringify(enveloppe);
+      const signature = await sceau.signer(charge);
+      let corps = { enveloppe, signature };
+      if (sceller) {
+        if (!sceau.sceller) throw new Error("scellement demandé mais aucun destinataire configuré (clé publique du certificateur)");
+        corps = { type: 'mostajs-recette-scelle/1', scelle: await sceau.sceller(JSON.stringify(corps)) };
+      }
+      await repo.dossiers.update(d.id, { signature, scelle: Boolean(sceller), exporteLe: clock(), exportePar: by });
+      await trace('recette.dossier.exporter', by, { campagneId, dossierId: d.id, scelle: Boolean(sceller) });
+      return corps;
+    },
+
+    /** L'accusé rendu par QaTrax APRÈS dépôt manuel — enregistré, jamais supposé. */
+    accuser: async (campagneId, depotRef) => {
+      const d = need(await dossiers.of(campagneId), 'aucun dossier pour cette campagne');
+      return repo.dossiers.update(d.id, { depotRef: need(depotRef, 'depotRef requis') });
+    },
+    of: async (campagneId) => (await repo.dossiers.find((x) => x.campagneId === campagneId))[0] || null,
+  };
+
+  const certificats = {
+    /**
+     * RECEVOIR le certificat émis par QaTrax. Ce module ne signe pas — il vérifie l'adossement.
+     *
+     * L'empreinte doit correspondre au dossier déposé : un certificat qui porte sur un autre
+     * contenu que celui qu'on a soumis n'est pas un certificat, c'est une homonymie.
+     */
+    async recevoir(campagneId, { no, verdict, empreinteDossier, signature, reserves = [], emisPar = '', emisLe = null, verificationUrl = '', documentRef = null, goExploitation = false, by = null } = {}) {
+      const c = await getCampagne(campagneId);
+      if (c.state !== 'figee') throw new Error(`un certificat se reçoit sur une campagne figée (celle-ci est « ${c.state} »)`);
+      const d = need(await dossiers.of(campagneId), 'aucun dossier déposé pour cette campagne');
+      if (empreinteDossier !== d.empreinte) {
+        throw new Error(`le certificat porte sur une autre empreinte que le dossier déposé — reçu ${String(empreinteDossier).slice(0, 12)}…, attendu ${d.empreinte.slice(0, 12)}…`);
+      }
+      if (!['accepte', 'accepte-avec-reserves', 'refuse'].includes(verdict)) throw new Error(`verdict inconnu : ${verdict}`);
+      // LA SIGNATURE DU PV SE VÉRIFIE, elle ne se croit pas. Un certificat non vérifié vaut ce
+      // que vaut le courriel qui l'apportait — c'est-à-dire rien, le jour où quelqu'un conteste.
+      // Même construction que la licence signée de LabTrax : clé publique du tiers, hors ligne.
+      need(signature, "un certificat NON SIGNÉ n'est pas un certificat");
+      if (!ports.sceau?.verifier) throw new Error("aucune clé publique du certificateur configurée : la signature du PV ne peut pas être vérifiée");
+      const atteste = JSON.stringify({ no, campagne: c.no, empreinteDossier, verdict, goExploitation: Boolean(goExploitation) });
+      if (!(await ports.sceau.verifier(atteste, signature))) throw new Error(`signature du certificat ${no} INVALIDE — le document est refusé`);
+      const cert = await repo.certificats.create({
+        campagneId, no: need(no, 'no du certificat requis'), empreinteDossier, verdict, reserves,
+        emisPar, emisLe: asDate(emisLe) || clock(), verificationUrl, documentRef, signature,
+        goExploitation: Boolean(goExploitation), goLe: goExploitation ? clock() : null,
+      });
+      await avancer(c, 'certifiee', { by, reason: `certificat ${cert.no} — ${verdict}` });
+      await trace('recette.certificat.recevoir', by, { campagneId, no: cert.no, verdict });
+      return cert;
+    },
+    of: async (campagneId) => (await repo.certificats.find((x) => x.campagneId === campagneId))[0] || null,
+  };
+
+  /**
+   * LE FEU — il DÉRIVE du certificat, il ne se coche pas.
+   *
+   * Un « go » qui s'attribue sans certificat ne s'oppose à personne six mois plus tard, quand la
+   * question devient « qui avait validé ça ? ». C'est la raison d'être de tout ce qui précède.
+   */
+  async function autoriserExploitation(campagneId, { by = null, dateEffet = null } = {}) {
+    const c = await getCampagne(campagneId);
+    const cert = await certificats.of(campagneId);
+    if (!cert) throw new Error("aucun certificat reçu : l'exploitation ne s'autorise pas sans lui");
+    if (cert.verdict === 'refuse') throw new Error(`le certificat ${cert.no} REFUSE la version — l'exploitation est fermée`);
+    if (!cert.goExploitation) throw new Error(`le certificat ${cert.no} ne porte pas le feu vers l'exploitation`);
+    const out = await avancer(c, 'exploitation', { by, reason: `certificat ${cert.no}${dateEffet ? ` · effet ${new Date(dateEffet).toISOString()}` : ''}` });
+    await trace('recette.exploitation.autoriser', by, { campagneId, certificat: cert.no });
+    return out;
+  }
+
+  /** L'état d'une campagne, en une lecture : ce qui manque, et ce qui bloque. */
+  async function etat(campagneId) {
+    const c = await getCampagne(campagneId);
+    const fs = await feuillets.of(campagneId);
+    const rs = await releves.of(campagneId);
+    const as = await anomalies.of(campagneId);
+    return {
+      campagne: { no: c.no, state: c.state, releaseRef: c.releaseRef },
+      feuillets: { remis: fs.length, rendus: fs.filter((f) => f.state !== 'remis').length },
+      releves: { ok: rs.filter((r) => r.issue === 'ok').length, ko: rs.filter((r) => r.issue === 'ko').length, er: rs.filter((r) => r.issue === 'er').length },
+      anomalies: { declarees: as.filter((a) => a.state === 'declaree').length, bloquantes: as.filter((a) => a.graviteQualifiee === 'bloquante').length, total: as.length },
+      obstacles: await obstaclesAuDepot(campagneId),
+    };
+  }
+
+  return { campagnes, trame, points, feuillets, releves, anomalies, dossiers, certificats, autoriserExploitation, etat, PARCOURS };
+}

package/src/register.js

@@ -0,0 +1,55 @@
+// @mostajs/recette — enregistrement runtime (contrat @mostajs/module-contract).
+// Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+//
+// Le module CONTRIBUE ses schémas par le CONTRAT ; `@mostajs/socle` les agrège avec ceux des
+// autres modules câblés. Une app n'a donc pas de liste de schémas à tenir — liste qui, le jour où
+// ce module gagne une entité, ne le saurait pas : la table ne serait jamais créée, EN SILENCE.
+import { RECETTE_SCHEMAS } from './schemas.js';
+
+export function register(registry) {
+  registry.register({
+    manifest: {
+      name: 'recette',
+      package: '@mostajs/recette',
+      // À TENIR ÉGALE à `package.json` — un essai l'épingle.
+      version: '0.1.0',
+      type: 'business',
+      priority: 100,
+      displayName: 'Recette (ValiTrax)',
+      description: "Validation & recette applicative : campagne sur une version candidate, feuillets remis, relevés, anomalies déclarées puis qualifiées, dossier figé déposé, certificat reçu et feu d'exploitation dérivé.",
+      icon: 'ClipboardCheck',
+      register: './src/register.js',
+    },
+    // Les PERMISSIONS sont nommées PAR LE MODULE : sans cela, chaque app réinventerait un
+    // vocabulaire, et deux apps le composant n'auraient aucun nom en commun. L'app agrège et
+    // n'a plus qu'à définir ses RÔLES — le seul étage légitimement propre à une organisation.
+    // FORME IMPOSÉE PAR LE CONTRAT : `{ permissions, definitions, categories }`, pas un tableau.
+    permissions: {
+      permissions: {
+        'recette:campagne:ouvrir': 'Ouvrir une campagne de recette',
+        'recette:campagne:lire': 'Consulter une campagne',
+        'recette:campagne:conduire': 'Faire avancer une campagne',
+        'recette:feuillet:remettre': 'Remettre un feuillet à un testeur',
+        'recette:releve:consigner': 'Consigner une observation',
+        'recette:anomalie:declarer': 'Déclarer une anomalie',
+        'recette:anomalie:qualifier': 'Qualifier ou écarter une anomalie',
+        'recette:dossier:deposer': 'Figer et déposer le dossier de recette',
+        'recette:exploitation:autoriser': "Autoriser l'exploitation",
+      },
+      definitions: {
+        'recette:anomalie:declarer': {
+          label: 'Déclarer une anomalie',
+          // Le CLIENT la porte. C'est la permission qui rend la délégation réelle : sans elle,
+          // « déléguer la recette » se réduit à envoyer un document.
+          note: "Portée par le client. Une anomalie déclarée n'est pas un bug : elle le devient après qualification.",
+        },
+        'recette:exploitation:autoriser': {
+          label: "Autoriser l'exploitation",
+          note: "Ne s'exerce QUE sur un certificat reçu portant le feu. Le go dérive du certificat, il ne se coche pas.",
+        },
+      },
+      categories: { recette: 'Recette & validation' },
+    },
+    schemas: RECETTE_SCHEMAS.map((schema) => ({ name: schema.name, schema })),
+  });
+}

package/src/sceau.js

@@ -0,0 +1,98 @@
+// @mostajs/recette — le SCEAU : signer ce qui part, vérifier ce qui revient.
+// Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+//
+// POURQUOI CE FICHIER EST À PART, ET EXPOSÉ EN `@mostajs/recette/sceau`.
+// Le moteur (`.`) ne connaît AUCUNE cryptographie : il reçoit un port `sceau` à trois verbes et
+// refuse d'exporter sans lui. Ici vit le câblage canonique sur `@mostajs/crypto-box` — la seule
+// maison des primitives de l'écosystème (N0). Deux conséquences :
+//   · une app qui n'exporte pas n'a aucune dépendance cryptographique à installer ;
+//   · le FORMAT de la signature est le même partout, parce qu'il n'est écrit qu'ici.
+//
+// ─── SIGNER ET SCELLER NE SONT PAS LA MÊME CHOSE ─────────────────────────────────────────────
+// On SIGNE avec sa clé PRIVÉE ; le destinataire vérifie avec la clé PUBLIQUE correspondante.
+// Cela prouve l'ORIGINE, et rien d'autre : un document signé se lit par tout le monde.
+// On SCELLE avec la clé PUBLIQUE du destinataire ; lui seul ouvre, avec sa privée.
+// Cela ferme le PLI, et rien d'autre : un document scellé n'est pas authentifié pour autant.
+//
+// L'usage attendu ici les enchaîne, dans cet ordre : **signer PUIS sceller**. Sceller d'abord
+// signerait un chiffré — on prouverait qu'on a bien transmis une boîte, pas ce qu'elle contient.
+//
+// La formule « signé avec la clé publique fournie par le certificateur » décrit en réalité le
+// SCELLEMENT : cette clé sert à fermer le pli à son intention, pas à prouver notre identité.
+// C'est `destinataire.publique` ci-dessous. Notre identité, elle, vient de `signature.privee`.
+import { sign, verifySignature, seal, generateSigningKeyPair, generateRecipientKeyPair } from '@mostajs/crypto-box';
+
+const ALG_SIGNATURE = 'Ed25519';
+
+/** Accepte une clé en Buffer, en base64 ou en hexadécimal — un `.env` ne transporte pas d'octets. */
+function octets(k, quoi) {
+  if (!k) throw new Error(`clé absente : ${quoi}`);
+  if (k instanceof Uint8Array) return k;
+  const t = String(k).trim();
+  if (/^[0-9a-f]+$/i.test(t) && t.length % 2 === 0) return Buffer.from(t, 'hex');
+  return Buffer.from(t, 'base64');
+}
+
+/**
+ * Le port `sceau` du moteur, câblé sur crypto-box.
+ *
+ * LES VERBES N'EXISTENT QUE SI LEUR CLÉ EXISTE. Ce n'est pas une commodité : le moteur décide de
+ * refuser un export ou un certificat en regardant si le verbe est là. Rendre `signer` sans clé
+ * privée produirait une erreur au moment de l'export — c'est-à-dire à la fin de la recette,
+ * quand tout le monde attend le document. Mieux vaut qu'il manque tout de suite.
+ *
+ * @param {object}  opt
+ * @param {object}  [opt.signature]     `{ privee, nom }` — NOTRE identité (Ed25519). Sans elle, pas d'export.
+ * @param {object}  [opt.destinataire]  `{ publique }` — le certificateur (X25519). Sans elle, pas de scellement.
+ * @param {object}  [opt.certificateur] `{ publique }` — le certificateur (Ed25519). Sans elle, aucun PV vérifiable.
+ */
+export function creerSceau({ signature, destinataire, certificateur } = {}) {
+  const port = {};
+
+  if (signature?.privee) {
+    const privee = octets(signature.privee, 'signature.privee');
+    const nom = signature.nom || 'valitrax';
+    port.signer = async (charge) => ({
+      alg: ALG_SIGNATURE,
+      cle: nom,                                   // QUELLE clé a signé — une instance en change un jour
+      valeur: Buffer.from(sign(privee, charge)).toString('base64'),
+    });
+  }
+
+  if (destinataire?.publique) {
+    const pub = octets(destinataire.publique, 'destinataire.publique');
+    // `seal` prend une LISTE de destinataires : le format en accepte jusqu'à 255. Ici un seul —
+    // mais garder la liste ouverte évite de refaire l'enveloppe le jour où un client exige d'être
+    // destinataire de son propre dossier.
+    port.sceller = async (charge) => Buffer.from(seal([pub], charge)).toString('base64');
+  }
+
+  if (certificateur?.publique) {
+    const pub = octets(certificateur.publique, 'certificateur.publique');
+    port.verifier = async (charge, sig) => {
+      // Un algorithme inattendu n'est pas une signature invalide : c'est un document qu'on ne
+      // sait pas lire. On refuse dans les deux cas, mais on ne prétend pas avoir vérifié.
+      if (!sig || sig.alg !== ALG_SIGNATURE || !sig.valeur) return false;
+      try { return verifySignature(pub, charge, Buffer.from(sig.valeur, 'base64')); } catch { return false; }
+    };
+  }
+
+  return port;
+}
+
+/**
+ * Engendre les paires de clés d'une installation. À exécuter UNE fois, à la mise en service.
+ *
+ * Rendues en base64, parce qu'elles finiront dans un `.env` ou un coffre — jamais dans le code,
+ * et jamais dans un dépôt. La PRIVÉE de signature ne quitte pas l'instance qui signe ; la
+ * PUBLIQUE de réception se donne à qui doit nous écrire.
+ */
+export function engendrerClefs() {
+  const s = generateSigningKeyPair();
+  const r = generateRecipientKeyPair();
+  const b64 = (x) => Buffer.from(x).toString('base64');
+  return {
+    signature: { privee: b64(s.privateKey), publique: b64(s.publicKey) },   // Ed25519 — prouver l'origine
+    reception: { privee: b64(r.privateKey), publique: b64(r.publicKey) },   // X25519  — recevoir un pli scellé
+  };
+}

package/src/schemas.js

@@ -0,0 +1,159 @@
+// @mostajs/recette — schémas (EntitySchema @mostajs/orm). Author: Dr Hamid MADANI <drmdh@msn.com>
+//
+// L'agrégat racine est la CAMPAGNE — une recette portant sur UNE version candidate. Ce n'est ni le
+// projet (il vit chez @mostajs/qa-engine) ni la version (idem) : c'est l'ÉPREUVE qu'on leur fait
+// subir, avec ses convoqués, ses dates et son résultat.
+//
+// CE MODULE NE RE-MODÉLISE RIEN DE QA-ENGINE. `releaseRef` est une RÉFÉRENCE opaque vers la
+// `Release` de QaTrax, jamais une copie de ses champs : deux modèles de la même chose divergent,
+// et l'on découvre la divergence le jour d'un litige.
+
+/** La campagne : une version candidate, des convoqués, une issue. */
+export const CampagneSchema = { name: 'Campagne', collection: 'recette_campagnes', timestamps: true, fields: {
+  no: { type: 'string' },
+  releaseRef: { type: 'string', required: true },          // → Release de @mostajs/qa-engine, OPAQUE
+  projet: { type: 'string' },
+  tenantId: { type: 'string', default: null },             // le client — cloisonnement strict
+  perimetre: { type: 'string' },                           // ce que la recette couvre, en clair
+  instanceUrl: { type: 'string' },                         // l'instance éprouvée — jamais la production
+  // Les six étapes du parcours, dans l'ordre. `abandonnee` est la seule sortie latérale.
+  state: { type: 'string', required: true, default: 'candidate' },
+  stateHistory: { type: 'array', default: [] },            // [{from,to,at,by,reason}] IMMUABLE
+  ouverteLe: { type: 'date', default: null },
+  closeLe: { type: 'date', default: null },
+} };
+
+/** Le feuillet remis à UNE personne : son rôle, sa langue, son état de retour. */
+export const FeuilletSchema = { name: 'Feuillet', collection: 'recette_feuillets', timestamps: true, fields: {
+  campagneId: { type: 'string', required: true },
+  role: { type: 'string', required: true },                // 'A' | 'S' | 'client' | …
+  destinataireId: { type: 'string', default: null },
+  destinataire: { type: 'string' },                        // libellé lisible, si le compte n'existe pas encore
+  langue: { type: 'string', default: 'fr' },
+  planVersion: { type: 'string' },                         // empreinte du plan au TIRAGE — voir §manifeste
+  // `remis` → `rendu` → `depouille`. Savoir CE QUI MANQUE est plus utile que savoir ce qui est revenu.
+  state: { type: 'string', required: true, default: 'remis' },
+  remisLe: { type: 'date', default: null },
+  renduLe: { type: 'date', default: null },
+} };
+
+/**
+ * UN POINT DE RECETTE — ce que le client LIT, et sur quoi il coche.
+ *
+ * DEUX CÔTÉS, ET UNE FRONTIÈRE ENTRE EUX.
+ *
+ * Le côté TRAME vient de QaTrax (format `mostajs-devtest/1`) : `ref`, `specRef`, `titreTrame`,
+ * priorité. Il se réimporte à chaque version candidate, et l'import l'écrase — c'est son rôle.
+ *
+ * Le côté ENRICHISSEMENT appartient à ValiTrax : le libellé écrit POUR LE CLIENT, l'attendu tel
+ * qu'il le reconnaîtra, le rôle qui le joue, l'ordre, la langue. **L'import n'y touche JAMAIS.**
+ * Sans cette garde, chaque réimport effacerait le travail humain — et l'on ne s'en apercevrait
+ * qu'en distribuant les feuillets. C'est la règle de `seedRbac` dans LabTrax, pour la même raison.
+ *
+ * « Vérifier que POST /dossiers refuse un livrable non accepté » est un titre de trame.
+ * « Essayez de programmer une soutenance sur un dossier dont un livrable manque — le refus doit
+ * dire lequel » est un libellé de recette. Même exigence, deux lecteurs, deux textes.
+ */
+export const PointSchema = { name: 'Point', collection: 'recette_points', timestamps: true, fields: {
+  campagneId: { type: 'string', required: true },
+  ref: { type: 'string', required: true },                 // la clé d'idempotence : 'T-APP-9'
+  // ── côté TRAME — réécrit à chaque import ────────────────────────────────────────────────
+  specRef: { type: 'string', default: null },              // → l'exigence, ce qui rend la couverture vérifiable
+  titreTrame: { type: 'string' },
+  priorite: { type: 'string', default: 'medium' },
+  typeTrame: { type: 'string', default: null },            // 'manual' | 'automated'
+  etapesTrame: { type: 'array', default: [] },             // [{action, expected}] — la matière première
+  importeLe: { type: 'date', default: null },
+  // ── côté ENRICHISSEMENT — l'import ne le touche jamais ──────────────────────────────────
+  libelle: { type: 'string', default: null },              // « ce que vous faites »
+  attendu: { type: 'string', default: null },              // « ce que vous devez voir »
+  role: { type: 'string', default: null },                 // qui le joue
+  ordre: { type: 'number', default: 0 },
+  langue: { type: 'string', default: null },
+  // LA SÉLECTION SE FAIT ICI, pas chez QaTrax : c'est le responsable de recette qui sait ce que
+  // SON client doit éprouver. La trame arrive entière ; on en retient une partie.
+  retenu: { type: 'boolean', default: false },
+} };
+
+/** Un relevé : UNE observation sur UNE action, par UNE personne. L'unité de vérité. */
+export const ReleveSchema = { name: 'Releve', collection: 'recette_releves', timestamps: true, fields: {
+  feuilletId: { type: 'string', required: true },
+  campagneId: { type: 'string', required: true },
+  ref: { type: 'string', required: true },                 // l'action du plan : 'DH9', 'S12'…
+  // `ok` conforme · `ko` le logiciel marche mais AUTREMENT que le plan l'annonce (c'est le
+  // DOCUMENT qu'on corrige) · `er` panne (c'est le CODE). Absent = non joué : les trois valeurs
+  // plus l'absence en font quatre, sans quatrième colonne.
+  issue: { type: 'string', required: true, enum: ['ok', 'ko', 'er'] },
+  at: { type: 'date', default: null },                     // l'HEURE — c'est elle qui retrouve la trace serveur
+  texte: { type: 'string' },
+  source: { type: 'string', default: 'formulaire', enum: ['formulaire', 'pdf', 'image'] },
+  // Une observation lue par reconnaissance d'image ne vaut pas une case cochée à l'écran.
+  confiance: { type: 'number', default: 1 },
+} };
+
+/** Une anomalie : ce qu'un client DÉCLARE. Ce n'est pas encore un bug. */
+export const AnomalieSchema = { name: 'Anomalie', collection: 'recette_anomalies', timestamps: true, fields: {
+  campagneId: { type: 'string', required: true },
+  feuilletId: { type: 'string', default: null },
+  releveRef: { type: 'string', default: null },
+  declareePar: { type: 'string', required: true },
+  titre: { type: 'string', required: true },
+  description: { type: 'string' },
+  // DEUX gravités, et jamais une seule. Celle que le client PROPOSE n'est pas écrasée par celle
+  // que l'éditeur QUALIFIE : effacer la première, c'est effacer le désaccord, et le désaccord est
+  // précisément ce qu'un procès-verbal doit pouvoir montrer.
+  graviteProposee: { type: 'string', default: null, enum: ['bloquante', 'majeure', 'mineure', null] },
+  graviteQualifiee: { type: 'string', default: null, enum: ['bloquante', 'majeure', 'mineure', null] },
+  state: { type: 'string', required: true, default: 'declaree' },   // declaree|qualifiee|ecartee|corrigee|verifiee
+  motifEcart: { type: 'string', default: null },
+  bugRef: { type: 'string', default: null },               // → Bug de @mostajs/qa-engine, après promotion
+  qualifieePar: { type: 'string', default: null },
+  qualifieeLe: { type: 'date', default: null },
+} };
+
+/** Le DOSSIER DE RECETTE : le livrable figé, celui que QaTrax ingère. */
+export const DossierSchema = { name: 'Dossier', collection: 'recette_dossiers', timestamps: true, fields: {
+  campagneId: { type: 'string', required: true, unique: true },
+  no: { type: 'string' },
+  figeLe: { type: 'date', required: true },
+  figePar: { type: 'string' },
+  // L'EMPREINTE fait le lien avec le certificat. Un certificat porte sur CE dossier ; sans
+  // empreinte, il porterait sur « la recette », c'est-à-dire sur rien d'opposable.
+  empreinte: { type: 'string', required: true },
+  contenu: { type: 'object', default: () => ({}) },        // l'agrégat figé : compteurs, relevés, anomalies
+  // LE DOSSIER VOYAGE COMME UN FICHIER, pas par un appel réseau. ValiTrax n'appelle jamais
+  // QaTrax : le client — ou notre service — TRANSPORTE l'export et le dépose. La signature est
+  // ce qui rend ce transport sûr : elle dit d'où vient le document, quoi qu'il ait traversé.
+  signature: { type: 'object', default: null },            // { alg, valeur, cle } — clé PRIVÉE de l'émetteur
+  scelle: { type: 'boolean', default: false },             // chiffré pour le destinataire (sa clé PUBLIQUE)
+  exporteLe: { type: 'date', default: null },
+  exportePar: { type: 'string', default: null },
+  depotRef: { type: 'string', default: null },             // accusé rendu par QaTrax APRÈS dépôt manuel
+} };
+
+/** Le CERTIFICAT : ce que QaTrax RENVOIE. Ce module ne l'émet pas — il le reçoit et le garde. */
+export const CertificatSchema = { name: 'Certificat', collection: 'recette_certificats', timestamps: true, fields: {
+  campagneId: { type: 'string', required: true },
+  no: { type: 'string', required: true },
+  empreinteDossier: { type: 'string', required: true },    // doit correspondre au dossier déposé
+  verdict: { type: 'string', required: true, enum: ['accepte', 'accepte-avec-reserves', 'refuse'] },
+  reserves: { type: 'array', default: [] },
+  emisPar: { type: 'string' },
+  emisLe: { type: 'date', default: null },
+  // LE PV EST SIGNÉ PAR QATRAX, et ValiTrax le VÉRIFIE avant de l'accepter. Un certificat dont
+  // on ne contrôle pas la signature vaut ce que vaut le courriel qui l'apportait — c'est-à-dire
+  // rien, le jour où quelqu'un conteste. Même construction que la licence signée de LabTrax :
+  // clé publique du tiers, vérification HORS LIGNE.
+  signature: { type: 'object', required: true },           // { alg, valeur, cle }
+  verificationUrl: { type: 'string' },                     // la preuve que le client peut présenter seul
+  // LE DOCUMENT EST CONSERVÉ ICI, pas seulement pointé. QaTrax le FAIT, ValiTrax l'EXPOSE : le
+  // client ne va jamais sur QaTrax, qui est un outil de développement. Un lien vers une instance
+  // de dev se casse le jour où l'on renomme un vhost, et le client se retrouve sans preuve —
+  // alors que la preuve était l'objet de tout l'exercice. → @mostajs/ged
+  documentRef: { type: 'string', default: null },
+  // LE FEU. Il vient AVEC le certificat, il ne se coche pas ici.
+  goExploitation: { type: 'boolean', default: false },
+  goLe: { type: 'date', default: null },
+} };
+
+export const RECETTE_SCHEMAS = [CampagneSchema, PointSchema, FeuilletSchema, ReleveSchema, AnomalieSchema, DossierSchema, CertificatSchema];