@roomi-fields/grillhouse 0.23.1 → 0.24.0

package/scripts/resultats.mjs

@@ -5,49 +5,66 @@
 //
 //   npx grillhouse resultats --schema <rôle>      prints the JSON schema of a role's sheet
 //
-// - The sheet of the end of a session (« la fiche ») of the testwriter, the developpeur, the reviewer,
-//   the regulator, the questionneur and the technical referent: the schema of each role (FICHES), which the session receives
+// - The sheet of the end of a session (« la fiche ») of the explorateur, the questionneur, the
+//   testwriter, the developpeur and the reviewer: the schema of each role (FICHES), which the session receives
 //   (`claude -p --output-format json --json-schema <schéma>`) and fills as its last act; claude
 //   writes it in the field `structured_output` of its result (Claude Code, « headless »). A field
 //   exists only when a reader reads it:
-//   - `statut` (FAIT, BLOQUÉ, BESOIN), with `raison` for BLOQUÉ and `question` for BESOIN: the
-//     circuit goes on, or stops at « hors-portee » or « besoin » (testwriter, developpeur);
+//   - `statut` (FAIT, BLOQUÉ, BESOIN), with `raison` for BLOQUÉ and `question` for BESOIN, each
+//     with its `piece`: the circuit goes on, or stops at « hors-portee » or « besoin », the piece
+//     with the stop (testwriter, developpeur);
 //   - `verts_attendus` (`fichier` from the root, `test` its full name, or none for every green of a
 //     file HEAD holds, `raison`): the proof of the red (testwriter);
-//   - `renvoi` (`role` testwriter, `composant`): the circuit plays that component from its testwriter
-//     (developpeur);
+//   - `renvoi` (`role` testwriter): the circuit relaunches the testwriter, then the proof and the
+//     developpeur (developpeur);
 //   - `ecarts` (`sujet`, `texte`): the body of the commit message, written by the circuit, each
 //     subject once, its value from the last sheet that carries it (developpeur, reviewer);
 //   - `decouvertes` (`sujet`, `corps`): each one a ticket filed closed under the ticket, labelled
 //     `decouverte`, created by the circuit (every role);
-//   - `verdict` (ACCEPTÉ, RENDU), `constats` (`titre`, `corps`, `genre` bloquant or remarque; a
+//   - `verdict` (ACCEPTÉ, RENDU), `constats` (`titre`, `corps`, `piece`, `genre` bloquant or
+//     remarque; a
 //     blocking one with `regle`, the criterion of the plan or the rule of the frame it holds, and
-//     `role` and `composant` its recipient, or `critere_en_cause`): as Conventional Comments mark
-//     a comment blocking or not, the circuit plays the blocking findings alone and writes the
-//     verdict at the ticket for the human, the remarks with it; a RENDU carries a blocking finding,
-//     an ACCEPTÉ none (reviewer);
+//     `role` its recipient, or `critere_en_cause`): as Conventional Comments mark
+//     a comment blocking or not, the circuit plays the blocking findings alone, each open until a
+//     review marks it lifted, and writes the verdict at the ticket for the human, the remarks with
+//     it; a RENDU carries a blocking finding, an ACCEPTÉ none (reviewer);
+//   - `conformite` (`element`, `conforme` oui or non, `document` CADRE, INTERFACE or
+//     ARCHITECTURE, `reference`, `piece`; a « non » with `role` its recipient):
+//     one line per element of the lot (scripts/elements-du-lot.mjs), its rule cited from a
+//     document of its package, a new export's the entry of the INTERFACE that names it; a line
+//     without its reference is refused; a « non » is a blocking finding (`bloquantsDeLaFiche`),
+//     and the circuit refuses a sheet without a line for each element (`conformiteDuLot`)
+//     (reviewer);
 //   - `suivi` (`titre`, `etat` levé or non levé, `preuve`): after a review sent back, each finding
 //     before it judged on the difference of the lot, which the circuit writes at the ticket with
 //     the verdict, for the human (reviewer);
