repowarden 4.12.1-next.3 → 4.13.0-next.7

package/bin/agents

@@ -3,7 +3,8 @@
 #   repowarden agents init    [--claude] [--opencode] [--projet | --global]
 #   repowarden agents retirer [--claude] [--opencode] [--projet | --global]
 #     Claude Code  hook PreToolUse dans .claude/settings.json
-#     opencode     plugin .opencode/plugins/repowarden-garde.js
+#     opencode     plugins .opencode/plugins/repowarden-garde.js (opencode 1.x)
+#                  et repowarden-garde-v2.js (opencode 2.x)
 # Sans --claude ni --opencode : les deux. --projet (défaut) : fichiers du dépôt,
 # à versionner ; --global : configuration de l'utilisateur, là où chaque outil
 # la lit (CLAUDE_CONFIG_DIR ; OPENCODE_CONFIG_DIR, sinon XDG_CONFIG_HOME).
@@ -20,7 +21,6 @@ source "$ROOT/hooks/lib/agents.sh"
 
 aide() { _tr help.agents; printf '%b\n' "$_T"; }
 
-MODELE_OPENCODE="$AGENTS_MODELE_OPENCODE"
 COMMANDE_CLAUDE="$AGENTS_COMMANDE_CLAUDE"
 MATCHER_CLAUDE="$AGENTS_MATCHER_CLAUDE"
 
@@ -50,13 +50,13 @@ if [ "$portee" = projet ]; then
     [ -n "$GIT_TOPLEVEL" ] || { err_t install.not_repo; exit 1; }
     base="$GIT_TOPLEVEL"
     fichier_claude="$base/.claude/settings.json"
-    fichier_opencode="$base/.opencode/plugins/repowarden-garde.js"
+    dossier_opencode="$base/.opencode/plugins"
 else
     # Réglages utilisateur de Claude Code : $CLAUDE_CONFIG_DIR s'il est défini
     # (code.claude.com/docs/en/settings) ; plugins globaux d'opencode :
     # $OPENCODE_CONFIG_DIR, sinon $XDG_CONFIG_HOME/opencode (opencode.ai/docs/config)
     fichier_claude="${CLAUDE_CONFIG_DIR:-$HOME/.claude}/settings.json"
-    fichier_opencode="${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/plugins/repowarden-garde.js"
+    dossier_opencode="${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/plugins"
 fi
 
 ecrits=()
@@ -99,26 +99,27 @@ init_claude() {
     ok_t agents.added "Claude Code" "$f"
 }
 
-# Plugin opencode : copie du modèle ; celui d'une version antérieure de
-# repowarden est remplacé, un fichier personnel gardé et signalé
+# Plugins opencode (1.x et 2.x) : copie du modèle ; celui d'une version
+# antérieure de repowarden est remplacé, un fichier personnel gardé et signalé
 init_opencode() {
-    local f="$fichier_opencode"
-    if [ -f "$f" ]; then
-        if cmp -s "$f" "$MODELE_OPENCODE"; then
+    local p f modele
+    for p in $AGENTS_PLUGINS_OPENCODE; do
+        f="$dossier_opencode/$p" modele="$AGENTS_MODELES/$p"
+        if [ ! -f "$f" ]; then
+            mkdir -p "$dossier_opencode"
+            cp "$modele" "$f"
+            ecrits+=("$f")
+            ok_t agents.added opencode "$f"
+        elif cmp -s "$f" "$modele"; then
             ok_t agents.present opencode "$f"
         elif agents_plugin_repowarden "$f"; then
-            cp "$MODELE_OPENCODE" "$f"
+            cp "$modele" "$f"
             ecrits+=("$f")
             ok_t agents.updated opencode "$f"
         else
-            attention_t agents.kept opencode "$f" "$MODELE_OPENCODE"
+            attention_t agents.kept opencode "$f" "$modele"
         fi
-        return 0
-    fi
-    mkdir -p "$(dirname "$f")"
-    cp "$MODELE_OPENCODE" "$f"
-    ecrits+=("$f")
-    ok_t agents.added opencode "$f"
+    done
 }
 
 # Hook PreToolUse : seules les commandes « repowarden garde » retirées ; une
@@ -146,17 +147,21 @@ retirer_claude() {
     ok_t agents.removed "Claude Code" "$f"
 }
 
-# Plugin opencode : supprimé s'il est celui du modèle ; modifié, gardé et signalé
+# Plugins opencode : chacun supprimé s'il est celui du modèle ; modifié, gardé
+# et signalé
 retirer_opencode() {
-    local f="$fichier_opencode"
-    if [ ! -f "$f" ]; then
-        ok_t agents.absent opencode "$f"
-    elif cmp -s "$f" "$MODELE_OPENCODE"; then
-        rm -f "$f"
-        ok_t agents.removed opencode "$f"
-    else
-        attention_t agents.kept_remove opencode "$f"
-    fi
+    local p f
+    for p in $AGENTS_PLUGINS_OPENCODE; do
+        f="$dossier_opencode/$p"
+        if [ ! -f "$f" ]; then
+            ok_t agents.absent opencode "$f"
+        elif cmp -s "$f" "$AGENTS_MODELES/$p"; then
+            rm -f "$f"
+            ok_t agents.removed opencode "$f"
+        else
+            attention_t agents.kept_remove opencode "$f"
+        fi
+    done
 }
 
 statut=0

package/bin/carte

@@ -0,0 +1,69 @@
+#!/usr/bin/env bash
+# Usage : repowarden carte                       (re)génère la carte
+#         repowarden carte <fichier|fonction|'#n'> [--json]   extrait utile
+#
+# Carte du projet, sans LLM (gh seulement pour la conception des tickets) : chaque fonction des scripts shell,
+# son fichier, sa ligne et son « pourquoi » (le commentaire juste au-dessus),
+# dans .repowarden/carte/carte.json (dossier ignoré par git). Interrogée,
+# elle est d'abord régénérée si elle est absente ou périmée. Voir docs/carte.md.
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd -P)"
+# shellcheck source=../hooks/lib/common.sh
+source "$ROOT/hooks/lib/common.sh"
+# shellcheck source=../hooks/lib/lang.sh
+source "$ROOT/hooks/lib/lang.sh"
+# shellcheck source=../hooks/lib/carte.sh
+source "$ROOT/hooks/lib/carte.sh"
+
+# Arguments : une cible (fichier ou fonction), --json
+cible="" json=""
+for a in "$@"; do
+    case "$a" in
+        --json) json=json ;;
+        -*) inconnu="$a" ;;
+        *) if [ -z "$cible" ]; then cible="$a"; else inconnu="$a"; fi ;;
+    esac
+    if [ -n "${inconnu:-}" ]; then
+        err_t install.unknown_arg "$inconnu"
+        _tr help.carte
+        printf '%b\n' "$_T" >&2
+        exit 1
+    fi
+done
+if [ -z "$GIT_TOPLEVEL" ]; then
+    err_t carte.no_repo
+    exit 1
+fi
+if ! has jq; then
+    err_t carte.no_jq
+    exit 1
+fi
+# Fichier existant : chemin depuis la racine du dépôt, quel que soit le dossier courant
+chemin=""
+if [ -n "$cible" ] && [ -e "$cible" ]; then
+    chemin="$(cd "$(dirname "$cible")" && pwd -P)/${cible##*/}"
+    chemin="${chemin#"$(cd "$GIT_TOPLEVEL" && pwd -P)"/}"
+    chemin="${chemin%/.}"
+fi
+cd "$GIT_TOPLEVEL"
+
+if [ -z "$cible" ] && [ -z "$json" ]; then
+    carte_generer
+    # shellcheck disable=SC2016 # programme jq, rien à développer
+    read -r fichiers fonctions sans < <(cjq -r '[.fichiers[].fonctions[]?] as $f
+        | "\(.fichiers | length) \($f | length) \([$f[] | select(.pourquoi == "")] | length)"' "$CARTE_JSON")
+    ok_t carte.done "$fichiers" "$fonctions" "$sans" "$CARTE_JSON"
+    exit 0
+fi
+# Interrogation : carte absente ou périmée, régénérée d'abord
+carte_a_jour || carte_generer
+if [ -z "$cible" ]; then
+    cat "$CARTE_JSON"
+elif [[ "$cible" =~ ^#([0-9]+)$ ]]; then
+    carte_ticket "${BASH_REMATCH[1]}" "$json"
+elif [ -n "$chemin" ] || jq -e --arg f "$cible" '.fichiers | has($f)' "$CARTE_JSON" >/dev/null; then
+    carte_fichier "${chemin:-$cible}" "$json"
+else
+    carte_fonction "$cible" "$json"
+fi

package/bin/garde

@@ -43,10 +43,14 @@ args="$(jq -c ".$a // {}" <<<"$entree")"
 # Refus : raison et commande à lancer, puis code 2. Ligne shell de plusieurs
 # commandes (LIGNE_MULTIPLE) : refusée en bloc, ce que l'agent doit savoir
 LIGNE_MULTIPLE=""
+# Fichier existant dont la modification est vérifiée (chemin depuis la racine) :
+# un refus rappelle de lire sa carte avant de le modifier
+FICHIER_CARTE=""
 refuser() {
     _tr "$@"
     printf '✖ repowarden : %b\n' "$_T" >&2
     [ -z "$LIGNE_MULTIPLE" ] || { _tr garde.ligne_entiere; printf '%b\n' "$_T" >&2; }
+    [ -z "$FICHIER_CARTE" ] || { _tr garde.carte "$FICHIER_CARTE" "$FICHIER_CARTE"; printf '%b\n' "$_T" >&2; }
     exit 2
 }
 
@@ -133,12 +137,19 @@ protegee() {
 # si le dépôt suit ses tickets)
 verifier_fichier() {
     dossier_r "$1"
-    local d="$REPLY"
+    # Sous Windows, jq finit le chemin lu par un CR (retiré) et le chemin peut
+    # être en forme Windows (D:/…), absolu lui aussi
+    local d="$REPLY" f="${1%$'\r'}"
+    case "$f" in /* | [A-Za-z]:[/\\]*) ;; *) f="$cwd/$f" ;; esac
     (
         cd "$d" 2>/dev/null || exit 0
         depot_repowarden || exit 0
         # Fichiers internes de git (.git/…) : hors du travail de l'agent
         case "$(pwd -P)/" in "$(cd "$(git rev-parse --git-dir)" && pwd -P)"/*) exit 0 ;; esac
+        if [ -f "$f" ]; then
+            FICHIER_CARTE="$(cd "$(dirname "$f")" && pwd -P)/${f##*/}"
+            FICHIER_CARTE="${FICHIER_CARTE#"$(cd "$(git rev-parse --show-toplevel)" && pwd -P)"/}"
+        fi
         branche="$(git symbolic-ref -q --short HEAD 2>/dev/null || true)"
         [ -n "$branche" ] || refuser garde.detache "$GIT_TOPLEVEL"
         if protegee "$branche"; then
@@ -431,7 +442,8 @@ verifier_shell() {
 
 case "$outil" in
     Edit | Write | MultiEdit | NotebookEdit | edit | write | multiedit)
-        chemin="$(jq -r '.file_path // .filePath // .notebook_path // empty' <<<"$args" 2>/dev/null)"
+        # path : outils edit et write d'opencode 2.x
+        chemin="$(jq -r '.file_path // .filePath // .notebook_path // .path // empty' <<<"$args" 2>/dev/null)"
         [ -z "$chemin" ] || verifier_fichier "$chemin"
         ;;
     apply_patch)
@@ -440,7 +452,8 @@ case "$outil" in
         done < <(jq -r '.patchText // empty' <<<"$args" 2>/dev/null |
             sed -nE -e 's/^\*\*\* (Add|Update|Delete) File: //p' -e 's/^\*\*\* Move to: //p')
         ;;
-    Bash | bash)
+    # shell : nom de l'outil bash dans opencode 2.x
+    Bash | bash | shell)
         verifier_shell "$(jq -r '.command // empty' <<<"$args" 2>/dev/null)"
         ;;
 esac

package/bin/repowarden

@@ -7,6 +7,7 @@
 #   repowarden uninstall [--global] [--purge]      les retire (avant npm uninstall -g)
 #   repowarden cc                                  assistant de commit
 #   repowarden code-mort                           nouveau code mort de la branche
+#   repowarden carte                               carte du projet : fonctions et leur pourquoi
 #   repowarden ticket <n>                         branche du ticket (créée, liée, si besoin)
 #   repowarden ticket nouveau "<titre>"           nouveau ticket
 #   repowarden ticket comment <n> "<texte>"       commentaire sur un ticket
@@ -52,6 +53,7 @@ help_key_r() {
         garde | guard) REPLY=help.garde ;;
         cc | commit) REPLY=help.cc ;;
         code-mort | deadcode) REPLY=help.code-mort ;;
