repowarden 4.11.0-next.13 → 4.11.0-next.21

package/bin/pr-checks

@@ -21,9 +21,41 @@ if [[ "$1" == "--help" || "$1" == "-h" ]]; then
 fi
 command -v gh >/dev/null || { err_t bot.no_gh; exit 1; }
 
-n="${1}"
+n="${1#\#}"
 
 step_t pr.checks.checking "$n"
-gh api "repos/{{owner}}/{{repo}}/pulls/$n/check-runs" --jq '.check_runs[] | {name: .name, conclusion: .conclusion, status: .status, url: .html_url}' 2>/dev/null | while IFS= read -r line; do
-    echo "$line"
-done
+# gh pr checks résout le commit de tête de la PR : les check-runs y sont
+# rattachés, pas à la PR. Le verdict se calcule sur les lignes, pas sur son
+# code ; sans ligne, un code non nul est une vraie erreur (PR introuvable,
+# aucun check), déjà expliquée par gh
+rc=0
+lignes="$(gh pr checks "$n" --json name,bucket,link \
+    -q '.[] | [.bucket, .name, .link] | @tsv')" || rc=$?
+if [ -z "$lignes" ]; then
+    [ "$rc" -ne 0 ] || info_t pr.checks.none "$n"
+    exit "$rc"
+fi
+
+reussis=0 echecs=0 attentes=0
+while IFS=$'\t' read -r etat nom lien; do
+    case "$etat" in
+        pass | skipping) reussis=$((reussis + 1)) ;;
+        fail | cancel)
+            echecs=$((echecs + 1))
+            err_t pr.checks.failed "$nom" "$lien"
+            ;;
+        pending)
+            attentes=$((attentes + 1))
+            info_t pr.checks.pending "$nom"
+            ;;
+    esac
+done <<<"$lignes"
+
+if [ "$echecs" -gt 0 ]; then
+    err_t pr.checks.verdict "$n" "$reussis" "$echecs" "$attentes"
+    exit 1
+elif [ "$attentes" -gt 0 ]; then
+    info_t pr.checks.verdict "$n" "$reussis" "$echecs" "$attentes"
+else
+    ok_t pr.checks.green "$n"
+fi

package/bin/run-list

@@ -14,7 +14,7 @@ aide() {
     printf '%b\n' "$_T"
 }
 
-if [[ "$1" == "--help" || "$1" == "-h" ]]; then
+if [[ "${1:-}" == "--help" || "${1:-}" == "-h" ]]; then
     aide
     exit 0
 fi
@@ -34,14 +34,15 @@ done
 
 repo="${GH_REPO:-$(gh repo view --json nameWithOwner -q .nameWithOwner)}"
 
+# --jq plutôt que --template : le gabarit Go écrit les identifiants en
+# notation scientifique (3.96e+10), inutilisables par run rerun
+filtre=()
 if [ -n "$workflow" ]; then
     step_t run.listing.workflow "$workflow"
-    gh run list --repo "$repo" --workflow "$workflow" --limit "$limit" \
-        --json databaseId,name,conclusion,createdAt,headBranch \
-        --template '{{range .}}{{.databaseId}}	{{.name}}	{{.conclusion}}	{{.createdAt}}	{{.headBranch}}{{"\n"}}{{end}}'
+    filtre=(--workflow "$workflow")
 else
     step_t run.listing.all
-    gh run list --repo "$repo" --limit "$limit" \
-        --json databaseId,name,conclusion,createdAt,headBranch \
-        --template '{{range .}}{{.databaseId}}	{{.name}}	{{.conclusion}}	{{.createdAt}}	{{.headBranch}}{{"\n"}}{{end}}'
-fi
+fi
+gh run list --repo "$repo" ${filtre[@]+"${filtre[@]}"} --limit "$limit" \
+    --json databaseId,name,conclusion,createdAt,headBranch \
+    --jq '.[] | [.databaseId, .name, .conclusion, .createdAt, .headBranch] | @tsv'

package/bin/ticket

@@ -18,7 +18,9 @@ source "$ROOT/hooks/lib/common.sh"
 # shellcheck source=../hooks/lib/tickets.sh
 source "$ROOT/hooks/lib/tickets.sh"
 
-aide() { _tr help.ticket; printf '%b\n' "$_T" >&2; }
+# Aide sur la sortie standard quand elle est demandée (code 0) ; les cas
+# d'erreur la redirigent eux-mêmes vers stderr
+aide() { _tr help.ticket; printf '%b\n' "$_T"; }
 
 [ -n "$GIT_TOPLEVEL" ] || { err_t install.not_repo; exit 1; }
 cd "$GIT_TOPLEVEL"
@@ -62,9 +64,14 @@ cmd_ticket() {
     git fetch -q origin --prune
     ticket_remote_branch_r "$n"
     if [ -n "$REPLY" ]; then
-        switch_to "$REPLY"
+        local existante="$REPLY"
+        switch_to "$existante"
         prendre "$n"
-        ok_t tk.cli.switched "$REPLY" "$n"
+        ok_t tk.cli.switched "$existante" "$n"
+        # Faite avant la validation : jamais recréée, son lien va sur le ticket
+        if ticket_note_unlinked_branch "$n" "$existante"; then
+            attention_t tk.cli.unlinked "$existante" "$n"
+        fi
         return 0
     fi
     json="$(gh issue view "$n" --json state,title,labels \
@@ -97,6 +104,7 @@ cmd_nouveau() {
             --type) shift; type="${1:?--type attend un type}" ;;
             --description) shift; description="${1:?--description attend un texte}" ;;
             --porcelain) porcelain=1 ;;
+            -h | --help) aide; exit 0 ;;
             -*) err_t install.unknown_arg "$1"; exit 1 ;;
             *) titre="$1" ;;
         esac