-//   - `question` (reviewer): what goes up to the owner, a real word of the language written in the
-//     code; the circuit stops at « besoin » before it commits or relaunches anyone;
-//   - `decision` (« RELANCE --reprendre » with its `contexte`, « RELANCE --depuis » with `depuis`,
-//     one or more components of the title, each with its `role` and its `contexte`, « MONTE »
-//     with `question`): what the circuit applies (regulator);
-//   - `faits` (`sujet` of SUJETS_DES_FAITS, `composant`): the facts of the state the decision
-//     rests on, which the circuit checks before it applies the decision, and compares with the
-//     facts of the RELANCE before on the same stop (regulator);
-//   - `issue` (QUESTIONS with its `questions`, each with what it aims at, `vise`; AUCUNE; DÉSACCORD
-//     with its `desaccord`): the circuit hands the questions to the author, ends the questioning,
-//     or sends it up to the supervisor, and writes the exchange at the ticket (questionneur);
-//   - `reponses` (`question`, `choix` CHANGE or GARDE, `texte`: what the proposal becomes, or why
-//     it stays): the circuit hands them to the questionneur and writes them at the ticket (the
-//     regulator, the technical referent);
-//   - `titre`, `description`: the plan as an answer changes it, which the circuit writes to the
-//     ticket (`bd update`) (technical referent).
+//   - `question`, with its `piece` (reviewer): what goes up to the owner, a real word of the
+//     language written in the code; the circuit stops at « besoin » before it commits or
+//     relaunches anyone;
+//   - `criteres`, `paquets`, `questions` (each with its `piece`): the plan, which the circuit
+//     writes at the ticket: the criteria it adds after those the ticket holds, which the circuit
+//     keeps as they are; the packages in the title as it names its components (a package name or a
+//     path), the list the envelope of every later session writes; the open questions, a change or
+//     a removal of a criterion written among them, go up to the supervisor (explorateur);
+//   - `reponses` (`numero` of the question, `reponse` CHANGE or GARDE, `texte`): the explorateur's
+//     one answer to the questionneur, which the circuit writes at the ticket; a question without
+//     an answer stays open (explorateur);
+//   - `issue` (QUESTIONS with its `questions`, each with what it aims at, `vise`, and its
+//     `piece`; AUCUNE; DÉSACCORD
+//     with its `desaccord`): the explorateur answers the questions, the disagreement as one, and
+//     the circuit writes them at the ticket (questionneur).
 //   `lireFiche` reads a session's output: the sheet and the session's id, or the error that
 //   names what lacks or does not conform (no `structured_output`, a field out of the schema, a
-//   status without its reason, a blocking finding without its criterion or rule).
+//   status without its reason, a blocking finding without its criterion or rule, a line of
+//   conformity without its rule or a « non » without its recipient, a plan without packages, a
+//   fact without its piece, a piece in neither form, and, given the copy, a file piece not in it).
+// - The piece of a fact (« la pièce »), one format, as a code review cites the line it judges: a
+//   finding, a question or a stop carries it, so the agent who takes the fact up re-reads it
+//   before he builds on it (BP 320.9: a line read wrong, copied by five agents up to the owner).
+//   Either `<fichier>:<ligne>` or `<fichier>:<ligne>-<fin>`, the file from the root of the copy,
+//   the line from 1, then, after a space, what it shows (« packages/a/src/x.ts:3 divise par sa valeur. »); or `$ <commande>` on
+//   its first line and its output on the lines after. `lirePiece` reads it; the circuit gives
+//   `lireFiche` the copy, where each file piece's file stands and holds its line.
 // - The findings of a guard, in SARIF 2.1.0 (OASIS), beside its output for the human: one run per
 //   guard, `tool.driver.name` the guard; each finding a result, `ruleId` the guard, `level`
 //   (error by default), `message.text`, its file and line as its location when it has them, and its
@@ -75,6 +92,7 @@ import {
   readFileSync,
   rmdirSync,
   rmSync,
+  statSync,
   writeFileSync,
 } from 'node:fs';
 import path from 'node:path';
@@ -85,18 +103,12 @@ import { RESULTATS, VITEST } from './vitest-config/resultats.mjs';
 export { RESULTATS };
 const SARIF = 'sarif';
 const TURBO = 'turbo';