+        carte | map) REPLY=help.carte ;;
         ticket) REPLY=help.ticket ;;
         tickets) REPLY=help.tickets ;;
         pr) REPLY=help.pr ;;
@@ -102,6 +104,7 @@ case "$cmd" in
     uninstall) exec bash "$ROOT/install.sh" --uninstall "$@" ;;
     cc | commit) exec bash "$ROOT/bin/commit" "$@" ;;
     code-mort | deadcode) exec bash "$ROOT/bin/code-mort" "$@" ;;
+    carte | map) exec bash "$ROOT/bin/carte" "$@" ;;
     tickets) exec bash "$ROOT/bin/tickets" "$@" ;;
     ticket) exec bash "$ROOT/bin/ticket" "$@" ;;
     ticket-comment) exec bash "$ROOT/bin/ticket-comment" "$@" ;;

package/bin/statut

@@ -13,6 +13,8 @@ source "$ROOT/hooks/lib/common.sh"
 source "$ROOT/hooks/lib/secrets.sh"
 # shellcheck source=../hooks/lib/agents.sh
 source "$ROOT/hooks/lib/agents.sh"
+# shellcheck source=../hooks/lib/carte.sh
+source "$ROOT/hooks/lib/carte.sh"
 exec 2>&1 # une seule sortie, dans l'ordre (avertissements compris)
 # shellcheck disable=SC2034 # lu par check_version (common.sh)
 HOOKS_DIR="$ROOT/hooks"
@@ -75,6 +77,21 @@ if [ -n "$GIT_TOPLEVEL" ]; then
         attention_t st.repo_lefthook "$f"
         break
     done
+    # Projet pre-commit : avec les hooks repowarden actifs, « pre-commit install »
+    # refuse ; ses hooks ne tournent que dans .git/hooks ou .repowarden, lancés par repowarden
+    if [ -f "$GIT_TOPLEVEL/.pre-commit-config.yaml" ] &&
+        [ "$(reel "$(git config --get core.hooksPath 2>/dev/null || true)")" = "$ROOT/hooks" ]; then
+        commun="$(cd "$GIT_TOPLEVEL" && reel "$(git rev-parse --git-common-dir)")"
+        lance=""
+        for h in "$commun/hooks/pre-commit" "$GIT_TOPLEVEL/.repowarden/pre-commit"; do
+            [ -x "$h" ] && grep -qsE 'File generated by pre-commit|pre-commit +(run|hook-impl)' "$h" && lance=1
+        done
+        if [ -z "$lance" ]; then
+            marche="GIT_CONFIG_COUNT=1 GIT_CONFIG_KEY_0=core.hooksPath GIT_CONFIG_VALUE_0= pre-commit install"
+            attention_t st.repo_precommit "$marche"
+            suivant="${suivant:-$marche}"
+        fi
+    fi
     # Anciens noms (configuration, workflows de l'ancien dépôt, que GitHub ne
     # redirige plus) : la migration les remplace
     if [ -e "$GIT_TOPLEVEL/.repogarde.conf" ] || [ -d "$GIT_TOPLEVEL/.repogarde" ] ||
@@ -138,6 +155,16 @@ if [ -n "$GIT_TOPLEVEL" ]; then
         sensitive_files_r
         [ -z "$REPLY" ] || sensitive_files_warn "$REPLY"
     fi
+    # Carte du projet (repowarden carte) : facultative ; périmée, elle ne dit
+    # plus ce que fait le code, et les agents la lisent avant de modifier
+    if [ ! -f "$GIT_TOPLEVEL/$CARTE_JSON" ]; then
+        info_t st.carte_absente
+    elif (cd "$GIT_TOPLEVEL" && carte_a_jour); then
+        ok_t st.carte_ok
+    else
+        attention_t st.carte_perimee
+        suivant="${suivant:-repowarden carte}"
+    fi
     info_t st.repo_forge "$FORGE"
     [ "$FORGE" != github ] || dim_t st.repo_rules
 fi

package/ci/tickets/commun.sh

@@ -113,4 +113,7 @@ notice() { echo "::notice title=repowarden::$*"; }
 
 notice_t() { _tr "$@"; notice "$_T"; }
 
+# Avertissement traduit dans le journal du run : signale sans faire échouer
+avertir_t() { _tr "$@"; echo "::warning title=repowarden::$_T"; }
+
 # Chargé par les tests (source) : fonctions seulement

package/ci/tickets/push.sh

@@ -69,12 +69,13 @@ titre_pr_brouillon_r() {
     suggest_pr_title_r "$branche"
 }
 
-# $1 = corps d'un ticket → REPLY : les puces de ses critères d'acceptation
+# $1 = corps d'un ticket → REPLY : ses sections de critères d'acceptation
 # (« Terminé quand… », « Critères d'acceptation ») en cases à cocher « - [ ] »,
-# le reste inchangé
+# RESTE_TICKET : le reste (constat, proposition), que la PR replie
 criteres_coches_r() {
-    local corps="$1" ligne dedans=0 sortie=""
+    local corps="$1" ligne dedans=0 criteres="" reste=""
     while IFS= read -r ligne; do
+        ligne="${ligne%$'\r'}"
         if [[ "$ligne" =~ ^#{1,6}[[:space:]] ]]; then
             dedans=0
             case "$ligne" in
@@ -85,9 +86,16 @@ criteres_coches_r() {
             ligne="$(printf '%s' "$ligne" |
                 sed -E 's/^([[:space:]]*[-*][[:space:]]+)(\[[xX ]\][[:space:]]+)?/\1[ ] /')"
         fi
-        sortie="$sortie$ligne"$'\n'
+        if [ "$dedans" = 1 ]; then
+            criteres="$criteres$ligne"$'\n'
+        else
+            reste="$reste$ligne"$'\n'
+        fi
     done <<<"$corps"
-    REPLY="${sortie%$'\n'}"
+    while [[ "$reste" == $'\n'* ]]; do reste="${reste#$'\n'}"; done
+    sans_fin_vide_r "$reste"
+    RESTE_TICKET="$REPLY"
+    sans_fin_vide_r "$criteres"
 }
 
 # Fin de chaque commentaire lu d'un bloc (séparateur ASCII) : un texte écrit à
@@ -189,41 +197,98 @@ section_realise_r() {
     sans_fin_vide_r "$section"
 }
 
+# Ligne de pied d'un commit (`repowarden cc --refs`), faite seulement de
+# références : retirée, le pied de la PR porte déjà le ticket
+PIED_COMMIT_RE='^[[:space:]]*(Tickets?|Refs?|Closes|Fixes|Resolves)[[:space:]]*:?[[:space:]]*#[0-9]+([[:space:],]+#[0-9]+)*[[:space:]]*$'
+
+# $1 = commits lus par l'API (« parents sha message », chacun suivi d'une ligne
+# SEP_COMMENTAIRE) → REPLY : pour chaque commit hors fusion, « ### en-tête (sha) »
+# puis son corps, le pourquoi que le relecteur cherche avant le ticket
+ce_que_fait_r() {
+    local ligne debut=1 fusion=0 entete="" bloc="" sortie="" reste
+    while IFS= read -r ligne; do
+        ligne="${ligne%$'\r'}"
+        if [ "$ligne" = "$SEP_COMMENTAIRE" ]; then
+            if [ -n "$entete" ] && [ "$fusion" = 0 ]; then
+                sans_fin_vide_r "$bloc"
+                sortie="$sortie${sortie:+$'\n\n'}$entete${REPLY:+$'\n'}$REPLY"
+            fi
+            debut=1 fusion=0 entete="" bloc=""
+            continue
+        fi
+        if [ "$debut" = 1 ]; then
+            [ -n "$ligne" ] || continue
+            debut=0
+            # plus d'un parent : commit de fusion, sans rien à dire à la revue
+            [ "${ligne%% *}" -le 1 ] 2>/dev/null || fusion=1
+            reste="${ligne#* }"
+            entete="### ${reste#* } (${reste%% *})"
+            continue
+        fi
+        [ -n "$bloc" ] || [ -n "${ligne//[[:space:]]/}" ] || continue
+        [[ ! "$ligne" =~ $PIED_COMMIT_RE ]] || continue
+        ligne_reprise_r "$ligne"
+        bloc="$bloc$REPLY"$'\n'
+    done <<<"$1"$'\n'"$SEP_COMMENTAIRE"
+    REPLY="$sortie"
+}
+
 # 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.
+# elle existe) : ce que fait la PR (corps des commits), les critères du ticket
+# en cases à cocher, ses ajouts en commentaire, le résumé de sa conception, le
+# reste du ticket replié, 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" pr="${3:-}" corps commits commentaires
+    local n="$1" branche="$2" pr="${3:-}" corps="" reste commentaires
+    ce_que_fait_r "$(gh api "repos/$GH_REPO/compare/$INTEGRATION...$branche" \
+        -q '.commits[] | "\(.parents | length) \(.sha[0:7]) \(.commit.message)\n\u001e"' 2>/dev/null || true)"
+    _tr tk.pr_does
+    [ -z "$REPLY" ] || corps="## $_T"$'\n'"$REPLY"
     criteres_coches_r "$(gh issue view "$n" --json body -q .body)"
-    corps="$REPLY"
+    reste="$RESTE_TICKET"
+    [ -z "$REPLY" ] || corps="$corps${corps:+$'\n\n'}$REPLY"
     commentaires_mainteneur_r "$n"
     commentaires="$REPLY"
     ajouts_ticket_r "$commentaires"
     _tr tk.pr_additions
-    [ -z "$REPLY" ] || corps="$corps"$'\n\n## '"$_T"$'\n'"$REPLY"
+    [ -z "$REPLY" ] || corps="$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"
+    [ -z "$REPLY" ] || corps="$corps${corps:+$'\n\n'}## $_T"$'\n'"$REPLY"
+    if [ -n "$reste" ]; then
+        # lignes vides autour du texte : sinon GitHub ne rend pas son Markdown
+        _tr tk.pr_ticket "$n"
+        corps="$corps${corps:+$'\n\n'}<details>"$'\n'"<summary>$_T</summary>"$'\n\n'"$reste"$'\n\n</details>'
+    fi
     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"
+        [ -z "$REPLY" ] || corps="$corps${corps:+$'\n\n'}$REPLY"
     fi
-    REPLY="$corps"$'\n\nTicket : #'"$n"
+    REPLY="$corps${corps:+$'\n\n'}Ticket : #$n"
+}
+
+# REPLY = compte à assigner à la PR brouillon du ticket $1 : l'auteur du push
+# s'il est une personne (GitHub refuse d'assigner un bot avec un jeton d'App),
+# sinon le premier assigné du ticket, sinon vide
+assigne_pr_r() {
+    REPLY=""
+    case "${PUSHER:-}" in
+        "" | *"[bot]") ;;
+        *) REPLY="$PUSHER"; return 0 ;;
+    esac
+    REPLY="$(assignes "$1")"
+    REPLY="${REPLY%%$'\n'*}"
 }
 
 # Premier push sur la branche d'un ticket : PR brouillon vers la branche
 # d'intégration, titrée par le premier commit (repli : le ticket), à la
