@roomi-fields/grillhouse 0.23.0 → 0.24.0

package/scripts/enveloppe/lancer.sh

@@ -1,8 +1,9 @@
 #!/usr/bin/env bash
 # Launches a role agent on one ticket, as its own Claude session inside the envelope of its
-# component. The supervisor runs it in the background and is told when the session ends.
+# plan, the packages it writes (one session of the testwriter or the developpeur for the whole
+# ticket, `.` as its component and the plan as `--paquets`, grillhouse-3uv.95.6). The supervisor runs it in the background and is told when the session ends.
 #
-#   npx grillhouse lancer [--modele <m>] [--effort <e>] [--seance <id> | --reprise <id>] <ticket> <rôle> <composant> <fichier de consigne>
+#   npx grillhouse lancer [--modele <m>] [--effort <e>] [--seance <id> | --reprise <id>] [--paquets <liste>] <ticket> <rôle> <composant> <fichier de consigne>
 #
 # - <composant> is the component's path from the root (`packages/<nom>`, or `.` for the whole
 #   repository). It is judged before the copy is prepared, by the envelope's rule
@@ -10,6 +11,11 @@
 #   when it exists, else in the main tree or in the tree of the branch agent/<ticket> when it
 #   exists (`git cat-file -e`; `.` is always admitted): a path that names nothing there is refused on the standard error, CODE_USAGE, nothing prepared; when
 #   it is the name of a package or of its folder, the refusal names the path it means.
+# - --paquets <liste> is the plan of the session: the paths of the packages it writes, in the form
+#   of the envelope's variable (`ecrireLaListe` of paquets-du-plan.mjs, `packages/a:packages/b`),
+#   each judged as <composant> is; without it, the plan is <composant> alone. The envelope shows
+#   the session the whole copy and opens in writing the packages of the plan alone. It takes a
+#   value as --modele does.
 # - --modele <m> and --effort <e> override, for this session only, the model and the thinking level
 #   of the role's definition (its agent in the frame's plugin, agents/<rôle>.md); they reach claude
 #   as --model and --effort.
@@ -45,21 +51,22 @@
 #   dependencies are installed when `node_modules` is absent or `package-lock.json` is newer than
 #   the last installation (`node_modules/.package-lock.json`, written by npm), and it is built there
 #   by Turborepo, which restores an unchanged build from its cache, outside the envelope, so the
-#   agent finds the published parts of its neighbours. As Bazel builds the dependencies of a target
-#   before the target: for a component that is a package of the frame, its providers are built
-#   first (the packages whose build its build waits for, read in Turborepo's graph,
-#   `turbo run build --filter=<paquet> --dry=json`, which node reads on its standard input, whatever
-#   its size), and a failure stops the launch, CODE_COPIE;
-#   then the traces of other packages its tests wait for (`grillhouse.traces`, read in Turborepo's
-#   plan of its tests, `turbo run test:vitest --filter=<paquet> --dry=json`), which the envelope
-#   shows read-only, and a failure stops the launch, CODE_COPIE; then the package, its own traces
-#   and what its tests read (`turbo run build <its traces> --filter=<paquet>...
+#   agent finds the builds of the packages out of its plan. As Bazel builds the dependencies of a
+#   target before the target: for a plan whose every path is a package of the frame (the circuit's
+#   session over the whole ticket, `.` as its component and the plan as `--paquets`, or a component
+#   alone), their providers are built first (the packages whose build their builds wait for, read
+#   in Turborepo's graph, `turbo run build --filter=<paquet>… --dry=json`, which node reads on its
+#   standard input, whatever its size), and a failure stops the launch, CODE_COPIE;
+#   then the traces of other packages their tests wait for (`grillhouse.traces`, read in Turborepo's
+#   plan of their tests, `turbo run test:vitest --filter=<paquet>… --dry=json`), which the envelope
+#   shows read-only, and a failure stops the launch, CODE_COPIE; then the packages, their own
+#   traces and what their tests read (`turbo run build <their traces> --filter=<paquet>...…
 #   --continue=dependencies-successful`), whose failure does not stop it: each task whose
-#   dependencies succeed goes to its end, so what its tests read without depending on it is built
-#   whole; the session opens, its instruction ending with a section « La construction de ton
+#   dependencies succeed goes to its end, so what their tests read without depending on them is
+#   built whole; the session opens, its instruction ending with a section « La construction de ton
 #   paquet échoue » with the end of that output, since repairing it is the session's work (a
