@roomi-fields/grillhouse 0.23.0 → 0.24.0

package/scripts/etapes.mjs

@@ -3,121 +3,81 @@
 // list, which the circuit (scripts/circuit.mjs), the board (scripts/tableau.mjs), the bilan
 // (scripts/bilan.mjs) and the texts read.
 //
-// - A step (ETAPES): its number (« 2 », « 2.3 »), its title, who works there (`qui`: the role
+// - A step (ETAPES): its number (« 2 », « 4.1 »), its title, who works there (`qui`: the role
 //   agents, or AUTO for a step the circuit leads itself; none for a step that only holds its
-//   sub-steps), its short form on the board's line where the roles' names do not hold in its
-//   width (`quiCourt`, the roles keeping their whole name everywhere else), whether it runs for each component of the ticket's title (`parComposant`), its
-//   sub-steps (`sous`), and the step of the circuit's state it is (`etat`: the `etape` of
-//   `.claude/worktrees/<ticket>.circuit.json`, the final pass being the checks once `finale`).
-//   A step that runs only for a project that declares it names the key of that declaration under
-//   `grillhouse` of the project's package.json (`declaration`): the board shows it only there.
-//   The opening reads its sub-steps elsewhere in the state: the survey of the components by its
-//   start while it runs (`releve`) and by its stop (`arrets`), the questioning of the plan by the questioning under way (`questionnement`)
-//   and by its stop. SUITE is the tree in its order, each step before its sub-steps.
-// - A step carries as many bounded loops as it needs (`boucles`): each its key (`cle`, which
-//   keys its count in the state's `boucles`), its label, its maximum (`max`, the pass that stops
-//   it; null for the components, whose number is the title's) and the sub-steps it spans (`sur`;
-//   the step and all its sub-steps without it): the components of the title, the testwriter's
-//   sessions after a refused proof, the developpeur's sessions with their checks, the rounds of
-//   a questioning, the reviews, the same stop come back after a RELANCE of the regulator. The
-//   circuit stops each loop at its maximum and writes its count in its state; the board shows
-//   « <label> <n>/<max> » on the ticket's line from the second pass.
-// - The arbitrage of a stop (ARBITRAGE) stands out of the sequence, under the stopped step: the
-//   regulator settles the stop, and the questionneur asks its questions of his decision before it
-//   is applied, as Amazon's bar raiser and a cockpit's challenge and response; it has no number.
+//   sub-steps), its sub-steps (`sous`), and the step of the circuit's state it is (`etat`: the
+//   `etape` of `.claude/worktrees/<ticket>.circuit.json`, the final pass being the checks once
+//   `finale`). Every step runs once for the whole ticket, as a merge request has one author of
+//   its tests and one of its code, one CI on the whole and one review: one session of the
+//   testwriter (2) and one of the developpeur (3) carry the whole plan.
+//   The plan (1) is read elsewhere in the state: by the work on the plan under way
+//   (`questionnement`, the explorateur's or the questionneur's session) and by its stop (`arrets`).
+//   SUITE is the tree in its order, each step before its sub-steps.
+// - A step carries as many bounded loops as it needs (`boucles`), each spanning the step and its
+//   sub-steps: each its key (`cle`, which keys its count in the state's `boucles`), its label and
+//   its maximum (`max`, the pass that stops it): the testwriter's sessions after a refused proof,
+//   the developpeur's sessions with their checks, the reviews. The circuit stops each loop at its
+//   maximum and writes its count in its state; the board shows « <label> <n>/<max> » on the
+//   ticket's line from the second pass.
 // - The stops of the circuit, each by its name and its exit code (ARRETS): the circuit ends on one
 //   with its code, and its header says when.
-// - The table of the stops (TABLE_DES_ARRETS, below): each kind of stop and its gesture.
+// - The gestures of the circuit (GESTES, below): what it does itself on a stop a rule settles,
+//   with no session.
+// - The question of each other stop (MONTEES, below): what goes up to the supervisor, and who
+//   must answer it.
 import { A_REPASSER } from './vitest-config/pression.mjs';
 
 // Who works at a step the circuit leads itself, with no agent.
 export const AUTO = 'auto';
 
