repowarden 4.7.2-next.6 → 4.8.0

package/bin/bots

@@ -0,0 +1,370 @@
+#!/usr/bin/env bash
+# Bots du dépôt GitHub courant, configurés avec l'accord de l'utilisateur :
+#   repowarden bots              questions, aperçu, puis confirmation
+#   repowarden install --bots    (idem, après l'installation des hooks)
+#   repowarden install --sans-bots
+#                                ne plus jamais le proposer (repowarden.bots = off)
+# Rien n'est fait sans accord : une question globale (non par défaut), le
+# flux (main seul, ou develop → main), un accord par bot (CI, releases,
+# nettoyage, tickets, App, protection, npm), l'aperçu de ce qui sera créé ou
+# modifié, puis une confirmation finale. Un fichier existant n'est jamais
+# écrasé. Relançable pour compléter. Demande un terminal, gh connecté et les
+# droits d'administration du dépôt.
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd -P)"
+# shellcheck source=../hooks/lib/common.sh
+source "$ROOT/hooks/lib/common.sh"
+
+aide() { sed -n '2,12p' "$0" | sed 's/^# \{0,1\}//'; }
+
+# Commandes enchaînées (remplaçables dans les tests)
+BIN="${REPOWARDEN_BIN:-$ROOT/bin}"
+DEPUIS_INSTALL=""
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --depuis-install) DEPUIS_INSTALL=1 ;;
+        -h | --help) aide; exit 0 ;;
+        *) err_t install.unknown_arg "$1"; exit 1 ;;
+    esac
+    shift
+done
+
+# Rien n'est proposé : une ligne dit pourquoi, et comment le faire plus tard
+pas_maintenant() { # $1 clé de la raison
+    t "$1"
+    info_t bots.skip "$REPLY"
+    exit 0
+}
+
+# Refus permanent (install --sans-bots) : silence depuis l'installation
+if [ -n "$DEPUIS_INSTALL" ] && [ "$(git config --get repowarden.bots 2>/dev/null || true)" = off ]; then
+    exit 0
+fi
+[ -n "$GIT_TOPLEVEL" ] || pas_maintenant bots.why_repo
+cd "$GIT_TOPLEVEL"
+[ "$FORGE" = github ] || pas_maintenant bots.why_github
+command -v gh >/dev/null || pas_maintenant bots.why_gh
+gh auth status >/dev/null 2>&1 || pas_maintenant bots.why_gh_login
+REPO="$(gh repo view --json nameWithOwner -q .nameWithOwner 2>/dev/null || true)"
+[ -n "$REPO" ] || pas_maintenant bots.why_github
+[ "$(gh api "repos/$REPO" --jq .permissions.admin 2>/dev/null || true)" = true ] || pas_maintenant bots.why_admin
+# Terminal (ou réponses fournies, tests) : sinon, jamais de question
+[ -t 0 ] || [ -n "${REPOWARDEN_INTERACTIF:-}" ] || pas_maintenant bots.why_tty
+
+# Question fermée : $1 clé, $2 défaut (o ou n) ; vrai si oui
+demander() {
+    local reponse choix="o/N"
+    [ "$2" = n ] || choix="O/n"
+    t "$1"
+    printf '%s [%s] ' "$REPLY" "$choix" >&2
+    IFS= read -r reponse || reponse=""
+    case "$reponse" in
+        "") [ "$2" = o ] ;;
+        [oOyY]*) return 0 ;;
+        *) return 1 ;;
+    esac
+}
+
+brand "bots · $REPO"
+demander bots.ask_global n || { info_t bots.later; exit 0; }
+
+# --- Flux ------------------------------------------------------------------
+cfg_r integrationBranch ""
+INTEGRATION="$REPLY"
+DEFAUT="$(gh api "repos/$REPO" --jq .default_branch)"
+PRINCIPALE=main
+[ "$DEFAUT" = master ] && PRINCIPALE=master
+echo >&2
+t bots.flow_question
+printf '%s\n' "$REPLY" >&2
+t bots.flow_main "$PRINCIPALE"
+printf '  1) %s\n' "$REPLY" >&2
+t bots.flow_develop "$PRINCIPALE"
+printf '  2) %s\n' "$REPLY" >&2
+# develop → main par défaut : seul develop entre dans main
+choix_flux=2
+read -r -p "[$choix_flux] : " reponse || reponse=""
+case "${reponse:-$choix_flux}" in
+    2*) FLUX=develop; INTEGRATION="${INTEGRATION:-develop}" ;;
+    *) FLUX=main; INTEGRATION="" ;;
+esac
+CREER_DEVELOP=""
+if [ "$FLUX" = develop ] &&
+    [ -z "$(gh api "repos/$REPO/branches/$INTEGRATION" --jq .name 2>/dev/null || true)" ]; then
+    if demander bots.ask_create_develop o; then
+        CREER_DEVELOP=1
+    else
+        FLUX=main INTEGRATION=""
+    fi
+fi
+
+# --- Un accord par bot -----------------------------------------------------
+echo >&2
+info_t bots.one_by_one
+APP_PRESENTE=""
+[ -z "$(gh variable get REPOWARDEN_APP_CLIENT_ID --repo "$REPO" 2>/dev/null || true)" ] || APP_PRESENTE=1
+NPM_POSSIBLE=""
+[ ! -f package.json ] || grep -qE '"private": *true' package.json || NPM_POSSIBLE=1
+BOTS=()
+for bot in ci release nettoyage tickets app proteger npm; do
+    case "$bot" in
+        nettoyage) [ "$FLUX" = develop ] || continue ;;
+        app) [ -z "$APP_PRESENTE" ] || { info_t bots.app_present; continue; } ;;
+        npm) [ -n "$NPM_POSSIBLE" ] || continue ;;
+    esac
+    dim_t "bots.desc_$bot"
+    demander "bots.ask_$bot" o && BOTS+=("$bot")
+done
+[ "${#BOTS[@]}" -gt 0 ] || [ -n "$CREER_DEVELOP" ] || { info_t bots.later; exit 0; }
+choisi() { [[ " ${BOTS[*]+"${BOTS[*]}"} " == *" $1 "* ]]; }
+AVEC_APP=""
+{ [ -n "$APP_PRESENTE" ] || choisi app; } && AVEC_APP=1
+
+# --- Modèles des workflows -------------------------------------------------
+modele_ci() {
+    cat <<'YAML'
+# Vérifications repowarden en CI (obligatoires pour merger : repowarden proteger)
+name: repowarden
+
+on:
+  pull_request:
+    # edited : revérifie quand le titre de la PR change (message du commit en squash)
+    types: [opened, synchronize, reopened, edited]
+  push:
+YAML
+    if [ "$FLUX" = develop ]; then
+        echo "    branches: [$PRINCIPALE, $INTEGRATION]"
+    else
+        echo "    branches: [$PRINCIPALE]"
+    fi
+    cat <<'YAML'
+  # Lancé par le workflow de release sur sa PR (release-auto)
+  workflow_dispatch:
+
+permissions:
+  contents: read
+YAML
+    [ "$FLUX" != develop ] || echo "  pull-requests: write # fix-pr : PR mal visée reciblée"
+    cat <<'YAML'
+
+jobs:
+  repowarden:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          fetch-depth: 0 # historique complet : messages de commit, diff depuis la base
+      # Outils du projet nécessaires au formatage et aux tests, par exemple :
+      # - uses: actions/setup-node@v7
+      #   with: { node-version: 24, cache: npm }
+      # - run: npm ci
+      - uses: simdevWarden/repowarden@v4
+YAML
+    if [ "$FLUX" = develop ]; then
+        cat <<'YAML'
+        with:
+          # strict: true   # outil absent bloquant, une fois l'outillage installé ci-dessus
+          # Seule la branche d'intégration entre dans la principale : une PR
+          # de travail mal visée est reciblée avant les vérifications
+          fix-pr: "true"
+YAML
+    else
+        cat <<'YAML'
+        # with:
+        #   strict: true   # outil absent bloquant, une fois l'outillage installé ci-dessus
+YAML
+    fi
+}
+
+modele_release() {
+    if [ "$FLUX" = develop ]; then
+        cat <<YAML
+# Releases, flux $INTEGRATION → $PRINCIPALE (mode tag) : préversion vX.Y.Z-next.N le
+# soir si $INTEGRATION a changé ; le vendredi matin (ou à la main), une demande
+# de livraison $INTEGRATION → $PRINCIPALE, qui publie le tag vX.Y.Z et la release.
+name: release
+
+on:
+  push:
+    branches: [$PRINCIPALE, $INTEGRATION]
+  schedule:
+    - cron: "0 19 * * *" # préversion du soir, si $INTEGRATION a changé
+    - cron: "0 7 * * 5" # fenêtre de livraison : le vendredi matin
+  workflow_dispatch: # à la main (et urgence) : préversion et demande de livraison
+
+# Une file par branche et par déclencheur ; une demande manuelle ou planifiée
+# remplace celle en attente ; un push n'annule jamais un run en cours
+concurrency:
+  group: release-\${{ github.ref_name }}-\${{ github.event.schedule || github.event_name }}
+  cancel-in-progress: \${{ github.event_name != 'push' }}
+
+permissions: {}
+
+jobs:
+  release:
+    uses: simdevWarden/repowarden/.github/workflows/release-auto.yml@v4
+    permissions: { contents: write, pull-requests: write, actions: write, checks: read, statuses: write }
+    with:
+      mode: tag
+      integration-branch: $INTEGRATION
+      main-branch: $PRINCIPALE
+      delivery-schedule: "0 7 * * 5" # même cron que la fenêtre ci-dessus
+YAML
+        if [ -n "$AVEC_APP" ]; then
+            cat <<'YAML'
+      delivery-environment: production # « Approve and deploy » valide la livraison
+      app-client-id: ${{ vars.REPOWARDEN_APP_CLIENT_ID }} # la GitHub App merge la livraison approuvée
+    secrets:
+      app-key: ${{ secrets.REPOWARDEN_APP_KEY }}
+YAML
+        fi
+    else
+        cat <<'YAML'
+# Releases automatiques : à chaque merge sur la branche principale, la version
+# (semver) est calculée depuis les Conventional Commits ; une PR « release
+# x.y.z » est validée par la CI puis mergée, et le tag et la release créés.
+name: release
+
+on:
+  push:
+YAML
+        echo "    branches: [$PRINCIPALE]"
+        cat <<'YAML'
+  workflow_dispatch:
+
+# Une release à la fois
+concurrency:
+  group: release
+  cancel-in-progress: false
+
+permissions: {}
+
+jobs:
+  release:
+    uses: simdevWarden/repowarden/.github/workflows/release-auto.yml@v4
+    permissions: { contents: write, pull-requests: write, actions: write, checks: read, statuses: write }
+YAML
+        if [ -n "$AVEC_APP" ]; then
+            cat <<'YAML'
+    with:
+      app-client-id: ${{ vars.REPOWARDEN_APP_CLIENT_ID }}
+    secrets:
+      app-key: ${{ secrets.REPOWARDEN_APP_KEY }}
+YAML
+        fi
+    fi
+}
+
+modele_nettoyage() {
+    cat <<'YAML'
+# Branches de PR supprimées après merge (la suppression automatique de GitHub
+# est désactivée dans le flux develop : elle supprimerait la branche
+# d'intégration au merge de la livraison). Les branches longues et toute
+# branche encore source d'une PR ouverte sont conservées.
+name: nettoyage
+
+on:
+  pull_request:
+    types: [closed]
+
+permissions: {}
+
+jobs:
+  nettoyage:
+    uses: simdevWarden/repowarden/.github/workflows/nettoyage-branches.yml@v4
+    permissions:
+      contents: write
+      pull-requests: read
+YAML
+}
+
+fichier_du() { # $1 bot → REPLY : chemin de son workflow (vide : aucun)
+    case "$1" in
+        ci) REPLY=.github/workflows/repowarden.yml ;;
+        release) REPLY=.github/workflows/release.yml ;;
+        nettoyage) REPLY=.github/workflows/nettoyage.yml ;;
+        *) REPLY="" ;;
+    esac
+}
+
+# --- Aperçu, puis confirmation ---------------------------------------------
+echo >&2
+step_t bots.preview
+[ -z "$CREER_DEVELOP" ] || info_t bots.prev_develop "$INTEGRATION" "$PRINCIPALE"
+if [ "$FLUX" = develop ]; then
+    info_t bots.prev_conf "$INTEGRATION"
+    [ -n "$AVEC_APP" ] || info_t bots.prev_review
+fi
+for bot in ${BOTS[@]+"${BOTS[@]}"}; do
+    fichier_du "$bot"
+    f="$REPLY"
+    if [ -n "$f" ]; then
+        if [ -e "$f" ]; then
+            ecart="$(diff <("modele_$bot") "$f" | grep -c '^[<>]' || true)"
+            info_t bots.prev_kept "$f" "$ecart"
+        else
+            info_t bots.prev_file "$f"
+        fi
+    else
+        info_t "bots.prev_$bot"
+    fi
+done
+demander bots.ask_confirm n || { info_t bots.later; exit 0; }
+
+# --- Application -----------------------------------------------------------
+echecs=0
+lancer() { # $1 bot, puis la commande : une erreur n'arrête pas les autres
+    local bot="$1"
+    shift
+    echo >&2
+    step_t "bots.run_$bot"
+    if ! "$@"; then
+        err_t bots.failed_one "$bot"
+        echecs=$((echecs + 1))
+    fi
+}
+
+if [ -n "$CREER_DEVELOP" ]; then
+    sha="$(gh api "repos/$REPO/git/ref/heads/$DEFAUT" --jq .object.sha)"
+    gh api -X POST "repos/$REPO/git/refs" -f "ref=refs/heads/$INTEGRATION" -f "sha=$sha" --silent
+    ok_t bots.develop_created "$INTEGRATION" "$DEFAUT"
+fi
+if [ "$FLUX" = develop ]; then
+    conf="$GIT_TOPLEVEL/.repowarden.conf"
+    git config -f "$conf" repowarden.integrationBranch "$INTEGRATION"
+    git config -f "$conf" --get repowarden.protectedBranches >/dev/null ||
+        git config -f "$conf" repowarden.protectedBranches "$PRINCIPALE $INTEGRATION"
+    if [ -z "$AVEC_APP" ]; then
+        git config -f "$conf" --get repowarden.deliveryApproval >/dev/null ||
+            git config -f "$conf" repowarden.deliveryApproval review
+    fi
+    ok_t bots.conf_written .repowarden.conf
+fi
+for bot in ${BOTS[@]+"${BOTS[@]}"}; do
+    fichier_du "$bot"
+    f="$REPLY"
+    if [ -n "$f" ]; then
+        if [ -e "$f" ]; then
+            info_t bots.kept "$f"
+        else
+            mkdir -p "${f%/*}"
+            "modele_$bot" >"$f"
+            ok_t bots.written "$f"
+        fi
+    fi
+done
+choisi tickets && lancer tickets bash "$BIN/tickets" init --repo "$REPO"
+choisi app && lancer app bash "$BIN/app" init --repo "$REPO"
+choisi proteger && lancer proteger bash "$BIN/proteger" --repo "$REPO"
+choisi npm && lancer npm bash "$BIN/npm-publication" --repo "$REPO"
+
+echo >&2
+if [ "$echecs" = 0 ]; then
+    ok_t bots.done
+else
+    attention_t bots.done_errors "$echecs"
+fi
+[ -z "$(git status --porcelain -- .github .repowarden.conf 2>/dev/null)" ] || info_t bots.commit_files
+dim_t bots.verify
+[ "$echecs" = 0 ]