@@ -151,6 +159,8 @@ case "${1:-}" in
         ;;
     *)
         if [[ "$1" =~ ^#?[0-9]+$ ]]; then
+            # ticket <n> --help : l'aide, sans prendre le ticket
+            case "${2:-}" in -h | --help) aide; exit 0 ;; esac
             cmd_ticket "${1#\#}"
         else
             err_t install.unknown_arg "$1"

package/ci/tickets/commun.sh

@@ -5,12 +5,16 @@
 # Chargé par ci/tickets.sh (après hooks/lib/common.sh et hooks/lib/tickets.sh).
 # shellcheck disable=SC2154 # statuts, réglages et compteurs définis dans les autres modules
 
+# Ligne de description lue comme référence de ticket (« Ticket : #12 », mot-clé
+# de fermeture) : partagée avec la PR brouillon, qui cite ces lignes reprises
+REF_TICKET_RE='^[[:space:]]*(Tickets?|Refs?|Closes|Fixes|Resolves)[[:space:]]*:?[[:space:]]*(.*)$'
+
 # REPLY = numéros de tickets (uniques) cités par la description $1 (« Ticket : #12 »,
 # « Tickets : #3, #4 », ou un mot-clé de fermeture) et la branche $2 (type/12-sujet)
 pr_tickets_r() {
     local body="$1" branch="$2" found="" n line
     while IFS= read -r line; do
-        if [[ "$line" =~ ^[[:space:]]*(Tickets?|Refs?|Closes|Fixes|Resolves)[[:space:]]*:?[[:space:]]*(.*)$ ]]; then
+        if [[ "$line" =~ $REF_TICKET_RE ]]; then
             for n in $(grep -oE '#[0-9]+' <<<"${BASH_REMATCH[2]}" | tr -d '#'); do
                 [[ " $found " == *" $n "* ]] || found="$found $n"
             done
@@ -53,10 +57,31 @@ statut() {
     gh issue edit "$n" --add-label "$s" ${retirer[@]+"${retirer[@]}"} >/dev/null
 }
 
+# Pied des commentaires du bot : l'avatar d'une App mène à une page 404 sur
+# GitHub (pas de profil), le pied dit d'où vient le bot. Repère invisible : un
+# texte déjà signé (repris, mis à jour) n'en reçoit pas un second.
+PIED="<!-- repowarden:pied -->"
+
+# REPLY = texte $1 terminé par le pied (page de l'App APP_SLUG, doc) ; sans
+# slug (jeton des Actions, github-actions[bot]) ou déjà signé, texte inchangé
+pied_r() {
+    REPLY="$1"
+    [ -n "${APP_SLUG:-}" ] && [[ "$REPLY" != *"$PIED"* ]] || return 0
+    _tr tk.footer "$APP_SLUG" "$APP_SLUG"
+    REPLY="$REPLY"$'\n\n'"$PIED<sub>$_T</sub>"
+}
+
+# Commentaire $2 du bot sur le ticket $1, avec son pied
+commenter() {
+    pied_r "$2"
+    gh issue comment "$1" --body "$REPLY" >/dev/null
+}
+
 # Ferme la PR $1 avec le commentaire $2 ; déjà fermée ou mergée entre-temps
 # (merge pendant le run) : rien à faire, pas un échec
 fermer_pr() {
-    gh pr close "$1" --comment "$2" >/dev/null 2>&1 && return 0
+    pied_r "$2"
+    gh pr close "$1" --comment "$REPLY" >/dev/null 2>&1 && return 0
     [ "$(gh pr view "$1" --json state -q .state 2>/dev/null)" != OPEN ]
 }
 

package/ci/tickets/issue.sh

@@ -17,12 +17,14 @@ accepter() {
         gh issue edit "$n" --remove-label "$A_DECIDER" >/dev/null
     fi
     # La branche naît quand le ticket est pris (assigné) : un ticket validé
-    # pour plus tard n'a pas de branche qui vieillit en attendant
-    if [ -n "$(assignes "$n")" ]; then
+    # pour plus tard n'a pas de branche qui vieillit en attendant. Une branche
+    # déjà faite à son nom (avant la validation) est reprise, jamais recréée.
+    branche_du_ticket_r "$n"
+    if [ -n "$REPLY" ] || [ -n "$(assignes "$n")" ]; then
         creer_branche "$n"
     else
         _tr tk.validated_waiting "$n"
-        gh issue comment "$n" --body "$_T" >/dev/null
+        commenter "$n" "$_T"
     fi
     while IFS=$'\t' read -r pr head sha base brouillon; do
         [ -n "$pr" ] || continue
@@ -117,7 +119,7 @@ cmd_issue() {
                     gh issue reopen "$ISSUE" >/dev/null
                     statut "$ISSUE" "$S_PREPROD"
                     _tr tk.reopened "$fpr" "$fbase"
-                    gh issue comment "$ISSUE" --body "$_T" >/dev/null
+                    commenter "$ISSUE" "$_T"
                     notice "$_T"
                     return 0
                 fi

package/ci/tickets/pr.sh

@@ -50,7 +50,7 @@ cmd_pr() {
         for n in $tickets; do
             statut "$n" "$S_PREPROD"
             _tr tk.merged "$PR" "$BASE"
-            gh issue comment "$n" --body "$_T" >/dev/null
+            commenter "$n" "$_T"
         done
         return 0
     fi

package/ci/tickets/push.sh

@@ -90,15 +90,128 @@ criteres_coches_r() {
     REPLY="${sortie%$'\n'}"
 }
 
-# REPLY = description de la PR brouillon du ticket $1 (branche $2) : le ticket
-# (critères en cases à cocher), puis la liste des commits, puis « Ticket : #N »
+# Fin de chaque commentaire lu d'un bloc (séparateur ASCII) : un texte écrit à
+# la main ne le contient pas, les commentaires se découpent sans ambiguïté
+SEP_COMMENTAIRE=$'\x1e'
+
+# REPLY = commentaires de mainteneur du ticket $1, chacun suivi d'une ligne
+# SEP_COMMENTAIRE : comme la conception, seul un mainteneur alimente la PR
+commentaires_mainteneur_r() {
+    REPLY="$(gh issue view "$1" --json comments -q '.comments[]
+        | select(.authorAssociation == "OWNER" or .authorAssociation == "MEMBER" or .authorAssociation == "COLLABORATOR")
+        | .body + "\n\u001e"' 2>/dev/null || true)"
+}
+
+# $1 = ligne d'un commentaire → REPLY : titre décalé d'un niveau (rangé sous la
+# section du bot), ligne citée si pr_tickets_r la lirait : seul le pied compte
+ligne_reprise_r() {
+    REPLY="$1"
+    [[ ! "$REPLY" =~ ^#{1,5}[[:space:]] ]] || REPLY="#$REPLY"
+    [[ ! "$REPLY" =~ $REF_TICKET_RE ]] || REPLY="> $REPLY"
+}
+
+# $1 = texte → REPLY : sans ses lignes vides finales
+sans_fin_vide_r() {
+    REPLY="$1"
+    while [[ "$REPLY" == *$'\n' ]]; do REPLY="${REPLY%$'\n'}"; done
+}
+
+# Première ligne d'un commentaire d'ajout : titre ou gras « Ajout… », « Constat lié… »
+AJOUT_RE='^(#{1,6}[[:space:]]+|\*\*)?([Aa]jouts?|[Cc]onstats?[[:space:]]+li(é|e)s?)([[:space:]:*(.,-]|$)'
+
+# $1 = commentaires (commentaires_mainteneur_r) → REPLY : ceux dont la première
+# ligne est un titre ou un gras « Ajout » / « Constat lié », dans l'ordre :
+# les ajouts faits au ticket après coup, que le corps du ticket n'a pas
+ajouts_ticket_r() {
+    local ligne bloc="" premiere="" sortie=""
+    while IFS= read -r ligne; do
+        ligne="${ligne%$'\r'}"
+        if [ "$ligne" = "$SEP_COMMENTAIRE" ]; then
+            if [[ "$premiere" =~ $AJOUT_RE ]]; then
+                sans_fin_vide_r "$bloc"
+                sortie="$sortie${sortie:+$'\n\n'}$REPLY"
+            fi
+            bloc="" premiere=""
+            continue
+        fi
+        if [ -z "$premiere" ]; then
+            [ -n "${ligne//[[:space:]]/}" ] || continue
+            premiere="$ligne"
+        fi
+        ligne_reprise_r "$ligne"
+        bloc="$bloc$REPLY"$'\n'
+    done <<<"$1"$'\n'"$SEP_COMMENTAIRE"
+    REPLY="$sortie"
+}
+
+# $1 = commentaires → REPLY : du dernier « Conception retenue », les blocs « Ce
+# qui change » et « Hors périmètre » (titre ou gras, jusqu'au libellé suivant) :
+# le périmètre sans les détails (fichiers, tests) que montre déjà le diff
+resume_conception_r() {
+    local ligne bloc="" dernier="" garder=0 conception=0
+    while IFS= read -r ligne; do
+        ligne="${ligne%$'\r'}"
+        if [ "$ligne" = "$SEP_COMMENTAIRE" ]; then
+            [ "$conception" = 0 ] || dernier="$bloc"
+            bloc="" garder=0 conception=0
+            continue
+        fi
+        if [[ "$ligne" =~ ^(#{1,6}[[:space:]]|\*\*) ]]; then
+            garder=0
+            case "$ligne" in
+                *[Cc]onception\ retenue*) conception=1; continue ;;
+                *[Cc]e\ qui\ change* | *[Hh]ors\ p*) garder=1 ;;
+            esac
+        fi
+        [ "$garder" = 1 ] || continue
+        ligne_reprise_r "$ligne"
+        bloc="$bloc$REPLY"$'\n'
+    done <<<"$1"$'\n'"$SEP_COMMENTAIRE"
+    sans_fin_vide_r "$dernier"
+}
+
+# $1 = description actuelle de la PR → REPLY : sa dernière section « ## Réalisé »
+# (jusqu'au titre suivant ou au pied), écrite par l'auteur : reprise telle quelle
+section_realise_r() {
+    local ligne dedans=0 section=""
+    while IFS= read -r ligne; do
+        ligne="${ligne%$'\r'}"
+        if [[ "$ligne" =~ ^##[[:space:]]+R(é|e)alis(é|e) ]]; then
+            dedans=1 section="$ligne"$'\n'
+        elif [ "$dedans" = 1 ]; then
+            if [[ "$ligne" =~ ^#{1,2}[[:space:]] || "$ligne" == "Ticket : #"* ]]; then
+                dedans=0
+            else
+                section="$section$ligne"$'\n'
+            fi
+        fi
+    done <<<"$1"
+    sans_fin_vide_r "$section"
+}
+
+# REPLY = description de la PR brouillon du ticket $1 (branche $2, PR $3 si
+# elle existe) : le ticket (critères en cases à cocher), ses ajouts en
+# commentaire, le résumé de sa conception, les commits, la section « Réalisé »
+# de l'auteur gardée, puis « Ticket : #N ». Le bot ne régénère que ses sections.
 description_pr_brouillon_r() {
-    local n="$1" branche="$2" corps commits
+    local n="$1" branche="$2" pr="${3:-}" corps commits commentaires
     criteres_coches_r "$(gh issue view "$n" --json body -q .body)"
     corps="$REPLY"
+    commentaires_mainteneur_r "$n"
+    commentaires="$REPLY"
+    ajouts_ticket_r "$commentaires"
+    _tr tk.pr_additions
+    [ -z "$REPLY" ] || corps="$corps"$'\n\n## '"$_T"$'\n'"$REPLY"
+    resume_conception_r "$commentaires"
+    _tr tk.pr_design
+    [ -z "$REPLY" ] || corps="$corps"$'\n\n## '"$_T"$'\n'"$REPLY"
     commits="$(gh api "repos/$GH_REPO/compare/$INTEGRATION...$branche" \
         -q '.commits[] | "- \(.sha[0:7]) \(.commit.message | split("\n")[0])"' 2>/dev/null || true)"
     [ -z "$commits" ] || corps="$corps"$'\n\n## Commits\n'"$commits"
+    if [ -n "$pr" ]; then
+        section_realise_r "$(gh pr view "$pr" --json body -q .body 2>/dev/null || true)"
+        [ -z "$REPLY" ] || corps="$corps"$'\n\n'"$REPLY"
+    fi
     REPLY="$corps"$'\n\nTicket : #'"$n"
 }
 
@@ -124,7 +237,7 @@ cmd_push() {
     [ "$(gh api "repos/$GH_REPO/compare/$INTEGRATION...$PUSH_BRANCH" -q .ahead_by)" != 0 ] || return 0
     titre_pr_brouillon_r "$n" "$PUSH_BRANCH"
     titre="$REPLY"
-    description_pr_brouillon_r "$n" "$PUSH_BRANCH"
+    description_pr_brouillon_r "$n" "$PUSH_BRANCH" "$pr"
     corps="$REPLY"
     if [ -n "$pr" ]; then
         gh pr edit "$pr" --title "$titre" --body "$corps" >/dev/null

package/ci/tickets/registre.sh

@@ -4,20 +4,8 @@
 # Chargé par ci/tickets.sh (après hooks/lib/common.sh et hooks/lib/tickets.sh).
 # shellcheck disable=SC2154 # statuts, réglages et compteurs définis dans les autres modules
 
-# Registre des branches d'un ticket : repère invisible dans les commentaires
-# du bot. GitHub ne lie une branche au ticket qu'à sa création, et une branche
-# liée supprimée y perd son nom : le registre garde le nom de chaque branche.
-REPERE="repowarden:branche"
-
-repere() { printf '<!-- %s %s -->' "$REPERE" "$1"; }
-
-# REPLY = branches inscrites sur le ticket $1 (séparées par des espaces)
-branches_inscrites_r() {
-    local corps
-    corps="$(gh issue view "$1" --json comments -q '.comments[].body' 2>/dev/null || true)"
-    REPLY="$(grep -oE "<!-- $REPERE [^ ]+ -->" <<<"$corps" | awk '{ printf "%s ", $3 }' || true)"
-    REPLY="${REPLY% }"
-}
+# Registre (REPERE, repere, branches_inscrites_r) : hooks/lib/tickets.sh,
+# partagé avec repowarden ticket.
 
 # Inscrit la branche $2 sur le ticket $1, une seule fois ($3 : origine, ex. PR #7).
 # Une seconde branche pour le même ticket est inscrite et signalée.
@@ -34,7 +22,7 @@ inscrire_branche() {
         _tr tk.branch_registered "$b"
     fi
     [ -z "$origine" ] || _T="$_T ($origine)"
-    gh issue comment "$n" --body "$_T"$'\n\n'"$(repere "$b")" >/dev/null
+    commenter "$n" "$_T"$'\n\n'"$(repere "$b")"
     INSCRITES=$((INSCRITES + 1))
 }
 
@@ -65,19 +53,23 @@ nettoyer_branche() {
         notice_t tk.branch_deleted "$branche" "$n"
     else
         _tr tk.branch_kept "$branche" "${avance:-?}" "${prs:--}"
-        gh issue comment "$n" --body "$_T" >/dev/null
+        commenter "$n" "$_T"
     fi
 }
 
 # Ticket $1 validé : sa branche naît de la branche d'intégration, liée au
-# ticket (panneau « Development »). Rien si elle existe déjà, ou si une PR
-# ouverte cite déjà le ticket (travail commencé hors de sa branche).
+# ticket (panneau « Development »). Rien si une PR ouverte cite déjà le ticket
+# (travail commencé hors de sa branche) ; si elle existe déjà, jamais recréée :
+# faite avant la validation, elle n'est pas liée et son lien est inscrit.
 creer_branche() {
     local n="$1" titre labels branche pr head body
     # Travail déjà mergé ou en production : plus de branche à (re)créer
     travail_termine "$(etiquettes "$n")" && return 0
     branche_du_ticket_r "$n"
-    [ -z "$REPLY" ] || return 0
+    if [ -n "$REPLY" ]; then
+        ticket_note_unlinked_branch "$n" "$REPLY" || true
+        return 0
+    fi
     while IFS=$'\t' read -r pr head; do
         [ -n "$pr" ] || continue
         body="$(gh pr view "$pr" --json body -q .body)"
@@ -97,6 +89,6 @@ creer_branche() {
         -f oid="$(gh api "repos/$GH_REPO/git/ref/heads/$INTEGRATION" -q .object.sha)" \
         -f name="$branche" >/dev/null
     _tr tk.branch_created "$branche" "$INTEGRATION" "$n" "$branche"
-    gh issue comment "$n" --body "$_T"$'\n\n'"$(repere "$branche")" >/dev/null
+    commenter "$n" "$_T"$'\n\n'"$(repere "$branche")"
     notice_t tk.branch_notice "$branche" "$n"
 }

package/ci/tickets/release.sh

@@ -21,10 +21,11 @@ cmd_release() {
     while IFS= read -r n; do
         [ -n "$n" ] || continue
         if [[ "$tag" == *-* ]]; then
-            gh issue comment "$n" --body "$msg" >/dev/null
+            commenter "$n" "$msg"
         else
             statut "$n" "$S_DONE"
-            gh issue close "$n" --comment "$msg" >/dev/null
+            pied_r "$msg"
+            gh issue close "$n" --comment "$REPLY" >/dev/null
             nettoyer_branche "$n"
         fi
     done < <(gh issue list --state open --label "$S_PREPROD" --limit 500 --json number -q '.[].number')

package/ci/tickets.sh

@@ -25,8 +25,8 @@
 # feat/12-sujet. « Closes #12 » fermerait le ticket dès le merge dans develop :
 # c'est la release qui le ferme.
 #
-# Variables : GH_TOKEN, GH_REPO, INTEGRATION ; pr : PR, ACTION, MERGED, DRAFT,
-# HEAD, BASE, HEAD_SHA, AUTHOR ; issue : ISSUE, ACTION, LABEL, STATE_REASON ;
+# Variables : GH_TOKEN, GH_REPO, INTEGRATION, APP_SLUG (pied des commentaires) ;
+# pr : PR, ACTION, MERGED, DRAFT, HEAD, BASE, HEAD_SHA, AUTHOR ; issue : ISSUE, ACTION, LABEL, STATE_REASON ;
 # push : PUSH_BRANCH, DELETED, PUSHER, SHA ; revue : PR, HEAD, REVIEW_STATE ;
 # release : TAG, ou DELIVERED_SHA et MAIN (livraison sans nouvelle version)
 set -euo pipefail

package/hooks/lib/commentaires.sh

@@ -0,0 +1,123 @@
+#!/usr/bin/env bash
+# Fonctions ajoutées sans commentaire : chaque nouvelle fonction doit dire,
+# juste au-dessus, ce qu'elle fait et pourquoi (docstring acceptée en Python).
+# Comme pour le code mort, seul le code ajouté compte : une fonction dont le
+# nom existait déjà dans le fichier n'est jamais signalée, même retouchée.
+# Avertissement seulement (pre-commit et CI), désactivable par skip = comments.
+# Langages : Shell (.sh, .bash, ou shebang sh/bash), Python, JavaScript/TypeScript.
+
+# Une ligne « fichier:ligne<TAB>nom » par fonction ajoutée sans commentaire
+# entre $1 (commit de base) et $2 (commit, ou vide pour le contenu stagé).
+comments_missing() {
+    local base="$1" new="$2" st a b f old lang added tmp
+    tmp="$(mktemp -d)"
+    while IFS=$'\t' read -r st a b; do
+        [ -n "$a" ] || continue
+        # Renommage ou copie : l'ancien chemin donne les fonctions existantes
+        if [ -n "$b" ]; then old="$a" f="$b"; else old="$a" f="$a"; fi
+        is_excluded "$f" && continue
+        case "${f##*/}" in
+            *.sh | *.bash) lang=shell ;;
+            *.py) lang=py ;;
+            *.js | *.jsx | *.mjs | *.cjs | *.ts | *.tsx) lang=js ;;
+            *.*) continue ;;
+            *) lang=shebang ;;
+        esac
+        git show "$new:$f" >"$tmp/new" 2>/dev/null || continue
+        if [ "$lang" = shebang ]; then
+            # Script sans extension (bin/…) : seul un shebang sh ou bash compte
+            IFS= read -r st <"$tmp/new" || true
+            [[ "$st" =~ ^#!.*[/\ ](ba)?sh([[:space:]]|$) ]] || continue
+            lang=shell
+        fi
+        git show "$base:$old" >"$tmp/base" 2>/dev/null || : >"$tmp/base"
+        if [ -n "$new" ]; then
+            git diff -U0 --no-color --no-ext-diff "$base" "$new" -- "$f"
+        else
+            git diff --cached -U0 --no-color --no-ext-diff "$base" -- "$f"
+        fi 2>/dev/null >"$tmp/diff"
+        # Numéros des lignes ajoutées ou modifiées, d'après les en-têtes @@
+        added="$(awk '/^@@/ {
+            split($3, a, ","); s = substr(a[1], 2); n = (a[2] == "" ? 1 : a[2])
+            for (i = 0; i < n; i++) printf " %d", s + i
+        }' "$tmp/diff") "
+        [ "$added" != " " ] || continue
+        awk -v lang="$lang" -v added="$added" -v f="$f" -v q="'" "$COMMENTS_AWK" "$tmp/base" "$tmp/new"
+    done < <(
+        if [ -n "$new" ]; then
+            git diff --name-status -M --diff-filter=ACMR "$base" "$new"
+        else
+            git diff --cached --name-status -M --diff-filter=ACMR "$base"
+        fi 2>/dev/null
+    )
+    rm -rf "$tmp"
+}
+
+# Avertit des fonctions ajoutées sans commentaire, sans jamais bloquer : le
+# commentaire aide la relecture, son absence n'est pas une faute. REPLY = nombre.
+comments_check() {
+    local loc name n=0
+    while IFS=$'\t' read -r loc name; do
+        [ -n "$loc" ] || continue
+        n=$((n + 1))
+        attention_t cm.missing "$loc" "$name"
+    done < <(comments_missing "$1" "$2")
+    [ "$n" = 0 ] || info_t cm.summary "$n"
+    REPLY="$n"
+}
+
+# Programme awk de comments_missing : lit le fichier de base (noms des
+# fonctions existantes) puis le nouveau, et signale les fonctions nouvelles
+# dont aucune ligne de commentaire ne précède la déclaration
+# shellcheck disable=SC2016 # programme awk, rien à développer
+COMMENTS_AWK='
+# Nom de la fonction déclarée par la ligne l (vide sinon), selon le langage
+function nom(l) {
+    if (lang == "shell") {
+        if (l ~ /^[ \t]*function[ \t]+[A-Za-z_]/) {
+            sub(/^[ \t]*function[ \t]+/, "", l); sub(/[ \t(){}].*$/, "", l); return l
+        }
+        if (l ~ /^[ \t]*[A-Za-z_][A-Za-z0-9_:.@-]*[ \t]*\(\)/) {
+            sub(/^[ \t]*/, "", l); sub(/[ \t]*\(\).*$/, "", l); return l
+        }
+    } else if (lang == "py") {
+        if (l ~ /^[ \t]*(async[ \t]+)?def[ \t]+[A-Za-z_]/) {
+            sub(/^[ \t]*(async[ \t]+)?def[ \t]+/, "", l); sub(/[^A-Za-z0-9_].*$/, "", l); return l
+        }
+    } else {
+        if (l ~ /^[ \t]*(export[ \t]+(default[ \t]+)?)?(async[ \t]+)?function[ \t]*\*?[ \t]*[A-Za-z_$]/) {
+            sub(/^[ \t]*(export[ \t]+(default[ \t]+)?)?(async[ \t]+)?function[ \t]*\*?[ \t]*/, "", l)
+            sub(/[^A-Za-z0-9_$].*$/, "", l); return l
+        }
+        if (l ~ /^[ \t]*(export[ \t]+)?(const|let|var)[ \t]+[A-Za-z_$][A-Za-z0-9_$]*[ \t]*(:[^=]*)?=[ \t]*(async[ \t]+)?(function[^A-Za-z0-9_$]|function$|\([^)]*\)[^=]*=>|[A-Za-z_$][A-Za-z0-9_$]*[ \t]*=>)/) {
+            sub(/^[ \t]*(export[ \t]+)?(const|let|var)[ \t]+/, "", l); sub(/[^A-Za-z0-9_$].*$/, "", l); return l
+        }
+    }
+    return ""
+}
+# Directive d outil (shellcheck, eslint, noqa…) : n explique rien, on regarde au-dessus
+function directive(l) {
+    return l ~ /^[ \t]*(#|\/\/)[ \t]*(shellcheck|noqa|type:|pylint:|eslint|@ts-|prettier-)/
+}
+# Commentaire juste au-dessus de la ligne i (décorateurs et directives sautés),
+# ou docstring en tête du corps pour Python
+function commentee(i,   j, s) {
+    for (j = i - 1; j > 0 && (L[j] ~ /^[ \t]*@/ || directive(L[j])); j--) ;
+    if (j > 0 && L[j] !~ /^#!/ && L[j] ~ /^[ \t]*(#|\/\/|\/\*|\*)/) return 1
+    if (lang != "py") return 0
+    # Fin de la signature (deux-points en fin de ligne), puis première ligne non vide
+    for (j = i; j <= N && j < i + 20 && L[j] !~ /:[ \t]*(#.*)?$/; j++) ;
+    for (j++; j <= N && L[j] ~ /^[ \t]*$/; j++) ;
+    s = "^[ \t]*[rRuUbBfF]*[\"" q "]"
+    return j <= N && L[j] ~ s
+}
+FILENAME == ARGV[1] { n = nom($0); if (n != "") ancien[n] = 1; next }
+{ L[FNR] = $0; N = FNR }
+END {
+    for (i = 1; i <= N; i++) {
+        if (index(added, " " i " ") == 0) continue
+        n = nom(L[i])
+        if (n == "" || (n in ancien) || commentee(i)) continue
+        print f ":" i "\t" n
+    }
+}'

package/hooks/lib/i18n/en.sh

@@ -56,6 +56,7 @@ _msg_en() {
         tk.cli.silence) _M="Project without ticket tracking? git config repowarden.skip tickets to stop seeing this." ;;
         tk.cli.fetch) _M="Branch of ticket #%s…" ;;
         tk.cli.switched) _M="On branch %s (ticket #%s)." ;;
+        tk.cli.unlinked) _M="Branch %s was created before validation: GitHub cannot link it to ticket #%s afterwards, its link is written on the ticket." ;;
         tk.cli.created_branch) _M="Branch %s created from %s, linked to ticket #%s." ;;
         tk.cli.not_validated) _M="Ticket #%s not validated yet: its branch will be created automatically on validation (\"%s\" label)." ;;
         tk.cli.closed) _M="Ticket #%s is closed: no branch to create." ;;
@@ -121,7 +122,7 @@ _msg_en() {
         help.code-mort) _M="Usage: repowarden code-mort [base]\n\nDead code introduced by your branch (like CI): only added/changed lines\nsince base (commits, staged/uncommitted, new files). Default: merge-base\nwith origin/main. See docs/code-mort.md (proven vs candidates)." ;;
         help.ticket) _M="Usage: repowarden ticket <n>                          branch for ticket (created, linked if needed)\n       repowarden ticket                              ticket of current branch\n       repowarden ticket nouveau \"<title>\" [--type fix] [--description \"…\"]\n       repowarden ticket comment <n> \"<text>\"         add comment\n       repowarden ticket label <n> <label> [--remove] manage labels\n\nTicket first: taking <n> assigns to you and switches to its branch\n(created from develop if needed). \"nouveau\" creates a ticket (\"à valider\"\nif tracking is managed). Needs gh connected (https://cli.github.com)." ;;
         help.tickets) _M="Usage: repowarden tickets init [--repo owner/name] [--sans-validation-auto]\n       repowarden tickets sync\n\nSets up ticket tracking: labels, issue template, workflow; classifies\nexisting tickets; records PR branches. sync checks out local branches for\ntickets assigned to you (auto with ticketSync=auto, manual by default)." ;;
-        help.pr) _M="Usage: repowarden pr label <n> <label> [--remove]\n       repowarden pr checks <n>\n\nlabel adds or removes a label from PR #<n>; checks shows its checks\n(name, conclusion, status, link).\nExamples:\n  repowarden pr label 123 \"ready-for-review\"\n  repowarden pr label 123 \"needs-changes\" --remove\n  repowarden pr checks 123" ;;
+        help.pr) _M="Usage: repowarden pr label <n> <label> [--remove]\n       repowarden pr checks <n>\n\nlabel adds or removes a label from PR #<n>; checks lists its failed\njobs (with their link) and pending ones, then the verdict; exit 1 if a job fails.\nExamples:\n  repowarden pr label 123 \"ready-for-review\"\n  repowarden pr label 123 \"needs-changes\" --remove\n  repowarden pr checks 123" ;;
         help.run) _M="Usage: repowarden run rerun <run-id|--failed|--workflow <name>>\n       repowarden run list [--workflow <name>] [--limit N]\n\nrerun restarts a GitHub Actions workflow. list shows recent runs\n(default limit 20).\nExamples:\n  repowarden run rerun --failed\n  repowarden run list --workflow \"CI\" --limit 10" ;;
         help.proteger) _M="Usage: repowarden proteger [--repo owner/name] [--checks \"repowarden,tests (ubuntu-latest)\"]\n       [--relecteurs N] [--codeowners] [--environnement NAME] [--approbateurs \"login …\"]\n       [--sans-tags] [--dry-run] [--verifier]\n\nProtects GitHub repo per .repowarden.conf: required PR, required checks,\nno force push/deletion, ruleset, squash merges, v* tags reserved to\nworkflows, optional human approvals. --verifier checks online rules\nwithout changes. Needs gh and admin rights." ;;
         help.migrer) _M="Usage: repowarden migrer [--pr] [--hooks]\n\nMigrates from repogarde to repowarden (docs/migration-v4.md): configs,\nworkflows, renames, lists manual steps left. Safe to rerun.\n  --pr     on chore/migration-repowarden-vN: commit, push and PR\n  --hooks  also move leftover lefthook hooks to .git/hooks-lefthook/" ;;
@@ -293,6 +294,11 @@ _msg_en() {
         ci.fix_pr.2) _M="PR #%s retargeted: %s → %s (%s flow)" ;;
         ci.fix_pr.3) _M="Title follows the convention: %s" ;;
         ci.fix_pr.4) _M="Title \"%s\" replaced with \"%s\"" ;;
