@@ -76,6 +76,9 @@ RUN echo "${GH_SHA256}  /tmp/gh.tar.gz" | sha256sum -c - \
 USER runner
 WORKDIR /opt/runner
 
+# work_cache_health.sh : moitie executante de #15105, sourcee par l'entrypoint
+# au demarrage de chaque conteneur (controle du cache _work persistant).
+COPY --chown=runner:runner work_cache_health.sh /opt/runner/work_cache_health.sh
 COPY --chown=runner:runner entrypoint.sh /opt/runner/entrypoint.sh
 RUN chmod +x /opt/runner/entrypoint.sh
 
 
@@ -49,6 +49,22 @@ for gitdir in "$ACTIONS_RUNNER_INPUT_WORK"/*/*/.git; do
 done
 # ---------------------------------------------------------------------------
 
+# --- Sante du cache de depot persistant (#15105) ---------------------------
+# Meme hook job-started que le bloc sparse ci-dessus : le volume _work survit
+# au conteneur, l'entrypoint est le seul point qui s'execute avant
+# l'enregistrement du runner -- donc avant qu'un job n'attrape le cache.
+# Deux passes par clone : integrite (refs cassees -> reparation ou purge,
+# le gate de la flotte etait une loterie 1-sur-8 sans que rien le nomme),
+# puis maintenance (repack -ad si le compte de packs depasse le seuil ;
+# gc.auto=0 fait que rien d'autre ne consolide jamais). Le detail et les
+# trois controles positifs (safe.directory, stderr, .promisor) sont dans
+# work_cache_health.sh.
+WCH_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck disable=SC1091
+. "$WCH_DIR/work_cache_health.sh"
+wch_check_workdir "$ACTIONS_RUNNER_INPUT_WORK" "${RUNNER_WORK_CACHE_PACK_THRESHOLD:-16}"
+# ---------------------------------------------------------------------------
+
 cd /opt/runner
 # --disableupdate : le conteneur est --rm et le runner --ephemeral (un seul
 # job puis mort). Un self-update n'y est donc jamais CONSERVE -- GitHub ordonne
 
@@ -217,11 +217,43 @@ Les journaux des **conteneurs** sont bornes ailleurs, par `daemon.json`
 (`log-driver: local`, 10 Mo x 3). Deux mecanismes distincts, ecrits a deux endroits
 differents, qui remplissaient chacun le meme disque.
 