package/bin/migrer

@@ -0,0 +1,205 @@
+#!/usr/bin/env bash
+# Passage de repogarde à repowarden dans le projet courant (docs/migration-v4.md) :
+#   repowarden migrer           applique la migration dans l'arbre de travail
+#   repowarden migrer --pr      sur une branche chore/migration-repowarden-vN :
+#                               commit, push et PR (rien si une PR est ouverte)
+#   repowarden migrer --hooks   déplace aussi les hooks lefthook résiduels de
+#                               .git/hooks dans .git/hooks-lefthook/
+# Configuration (.repowarden.conf, .repowarden/), workflows (uses: vers le
+# dépôt repowarden et sa version majeure, anciens noms, permissions), puis la
+# liste de ce qui reste à faire à la main. Relançable : rien n'est fait deux fois.
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd -P)"
+# shellcheck source=../hooks/lib/common.sh
+source "$ROOT/hooks/lib/common.sh"
+
+aide() { sed -n '2,10p' "$0" | sed 's/^# \{0,1\}//'; }
+
+PR="" HOOKS_LEFTHOOK=""
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --pr) PR=1 ;;
+        --hooks) HOOKS_LEFTHOOK=1 ;;
+        -h | --help) aide; exit 0 ;;
+        *) err_t install.unknown_arg "$1"; exit 1 ;;
+    esac
+    shift
+done
+[ -n "$GIT_TOPLEVEL" ] || { err_t install.not_repo; exit 1; }
+cd "$GIT_TOPLEVEL"
+
+# Version majeure dont le tag flottant (vN) est publié : celle de repowarden ;
+# préversion d'une nouvelle majeure (X.0.0-next) : X-1, vX n'existant pas encore
+majeure_r() {
+    local v
+    repowarden_version_r "$ROOT"
+    v="$REPLY"
+    REPLY="${v%%.*}"
+    REPLY="${REPLY%%-*}"
+    [[ "$v" != *.0.0-* ]] || REPLY=$((REPLY - 1))
+}
+if [ -n "${REPOWARDEN_MAJEURE:-}" ]; then
+    MAJEURE="$REPOWARDEN_MAJEURE"
+else
+    majeure_r
+    MAJEURE="$REPLY"
+fi
+[[ "$MAJEURE" =~ ^[1-9][0-9]*$ ]] || { err_t mig.no_major "$MAJEURE"; exit 1; }
+BRANCHE="chore/migration-repowarden-v$MAJEURE"
+
+if [ -n "$PR" ]; then
+    command -v gh >/dev/null || { err_t bot.no_gh; exit 1; }
+    [ -z "$(git status --porcelain)" ] || { err_t mig.dirty; exit 1; }
+    if [ -n "$(gh pr list --head "$BRANCHE" --state open --json number --jq '.[].number' 2>/dev/null)" ]; then
+        info_t mig.pr_open "$BRANCHE"
+        exit 0
+    fi
+    git switch -q -c "$BRANCHE"
+fi
+
+FAITS=0
+fait() { FAITS=$((FAITS + 1)); ok_t "$@"; }
+
+# Fichier réécrit par sed (-E), sans -i (BSD et GNU diffèrent)
+reecrire() { # $1 fichier, $2… expressions sed
+    local f="$1" tmp
+    shift
+    tmp="$(mktemp)"
+    sed -E "$@" "$f" >"$tmp"
+    if cmp -s "$f" "$tmp"; then
+        rm -f "$tmp"
+        return 1
+    fi
+    cat "$tmp" >"$f"
+    rm -f "$tmp"
+}
+
+# 1. Configuration du projet
+if [ -f .repogarde.conf ]; then
+    if [ -e .repowarden.conf ]; then
+        attention_t mig.both .repogarde.conf .repowarden.conf
+    else
+        git mv .repogarde.conf .repowarden.conf 2>/dev/null || mv .repogarde.conf .repowarden.conf
+        reecrire .repowarden.conf -e 's/repogarde/repowarden/g' \
+            -e "s/^([[:space:]]*version[[:space:]]*=[[:space:]]*).*/\\1$MAJEURE/" || true
+        fait mig.conf
+    fi
+fi
+if [ -d .repogarde ]; then
+    if [ -e .repowarden ]; then
+        attention_t mig.both .repogarde/ .repowarden/
+    else
+        git mv .repogarde .repowarden 2>/dev/null || mv .repogarde .repowarden
+        fait mig.dir
+    fi
+fi
+
+# 2. Workflows
+secrets=""
+for wf in .github/workflows/*.yml .github/workflows/*.yaml; do
+    [ -f "$wf" ] || continue
+    grep -qi repogarde "$wf" || continue
+    # shellcheck disable=SC2013 # noms sans espace
+    for nom in $(grep -oE '(secrets|vars)\.REPOGARDE_[A-Z0-9_]+' "$wf" | sort -u); do
+        secrets="$secrets ${nom/REPOGARDE_/REPOWARDEN_}"
+    done
+    # uses: vers l'ancien dépôt, toute référence (tag, branche d'essai) ;
+    # entrée retirée (version désormais fixée par uses:) ; anciens noms ;
+    # tickets.yml de la v4 : création de branches (contents: write)
+    change=""
+    reecrire "$wf" \
+        -e "s#(uses:[[:space:]]*)[A-Za-z0-9_.-]+/repogarde((/[^@[:space:]]+)?)@[^[:space:]]+#\\1simdevWarden/repowarden\\2@v$MAJEURE#" \
+        -e '/^[[:space:]]*repogarde-ref:/d' \
+        -e 's#SimBienvenueHoulBoumi/repogarde#simdevWarden/repowarden#g' \
+        -e 's/repogarde/repowarden/g' -e 's/REPOGARDE_/REPOWARDEN_/g' && change=1
+    # permissions du job (pas celles du workflow, souvent « {} »)
+    if grep -q 'repowarden/.github/workflows/tickets.yml' "$wf"; then
+        reecrire "$wf" -e '/^[[:space:]]*permissions:[[:space:]]*\{[^}]*issues:/{/contents:/!s/\{[[:space:]]*/{ contents: write, /;}' && change=1
+    fi
+    [ -z "$change" ] || fait mig.workflow "$wf"
+done
+if [ -f .github/workflows/repogarde.yml ] && [ ! -e .github/workflows/repowarden.yml ]; then
+    git mv .github/workflows/repogarde.yml .github/workflows/repowarden.yml 2>/dev/null ||
+        mv .github/workflows/repogarde.yml .github/workflows/repowarden.yml
+    fait mig.renamed .github/workflows/repogarde.yml .github/workflows/repowarden.yml
+fi
+
+# Suivi des tickets d'une version antérieure : sans l'événement push, le
+# premier push d'une branche de ticket n'ouvre pas la PR brouillon préremplie
+# (ni revue, assignation, fermeture : statuts figés). Section on: remplacée
+# par celle du modèle (repowarden tickets init), le reste gardé.
+for wf in .github/workflows/*.yml .github/workflows/*.yaml; do
+    [ -f "$wf" ] || continue
+    grep -q 'repowarden/.github/workflows/tickets.yml' "$wf" || continue
+    grep -qE '^  push:' "$wf" && continue
+    tmp="$(mktemp)"
+    awk '
+        /^on:/ {
+            print "on:"
+            print "  pull_request_target:"
+            print "    types: [opened, reopened, edited, synchronize, ready_for_review, converted_to_draft, closed]"
+            print "  pull_request_review:"
+            print "    types: [submitted]"
+            print "  issues:"
+            print "    types: [opened, labeled, assigned, closed]"
+            print "  push:"
+            print "    branches-ignore: [main, master, develop]"
+            dans = 1
+            next
+        }
+        dans && /^[^ #]/ { dans = 0 }
+        !dans { print }
+    ' "$wf" >"$tmp"
+    cat "$tmp" >"$wf"
+    rm -f "$tmp"
+    fait mig.tickets_events "$wf"
+    info_t mig.tickets_labels
+done
+
+# 3. Hooks lefthook résiduels (lefthook n'est plus pris en charge)
+hooks_dir="$(git rev-parse --git-common-dir)/hooks"
+residuels=""
+for h in "$hooks_dir"/*; do
+    [ -f "$h" ] && [[ "$h" != *.sample ]] && grep -qs lefthook "$h" && residuels="$residuels ${h##*/}"
+done
+if [ -n "$residuels" ]; then
+    if [ -n "$HOOKS_LEFTHOOK" ]; then
+        mkdir -p "$hooks_dir-lefthook"
+        for h in $residuels; do mv "$hooks_dir/$h" "$hooks_dir-lefthook/$h"; done
+        ok_t mig.hooks_moved "$residuels" "$hooks_dir-lefthook/"
+    else
+        attention_t mig.hooks_left "$residuels"
+    fi
+fi
+for f in lefthook.yml lefthook.yaml .lefthook.yml .lefthook.yaml; do
+    [ -f "$f" ] && attention_t mig.lefthook_conf "$f"
+done
+
+# 4. À faire à la main
+[ -z "$secrets" ] || attention_t mig.secrets "$secrets"
+restants="$(git grep -il repogarde -- . ':!CHANGELOG.md' 2>/dev/null | tr '\n' ' ' || true)"
+[ -z "$restants" ] || info_t mig.remaining "$restants"
+
+if [ "$FAITS" = 0 ]; then
+    ok_t mig.nothing
+    if [ -n "$PR" ]; then
+        git switch -q -
+        git branch -q -D "$BRANCHE"
+    fi
+    exit 0
+fi
+info_t mig.next
+
+[ -n "$PR" ] || exit 0
+git add -A
+t mig.commit_subject "$MAJEURE"
+sujet="$REPLY"
+t mig.commit_body
+bash "$ROOT/bin/commit" -m "$sujet" --type chore --scope migration --body "$REPLY"
+git push -q -u origin "$BRANCHE"
+t mig.pr_body
+corps="$REPLY"
+t mig.pr_after
+gh pr create --head "$BRANCHE" --title "chore(migration): $sujet" --body "$corps"$'\n\n'"$REPLY" >/dev/null
+ok_t mig.pr_created "$BRANCHE"

