@roomi-fields/grillhouse 0.23.1 → 0.24.0

package/scripts/integration/integrer.mjs

@@ -14,8 +14,8 @@
 // --ticket is a usage error, named. In order, each step refusing stops the run:
 //  1. the verdict: the ticket has `ACCEPTÉ` as its last reviewer verdict (`ACCEPTÉ` or
 //     `RENDU` at the start of a comment of the author `relecteur`; another author's is none) and, when labelled `arbitrage`, each arbitrage
-//     (`estArbitrage`: a « ## Arbitrage » comment, or the regulator's the circuit writes) is settled
-//     (`arbitrageTranche`: the regulator's, `### Verdict — tranché`, or a « ## Réponse du
+//     (`estArbitrage`: a « ## Arbitrage » comment, the supervisor's) is settled
+//     (`arbitrageTranche`: `### Verdict — tranché`, or a « ## Réponse du
 //     responsable » comment after it);
 //  2. the lots: the tests lot touches only what the testwriter writes (`isTesterFile`: test files
 //     and the shared test material), the code lot none of it;

package/scripts/interfaces-contre-code.mjs

@@ -45,10 +45,10 @@
 // `faute-mal-formee`, `faute-hors-catalogue`, `faute-non-nommee`, `faute-non-produite`,
 // `faute-non-listee`), or by the declaration file and TSDoc's message id for a TSDoc message.
 //
-// In the envelope of a component (`GRILLHOUSE_ENVELOPPE`, scripts/enveloppe/composant.mjs), the
-// check and `npm run api` read and write that component alone: its neighbours' source is hidden,
-// their published parts read-only, and the integration checks every component on the whole
-// repository. The component's build comes first, as outside (`npm test -- <its files>` builds it).
+// In the envelope of an agent (`GRILLHOUSE_ENVELOPPE`, scripts/enveloppe/paquets-du-plan.mjs), the
+// check and `npm run api` judge and write the components of its plan alone: the others are
+// read-only there, and the integration checks every component on the whole repository. The
+// component's build comes first, as outside (`npm test -- <its files>` builds it).
 //
 // A component without `docs/INTERFACE.md` is reported and skipped. A project that prefers a
 // bench per component calls `verifierComposant(racine, composant)` from its test.
@@ -58,7 +58,7 @@ import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { composants, lireSiPresent, parcourir } from './consommateurs.mjs';
-import { composantDeLEnveloppe } from './enveloppe/composant.mjs';
+import { paquetsDeLEnveloppe } from './enveloppe/paquets-du-plan.mjs';
 import { trancher } from './dette.mjs';
 
 const require = createRequire(import.meta.url);
