@roomi-fields/grillhouse 0.23.1 → 0.24.1

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,274 @@
+// 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>`, `file://$1/scripts/<script>`,
+//   `path.join(…, '..', 'scripts', '<dossier>', '<script>')`, found by its words, sousScripts; a
+//   `scripts/` under a literal directory, a package of the project or the installed package, is
+//   another's, `.` and `..` naming none; 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). A script of the package that has none of them is named with « aucune
+//   entrée publiée ne la remplace ». 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, readdirSync, 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; none for a script of the package that has none of them.
+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 { name, 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), `\`${name}${entree.slice(1)}\``);
+    }
+  }
+  const scripts = path.join(PAQUET, 'scripts');
+  for (const e of readdirSync(scripts, { recursive: true, withFileTypes: true })) {
+    const s = path.relative(scripts, path.join(e.parentPath, e.name)).split(path.sep).join('/');
+    if (e.isFile() && SCRIPT.test(s) && !r.has(s)) {
+      r.set(s, []);
+    }
+  }
+  return r;
+}
+const SCRIPT = /\.(?:mjs|sh)$/;
+const SANS = /(^|\/)(?:node_modules\/|CHANGELOG\.md$)/;
+// What separates the words of a line, and the arguments of a call.
+const BLANCS = /[\s'"`();|&<>=,]+/;
+const APPELS = /[();]/;
+const cite = a => a.length >= 2 && /^['"`]$/.test(a[0]) && a.at(-1) === a[0];
+// Whether a piece of a path names a directory: `.` and `..` name none, only a step.
+const dossier = m => m !== '.' && m !== '..';
+
+// The paths under `scripts/` that the line <ligne> names at a project's root, each as its pieces
+// after `scripts`: a word cut at its `/` (`scripts/x.mjs`, `./scripts/x.mjs`, `../scripts/x.mjs`,
+// `$RACINE/scripts/x.mjs`, `file://$1/scripts/x.mjs`), whose piece before `scripts` is none, a
+// step (`.`, `..`) or a variable; the arguments of a call (`path.join(RACINE, 'scripts', 'd',
+// 'x.mjs')`, `path.join(dir, '..', 'scripts', 'x.mjs')`), whose argument before `'scripts'` is
+// none, no literal or a step, the literals after it its pieces. A `scripts/` under a literal
+// directory (`packages/a/scripts/`, the installed package) is another's.
+function sousScripts(ligne) {
+  const chemins = [];
+  for (const mot of ligne.split(BLANCS)) {
+    const p = mot.split('/');
+    p.forEach((m, i) => {
+      if (m === 'scripts' && (i === 0 || !dossier(p[i - 1]) || p[i - 1].startsWith('$'))) {
+        chemins.push(p.slice(i + 1));
+      }
+    });
+  }
+  for (const appel of ligne.split(APPELS)) {
+    const a = appel.split(',').map(x => x.trim());
+    a.forEach((x, i) => {
+      const avant = a[i - 1];
+      const libre = i === 0 || !cite(avant) || !dossier(avant.slice(1, -1));
+      if (cite(x) && x.slice(1, -1) === 'scripts' && libre) {
+        const suite = a.slice(i + 1);
+        const fin = suite.findIndex(y => !cite(y));
+        chemins.push(suite.slice(0, fin === -1 ? suite.length : fin).map(y => y.slice(1, -1)));
+      }
+    });
+  }
+  return chemins;
+}
+
+/** 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 = sousScripts(ligne).flatMap(pieces =>
+        pieces.map((_, n) => pieces.slice(0, n + 1).join('/')).filter(s => par.has(s))
+      );
+      for (const s of new Set(scripts)) {
+        const quoi = par.get(s);
+        if (existsSync(path.join(projet, 'scripts', s))) {
+          continue;
+        }
+        const suite =
+          quoi.length > 0
+            ? `${quoi.join(' ou ')} la remplace`
+            : 'aucune entrée publiée ne la remplace';
+        sortie.push(`${f}:${i + 1} : appelle scripts/${s}, copie du cadre retirée ; ${suite}`);
+      }
+    });
+  }
+  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)];
+}

package/scripts/migrations.mjs

@@ -4,21 +4,37 @@
 //
 // - A migration exports `version` (the version of the package that brings the change of form),
 //   `nom` and `migrer(projet)`, which brings the project at <projet> to the new form and returns
-//   the lines of what it changed: none when the project already has it. It is replayable without
-//   effect: a second pass changes no byte and returns no line.
+//   the lines of what it changed: none when the project already has it. A line `{ aFaire }` is
+//   what it leaves to the project (a copy of the frame the project modified), which the update
+//   writes on its error stream, its exit code non-zero, as `@turbo/codemod` fails on a file it
+//   could not transform. It is replayable without effect: a second pass changes no byte and
+//   returns no line.
 // - MIGRATIONS lists them, each imported by its module; the update plays those newer than the
 //   version the project recorded (`grillhouse.version` of its package.json), in the order of their
 //   versions; a project that recorded none plays them all. The package carries no migration newer
 //   than itself once released, so the range ends with the package.
+// - A migration may also export `restes(projet)`: the lines of what stays to the project once the
+//   update is done, which the update plays after its own update and its regeneration, for each
+//   migration it played, and reports (« reste au projet ») without holding back the version, as a
+//   codemod reports what it leaves without failing (restesAuProjet).
 // - Each migration has its test, tests/unit/migration.<nom>.spec.ts.
 import semver from 'semver';
 import * as charteImportee from './migrations/0.23.0-charte-importee.mjs';
 import * as configVitest from './migrations/0.23.0-config-vitest.mjs';
 import * as crochetsDeSeance from './migrations/0.23.0-crochets-de-seance.mjs';
 import * as marcheDuProjet from './migrations/0.23.0-marche-du-projet.mjs';
+import * as copiesDuCadre from './migrations/0.23.2-copies-du-cadre.mjs';
+import * as circuitSimplifie from './migrations/0.24.0-circuit-simplifie.mjs';
 
 /** The migrations of the package. */
-export const MIGRATIONS = [crochetsDeSeance, configVitest, marcheDuProjet, charteImportee];
+export const MIGRATIONS = [
+  crochetsDeSeance,
+  configVitest,
+  marcheDuProjet,
+  charteImportee,
+  copiesDuCadre,
+  circuitSimplifie,
+];
 
 /**
  * The migrations of <liste> newer than <depuis> (all of them when it is null), in the order of
@@ -32,12 +48,31 @@ export function migrationsAJouer(depuis, liste = MIGRATIONS) {
     .map(({ m }) => m);
 }
 
+/**
+ * What stays to the project at <projet> after the update, for each migration newer than <depuis>
+ * that exports `restes` and names something: `{ version, nom, lignes }`.
+ */
+export function restesAuProjet(projet, depuis, liste = MIGRATIONS) {
+  return migrationsAJouer(depuis, liste)
+    .filter(m => typeof m.restes === 'function')
+    .map(m => ({ version: m.version, nom: m.nom, lignes: m.restes(projet) }))
+    .filter(r => r.lignes.length > 0);
+}
+
 /**
  * Plays on the project at <projet> each migration newer than <depuis>; returns, for each one that
- * changed something, `{ version, nom, lignes }`.
+ * changed something or left something to do, `{ version, nom, lignes, aFaire }`.
  */
 export function migrer(projet, depuis, liste = MIGRATIONS) {
   return migrationsAJouer(depuis, liste)
-    .map(m => ({ version: m.version, nom: m.nom, lignes: m.migrer(projet) }))
-    .filter(r => r.lignes.length > 0);
+    .map(m => {
+      const tout = m.migrer(projet);
+      return {
+        version: m.version,
+        nom: m.nom,
+        lignes: tout.filter(l => typeof l === 'string'),
+        aFaire: tout.filter(l => typeof l !== 'string').map(l => l.aFaire),
+      };
+    })
+    .filter(r => r.lignes.length > 0 || r.aFaire.length > 0);
 }

package/scripts/paquets.d.ts

@@ -0,0 +1,5 @@
+// The types of ./paquets.mjs as the entry `@roomi-fields/grillhouse/paquets` publishes it, for a
+// project's guard that leaves out the packages out of the frame.
+
+/** The names listed in `racine`'s `docs/agents/hors-cadre.txt`: empty without the file. */
+export function horsCadre(racine: string): Set<string>;

package/scripts/paquets.mjs

@@ -12,6 +12,9 @@
 //
 // This module and the ones it imports use Node alone: the update runs them from a source checkout
 // of the frame that installs no dependency.
+//
+// A project's guard imports `horsCadre` by the package's entry `@roomi-fields/grillhouse/paquets`,
+// its types in ./paquets.d.ts (docs/ARCHITECTURE.md, the package's named entries).
 import { existsSync, globSync, readFileSync } from 'node:fs';
 import path from 'node:path';