+        ci.verrous_pip.compile) _M="Lock file %s: re-running the command from its header" ;;
+        ci.verrous_pip.refused) _M="Lock file %s skipped: the output of its header command is not this file" ;;
+        ci.verrous_pip.compliant) _M="pip lock files match their header: no commit" ;;
+        ci.verrous_pip.committed) _M="Lock files regenerated and committed: %s" ;;
+        ci.verrous_pip.pushed) _M="Commit pushed to %s" ;;
         ci.version.1) _M="version announced by the delivery PR" ;;
         ci.version.2) _M="No feat, fix, perf or breaking change since %s: no version." ;;
         ci.version.3) _M="first version" ;;
@@ -426,6 +432,12 @@ _msg_en() {
         dc.knip_file) _M="file never imported" ;;
         dc.knip_export) _M="export never imported:" ;;
         dc.knip_dep) _M="dependency never imported:" ;;
+        # Functions added without a comment
+        cm.section) _M="Functions without a comment (new code only)" ;;
+        cm.no_base) _M="No base: comment check skipped." ;;
+        cm.missing) _M="%s: function %s has no comment right above it" ;;
+        cm.summary) _M="%s function(s) added without a comment: one or two lines right above, saying what it does and why (warning, not blocking)." ;;
+        cm.none) _M="Every added function has a comment." ;;
         ci.section.commits) _M="Commit messages (Conventional Commits)" ;;
         ci.section.branch) _M="Branch name" ;;
         ci.section.secrets) _M="Secrets (gitleaks)" ;;