@@ -428,7 +428,10 @@ function avecPartie(m, texte, partie) {
 // the debt (`dette.mjs`) judges, keyed by the component's interface (by the declaration file for a
 // TSDoc message, its rule TSDoc's message id); a refusal that a command or a build repairs (a
 // generated part, an API report, a built entry, the marks, the TSDoc configuration) has no key and
-// is never inscribed.
+// is never inscribed. The refusals `npm run api` lifts carry their rule without a file, never
+// inscribed either: `rapport-api` (the API report absent or stale) and `partie-generee` (the
+// generated part of the interface), by which the circuit regenerates them at the final pass
+// (scripts/circuit.mjs, the references of the frame).
 export function verifierComposant(racine, c, { ecrire = false } = {}) {
   const refus = [];
   const signaux = [];
@@ -442,6 +445,8 @@ export function verifierComposant(racine, c, { ecrire = false } = {}) {
         ? { fichier, ...(ligne ? { ligne } : {}), regle, message: `${rel} : ${texte}` }
         : { message: `${rel} : ${texte}` }
     );
+  // A refusal `npm run api` lifts: its rule, no file.
+  const aRegenerer = (texte, regle) => refus.push({ regle, message: `${rel} : ${texte}` });
   if (!existsSync(iface)) {
     signaux.push(`${rel} n'a pas d'interface (docs/INTERFACE.md) : rien n'est vérifié.`);
     return { refus, signaux };
@@ -474,12 +479,14 @@ export function verifierComposant(racine, c, { ecrire = false } = {}) {
     }
     const manque = !ecrire && !existsSync(path.join(c.dir, 'docs', 'INTERFACE.api.md'));
     if (manque) {
-      refuser(
-        "son rapport docs/INTERFACE.api.md manque ; npm run api l'écrit, après la construction."
+      aRegenerer(
+        "son rapport docs/INTERFACE.api.md manque ; npm run api l'écrit, après la construction.",
+        'rapport-api'
       );
     } else if (!api.ajour && !ecrire) {
-      refuser(
-        "l'API a changé sans son rapport docs/INTERFACE.api.md ; npm run api le régénère, après la construction."
+      aRegenerer(
+        "l'API a changé sans son rapport docs/INTERFACE.api.md ; npm run api le régénère, après la construction.",
+        'rapport-api'
       );
     }
     const nommees = new Set();
@@ -497,8 +504,9 @@ export function verifierComposant(racine, c, { ecrire = false } = {}) {
       if (ecrire) {
         if (attendu !== texte) writeFileSync(iface, attendu);
       } else if (attendu !== texte) {
-        refuser(
-          `la part générée de docs/INTERFACE.md (entre ${DEBUT} et ${FIN}) n'est pas celle du code ; npm run api la refait.`
+        aRegenerer(
+          `la part générée de docs/INTERFACE.md (entre ${DEBUT} et ${FIN}) n'est pas celle du code ; npm run api la refait.`,
+          'partie-generee'
         );
       }
     }
@@ -522,13 +530,13 @@ function codesContreCatalogue(c, racine, fautes, refuser) {
   }
 }
 
-// The components a run reads: every one of <racine>; in the envelope of a component, that one
-// alone, its neighbours read by their published form and never written.
+// The components a run reads: every one of <racine>; in an envelope, those its plan names, the
+// others never written; every one when the plan names none of them (a folder of the root, `.`).
 export function aVerifier(racine, env = process.env) {
   const tous = composants(racine);
-  const propre = composantDeLEnveloppe(env);
-  const sien = propre && tous.filter(c => path.resolve(c.dir) === path.resolve(racine, propre));
-  return sien?.length ? sien : tous;
+  const plan = (paquetsDeLEnveloppe(env) ?? []).map(p => path.resolve(racine, p));
+  const siens = tous.filter(c => plan.includes(path.resolve(c.dir)));
+  return siens.length ? siens : tous;
 }
 
 if (import.meta.url === pathToFileURL(process.argv[1] ?? '').href) {

package/scripts/migrations/0.23.0-config-vitest.mjs

@@ -2,22 +2,24 @@
 // (and `/mesure`), in place of the workspace package `@grillhouse/vitest-config` that the frame's
 // copied files held.
 //
-// - Each source file of the project (`.ts`, `.mts`, `.cts`, `.js`, `.mjs`, `.cjs`; node_modules,
-//   .git, dist, coverage, .turbo, .claude, .beads, .codegraph and .rtfm left out) that names
+// - Each source file of the project (scripts/sources.mjs) that names
 //   `@grillhouse/vitest-config` or `@grillhouse/vitest-config/mesure` in quotes names the package's
 //   instead; a root configuration that imports the base by its former path
 //   (`./scripts/vitest-config/base.mjs`, `./packages/grillhouse/scripts/vitest-config/base.mjs`)
-//   imports it by its name.
+//   imports it by its name. `formesAnterieures` gives back what a text so rewritten held before,
+//   by which the migration of the copies (0.23.2-copies-du-cadre.mjs) still knows a former copy of
+//   the frame by its fingerprint.
 // - Each package.json of the project (the root's and each workspace's) that declares
 //   `@grillhouse/vitest-config` declares `@roomi-fields/grillhouse` in the same field in its place,
 //   at the range the root declares (else `^<version>` of the package), unless it already declares
 //   it; the root's workspaces lose the former directory of the package (`scripts/vitest-config`,
 //   `packages/grillhouse/scripts/vitest-config`).
 // - A project already in the new form is not written.
-import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { VERSION } from '../cadre.mjs';
 import { paquets } from '../paquets.mjs';
+import { sources } from '../sources.mjs';
 
 export const version = '0.23.0';
 export const nom = 'configuration de base de Vitest';
@@ -27,33 +29,34 @@ const PAQUET = '@roomi-fields/grillhouse';
 const NOUVEAU = `${PAQUET}/vitest-config`;
 const ANCIENS_ESPACES = ['scripts/vitest-config', 'packages/grillhouse/scripts/vitest-config'];
 const CHAMPS = ['dependencies', 'devDependencies', 'optionalDependencies', 'peerDependencies'];
-const EXTENSIONS = /\.(?:[mc]?ts|[mc]?js)$/;
-const HORS = new Set([
-  'node_modules',
-  '.git',
-  'dist',
-  'coverage',
-  '.turbo',
-  '.claude',
-  '.beads',
-  '.codegraph',
-  '.rtfm',
-]);
 // A quoted name of the former package, or a former path of the base at the root.
 const NOMME =
   /(['"])(?:@grillhouse\/vitest-config(\/mesure)?|\.\/(?:packages\/grillhouse\/)?scripts\/vitest-config\/base\.mjs)\1/g;
 
-function sources(racine, rel = '') {
-  return readdirSync(path.join(racine, rel), { withFileTypes: true }).flatMap(e => {
-    const r = rel === '' ? e.name : `${rel}/${e.name}`;
-    if (e.isDirectory()) return HORS.has(e.name) ? [] : sources(racine, r);
-    return e.isFile() && EXTENSIONS.test(e.name) ? [r] : [];
-  });
-}
+// A quoted name of the package's base, as this migration writes it.
+const ECRIT = /(['"])@roomi-fields\/grillhouse\/vitest-config(\/mesure)?\1/g;
+const ANCIENS_CHEMINS = [
+  './scripts/vitest-config/base.mjs',
+  './packages/grillhouse/scripts/vitest-config/base.mjs',
+];
 
 const lireJson = f => JSON.parse(readFileSync(f, 'utf8'));
 const ecrireJson = (f, v) => writeFileSync(f, `${JSON.stringify(v, null, 2)}\n`);
 
+/**
+ * The texts <texte> may have held before this migration rewrote it: each name it wrote back to the
+ * former package's, or each name of the base back to one former path; none when it wrote nothing.
+ */
+export function formesAnterieures(texte) {
+  if (texte.search(ECRIT) < 0) return [];
+  return [
+    texte.replace(ECRIT, (_, q, mesure) => `${q}${ANCIEN}${mesure ?? ''}${q}`),
+    ...ANCIENS_CHEMINS.map(c =>
+      texte.replace(ECRIT, (tout, q, mesure) => (mesure ? tout : `${q}${c}${q}`))
+    ),
+  ];
+}
+
 /** Brings the project to the package's base configuration of Vitest; returns what it did. */
 export function migrer(projet) {
   const lignes = [];

package/scripts/migrations/0.23.2-copies-du-cadre.mjs

@@ -0,0 +1,201 @@
+// The frame's copies leave a project in 0.22.x: the package carries the scripts, its plugin the
+// skills, agents, charter and meta-frame, so the copies the former update placed
+// (`.claude/grillhouse/fichiers.txt`, each file's SHA-256 in `.claude/grillhouse/empreintes.json`)
+// are what this version replaces, as a codemod of `@turbo/codemod` removes what a version replaces.
+// The list says what to remove: nothing is guessed.
+//
+// - Each file `empreintes.json` records that a line of `fichiers.txt` keeps (the file itself, or a
+//   directory « …/ » above it; a line « - … » keeps none) goes when its bytes have the recorded
+//   SHA-256 (as the former update computed it), or had it before the migration 0.23.0 of Vitest
+//   rewrote its import of the base (`formesAnterieures` of 0.23.0-config-vitest.mjs); a directory
+//   it leaves empty goes with it. A file the template of a project holds at the same path
+//   (`tsdoc.json`, `docs/agents/issue-tracker.md`) is the project's own since 0.23.0, as
+//   `grillhouse init` places it, and stays.
+// - Under a directory the list keeps that is no workspace of the project (scripts/paquets.mjs), a
+//   file the former generator of the packages' turbo.json wrote (its first line « // Généré par
+//   `…turbo-des-paquets…` ») goes too: it belonged to the former workspace of a copy.
+// - A file whose bytes differ (the project modified it) stays: the migration leaves it to the
+//   project (`{ aFaire }`), with the command that removes it, and the update's exit code is
+//   non-zero; an npm script that runs it is named with it, since its removal breaks that script.
+//   While one stays, the list and the fingerprints stay, so that the next update names it again;
+//   once none stays, `.claude/grillhouse/` goes whole (the list, the fingerprints, the version, the
+//   former charter). A modified copy of a role 0.24.0 removes stays too, but is named by that
+//   migration alone (`deRoleSupprime` of 0.24.0-circuit-simplifie.mjs), once.
+// - Each root npm script that runs a copy removed (`node scripts/<chemin>`, `bash scripts/<chemin>`,
+//   its arguments kept) runs its subcommand, `grillhouse <sous-commande>`, by the table of
+//   scripts/sous-commandes.mjs; a script that still names a copy removed (no subcommand runs it) is
+//   named, not rewritten.
+// - A dependency of the project's root that a copy removed imported, that the package declares in
+//   its own `dependencies`, that the template of a project does not declare, and that no source of
+//   the project still imports, is named, not removed: the project decides.
+// - A project without `fichiers.txt` and `empreintes.json` is not written: a second pass finds
+//   neither, or finds only the copies left to the project, which it names again.
+import { createHash } from 'node:crypto';
+import { existsSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { CADRE, PAQUET } from '../cadre.mjs';
+import { paquets } from '../paquets.mjs';
+import { sources } from '../sources.mjs';
+import { SOUS_COMMANDES } from '../sous-commandes.mjs';
+import { formesAnterieures } from './0.23.0-config-vitest.mjs';
+import { deRoleSupprime } from './0.24.0-circuit-simplifie.mjs';
+
+export const version = '0.23.2';
+export const nom = 'copies du cadre';
+
+const DOSSIER = '.claude/grillhouse';
+const LISTE = `${DOSSIER}/fichiers.txt`;
+const EMPREINTES = `${DOSSIER}/empreintes.json`;
+const GABARIT = 'templates/projet';
+const CHAMPS = ['dependencies', 'devDependencies', 'optionalDependencies'];
+const CODE = /\.(?:[mc]?ts|[mc]?js)$/;
+// A call of a script of the frame's former copies in an npm script: its runner, then its path.
+const APPEL = /(^|[\s;&|(])(?:node|bash)\s+(?:\.\/)?(scripts\/[^\s'";&|)]+)/g;
+// The first line of a file the generator of the packages' turbo.json wrote.
+const GENERE = /^\/\/ Généré par `[^`\n]*turbo-des-paquets[^`\n]*`/;
+
+const hacher = octets => createHash('sha256').update(octets).digest('hex');
+const lireJson = f => JSON.parse(readFileSync(f, 'utf8'));
+const echapper = t => t.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+// Whether the source text <texte> imports the package <dep> (or a path into it).
+const importe = (texte, dep) =>
+  new RegExp(
+    `(?:\\bfrom\\s*|\\bimport\\s*\\(?\\s*|\\brequire\\s*\\(\\s*)(['"])${echapper(dep)}(?:/[^'"]*)?\\1`
+  ).test(texte);
+
+// The subcommand that runs each script of the package, by the path of its former copy.
+const PAR_COPIE = new Map(Object.entries(SOUS_COMMANDES).map(([n, s]) => [`scripts/${s}`, n]));
+
+// The lines of the list that keep a path: a file, or a directory « …/ ».
+const gardees = texte =>
+  texte
+    .split('\n')
+    .map(l => l.trim())
+    .filter(l => l !== '' && !l.startsWith('#') && !l.startsWith('-'));
+const couvert = (lignes, f) => lignes.some(l => (l.endsWith('/') ? f.startsWith(l) : f === l));
+
+// Whether the file at <absolu> has the fingerprint <attendue>, as copied or as 0.23.0 rewrote it.
+function intacte(absolu, attendue) {
+  const octets = readFileSync(absolu);
+  if (hacher(octets) === attendue) return true;
+  return formesAnterieures(octets.toString('utf8')).some(t => hacher(t) === attendue);
+}
+
+// The files under the directory <rel> of <projet>, as paths from it.
+function fichiersSous(projet, rel) {
+  const absolu = path.join(projet, rel);
+  if (!existsSync(absolu)) return [];
+  return readdirSync(absolu, { withFileTypes: true }).flatMap(e => {
+    const r = `${rel}/${e.name}`;
+    if (e.isDirectory()) return fichiersSous(projet, r);
+    return e.isFile() ? [r] : [];
+  });
+}
+
+// Removes each directory above <f> (a path from <projet>) that is left empty.
+function viderDossiers(projet, f) {
+  for (let d = path.dirname(f); d !== '.'; d = path.dirname(d)) {
+    const absolu = path.join(projet, d);
+    if (!existsSync(absolu) || readdirSync(absolu).length > 0) return;
+    rmSync(absolu, { recursive: true });
+  }
+}
+
+/** Takes the frame's former copies off the project at <projet>; returns what it did. */
+export function migrer(projet) {
+  const liste = path.join(projet, LISTE);
+  const fEmpreintes = path.join(projet, EMPREINTES);
+  if (!existsSync(liste) || !existsSync(fEmpreintes)) return [];
+  const lignes = gardees(readFileSync(liste, 'utf8'));
+  const enregistres = Object.entries(lireJson(fEmpreintes).fichiers ?? {}).filter(
+    ([f]) =>
+      couvert(lignes, f) &&
+      !f.startsWith(`${DOSSIER}/`) &&
+      !existsSync(path.join(CADRE, GABARIT, f))
+  );
+  const sortie = [];
+  const retires = new Map();
+  const restes = [];
+  const retirer = (f, ligne) => {
+    const absolu = path.join(projet, f);
+    retires.set(f, CODE.test(f) ? readFileSync(absolu, 'utf8') : '');
+    rmSync(absolu);
+    viderDossiers(projet, f);
+    sortie.push(ligne);
+  };
+  for (const [f, attendue] of enregistres) {
+    if (!existsSync(path.join(projet, f))) continue;
+    if (intacte(path.join(projet, f), attendue)) {
+      retirer(f, `${f} : copie du cadre retirée, que le paquet porte`);
+    } else if (!deRoleSupprime(f)) {
+      restes.push(f);
+      sortie.push({
+        aFaire: `${f} : copie du cadre modifiée par le projet, laissée en place ; \`git rm ${f}\` la retire, le paquet porte le cadre`,
+      });
+    }
+  }
+  const espaces = new Set(paquets(projet).map(p => p.dossier));
+  for (const d of lignes.filter(l => l.endsWith('/') && !l.startsWith(`${DOSSIER}/`))) {
+    const dossier = d.replace(/\/$/, '');
+    if (espaces.has(dossier)) continue;
+    for (const f of fichiersSous(projet, dossier)) {
+      if (!GENERE.test(readFileSync(path.join(projet, f), 'utf8'))) continue;
+      retirer(f, `${f} : fichier engendré pour l'ancien espace de travail ${dossier}, retiré`);
+    }
+  }
+  if (restes.length === 0) {
+    rmSync(path.join(projet, DOSSIER), { recursive: true, force: true });
+    viderDossiers(projet, DOSSIER);
+    sortie.push(`${DOSSIER}/ : retiré (la liste et les empreintes des copies du cadre)`);
+  } else {
+    for (const e of readdirSync(path.join(projet, DOSSIER))) {
+      if (`${DOSSIER}/${e}` !== LISTE && `${DOSSIER}/${e}` !== EMPREINTES) {
+        retirer(`${DOSSIER}/${e}`, `${DOSSIER}/${e} : retiré`);
+      }
+    }
+  }
+
+  const fPkg = path.join(projet, 'package.json');
+  if (!existsSync(fPkg)) return sortie;
+  const pkg = lireJson(fPkg);
+  let reecrit = false;
+  for (const [n, script] of Object.entries(pkg.scripts ?? {})) {
+    if (typeof script !== 'string') continue;
+    const neuf = script.replace(APPEL, (tout, avant, f) =>
+      retires.has(f) && PAR_COPIE.has(f) ? `${avant}grillhouse ${PAR_COPIE.get(f)}` : tout
+    );
+    if (neuf !== script) {
+      pkg.scripts[n] = neuf;
+      reecrit = true;
+      sortie.push(`package.json : le script ${n} lance \`${neuf}\``);
+    }
+    for (const f of retires.keys()) {
+      if (neuf.includes(f)) {
+        sortie.push(
+          `package.json : le script ${n} nomme ${f}, copie retirée qu'aucune sous-commande ne remplace ; à réécrire`
+        );
+      }
+    }
+    for (const f of restes.filter(r => neuf.includes(r))) {
+      const sous = PAR_COPIE.get(f);
+      sortie.push({
+        aFaire: `package.json : le script ${n} lance ${f}, copie modifiée laissée en place ; son \`git rm\` le casse : ${sous ? `\`grillhouse ${sous}\` le remplace` : 'à réécrire'}`,
+      });
+    }
+  }
+  if (reecrit) writeFileSync(fPkg, `${JSON.stringify(pkg, null, 2)}\n`);
+
+  const duPaquet = Object.keys(lireJson(path.join(PAQUET, 'package.json')).dependencies ?? {});
+  const gabarit = lireJson(path.join(CADRE, GABARIT, 'package.json'));
+  const textes = sources(projet).map(f => readFileSync(path.join(projet, f), 'utf8'));
+  for (const dep of duPaquet) {
+    if (!CHAMPS.some(c => pkg[c]?.[dep] !== undefined)) continue;
+    if (CHAMPS.some(c => gabarit[c]?.[dep] !== undefined)) continue;
+    if (![...retires.values()].some(t => importe(t, dep))) continue;
+    if (textes.some(t => importe(t, dep))) continue;
+    sortie.push(
+      `package.json : la dépendance ${dep} n'est plus importée que par le paquet, qui la déclare lui-même ; \`npm uninstall ${dep}\` la retire si le projet n'en a pas l'usage`
+    );
+  }
+  return sortie;
+}

package/scripts/migrations/0.24.0-circuit-simplifie.mjs

@@ -0,0 +1,231 @@
+// The circuit of 0.24.0 has no regulator and no technical referent: the circuit makes the mechanical
+// gestures, and any other question goes up to the supervisor with its piece, who takes to the owner
+// what is his. What a project holds of the former circuit is rewritten here, as a codemod of
+// `@turbo/codemod` rewrites what a version changes, and nothing else.
+//
+// - The rubric « Ce qui monte au superviseur » of the project's CLAUDE.md: the paragraph of the
+//   template of 0.22.x and 0.23.x (« Le fonctionnel que le régulateur ne tranche jamais seul : <la
+//   liste>. Le cadre et l'architecture montent toujours (charte commune). »), its list as the
+//   project filled it, becomes the paragraph of the template of 0.24.0, the list kept, wrapped at
+//   100 columns; the rest of the rubric stays. A rubric the project wrote itself that still names
+//   a removed role is left to the project (`{ aFaire }`); one that names none is left silently.
+// - `docs/agents/issue-tracker.md`, the project's own since 0.23.0 (`grillhouse init` places it):
+//   a file whose bytes are those of the template of 0.21.0 to 0.22.x, or of 0.23.x (their SHA-256
+//   in FORMES), becomes the template's; a file the project modified that names a removed role is
+//   left to the project.
+// - A copy of a removed role (`.claude/agents/<rôle>.md`, `.claude/skills/<rôle>/`) still in the
+//   project is one the migration of the copies (0.23.2-copies-du-cadre.mjs, played before) could
+//   not know as the frame's: the project modified it, or no list named it. It is left to the
+//   project, with the command that removes it; the migration of the copies leaves it to this one
+//   (deRoleSupprime), so that it is named once.
+// - What stays to the project (`restes`, which the update plays after its own update and its
+//   regeneration, so that it sees the final state): a tracked file of the project (`git ls-files`,
+//   node_modules and the changelogs aside) that still calls or names a script of the frame at its former address under `scripts/`
+//   (`node scripts/<script>`, `$RACINE/scripts/<script>`, `path.join(…, 'scripts', '<script>')`;
+//   a tracked path that is no regular file, a submodule or a link, is skipped),
+//   where the project holds no such file any more, is named with its file:line and what replaces
+//   it: the subcommand (`SOUS_COMMANDES` of scripts/sous-commandes.mjs), the hook
+//   (`grillhouse hook <nom>`, `CROCHETS` of scripts/crochets.mjs) or the named entry (the
+//   `exports` of the package). The project's scripts are its own: none is rewritten, and the
+//   lines are a report, which never holds back the version the project records, as a codemod
+//   reports what it leaves without failing.
+// - No version of the update wrote a setting of a role in `.claude/settings.json` or under
+//   `grillhouse` of the package.json (the update of 0.22.x wrote the hooks, the status line and the
+//   plugins; the rights of a role are given on the command line of its session, scripts/droits.mjs):
+//   the migration writes neither.
+// - A project already in the new form is not written, and a second pass reports only what it left
+//   to the project.
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, lstatSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { CADRE, PAQUET } from '../cadre.mjs';
+import { CROCHETS } from '../crochets.mjs';
+import { SOUS_COMMANDES } from '../sous-commandes.mjs';
+
+export const version = '0.24.0';
+export const nom = 'circuit simplifié';
+
+const SUPPRIMES = ['regulateur', 'referent-technique'];
+
+/** Whether <f>, a path from a project's root, is in a copy of a removed role, which this migration names. */
+export const deRoleSupprime = f =>
+  SUPPRIMES.some(r => f === `.claude/agents/${r}.md` || f.startsWith(`.claude/skills/${r}/`));
+// A removed role named in a text, in its words or by its name.
+const NOMME_UN_SUPPRIME = /r[ée]gulat(?:eur|rice)|referent-technique|r[ée]f[ée]rents? techniques?/i;
+
+const RUBRIQUE = 'Ce qui monte au superviseur';
+// The section of the rubric, its title line apart, up to the next section or the end.
+const SECTION = new RegExp(`^(## ${RUBRIQUE}[ \\t]*\\n)([^]*?)(?=^## |(?![^]))`, 'm');
+// The paragraph of the former template, its list captured, as a paragraph of its own.
+const ANCIEN =
+  /(^\n*|\n\n)Le\s+fonctionnel\s+que\s+le\s+régulateur\s+ne\s+tranche\s+jamais\s+seul\s+:\s+([^]*?)\.\s+Le\s+cadre\s+et\s+l'architecture\s+montent\s+toujours\s+\(charte\s+commune\)\.(?=\n\n|\n?$)/;
+const NEUF = liste =>
+  `Une question qu'aucun geste du circuit ne tranche monte au superviseur, avec sa pièce. Il monte au responsable le fonctionnel, qu'il ne tranche jamais seul : ${liste}. Le cadre et l'architecture montent toujours (charte commune).`;
+const COLONNES = 100;
+
+const SUIVI = 'docs/agents/issue-tracker.md';
+// The SHA-256 of the guide of the issue tracker as the template held it: 0.21.0 to 0.22.6 (the
+// copy the update placed), 0.23.0 and 0.23.1 (the template `grillhouse init` places).
+const FORMES = new Set([
+  '2b7c70b22001c83009887372f2bc5b04509e8e4dbc14f1e647df2c686b0ba5e0',
+  'a6d6e9ecbb75b82dad9c6adadd310fe1047c4a5f83d4d789718cd921eda6b258',
+]);
+
+const hacher = octets => createHash('sha256').update(octets).digest('hex');
+
+// The words of <texte> in lines of at most COLONNES characters.
+function replier(texte) {
+  const lignes = [];
+  for (const mot of texte.split(/\s+/).filter(Boolean)) {
+    const l = lignes.length - 1;
+    if (l >= 0 && lignes[l].length + 1 + mot.length <= COLONNES) {
+      lignes[l] += ` ${mot}`;
+    } else {
+      lignes.push(mot);
+    }
+  }
+  return lignes.join('\n');
+}
+
+// The rubric of the CLAUDE.md of <projet>.
+function rubrique(projet) {
+  const fichier = path.join(projet, 'CLAUDE.md');
+  if (!existsSync(fichier)) {
+    return [];
+  }
+  const texte = readFileSync(fichier, 'utf8');
+  const s = SECTION.exec(texte);
+  if (!s) {
+    return [];
+  }
+  const [tout, titre, corps] = s;
+  if (ANCIEN.test(corps)) {
+    const neuf = corps.replace(ANCIEN, (_, avant, liste) => `${avant}${replier(NEUF(liste))}`);
+    writeFileSync(
+      fichier,
+      texte.replace(tout, () => `${titre}${neuf}`)
+    );
+    return [
+      `CLAUDE.md : la rubrique « ${RUBRIQUE} » dit le circuit de la 0.24.0 (une question qu'aucun geste ne tranche monte au superviseur, avec sa pièce), sa liste gardée`,
+    ];
+  }
+  if (!NOMME_UN_SUPPRIME.test(corps)) {
+    return [];
+  }
+  return [
+    {
+      aFaire: `CLAUDE.md : la rubrique « ${RUBRIQUE} », que le projet a écrite, nomme un rôle que la 0.24.0 supprime (le régulateur ou le référent technique) ; à réécrire : une question qu'aucun geste du circuit ne tranche monte au superviseur, avec sa pièce, et il monte au responsable ce que la rubrique nomme`,
+    },
+  ];
+}
+
+// The guide of the issue tracker of <projet>.
+function suivi(projet) {
+  const fichier = path.join(projet, SUIVI);
+  if (!existsSync(fichier)) {
+    return [];
+  }
+  const octets = readFileSync(fichier);
+  if (FORMES.has(hacher(octets))) {
+    writeFileSync(fichier, readFileSync(path.join(CADRE, 'templates/projet', SUIVI)));
+    return [`${SUIVI} : le guide du gabarit, qui dit le circuit de la 0.24.0`];
+  }
+  if (!NOMME_UN_SUPPRIME.test(octets.toString('utf8'))) {
+    return [];
+  }
+  return [
+    {
+      aFaire: `${SUIVI} : modifié par le projet, il nomme un rôle que la 0.24.0 supprime ; le gabarit du paquet (templates/projet/${SUIVI}) dit le circuit neuf`,
+    },
+  ];
+}
+
+// The copies of the removed roles left in <projet>.
+function copies(projet) {
+  return SUPPRIMES.flatMap(r => [
+    { f: `.claude/agents/${r}.md`, rm: 'git rm' },
+    { f: `.claude/skills/${r}`, rm: 'git rm -r' },
+  ])
+    .filter(({ f }) => existsSync(path.join(projet, f)))
+    .map(({ f, rm }) => ({
+      aFaire: `${f} : copie d'un rôle que la 0.24.0 supprime (le circuit ne le lance plus), laissée en place ; \`${rm} ${f}\` la retire`,
+    }));
+}
+
+// What replaces each script of the frame, by its path under `scripts/`: its subcommand, its hook,
+// its named entry.
+function remplacants() {
+  const r = new Map();
+  const ajouter = (script, quoi) => r.set(script, [...(r.get(script) ?? []), quoi]);
+  for (const [n, s] of Object.entries(SOUS_COMMANDES)) {
+    ajouter(s, `\`grillhouse ${n}\``);
+  }
+  for (const [n, c] of Object.entries(CROCHETS)) {
+    ajouter(c.garde, `\`grillhouse hook ${n}\``);
+  }
+  const { exports = {} } = JSON.parse(readFileSync(path.join(PAQUET, 'package.json'), 'utf8'));
+  for (const [entree, cible] of Object.entries(exports)) {
+    const d = typeof cible === 'string' ? cible : cible?.default;
+    if (typeof d === 'string' && d.startsWith('./scripts/')) {
+      ajouter(d.slice('./scripts/'.length), `\`@roomi-fields/grillhouse${entree.slice(1)}\``);
+    }
+  }
+  return r;
+}
+// A script named at its former address: `scripts/<chemin>`, alone or after `./` or `$VAR/`.
+const ADRESSE = /(?<![\w./-])(?:\.\/|\$\{?\w+\}?\/)?scripts\/([\w./-]+?\.(?:mjs|sh))(?![\w.-])/g;
+// The same, as the segments of a path.join: `'scripts', 'dette.mjs'`.
+const SEGMENTS = /(['"])scripts\1((?:\s*,\s*(['"])[\w.-]+\3)+)/g;
+const SANS = /(^|\/)(?:node_modules\/|CHANGELOG\.md$)/;
+
+/** The lines of the tracked files of <projet> that still reach a script of the frame at its former address. */
+export function restes(projet) {
+  let suivis;
+  try {
+    suivis = execFileSync('git', ['-C', projet, 'ls-files', '-z'], { encoding: 'utf8' })
+      .split('\0')
+      .filter(f => f && !SANS.test(f));
+  } catch {
+    return [];
+  }
+  const par = remplacants();
+  const sortie = [];
+  for (const f of suivis) {
+    const absolu = path.join(projet, f);
+    // A submodule, a link, a file gone from the disk: no text of the project to read.
+    if (!existsSync(absolu) || !lstatSync(absolu).isFile()) {
+      continue;
+    }
+    const texte = readFileSync(absolu, 'utf8');
+    if (texte.includes('\0')) {
+      continue;
+    }
+    texte.split('\n').forEach((ligne, i) => {
+      const scripts = [
+        ...[...ligne.matchAll(ADRESSE)].map(m => m[1]),
+        ...[...ligne.matchAll(SEGMENTS)].map(m =>
+          m[2]
+            .split(',')
+            .map(s => s.trim().slice(1, -1))
+            .filter(Boolean)
+            .join('/')
+        ),
+      ];
+      for (const s of new Set(scripts)) {
+        if (!par.has(s) || existsSync(path.join(projet, 'scripts', s))) {
+          continue;
+        }
+        sortie.push(
+          `${f}:${i + 1} : appelle scripts/${s}, copie du cadre retirée ; ${par.get(s).join(' ou ')} la remplace`
+        );
+      }
+    });
+  }
+  return sortie;
+}
+
+/** Rewrites in the project at <projet> what the circuit of 0.24.0 changes; returns what it did. */
+export function migrer(projet) {
+  return [...rubrique(projet), ...suivi(projet), ...copies(projet)];
+}