-# description reprise du ticket, citant le
-# ticket, assignée à l'auteur du push ; ticket en cours. Ouverte par le jeton
-# des Actions, elle ne lance pas la CI : elle tourne au push suivant, ou au
+# description reprise du ticket, citant le ticket, assignée à l'auteur du
+# push (une personne, jamais un bot ; repli : l'assigné du ticket ; un refus
+# n'est qu'un avertissement) ; ticket en cours. Ouverte par le jeton des Actions, elle ne lance pas la CI : elle tourne au push suivant, ou au
 # passage « prête pour revue ». Tant qu'elle est en brouillon, chaque push met
 # à jour son titre et sa description ; une PR prête n'est plus touchée.
 cmd_push() {
-    local n pr titre corps url
+    local n pr titre corps url qui
     : "${PUSH_BRANCH:?}" "${SHA:?}"
     [ "${DELETED:-false}" != true ] || return 0
     branch_ticket_r "$PUSH_BRANCH"
@@ -245,8 +310,15 @@ cmd_push() {
         return 0
     fi
     url="$(gh pr create --draft --base "$INTEGRATION" --head "$PUSH_BRANCH" --title "$titre" \
-        --body "$corps" ${PUSHER:+--assignee "$PUSHER"})"
-    [ -z "${PUSHER:-}" ] || gh issue edit "$n" --add-assignee "$PUSHER" >/dev/null || true
+        --body "$corps")"
+    # assignation à part : un refus de GitHub ne doit pas faire échouer le suivi
+    assigne_pr_r "$n"
+    qui="$REPLY"
+    if [ -n "$qui" ]; then
+        gh pr edit "${url##*/}" --add-assignee "$qui" >/dev/null 2>&1 ||
+            avertir_t tk.assign_failed "${url##*/}" "$qui"
+        [ "$qui" != "${PUSHER:-}" ] || gh issue edit "$n" --add-assignee "$qui" >/dev/null 2>&1 || true
+    fi
     est_valide "$n" && statut "$n" "$S_ENCOURS"
     notice_t tk.draft_opened "${url##*/}" "$n"
     verifier "${url##*/}" "$SHA" "$n" "$PUSH_BRANCH" || true

package/hooks/agents/repowarden-garde-v2.js

@@ -0,0 +1,28 @@
+// Garde-fou repowarden pour opencode 2.x (écrit par repowarden agents init) :
+// chaque outil est soumis à « repowarden garde » avant de s'exécuter. Refus
+// (code 2) → erreur rendue à l'agent, avec la commande à lancer. repowarden
+// absent ou en panne : rien n'est bloqué. opencode 1.x : repowarden-garde.js,
+// à côté (un module à export par défaut y passerait pour un plugin 2.x).
+// Plugins opencode 2.x : export par défaut { id, setup }, crochet
+// ctx.tool.hook("execute.before") (outils edit, write, shell…)
+import { spawnSync } from "node:child_process"
+
+// Soumet l'appel d'outil à repowarden garde ; l'erreur levée par le crochet
+// empêche l'outil de s'exécuter et son message est rendu à l'agent
+function garde(tool, args, cwd) {
+  const r = spawnSync("repowarden", ["garde"], {
+    input: JSON.stringify({ tool, args, cwd }),
+    encoding: "utf8",
+  })
+  if (r.status === 2) throw new Error((r.stderr || "").trim())
+}
+
+export default {
+  id: "repowarden-garde",
+  // Sans ctx.tool.hook (opencode 1.x charge aussi ce fichier) : rien
+  setup: (ctx) => {
+    if (typeof ctx?.tool?.hook !== "function") return
+    const dossier = ctx.location?.directory || process.cwd()
+    return ctx.tool.hook("execute.before", (appel) => garde(appel.tool, appel.input, dossier))
+  },
+}

package/hooks/lib/agents.sh

@@ -4,7 +4,10 @@
 
 # Forme actuelle du garde-fou : un garde-fou posé par repowarden qui en diffère
 # date d'une version antérieure et est mis à jour (#470)
-AGENTS_MODELE_OPENCODE="$(cd "$(dirname "${BASH_SOURCE[0]}")/../agents" && pwd -P)/repowarden-garde.js"
+AGENTS_MODELES="$(cd "$(dirname "${BASH_SOURCE[0]}")/../agents" && pwd -P)"
+# Plugins opencode, un par API : 1.x lit l'export nommé, 2.x l'export par
+# défaut, et 1.x ignore l'export nommé d'un module qui a les deux (#469)
+AGENTS_PLUGINS_OPENCODE="repowarden-garde.js repowarden-garde-v2.js"
 AGENTS_COMMANDE_CLAUDE="repowarden garde --format claude"
 AGENTS_MATCHER_CLAUDE="Edit|Write|MultiEdit|NotebookEdit|Bash"
 
@@ -25,10 +28,10 @@ agents_plugin_repowarden() {
     return 1
 }
 
-# Vrai si le plugin $1 vient de repowarden mais diffère du modèle actuel :
-# posé par une version antérieure, il n'a pas suivi les mises à jour
+# Vrai si le plugin $1 vient de repowarden mais diffère du modèle actuel (même
+# nom) : posé par une version antérieure, il n'a pas suivi les mises à jour
 agents_plugin_perime() {
-    agents_plugin_repowarden "$1" && ! cmp -s "$1" "$AGENTS_MODELE_OPENCODE"
+    agents_plugin_repowarden "$1" && ! cmp -s "$1" "$AGENTS_MODELES/$(basename "$1")"
 }
 
 # Vrai si le settings.json $1 a un hook « repowarden garde… » d'une autre forme
@@ -47,15 +50,25 @@ agents_perimes() {
     agents_dossiers_globaux
     if [ -n "${1:-}" ]; then
         ! agents_claude_perime "$1/.claude/settings.json" || echo "projet claude $1/.claude/settings.json"
-        ! agents_plugin_perime "$1/.opencode/plugins/repowarden-garde.js" ||
-            echo "projet opencode $1/.opencode/plugins/repowarden-garde.js"
+        agents_opencode_perimes projet "$1/.opencode/plugins"
     fi
     ! agents_claude_perime "$AGENTS_CLAUDE_DIR/settings.json" || echo "global claude $AGENTS_CLAUDE_DIR/settings.json"
-    ! agents_plugin_perime "$AGENTS_OPENCODE_DIR/plugins/repowarden-garde.js" ||
-        echo "global opencode $AGENTS_OPENCODE_DIR/plugins/repowarden-garde.js"
+    agents_opencode_perimes global "$AGENTS_OPENCODE_DIR/plugins"
     return 0
 }
 
+# Plugins opencode périmés du dossier $2 (portée $1) : différents du modèle, ou
+# absents à côté d'un plugin repowarden (posé avant le plugin 2.x, #469)
+agents_opencode_perimes() {
+    local p
+    for p in $AGENTS_PLUGINS_OPENCODE; do
+        if agents_plugin_perime "$2/$p" ||
+            { [ ! -e "$2/$p" ] && agents_plugin_repowarden "$2/repowarden-garde.js"; }; then
+            echo "$1 opencode $2/$p"
+        fi
+    done
+}
+
 # Vrai si Claude Code ou opencode est sur ce poste (commande, ou dossier de
 # configuration) sans garde-fou branché, ni dans le dépôt $1 (racine, vide hors
 # dépôt) ni pour l'utilisateur : ses actions ne seraient vues qu'au commit

package/hooks/lib/carte.sh

@@ -0,0 +1,339 @@
+#!/usr/bin/env bash
+# Carte du projet (repowarden carte) : quoi fait quoi et pourquoi, sans LLM ni
+# réseau, pour qu'un agent (ou une personne) lise l'extrait utile au lieu
+# d'explorer le dépôt. Fichier .repowarden/carte/carte.json, dossier ignoré
+# par git ; clés triées, ni date ni chemin absolu : même dépôt, même fichier.
+# Les fonctions et leur « pourquoi » viennent de la détection du contrôle
+# « fonctions sans commentaire » (commentaires.sh) : pas de second analyseur.
+# Demande commentaires.sh (via lang.sh) et common.sh ; lancé à la racine.
+# La conception des tickets est résumée comme pour les PR brouillon du bot :
+# mêmes lecteurs (ci/tickets/push.sh), pas un second.
+# shellcheck disable=SC2016,SC2013 # programmes jq et awk entre apostrophes ; numéros de tickets, un mot par ligne
+_carte_ci="$(cd "$(dirname "${BASH_SOURCE[0]}")/../../ci/tickets" && pwd -P)"
+# shellcheck source=../../ci/tickets/commun.sh
+source "$_carte_ci/commun.sh"
+# shellcheck source=../../ci/tickets/push.sh
+source "$_carte_ci/push.sh"
+
+CARTE_DIR=.repowarden/carte
+CARTE_JSON="$CARTE_DIR/carte.json"
+
+# jq sans retour chariot : sous Windows, jq finit ses lignes par CRLF, et un
+# read garderait le CR collé à la dernière valeur lue
+cjq() { jq "$@" | tr -d '\r'; }
+
+# Fichiers lus par la carte, dans le dossier $1 : « shell » (fichiers
+# cartographiés), « tous » (fichiers du dépôt, rattachables à des tickets),
+# tous deux hors repowarden.exclude, et « tests » (*.bats, tous)
+carte_fichiers() {
+    local f
+    : >"$1/shell"
+    : >"$1/tests"
+    : >"$1/tous"
+    while IFS= read -r -d '' f; do
+        [ -f "$f" ] || continue
+        case "$f" in *.bats) printf '%s\n' "$f" >>"$1/tests" ;; esac
+        is_excluded "$f" && continue
+        printf '%s\n' "$f" >>"$1/tous"
+        case "$f" in *.bats) continue ;; esac
+        comments_lang_r "$f" "$f"
+        [ "$REPLY" != shell ] || printf '%s\n' "$f" >>"$1/shell"
+    done < <(git ls-files -z -co --exclude-standard)
+}
+
+# Écrit la carte (remplacement atomique : une lecture concurrente voit
+# l'ancienne ou la nouvelle) ; le dossier s'ignore lui-même pour git
+carte_generer() {
+    local d f
+    local -a shell=() tests=()
+    mkdir -p "$CARTE_DIR"
+    [ -f "$CARTE_DIR/.gitignore" ] || printf '*\n' >"$CARTE_DIR/.gitignore"
+    d="$(mktemp -d)"
+    carte_fichiers "$d"
+    while IFS= read -r f; do shell+=("$f"); done <"$d/shell"
+    while IFS= read -r f; do tests+=("$f"); done <"$d/tests"
+    : >"$d/fonctions"
+    : >"$d/liens"
+    # « fichier<TAB>ticket » par fichier modifié par un ticket (git seul)
+    git -c core.quotePath=false log --no-color --diff-merges=first-parent --name-only \
+        --format='%x1e%s%n%b%x1f' 2>/dev/null |
+        awk -v D=$'\x1e' -v F=$'\x1f' "$CARTE_HIST_AWK" >"$d/historique" || true
+    # Conceptions en cache, « \x1d<n> » puis le résumé, ticket par ticket
+    # Hors ligne (post-merge) : seules les conceptions déjà en cache servent
+    [ -n "${REPOWARDEN_CARTE_HORS_LIGNE:-}" ] || carte_conceptions "$d/historique"
+    : >"$d/conceptions"
+    for f in $(cut -f2 "$d/historique" | sort -un); do
+        [ -s "$CARTE_DIR/conception/$f.md" ] || continue
+        printf '\035%s\n' "$f" >>"$d/conceptions"
+        cat "$CARTE_DIR/conception/$f.md" >>"$d/conceptions"
+    done
+    if [ ${#shell[@]} -gt 0 ]; then
+        # « fichier<TAB>ligne<TAB>nom<TAB>pourquoi » par fonction
+        awk -v lang=shell -v q="'" "$COMMENTS_AWK_LIB$CARTE_AWK" "${shell[@]}" >"$d/fonctions"
+        # « fichier<TAB>test » par test qui le couvre
+        [ ${#tests[@]} -eq 0 ] ||
+            awk "$CARTE_TESTS_AWK" "$d/shell" "${tests[@]}" >"$d/liens"
+    fi
+    jq -n -S --rawfile s "$d/shell" --rawfile fo "$d/fonctions" --rawfile li "$d/liens" \
+        --rawfile to "$d/tous" --rawfile hi "$d/historique" --rawfile co "$d/conceptions" '
+        def lignes($x): $x | split("\n") | map(select(length > 0) | split("\t"));
+        (lignes($fo) | group_by(.[0]) | map({key: .[0][0], value:
+            map({nom: .[2], ligne: (.[1] | tonumber), pourquoi: (.[3] // "")})
+            | sort_by(.ligne)}) | from_entries) as $fn
+        | (lignes($li) | group_by(.[0])
+            | map({key: .[0][0], value: (map(.[1]) | unique)}) | from_entries) as $te
+        | ($co | split("\u001d") | map(select(length > 0) | index("\n") as $i
+            | {key: .[:$i], value: (.[$i + 1:] | rtrimstr("\n"))}) | from_entries) as $cn
+        | (lignes($to) | map({key: .[0], value: 1}) | from_entries) as $ok
+        | (lignes($hi) | map(select($ok[.[0]] != null))) as $h
+        | ($h | group_by(.[0])
+            | map({key: .[0][0], value: (map(.[1] | tonumber) | unique)}) | from_entries) as $tf
+        | {version: 1,
+           fichiers: (($tf | map_values({tickets: .})) + (lignes($s) | map(.[0])
+            | map({key: ., value: {fonctions: ($fn[.] // []), tests: ($te[.] // []),
+                tickets: ($tf[.] // [])}})
+            | from_entries)),
+           tickets: ($h | group_by(.[1])
+            | map({key: .[0][1], value: ({fichiers: (map(.[0]) | unique)}
+                + (if $cn[.[0][1]] then {conception: $cn[.[0][1]]} else {} end))})
+            | from_entries)}' >"$d/carte.json"
+    mv -f "$d/carte.json" "$CARTE_JSON"
+    rm -rf "$d"
+}
+
+# Vrai si la carte existe et qu'aucun fichier du dépôt (suivi, ou nouveau non
+# ignoré) ni l'index git n'est plus récent : sinon elle ne dit plus le code
+carte_a_jour() {
+    local f
+    [ -f "$CARTE_JSON" ] || return 1
+    f="$(git rev-parse --git-path index)"
+    [ ! "$f" -nt "$CARTE_JSON" ] || return 1
+    while IFS= read -r -d '' f; do
+        [ ! "$f" -nt "$CARTE_JSON" ] || return 1
+    done < <(git ls-files -z -co --exclude-standard)
+    return 0
+}
+
+# Fonctions du fichier $1 (chemin depuis la racine) : une ligne chacune,
+# « ligne  nom — pourquoi », puis ses tests et tickets ; JSON si $2 = json
+carte_fichier() {
+    local f="$1" ligne nom pourquoi tests tickets n=0
+    if [ "${2:-}" = json ]; then
+        jq --arg f "$f" '{fichier: $f} + (.fichiers[$f] // {fonctions: []})' "$CARTE_JSON"
+        return 0
+    fi
+    printf '%s%s%s\n' "$UI_B" "$f" "$UI_N"
+    while IFS=$'\t' read -r ligne nom pourquoi; do
+        n=$((n + 1))
+        if [ -n "$pourquoi" ]; then
+            printf '  %s  %s — %s\n' "$ligne" "$nom" "$pourquoi"
+        else
+            t carte.no_comment
+            printf '  %s  %s %s\n' "$ligne" "$nom" "$REPLY"
+        fi
+    done < <(cjq -r --arg f "$f" '(.fichiers[$f].fonctions // [])[] | "\(.ligne)\t\(.nom)\t\(.pourquoi)"' "$CARTE_JSON")
+    [ "$n" -gt 0 ] || info_t carte.file_empty "$f"
+    # Tests liés (fichiers cartographiés) : ceux à écrire d'abord, puis à relancer
+    if jq -e --arg f "$f" '.fichiers[$f] | has("tests")' "$CARTE_JSON" >/dev/null 2>&1; then
+        tests="$(cjq -r --arg f "$f" '.fichiers[$f].tests | join(" ")' "$CARTE_JSON")"
+        if [ -n "$tests" ]; then
+            echo_t carte.tests "$tests"
+            echo_t carte.tests_run "bats $tests"
+        else
+            info_t carte.no_tests "$f"
+        fi
+    fi
+    # Tickets qui l'ont modifié : le pourquoi de son histoire
+    tickets="$(cjq -r --arg f "$f" '(.fichiers[$f].tickets // []) | map("#\(.)") | join(" ")' "$CARTE_JSON")"
+    [ -z "$tickets" ] || echo_t carte.tickets "$tickets"
+    # Conception de chacun de ces tickets : sa première ligne utile
+    cjq -r --arg f "$f" '. as $c | (.fichiers[$f].tickets // [])[] | tostring as $n
+        | ($c.tickets[$n].conception // empty) | split("\n")
+        | map(select(test("^\\s*(#|$)") | not)) | first // empty
+        | "  #\($n) — \(sub("^\\s*[-*]\\s*"; ""))"' "$CARTE_JSON"
+}
+
+# Met en cache (conception/<n>.md, vide sans conception) le résumé de chaque
+# ticket de l'historique $1 absent du cache : un seul appel gh, jamais bloquant
+carte_conceptions() {
+    local n manquants="" tmp ligne num="" texte=""
+    mkdir -p "$CARTE_DIR/conception"
+    for n in $(cut -f2 "$1" | sort -un); do
+        [ -f "$CARTE_DIR/conception/$n.md" ] || manquants="$manquants $n"
+    done
+    [ -n "$manquants" ] || return 0
+    if ! has gh || ! gh auth token >/dev/null 2>&1; then
+        attention_t carte.no_gh
+        return 0
+    fi
+    tmp="$(mktemp)"
+    if ! gh issue list --state all --limit 1000 --json number,comments >"$tmp" 2>/dev/null; then
+        attention_t carte.no_gh
+        rm -f "$tmp"
+        return 0
+    fi
+    # Par ticket : « \x1d<n> » puis ses commentaires de mainteneur, chacun
+    # suivi de SEP_COMMENTAIRE (forme de commentaires_mainteneur_r) ; une
+    # dernière ligne « \x1d » seule clôt le dernier ticket
+    while IFS= read -r ligne; do
+        if [[ "$ligne" == $'\035'* ]]; then
+            if [ -n "$num" ] && [[ " $manquants " == *" $num "* ]]; then
+                carte_resume_r "$texte"
+                printf '%s' "$REPLY" >"$CARTE_DIR/conception/$num.md"
+            fi
+            num="${ligne#$'\035'}" texte=""
+            [ -n "$num" ] || break
+            continue
+        fi
+        texte="$texte$ligne"$'\n'
+    done < <(cjq -r '.[] | "\u001d\(.number)", (.comments[]
+        | select(.authorAssociation == "OWNER" or .authorAssociation == "MEMBER" or .authorAssociation == "COLLABORATOR")
+        | .body + "\n\u001e")' "$tmp"; printf '\035\n')
+    rm -f "$tmp"
+    # Tickets absents de la réponse : sans conception, pas redemandés
+    for n in $manquants; do
+        [ -f "$CARTE_DIR/conception/$n.md" ] || : >"$CARTE_DIR/conception/$n.md"
+    done
+}
+
+# REPLY = résumé de conception des commentaires $1 : « Ce qui change » et
+# « Hors périmètre » de la dernière conception, puis les ajouts
+carte_resume_r() {
+    local conception
+    resume_conception_r "$1"
+    conception="$REPLY"
+    ajouts_ticket_r "$1"
+    REPLY="$conception${conception:+${REPLY:+$'\n\n'}}$REPLY"
+    [ -z "$REPLY" ] || REPLY="$REPLY"$'\n'
+}
+
+# Fichiers modifiés par le ticket $1 (numéro, sans #), puis sa conception ;
+# JSON si $2 = json.
+# Code 1 si l'historique git ne le cite pas
+carte_ticket() {
+    local n="$1" f c=0 conception
+    if [ "${2:-}" = json ]; then
+        jq -e -S --arg n "$n" '.tickets[$n] // empty | {ticket: ($n | tonumber)} + .' "$CARTE_JSON" && return 0
+        err_t carte.ticket_unknown "$n" "$n" "$n"
+        return 1
+    fi
+    while IFS= read -r f; do
+        c=$((c + 1))
+        [ "$c" -gt 1 ] || { t carte.ticket_title "$n"; printf '%s%s%s\n' "$UI_B" "$REPLY" "$UI_N"; }
+        printf '  %s\n' "$f"
+    done < <(cjq -r --arg n "$n" '(.tickets[$n].fichiers // [])[]' "$CARTE_JSON")
+    if [ "$c" -gt 0 ]; then
+        conception="$(cjq -r --arg n "$n" '.tickets[$n].conception // empty' "$CARTE_JSON")"
+        [ -z "$conception" ] || { echo_t carte.conception; printf '%s\n' "$conception" | sed 's/^/  /'; }
+        return 0
+    fi
+    err_t carte.ticket_unknown "$n" "$n" "$n"
+    return 1
+}
+
+# Définitions de la fonction $1 : « nom  fichier:ligne » puis son pourquoi ;
+# JSON (liste) si $2 = json. Code 1 si la carte ne la connaît pas
+carte_fonction() {
+    local nom="$1" f ligne pourquoi n=0
+    if [ "${2:-}" = json ]; then
+        jq -e --arg n "$nom" '[.fichiers | to_entries[] | .key as $f
+            | .value.fonctions[]? | select(.nom == $n) | {fichier: $f} + .]
+            | if length > 0 then . else empty end' "$CARTE_JSON" && return 0
+        err_t carte.unknown "$nom"
+        return 1
+    fi
+    while IFS=$'\t' read -r f ligne pourquoi; do
+        n=$((n + 1))
+        printf '%s%s%s  %s:%s\n' "$UI_B" "$nom" "$UI_N" "$f" "$ligne"
+        if [ -n "$pourquoi" ]; then
+            printf '  %s\n' "$pourquoi"
+        else
+            t carte.no_comment
+            printf '  %s\n' "$REPLY"
+        fi
+    done < <(cjq -r --arg n "$nom" '.fichiers | to_entries[] | .key as $f
+        | .value.fonctions[]? | select(.nom == $n) | "\($f)\t\(.ligne)\t\(.pourquoi)"' "$CARTE_JSON")
+    [ "$n" -gt 0 ] && return 0
+    err_t carte.unknown "$nom"
+    return 1
+}
+
+# Programme awk de la carte : chaque fonction de chaque fichier lu, avec sa
+# ligne et le texte de son commentaire (vide s'il n'y en a pas)
+# shellcheck disable=SC2016 # programme awk, rien à développer
+CARTE_AWK='
+# Fonctions du fichier f (lignes L[1..N])
+function sortie(   i, n) {
+    for (i = 1; i <= N; i++) {
+        n = nom(L[i])
+        if (n != "") printf "%s\t%d\t%s\t%s\n", f, i, n, commentaire(i)
+    }
+}
+FNR == 1 { if (NR > 1) sortie(); f = FILENAME; N = 0 }
+# Fichier en CRLF (extraction Windows) : le CR ne fait pas partie du texte
+{ sub(/\r$/, ""); L[FNR] = $0; N = FNR }
+END { if (NR > 0) sortie() }'
+
+
+# Programme awk des tests liés : lit la liste des fichiers cartographiés, puis
+# chaque test ; relie un fichier à un test par le nommage (même nom sans
+# extension), par son chemin cité, ou par « repowarden <commande> » (bin/…)
+# shellcheck disable=SC2016 # programme awk, rien à développer
+CARTE_TESTS_AWK='
+# Nom sans dossier ni extension : bin/garde, test/garde.bats → garde
+function base(p) { sub(/^.*\//, "", p); sub(/\.[^.\/]*$/, "", p); return p }
+# Vrai si le texte x cite le chemin p, sans autre caractère de nom collé
+function cite(x, p,   k, av, ap) {
+    while ((k = index(x, p)) > 0) {
+        av = (k > 1) ? substr(x, k - 1, 1) : ""
+        ap = substr(x, k + length(p), 1)
+        if (av !~ /[A-Za-z0-9_-]/ && ap !~ /[A-Za-z0-9_.-]/) return 1
+        x = substr(x, k + 1)
+    }
+    return 0
+}
+# Liens du test t (texte complet x) vers les fichiers cartographiés
+function liens(   i, bt, r, c, cmd) {
+    bt = base(t)
+    split("", cmd)
+    r = x
+    while (match(r, /repowarden[ \t]+[a-z][a-z0-9-]*/)) {
+        c = substr(r, RSTART, RLENGTH); sub(/^repowarden[ \t]+/, "", c)
+        cmd["bin/" c] = 1
+        r = substr(r, RSTART + RLENGTH)
+    }
+    for (i = 1; i <= nf; i++)
+        if (base(F[i]) == bt || (F[i] in cmd) || cite(x, F[i])) print F[i] "\t" t
+}
+FILENAME == ARGV[1] { F[++nf] = $0; next }
+FNR == 1 { if (t != "") liens(); t = FILENAME; x = "" }
+{ sub(/\r$/, ""); x = x "\n" $0 }
+END { if (t != "") liens() }'
+
+# Programme awk de l'historique : lit « git log --name-only » (en-tête de
+# commit précédé de D, fin du message marquée par F) et écrit
+# « fichier<TAB>ticket » pour chaque ticket du commit (pieds « Ticket : #n »,
+# branche type/<n>-sujet d'une fusion) et chaque fichier modifié
+# shellcheck disable=SC2016 # programme awk, rien à développer
+CARTE_HIST_AWK='
+# Tickets cités par la ligne l, si c est un pied « Ticket(s) : #n »
+function pied(l) {
+    if (l !~ /^[ \t]*[Tt][Ii][Cc][Kk][Ee][Tt][Ss]?[ \t]*:[ \t]*#[0-9]/) return
+    while (match(l, /#[0-9]+/)) {
+        T[substr(l, RSTART + 1, RLENGTH - 1) + 0] = 1
+        l = substr(l, RSTART + RLENGTH)
+    }
+}
+index($0, D) == 1 {
+    split("", T); msg = 1; $0 = substr($0, 2)
+    if ($0 ~ /^Merge / && match($0, /[A-Za-z]+\/[0-9]+-/)) {
+        b = substr($0, RSTART, RLENGTH); sub(/^[A-Za-z]+\//, "", b); T[b + 0] = 1
+    }
+}
+msg {
+    k = index($0, F)
+    if (k > 0) { pied(substr($0, 1, k - 1)); msg = 0 } else pied($0)
+    next
+}
+{ sub(/\r$/, "") }
+$0 != "" { for (n in T) print $0 "\t" n }'

package/hooks/lib/commentaires.sh

@@ -9,27 +9,17 @@
 # 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
+    local base="$1" new="$2" a b f old lang added tmp
     tmp="$(mktemp -d)"
-    while IFS=$'\t' read -r st a b; do
+    while IFS=$'\t' read -r _ 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
+        comments_lang_r "$f" "$tmp/new"
+        lang="$REPLY"
+        [ -n "$lang" ] || continue
         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"
@@ -42,7 +32,7 @@ comments_missing() {
             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"
+        awk -v lang="$lang" -v added="$added" -v f="$f" -v q="'" "$COMMENTS_AWK_LIB$COMMENTS_AWK" "$tmp/base" "$tmp/new"
     done < <(
         if [ -n "$new" ]; then
             git diff --name-status -M --diff-filter=ACMR "$base" "$new"
@@ -53,6 +43,22 @@ comments_missing() {
     rm -rf "$tmp"
 }
 
+# REPLY = langage du fichier $1 pour la détection des fonctions (shell, py,
+# js), vide sinon ; $2 = son contenu, dont le shebang décide sans extension.
+# Partagé par le contrôle et la carte (repowarden carte) : une seule détection.
+comments_lang_r() {
+    local l=""
+    case "${1##*/}" in
+        *.sh | *.bash) REPLY=shell; return 0 ;;
+        *.py) REPLY=py; return 0 ;;
+        *.js | *.jsx | *.mjs | *.cjs | *.ts | *.tsx) REPLY=js; return 0 ;;
+        *.*) REPLY=""; return 0 ;;
+    esac
+    # Script sans extension (bin/…) : seul un shebang sh ou bash compte
+    IFS= read -r l <"$2" 2>/dev/null || true
+    if [[ "$l" =~ ^#!.*[/\ ](ba)?sh([[:space:]]|$) ]]; then REPLY=shell; else REPLY=""; fi
+}
+
 # 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() {
@@ -66,11 +72,10 @@ comments_check() {
     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
+# Bibliothèque awk commune au contrôle et à la carte : déclarations de
+# fonctions et commentaire au-dessus (variables lang et q)
 # shellcheck disable=SC2016 # programme awk, rien à développer
-COMMENTS_AWK='
+COMMENTS_AWK_LIB='
 # Nom de la fonction déclarée par la ligne l (vide sinon), selon le langage
 function nom(l) {
     if (lang == "shell") {
@@ -111,6 +116,26 @@ function commentee(i,   j, s) {
     s = "^[ \t]*[rRuUbBfF]*[\"" q "]"
     return j <= N && L[j] ~ s
 }
+# Texte des lignes de commentaire contiguës juste au-dessus de la ligne i,
+# jointes par une espace (décorateurs et directives sautés), vide sinon
+function commentaire(i,   j, s, t) {
+    s = ""
+    for (j = i - 1; j > 0 && L[j] !~ /^#!/ && (L[j] ~ /^[ \t]*@/ || L[j] ~ /^[ \t]*(#|\/\/|\/\*|\*)/); j--) {
+        if (L[j] ~ /^[ \t]*@/ || directive(L[j])) continue
+        t = L[j]
+        sub(/^[ \t]*(#+|\/\/+|\/\*+|\*+)[ \t]*/, "", t); sub(/[ \t]*\*\/[ \t]*$/, "", t)
+        gsub(/\t/, " ", t); sub(/[ \t]+$/, "", t)
+        if (t != "") s = (s == "" ? t : t " " s)
+    }
+    return s
+}
+'
+
+# 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='
 FILENAME == ARGV[1] { n = nom($0); if (n != "") ancien[n] = 1; next }
 { L[FNR] = $0; N = FNR }
 END {

package/hooks/lib/i18n/en.sh

@@ -114,13 +114,14 @@ _msg_en() {
         help.alias.feat) _M="(branch: feature/ accepted)" ;;
         help.alias.fix) _M="(branch: bugfix/, hotfix/ accepted)" ;;
         # Help texts for commands (--help): single source shown by bin/repowarden
-        help.main) _M="Usage: repowarden <command> [options] · detailed help: repowarden <command> --help\n\n  repowarden                                     post status and next step\n  repowarden statut                              (same)\n  repowarden install [--global] [--lang fr|en]   activate hooks (install.sh)\n  repowarden uninstall [--global] [--purge]      remove them (before npm uninstall -g)\n  repowarden bots                                GitHub repo bots (CI, releases, tickets…)\n  repowarden cc                                  commit assistant\n  repowarden code-mort                           new dead code in branch\n  repowarden ticket                              ticket of the current branch\n  repowarden ticket <n>                          branch of ticket (created, linked if needed)\n  repowarden ticket nouveau \"<title>\"            new ticket\n  repowarden ticket comment <n> \"<text>\"         add a comment\n  repowarden ticket label <n> <label> [--remove] manage ticket labels\n  repowarden pr label <n> <label> [--remove]     manage PR labels\n  repowarden pr checks <n>                       show PR checks\n  repowarden run rerun <id|--failed|--workflow>  rerun a workflow\n  repowarden run list [--workflow <name>]        list recent runs\n  repowarden tickets init                        set up ticket tracking (GitHub)\n  repowarden tickets sync                        my assigned tickets → local branches\n  repowarden proteger [options]                  protect GitHub branches\n  repowarden migrer [--pr] [--hooks]             migrate from repogarde to repowarden\n  repowarden npm-publication                     automate npm publication\n  repowarden app init                            GitHub App for workflows (once)\n  repowarden bot [init|rapport]                  org bot (pilot repo)\n  repowarden agents init [--claude] [--opencode] AI agent guard (Claude Code, opencode)\n  repowarden agents retirer                      removes the AI agent guard\n  repowarden garde                               checks an agent action (called by its hook)\n  repowarden --version                           installed version" ;;
+        help.main) _M="Usage: repowarden <command> [options] · detailed help: repowarden <command> --help\n\n  repowarden                                     post status and next step\n  repowarden statut                              (same)\n  repowarden install [--global] [--lang fr|en]   activate hooks (install.sh)\n  repowarden uninstall [--global] [--purge]      remove them (before npm uninstall -g)\n  repowarden bots                                GitHub repo bots (CI, releases, tickets…)\n  repowarden cc                                  commit assistant\n  repowarden code-mort                           new dead code in branch\n  repowarden carte                               project map: functions and their why\n  repowarden ticket                              ticket of the current branch\n  repowarden ticket <n>                          branch of ticket (created, linked if needed)\n  repowarden ticket nouveau \"<title>\"            new ticket\n  repowarden ticket comment <n> \"<text>\"         add a comment\n  repowarden ticket label <n> <label> [--remove] manage ticket labels\n  repowarden pr label <n> <label> [--remove]     manage PR labels\n  repowarden pr checks <n>                       show PR checks\n  repowarden run rerun <id|--failed|--workflow>  rerun a workflow\n  repowarden run list [--workflow <name>]        list recent runs\n  repowarden tickets init                        set up ticket tracking (GitHub)\n  repowarden tickets sync                        my assigned tickets → local branches\n  repowarden proteger [options]                  protect GitHub branches\n  repowarden migrer [--pr] [--hooks]             migrate from repogarde to repowarden\n  repowarden npm-publication                     automate npm publication\n  repowarden app init                            GitHub App for workflows (once)\n  repowarden bot [init|rapport]                  org bot (pilot repo)\n  repowarden agents init [--claude] [--opencode] AI agent guard (Claude Code, opencode)\n  repowarden agents retirer                      removes the AI agent guard\n  repowarden garde                               checks an agent action (called by its hook)\n  repowarden --version                           installed version" ;;
         help.statut) _M="Usage: repowarden statut   (or repowarden, no args)\n\nRead-only status of repowarden on this machine and in the current repo,\nplus the next command to run (like \"gh auth status\" or \"brew doctor\")." ;;
         help.install) _M="Usage: repowarden install [--global] [--lang fr|en] [--bots | --sans-bots]\n\nActivate repowarden hooks (install.sh).\n  --global       all repos (and commit assistant: git cc)\n  --lang fr|en   message language (asked once if unset)\n  --bots         then propose repo bots (repowarden bots)\n  --sans-bots    never propose bots" ;;
         help.uninstall) _M="Usage: repowarden uninstall [--global] [--purge] [--scan FOLDER]\n\nRemove repowarden hooks (only if owned). Do before npm uninstall -g.\n  --global        also remove global installation\n  --purge         remove caches and list repos still pointing to repowarden\n  --scan FOLDER   check repos in FOLDER still using repowarden (with --purge)" ;;
         help.bots) _M="Usage: repowarden bots\n\nSet up GitHub repo bots (CI, releases, cleanup, tickets, App, protection,\nnpm): one global question, per-bot confirmation, preview, final confirmation.\nNothing done without consent. Can be rerun. Also via install --bots.\nNeeds a terminal, gh logged in and admin rights on the repo." ;;
         help.bot) _M="Usage: repowarden bot [--repo o/r]… [--dry-run] [--rapport FILE]\n       repowarden bot rapport FILE\n       repowarden bot init\n\nOrg bot: nightly (and on demand) updates adopted projects (protection,\nmigration), publishes a report to the \"Rapport du bot repowarden\" issue.\n--dry-run shows without changes. init writes .github/workflows/bot.yml.\nUses installation token of the bot App (repowarden app init --bot)." ;;
         help.cc) _M="Usage: repowarden cc [git commit options]   (alias: git cc)\n       repowarden cc -m \"description\" [--type T] [--scope S] [--breaking NOTE] [--body TEXT] [--refs \"Ticket: #12\"]\n       repowarden cc --dry-run\n\nConventional commit assistant: guides header, body and footer, runs hooks.\nBatch mode (-m etc.): same checks, type/scope inferred from branch if omitted.\n  --strict    any refused answer stops (nothing committed)\n  --dry-run   show message without committing" ;;
+        help.carte) _M="Usage: repowarden carte                              (re)generates the map\n       repowarden carte <file|function|'#n'> [--json] useful excerpt\n\nProject map, no LLM: every function of the shell scripts, with\nits file, line and \"why\" (the comment right above it),\nthe tests of each file (same name, cited path or command) and the tickets\nthat changed it (git \"Ticket : #n\" footers, no network), with the design\nof each (read with gh once, cached).\nWritten to .repowarden/carte/carte.json, a folder ignored by git; when queried,\nit is regenerated first if missing or stale. --json: output for tools.\nRequires jq." ;;
         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)." ;;
@@ -130,7 +131,7 @@ _msg_en() {
         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/" ;;
         help.npm-publication) _M="Usage: repowarden npm-publication [--repo owner/name] [--workflow release.yml]\n       [--environnement NAME] [--dry-run]\n\nSets up automatic npm publishing per release via OIDC (trusted publishing,\nprovenance). Needs npm logged in, package exists; if interrupted resumes.\nWorkflow: release.yml publishes via npm-publish.yml." ;;
         help.garde) _M="Usage: repowarden garde [--format claude|opencode]   (reads the action on standard input)\n\nAI agent guard, called by the agent's hook before each action (repowarden\nagents init wires it): exit code 0 allowed, 2 refused with the command to\nrun. In a repowarden repository: no change on a detached HEAD, on a\nprotected branch, or outside a ticket branch when the repository tracks its\ntickets; branches created by repowarden ticket <n>, commits by repowarden\ncc (repowarden hooks active, off protected branches); no --no-verify, no\ngit add . / -A / --all. Requires jq." ;;
-        help.agents) _M="Usage: repowarden agents init    [--claude] [--opencode] [--projet | --global]\n       repowarden agents retirer [--claude] [--opencode] [--projet | --global]\n\nWires the guard (repowarden garde) into AI agents: Claude Code PreToolUse\nhook (.claude/settings.json), opencode plugin\n(.opencode/plugins/repowarden-garde.js). Without --claude or --opencode:\nboth. --projet (default): repository files, to commit; --global: user\nconfiguration (\$CLAUDE_CONFIG_DIR, ~/.claude by default;\n\$OPENCODE_CONFIG_DIR, else \$XDG_CONFIG_HOME/opencode, ~/.config/opencode by\ndefault). Re-runnable: existing files are completed, never overwritten.\nretirer (or remove): removes only what init wrote." ;;
+        help.agents) _M="Usage: repowarden agents init    [--claude] [--opencode] [--projet | --global]\n       repowarden agents retirer [--claude] [--opencode] [--projet | --global]\n\nWires the guard (repowarden garde) into AI agents: Claude Code PreToolUse\nhook (.claude/settings.json), opencode plugins\n(.opencode/plugins/repowarden-garde.js for opencode 1.x,\nrepowarden-garde-v2.js for 2.x). Without --claude or --opencode:\nboth. --projet (default): repository files, to commit; --global: user\nconfiguration (\$CLAUDE_CONFIG_DIR, ~/.claude by default;\n\$OPENCODE_CONFIG_DIR, else \$XDG_CONFIG_HOME/opencode, ~/.config/opencode by\ndefault). Re-runnable: existing files are completed, never overwritten.\nretirer (or remove): removes only what init wrote." ;;
         help.app) _M="Usage: repowarden app init [--repo owner/name] [--nom NAME] [--administration]\n       repowarden app init --bot\n\nCreates/sets up a GitHub App for repowarden workflows (Actions token doesn't\ntrigger other workflows; App token does). Browser-based manifest, minimal\npermissions, credentials stored securely, installed on repo. --bot for org\nbot (pilot repo). Needs gh and node. Rerunnable." ;;
         # Hooks and language plugins
         hook.pre_commit.1) _M="Commit refused: branch name does not follow the convention." ;;
@@ -440,6 +441,21 @@ _msg_en() {
         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." ;;
+        # Project map (repowarden carte)
+        carte.done) _M="Map: %s file(s), %s function(s), %s without a comment → %s" ;;
+        carte.no_repo) _M="repowarden carte: run it inside a git repository." ;;
+        carte.no_jq) _M="jq is missing: the map needs it (install jq: https://jqlang.org)." ;;
+        carte.no_comment) _M="(no comment)" ;;
+        carte.file_empty) _M="%s: no function listed in the map." ;;
+        carte.tests) _M="Tests: %s" ;;
+        carte.tickets) _M="Tickets: %s" ;;
+        carte.conception) _M="Design:" ;;
+        carte.no_gh) _M="gh missing or not logged in (gh auth login): map without the tickets' design." ;;
+        carte.ticket_title) _M="Ticket #%s: modified files" ;;
+        carte.ticket_unknown) _M="Ticket #%s: no commit cites it (footer \"Ticket : #%s\" or branch type/%s-topic)." ;;
+        carte.tests_run) _M="  → %s" ;;
+        carte.no_tests) _M="No test found for %s (no test with the same name, no test citing its path or repowarden command)." ;;
+        carte.unknown) _M="\"%s\" is neither a file nor a function of the map." ;;
         ci.section.commits) _M="Commit messages (Conventional Commits)" ;;
         ci.section.branch) _M="Branch name" ;;
         ci.section.secrets) _M="Secrets (gitleaks)" ;;