@@ -644,6 +656,7 @@ _msg_en() {
         tk.pr_backmerge_empty) _M="PR closed automatically: \`%s\` brings no content to \`%s\`. The back-merge is done automatically after a release, only when there is something to bring back." ;;
         tk.pr_delivery_manual) _M="PR closed automatically: the \`%s\` → \`%s\` delivery is opened by the release workflow; a PR opened by hand would never get a deployment approval. Run *Actions → release → Run workflow* on \`%s\` (or \`gh workflow run release.yml --ref %s\`), then **Approve and deploy** on the run." ;;
         tk.branch_registered) _M="Ticket branch: \`%s\`." ;;
+        tk.branch_unlinked) _M="Ticket branch: [\`%s\`](%s). Created before the ticket was validated: GitHub does not link an existing branch, so it does not show under *Development*; this comment keeps its link." ;;
         tk.branch_second) _M="Second branch for this ticket: \`%s\` (already: %s). One ticket, one branch: group the work, or open a separate ticket." ;;
         tk.adopted) _M="Existing tickets: %s sorted, %s branch(es) registered." ;;
         tk.init_adopt) _M="Existing tickets and branches" ;;
@@ -652,6 +665,8 @@ _msg_en() {
         tk.branch_kept) _M="Branch \`%s\` kept: %s commit(s) missing from the integration branch, open PR(s): %s. Delete it by hand if the work lives elsewhere." ;;
         tk.draft_opened) _M="Draft PR #%s opened for ticket #%s" ;;
         tk.draft_updated) _M="PR #%s (ticket #%s): title and description taken from the ticket" ;;
