@roomi-fields/grillhouse 0.0.0-stage → 0.23.0

package/scripts/retirer-copie.sh

@@ -0,0 +1,127 @@
+#!/usr/bin/env bash
+# The removal of a working copy, called by the three places that end one: the agent copy (by
+# scripts/integration/integrer.mjs once its lot is committed, and by the supervisor for a ticket
+# closed without integration), the integration copy (by the same script) and the night copy
+# (scripts/nuit.sh), the last two when their existing copy does not get ready.
+#
+#   npx grillhouse retirer-copie [--jetable] [--garder-travail] <copie>
+#
+# - The copy is a path read from the current directory, as git reads it, and must be a copy that
+#   `git worktree list` names for the repository of the current directory: the main working tree,
+#   an absent path, a plain folder or a submodule's folder is refused, nothing touched.
+# - A copy that carries a submodule is removed too: `git worktree remove` refuses it, so the
+#   script reads the copy first, then removes it with `git worktree remove --force`. Only the named
+#   copy goes, with the link to a shared submodule (`grillhouse.partage`); the main repository and
+#   its submodules (.git/modules) stay as they are.
+# - Without `--jetable`, the reading stands in for what `--force` would erase: a copy that carries
+#   local work (a modified tracked file, an untracked file outside the ignored ones, a submodule
+#   modified or at another commit, read by `git status --ignore-submodules=none`, whatever the
+#   project's `submodule.<name>.ignore` or `diff.ignoreSubmodules`), or whose state does not read,
+#   is refused, and stays in place intact. Local work that has entered the branch `main` loses
+#   nothing and does not hold the copy: each file of the work (its deletion, or its submodule at a
+#   commit with no work in it) holds the content and the mode that a commit of `main` after the
+#   copy's base gave that path; a content `main` held before the base is not work that entered. The
+#   refusal names the work that has not entered. The agent copy's removal passes no option.
+# - With `--jetable`, passed only by the integration and the night for their own copy, local work
+#   and an unreadable state do not hold the removal.
+# - A locked copy (`git worktree lock`) is refused in every case.
+# - The copy removed, the working directory of its ticket's circuit, `<copie>.travail` beside it
+#   (scripts/circuit.mjs), goes with it, as the workspace of a pipeline goes at its end: a ticket
+#   closed without integration (a final stop, an abandon) loses both by this one command. With
+#   `--garder-travail`, passed only by the integration, it stays: the circuit still runs, and the
+#   queue removes it at the ticket's closure (scripts/integration/file.mjs). A copy refused keeps
+#   it.
+# - Exit 0 removed, 1 refused (the first line on stderr names the copy and what holds it), 2 a
+#   malformed call (the usage on stderr).
+set -uo pipefail
+jetable=0
+garder=0
+while [ $# -gt 0 ]; do
+  case $1 in
+    --jetable) jetable=1 ;;
+    --garder-travail) garder=1 ;;
+    *) break ;;
+  esac
+  shift
+done
+[ $# -eq 1 ] && [ "${1#-}" = "$1" ] || {
+  echo "usage: retirer-copie.sh [--jetable] [--garder-travail] <copie>" >&2
+  exit 2
+}
+copie=$1
+
+refuser() {
+  echo "$1" >&2
+  shift
+  [ $# -eq 0 ] || echo "$*" >&2
+  exit 1
+}
+
+[ -n "$copie" ] && [ -d "$copie" ] || refuser "la copie $copie n'existe pas : rien n'est retiré."
+chemin=$(cd "$copie" && pwd -P) || refuser "la copie $copie ne se lit pas : rien n'est retiré."
+liste=$(git worktree list --porcelain 2>&1) ||
+  refuser "la liste des copies ne se lit pas pour retirer $copie : rien n'est retiré." "$liste"
+
+# The list is one block per copy, separated by a blank line: the first block is the main working
+# tree, never removable; a `locked` line marks a locked copy. `trouvee` is the verdict of the block
+# of the copy, printed once (`dit`: `exit` runs the END rule, which must not read the same block
+# again).
+trouvee=$(printf '%s\n' "$liste" | awk -v cible="$chemin" '
+  function fin() {
+    if (n > 1 && dossier != "") {
+      cmd = "cd \"" dossier "\" 2>/dev/null && pwd -P"
+      cmd | getline reel; close(cmd)
+      if (reel == cible) { print (verrou ? "verrouillee" : "libre"); dit = 1; exit }
+    }
+  }
+  /^worktree / { fin(); n++; dossier = substr($0, 10); verrou = 0; reel = ""; next }
+  /^locked/ { verrou = 1 }
+  END { if (!dit) fin() }
+')
+[ -n "$trouvee" ] || refuser "$copie n'est pas une copie inscrite de ce dépôt (git worktree list) : rien n'est retiré."
+[ "$trouvee" != verrouillee ] || refuser "la copie $copie est verrouillée (git worktree lock) : elle n'est pas retirée."
+
+# Whether the work at path $1 of the copy has entered `main`: what the copy holds there (a file's
+# blob and mode, a submodule's commit once its own state is clean, zeros for a deleted path) is
+# what a commit of `main` after the copy's base (`HEAD..refs/heads/main` in the copy) gave that
+# path, mode included, as git judges a branch already merged.
+est_entre() {
+  local p=$1 id mode
+  if [ -e "$chemin/$p/.git" ]; then
+    [ -z "$(git -C "$chemin/$p" status --porcelain --ignore-submodules=none 2>/dev/null)" ] ||
+      return 1
+    id=$(git -C "$chemin/$p" rev-parse HEAD 2>/dev/null) || return 1
+    mode=160000
+  elif [ -L "$chemin/$p" ]; then
+    id=$(git -C "$chemin" hash-object --no-filters -- "$p" 2>/dev/null) || return 1
+    mode=120000
+  elif [ -e "$chemin/$p" ]; then
+    id=$(git -C "$chemin" hash-object -- "$p" 2>/dev/null) || return 1
+    if [ -x "$chemin/$p" ]; then mode=100755; else mode=100644; fi
+  else
+    id=0
+    mode=000000
+  fi
+  git -C "$chemin" log HEAD..refs/heads/main --no-renames --format= --raw --no-abbrev -- "$p" \
+    2>/dev/null |
+    awk -v id="$id" -v mode="$mode" '
+      $2 == mode && ($4 == id || (id == 0 && $4 ~ /^0+$/)) { ok = 1 }
+      END { exit !ok }'
+}
+
+if [ "$jetable" -eq 0 ]; then
+  etat=$(git -C "$chemin" status --porcelain -z -uall --no-renames --ignore-submodules=none 2>&1 |
+    tr '\0' '\n') ||
+    refuser "l'état de la copie $copie ne se lit pas : elle n'est pas retirée." "$etat"
+  restant=
+  while IFS= read -r ligne; do
+    [ -n "$ligne" ] || continue
+    est_entre "${ligne:3}" || restant+="${restant:+$'\n'}$ligne"
+  done <<<"$etat"
+  [ -z "$restant" ] ||
+    refuser "la copie $copie porte du travail local : elle n'est pas retirée." "$restant"
+fi
+
+sortie=$(git worktree remove --force "$chemin" 2>&1) ||
+  refuser "la copie $copie ne se retire pas :" "$sortie"
+[ "$garder" -eq 1 ] || rm -rf -- "$chemin.travail"

package/scripts/session-start.sh

@@ -0,0 +1,203 @@
+#!/usr/bin/env bash
+# SessionStart hook: tells the session what the project still lacks before work can start.
+# Silent once the project is set up and initialised. It changes nothing, save the lock of the
+# supervisor below.
+#
+# The project's own check: `grillhouse.demarrage` in the package.json of the root names an npm
+# script (`npm pkg set grillhouse.demarrage=<script>`). The session start plays
+# `npm run --silent <script>` at the root; each non-blank line it writes joins the list « Pas encore
+# renseignés », as an item to deal with. The script has 10 s: past them its whole process group is
+# stopped. A failure (non-zero code) or a stop adds a line that says so, after the lines already
+# written; the session start goes on. Without the key (or with null), nothing runs; a value that is
+# not a non-blank string runs nothing and adds a line that says so. An agent's copy does not play it.
+#
+# The frame's plugins: scripts/greffons.mjs --absents reads `.claude/settings.json` and
+# `claude plugin list --json` (each call stopped after 5 s). Each declared plugin not installed for
+# the project joins « Manque » as « le greffon <id> », the missing claude command as « la commande
+# claude » (the line gives `npx grillhouse maj`, which installs them), and a reading that fails
+# or is stopped as « la lecture des greffons … ». The same reading names the frame's mod installed
+# for the project at another version than the package @roomi-fields/grillhouse, both released under
+# one version, with the command that aligns the one behind. An agent's copy does not read them.
+#
+# One supervisor per project (scripts/superviseur.mjs): the session takes the lock of its
+# repository; a second session, while the first one lives, receives first the section « Un autre
+# superviseur tient ce dépôt », which asks it to say so to the owner and to launch no circuit. An
+# agent's copy and a session of a role the circuit launches take nothing and receive nothing.
+#
+# A session of a role agent of the frame (`claude --agent <rôle>`, the circuit's sessions: the
+# hook's input names it, `agent_type`, bare or as `grillhouse:<rôle>`, and the frame's plugin
+# defines it, `$CLAUDE_PLUGIN_ROOT/agents/<rôle>.md`, the plugin whose hook runs this script) receives nothing:
+# what the project lacks is the supervisor's to deal with, and in an envelope the documents of the
+# hidden packages read as absent.
+set -uo pipefail
+
+# The project is Claude Code's, else the working directory; the frame's scripts are this one's
+# neighbours.
+root="${CLAUDE_PROJECT_DIR:-$PWD}"
+ici="$(cd "$(dirname "$0")" && pwd)"
+entree=
+[ -t 0 ] || entree="$(cat)"
+role="$(printf '%s' "$entree" | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{const a=JSON.parse(s).agent_type;if(typeof a==="string"&&/^[A-Za-z0-9_:-]+$/.test(a))process.stdout.write(a)}catch{}})' 2>/dev/null)"
+role="${role#grillhouse:}"
+[ -n "$role" ] && [ -n "${CLAUDE_PLUGIN_ROOT:-}" ] && [ -f "$CLAUDE_PLUGIN_ROOT/agents/$role.md" ] && exit 0
+if [ -f "$root/.claude/template" ]; then
+  echo "## Gabarit Roomi's Grillhouse"
+  echo "Ce dossier est le gabarit du framework, pas un projet : il ne s'initialise pas. Un projet neuf se crée par \`npx @roomi-fields/grillhouse init <chemin> [préfixe]\` ; sa première séance propose le grill d'initialisation."
+  exit 0
+fi
+
+# One supervisor per project: the lock of the repository, or the section that says who holds it.
+superviseur="$(node "$ici/superviseur.mjs" "$root" 2>/dev/null)"
+[ -z "$superviseur" ] || echo "$superviseur"
+
+missing=()
+
+command -v bd >/dev/null || missing+=("l'outil de tickets bd (Beads : \`npm install -g @beads/bd\`)")
+[ -d "$root/.beads" ] || missing+=("le magasin de tickets (Beads : \`bd init\`)")
+# The index of CodeGraph is for the roles that see the whole repository: an agent's copy (a git
+# worktree under .claude/worktrees/) is asked for neither the tool nor the index.
+copie_agent=
+case "$root" in
+  */.claude/worktrees/*)
+    [ "$(git -C "$root" rev-parse --git-dir 2>/dev/null)" != "$(git -C "$root" rev-parse --git-common-dir 2>/dev/null)" ] && copie_agent=1
+    ;;
+esac
+if [ -z "$copie_agent" ]; then
+  command -v codegraph >/dev/null || missing+=("l'outil CodeGraph (\`npm install -g @colbymchenry/codegraph\`)")
+  [ -d "$root/.codegraph" ] || missing+=("l'index CodeGraph du code (\`codegraph init .\`)")
+fi
+[ ! -f "$root/package.json" ] || [ -d "$root/node_modules" ] || missing+=("les dépendances npm (\`npm install\`)")
+# The frame's plugins not installed for the project (scripts/greffons.mjs): the plugins are the
+# machine's installation for the project, so an agent's copy does not read them.
+if [ -z "$copie_agent" ]; then
+  while IFS= read -r ligne; do
+    case "$ligne" in
+      claude) missing+=("la commande claude") ;;
+      "greffon "*) missing+=("le greffon ${ligne#greffon }") ;;
+      "lecture "*) missing+=("la lecture des greffons : ${ligne#lecture }") ;;
+      "ecart "*)
+        read -r _ e_id e_greffon e_paquet e_commande <<< "$ligne"
+        ecart_versions="Le greffon $e_id est en $e_greffon, le paquet @roomi-fields/grillhouse en $e_paquet : les deux sortent ensemble, sous une même version. Aligne-les : \`$e_commande\`."
+        ;;
+    esac
+  done < <(timeout -k 1 8 node "$ici/greffons.mjs" --absents "$root" 2>/dev/null)
+fi
+# The frame's git hooks absent from the folder git reads (scripts/crochets.mjs), each named.
+while IFS= read -r crochet; do
+  [ -n "$crochet" ] && missing+=("le crochet git $crochet du cadre")
+done < <(node "$ici/crochets.mjs" --absents "$root" 2>/dev/null)
+command -v bwrap >/dev/null || missing+=("bubblewrap (bwrap), l'enveloppe des agents : sudo apt install bubblewrap")
+
+# The key elements the skills read; each one still empty is proposed for a grill.
+pending=()
+charter="$root/CLAUDE.md"
+if [ ! -f "$charter" ]; then
+  pending+=("la charte (CLAUDE.md)")
+else
+  # an unfilled field of the charter template: <…> outside code spans
+  node -e 'const t=require("fs").readFileSync(process.argv[1],"utf8").replace(/`[^`]*`/g,"");process.exit(/<[^<>\n]+>/.test(t)?0:1)' "$charter" \
+    && pending+=("les champs <…> encore vides de la charte (CLAUDE.md)")
+  # the arbitration criteria: a heading about arbitration in the charter or a reference document
+  grep -qiE '^#+ .*(arbitr)' "$charter" "$root"/docs/*.md 2>/dev/null \
+    || pending+=("les critères d'arbitrage (section « Comment on arbitre » de CLAUDE.md : la référence mature du domaine, l'existant à reprendre, les exigences du domaine)")
+fi
+# The packages out of the frame: docs/agents/hors-cadre.txt ("<package> <reason>", e.g. a frozen
+# version), read by scripts/paquets.mjs as every check reads it; Turborepo plays none of
+# its tasks (scripts/turbo-des-paquets.mjs). Line 1: the names listed;
+# line 2: the names that no directory under packages/ or src/ bears.
+{ read -r hors; read -r inconnus; } < <(node --input-type=module -e '
+const { pathToFileURL } = await import("node:url");
+const { horsCadre } = await import(pathToFileURL(process.argv[1]).href);
+const { horsCadreInconnus } = await import(pathToFileURL(process.argv[2]).href);
+process.stdout.write(`${[...horsCadre(process.argv[3])].join(" ")}\n${horsCadreInconnus(process.argv[3]).join(" ")}\n`);
+' "$ici/paquets.mjs" "$ici/consommateurs.mjs" "$root" 2>/dev/null)
+# One package: docs/ at the root. Several: each package under packages/ has its own three documents,
+# unless it is out of the frame.
+if ls -d "$root"/packages/*/ >/dev/null 2>&1; then
+  for pkg in "$root"/packages/*/; do
+    name="$(basename "$pkg")"
+    case " ${hors:-} " in *" $name "*) continue ;; esac
+    for doc in ARCHITECTURE CADRE INTERFACE; do
+      [ -f "$pkg/docs/$doc.md" ] || pending+=("packages/$name/docs/$doc.md")
+    done
+  done
+else
+  for doc in ARCHITECTURE CADRE INTERFACE; do
+    [ -f "$root/docs/$doc.md" ] || pending+=("docs/$doc.md")
+  done
+fi
+[ -f "$root/CONTEXT.md" ] || pending+=("le lexique du domaine (CONTEXT.md)")
+
+# The project's own check (grillhouse.demarrage, described in the header), outside an agent's copy.
+# The reading gives « script<TAB>name », « invalide<TAB>value as JSON », or nothing.
+lecture=
+[ -n "$copie_agent" ] || lecture="$(node -e '
+  const v = require(process.argv[1]).grillhouse?.demarrage;
+  if (v == null) process.exit(0);
+  if (typeof v === "string" && v.trim()) process.stdout.write("script\t" + v);
+  else process.stdout.write("invalide\t" + JSON.stringify(v));
+' "$root/package.json" 2>/dev/null)"
+demarrage=
+case "$lecture" in
+  script$'\t'*) demarrage="${lecture#script$'\t'}" ;;
+  invalide$'\t'*) pending+=("la clé grillhouse.demarrage vaut ${lecture#invalide$'\t'}, pas un nom de script npm : rien n'est lancé") ;;
+esac
+if [ -n "$demarrage" ]; then
+  # timeout signals the script's whole process group, so a child that keeps the output open stops too.
+  sortie="$(cd "$root" && timeout -k 2 10 npm run --silent "$demarrage" 2>/dev/null)"
+  code=$?
+  while IFS= read -r ligne; do
+    ligne="${ligne%$'\r'}"
+    [ -n "${ligne//[[:space:]]/}" ] && pending+=("$ligne")
+  done <<< "$sortie"
+  if [ "$code" -eq 124 ] || [ "$code" -eq 137 ]; then
+    pending+=("le contrôle d'ouverture \`npm run $demarrage\` (grillhouse.demarrage) a été interrompu après 10 s")
+  elif [ "$code" -ne 0 ]; then
+    pending+=("le contrôle d'ouverture \`npm run $demarrage\` (grillhouse.demarrage) échoue (code $code)")
+  fi
+fi
+
+# The agents run the tests by `npm test`; the integration, the queue and the night run the guards
+# and the tests by `npm run verifier` (Turborepo): two npm scripts to wire.
+wiring=()
+if [ -f "$root/package.json" ]; then
+  for s in test verifier; do
+    node -e 'const p=require(process.argv[1]);process.exit(p.scripts&&p.scripts[process.argv[2]]?0:1)' \
+      "$root/package.json" "$s" 2>/dev/null || wiring+=("$s")
+  done
+fi
+
+# Once the architecture is written, the night (the full pass played for real, the night tests and
+# the time budget benches) needs its line in the crontab.
+if [ -f "$root/docs/ARCHITECTURE.md" ] && ! crontab -l 2>/dev/null | grep -qF "cd $root && node_modules/.bin/grillhouse nuit"; then
+  nuit="0 3 * * * cd $root && node_modules/.bin/grillhouse nuit"
+fi
+
+# An epic is a chantier, at the root: one with a mother is a mother ticket typed by mistake.
+epopees="$(cd "$root" && bd list --type epic --all --json --limit 0 2>/dev/null | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{process.stdout.write(JSON.parse(s).filter(t=>t.parent).map(t=>t.id).join(" "))}catch{}})')"
+
+[ ${#missing[@]} -eq 0 ] && [ ${#pending[@]} -eq 0 ] && [ ${#wiring[@]} -eq 0 ] && [ -z "${nuit:-}" ] && [ -z "$epopees" ] && [ -z "${inconnus:-}" ] && [ -z "${ecart_versions:-}" ] && exit 0
+
+echo "## Éléments du projet à définir (Roomi's Grillhouse)"
+if [ ${#missing[@]} -gt 0 ]; then
+  echo "Manque : $(IFS=';'; echo "${missing[*]}" | sed "s/;/, /g"). Installe-les toi-même avant tout autre geste, sans invite, chacun par la commande qu'il nomme ; \`npx grillhouse maj\` installe les greffons et les crochets git du cadre."
+fi
+if [ ${#pending[@]} -gt 0 ]; then
+  echo "Pas encore renseignés :"
+  for p in "${pending[@]}"; do echo "- $p"; done
+  echo "Dès ta première réponse, propose au responsable de les griller, chacun avec ce que tu recommandes pour ce projet (compétence \`grill\`). Il peut accepter, en choisir un, ou reporter ; tant qu'un élément reste vide, cette proposition revient à chaque séance."
+fi
+if [ ${#wiring[@]} -gt 0 ]; then
+  echo "À brancher : $(IFS=' '; echo "${wiring[*]}") dans le package.json de la racine. L'intégration (\`npx grillhouse integrer\`, contrat en tête de son script) et la nuit lancent \`npm run verifier\` (Turborepo, \`turbo.json\` : construction, puis gardes et tests), les agents \`npm test\` ; sans eux, l'intégration refuse chaque lot. Un projet testé par Vitest les reçoit de \`npm run grillhouse:maj\` ; sinon, écris-les pour ses tests."
+fi
+if [ -n "${nuit:-}" ]; then
+  echo "La nuit n'est pas programmée : elle rejoue pour de vrai la passe complète, puis les tests de nuit et les bancs de budget, que le jour ne joue pas (\`npx grillhouse nuit\`). Propose au responsable d'ajouter à la table des tâches du poste (\`crontab -e\`) : \`$nuit\`."
+fi
+if [ -n "$epopees" ]; then
+  echo "Épopées qui ont une mère : $epopees. Une épopée est un chantier, à la racine ; une mère sous un chantier est une tâche (\`bd update <id> -t task\`, docs/agents/issue-tracker.md, « Numéros et titres »)."
+fi
+if [ -n "${inconnus:-}" ]; then
+  echo "docs/agents/hors-cadre.txt nomme un dossier absent de packages/ et de src/ : $inconnus. Corrige la ligne (faute de frappe) ou retire-la : un nom sans dossier n'écarte rien."
+fi
+[ -n "${ecart_versions:-}" ] && echo "$ecart_versions"
+exit 0

package/scripts/sortie.mjs

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+// A release of Grillhouse, its package npm, which carries the frame's plugin: Grillhouse's own
+// script, which no project runs (`grillhouse init` installs the template of a project alone).
+//
+//   npx grillhouse sortie <x.y.z>                    the release's files: the package's package.json, CHANGELOG.md
+//   npx grillhouse sortie --etiqueter                the annotated tag v<version> on HEAD, the release commit
+//   npx grillhouse sortie --verifier-etiquette <v>   exits 0 when the tag <v> names the version of the package
+//   npx grillhouse sortie --entree-du-marche         the entry of the plugin in the marketplace roomi-fields
+//
+// - The version is the `version` of the package's `packages/grillhouse/package.json`, which npm
+//   publishes; the plugin the package carries takes it when the package is packed
+//   (scripts/cadre.mjs), so the frame has one version. Semantic versioning in 0.x: a change that
+//   obliges a project to act raises the minor, a fix the patch.
+// - Preparing writes the version given, above the current one, in the package's package.json, its
+//   other fields kept, and dates the changelog: « ## [Unreleased] » becomes « ## [<x.y.z>] - <today> » and an
+//   empty « ## [Unreleased] » opens above it. A release with nothing under « [Unreleased] » is
+//   refused. Nothing is written when a check fails.
+// - Tagging creates the annotated tag `v<version>` on HEAD, once the release commit is made and
+//   the working tree holds no change. Nothing is pushed: the owner validates the push, whose
+//   command the script names; `.github/workflows/release.yml` then plays the CI on the tagged
+//   commit and, once it is green, checks the tag (`--verifier-etiquette`), publishes the package
+//   on the npm registry (the repository's secret NPM_TOKEN) and the release on GitHub.
+// - The marketplace roomi-fields (GitHub, roomi-fields/claude-plugins, a repository of its own)
+//   lists the plugin by its source npm, ENTREE_DU_MARCHE: the package, without a subdirectory (a
+//   source npm has none: the package's root is the plugin's) and without a version, so the machine
+//   installs the version published last. `--entree-du-marche` prints it; the owner sets it in that
+//   repository once the package is published, a public gesture this script does not make.
+import { execFileSync } from 'node:child_process';
+import { readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const PAQUET = 'packages/grillhouse/package.json';
+
+/** The entry of the frame's plugin in the marketplace roomi-fields. */
+export const ENTREE_DU_MARCHE = {
+  name: 'grillhouse',
+  source: { source: 'npm', package: '@roomi-fields/grillhouse' },
+};
+const CHANGELOG = 'CHANGELOG.md';
+const OUVERTE = '## [Unreleased]\n';
+const SEMVER = /^(\d+)\.(\d+)\.(\d+)$/;
+
+const lire = (racine, f) => readFileSync(path.join(racine, f), 'utf8');
+
+// The version of Grillhouse at <racine>: its package's.
+export function versionDuCadre(racine) {
+  return JSON.parse(lire(racine, PAQUET)).version;
+}
+
+// Refuses a tag <etiquette> other than v<version> of the package at <racine>.
+export function verifierEtiquette(racine, etiquette) {
+  const v = versionDuCadre(racine);
+  if (etiquette !== `v${v}`) {
+    throw new Error(`L'étiquette ${etiquette} ne nomme pas la version du paquet, ${v}.`);
+  }
+}
+
+const rang = v => SEMVER.exec(v)?.slice(1).map(Number) ?? null;
+const audessus = (a, b) => {
+  for (let i = 0; i < 3; i++) {
+    if (a[i] !== b[i]) {
+      return a[i] > b[i];
+    }
+  }
+  return false;
+};
+
+// Writes the release <version> of Grillhouse at <racine>, dated <date> (YYYY-MM-DD).
+export function preparerSortie(racine, version, date) {
+  const actuelle = versionDuCadre(racine);
+  const neuve = rang(version);
+  if (!neuve) {
+    throw new Error(`« ${version} » n'est pas une version x.y.z.`);
+  }
+  if (!audessus(neuve, rang(actuelle))) {
+    throw new Error(`${version} n'est pas au-dessus de la version actuelle, ${actuelle}.`);
+  }
+  const journal = lire(racine, CHANGELOG);
+  const debut = journal.indexOf(`\n${OUVERTE}`);
+  if (debut < 0) {
+    throw new Error(`${CHANGELOG} n'a pas de section « [Unreleased] ».`);
+  }
+  const corps = journal.slice(debut + 1 + OUVERTE.length);
+  const fin = corps.search(/^## \[/m);
+  if ((fin < 0 ? corps : corps.slice(0, fin)).trim() === '') {
+    throw new Error(`La section « [Unreleased] » de ${CHANGELOG} est vide : rien à sortir.`);
+  }
+  const paquet = JSON.parse(lire(racine, PAQUET));
+  paquet.version = version;
+  writeFileSync(path.join(racine, PAQUET), `${JSON.stringify(paquet, null, 2)}\n`);
+  writeFileSync(
+    path.join(racine, CHANGELOG),
+    `${journal.slice(0, debut + 1)}${OUVERTE}\n## [${version}] - ${date}\n${corps}`
+  );
+}
+
+// Creates the annotated tag of the release at <racine> on HEAD, and returns its name.
+export function etiqueter(racine) {
+  const git = (...args) => execFileSync('git', ['-C', racine, ...args], { encoding: 'utf8' });
+  const etiquette = `v${versionDuCadre(racine)}`;
+  if (git('status', '--porcelain').trim() !== '') {
+    throw new Error(
+      "L'arbre de travail porte des changements : le commit de sortie vient d'abord."
+    );
+  }
+  if (git('tag', '--list', etiquette).trim() !== '') {
+    throw new Error(`L'étiquette ${etiquette} existe déjà.`);
+  }
+  git('tag', '-a', etiquette, '-m', `Roomi's Grillhouse ${etiquette.slice(1)}`);
+  return etiquette;
+}
+
+const USAGE =
+  'Usage : npx grillhouse sortie <x.y.z>                    prépare la sortie (package.json du paquet, CHANGELOG.md)\n' +
+  "        npx grillhouse sortie --etiqueter                pose l'étiquette v<version> sur le commit de sortie\n" +
+  "        npx grillhouse sortie --verifier-etiquette <v>   vérifie que l'étiquette <v> nomme la version du paquet\n" +
+  '        npx grillhouse sortie --entree-du-marche         écrit l’entrée du greffon dans la place de marché roomi-fields\n';
+
+// Today, in the local calendar, as YYYY-MM-DD.
+const aujourdhui = () => {
+  const d = new Date();
+  const n = x => String(x).padStart(2, '0');
+  return `${d.getFullYear()}-${n(d.getMonth() + 1)}-${n(d.getDate())}`;
+};
+
+if (import.meta.url === pathToFileURL(process.argv[1] ?? '').href) {
+  const args = process.argv.slice(2);
+  const racine = process.cwd();
+  try {
+    if (args.length === 1 && args[0] === '--etiqueter') {
+      const e = etiqueter(racine);
+      process.stdout.write(
+        `Étiquette ${e} posée sur HEAD, en local. La poussée, que valide le responsable : git push origin ${e} ` +
+          '(la CI joue alors le commit, puis publie le paquet sur npm)\n'
+      );
+    } else if (args.length === 1 && args[0] === '--entree-du-marche') {
+      process.stdout.write(`${JSON.stringify(ENTREE_DU_MARCHE, null, 2)}\n`);
+    } else if (args.length === 2 && args[0] === '--verifier-etiquette') {
+      verifierEtiquette(racine, args[1]);
+    } else if (args.length === 1 && !args[0].startsWith('-')) {
+      preparerSortie(racine, args[0], aujourdhui());
+      process.stdout.write(
+        `Sortie ${args[0]} préparée : ${PAQUET}, ${CHANGELOG}. ` +
+          `Le commit de sortie, puis : npx grillhouse sortie --etiqueter\n`
+      );
+    } else {
+      process.stderr.write(USAGE);
+      process.exitCode = 2;
+    }
+  } catch (e) {
+    process.stderr.write(`${e.message}\n`);
+    process.exitCode = 1;
+  }
+}