@@ -502,6 +518,7 @@ _msg_en() {
         st.repo) _M="Repository: %s" ;;
         st.repo_local) _M="Repository-specific hooks (local core.hooksPath = %s), take precedence" ;;
         st.repo_lefthook) _M="%s present: lefthook is no longer supported since repowarden 4, its commands are not run. Move them to .repowarden/<hook>, the expected version to .repowarden.conf (version)" ;;
+        st.repo_precommit) _M=".pre-commit-config.yaml present: its hooks are not run (pre-commit refuses to install with core.hooksPath set). Install them in .git/hooks, which repowarden runs on every commit: %s" ;;
         st.repo_version_old) _M="The project requires repowarden %s; installed: %s" ;;
         st.repo_version_ok) _M="Version required by the project (%s): met" ;;
         st.repo_forge) _M="Platform: %s" ;;
@@ -514,6 +531,9 @@ _msg_en() {
         st.agents_sans_garde) _M="AI agent without the guard (Claude Code, opencode): its actions are only checked at commit time. → %s" ;;
         st.agents_stale) _M="Outdated repowarden guard (%s): wired by an earlier version of repowarden. → %s" ;;
         st.next) _M="Next step:" ;;
+        st.carte_absente) _M="No project map (optional, read by agents before changing a file): repowarden carte" ;;
+        st.carte_ok) _M="Project map up to date (repowarden carte <file>)" ;;
+        st.carte_perimee) _M="Project map is stale: files changed since, it no longer tells what the code does." ;;
         st.ready) _M="All set: git cc to commit, repowarden code-mort on a branch." ;;
         st.help) _M="Every command: repowarden --help" ;;
         # Tickets