+        tk.pr_additions) _M="Ticket additions" ;;
+        tk.pr_design) _M="Design (summary)" ;;
         tk.created_body) _M="Ticket created automatically for PR #%s, which cited none. To be validated by a maintainer (\"validé\" label)." ;;
         tk.created) _M="Ticket #%s created for PR #%s and linked in its description: to be validated by a maintainer." ;;
         tk.init_labels) _M="Labels (statuses and validation)" ;;
@@ -665,6 +680,7 @@ _msg_en() {
         tk.init_next_wired) _M="Next: commit these files; require the \"ticket\" check (repowarden proteger --checks \"…,ticket\"). The tickets job of release.yml is already wired." ;;
         tk.prerelease) _M="Available in pre-release **%s**: to be tested before production." ;;
         tk.released) _M="Released in **%s**." ;;
+        tk.footer) _M="Posted by this repository's GitHub App ([repowarden docs](https://simdevwarden.github.io/repowarden/en/industrialisation/#github-app-for-workflows)): [%s](https://github.com/apps/%s)" ;;
         tk.delivered) _M="Delivered to **%s**, without a new version (commit %s)." ;;
         # Ticket comment
         tk.comment.adding) _M="Adding comment to ticket #%s..." ;;
@@ -691,6 +707,11 @@ _msg_en() {
         run.listing.workflow) _M="Listing runs for workflow \"%s\"..." ;;
         # PR checks
         pr.checks.checking) _M="Checking checks for PR #%s..." ;;