-#   provider's lot that breaks its consumers). Its consumers are not built. Any other component,
-#   the whole repository (`.`) included, builds the copy whole (`turbo run build`). The
+#   provider's lot that breaks its consumers). Their consumers are not built. Any other plan, the
+#   whole repository (`.`) included, builds the copy whole (`turbo run build`). The
 #   installation and the build play through `scripts/sous-modules.sh monter`, each shared submodule
 #   of the main repository read-only, by the list the pose printed, whatever the installation
 #   rewrites afterwards; with a shared submodule and no possible mount (bwrap absent or
@@ -69,11 +76,13 @@
 # - The session runs `claude -p` with the role's agent and, as its prompt, read on its standard
 #   input from a temporary file the launcher writes and removes (an argument may not pass the
 #   128 KiB Linux allows one, MAX_ARG_STRLEN), the instruction file
-#   followed by the section « Ce que les composants d'avant publient »: for each component whose
-#   `## Consommateurs` section names the component, its line, the names of the elements declared
-#   for the component, and the address of the rubric « Rend » of its frame, the rest of its
-#   elements left to the index of the interfaces (`scripts/index-interfaces.mjs --publie`, read in
-#   the prepared copy; a reading that fails stops the launch, CODE_COPIE), then the
+#   followed by the section « Ce que les composants d'avant publient », for each package of the
+#   plan (one part per package when the plan holds several, grillhouse-3uv.95.6): for each
+#   component whose `## Consommateurs` section names the package, its line, the names of the
+#   elements declared for the package, and the address of the rubric « Rend » of its frame, the
+#   rest of its elements left to the index of the interfaces (`scripts/index-interfaces.mjs
+#   --publie <plan>`, read in the prepared copy; a reading that fails stops the launch,
+#   CODE_COPIE), then the
 #   section « Ton dossier de travail », which names the session's working directory, where every
 #   temporary file goes (`dossierDeTravail` of enveloppe.mjs, the envelope's TMPDIR), then the
 #   section « La construction de ton paquet échoue » when it fails. The prompt
@@ -83,7 +92,7 @@
 #   the launch, CODE_COPIE): the user's own configuration left out, its settings on the command
 #   line (its refusals, among them the change of its author at the ticket, AUTEUR_FIXE: its
 #   comments carry the author the launch names in BEADS_ACTOR, which the envelope passes on; its
-#   locks), its tools and no server of the index.
+#   locks), its tools and the servers of the index, for the reading of the whole copy.
 # - A role that ends on a sheet (scripts/resultats.mjs: the testwriter, the developpeur) runs with
 #   `--output-format json --json-schema <its schema>` (`npx grillhouse resultats --schema
 #   <rôle>`): claude's JSON result, its sheet in `structured_output`, goes to
@@ -96,19 +105,22 @@
 #   launcher writes the session's exit code to .claude/worktrees/<ticket>.fin, which a launch
 #   removes first: a launch that stops before its session leaves none, so the circuit
 #   (scripts/circuit.mjs) tells a code of the session from CODE_USAGE, CODE_REFUS and CODE_COPIE.
-#   It then writes the session's line to the register (scripts/registre.mjs --copie), and exits
-#   with the envelope's code.
+#   A session its lock stopped on a write out of the plan (scripts/verrous/verrou.mjs) left the
+#   reason in its working directory (`hors-plan`, removed before the session): the launcher moves
+#   it to .claude/worktrees/<ticket>.hors-plan, which a launch removes first and the circuit reads,
+#   and adds it to the log. It then writes the session's line to the register
+#   (scripts/registre.mjs --copie), and exits with the envelope's code.
 # - The exit codes are named in scripts/enveloppe/codes.mjs; a malformed call exits CODE_USAGE.
 # - CLAUDE_BIN replaces `claude` (the tests use it).
 set -euo pipefail
 ici="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 eval "$(node "$ici/codes.mjs")"
-usage="usage: npx grillhouse lancer [--modele <m>] [--effort <e>] [--seance <id> | --reprise <id>] <ticket> <rôle> <composant> <fichier de consigne>"
+usage="usage: npx grillhouse lancer [--modele <m>] [--effort <e>] [--seance <id> | --reprise <id>] [--paquets <liste>] <ticket> <rôle> <composant> <fichier de consigne>"
 refus_usage() { echo "$usage" >&2; exit "$CODE_USAGE"; }