@@ -669,8 +689,11 @@ _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.assign_failed) _M="PR #%s: GitHub refused to assign %s, PR left unassigned" ;;
         tk.pr_additions) _M="Ticket additions" ;;
         tk.pr_design) _M="Design (summary)" ;;
+        tk.pr_does) _M="What this PR does" ;;
+        tk.pr_ticket) _M="Ticket #%s" ;;
         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)" ;;
@@ -723,6 +746,7 @@ _msg_en() {
         garde.detache) _M="change refused: detached HEAD in %s.\n  → Switch to a ticket's branch: repowarden ticket <n>" ;;
         garde.protegee) _M="change refused: \"%s\" is a protected branch.\n  → Work on a ticket's branch: repowarden ticket <n>" ;;
         garde.protegee_libre) _M="change refused: \"%s\" is a protected branch.\n  → Create a work branch: git switch -c <type>/<topic>" ;;
+        garde.carte) _M="  → Before changing %s, once on the right branch: repowarden carte %s (functions, tests, tickets)" ;;
         garde.hors_ticket) _M="change refused: branch \"%s\" is not a ticket's branch (<type>/<n>-<topic>).\n  → Take the ticket: repowarden ticket <n>" ;;
         garde.branche) _M="command refused: \"%s\" creates a branch; here, branches come from tickets.\n  → repowarden ticket <n>" ;;
         garde.commit) _M="command refused: \"%s\"; commits go through the assistant (only --amend --no-edit is allowed).\n  → repowarden cc -m \"<description>\" --refs \"Ticket : #<n>\"" ;;