+        pr.checks.failed) _M="Failed: %s  %s" ;;
+        pr.checks.pending) _M="Pending: %s" ;;
+        pr.checks.verdict) _M="PR #%s: %s passed, %s failed, %s pending." ;;
+        pr.checks.green) _M="All checks of PR #%s are green." ;;
+        pr.checks.none) _M="No check on PR #%s." ;;
         # AI agent guard (repowarden garde, repowarden agents)
         garde.format) _M="Unknown format \"%s\": claude or opencode." ;;
         garde.no_jq) _M="repowarden garde: jq missing, action not checked (install jq: https://jqlang.org)." ;;

package/hooks/lib/i18n/fr.sh

@@ -56,6 +56,7 @@ _msg_fr() {
         tk.cli.silence) _M="Projet sans suivi de tickets ? git config repowarden.skip tickets pour ne plus le voir." ;;
         tk.cli.fetch) _M="Branche du ticket #%s…" ;;
         tk.cli.switched) _M="Sur la branche %s (ticket #%s)." ;;
+        tk.cli.unlinked) _M="Branche %s créée avant la validation : GitHub ne la lie pas au ticket #%s après coup, son lien est inscrit sur le ticket." ;;
         tk.cli.created_branch) _M="Branche %s créée depuis %s, liée au ticket #%s." ;;
         tk.cli.not_validated) _M="Ticket #%s pas encore validé : sa branche sera créée automatiquement à la validation (étiquette « %s »)." ;;
         tk.cli.closed) _M="Ticket #%s fermé : pas de branche à créer." ;;
@@ -244,7 +245,7 @@ _msg_fr() {
         help.code-mort) _M="Usage : repowarden code-mort [base]\n\nCode mort introduit par ta branche, comme en CI : seules les lignes ajoutées\nou modifiées depuis la base comptent (commits, modifications en cours,\nnouveaux fichiers). Défaut : point de départ de la branche depuis origin/main.\nVoir docs/code-mort.md : ce qui est prouvé (bloquant) et ce qui est candidat." ;;
         help.ticket) _M="Usage : repowarden ticket <n>                          branche du ticket (créée, liée, si besoin)\n        repowarden ticket                              ticket de la branche courante\n        repowarden ticket nouveau \"<titre>\" [--type fix] [--description \"…\"]\n        repowarden ticket comment <n> \"<texte>\"        commentaire sur le ticket\n        repowarden ticket label <n> <label> [--remove] labels du ticket\n\nLe ticket d'abord : prendre <n> l'assigne à toi et place sur sa branche\n(créée depuis develop au besoin) ; nouveau crée le ticket (« à valider » si\nle suivi est géré par repowarden). Demande gh connecté (https://cli.github.com)." ;;
         help.tickets) _M="Usage : repowarden tickets init [--repo propriétaire/nom] [--sans-validation-auto]\n        repowarden tickets sync\n\nPrépare le suivi des tickets d'un dépôt GitHub (relançable sans risque) :\nétiquettes (« validé », statuts et types, préfixe des branches), modèle de\nticket, workflow ; tickets existants rangés ; branches des PR inscrites sur\nleurs tickets. sync : branches locales des tickets qui me sont assignés\n(automatique avec ticketSync = auto, défaut manual)." ;;