-// The kinds of a guard's finding: to fix (a developpeur's work), to settle (a person's decision).
-const GENRES = ['a-corriger', 'a-arbitrer'];
-// The subjects of the facts a regulator's decision rests on, which the circuit checks on its
-// state (scripts/circuit.mjs, `faitFaux`): all but sous-charge name their component.
-export const SUJETS_DES_FAITS = [
-  'au-titre',
-  'hors-titre',
-  'rouge-de',
-  'sans-changement',
-  'sous-charge',
-];
-
+// The kind of a note of a guard, no red: a key of the known debt inscribed above what the guard
+// finds, which the circuit lowers (scripts/dette.mjs, scripts/circuit.mjs).
+export const A_ELAGUER = 'a-elaguer';
+// The kinds of a guard's finding: to fix (a developpeur's work), to settle (a person's decision),
+// to lower (a note).
+const GENRES = ['a-corriger', 'a-arbitrer', A_ELAGUER];
 const texte = description => ({ type: 'string', description });
 const liste = (items, description) => ({ type: 'array', description, items });
 const objet = (properties, required = [], description) => ({
@@ -106,10 +118,15 @@ const objet = (properties, required = [], description) => ({
   required,
   properties,
 });
+// The description of a piece in a sheet's schema, the format `lirePiece` reads.
+const PIECE =
+  'fichier:ligne depuis la racine de la copie, puis ce qu’elle montre ; ou « $ <commande> » et sa sortie aux lignes suivantes';
+const piece = quoi => texte(`${quoi} : ${PIECE}.`);
 const STATUT = {
   statut: { type: 'string', enum: ['FAIT', 'BLOQUÉ', 'BESOIN'] },
   raison: texte('BLOQUÉ : ce qui reste hors de ta portée, et où.'),
   question: texte('BESOIN : la question qui t’arrête, ses options et ta recommandation.'),
+  piece: piece('BLOQUÉ ou BESOIN : la pièce de ta raison ou de ta question'),
 };
 const DECOUVERTES = {
   decouvertes: liste(
@@ -135,23 +152,46 @@ const ECARTS = {
   ),
 };
 
-// The answers of an author to the questions of the questionneur.
-const REPONSES = {
-  reponses: liste(
-    objet(
-      {
-        question: texte('La question, telle que le questionneur l’a posée.'),
-        choix: { type: 'string', enum: ['CHANGE', 'GARDE'] },
-        texte: texte('CHANGE : ce que ta proposition devient ; GARDE : pourquoi elle reste.'),
-      },
-      ['question', 'choix', 'texte']
-    ),
-    'Ta réponse à chaque question du questionneur.'
-  ),
-};
+// The documents a line of a reviewer's conformity cites its rule from.
+const DOCUMENTS = ['CADRE', 'INTERFACE', 'ARCHITECTURE'];
 
 // The schema of the sheet of each role the circuit leads.
 const FICHES = {
+  explorateur: objet(
+    {
+      criteres: liste(
+        texte('Un critère, sans son numéro : un comportement que ses tests mesurent.'),
+        'Les critères que le plan ajoute, dans leur ordre ; le circuit garde tels quels ceux que le ticket porte et écrit les tiens après eux. Changer ou retirer un critère écrit est une question ouverte.'
+      ),
+      paquets: liste(
+        texte('Un paquet, comme le titre le nomme : le nom de son paquet, ou son chemin.'),
+        'Les paquets à toucher, le fournisseur d’abord ; le circuit les écrit au titre, et chaque séance n’écrit qu’eux.'
+      ),
+      questions: liste(
+        objet(
+          {
+            question: texte('La question qui reste ouverte, ses options et ta recommandation.'),
+            piece: piece('Sa pièce'),
+          },
+          ['question', 'piece']
+        ),
+        'Les questions ouvertes du plan, que tu ne tranches pas ; elles montent au superviseur.'
+      ),
+      reponses: liste(
+        objet(
+          {
+            numero: texte('Le numéro de la question, « 1 ».'),
+            reponse: { type: 'string', enum: ['CHANGE', 'GARDE'] },
+            texte: texte('CHANGE : ce que le plan devient ; GARDE : pourquoi il reste tel quel.'),
+          },
+          ['numero', 'reponse', 'texte']
+        ),
+        'Ta réponse, une fois, à chaque question du questionneur.'
+      ),
+      ...DECOUVERTES,
+    },
+    ['criteres', 'paquets', 'questions']
+  ),
   testwriter: objet(
     {
       ...STATUT,
@@ -176,12 +216,9 @@ const FICHES = {
     {
       ...STATUT,
       renvoi: objet(
-        {
-          role: { type: 'string', enum: ['testwriter'] },
-          composant: texte('Un composant du titre.'),
-        },
-        ['role', 'composant'],
-        'Le rouge qui reste est dans les tests de ce composant, le tien ou un d’avant.'
+        { role: { type: 'string', enum: ['testwriter'] } },
+        ['role'],
+        'Le rouge qui reste est dans les tests du lot : le circuit relance le testwriter.'
       ),
       ...ECARTS,
       ...DECOUVERTES,
@@ -191,10 +228,35 @@ const FICHES = {
   relecteur: objet(
     {
       verdict: { type: 'string', enum: ['ACCEPTÉ', 'RENDU'] },
+      conformite: liste(
+        objet(
+          {
+            element: texte('L’élément, tel que la liste des éléments du lot l’écrit.'),
+            conforme: {
+              type: 'string',
+              enum: ['oui', 'non'],
+              description: 'non : il rend le lot, à son destinataire.',
+            },
+            document: {
+              type: 'string',
+              enum: DOCUMENTS,
+              description:
+                'Le document de son paquet dont la règle est citée ; un export neuf, l’INTERFACE.',
+            },
+            reference: texte(
+              'La règle dans ce document (« 000-forms, R2 », « § Les frontières ») ; un export neuf, le nom de son entrée.'
+            ),
+            piece: piece('Sa pièce'),
+            role: { type: 'string', enum: ['testwriter', 'developpeur'] },
+          },
+          ['element', 'conforme', 'document', 'reference', 'piece']
+        ),
+        'Une ligne par élément du lot, chacun une fois : sa conformité à l’architecture.'
+      ),
       constats: liste(
         objet(
           {
-            titre: texte('Son adresse : fichier et ligne.'),
+            titre: texte('Son sujet, une ligne.'),
             genre: {
               type: 'string',
               enum: ['bloquant', 'remarque'],
@@ -204,12 +266,16 @@ const FICHES = {
             regle: texte(
               'Bloquant : le critère du plan (« critère 2 ») ou la règle du cadre (son document et sa règle) qu’il tient.'
             ),
-            role: { type: 'string', enum: ['testwriter', 'developpeur'] },
-            composant: texte('Le composant du titre où la correction s’écrit.'),
+            role: {
+              type: 'string',
+              enum: ['testwriter', 'developpeur'],
+              description: 'Bloquant : l’agent qui écrit la correction, à qui le circuit le rend.',
+            },
             corps: texte('Sa preuve : son exemple et ce qu’il montre.'),
+            piece: piece('Sa pièce'),
             critere_en_cause: texte('Le critère lui-même en cause, au lieu d’un destinataire.'),
           },
-          ['titre', 'corps', 'genre']
+          ['titre', 'corps', 'genre', 'piece']
         ),
         'Chaque constat, bloquant ou remarque ; un verdict RENDU en porte au moins un bloquant, un verdict ACCEPTÉ aucun.'
       ),
@@ -225,50 +291,14 @@ const FICHES = {
         'Relecture bornée : chaque constat de la relecture d’avant, levé ou non.'
       ),
       question: texte(
-        'Ce qui revient au responsable (par exemple un vrai mot du langage écrit en dur) : la question, ses pièces et ta recommandation ; le circuit s’arrête avant de commiter ou de relancer.'
+        'Ce qui revient au responsable (par exemple un vrai mot du langage écrit en dur) : la question et ta recommandation ; le circuit s’arrête avant de commiter ou de relancer.'
       ),
+      piece: piece('question : sa pièce'),
       ...ECARTS,
       ...DECOUVERTES,
     },
     ['verdict']
   ),
-  regulateur: objet(
-    {
-      decision: { type: 'string', enum: ['RELANCE --reprendre', 'RELANCE --depuis', 'MONTE'] },
-      depuis: liste(
-        objet(
-          {
-            role: { type: 'string', enum: ['testwriter', 'developpeur'] },
-            composant: texte('Un composant du titre.'),
-            contexte: texte('Ce que l’agent relancé fait dans ce composant.'),
-          },
-          ['role', 'composant', 'contexte']
-        ),
-        'RELANCE --depuis : chaque composant que le lot reprend, avec l’agent qui le reprend et son contexte ; le circuit les rejoue dans l’ordre du titre, puis une seule passe finale.'
-      ),
-      contexte: texte('RELANCE --reprendre : ce que l’agent repris fait dans son composant.'),
-      question: texte('MONTE : la question, ses pièces et ta recommandation.'),
-      arbitrage: texte(
-        'RELANCE : ce que tu tranches seul et sa source (la lettre d’un critère, un précédent écrit, une règle du cadre), en nommant chaque consommateur qu’il fixe ; le circuit l’écrit au ticket, tranché.'
-      ),
-      critere: texte(
-        'RELANCE --depuis, son premier composant repris par son testwriter : le critère que tu ajoutes, sans son numéro ; le circuit l’écrit, numéroté, à la fin de la description.'
-      ),
-      faits: liste(
-        objet(
-          {
-            sujet: { type: 'string', enum: SUJETS_DES_FAITS },
-            composant: texte('Le composant ou le paquet du fait ; sans objet pour sous-charge.'),
-          },
-          ['sujet']
-        ),
-        'Chaque fait de l’état sur lequel ta décision s’appuie : au-titre et hors-titre (un composant au titre ou non), rouge-de (un rouge de l’arrêt dans ce composant ou ce paquet), sans-changement (la copie ne change rien de ce composant), sous-charge (une commande de l’arrêt à repasser, sous charge). Le circuit vérifie chacun sur l’état avant d’appliquer ta décision, et refuse une décision qui s’appuie sur un fait faux.'
-      ),
-      ...REPONSES,
-      ...DECOUVERTES,
-    },
-    ['decision']
-  ),
   questionneur: objet(
     {
       issue: { type: 'string', enum: ['QUESTIONS', 'AUCUNE', 'DÉSACCORD'] },
@@ -277,26 +307,16 @@ const FICHES = {
           {
             question: texte('Ta question, dans les mots de la proposition.'),
             vise: { type: 'string', enum: ['flou', 'intention', 'référence', 'règle', 'critère'] },
+            piece: piece('Sa pièce, ce qui dans la proposition ou le dépôt la fait naître'),
           },
-          ['question', 'vise']
+          ['question', 'vise', 'piece']
         ),
-        'QUESTIONS : tes questions de ce tour.'
-      ),
-      desaccord: texte(
-        'DÉSACCORD : ce qui reste, que la réponse de l’auteur ne lève pas, et pourquoi.'
+        'QUESTIONS : tes questions.'
       ),
+      desaccord: texte('DÉSACCORD : l’écart que la proposition laisse, et pourquoi.'),
     },
     ['issue']
   ),
-  'referent-technique': objet(
-    {
-      ...REPONSES,
-      titre: texte('Le titre du ticket que ta réponse change, entier.'),
-      description: texte('La description du ticket que ta réponse change, entière.'),
-      ...DECOUVERTES,
-    },
-    ['reponses']
-  ),
 };
 
 // The schema of the sheet of <role>, or null for a role the circuit does not lead.
@@ -331,24 +351,134 @@ function erreurs(schema, valeur, ou) {
   return [];
 }
 
+// The rule a line of conformity <l> cites: its document and its reference.
+export const regleDeLaLigne = l => `${l.document} ${l.reference}`;
+
+// The blocking findings of a reviewer's sheet <fiche>, the ones that send the lot back: its
+// findings of `genre` bloquant, then each line of its conformity that says « non », as a finding
+// on its element, its rule, its recipient and its piece.
+export const bloquantsDeLaFiche = fiche => [
+  ...(fiche.constats ?? []).filter(c => c.genre === 'bloquant'),
+  ...(fiche.conformite ?? [])
+    .filter(l => l.conforme === 'non')
+    .map(l => ({
+      titre: l.element,
+      genre: 'bloquant',
+      regle: regleDeLaLigne(l),
+      role: l.role,
+      corps: `Non conforme : ${l.piece}`,
+    })),
+];
+
+// What makes the reviewer's sheet <fiche> out of conformity with the elements of its lot
+// <elements> (scripts/elements-du-lot.mjs: `{ id, nom, statut, exporte }`), as a review asks a
+// word on every changed file: an element without its line, a line on an element out of the list,
+// a new export whose rule does not name its entry in the INTERFACE of its package. The fault, or
+// null.
+export function conformiteDuLot(fiche, elements) {
+  const lignes = fiche.conformite ?? [];
+  const ids = new Set(elements.map(e => e.id));
+  const fautes = [];
+  const sans = elements.filter(e => !lignes.some(l => l.element === e.id)).map(e => e.id);
+  if (sans.length) fautes.push(`conformite : sans ligne pour ${sans.join(', ')}`);
+  for (const [i, l] of lignes.entries()) {
+    if (!ids.has(l.element)) {
+      fautes.push(`conformite[${i}].element : ${l.element} n'est pas un élément du lot`);
+    }
+  }
+  for (const e of elements.filter(x => x.statut === 'neuf' && x.exporte)) {
+    for (const l of lignes.filter(x => x.element === e.id)) {
+      if (!(l.document === 'INTERFACE' && l.reference.includes(e.nom))) {
+        fautes.push(
+          `conformite : ${e.id} est un export neuf ; sa règle nomme son entrée « ${e.nom} » dans l'INTERFACE de son paquet`
+        );
+      }
+    }
+  }
+  return fautes.length ? fautes.join(' ; ') : null;
+}
+
+// The piece of a fact <texte>: `{ fichier, ligne }` for « <fichier>:<ligne> », `{ fichier, ligne,
+// fin }` for « <fichier>:<ligne>-<fin> » (as SARIF's region has a start line and an optional end
+// line), then what it shows after a space, the place in backquotes or followed by punctuation
+// read the same; `{ commande, sortie }` for « $ <commande> » and its output on the lines after;
+// null for a text in neither form.
+export function lirePiece(texte) {
+  const t = String(texte ?? '').trim();
+  if (t.startsWith('$ ')) {
+    const saut = t.indexOf('\n');
+    const commande = saut < 0 ? '' : t.slice(2, saut).trim();
+    const sortie = saut < 0 ? '' : t.slice(saut + 1).trim();
+    return commande && sortie ? { commande, sortie } : null;
+  }
+  let lieu = t.split(/\s/)[0];
+  while (lieu && '`.,;:)'.includes(lieu.at(-1))) lieu = lieu.slice(0, -1);
+  while (lieu.startsWith('`')) lieu = lieu.slice(1);
+  const deux = lieu.lastIndexOf(':');
+  const [debut, fin, ...reste] = lieu.slice(deux + 1).split('-');
+  const nombre = n => (/^\d+$/.test(n ?? '') && Number(n) >= 1 ? Number(n) : null);
+  const ligne = nombre(debut);
+  if (deux < 1 || !ligne || reste.length) return null;
+  if (fin === undefined) return { fichier: lieu.slice(0, deux), ligne };
+  if (!nombre(fin) || nombre(fin) < ligne) return null;
+  return { fichier: lieu.slice(0, deux), ligne, fin: nombre(fin) };
+}
+
+// The pieces of the sheet <f>, each `[son chemin, son texte]`: of the stop it carries (a status,
+// a reviewer's question), of its findings, of its lines of conformity, of its questions.
+const piecesDe = f => [
+  ...('piece' in f ? [['piece', f.piece]] : []),
+  ...['constats', 'conformite', 'questions'].flatMap(k =>
+    (f[k] ?? []).map((x, i) => [`${k}[${i}].piece`, x.piece]).filter(([, p]) => p !== undefined)
+  ),
+];
+
+// What makes a file piece of the sheet <f> not found in the copy <copie>: a file absent from it,
+// or out of it, or a line (the end of a range) past its end; each fault, naming its piece.
+function introuvables(f, copie) {
+  const out = [];
+  const racine = path.resolve(copie);
+  for (const [ou, p] of piecesDe(f)) {
+    const lu = lirePiece(p);
+    if (!lu?.fichier) continue;
+    const abs = path.resolve(racine, lu.fichier);
+    const lieu = `${lu.fichier}:${lu.ligne}${lu.fin ? `-${lu.fin}` : ''}`;
+    if (!abs.startsWith(`${racine}${path.sep}`) || !existsSync(abs) || !statSync(abs).isFile()) {
+      out.push(`${ou} : ${lieu} introuvable dans la copie : pas de tel fichier`);
+      continue;
+    }
+    const contenu = readFileSync(abs, 'utf8');
+    const lignes = contenu.split('\n').length - (contenu.endsWith('\n') ? 1 : 0);
+    if ((lu.fin ?? lu.ligne) > lignes) {
+      out.push(`${ou} : ${lieu} introuvable dans la copie : le fichier a ${lignes} lignes`);
+    }
+  }
+  return out;
+}
+
 // What a sheet of <role> needs beyond its schema: the reason of a BLOQUÉ, the question of a
-// BESOIN or a MONTE, the agents of a RELANCE --depuis, each with its own context and none beside
-// them, the component of a fact, the questions of a QUESTIONS, the text of a DÉSACCORD, the plan
-// an answer CHANGE gives, the criterion or rule of a blocking finding, and a reviewer's verdict
-// that follows its findings (RENDU with a blocking one, ACCEPTÉ without).
+// BESOIN, the packages of a plan and the number of each answer, the questions of a QUESTIONS, the text of a
+// DÉSACCORD, the criterion or rule of a blocking finding, the reference of the rule each line of
+// a reviewer's conformity cites in its document and the recipient of a « non », and a reviewer's verdict that follows its blocking findings, its « non » among them
+// (RENDU with one, ACCEPTÉ without), the piece of a BLOQUÉ, a BESOIN and a reviewer's question,
+// and each piece in one of its two forms (`lirePiece`).
 function manques(role, f) {
   const out = [];
   const plein = k => typeof f[k] === 'string' && f[k].trim() !== '';
   if (f.statut === 'BLOQUÉ' && !plein('raison')) out.push('raison : manque, pour BLOQUÉ');
   if (f.statut === 'BESOIN' && !plein('question')) out.push('question : manque, pour BESOIN');
-  if (role === 'regulateur' && f.decision === 'MONTE' && !plein('question')) {
-    out.push('question : manque, pour MONTE');
+  if (['BLOQUÉ', 'BESOIN'].includes(f.statut) && !('piece' in f)) {
+    out.push(`piece : manque, pour ${f.statut}`);
   }
-  if (role === 'regulateur' && f.decision === 'RELANCE --depuis' && !f.depuis?.length) {
-    out.push('depuis : manque, pour RELANCE --depuis');
+  if (role === 'relecteur' && 'question' in f && !('piece' in f)) {
+    out.push('piece : manque, pour la question');
   }
-  if (role === 'regulateur' && f.decision === 'RELANCE --depuis' && 'contexte' in f) {
-    out.push('contexte : sous RELANCE --depuis, chaque composant de depuis porte le sien');
+  for (const [ou, p] of piecesDe(f)) {
+    if (!lirePiece(p)) {
+      out.push(
+        `${ou} : « ${p} » n'est pas une pièce (fichier:ligne, ou « $ <commande> » et sa sortie)`
+      );
+    }
   }
   if (role === 'relecteur') {
     const constats = f.constats ?? [];
@@ -357,7 +487,17 @@ function manques(role, f) {
         out.push(`constats[${i}].regle : manque, pour un constat bloquant`);
       }
     }
-    const bloque = constats.some(c => c.genre === 'bloquant');
+    for (const [i, l] of (f.conformite ?? []).entries()) {
+      if (!l.reference.trim()) {
+        out.push(`conformite[${i}].reference : manque, la règle citée dans le ${l.document}`);
+      }
+      if (l.conforme === 'non') {
+        if (!(typeof l.role === 'string' && l.role.trim())) {
+          out.push(`conformite[${i}].role : manque, pour un élément non conforme`);
+        }
+      }
+    }
+    const bloque = bloquantsDeLaFiche(f).length > 0;
     if (f.verdict === 'RENDU' && !bloque) {
       out.push('verdict : RENDU sans constat bloquant ; un lot sans constat bloquant est ACCEPTÉ');
     }
@@ -365,9 +505,12 @@ function manques(role, f) {
       out.push('verdict : ACCEPTÉ avec un constat bloquant, qui rend le lot');
     }
   }
-  for (const [i, x] of (role === 'regulateur' ? (f.faits ?? []) : []).entries()) {
-    if (x.sujet !== 'sous-charge' && !(typeof x.composant === 'string' && x.composant.trim())) {
-      out.push(`faits[${i}].composant : manque, pour ${x.sujet}`);
+  if (role === 'explorateur') {
+    if (!(f.paquets ?? []).length) out.push('paquets : manque, pour un plan');
+    for (const [i, r] of (f.reponses ?? []).entries()) {
+      if (!/^[1-9]\d*$/.test(r.numero)) {
+        out.push(`reponses[${i}].numero : « ${r.numero} » n'est pas le numéro d'une question`);
+      }
     }
   }
   if (role === 'questionneur' && f.issue === 'QUESTIONS' && !(f.questions ?? []).length) {
@@ -376,20 +519,13 @@ function manques(role, f) {
   if (role === 'questionneur' && f.issue === 'DÉSACCORD' && !plein('desaccord')) {
     out.push('desaccord : manque, pour DÉSACCORD');
   }
-  if (
-    role === 'referent-technique' &&
-    (f.reponses ?? []).some(r => r.choix === 'CHANGE') &&
-    !plein('titre') &&
-    !plein('description')
-  ) {
-    out.push('titre ou description : manque, pour une réponse CHANGE');
-  }
   return out;
 }
 
 // The sheet of <role> in <sortie>, what claude prints with `--output-format json`: `{ fiche,
-// seance }`, or `{ erreur }` naming what lacks or does not conform.
-export function lireFiche(role, sortie) {
+// seance }`, or `{ erreur }` naming what lacks or does not conform; with <copie>, the directory
+// of the copy, each file piece of the sheet stands in it, its file and its line.
+export function lireFiche(role, sortie, { copie } = {}) {
   const schema = schemaDeFiche(role);
   if (!schema) return { erreur: `le rôle ${role} n'a pas de fiche` };
   let resultat;
@@ -404,6 +540,7 @@ export function lireFiche(role, sortie) {
   const fiche = resultat.structured_output;
   const fautes = erreurs(schema, fiche, '');
   if (!fautes.length) fautes.push(...manques(role, fiche));
+  if (!fautes.length && copie) fautes.push(...introuvables(fiche, copie));
   if (fautes.length) return { erreur: `fiche non conforme : ${fautes.join(' ; ')}` };
   return { fiche, seance: resultat.session_id ?? null };
 }
@@ -418,7 +555,8 @@ function paquetDe(racine, fichier) {
 }
 
 // The SARIF 2.1.0 of the findings <constats> of <garde> in <racine>: each `{ fichier, ligne,
-// message, regle, niveau, genre }`, all but the message optional.
+// message, regle, niveau, genre, trouve }`, all but the message optional (`trouve`, the count a
+// note of the debt finds).
 export function sarif({ garde, constats, racine = process.cwd() }) {
   return {
     $schema: 'https://json.schemastore.org/sarif-2.1.0.json',
@@ -446,6 +584,7 @@ export function sarif({ garde, constats, racine = process.cwd() }) {
             ...(c.regle ? { regle: c.regle } : {}),
             paquet: paquetDe(racine, c.fichier),
             genre: c.genre ?? GENRES[0],
+            ...(c.trouve !== undefined ? { trouve: c.trouve } : {}),
           },
         })),
       },
@@ -482,7 +621,8 @@ const lireJson = f => {
 
 // The guards that wrote their SARIF under the results directory <dossier>, and their findings:
 // `{ gardes, constats }`, each finding `{ garde, regle, fichier, ligne, niveau, message, paquet,
-// genre }`, `fichier`, `ligne`, `regle` and `paquet` null when the guard gave none.
+// genre }`, `fichier`, `ligne`, `regle` and `paquet` null when the guard gave none, and `trouve`,
+// the count a note of the debt finds, when it carries one.
 export function lireSarif(dossier) {
   const gardes = new Set();
   const constats = [];
@@ -501,6 +641,7 @@ export function lireSarif(dossier) {
           message: String(r.message?.text ?? ''),
           paquet: r.properties?.paquet ?? null,
           genre: r.properties?.genre ?? GENRES[0],
+          ...(r.properties?.trouve !== undefined ? { trouve: r.properties.trouve } : {}),
         });
       }
     }

package/scripts/resumes.mjs

@@ -15,7 +15,7 @@
 //   written in the documentation comment of the export, and `npm run api` carries it over.
 // - A refusal inscribed in the project's debt (`grillhouse-dette.json`, see `dette.mjs`) passes,
 //   keyed by the interface and `resume-trop-long`.
-// - In the envelope of a component (`GRILLHOUSE_ENVELOPPE`), that component alone is judged.
+// - In an envelope (`GRILLHOUSE_ENVELOPPE`), the components of its plan alone are judged.
 import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';

package/scripts/session-start.sh

@@ -27,8 +27,7 @@
 # A session of a role agent of the frame (`claude --agent <rôle>`, the circuit's sessions: the
 # hook's input names it, `agent_type`, bare or as `grillhouse:<rôle>`, and the frame's plugin
 # defines it, `$CLAUDE_PLUGIN_ROOT/agents/<rôle>.md`, the plugin whose hook runs this script) receives nothing:
-# what the project lacks is the supervisor's to deal with, and in an envelope the documents of the
-# hidden packages read as absent.
+# what the project lacks is the supervisor's to deal with.
 set -uo pipefail
 
 # The project is Claude Code's, else the working directory; the frame's scripts are this one's