package/hooks/lib/i18n/fr.sh

@@ -237,13 +237,14 @@ _msg_fr() {
         help.alias.fix) _M="(branche : bugfix/, hotfix/ acceptés)" ;;
         # Aide des commandes (repowarden <commande> --help) : source unique,
         # affichée par bin/repowarden avant toute action (printf '%b\n' → \n)
-        help.main) _M="Usage : repowarden <commande> [options] · aide détaillée : repowarden <commande> --help\n\n  repowarden                                     état du poste et étape suivante\n  repowarden statut                              (idem)\n  repowarden install [--global] [--lang fr|en]   active les hooks (install.sh)\n  repowarden uninstall [--global] [--purge]      les retire (avant npm uninstall -g)\n  repowarden bots                                bots du dépôt GitHub (CI, releases, tickets…)\n  repowarden cc                                  assistant de commit\n  repowarden code-mort                           nouveau code mort de la branche\n  repowarden ticket                              ticket de la branche courante\n  repowarden ticket <n>                          branche du ticket (créée, liée, si besoin)\n  repowarden ticket nouveau \"<titre>\"            nouveau ticket\n  repowarden ticket comment <n> \"<texte>\"        commentaire sur un ticket\n  repowarden ticket label <n> <label> [--remove] gère les labels d'un ticket\n  repowarden pr label <n> <label> [--remove]     gère les labels d'une PR\n  repowarden pr checks <n>                       vérifie les checks d'une PR\n  repowarden run rerun <id|--failed|--workflow>  relance un workflow\n  repowarden run list [--workflow <nom>]         liste les runs récents\n  repowarden tickets init                        suivi des tickets (GitHub)\n  repowarden tickets sync                        mes tickets assignés → leurs branches locales\n  repowarden proteger [options]                  protection des branches (GitHub)\n  repowarden migrer [--pr] [--hooks]             passage de repogarde à repowarden\n  repowarden npm-publication                     publication npm automatique\n  repowarden app init                            GitHub App des workflows (une fois)\n  repowarden bot [init|rapport]                  bot d'organisation (dépôt de pilotage)\n  repowarden agents init [--claude] [--opencode] garde-fou des agents IA (Claude Code, opencode)\n  repowarden agents retirer                      retire le garde-fou des agents IA\n  repowarden garde                               vérifie une action d'agent (appelé par son hook)\n  repowarden --version                           version installée" ;;
+        help.main) _M="Usage : repowarden <commande> [options] · aide détaillée : repowarden <commande> --help\n\n  repowarden                                     état du poste et étape suivante\n  repowarden statut                              (idem)\n  repowarden install [--global] [--lang fr|en]   active les hooks (install.sh)\n  repowarden uninstall [--global] [--purge]      les retire (avant npm uninstall -g)\n  repowarden bots                                bots du dépôt GitHub (CI, releases, tickets…)\n  repowarden cc                                  assistant de commit\n  repowarden code-mort                           nouveau code mort de la branche\n  repowarden carte                               carte du projet : fonctions et leur pourquoi\n  repowarden ticket                              ticket de la branche courante\n  repowarden ticket <n>                          branche du ticket (créée, liée, si besoin)\n  repowarden ticket nouveau \"<titre>\"            nouveau ticket\n  repowarden ticket comment <n> \"<texte>\"        commentaire sur un ticket\n  repowarden ticket label <n> <label> [--remove] gère les labels d'un ticket\n  repowarden pr label <n> <label> [--remove]     gère les labels d'une PR\n  repowarden pr checks <n>                       vérifie les checks d'une PR\n  repowarden run rerun <id|--failed|--workflow>  relance un workflow\n  repowarden run list [--workflow <nom>]         liste les runs récents\n  repowarden tickets init                        suivi des tickets (GitHub)\n  repowarden tickets sync                        mes tickets assignés → leurs branches locales\n  repowarden proteger [options]                  protection des branches (GitHub)\n  repowarden migrer [--pr] [--hooks]             passage de repogarde à repowarden\n  repowarden npm-publication                     publication npm automatique\n  repowarden app init                            GitHub App des workflows (une fois)\n  repowarden bot [init|rapport]                  bot d'organisation (dépôt de pilotage)\n  repowarden agents init [--claude] [--opencode] garde-fou des agents IA (Claude Code, opencode)\n  repowarden agents retirer                      retire le garde-fou des agents IA\n  repowarden garde                               vérifie une action d'agent (appelé par son hook)\n  repowarden --version                           version installée" ;;
         help.statut) _M="Usage : repowarden statut   (ou repowarden, sans argument)\n\nÉtat de repowarden sur ce poste et dans le dépôt courant, puis la commande\nsuivante à lancer (l'équivalent de « gh auth status » ou « brew doctor »).\nLecture seule : rien n'est modifié." ;;
         help.install) _M="Usage : repowarden install [--global] [--lang fr|en] [--bots | --sans-bots]\n\nActive les hooks repowarden (install.sh).\n  --global       tous les dépôts (et l'assistant de commit : git cc)\n  --lang fr|en   langue des messages (demandée une fois sinon)\n  --bots         propose ensuite les bots du dépôt GitHub (repowarden bots)\n  --sans-bots    ne plus jamais les proposer" ;;
         help.uninstall) _M="Usage : repowarden uninstall [--global] [--purge] [--scan DOSSIER]\n\nRetire les hooks repowarden (seulement s'ils sont les tiens), avant\nnpm uninstall -g.\n  --global        retire aussi l'installation globale\n  --purge         retire les caches et liste les dépôts encore branchés\n  --scan DOSSIER  dépôts de DOSSIER encore branchés sur repowarden (avec --purge)" ;;
         help.bots) _M="Usage : repowarden bots\n\nBots du dépôt GitHub courant : une question globale, un accord par bot (CI,\nreleases, nettoyage, tickets, App, protection, npm), l'aperçu de ce qui sera\ncréé ou modifié, puis une confirmation finale. Rien sans accord, relançable\npour compléter. Aussi : repowarden install --bots, et --sans-bots pour ne\nplus les proposer. Demande un terminal, gh connecté et les droits\nd'administration du dépôt." ;;
         help.bot) _M="Usage : repowarden bot [--repo o/r]… [--dry-run] [--rapport FICHIER]\n        repowarden bot rapport FICHIER\n        repowarden bot init\n\nBot d'organisation : chaque nuit (et à la demande) il applique chaque projet\nadopté (protection, migration) et publie son rapport dans l'issue « Rapport\ndu bot repowarden » ; --dry-run voit sans rien modifier. init : écrit le\nworkflow du dépôt de pilotage (.github/workflows/bot.yml). GH_TOKEN : jeton\nd'installation de l'App (repowarden app init --bot)." ;;
         help.cc) _M="Usage : repowarden cc [options de git commit]   (alias : git cc, installé par install.sh)\n        repowarden cc -m \"description\" [--type T] [--scope S] [--breaking NOTE] [--body TEXTE] [--refs \"Ticket : #12\"]\n        repowarden cc --dry-run\n\nAssistant de commit conventionnel : guide l'en-tête, le corps et le pied,\npuis commit via les hooks habituels. Sans question (-m : scripts, agents) :\nmêmes contrôles, type et scope déduits de la branche s'ils sont omis.\n  --strict    une réponse refusée arrête tout (rien n'est commité)\n  --dry-run   affiche le message sans commiter" ;;