+## Maintenance du cache `_work` (#15105)
+
+`actions/checkout` pose `gc.auto = 0` dans le depot du slot : correct pour un
+workspace jetable, faux depuis que #14285 rend ce workspace persistant. Chaque
+job depose un pack promisor de plus (slot 1 : **264 packs** au diagnostic,
+compte croissant sans plafond), et un arret brutal laisse des refs de ZERO
+octet qui transforment le gate en loterie -- le slot 7 en portait 1471.
+
+Deux passes vivent dans l'entrypoint du conteneur (avant l'enregistrement du
+runner : aucun job en vol ne les paie, et elles tournent sous les bornes d'I/O
+du conteneur lui-meme) :
+
+- **Integrite, inconditionnelle** : refs cassees detectees sur le canal stderr
+  de `for-each-ref` (rc=0 -- seul le warning nomme la ref), reparees par
+  retrait des fichiers vides de `.git/refs` et `.git/logs` UNIQUEMENT (un
+  marqueur `.promisor` vide est legitime et vit sous `.git/objects` :
+  hors perimetre par construction), et purge du clone si le depot reste muet.
+- **Repack, seuille** : `COURSIA_RUNNER_CACHE_PACK_THRESHOLD` (defaut **16**,
+  0 = desactive) descend au conteneur ; au-dela, `git repack -ad` consolide
+  avec la mesure avant/apres au journal. Non inerte au meme titre que
+  `COURSIA_RUNNER_LOG_MAX_BYTES` : son absence est une croissance de disque
+  sans borne, pas un plafond qu'une machine n'a pas demande. Sur un clone
+  partiel `blob:none`, le repack est sur (mesure sur fixture au filtre
+  reellement honore : 5 packs promisor -> 1, marqueur preserve, lazy-fetch et
+  fetch incremental intacts).
+
+La garde de fraicheur #14801 lit desormais **deux** scripts embarques
+(`entrypoint.sh` ET `work_cache_health.sh` qu'il source) : un correctif merge
+mais non rebuild sur l'un ou l'autre est refuse au demarrage du pool.
+
 ## Voir aussi
 
 - [`../supervise.sh`](../supervise.sh) -- le superviseur, ses trois pools et ses bornes
-- [`../test_supervise_guards.sh`](../test_supervise_guards.sh) -- 18 tests, chaque garde avec son controle negatif
+- [`../test_supervise_guards.sh`](../test_supervise_guards.sh) -- 20 tests, chaque garde avec son controle negatif
+- [`../test_work_cache_health.sh`](../test_work_cache_health.sh) -- sante du cache `_work` sur fixtures git reelles (#15105)
 - [`../../../../../docs/ci/self-hosted-runners.md`](../../../../../docs/ci/self-hosted-runners.md) -- vue d'ensemble du parc
 - **#15091** -- revision du design du superviseur (traffic disque, isolation)
 - **#14385** -- volumes `_work` par slot -- les waiters n'en montent pas, le test 17 le garde
 - **#14801** -- fraicheur de l'image, verifiee par empreinte de l'entrypoint
+- **#15105** -- integrite et maintenance du cache `_work` persistant
@@ -232,6 +232,16 @@ BACKOFF_MAX_SEC="${COURSIA_RUNNER_BACKOFF_MAX_SEC:-300}"
 # jitter la disperse.
 BACKOFF_JITTER_PCT="${COURSIA_RUNNER_BACKOFF_JITTER_PCT:-25}"
 
+# Seuil de packs du cache _work persistant (#15105). Au-dela, l'entrypoint du
+# conteneur repack le clone (gc.auto=0 pose par actions/checkout : rien
+# d'autre ne consolide jamais -- slot 1 : 264 packs, compte croissant a
+# chaque job). NON inerte au meme titre que LOG_MAX_BYTES : son absence est
+# une croissance de disque sans borne, pas un plafond qu'une machine n'a pas
+# demande. 0 = desactive. Le knob descend au conteneur par -e ; la passe
+# integrite (refs cassees) est, elle, inconditionnelle -- cf
+# work_cache_health.sh et le bloc entrypoint #15105.
+CACHE_PACK_THRESHOLD="${COURSIA_RUNNER_CACHE_PACK_THRESHOLD:-16}"
+
 mkdir -p "$STATE_DIR"
 
 # Git Bash (MSYS) sous Windows reecrit les arguments de forme /posix/path des
@@ -255,21 +265,24 @@ RUNNER_CTX="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 # daemon docker-ce WSL construite 5 h AVANT le merge, jamais rebatie), et ce
 # silence a produit les rouges fantomes du sparse-checkout empoisonne. Le
 # demarrage d'un pool est le seul point qui s'execute inconditionnellement
-# (un job annule ne joue aucun step post) : on y compare le sha256 du
-# entrypoint.sh de CE checkout a celui embarque dans l'image. La lecture
+# (un job annule ne joue aucun step post) : on y compare le sha256 de CHAQUE
+# script embarque de CE checkout (entrypoint.sh, et depuis #15105
+# work_cache_health.sh qu'il source) a celui porte par l'image. La lecture
 # cote image passe par `docker run --entrypoint sha256sum` -- le Dockerfile
-# place le script a /opt/runner/entrypoint.sh et MSYS_NO_PATHCONV (exporte
-# plus haut) protege l'argument POSIX sous Git Bash.
+# place les scripts sous /opt/runner/ et MSYS_NO_PATHCONV (exporte plus haut)
+# protege l'argument POSIX sous Git Bash.
 assert_image_fresh() {
   local image="$1" build_cmd="$2"
-  local repo_sha img_sha
-  repo_sha="$(sha256sum "$RUNNER_CTX/entrypoint.sh" 2>/dev/null | awk '{print $1}')"
-  [ -n "$repo_sha" ] || die "entrypoint.sh introuvable a cote de supervise.sh ($RUNNER_CTX) -- lancer depuis un checkout du depot"
-  img_sha="$(docker run --rm --entrypoint sha256sum "$image" /opt/runner/entrypoint.sh 2>/dev/null | awk '{print $1}')"
-  [ -n "$img_sha" ] || die "lecture de /opt/runner/entrypoint.sh dans $image impossible (docker run --entrypoint sha256sum)"
-  [ "$repo_sha" = "$img_sha" ] || die "image $image PERIMEE : entrypoint.sh du checkout ($repo_sha) != entrypoint embarque ($img_sha).
+  local f repo_sha img_sha
+  for f in entrypoint.sh work_cache_health.sh; do
+    repo_sha="$(sha256sum "$RUNNER_CTX/$f" 2>/dev/null | awk '{print $1}')"
+    [ -n "$repo_sha" ] || die "$f introuvable a cote de supervise.sh ($RUNNER_CTX) -- lancer depuis un checkout du depot"
+    img_sha="$(docker run --rm --entrypoint sha256sum "$image" /opt/runner/$f 2>/dev/null | awk '{print $1}')"
+    [ -n "$img_sha" ] || die "lecture de /opt/runner/$f dans $image impossible (docker run --entrypoint sha256sum)"
+    [ "$repo_sha" = "$img_sha" ] || die "image $image PERIMEE : $f du checkout ($repo_sha) != version embarquee ($img_sha).
 Un correctif merge mais non deploye est indiscernable d'un correctif absent (#14801, #14385). Reconstruire :
     $build_cmd"
+  done
 }
 
 # --- Bornes d'I/O : resolution du device et des drapeaux docker -------------
@@ -564,6 +577,7 @@ slot_loop() {
       -v "$TOOLCACHE_VOLUME":"$TOOLCACHE_MOUNT" \
       -v "${vol_prefix}-${slot}":"$WORK_MOUNT" \
       -e RUNNER_TOOL_CACHE="$TOOLCACHE_MOUNT" \
+      -e RUNNER_WORK_CACHE_PACK_THRESHOLD="$CACHE_PACK_THRESHOLD" \
       -e ACTIONS_RUNNER_INPUT_TOKEN="$token" \
       -e ACTIONS_RUNNER_INPUT_URL="https://github.com/$REPO" \
       -e ACTIONS_RUNNER_INPUT_NAME="$name" \
 
@@ -31,13 +31,19 @@ ko() { echo "  FAIL: $1"; echo "FAIL $1" >> "$RESULTS"; }
 
 # Stubs docker + gh + ps. Le stub docker simule une image A JOUR pour le
 # garde de fraicheur #14801 : au probe `run --entrypoint sha256sum`, il rend
-# le sha256 du VRAI entrypoint.sh sibling (bake a la generation du stub).
-# STUB_IMG_ENTRYPOINT_SHA force un ecart pour tester le refus (test 9).
+# le sha256 du VRAI script sibling demande (entrypoint.sh, et depuis #15105
+# work_cache_health.sh -- le garde lit les DEUX, le stub dispatche sur le
+# chemin passe en argument). STUB_IMG_ENTRYPOINT_SHA / STUB_IMG_HEALTH_SHA
+# forcent un ecart pour tester le refus (tests 9 et 20).
 REPO_ENTRYPOINT_SHA="$(sha256sum "$SCRIPT_DIR/entrypoint.sh" 2>/dev/null | awk '{print $1}')"
+REPO_HEALTH_SHA="$(sha256sum "$SCRIPT_DIR/work_cache_health.sh" 2>/dev/null | awk '{print $1}')"
 cat > "$TEST_DIR/bin/docker" <<STUB
 #!/usr/bin/env bash
 if [ "\$1" = "run" ]; then
-  echo "\${STUB_IMG_ENTRYPOINT_SHA:-$REPO_ENTRYPOINT_SHA}  /opt/runner/entrypoint.sh"
+  case "\$*" in
+    *'/opt/runner/entrypoint.sh')        echo "\${STUB_IMG_ENTRYPOINT_SHA:-$REPO_ENTRYPOINT_SHA}  /opt/runner/entrypoint.sh" ;;
+    *'/opt/runner/work_cache_health.sh') echo "\${STUB_IMG_HEALTH_SHA:-$REPO_HEALTH_SHA}  /opt/runner/work_cache_health.sh" ;;
+  esac
   exit 0
 fi
 exit 0
@@ -121,9 +127,13 @@ echo "Test 3 : start --force leve sentinel (Defaut 2 avec --force)"
   export COURSIA_RUNNER_NAME_PREFIX="test-prefix-C"
   export COURSIA_RUNNER_STATE_DIR="$TEST_DIR/state-C"
   touch "$TEST_DIR/state-C/stop"
-  timeout --kill-after=1 2 bash "$SCRIPT_DIR/supervise.sh" start 1 --force >/dev/null 2>"$TEST_DIR/last.err" &
+  timeout --kill-after=1 4 bash "$SCRIPT_DIR/supervise.sh" start 1 --force >/dev/null 2>"$TEST_DIR/last.err" &
   TPID=$!
-  sleep 0.5
+  # 1.5 s : le garde de fraicheur #15105 lit DEUX scripts embarques, soit
+  # deux probes docker de plus avant le rm du sentinel -- sous Git Bash ou
+  # chaque fork de stub coute ~100 ms, 0.5 s coupaient parfois AVANT le rm
+  # et le test echouait sur une question de delai, pas d'intention.
+  sleep 1.5
   if [ ! -f "$TEST_DIR/state-C/stop" ]; then
     ok "sentinel leve par start --force"
   else
@@ -539,7 +549,10 @@ echo "Test 17 : waiters -- toolcache monte, et JAMAIS de volume _work (#15091)"
   cat > "$TEST_DIR/bin17/docker" <<STUB
 #!/usr/bin/env bash
 if [ "\$1" = "run" ] && printf '%s' "\$*" | grep -q -- '--entrypoint sha256sum'; then
-  echo "$REPO_ENTRYPOINT_SHA  /opt/runner/entrypoint.sh"
+  case "\$*" in
+    *'/opt/runner/entrypoint.sh')        echo "$REPO_ENTRYPOINT_SHA  /opt/runner/entrypoint.sh" ;;
+    *'/opt/runner/work_cache_health.sh') echo "$REPO_HEALTH_SHA  /opt/runner/work_cache_health.sh" ;;
+  esac
   exit 0
 fi
 if [ "\$1" = "run" ]; then
