From 4996807db0c5d976d6553bf495d0415b67595898 Mon Sep 17 00:00:00 2001
From: Sergio <sergio@gioser.net>
Date: Thu, 20 Aug 2026 16:52:57 +0000
Subject: [PATCH] corpus: el vigia de disco miraba un solo sistema de ficheros
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Media `df` sobre el repo y nada mas. Pero las recetas Rust no gastan solo ahi:
`cargo vendor` copia DESDE `~/.cargo/registry`, que en gioser esta en `/` (74 G)
y no en `/mnt/vvv` (255 G). Hoy eso eran 138 G libres segun el vigia y 19 G de
verdad — luz verde mientras el que se llenaba era el otro, y llenar `/` no
rompe una tanda, rompe la maquina.

Ahora toma el MINIMO de los dos FS (el del repo y el de CARGO_HOME). Si
comparten FS, `df` devuelve lo mismo dos veces y es inocuo.

La purga tambien se queda corta y crece:
- `work/repos/*`, los clones --mirror de gitea de las hub-only. Se re-clonan.
- `$CARGO_HOME/registry` como ULTIMO recurso y CON GUARDA: el act-runner de
  tawasuyu corre como el mismo usuario y comparte ese ~/.cargo. Purgarlo con un
  `cargo` ajeno en vuelo le arranca los ficheros a SU compilador. Se pregunta
  por el codigo de salida de `pgrep`, no por su stdout.

De paso queda dicho en la cabecera que CARGO_HOME se vigila: en gioser el
driver se lanza con el suyo propio dentro del volumen, y asi hammer deja de
gastar `/`.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Xd5DComN9Nu47TBpYMBHBn
---
 scripts/reconstruir-corpus.sh | 36 ++++++++++++++++++++++++++++++++---
 1 file changed, 33 insertions(+), 3 deletions(-)

diff --git a/scripts/reconstruir-corpus.sh b/scripts/reconstruir-corpus.sh
index 8b959f53..003cacec 100755
--- a/scripts/reconstruir-corpus.sh
+++ b/scripts/reconstruir-corpus.sh
@@ -26,7 +26,8 @@
 # el 2026-08-10 y se llevó por delante un kernel a medias.
 #
 # Uso:   scripts/reconstruir-corpus.sh [--seco]
-# Env:   MIN_LIBRE_GB (def 25) umbral de purga · ABORT_GB (def 10) aborta antes de llenar el disco
+# Env:   MIN_LIBRE_GB (def 40) umbral de purga · ABORT_GB (def 15) aborta antes de llenar el disco
+#        CARGO_HOME (def ~/.cargo) — se VIGILA su sistema de ficheros además del del repo
 set -uo pipefail
 
 ROOT="$(cd "$(dirname "$0")/.." && pwd)"; cd "$ROOT"
@@ -42,7 +43,21 @@ MIN_LIBRE_GB="${MIN_LIBRE_GB:-40}"
 ABORT_GB="${ABORT_GB:-15}"
 SECO=0; [ "${1:-}" = "--seco" ] && SECO=1
 
-libre_gb() { df -BG --output=avail "$ROOT" 2>/dev/null | tail -1 | tr -dc 0-9; }
+# ── EL VIGÍA MIRA DOS SISTEMAS DE FICHEROS, NO UNO ──────────────────────────────────────────────
+# Medía sólo el FS del repo, y las recetas Rust no gastan sólo ahí: `cargo vendor` copia DESDE
+# `~/.cargo/registry`, que en gioser está en `/` (74 G) y no en `/mnt/vvv` (255 G). El 2026-08-20 eso
+# era 138 G libres en el repo y 19 G en `/`, o sea que el vigía habría dado luz verde mientras el que
+# se llenaba de verdad era el otro — y llenar `/` no rompe una tanda, rompe la máquina. Se toma el
+# MÍNIMO de los dos. Si comparten FS, `df` devuelve lo mismo dos veces y esto es inocuo.
+CARGO_H="${CARGO_HOME:-$HOME/.cargo}"
+avail_gb() { df -BG --output=avail "$1" 2>/dev/null | tail -1 | tr -dc 0-9; }
+libre_gb() {
+  local a b
+  a=$(avail_gb "$ROOT"); b=$(avail_gb "$CARGO_H")
+  [ -z "${a:-}" ] && a=999999
+  [ -z "${b:-}" ] && b=999999
+  [ "$a" -le "$b" ] && echo "$a" || echo "$b"
+}
 ts() { date -u +%Y-%m-%dT%H:%M:%SZ; }
 
 # EL ORDEN IMPORTA, aunque las deps se resuelvan solas. `hammer build` construye recursivamente lo
@@ -160,8 +175,23 @@ for f in "${RECETAS[@]}"; do
   fi
   if [ "${l:-0}" -lt "$MIN_LIBRE_GB" ]; then
     # Seguro por construcción: acá NO hay ningún build corriendo (somos el único, y en serie).
-    echo "   [$(ts)] libre ${l} G < ${MIN_LIBRE_GB} ⇒ purgo work/sources" | tee -a "$LOG"
+    echo "   [$(ts)] libre ${l} G < ${MIN_LIBRE_GB} ⇒ purgo work/sources y work/repos" | tee -a "$LOG"
     rm -rf work/sources/* 2>/dev/null
+    # `work/repos` son los clones `--mirror` de gitea de las recetas hub-only. Se re-clonan; el coste
+    # es red, no trabajo perdido.
+    rm -rf work/repos/* 2>/dev/null
+    # El registry de cargo es lo ÚLTIMO, y va con guarda: el act-runner de tawasuyu corre como el
+    # mismo usuario y comparte este `~/.cargo`. Purgarlo con un `cargo` ajeno en vuelo le arranca los
+    # ficheros a SU compilador — el mismo accidente del kernel a medias, sólo que en el vecino. Se
+    # pregunta por el CÓDIGO DE SALIDA de `pgrep`, nunca por su stdout.
+    if [ "$(libre_gb)" -lt "$MIN_LIBRE_GB" ]; then
+      if pgrep -x cargo >/dev/null 2>&1 || pgrep -x rustc >/dev/null 2>&1; then
+        echo "   sigue corto, pero hay cargo/rustc ajeno en vuelo ⇒ NO toco $CARGO_H/registry" | tee -a "$LOG"
+      else
+        echo "   sigue corto ⇒ purgo $CARGO_H/registry (caché, se re-descarga)" | tee -a "$LOG"
+        rm -rf "$CARGO_H"/registry/cache/* "$CARGO_H"/registry/src/* 2>/dev/null
+      fi
+    fi
     echo "   libre tras purgar: $(libre_gb) G" | tee -a "$LOG"
   fi