+        help.carte) _M="Usage : repowarden carte                              (re)génère la carte\n        repowarden carte <fichier|fonction|'#n'> [--json]  extrait utile\n\nCarte du projet, sans LLM : chaque fonction des scripts shell, avec\nson fichier, sa ligne et son « pourquoi » (le commentaire juste au-dessus),\nles tests de chaque fichier (même nom, chemin ou commande cités) et les\ntickets qui l'ont modifié (pieds « Ticket : #n » de git, sans réseau), avec\nla conception de chacun (lue par gh une fois, mise en cache).\nÉcrite dans .repowarden/carte/carte.json, dossier ignoré par git ; interrogée,\nelle est d'abord régénérée si elle est absente ou périmée. --json : sortie\npour les outils. Demande jq." ;;
         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)." ;;
@@ -253,7 +254,7 @@ _msg_fr() {
         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/" ;;
         help.npm-publication) _M="Usage : repowarden npm-publication [--repo propriétaire/nom] [--workflow release.yml]\n        [--environnement NOM] [--dry-run]\n\nPublication npm automatique mise en place en une commande : chaque release\npublie le paquet (workflow npm-publish.yml), sans jeton (publication de\nconfiance OIDC, provenance jointe) : connexion npm, paquet existant, puis\nrelation de confiance. Interrompue, la commande reprend où elle en était." ;;
         help.garde) _M="Usage : repowarden garde [--format claude|opencode]   (lit l'action sur l'entrée standard)\n\nGarde-fou des agents IA, appelé par leur hook avant chaque action\n(repowarden agents init le branche) : code 0 permis, code 2 refusé avec la\ncommande à lancer. Dans un dépôt repowarden : pas de modification en HEAD\ndétaché, sur une branche protégée, ni hors branche de ticket si le dépôt\nsuit ses tickets ; branche créée par repowarden ticket <n>, commit par\nrepowarden cc (hooks repowarden actifs, hors branche protégée) ; ni\n--no-verify ni git add . / -A / --all. Demande jq." ;;