-// The rounds of a questioning, of the plan at 1.2 and of a decision at the arbitrage.
-const TOURS = { cle: 'questionnement', libelle: 'tour', max: 4 };
-
 export const ETAPES = [
-  { numero: '0', titre: 'Exploration', qui: ['explorateur'], etat: null },
   {
     numero: '1',
-    titre: 'Ouverture',
-    qui: [],
+    titre: 'Plan',
+    qui: ['explorateur', 'questionneur'],
     etat: null,
-    sous: [
-      {
-        numero: '1.1',
-        titre: 'Relevé des composants',
-        qui: [AUTO],
-        etat: null,
-        releve: true,
-        arrets: ['composants-manquants'],
-      },
-      {
-        numero: '1.2',
-        titre: 'Questionnement',
-        qui: ['questionneur', 'referent-technique'],
-        quiCourt: 'questionneur ⇄ référent',
-        etat: null,
-        questionnement: 'plan',
-        arrets: ['questionnement'],
-        boucles: [TOURS],
-      },
-    ],
+    questionnement: 'plan',
+    arrets: ['questionnement'],
   },
   {
     numero: '2',
-    titre: 'Composants',
-    qui: [],
-    parComposant: true,
-    etat: null,
-    boucles: [
-      { cle: 'composant', libelle: 'composant', max: null },
-      { cle: 'tests', libelle: 'essai', max: 3, sur: ['2.1', '2.2'] },
-      { cle: 'code', libelle: 'essai', max: 3, sur: ['2.3', '2.4'] },
-    ],
-    sous: [
-      {
-        numero: '2.1',
-        titre: 'Tests',
-        qui: ['testwriter'],
-        parComposant: true,
-        etat: 'testwriter',
-      },
-      { numero: '2.2', titre: 'Preuve du rouge', qui: [AUTO], parComposant: true, etat: 'preuve' },
-      {
-        numero: '2.3',
-        titre: 'Code',
-        qui: ['developpeur'],
-        parComposant: true,
-        etat: 'developpeur',
-      },
-      { numero: '2.4', titre: 'Contrôles', qui: [AUTO], parComposant: true, etat: 'controles' },
-    ],
+    titre: 'Tests',
+    qui: ['testwriter'],
+    etat: 'testwriter',
+    boucles: [{ cle: 'tests', libelle: 'essai', max: 3 }],
+    sous: [{ numero: '2.1', titre: 'Preuve du rouge', qui: [AUTO], etat: 'preuve' }],
   },
   {
     numero: '3',
-    titre: 'Passe finale',
-    qui: [AUTO],
-    etat: 'controles',
-    finale: true,
+    titre: 'Code',
+    qui: ['developpeur'],
+    etat: 'developpeur',
+    boucles: [{ cle: 'code', libelle: 'essai', max: 3 }],
+    sous: [{ numero: '3.1', titre: 'Contrôles', qui: [AUTO], etat: 'controles' }],
+  },
+  {
+    numero: '4',
+    titre: 'Passe finale et relecture',
+    qui: [],
+    etat: null,
     sous: [
+      { numero: '4.1', titre: 'Passe finale', qui: [AUTO], etat: 'controles', finale: true },
       {
-        numero: '3.1',
+        numero: '4.2',
         titre: 'Régénération des références',
         qui: [AUTO],
         etat: 'references',
-        declaration: 'references',
         arrets: ['references'],
       },
+      {
+        numero: '4.3',
+        titre: 'Relecture',
+        qui: ['relecteur'],
+        etat: 'relecture',
+        boucles: [{ cle: 'relecture', libelle: 'tour', max: 3 }],
+      },
     ],
   },
-  {
-    numero: '4',
-    titre: 'Relecture',
-    qui: ['relecteur'],
-    etat: 'relecture',
-    boucles: [{ cle: 'relecture', libelle: 'tour', max: 3 }],
-  },
   {
     numero: '5',
     titre: 'Intégration',
@@ -133,29 +93,19 @@ export const ETAPES = [
 // Every step and sub-step, in the order of the tree.
 export const SUITE = ETAPES.flatMap(e => [e, ...(e.sous ?? [])]);
 
-// The arbitrage of a stop, out of the sequence, under the stopped step.
-export const ARBITRAGE = {
-  numero: null,
-  titre: "Arbitrage de l'arrêt",
-  qui: ['regulateur', 'questionneur'],
-  etat: null,
-  boucles: [{ cle: 'arret', libelle: 'arrêt', max: 3 }, TOURS],
-};
-
 // The bounded loop of key <cle>.
-export const boucle = cle =>
-  [...SUITE, ARBITRAGE].flatMap(e => e.boucles ?? []).find(b => b.cle === cle) ?? null;
+export const boucle = cle => SUITE.flatMap(e => e.boucles ?? []).find(b => b.cle === cle) ?? null;
 
-// The loops that run at the step <etape>: those of the arbitrage at the arbitrage; else those of
-// each step that spans it, itself or its parent.
+// The loops that run at the step <etape>: its own and its parent's.
 export const bouclesDe = etape => {
-  if (etape === ARBITRAGE) return ARBITRAGE.boucles;
   const parent = ETAPES.find(e => e === etape || e.sous?.includes(etape));
-  return [...new Set([parent, etape])]
-    .flatMap(e => e?.boucles ?? [])
-    .filter(b => (b.sur ? b.sur.includes(etape.numero) : true));
+  return [...new Set([parent, etape])].flatMap(e => e?.boucles ?? []);
 };
 
+// The agents who write the lot, the testwriter its tests and the developpeur its code: the roles a
+// blocking finding of the reviewer names.
+export const AGENTS_DU_LOT = ['testwriter', 'developpeur'];
+
 // The exit code of each stop of the circuit.
 export const ARRETS = {
   lancement: 10,
@@ -166,46 +116,36 @@ export const ARRETS = {
   'sans-livraison': 15,
   'relecture-arret': 16,
   integration: 17,
-  question: 18,
   'hors-portee': 19,
   besoin: 20,
-  'composants-manquants': 21,
   questionnement: 22,
   references: 23,
+  'hors-plan': 24,
   'a-repasser': A_REPASSER,
 };
 
-// The role that settles a stop of the circuit, and the one that questions a plan or a decision.
-export const REGULATEUR = 'regulateur';
+// The role that writes the plan and answers its questions once, and the role that questions it.
+export const EXPLORATEUR = 'explorateur';
 export const QUESTIONNEUR = 'questionneur';
 
 // A role in words.
-const NOMS = {
-  'referent-technique': 'référent technique',
-  regulateur: 'régulateur',
-  developpeur: 'développeur',
-};
+const NOMS = { developpeur: 'développeur' };
 export const nomDuRole = role => NOMS[role] ?? role;
 
-// Who works at the step <e>, in words, « questionneur ⇄ référent »: its short form, else its
-// roles' names.
-export const quiDe = e => e.quiCourt ?? e.qui.map(nomDuRole).join(' ⇄ ');
+// Who works at the step <e>, in words: its roles' names.
+export const quiDe = e => e.qui.map(nomDuRole).join(' ⇄ ');
 
-// The step <e> in words, « 2.3 Code ».
+// The step <e> in words, « 3 Code ».
 export const libelle = e => `${e.numero} ${e.titre}`;
 
-// The step of a circuit's state (`etape`, `finale`, its stop `raison`, its questioning under way
-// `questionnement`, an object or its `objet`, the start of its survey of the components under way
-// `releve`), or null (« integre », an unknown step): the step
-// whose stop or questioning it is, else the step of its `etape`.
-export const etapeDuCircuit = ({ etape, finale, raison, questionnement, releve }) => {
+// The step of a circuit's state (`etape`, `finale`, its stop `raison`, the work on its plan under
+// way `questionnement`, an object or its `objet`), or null (« integre », an unknown step): the step
+// whose stop or work on the plan it is, else the step of its `etape`.
+export const etapeDuCircuit = ({ etape, finale, raison, questionnement }) => {
   const objet = questionnement?.objet ?? questionnement ?? null;
   return (
     SUITE.find(
-      e =>
-        (raison && e.arrets?.includes(raison)) ||
-        (objet && e.questionnement === objet) ||
-        (!raison && !objet && releve && e.releve)
+      e => (raison && e.arrets?.includes(raison)) || (objet && e.questionnement === objet)
     ) ??
     SUITE.find(
       e =>
@@ -217,107 +157,102 @@ export const etapeDuCircuit = ({ etape, finale, raison, questionnement, releve }
   );
 };
 
-// The step where the role agent <role> works, the arbitrage for the regulator, or null for any
-// other agent.
+// The step where the role agent <role> works, or null for any other agent.
 export const etapeDuRole = role =>
-  role === AUTO ? null : ([...SUITE, ARBITRAGE].find(e => e.qui.includes(role)) ?? null);
-
-// The step where a ticket's plan is questioned.
-const QUESTIONNEMENT_DU_PLAN = SUITE.find(e => e.questionnement === 'plan');
+  role === AUTO ? null : (SUITE.find(e => e.qui.includes(role)) ?? null);
 
-// Whether the role agent <role> judges a plan or a stop (the questioning of the plan, the
-// arbitrage), and so delivers nothing to the lot.
-export const juge = role =>
-  [QUESTIONNEMENT_DU_PLAN, ARBITRAGE].some(e => role !== AUTO && e.qui.includes(role));
-
-// The table of the stops and their gesture: the written policy of the circuit's stops, as Zuul
-// and GitHub's merge queue write their bounded retries and their failure policy, and as the
-// sheriffs of Chromium quarantine a flaky test by a rule, not by a judgement. The circuit
-// (scripts/circuit.mjs) tries its lines in their order on each stop, and on the regulator's
-// decision: a gesture the table names, it applies itself, with no regulator; the regulator is
-// launched for what no line settles, and for the line that sends to him. Each line: `genre`, the
-// kind of stop as the circuit reads it in its structured results and its state; `geste`, what
-// follows; `cas`, the case of BPScript 320.3 (2026-10-20) it would have settled, by its stop (A)
-// or its decision (D) in the analysis of that ticket. The gestures (GESTES):
-// - `superviseur`: the circuit ends on the stop, its reason saying why, for the supervisor, with
-//   no regulator, and the board shows it under its step after « ⤷ Arrêt · superviseur »;
-// - `a-repasser`: the circuit ends at 75, which the supervisor plays again at rest;
-// - `regulateur`: a session of the regulator settles the stop;
-// - `developpeur-du-composant`: the red goes to the developpeur of the component that owns it,
-//   never to the one under way: it waits for that component's checks, or, at the final pass, the
-//   circuit relaunches that developpeur (the checks of scripts/circuit.mjs);
-// - `testwriter`: the circuit plays the component again from its testwriter.
+// The gestures of the circuit: what it does itself on a stop a rule settles, as a CI applies its
+// rules (retry, regenerate, skip a job without object) without asking anyone, and as the sheriffs
+// of Chromium quarantine a flaky test by a rule, not by a judgement. Each gesture: `genre`, its
+// name as the circuit writes it at the ticket and in the log; `geste`, what the circuit does;
+// `regle`, the rule that settles it; `cas`, the case of BPScript it settles (the analysis of 320.3,
+// its stop A or its decision D, or that of 320.9). On each one, the circuit writes at the ticket
+// `Circuit · geste : <genre> → <geste> (règle : <regle>)`, and the same line in the ticket's log.
 export const GESTES = [
-  'superviseur',
-  'a-repasser',
-  'regulateur',
-  'developpeur-du-composant',
-  'testwriter',
-];
-
-export const TABLE_DES_ARRETS = [
   {
-    // A component the survey of the ticket finds and its title misses (21): the circuit ends on
-    // it at 1.1, before any session.
-    genre: 'composants-manquants',
-    geste: 'superviseur',
-    cas: 'A3 : 020-loader mis au titre en cours de route ; A14 : 040-checker, nommé au critère 13 et absent du titre, rouge à la première passe finale',
-  },
-  {
-    // A questioning of the plan that does not converge at 1.2 (22), a disagreement or a fourth
-    // round still questioned.
-    genre: 'questionnement',
-    geste: 'superviseur',
-    cas: 'A14 : 040-checker nommé au critère 13 et absent du titre, que le plan questionné aurait relevé ; D15 : une consigne neuve sur le fond, hors du plan',
-  },
-  {
-    // The same stop (its name, step and component) after a RELANCE, the copy and the ticket's
-    // description unchanged since that decision.
-    genre: 'meme-arret-sans-fait-nouveau',
-    geste: 'superviseur',
-    cas: 'A8 → A9 : RELANCE --reprendre sans contexte, le même arrêt sur la même copie (D9) ; A11 → A13 : le même rouge de la passe finale trois fois (D13, D14)',
-  },
-  {
-    // Checks whose failures all depend on a duration under load (verifier's 75), the integration
-    // at 75, or the branch kept in the queue.
     genre: 'a-repasser',
-    geste: 'a-repasser',
-    cas: 'A12, A17, A18 : un vrai rouge pris pour la charge du processeur (D14, D20, D21) ; seul le code 75 du vérificateur dit la charge',
+    geste: 'le circuit finit à 75, que le superviseur rejoue au repos par --reprendre',
+    regle: 'seul le code 75 du vérificateur dit la charge de la machine',
+    cas: 'A12, A17, A18 : un vrai rouge pris pour la charge du processeur (D14, D20, D21)',
   },
   {
-    // A red whose findings are all to settle (SARIF `genre` a-arbitrer), which no developpeur
-    // settles.
-    genre: 'a-arbitrer',
-    geste: 'regulateur',
-    cas: 'A16 : la garde consommateurs-arbitres attend un arbitrage, que seul le régulateur écrit (D19, juste)',
+    genre: 'rejeu',
+    geste: 'la commande joue une seconde fois',
+    regle:
+      'une commande des contrôles hors de la passe finale, ou l’intégration, à 75 rejoue une fois avant l’arrêt',
+    cas: 'A12 : un contrôle à 75, rejoué avant de conclure à la charge',
   },
   {
-    // A red that belongs to another component of the title than the one whose checks run.
-    genre: 'rouge-d-un-autre-composant',
-    geste: 'developpeur-du-composant',
-    cas: 'A4, A6, A8–A10 : la garde des mots de 030-binder rendue aux développeurs de 050, 130 et 900 (D5, D7, D9–D11)',
-  },
-  {
-    // A developpeur's sheet whose `renvoi` names the testwriter of a component of the title up to
-    // his own.
     genre: 'renvoi-au-testwriter',
-    geste: 'testwriter',
+    geste: 'au testwriter, que la fiche du développeur nomme, puis la preuve et le développeur',
+    regle: 'le rouge qui reste est dans les tests du lot (`renvoi` de sa fiche)',
     cas: 'A5, A7 : « Agent : testwriter » non lu, les tests périmés de 050 et de 130 (D6, D8) ; A2 (D2)',
   },
   {
-    // On the supervisor's answer to a question, a component the title gained since the stop.
-    genre: 'composant-ajoute',
-    geste: 'testwriter',
-    cas: 'A3 : 020-loader mis au titre, puis RELANCE testwriter 020-loader (D4) ; A14 : 040-checker, puis testwriter 040-checker (D17)',
+    genre: 'regeneration',
+    geste:
+      'à la régénération des références (4.2), puis la passe finale restreinte à ce qu’elle change',
+    regle:
+      'un rouge de la passe finale est celui d’une référence, même mêlé à d’autres : une que le projet déclare (`grillhouse.references`), ou un fichier que le cadre engendre (l’index des interfaces, les turbo.json, les rapports d’API) ; ou la passe abaisse la dette des gardes (`dette.mjs --abaisser`, depuis ses notes)',
+    cas: 'BP 320.9 : 292 min autour des références, dont 163 min d’attente pour régénérer à la main l’index des interfaces, le plafond et l’empreinte, des rouges de références mêlés à d’autres',
   },
   {
-    // The ticket's description changed while the stop was settled, a criterion added: the circuit
-    // then admits only a RELANCE from a testwriter.
-    genre: 'critere-neuf',
-    geste: 'testwriter',
-    cas: 'D15 : une consigne neuve sur le fond donnée au développeur de 030-binder sans test (A14), rendue au testwriter de 040-checker (D17)',
+    genre: 'rien-a-livrer',
+    geste: 'aux contrôles, qui jugent le lot',
+    regle:
+      'un développeur qui ne change aucun fichier du plan n’a rien à livrer quand les contrôles sont verts ; rouges, l’arrêt monte (sans-livraison)',
+    cas: 'BP 320.9 : 995-tools n’a rien à livrer, 4 montées et 49 min (B5)',
   },
 ];
 
-// The line of the table for the kind of stop <genre>, or null.
-export const gesteDe = genre => TABLE_DES_ARRETS.find(l => l.genre === genre) ?? null;
+// The gesture of name <genre>, or null.
+export const gesteDe = genre => GESTES.find(g => g.genre === genre) ?? null;
+
+// Who answers a question of the circuit: the supervisor, or the owner, whose question the
+// supervisor carries.
+export const SUPERVISEUR = 'superviseur';
+export const RESPONSABLE = 'responsable';
+
+// The commands by which the supervisor answers a question (scripts/circuit.mjs): resume, extend
+// the plan, stop.
+const REPONSES =
+  'Le superviseur répond par une commande du circuit : `--reprendre` (avec `--contexte`) ou `--depuis <testwriter|developpeur>` (avec `--contexte`), `--etendre <paquet>` (le plan gagne ce paquet, puis l’étape en cours reprend), ou `--arreter`.';
+
+// The question of each stop no gesture settles, as a CI calls a person only for what no rule
+// settles (the approval of a review): every stop of ARRETS but « a-repasser », a gesture. The
+// circuit ends on the stop, its state carrying the question (`question`: `{ arret, fait, piece,
+// question, qui }`: the fact, its piece, file:line or command and output, the question and who must
+// answer it), for the supervisor, who answers by a command of the circuit and carries to the owner
+// what is his (`qui` responsable: the reviewer's question on a real word of the language).
+export const MONTEES = Object.fromEntries(
+  Object.entries({
+    lancement:
+      'Le lanceur s’arrête avant la séance : la machine se répare-t-elle, pour reprendre ?',
+    bloqué:
+      'La séance n’a plus bougé, et le circuit l’a arrêtée : reprendre l’étape, ou arrêter le circuit ?',
+    'sans-fiche':
+      'La séance finit deux fois sans fiche conforme : reprendre l’étape, ou arrêter le circuit ?',
+    preuve:
+      'La troisième preuve du rouge refuse le lot de tests : quel contexte donner au testwriter, ou le plan doit-il changer ?',
+    controles:
+      'Un rouge reste, que le circuit ne rend pas au développeur (hors du plan, sans fichier, à arbitrer), ou que trois séances n’ont pas levé : avec quel contexte le lever, ou le plan doit-il s’étendre ?',
+    'sans-livraison':
+      'Le développeur ne change rien et le rouge reste : avec quel contexte le lever, ou le plan doit-il changer ?',
+    'relecture-arret':
+      'La relecture ne rend pas le lot à un agent (un constat sans destinataire valide, un critère en cause, ou la troisième relecture rendue) : que devient le plan, et qui reprend ?',
+    integration:
+      'L’intégration refuse le lot, ou la file rouvre le ticket : que corrige le lot, et qui le reprend ?',
+    'hors-portee':
+      'L’agent se dit bloqué hors de sa portée : le plan s’étend-il au paquet qu’il nomme, ou un autre agent lève-t-il le reste ?',
+    besoin: 'Une réponse manque pour avancer : laquelle ?',
+    questionnement:
+      'Des questions du plan restent ouvertes après la réponse de l’explorateur : le plan change-t-il (`bd update`), ou reste-t-il tel quel ? `--reprendre` le fait passer tel qu’il est alors.',
+    references:
+      'La régénération des références change une référence du projet que le plan ne nomme pas, un fichier qu’aucune référence n’écrit, ou sa commande échoue : le plan les nomme-t-il, ou qui corrige le lot ?',
+    'hors-plan':
+      'La séance écrit hors du plan du ticket : le plan s’étend-il à ce paquet (`--etendre`), ou l’écriture est-elle refusée (`--reprendre` avec son contexte) ?',
+  }).map(([arret, question]) => [arret, { question: `${question} ${REPONSES}`, qui: SUPERVISEUR }])
+);
+
+// The question of the stop <arret>, `{ question, qui }`, or null for a gesture.
+export const monteeDe = arret => MONTEES[arret] ?? null;

package/scripts/gardes-du-cadre.mjs

@@ -9,14 +9,14 @@
 // - Each red guard is named with its code at the end; the exit code is 1 when one guard is red,
 //   0 when all are green.
 // - While the run names its results directory (`GRILLHOUSE_RESULTATS`, scripts/resultats.mjs),
-//   each guard writes its findings there in SARIF; a red guard that wrote no finding has one
-//   written for it, without location, its name (its script's, without extension) and its code:
-//   a red no reader can place.
+//   each guard writes its findings there in SARIF; a red guard that wrote no finding (a note of
+//   the debt, `a-elaguer`, is none) has one written for it, without location, its name (its
+//   script's, without extension) and its code: a red no reader can place.
 // - The build is not among them: Turborepo builds before this task (turbo.json).
 import { spawnSync } from 'node:child_process';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { ecrireSarif, lireSarif, RESULTATS } from './resultats.mjs';
+import { A_ELAGUER, ecrireSarif, lireSarif, RESULTATS } from './resultats.mjs';
 
 // A script of the package, beside this one, by its name.
 const ici = nom => fileURLToPath(new URL(nom, import.meta.url));
@@ -47,13 +47,15 @@ export function jouerLesGardes({
   dire = l => process.stdout.write(`${l}\n`),
 }) {
   const rouges = [];
+  // The findings under the results directory, the notes of the debt left out.
+  const nombre = () => lireSarif(env[RESULTATS]).constats.filter(k => k.genre !== A_ELAGUER).length;
   for (const garde of gardes) {
-    const avant = env[RESULTATS] ? lireSarif(env[RESULTATS]).constats.length : 0;
+    const avant = env[RESULTATS] ? nombre() : 0;
     const r = spawnSync(process.execPath, garde, { cwd: racine, env, stdio: 'inherit' });
     if (r.status === 0) continue;
     const code = `code ${r.status ?? r.signal}`;
     rouges.push(`${libelle(garde)} (${code})`);
-    if (env[RESULTATS] && lireSarif(env[RESULTATS]).constats.length === avant) {
+    if (env[RESULTATS] && nombre() === avant) {
       ecrireSarif({
         garde: nomDeGarde(garde),
         racine,

package/scripts/grillhouse-maj.mjs

@@ -13,7 +13,14 @@
 // - The migrations first (scripts/migrations.mjs): each migration of the package newer than the
 //   version the project recorded (`grillhouse.version` of its package.json; none recorded, every
 //   migration), in the order of their versions; each is replayable without effect, and the report
-//   names each one that changed something, with what it changed.
+//   names each one that changed something, with what it changed. What a migration leaves to the
+//   project (a copy of the frame the project modified, scripts/migrations/0.23.2-copies-du-cadre.mjs)
+//   is written on the error stream, with the command that does it, and the exit code is non-zero;
+//   the project keeps the version it recorded, so that the next update plays that migration again.
+//   Last, after the update and the regeneration, what stays to the project (`restes` of a
+//   migration played, scripts/migrations.mjs: in 0.24.0, a file that still calls a former copy of
+//   the frame) is reported on the standard output, « reste au projet », with no effect on the exit
+//   code nor on the version recorded.
 // - The frame copies no file into a project: its scripts are the package's, its skills, agents,
 //   hooks of Claude Code, common charter and meta-frame the plugin's, which the package carries
 //   (scripts/cadre.mjs): the frame arrives in one piece, at the version npm installs.
@@ -31,7 +38,8 @@
 //   the frame's status line (`ligne-etat`, whatever its former form); a status line of the
 //   project's own stays. The settings keep their other keys, in their order.
 // - `package.json`, when there is one: the version of the frame it is brought to
-//   (`grillhouse.version`, the package's version), the frame's npm scripts (`tableau`,
+//   (`grillhouse.version`, the package's version once no migration leaves anything to do), the
+//   frame's npm scripts (`tableau`,
 //   `grillhouse:maj`), its `prepare` beginning with `grillhouse hooks` (the frame's git hooks at
 //   each `npm install`, as Husky's `prepare`; a `prepare` of the project's own follows it,
 //   `grillhouse hooks && …`), and `grillhouse:gardes` (scripts/gardes-du-cadre.mjs, the frame's controls), `grillhouse:dette:inscrire` and
@@ -120,7 +128,7 @@ import semver from 'semver';
 import { CADRE, VERSION } from './cadre.mjs';
 import { poserCrochets } from './crochets.mjs';
 import { installerGreffons } from './greffons.mjs';
-import { migrer } from './migrations.mjs';
+import { migrer, restesAuProjet } from './migrations.mjs';
 import { paquets } from './paquets.mjs';
 
 const SCRIPTS = {
@@ -285,9 +293,10 @@ export function versionDuProjet(projet) {
 
 /**
  * Brings the project at `projet` to the frame's files at `source` (CADRE, scripts/cadre.mjs; a
- * trial's own in the tests). Returns what changed.
+ * trial's own in the tests); <inscrite> is the version it records (the package's; null records
+ * none, the project keeping its own). Returns what changed.
  */
-export function mettreAJour(projet, source) {
+export function mettreAJour(projet, source, { inscrite = VERSION } = {}) {
   const bilan = {
     dependances: [],
     test: null,
@@ -301,7 +310,7 @@ export function mettreAJour(projet, source) {
   const pkg = path.join(projet, 'package.json');
   if (existsSync(pkg)) {
     const p = lireJson(pkg, {});
-    p.grillhouse = { ...(p.grillhouse ?? {}), version: VERSION };
+    if (inscrite !== null) p.grillhouse = { ...(p.grillhouse ?? {}), version: inscrite };
     const pkgSource = lireJson(path.join(source, GABARIT), {});
     const gardes = pkgSource.scripts?.['grillhouse:gardes'];
     p.scripts = { ...(p.scripts ?? {}), ...SCRIPTS };
@@ -497,18 +506,31 @@ if (import.meta.url === pathToFileURL(process.argv[1] ?? '').href) {
     process.exitCode = 2;
   } else {
     const projet = process.cwd();
-    const migrations = migrer(projet, versionDuProjet(projet));
-    const b = mettreAJour(projet, CADRE);
+    const depuis = versionDuProjet(projet);
+    const migrations = migrer(projet, depuis);
+    const resteAFaire = migrations.some(m => m.aFaire.length > 0);
+    const b = mettreAJour(projet, CADRE, resteAFaire ? { inscrite: null } : {});
     process.stdout.write(`Cadre ${VERSION}.\n`);
-    for (const { version, nom, lignes } of migrations) {
+    for (const { version, nom, lignes, aFaire } of migrations) {
       process.stdout.write(
         `Migration ${version} (${nom}) :\n${lignes.map(l => `- ${l}\n`).join('')}`
       );
+      if (aFaire.length > 0) {
+        process.stderr.write(
+          `Migration ${version} (${nom}), à faire :\n${aFaire.map(l => `- ${l}\n`).join('')}`
+        );
+        process.exitCode = 1;
+      }
     }
     process.stdout.write(rapport(b));
     for (const l of [...regenerer(projet), ...installerGreffons(projet)]) {
       process.stderr.write(`${l}\n`);
       process.exitCode = 1;
     }
+    for (const { version, nom, lignes } of restesAuProjet(projet, depuis)) {
+      process.stdout.write(
+        `Migration ${version} (${nom}), reste au projet :\n${lignes.map(l => `- ${l}\n`).join('')}`
+      );
+    }
   }
 }

package/scripts/index-interfaces.mjs

@@ -36,6 +36,7 @@ import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { composants, declares } from './consommateurs.mjs';
+import { lireLaListe } from './enveloppe/paquets-du-plan.mjs';
 import { DEBUT, FIN, marques } from './interfaces-contre-code.mjs';
 import { ecrireSarif } from './resultats.mjs';
 
@@ -179,7 +180,10 @@ function rend(racine, rel) {
 // What the components before <composant> publish, as the section the launcher writes after the
 // instruction of a role agent (scripts/enveloppe/lancer.sh). <composant> is the component's path
 // in the repository at <racine> (`packages/a`, `src/parser`), or `.` for a copy of the whole
-// repository, which the section points to the index of the interfaces. Its providers are the
+// repository, which the section points to the index of the interfaces; or the plan of a session,
+// several paths in the form of the envelope's list (`packages/a:packages/b`, `lireLaListe`), one
+// part of the section per package of the plan, its providers under it, as one session works the
+// whole plan of a ticket (grillhouse-3uv.95.6). Its providers are the
 // components whose `## Consommateurs` section names it; for each, its line in the index of the
 // interfaces (its heading, its first sentence, its interface), the names of the elements its
 // `## Consommateurs` line declares for the component, never their sentence, which the index of the
@@ -187,7 +191,23 @@ function rend(racine, rel) {
 // or one line saying the frame or the rubric is missing. A declaration of `*`, an import of the
 // whole component, names no element: its line says the elements are in the index. Each interface
 // and each frame is read once.
+/** @param {string} racine @param {string} composant @returns {string} */
 export function publie(racine, composant) {
+  const plan = lireLaListe(composant);
+  if (plan.length > 1) {
+    const parties = plan.map(c =>
+      publie(racine, c)
+        .split('\n')
+        .slice(2)
+        .map(l => (l.startsWith('### ') ? `#${l}` : l))
+    );
+    return [
+      TITRE_PUBLIE,
+      '',
+      'Ton plan porte plusieurs paquets : pour chacun, ce que publient les composants dont il dépend.',
+      ...plan.flatMap((c, i) => ['', `### Pour \`${path.basename(c)}\``, '', ...parties[i]]),
+    ].join('\n');
+  }
   if (composant === '.') {
     return [
       TITRE_PUBLIE,