-modele="" effort="" seance="" reprise="" surcharge=()
+modele="" effort="" seance="" reprise="" liste="" surcharge=()
 while [ $# -gt 0 ]; do
   case "$1" in
-    --modele|--effort|--seance|--reprise)
+    --modele|--effort|--seance|--reprise|--paquets)
       [ $# -ge 2 ] && [ -n "$2" ] && [[ "$2" != --* ]] || refus_usage
       if [ "$1" = --modele ]; then
         modele=$2
@@ -116,6 +128,8 @@ while [ $# -gt 0 ]; do
         seance=$2
       elif [ "$1" = --reprise ]; then
         reprise=$2
+      elif [ "$1" = --paquets ]; then
+        liste=$2
       else
         case "$2" in low|medium|high|xhigh|max) effort=$2 ;; *) refus_usage ;; esac
       fi
@@ -131,6 +145,8 @@ done
 [ -z "$reprise" ] || surcharge+=(--resume "$reprise")
 [ $# -eq 4 ] || refus_usage
 ticket=$1 role=$2 composant=$3 consigne=$4
+# The plan of the session: the packages it writes.
+paquets=${liste:-$composant}
 # The main tree, from the common git directory: launched from an agent copy, the new copy still
 # lands next to the others, never inside one.
 racine=$(cd "$(git rev-parse --path-format=absolute --git-common-dir)/.." && pwd)
@@ -147,7 +163,7 @@ if [ -d "$racine/.claude/worktrees/$ticket" ]; then
 elif git -C "$racine" rev-parse --verify --quiet "refs/heads/agent/$ticket" > /dev/null; then
   branche="agent/$ticket"
 fi
-refus_composant=$(node --input-type=module -e "import { spawnSync } from 'node:child_process'; import { existsSync } from 'node:fs'; import path from 'node:path'; import { jugerComposant } from '$ici/enveloppe.mjs'; import { paquets } from '$ici/../paquets.mjs'; const [depot, composant, branche] = process.argv.slice(1); const dansBranche = p => { const rel = path.relative(depot, p); return rel === '' || (!rel.startsWith('..') && spawnSync('git', ['-C', depot, 'cat-file', '-e', branche + ':' + rel]).status === 0); }; const existe = p => existsSync(p) || (branche !== '' && dansBranche(p)); process.stdout.write(jugerComposant({ depot, composant, paquets: paquets(depot) }, { existe }) ?? '');" "$juge" "$composant" "$branche") || exit "$CODE_USAGE"
+refus_composant=$(node --input-type=module -e "import { spawnSync } from 'node:child_process'; import { existsSync } from 'node:fs'; import path from 'node:path'; import { jugerComposant } from '$ici/enveloppe.mjs'; import { lireLaListe } from '$ici/paquets-du-plan.mjs'; import { paquets } from '$ici/../paquets.mjs'; const [depot, composant, liste, branche] = process.argv.slice(1); const dansBranche = p => { const rel = path.relative(depot, p); return rel === '' || (!rel.startsWith('..') && spawnSync('git', ['-C', depot, 'cat-file', '-e', branche + ':' + rel]).status === 0); }; const existe = p => existsSync(p) || (branche !== '' && dansBranche(p)); const tous = paquets(depot); process.stdout.write([composant, ...lireLaListe(liste)].map(c => jugerComposant({ depot, composant: c, paquets: tous }, { existe })).find(Boolean) ?? '');" "$juge" "$composant" "$paquets" "$branche") || exit "$CODE_USAGE"
 [ -z "$refus_composant" ] || { echo "⛔ $refus_composant" >&2; exit "$CODE_USAGE"; }
 # The ticket is matched whole: `demo-3160` is not `demo-316`, and its dots are dots.
 motif=$(printf '%s' "$ticket" | sed 's/[.[\*^$]/\\&/g')
@@ -157,8 +173,9 @@ copie="$racine/.claude/worktrees/$ticket"
 journal="$copie.log"
 fin="$copie.fin"
 resultat="$copie.resultat.json"
+hors_plan="$copie.hors-plan"
 mkdir -p "$(dirname "$copie")"
-rm -f "$fin" "$resultat"
+rm -f "$fin" "$resultat" "$hors_plan"
 printf '=== %s · %s · %s ===\n' "$(date -Iseconds)" "$role" "$composant" >> "$journal"
 # A branch still in the queue is not relaunched: the queue brings it onto main, or sends it back.
 if node --input-type=module -e "import { lireEntrees } from '$ici/../integration/file-attente.mjs'; const [r, b, t] = process.argv.slice(1); process.exit(lireEntrees(r).some(e => e.branche === b || e.ticket === t) ? 0 : 1);" "$racine" "agent/$ticket" "$ticket"; then
@@ -217,24 +234,28 @@ echec=$(mktemp)
     if [ ! -d "$copie/node_modules" ] || [ "$copie/package-lock.json" -nt "$installe" ]; then
       monter npm --prefix "$copie" install --no-save --no-audit --no-fund --silent || exit 1
     fi
-    # The package of the session, when the component is a package of the frame: its name.
-    paquet=$(node --input-type=module -e "import path from 'node:path'; import { paquets } from '$ici/../paquets.mjs'; const [r, d] = process.argv.slice(1); const p = paquets(r).find(p => !p.hors && p.dossier === path.normalize(d).replace(/\/\$/, '')); process.stdout.write(p?.pkg.name ?? '');" "$copie" "$composant") || exit 1
-    if [ -z "$paquet" ]; then
+    # The packages of the session's plan that are packages of the frame: their names, one per
+    # line; none when a path of the plan is no package of the frame (the root, `.`, a folder).
+    noms=$(node --input-type=module -e "import path from 'node:path'; import { lireLaListe } from '$ici/paquets-du-plan.mjs'; import { paquets } from '$ici/../paquets.mjs'; const [r, liste] = process.argv.slice(1); const tous = paquets(r).filter(p => !p.hors); const l = lireLaListe(liste).map(d => tous.find(p => p.dossier === path.normalize(d).replace(/\/\$/, ''))?.pkg.name ?? null); process.stdout.write(l.length && l.every(Boolean) ? l.join('\n') : '');" "$copie" "$paquets") || exit 1
+    if [ -z "$noms" ]; then
       (cd "$copie" && monter npx --no-install turbo run build) || exit 1
     else
-      # Its providers: the packages whose build its own build waits for, as Turborepo reads them.
-      graphe=$(cd "$copie" && monter npx --no-install turbo run build "--filter=$paquet" --dry=json) || exit 1
+      mapfile -t lesNoms <<<"$noms"
+      cibles=() lecteurs=()
+      for n in "${lesNoms[@]}"; do cibles+=("--filter=$n"); lecteurs+=("--filter=$n..."); done
+      # Their providers: the packages whose build their own builds wait for, as Turborepo reads them.
+      graphe=$(cd "$copie" && monter npx --no-install turbo run build "${cibles[@]}" --dry=json) || exit 1
       # The graph comes on the standard input: as an argument, it may pass the size Linux allows one.
-      fournisseurs=$(node -e 'const [p] = process.argv.slice(1); const t = JSON.parse(require("node:fs").readFileSync(0, "utf8")).tasks.filter(t => t.taskId !== `${p}#build`); console.log([...new Set(t.map(t => `--filter=${t.package}`))].join("\n"));' "$paquet" <<<"$graphe") || exit 1
+      fournisseurs=$(node -e 'const plan = process.argv.slice(1); const t = JSON.parse(require("node:fs").readFileSync(0, "utf8")).tasks.filter(t => !plan.includes(t.package)); console.log([...new Set(t.map(t => `--filter=${t.package}`))].join("\n"));' "${lesNoms[@]}" <<<"$graphe") || exit 1
       if [ -n "$fournisseurs" ]; then
         mapfile -t filtres <<<"$fournisseurs"
         (cd "$copie" && monter npx --no-install turbo run build "${filtres[@]}") || exit 1
       fi
-      # The traces its tests wait for, as Turborepo's plan of its tests reads them. Another
-      # package's trace is produced here, and a failure stops the launch, as a provider's; its own
-      # waits for its own build, and is produced with it below.
-      plan=$(cd "$copie" && monter npx --no-install turbo run test:vitest "--filter=$paquet" --dry=json) || exit 1
-      traces() { node --input-type=module -e "import { readFileSync } from 'node:fs'; import { tracesDuPlan } from '$ici/../turbo-des-paquets.mjs'; const [p, propres] = process.argv.slice(1); console.log(tracesDuPlan(JSON.parse(readFileSync(0, 'utf8')), t => (t.package === p) === (propres === 'oui')).join('\n'));" "$paquet" "$1" <<<"$plan"; }
+      # The traces their tests wait for, as Turborepo's plan of their tests reads them. Another
+      # package's trace is produced here, and a failure stops the launch, as a provider's; a trace
+      # of the plan waits for its build, and is produced with it below.
+      plan=$(cd "$copie" && monter npx --no-install turbo run test:vitest "${cibles[@]}" --dry=json) || exit 1
+      traces() { node --input-type=module -e "import { readFileSync } from 'node:fs'; import { tracesDuPlan } from '$ici/../turbo-des-paquets.mjs'; const [propres, ...plan] = process.argv.slice(1); console.log(tracesDuPlan(JSON.parse(readFileSync(0, 'utf8')), t => plan.includes(t.package) === (propres === 'oui')).join('\n'));" "$1" "${lesNoms[@]}" <<<"$plan"; }
       autres=$(traces non) || exit 1
       if [ -n "$autres" ]; then
         mapfile -t ids <<<"$autres"
@@ -243,26 +264,29 @@ echec=$(mktemp)
       propres=$(traces oui) || exit 1
       ids=()
       [ -z "$propres" ] || mapfile -t ids <<<"$propres"
-      # The package itself, its own traces, and what its tests read (the shared test material),
-      # built after its providers: a failure does not stop the launch, it goes into the instruction.
-      # Each task whose dependencies succeed goes to its end (--continue=dependencies-successful):
-      # the package's failure does not cancel the build of what its tests read without depending
-      # on it, which the envelope shows read-only.
-      if ! (cd "$copie" && monter npx --no-install turbo run build ${ids[@]+"${ids[@]}"} "--filter=$paquet..." --continue=dependencies-successful) > "$echec" 2>&1; then
+      # The packages of the plan, their own traces, and what their tests read (the shared test
+      # material), built after their providers: a failure does not stop the launch, it goes into
+      # the instruction. Each task whose dependencies succeed goes to its end
+      # (--continue=dependencies-successful): one package's failure does not cancel the build of
+      # what the tests read without depending on it, which the envelope shows read-only.
+      if ! (cd "$copie" && monter npx --no-install turbo run build ${ids[@]+"${ids[@]}"} "${lecteurs[@]}" --continue=dependencies-successful) > "$echec" 2>&1; then
         cat "$echec"
-        echo "⚠️  La construction de $paquet échoue : la séance s'ouvre, la consigne porte l'erreur."
+        echo "⚠️  La construction du plan (${lesNoms[*]}) échoue : la séance s'ouvre, la consigne porte l'erreur."
       else
         : > "$echec"
       fi
     fi
   fi
 ) >> "$journal" 2>&1 || { rm -f "$echec"; echo "⛔ La copie $copie n'a pas pu être préparée : voir $journal." >&2; exit "$CODE_COPIE"; }