-        help.agents) _M="Usage : repowarden agents init    [--claude] [--opencode] [--projet | --global]\n        repowarden agents retirer [--claude] [--opencode] [--projet | --global]\n\nBranche le garde-fou (repowarden garde) dans les agents IA : hook PreToolUse\nde Claude Code (.claude/settings.json), plugin opencode\n(.opencode/plugins/repowarden-garde.js). Sans --claude ni --opencode : les\ndeux. --projet (défaut) : fichiers du dépôt, à versionner ; --global :\nconfiguration de l'utilisateur (\$CLAUDE_CONFIG_DIR, ~/.claude par défaut ;\n\$OPENCODE_CONFIG_DIR, sinon \$XDG_CONFIG_HOME/opencode, ~/.config/opencode par\ndéfaut). Relançable : fichiers existants complétés, jamais écrasés.\nretirer : enlève seulement ce qu'init a écrit." ;;
+        help.agents) _M="Usage : repowarden agents init    [--claude] [--opencode] [--projet | --global]\n        repowarden agents retirer [--claude] [--opencode] [--projet | --global]\n\nBranche le garde-fou (repowarden garde) dans les agents IA : hook PreToolUse\nde Claude Code (.claude/settings.json), plugins opencode\n(.opencode/plugins/repowarden-garde.js pour opencode 1.x,\nrepowarden-garde-v2.js pour 2.x). Sans --claude ni --opencode : les\ndeux. --projet (défaut) : fichiers du dépôt, à versionner ; --global :\nconfiguration de l'utilisateur (\$CLAUDE_CONFIG_DIR, ~/.claude par défaut ;\n\$OPENCODE_CONFIG_DIR, sinon \$XDG_CONFIG_HOME/opencode, ~/.config/opencode par\ndéfaut). Relançable : fichiers existants complétés, jamais écrasés.\nretirer : enlève seulement ce qu'init a écrit." ;;
         help.app) _M="Usage : repowarden app init [--repo propriétaire/nom] [--nom NOM] [--administration]\n        repowarden app init --bot\n\nGitHub App du dépôt : identité d'automatisation des workflows repowarden (le\njeton des Actions ne déclenche aucun workflow, un jeton de l'App, si).\nCréation dans le navigateur (flux « manifest »), permissions minimales,\nidentifiants rangés sans être affichés, installation sur le dépôt. --bot :\nApp du bot d'organisation, dans le dépôt de pilotage. Relançable ; demande\ngh et node." ;;
         # CI et protection
         ci.check.2) _M="Pas de base : vérification ignorée." ;;
@@ -441,6 +442,21 @@ _msg_fr() {
         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." ;;
+        # Carte du projet (repowarden carte)
+        carte.done) _M="Carte : %s fichier(s), %s fonction(s), dont %s sans commentaire → %s" ;;
+        carte.no_repo) _M="repowarden carte : à lancer dans un dépôt git." ;;
+        carte.no_jq) _M="jq absent : la carte en a besoin (installer jq : https://jqlang.org)." ;;
+        carte.no_comment) _M="(sans commentaire)" ;;
+        carte.file_empty) _M="%s : aucune fonction répertoriée dans la carte." ;;
+        carte.tests) _M="Tests : %s" ;;
+        carte.tickets) _M="Tickets : %s" ;;
+        carte.conception) _M="Conception :" ;;
+        carte.no_gh) _M="gh absent ou non connecté (gh auth login) : carte sans la conception des tickets." ;;
+        carte.ticket_title) _M="Ticket #%s : fichiers modifiés" ;;
+        carte.ticket_unknown) _M="Ticket #%s : aucun commit ne le cite (pied « Ticket : #%s » ou branche type/%s-sujet)." ;;
+        carte.tests_run) _M="  → %s" ;;
+        carte.no_tests) _M="Aucun test trouvé pour %s (ni test du même nom, ni chemin ou commande repowarden cités dans un test)." ;;
+        carte.unknown) _M="« %s » n'est ni un fichier ni une fonction de la carte." ;;
         ci.section.commits) _M="Messages de commit (Conventional Commits)" ;;
         ci.section.branch) _M="Nom de branche" ;;
         ci.section.secrets) _M="Secrets (gitleaks)" ;;
@@ -503,6 +519,7 @@ _msg_fr() {
         st.repo) _M="Dépôt : %s" ;;
         st.repo_local) _M="Hooks propres à ce dépôt (core.hooksPath local = %s), prioritaires" ;;
         st.repo_lefthook) _M="%s présent : lefthook n'est plus pris en charge depuis repowarden 4, ses commandes ne sont pas lancées. Les déplacer dans .repowarden/<hook>, la version attendue dans .repowarden.conf (version)" ;;
+        st.repo_precommit) _M=".pre-commit-config.yaml présent : ses hooks ne sont pas lancés (pre-commit refuse de s'installer avec core.hooksPath). Les installer dans .git/hooks, que repowarden lance à chaque commit : %s" ;;
         st.repo_version_old) _M="Le projet demande repowarden %s ; installé : %s" ;;
         st.repo_version_ok) _M="Version demandée par le projet (%s) : respectée" ;;
         st.repo_forge) _M="Plateforme : %s" ;;
@@ -515,6 +532,9 @@ _msg_fr() {
         st.agents_sans_garde) _M="Agent IA sans garde-fou (Claude Code, opencode) : ses actions ne sont vérifiées qu'au commit. → %s" ;;
         st.agents_stale) _M="Garde-fou repowarden périmé (%s) : posé par une version antérieure de repowarden. → %s" ;;
         st.next) _M="Étape suivante :" ;;
+        st.carte_absente) _M="Carte du projet absente (facultative, lue par les agents avant de modifier un fichier) : repowarden carte" ;;
+        st.carte_ok) _M="Carte du projet à jour (repowarden carte <fichier>)" ;;
+        st.carte_perimee) _M="Carte du projet périmée : des fichiers ont changé depuis, elle ne dit plus ce que fait le code." ;;
         st.ready) _M="Tout est prêt : git cc pour commiter, repowarden code-mort sur une branche." ;;
         st.help) _M="Toutes les commandes : repowarden --help" ;;
         # Tickets
@@ -670,8 +690,11 @@ _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.assign_failed) _M="PR #%s : assignation de %s refusée par GitHub, PR laissée sans assigné" ;;
         tk.pr_additions) _M="Ajouts du ticket" ;;
         tk.pr_design) _M="Conception (résumé)" ;;
+        tk.pr_does) _M="Ce que fait cette PR" ;;
+        tk.pr_ticket) _M="Ticket #%s" ;;
         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)" ;;
@@ -724,6 +747,7 @@ _msg_fr() {
         garde.detache) _M="modification refusée : HEAD détaché dans %s.\n  → Se placer sur la branche d'un ticket : repowarden ticket <n>" ;;
         garde.protegee) _M="modification refusée : « %s » est une branche protégée.\n  → Travailler sur la branche d'un ticket : repowarden ticket <n>" ;;
         garde.protegee_libre) _M="modification refusée : « %s » est une branche protégée.\n  → Créer une branche de travail : git switch -c <type>/<sujet>" ;;
+        garde.carte) _M="  → Avant de modifier %s, une fois sur la bonne branche : repowarden carte %s (fonctions, tests, tickets)" ;;
         garde.hors_ticket) _M="modification refusée : la branche « %s » n'est pas celle d'un ticket (<type>/<n>-<sujet>).\n  → Prendre le ticket : repowarden ticket <n>" ;;
         garde.branche) _M="commande refusée : « %s » crée une branche ; ici, la branche naît du ticket.\n  → repowarden ticket <n>" ;;
         garde.commit) _M="commande refusée : « %s » ; les commits passent par l'assistant (seul --amend --no-edit est permis).\n  → repowarden cc -m \"<description>\" --refs \"Ticket : #<n>\"" ;;

package/hooks/post-merge

@@ -11,6 +11,11 @@ exit_if_skipped
 run_local_hook "$@"
 # Branches locales des tickets qui me sont assignés (au plus toutes les 15 min)
 tickets_sync || true
+# Carte du projet déjà générée (repowarden carte) : recalculée après la fusion,
+# hors ligne (ni gh ni réseau), sans jamais faire échouer le hook
+if [ -n "$GIT_TOPLEVEL" ] && [ -f "$GIT_TOPLEVEL/.repowarden/carte/carte.json" ] && has jq; then
+    REPOWARDEN_CARTE_HORS_LIGNE=1 bash "$(dirname "$0")/../bin/carte" >/dev/null 2>&1 || true
+fi
 skipped prune-branches && exit 0
 
 current="$(git symbolic-ref --short HEAD 2>/dev/null || echo "")"

package/package.json

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