-        help.pr) _M="Usage : repowarden pr label <n> <label> [--remove]\n        repowarden pr checks <n>\n\nlabel ajoute ou retire un label sur la PR #<n> ; checks affiche l'état de\nses checks (nom, conclusion, statut, lien).\nExemples :\n  repowarden pr label 123 \"ready-for-review\"\n  repowarden pr label 123 \"needs-changes\" --remove\n  repowarden pr checks 123" ;;
+        help.pr) _M="Usage : repowarden pr label <n> <label> [--remove]\n        repowarden pr checks <n>\n\nlabel ajoute ou retire un label sur la PR #<n> ; checks liste ses jobs en\néchec (avec leur lien) et en attente, puis le verdict ; code 1 si un job échoue.\nExemples :\n  repowarden pr label 123 \"ready-for-review\"\n  repowarden pr label 123 \"needs-changes\" --remove\n  repowarden pr checks 123" ;;
         help.run) _M="Usage : repowarden run rerun <run-id|--failed|--workflow <nom>>\n        repowarden run list [--workflow <nom>] [--limit N]\n\nrerun relance un workflow GitHub Actions : un run par son id, le dernier\néchoué (--failed) ou le dernier d'un workflow (--workflow) ; list affiche\nles runs récents (--limit, défaut 20).\nExemples :\n  repowarden run rerun --failed\n  repowarden run list --workflow \"CI\" --limit 10" ;;
         help.proteger) _M="Usage : repowarden proteger [--repo propriétaire/nom] [--checks \"repowarden,tests (ubuntu-latest)\"]\n        [--relecteurs N] [--codeowners] [--environnement NOM] [--approbateurs \"login …\"]\n        [--sans-tags] [--dry-run] [--verifier]\n\nProtège le dépôt GitHub courant d'après .repowarden.conf (relançable sans\nrisque) : PR obligatoire, vérifications exigées, ni suppression ni push forcé\n(ruleset « repowarden »), merge squash, tags v* réservés aux workflows,\nvalidation humaine optionnelle. --verifier compare les règles en ligne sans\nrien modifier. Réglages équivalents dans .repowarden.conf. Demande gh et les\ndroits d'administration du dépôt." ;;
         help.migrer) _M="Usage : repowarden migrer [--pr] [--hooks]\n\nPassage de repogarde à repowarden dans le projet courant\n(docs/migration-v4.md) : configuration (.repowarden.conf, .repowarden/),\nworkflows (uses: vers le dépôt repowarden et sa version majeure, anciens\nnoms), puis la liste de ce qui reste à faire à la main. Relançable : rien\nn'est fait deux fois.\n  --pr     sur la branche chore/migration-repowarden-vN : commit, push et PR\n  --hooks  déplace aussi les hooks lefthook résiduels dans .git/hooks-lefthook/" ;;
@@ -294,6 +295,11 @@ _msg_fr() {
         ci.fix_pr.2) _M="PR #%s reciblée : %s → %s (flux %s)" ;;
         ci.fix_pr.3) _M="Titre conforme : %s" ;;
         ci.fix_pr.4) _M="Titre « %s » remplacé par « %s »" ;;
+        ci.verrous_pip.compile) _M="Verrou %s : commande de son en-tête relancée" ;;
+        ci.verrous_pip.refused) _M="Verrou %s ignoré : la sortie de la commande de son en-tête n'est pas ce fichier" ;;
+        ci.verrous_pip.compliant) _M="Verrous pip conformes à leur en-tête : aucun commit" ;;
+        ci.verrous_pip.committed) _M="Verrous régénérés et commités : %s" ;;
+        ci.verrous_pip.pushed) _M="Commit poussé sur %s" ;;
         ci.version.1) _M="version annoncée par la PR de livraison" ;;
         ci.version.2) _M="Aucun feat, fix, perf ni changement incompatible depuis %s : pas de version." ;;
         ci.version.3) _M="première version" ;;
@@ -427,6 +433,12 @@ _msg_fr() {
         dc.knip_file) _M="fichier jamais importé" ;;
         dc.knip_export) _M="export jamais importé :" ;;
         dc.knip_dep) _M="dépendance jamais importée :" ;;
+        # Fonctions ajoutées sans commentaire
+        cm.section) _M="Fonctions sans commentaire (nouveau code uniquement)" ;;
+        cm.no_base) _M="Pas de base : contrôle des commentaires ignoré." ;;
+        cm.missing) _M="%s : fonction %s sans commentaire juste au-dessus" ;;
+        cm.summary) _M="%s fonction(s) ajoutée(s) sans commentaire : une à deux lignes juste au-dessus, qui disent ce qu'elle fait et pourquoi (avertissement, non bloquant)." ;;
+        cm.none) _M="Chaque fonction ajoutée est commentée." ;;
         ci.section.commits) _M="Messages de commit (Conventional Commits)" ;;
         ci.section.branch) _M="Nom de branche" ;;
         ci.section.secrets) _M="Secrets (gitleaks)" ;;
@@ -645,6 +657,7 @@ _msg_fr() {
         tk.pr_backmerge_empty) _M="PR fermée automatiquement : \`%s\` n'apporte aucun contenu à \`%s\`. Le retour est fait automatiquement après une release, seulement quand il y a quelque chose à rapporter." ;;
         tk.pr_delivery_manual) _M="PR fermée automatiquement : la livraison \`%s\` → \`%s\` est ouverte par le workflow de release ; une PR ouverte à la main n'aurait jamais d'approbation de déploiement. Lancer *Actions → release → Run workflow* sur \`%s\` (ou \`gh workflow run release.yml --ref %s\`), puis **Approve and deploy** sur le run." ;;
         tk.branch_registered) _M="Branche du ticket : \`%s\`." ;;
+        tk.branch_unlinked) _M="Branche du ticket : [\`%s\`](%s). Créée avant la validation du ticket : GitHub ne lie pas une branche existante, elle n'apparaît donc pas dans « Development » ; ce commentaire en garde le lien." ;;
         tk.branch_second) _M="Seconde branche pour ce ticket : \`%s\` (déjà : %s). Un ticket, une branche : regrouper le travail, ou ouvrir un ticket séparé." ;;
         tk.adopted) _M="Tickets existants : %s rangé(s), %s branche(s) inscrite(s)." ;;
         tk.init_adopt) _M="Tickets et branches existants" ;;
@@ -653,6 +666,8 @@ _msg_fr() {
         tk.branch_kept) _M="Branche \`%s\` gardée : %s commit(s) absent(s) de la branche d'intégration, PR ouverte(s) : %s. À supprimer à la main si le travail est ailleurs." ;;
         tk.draft_opened) _M="PR #%s ouverte en brouillon pour le ticket #%s" ;;
         tk.draft_updated) _M="PR #%s (ticket #%s) : titre et description repris du ticket" ;;
+        tk.pr_additions) _M="Ajouts du ticket" ;;
+        tk.pr_design) _M="Conception (résumé)" ;;
         tk.created_body) _M="Ticket créé automatiquement pour la PR #%s, qui n'en citait aucun. À valider par un mainteneur (étiquette « validé »)." ;;
         tk.created) _M="Ticket #%s créé pour la PR #%s et relié à sa description : à valider par un mainteneur." ;;
         tk.init_labels) _M="Étiquettes (statuts et validation)" ;;