-# What the components before publish, read in the prepared copy, follows the instruction.
-publie=$(cd "$copie" && node "$ici/../index-interfaces.mjs" --publie "$composant" 2>> "$journal") \
+# What the components before each package of the plan publish, read in the prepared copy,
+# follows the instruction.
+publie=$(cd "$copie" && node "$ici/../index-interfaces.mjs" --publie "$paquets" 2>> "$journal") \
   || { rm -f "$echec"; echo "⛔ Ce que publient les composants d'avant n'a pas pu se lire : voir $journal." >&2; exit "$CODE_COPIE"; }
 # The session's working directory, the one the envelope gives as TMPDIR, follows them.
 travail=$(node --input-type=module -e "import { dossierDeTravail } from '$ici/enveloppe.mjs'; process.stdout.write(dossierDeTravail(process.argv[1]));" "$copie" 2>> "$journal") \
   || { rm -f "$echec"; echo "⛔ Le dossier de travail de la séance n'a pas pu se lire : voir $journal." >&2; exit "$CODE_COPIE"; }
+# The mark a lock leaves there when it stops the session out of the plan: none before the session.
+rm -f "$travail/hors-plan"
 dossier=$'\n\n'"## Ton dossier de travail"$'\n\n'"Tout fichier temporaire s'écrit dans \`$travail\`, que \`\$TMPDIR\` nomme aussi."
 construction=
 if [ -s "$echec" ]; then