package/bin/proteger

@@ -193,7 +193,15 @@ if [ -n "$integration" ]; then
     # develop ne l'a pas reçu (retour main → develop vide après chaque
     # release). Une livraison n'apporte que develop, vérifiée par la CI ; le
     # retour reste fait quand main a un contenu propre (correctif direct).
+    # Garde-fou de livraison (statut posé par release-auto) : la livraison ne
+    # se merge que si elle peut aboutir (préversion publiée, protection en place)
+    contexts_branches="$contexts"
+    if grep -qs "release-auto.yml" "$GIT_TOPLEVEL"/.github/workflows/*.y*ml; then
+        contexts="${contexts:+$contexts,} {\"context\": \"livraison\", \"integration_id\": 15368}"
+        livraison_exigee=1
+    fi
     [ -z "$others" ] || rulesets+=("$(branch_ruleset repowarden "$others" '"merge"' false "$livraison" "$last_push" "$deploiement")")
+    contexts="$contexts_branches"
     # Branche d'intégration : squash seul (un commit par PR de travail, titre =
     # message : les commits intermédiaires n'entrent jamais) ; plus de retour
     # main → develop à merger, seuls develop et ses instantanés livraison/*
@@ -254,6 +262,7 @@ fi
 echo_t ci.proteger.1 "$REPO"
 echo_t ci.proteger.2 "$existing"
 echo_t ci.proteger.3 "$CHECKS"
+[ -z "${livraison_exigee:-}" ] || echo_t ci.proteger.livraison_check
 echo_t ci.proteger.4 "$methods" "$delete_on_merge"
 if [ -n "$integration" ] && [ "$DELIVERY" = deployment ]; then
     echo_t ci.proteger.delivery_deploy "$ENVIRONMENT" "$auto_merge"
@@ -360,12 +369,24 @@ erreur_github() {
     fi
 }
 
-anciens_rulesets
+# Rulesets indisponibles (dépôt privé d'un compte gratuit : GitHub les refuse
+# en 403) : les réglages du dépôt restent appliqués, les rulesets sautés avec
+# un message clair au lieu d'un arrêt sans explication
+RULESETS_OK=1
+if ! reponse="$(gh api "repos/$REPO/rulesets" 2>&1)" && [[ "$reponse" == *"403"* ]]; then
+    RULESETS_OK=""
+fi
+ANCIENS=""
+[ -z "$RULESETS_OK" ] || anciens_rulesets
 
 # shellcheck disable=SC2016 # expression jq (gh --jq), pas du shell
 SIG_EN_LIGNE='(.rules | map(select(.type == "pull_request"))[0].parameters) as $p
     | "approbations=\($p.required_approving_review_count) dernier_push=\($p.require_last_push_approval) codeowners=\($p.require_code_owner_review) deploiement=\([.rules[] | select(.type == "required_deployments") | .parameters.required_deployment_environments[]] | join(",")) verifications=\([.rules[] | select(.type == "required_status_checks") | .parameters.required_status_checks[].context] | sort | join(","))"'
 
+if [ -n "$VERIFY" ] && [ -z "$RULESETS_OK" ]; then
+    err_t ci.proteger.rulesets_unavailable "$REPO"
+    exit 1
+fi
 if [ -n "$VERIFY" ]; then
     ecarts=0
     for ruleset in "${rulesets[@]}"; do
@@ -407,6 +428,7 @@ if [ -n "$integration" ] && ! gh api "repos/$REPO/labels/urgent" --silent 2>/dev
 fi
 
 if [ -n "$DRY_RUN" ]; then
+    [ -n "$RULESETS_OK" ] || attention_t ci.proteger.rulesets_unavailable "$REPO"
     printf '%s\n' "${rulesets[@]}"
     [ -z "$env_json" ] || printf '%s\n' "$env_json"
     exit 0
@@ -421,7 +443,8 @@ gh api -X PUT "repos/$REPO/actions/permissions/workflow" --silent \
     -f default_workflow_permissions=read -F can_approve_pull_request_reviews=true
 
 echecs=0
-for ruleset in "${rulesets[@]}"; do
+[ -n "$RULESETS_OK" ] || { attention_t ci.proteger.rulesets_unavailable "$REPO"; rulesets=(); }
+for ruleset in ${rulesets[@]+"${rulesets[@]}"}; do
     name="$(sed -n 's/^  "name": "\(.*\)",$/\1/p' <<<"$ruleset")"
     # Ruleset posé sous l'ancien nom (repogarde, v3) : repris et renommé, sinon
     # il resterait à côté et exigerait une vérification « repogarde » disparue
@@ -454,6 +477,12 @@ for ruleset in "${rulesets[@]}"; do
         else
             ok_t ci.proteger.11 "$name"
         fi
+    elif [ "$name" = "repowarden (tags)" ] && [ "$owner_type" = Organization ] &&
+        [[ "$reponse" == *"ruleset source or owner organization"* ]] &&
+        gh api -X "$methode" "$chemin" --input - <<<"$(tags_ruleset User)" >/dev/null 2>&1; then
+        # Exception GitHub Actions refusée (App non installée dans l'organisation) :
+        # règle des comptes personnels, tags ni déplacés ni supprimés
+        attention_t ci.proteger.tags_fallback
     else
         erreur_github "$reponse"
         err_t ci.proteger.api_error "$name" "$REPLY"