@@ -683,6 +696,29 @@ echo "Test 19 : cmd_stop rend != 0 quand le sentinel n'a PAS pu etre pose (#1509
 )
 echo ""
 
+# --- Test 20 : garde de fraicheur -- health script perime refuse (#15105) ---
+# Le garde lit DEUX fichiers depuis #15105 (work_cache_health.sh est source
+# par l'entrypoint). Le controle positif du COTE garde : un ecart sur le
+# SEUL fichier ajoute doit refuser exactement comme un ecart d'entrypoint --
+# sinon la porte que le nouveau fichier ouvre serait garde par personne.
+echo "Test 20 : start refuse si work_cache_health.sh de l'image != checkout (#15105)"
+(
+  cd "$SCRIPT_DIR"
+  unset PS_OUTPUT
+  mkdir -p "$TEST_DIR/state-20"
+  STUB_IMG_HEALTH_SHA=e000000000000000000000000000000000000000000000000000000000000000e
+  export STUB_IMG_HEALTH_SHA
+  rc="$(run_supervise 'start 1' 'test-prefix-20' "$TEST_DIR/state-20" 2>&1 | head -1 | sed 's/rc=//')"
+  err="$(cat "$TEST_DIR/last.err")"
+  if [ "$rc" != "0" ] && echo "$err" | grep -q "PERIMEE" && echo "$err" | grep -q "work_cache_health.sh"; then
+    ok "health script perime refuse, fichier FAUTIF nomme (rc=$rc)"
+  else
+    ko "refus sur work_cache_health.sh attendu, rc=$rc err=$err"
+  fi
+  unset STUB_IMG_HEALTH_SHA
+)
+echo ""
+
 # --- Verdict agrege ---------------------------------------------------------
 # `|| echo 0` serait un piege ici, et il l'a ete : `grep -c` IMPRIME "0" avant
 # de sortir 1 quand il ne trouve rien, donc le repli SUFFIXE un second zero au