@@ -666,6 +681,7 @@ _msg_fr() {
         tk.init_next_wired) _M="Ensuite : committer ces fichiers ; exiger la vérification « ticket » (repowarden proteger --checks \"…,ticket\"). Le job tickets de release.yml est déjà branché." ;;
         tk.prerelease) _M="Disponible en préversion **%s** : à tester avant la production." ;;
         tk.released) _M="Publié dans **%s**." ;;
+        tk.footer) _M="Message de l'App GitHub de ce dépôt ([doc repowarden](https://simdevwarden.github.io/repowarden/industrialisation/#github-app-des-workflows)) : [%s](https://github.com/apps/%s)" ;;
         tk.delivered) _M="Livré sur **%s**, sans nouvelle version (commit %s)." ;;
         # Ticket comment
         tk.comment.adding) _M="Ajout d'un commentaire sur le ticket #%s..." ;;
@@ -692,6 +708,11 @@ _msg_fr() {
         run.listing.workflow) _M="Liste des runs du workflow « %s »..." ;;
         # PR checks
         pr.checks.checking) _M="Vérification des checks de la PR #%s..." ;;
+        pr.checks.failed) _M="En échec : %s  %s" ;;
+        pr.checks.pending) _M="En attente : %s" ;;
+        pr.checks.verdict) _M="PR #%s : %s réussi(s), %s en échec, %s en attente." ;;
+        pr.checks.green) _M="Tous les checks de la PR #%s sont verts." ;;
+        pr.checks.none) _M="Aucun check sur la PR #%s." ;;
         # Garde-fou des agents IA (repowarden garde, repowarden agents)
         garde.format) _M="Format inconnu « %s » : claude ou opencode." ;;
         garde.no_jq) _M="repowarden garde : jq absent, action non vérifiée (installer jq : https://jqlang.org)." ;;

package/hooks/lib/lang.sh

@@ -54,6 +54,9 @@ done
 # Détection de code mort (fonctions <plugin>_deadcode des plugins ci-dessus)
 # shellcheck source=deadcode.sh
 source "$(dirname "${BASH_SOURCE[0]}")/deadcode.sh"
+# Fonctions ajoutées sans commentaire (pre-commit et CI)
+# shellcheck source=commentaires.sh
+source "$(dirname "${BASH_SOURCE[0]}")/commentaires.sh"
 unset _plugin
 
 # --- Détection ---------------------------------------------------------------

package/hooks/lib/tickets.sh

@@ -112,6 +112,49 @@ ticket_type_r() {
     done <<<"$1"
 }
 
+# Registre des branches d'un ticket : repère invisible dans les commentaires
+# du bot. GitHub ne lie une branche au ticket qu'à sa création, et une branche
+# liée supprimée y perd son nom : le registre garde le nom de chaque branche.
+REPERE="repowarden:branche"
+
+repere() { printf '<!-- %s %s -->' "$REPERE" "$1"; }
+
+# REPLY = branches inscrites sur le ticket $1 (séparées par des espaces)
+branches_inscrites_r() {
+    local corps
+    corps="$(gh issue view "$1" --json comments -q '.comments[].body' 2>/dev/null || true)"
+    REPLY="$(grep -oE "<!-- $REPERE [^ ]+ -->" <<<"$corps" | awk '{ printf "%s ", $3 }' || true)"
+    REPLY="${REPLY% }"
+}
+
+# REPLY = adresse de la branche $2 si elle n'est pas liée au ticket $1, vide si
+# elle l'est ou si GitHub ne répond pas (dans le doute, on ne signale rien)
+ticket_unlinked_branch_url_r() {
+    local lignes url
+    REPLY=""
+    # shellcheck disable=SC2016 # variables GraphQL, pas du shell
+    lignes="$(gh api graphql -F owner='{owner}' -F repo='{repo}' -F n="$1" -f query='query($owner: String!, $repo: String!, $n: Int!) {
+  repository(owner: $owner, name: $repo) { url issue(number: $n) { linkedBranches(first: 50) { nodes { ref { name } } } } }
+}' -q '.data.repository.url, .data.repository.issue.linkedBranches.nodes[].ref.name' 2>/dev/null)" || return 0
+    url="${lignes%%$'\n'*}"
+    [ -n "$url" ] || return 0
+    grep -qxF "$2" <<<"$lignes" || REPLY="$url/tree/$2"
+}
+
+# Branche $2 du ticket $1 créée avant sa validation : GitHub ne lie pas une
+# branche existante (createLinkedBranch répond null), son lien est donc inscrit
+# sur le ticket, une seule fois. Vrai si le commentaire a été posté.
+ticket_note_unlinked_branch() {
+    local n="$1" b="$2" url
+    ticket_unlinked_branch_url_r "$n" "$b"
+    url="$REPLY"
+    [ -n "$url" ] || return 1
+    branches_inscrites_r "$n"
+    [[ " $REPLY " != *" $b "* ]] || return 1
+    _tr tk.branch_unlinked "$b" "$url"
+    gh issue comment "$n" --body "$_T"$'\n\n'"$(repere "$b")" >/dev/null
+}
+
 # Vrai si la branche $1 est une branche de travail : ni protégée, ni une
 # exception (main, develop, branches des bots…)
 work_branch() {
@@ -168,12 +211,19 @@ ticket_auto_create() {
 # Branche de travail sans ticket : avertissement, jamais bloquant. Création
 # proposée seulement si repowarden gère la vie des tickets du projet (et que
 # gh est là pour la faire) ; sinon, comment faire taire l'avertissement.
+# Projet sans suivi géré : une fois par branche seulement (le répéter à chaque
+# commit n'apprend rien), mémorisé dans la config locale de la branche, que git
+# efface avec elle.
 ticket_hint() {
     local branch="$1"
     skipped tickets && return 0
     work_branch "$branch" || return 0
     branch_ticket_r "$branch"
     [ -z "$REPLY" ] || return 0
+    if ! tickets_managed; then
+        [ "$(git config --get "branch.$branch.repowardenTicketWarned" 2>/dev/null)" != true ] || return 0
+        git config "branch.$branch.repowardenTicketWarned" true 2>/dev/null || true
+    fi
     attention_t tk.cli.no_ticket "$branch"
     dim_t tk.cli.explain
     if tickets_managed && has gh; then

package/hooks/pre-commit

@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 # Hook pre-commit : bloque les commits directs sur main, détecte les secrets,
-# puis formate les fichiers stagés selon le(s) langage(s) détecté(s).
+# formate les fichiers stagés selon le(s) langage(s) détecté(s), puis signale
+# les fonctions ajoutées sans commentaire.
 set -euo pipefail
 
 source "$(dirname "$0")/lib/common.sh"
@@ -74,4 +75,10 @@ if ! skipped format; then
     restore_unstaged
 fi
 
+# 4. Fonctions ajoutées sans commentaire juste au-dessus (avertissement seulement,
+# après le formatage : les lignes signalées sont celles du commit)
+if ! skipped comments && git rev-parse -q --verify HEAD >/dev/null; then
+    comments_check HEAD ""
+fi
+
 ok_t hook.pre_commit.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "repowarden",
-  "version": "4.11.0-next.13",
+  "version": "4.11.0-next.21",
   "description": "Hooks git et CI multi-langages : messages de commit, nommage des branches, secrets, formatage, tests ciblés, code mort, releases.",
   "keywords": [
     "git-hooks",