@@ -293,7 +317,7 @@ schema=$(node "$ici/../resultats.mjs" --schema "$role" 2> /dev/null) || schema=
 # An envelope in error does not stop the launcher (set -e): its code is kept for the exit.
 code=0
 lancer_claude() {
-  node "$ici/enveloppe.mjs" "$copie" "$composant" "$role" -- \
+  node "$ici/enveloppe.mjs" "$copie" "$paquets" "$role" -- \
     "${CLAUDE_BIN:-claude}" -p --agent "$role" \
     ${surcharge[@]+"${surcharge[@]}"} ${fiche[@]+"${fiche[@]}"} --permission-mode bypassPermissions \
     "${droits_du_role[@]}" < "$prompt"
@@ -305,6 +329,12 @@ else
   lancer_claude >> "$journal" 2>&1 || code=$?
 fi
 rm -f "$prompt"
+# A session its lock stopped out of the plan (scripts/verrous/verrou.mjs): its reason goes to the
+# circuit, and to the log.
+if [ -f "$travail/hors-plan" ]; then
+  mv "$travail/hors-plan" "$hors_plan"
+  { cat "$hors_plan"; echo; } >> "$journal"
+fi
 echo "$code" > "$fin"
 # The envelope ended: the session's line goes to the register from outside it, whatever its end hook did.
 node "$ici/../registre.mjs" --copie "$copie" >> "$journal" 2>&1 || true

package/scripts/enveloppe/paquets-du-plan.mjs

@@ -0,0 +1,49 @@
+// The packages of the plan of the envelope a command runs in. The envelope names them to every
+// command of its session, in the variable `GRILLHOUSE_ENVELOPPE`: the list of the paths the plan
+// names inside the copy (`packages/a`, or `src/parser` in a one-package project), joined by the
+// separator of a list of paths (`path.delimiter`, as NODE_PATH and PATH join theirs). As the
+// visibility of Bazel and the module boundaries of Nx refuse a dependency while the code stays
+// readable, the session reads the whole copy and writes these packages only: a command of the
+// frame that reads the list builds, judges and writes them alone.
+//
+// This module uses Node alone, as the modules of scripts/paquets.mjs.
+import path from 'node:path';
+
+export const VARIABLE = 'GRILLHOUSE_ENVELOPPE';
+// The file the lock of a session leaves in its working directory when it stops the session on a
+// write out of the plan (scripts/verrous/verrou.mjs); the launcher hands it to the circuit as
+// `<copie>.hors-plan` (scripts/enveloppe/lancer.sh).
+export const MARQUE_HORS_PLAN = 'hors-plan';
+
+// The list <paquets> as the variable carries it.
+export const ecrireLaListe = paquets => paquets.join(path.delimiter);
+
+// The list the text <texte> of the variable carries.
+export const lireLaListe = texte =>
+  String(texte ?? '')
+    .split(path.delimiter)
+    .filter(Boolean);
+
+// The packages of the plan of the envelope named in <env>, or null outside an envelope.
+export const paquetsDeLEnveloppe = (env = process.env) =>
+  env[VARIABLE] ? lireLaListe(env[VARIABLE]) : null;
+
+// The directory of the package of <paquetsDeLaCopie> (`paquets` of scripts/paquets.mjs, each
+// `dossier` relative to the copy) that holds the path <chemin> of the copy, the deepest; `.`, the
+// root, when none holds it.
+export function paquetQuiTient(chemin, paquetsDeLaCopie) {
+  const rel = path.normalize(chemin).replace(/\/+$/, '');
+  const tenants = paquetsDeLaCopie
+    .map(p => path.normalize(p.dossier))
+    .filter(d => rel === d || rel.startsWith(`${d}/`));
+  return tenants.sort((a, b) => b.length - a.length)[0] ?? '.';
+}
+
+// The directories, relative to the copy, that the plan <paquets> writes, sorted: for each path of
+// the plan, the package that holds it (`paquetQuiTient`). A path that no package holds (a folder of
+// the root, `scripts`; `src/parser` in a one-package project; `.`) writes the package that holds
+// it, the root: the plan then writes the whole copy, `['.']`.
+export function ecritsDuPlan(paquets, paquetsDeLaCopie) {
+  const ecrits = [...new Set(paquets.map(p => paquetQuiTient(p, paquetsDeLaCopie)))].sort();
+  return ecrits.includes('.') ? ['.'] : ecrits;
+}