sergio/takana

1#!/usr/bin/env bash
2# verificar-repro.sh — ¿reproducen los artefactos bit a bit? Reconstruye y COMPARA. Etapa 1 del SDD 23.
3#
4# ── POR QUÉ ESTE SCRIPT Y NO UN GREP ───────────────────────────────────────────────────────────
5# El no-determinismo se mide RECONSTRUYENDO Y COMPARANDO, no buscando cadenas sospechosas en los
6# binarios. El plan heredado daba 92 paquetes por «no-deterministas probables» porque tenían rutas
7# `/src` en `.debug_*`; al mirarlo resultó que `/src` es un bind CONSTANTE del lab, y que las únicas
8# rutas realmente ajenas venían de terceros (la ruta de compilación de Alpine horneada en el musl
9# prebuilt, cadenas literales del fuente, rutas de autores en assets SVG). Un grep sobre binarios da
10# CANDIDATOS, no veredictos. Ver SDD 23 §1.
11#
12# ── ⚠ QUÉ MIDE ESTE SCRIPT, EXACTAMENTE (leer antes de sacar conclusiones) ─────────────────────
13# Compara el artefacto GUARDADO en el store contra una reconstrucción de hoy. Eso NO es lo mismo que
14# medir no-determinismo, y confundirlos costó dos conclusiones equivocadas en el SDD 23:
15#   · si el artefacto guardado es viejo, se construyó con OTRO estado del lab ⇒ una diferencia es
16#     DERIVA («el mundo se movió»), no no-determinismo;
17#   · el no-determinismo es: mismas entradas, MISMO lab, salidas distintas.
18# ⇒ Esto YA NO lo tiene que hacer quien lee: ante una diferencia el script reconstruye una SEGUNDA
19#   vez y compara las dos reconstrucciones ENTRE SÍ. Si coinciden, el que estaba fuera de fecha era
20#   el guardado ⇒ `DERIVA`, que no es un fallo. Si no coinciden ⇒ `NO-DETERMINISMO`, y ahí sí. Antes
21#   la cabecera decía «corré el script dos veces y mirá la segunda», y eso dejaba el veredicto a
22#   cargo de que alguien se acordara: la primera corrida informaba «DIVERGE» sobre cosas sanas y
23#   entrenaba a no creerle. El rebuild extra sólo se paga cuando ya hubo una diferencia.
24#   (Medido antes de automatizarlo: anew, gron, age y scdoc divergían en la primera y reproducen en
25#   la segunda.)
26#
27# ── EL MÉTODO, Y POR QUÉ ES BARATO ─────────────────────────────────────────────────────────────
28# Se APARTA el artefacto (no se borra) y se reconstruye. Como las DEPS siguen en el store, el rebuild
29# es sólo el paquete en cuestión, no su cadena — que es lo que hace viable verificar decenas. Después
30# `hammer why-differs` compara los dos árboles y nombra la causa si divergen.
31#
32# ── LA RED DE SEGURIDAD ────────────────────────────────────────────────────────────────────────
33# Si el rebuild FALLA (y fallará en alguna: hay recetas que sólo construyen en ciertas máquinas), el
34# artefacto original se RESTAURA. Un verificador que destruye lo que verifica es peor que no tenerlo.
35# Por eso se APARTA en vez de borrar, y hay `trap` para reponer lo pendiente si se interrumpe.
36#
37# ⚠ El apartadero vive DENTRO del store (`store/.verificar-repro`), no en `/tmp`. Estaba en `/tmp` y
38# eso rompía la promesa de arriba en tres sitios a la vez: `/tmp` es tmpfs, así que apartar copiaba
39# el artefacto a RAM en una caja de 7,6 GiB sin swap; al ser otro sistema de ficheros el `mv` no era
40# un rename atómico sino copiar-y-borrar, así que una interrupción a mitad lo dejaba en ninguna
41# parte; y lo que sobreviviera se perdía al reiniciar. Costó un artefacto el 2026-09-05. Dentro del
42# store el `mv` es instantáneo y lo apartado SOBREVIVE a un kill: la corrida siguiente lo repone sola
43# antes de empezar. Y cuando hay NO-DETERMINISMO de verdad, los dos ejemplares se conservan en
44# `store/.divergen/` — antes se borraban, o sea que el guardián tiraba la única evidencia justo en el
45# caso que existe para encontrar.
46#
47# Uso:   scripts/verificar-repro.sh [receta.toml ...]      (sin args: muestra por clase)
48# Env:   STORE (def ./store)   N (def 30, tamaño de la muestra)
49set -uo pipefail
50ROOT="$(cd "$(dirname "$0")/.." && pwd)"; cd "$ROOT"
51STORE="${STORE:-./store}"; HAMMER="${HAMMER:-./target/release/hammer}"; N="${N:-30}"
52
53# ── EL LOCK LO TOMA EL SCRIPT, Y ANTES DE TOCAR NADA ───────────────────────────────────────────
54# Este script llama a `hammer build`, y la regla 1 del repo es que todo build va envuelto en el
55# `flock` de la granja: dos builds que compartan una dep se pisan el árbol de `work/sources` y lo
56# rompen PARA SIEMPRE (ADR 0012). Lo toma el script y no quien lo llama, por lo mismo que en
57# `poda-fuentes.sh`: así no hay forma de correrlo mal — y correrlo mal fue exactamente lo que pasó.
58#
59# `-E 3` importa: sin él, «no conseguí el lock» sale como exit 1, que es lo que este script usa para
60# «hay divergencias». Un guardián que informa «el corpus no reproduce» cuando lo que pasó es que
61# había otro build corriendo es peor que uno que no corre.
62if [ -z "${VERIFICAR_REPRO_CON_LOCK:-}" ]; then
63  export VERIFICAR_REPRO_CON_LOCK=1
64  flock -w 120 -E 3 "$ROOT/work/.farm-build.lock" "$0" "$@"
65  rc=$?
66  [ "$rc" -eq 3 ] && echo "── verificar-repro: build en vuelo (lock no tomado en 120s) ⇒ no toco nada"
67  exit "$rc"
68fi
69
70# ── ⚠ EL APARTADERO VA DENTRO DEL STORE, NO EN /tmp ────────────────────────────────────────────
71# Para verificar hay que sacar el artefacto de su sitio y dejar que hammer lo reconstruya. Ese
72# `mv` era a un `mktemp -d`, o sea a `/tmp`, y ahí se juntan tres cosas que costaron un artefacto
73# el 2026-09-05:
74#
75#   1. `/tmp` es **tmpfs** en gioser: mover un artefacto ahí lo copia a RAM, en una máquina de
76#      7,6 GiB y swap 0, compitiendo con el build que se está verificando.
77#   2. Al ser otro sistema de ficheros, `mv` NO es un rename atómico sino copiar-y-borrar. Si el
78#      proceso muere a mitad, el artefacto no está ni en un sitio ni en el otro.
79#   3. Y lo que quede ahí se pierde al reiniciar.
80#
81# Dentro del store el `mv` es un rename instantáneo, no cuesta RAM ni disco, y **sobrevive a un
82# kill**: lo que quedó apartado sigue en disco y la próxima corrida lo repone sola. El apartadero
83# empieza por punto, como `.dmerge`, y los consumidores del store filtran por `^[0-9a-f]{64}-`.
84GUARDA="$STORE/.verificar-repro"; mkdir -p "$GUARDA"; PENDIENTE=""
85
86restaurar_todo() {
87  for h in $PENDIENTE; do
88    [ -d "$GUARDA/$h" ] && [ ! -d "$STORE/$h" ] && mv "$GUARDA/$h" "$STORE/$h" && echo "  ↩ restaurado $h"
89  done
90  rmdir "$GUARDA" 2>/dev/null || true
91}
92trap restaurar_todo EXIT INT TERM
93
94# Repone lo que dejó apartado una corrida ANTERIOR que no llegó a su trap. Sin esto el apartadero
95# es un agujero silencioso: el artefacto existe, no está donde se lo busca, y el grafo lo llama
96# `debt` sin que nadie sepa por qué.
97for d in "$GUARDA"/*; do
98  b=$(basename "$d"); [ -d "$d" ] || continue
99  case "$b" in '*') continue ;; esac
100  if [ -d "$STORE/$b" ]; then rm -rf "$d"; else mv "$d" "$STORE/$b"; echo "  ↩ repuesto de una corrida anterior: $b"; fi
101done
102
103# ── EL LIBRO DE LO YA VERIFICADO ───────────────────────────────────────────────────────────────
104# Sin registro, cada corrida es una muestra aleatoria que se olvida: nadie puede decir qué fracción
105# del corpus se verificó nunca, y las mismas recetas salen sorteadas una y otra vez mientras otras
106# no se miran jamás. La clave es (receta, ArtifactHash) — el hash de HOY. Si la receta o cualquiera
107# de sus deps cambia, el hash cambia, la entrada deja de casar y hay que volver a verificar. Un
108# «ya lo verifiqué» que sobrevive a un re-hash sería una mentira; éste no puede.
109LIBRO="${LIBRO:-docs/state/repro-verificado.tsv}"
110[ -s "$LIBRO" ] || printf '%s\n' \
111  '# repro-verificado.tsv — qué artefactos se comprobaron que REPRODUCEN bit a bit, y cuándo.' \
112  '#' \
113  '# Clave = (receta, ArtifactHash). El hash resume la receta MÁS su cierre de deps, así que una' \
114  '# entrada deja de casar en cuanto algo aguas arriba cambia: no se puede dar por verificado lo' \
115  '# que ya no es lo mismo. Lo escribe scripts/verificar-repro.sh; se lee para medir cobertura y' \
116  '# para no volver a sortear lo ya hecho.' \
117  '#' \
118  '# receta<TAB>hash<TAB>fecha<TAB>veredicto' > "$LIBRO"
119
120ya_verificado() { grep -qF "$(printf '%s\t%s\t' "$1" "$2")" "$LIBRO" 2>/dev/null; }
121anotar() { printf '%s\t%s\t%s\t%s\n' "$1" "$2" "$(date -u +%F)" "$3" >> "$LIBRO"; }
122
123# `--coverage`: qué fracción del corpus PRESENTE en este store se comprobó, al hash de hoy. Es la
124# pregunta que el libro existe para poder contestar — antes no había forma de saberlo.
125if [ "${1:-}" = "--coverage" ]; then
126  tot=0; hechas=0; sin_art=0
127  for f in recipes/*.toml recipes/incoming-*/*.toml; do
128    [ -f "$f" ] || continue
129    nn=$(awk -F'"' '/^name[[:space:]]*=/{print $2; exit}' "$f"); [ -n "$nn" ] || nn=$(basename "$f" .toml)
130    hh=$("$HAMMER" --store "$STORE" hash "$f" 2>/dev/null | tail -1 | sed 's/^b3://')
131    [ -n "$hh" ] || continue
132    [ -d "$STORE/$hh-$nn" ] || { sin_art=$((sin_art+1)); continue; }
133    tot=$((tot+1)); ya_verificado "$nn" "$hh" && hechas=$((hechas+1))
134  done
135  echo "── cobertura de reproducibilidad (contra el hash de HOY)"
136  echo "   verificadas   $hechas de $tot artefactos presentes en $STORE"
137  echo "   sin artefacto $sin_art (selladas en otro lado, o en deuda: acá no hay qué comparar)"
138  exit 0
139fi
140
141if [ $# -gt 0 ]; then RECETAS="$*"
142else
143  # Muestra por CLASE de build: si sólo se verifican paquetes C con meson, el resultado no dice nada
144  # de Rust ni de Go, que son justamente donde el no-determinismo suele vivir (codegen paralelo,
145  # orden de símbolos, timestamps de módulos).
146  # ── `MAX_SECONDS`: sortear sólo entre builds BARATOS ─────────────────────────────────────────
147  # Elegir muestra «por artefacto chico» es una trampa: el artefacto de `nodejs` pesa 0,2 MB y su
148  # build son horas de V8. Lo que hace cara una verificación es el TIEMPO DE CONSTRUIR, y ese dato
149  # ya existe — `scripts/farm/build-timed.sh` deja un sidecar por build en `store/.times/` y llega
150  # con la cosecha. Con `MAX_SECONDS=60` la muestra sale de ahí.
151  #
152  # Las recetas SIN medición quedan fuera cuando se pone el tope: no se puede prometer que algo es
153  # barato sin haberlo medido nunca. El modo de ampliar esa lista no es relajar el filtro sino
154  # correr builds instrumentados en el worker, que es donde el tiempo se mide.
155  #
156  # ⚠ DOS LÍMITES DEL NÚMERO, medidos el 2026-09-05 con `MAX_SECONDS=45` en el hub:
157  #   · El sidecar lo escribe el WORKER. Una receta Rust que allá tarda 40 s con la caché de cargo
158  #     caliente puede tardar muchos minutos acá en frío — `angle-grinder` y `amp` entraron por el
159  #     filtro y se comieron el disco. El tope acota el build DE ESA RECETA en LA MÁQUINA QUE LO
160  #     MIDIÓ, no acá.
161  #   · Y no cuenta la CASCADA: `hammer build` reconstruye las deps que falten en el store local, y
162  #     eso no está en el tiempo del sidecar. Es la misma sorpresa que dio `gjs`, cuyo grafo decía
163  #     «una receta» y se puso a rehacer spidermonkey entero.
164  # ⇒ con disco justo, mejor pasar las recetas a mano que confiar en el tope.
165  if [ -n "${MAX_SECONDS:-}" ]; then
166    TODOS=$(python3 - "$MAX_SECONDS" <<'PY'
167import glob, json, os, sys, re
168from statistics import median
169cap = float(sys.argv[1])
170m = {}
171for f in glob.glob("store/.times/*.json"):
172    try: d = json.load(open(f))
173    except Exception: continue
174    if d.get("name") and isinstance(d.get("seconds"), (int, float)):
175        m.setdefault(d["name"], []).append(d["seconds"])
176baratas = {k for k, v in m.items() if median(v) < cap}
177for ruta in glob.glob("recipes/*.toml") + glob.glob("recipes/incoming-wlr/*.toml"):
178    txt = open(ruta, encoding="utf8", errors="replace").read(4000)
179    mm = re.search(r'^name\s*=\s*"([^"]+)"', txt, re.M)
180    if mm and mm.group(1) in baratas:
181        print(ruta)
182PY
183)
184    [ -n "$TODOS" ] || { echo "── no hay recetas medidas por debajo de ${MAX_SECONDS}s (¿falta store/.times?)"; exit 0; }
185  fi
186
187  # Se sortea entre lo que NO está en el libro, para que corridas sucesivas ACUMULEN cobertura en
188  # vez de repetir las mismas. Con `TODO=1` se sortea entre todas (para re-verificar a propósito).
189  TODOS=$(ls recipes/*.toml recipes/incoming-wlr/*.toml 2>/dev/null)
190  if [ -z "${TODO:-}" ]; then
191    PENDIENTES=""
192    for f in $TODOS; do
193      nn=$(awk -F'"' '/^name[[:space:]]*=/{print $2; exit}' "$f"); [ -n "$nn" ] || nn=$(basename "$f" .toml)
194      hh=$("$HAMMER" --store "$STORE" hash "$f" 2>/dev/null | tail -1 | sed 's/^b3://')
195      [ -n "$hh" ] || continue
196      ya_verificado "$nn" "$hh" || PENDIENTES="$PENDIENTES $f"
197    done
198    [ -n "$PENDIENTES" ] && TODOS="$PENDIENTES"
199  fi
200  RECETAS=$(printf '%s\n' $TODOS | shuf -n "$N" --random-source=/dev/zero | tr '\n' ' ')
201fi
202
203
204ok=0; dif=0; fallo=0; saltada=0; deriva=0; DIVERGEN=""
205for f in $RECETAS; do
206  [ -f "$f" ] || continue
207  n=$(awk -F'"' '/^name[[:space:]]*=/{print $2; exit}' "$f"); [ -n "$n" ] || n=$(basename "$f" .toml)
208  H=$("$HAMMER" --store "$STORE" hash "$f" 2>/dev/null | tail -1 | sed 's/^b3://')
209  [ -n "$H" ] || { saltada=$((saltada+1)); continue; }
210  D="$H-$n"
211  [ -d "$STORE/$D" ] || { saltada=$((saltada+1)); continue; }
212
213  mv "$STORE/$D" "$GUARDA/$D"; PENDIENTE="$PENDIENTE $D"
214  if "$HAMMER" --store "$STORE" build "$f" >/dev/null 2>&1 && [ -d "$STORE/$D" ]; then
215    if "$HAMMER" why-differs "$GUARDA/$D" "$STORE/$D" >/dev/null 2>&1; then
216      printf "  ✓ %-26s REPRODUCE\n" "$n"; ok=$((ok+1))
217      anotar "$n" "$H" "reproduce"
218      rm -rf "$GUARDA/$D"
219    else
220      # ── DERIVA vs NO-DETERMINISMO: SE DECIDE ACÁ, NO EN LA CABEZA DE QUIEN LEE ──────────────
221      # Que el guardado difiera de una reconstrucción de hoy puede ser dos cosas MUY distintas:
222      # DERIVA (el artefacto es viejo y el lab se movió) o NO-DETERMINISMO (mismas entradas, mismo
223      # lab, salidas distintas). La cabecera decía «corré el script dos veces y mirá la segunda»,
224      # y eso deja el veredicto a cargo de que alguien se acuerde — con lo que la primera corrida
225      # informa «DIVERGE» sobre cosas sanas y entrena a no creerle.
226      #
227      # Una segunda reconstrucción lo resuelve sin ambigüedad: si las DOS coinciden entre sí, el
228      # que estaba fuera de fecha era el guardado ⇒ deriva. Si no coinciden, es no-determinismo de
229      # verdad. Sólo se paga el rebuild extra cuando ya hubo una diferencia.
230      mv "$STORE/$D" "$GUARDA/$D.r1"; PENDIENTE="$PENDIENTE $D.r1"
231      # ⚠ «la segunda reconstrucción FALLÓ» NO es «difiere». Meterlas en la misma rama fue un error
232      # mío del 2026-09-05 y lo pagó el libro: se llenó el disco a mitad de una tanda, los rebuilds
233      # empezaron a morir por ENOSPC, y quedaron anotadas 21 recetas sanas como NO-DETERMINISMO —
234      # un registro falso y persistente, que es peor que no tener registro. Es la misma trampa de
235      # siempre: un disco lleno se lee como receta rota, y la pista es que mueren varias seguidas.
236      # El script original ya distinguía «no reproduce» de «no construye acá»; esto lo restituye.
237      if ! "$HAMMER" --store "$STORE" build "$f" >/dev/null 2>&1 || [ ! -d "$STORE/$D" ]; then
238        printf "  ⚠ %-26s la 2ª reconstrucción no construyó ⇒ SIN VEREDICTO (no lo anoto)\n" "$n"
239        fallo=$((fallo+1))
240        rm -rf "$STORE/$D"; mv "$GUARDA/$D" "$STORE/$D"; rm -rf "$GUARDA/$D.r1"
241        PENDIENTE=$(echo "$PENDIENTE" | sed "s| $D.r1||;s| $D||")
242        continue
243      fi
244      if "$HAMMER" why-differs "$GUARDA/$D.r1" "$STORE/$D" >/dev/null 2>&1; then
245        printf "  ~ %-26s DERIVA (el guardado era viejo; dos reconstrucciones coinciden)\n" "$n"
246        deriva=$((deriva+1))
247        # Se anota igual: las dos reconstrucciones coincidieron entre sí, que es justo lo que
248        # significa «reproduce». Lo viejo era el ejemplar guardado, no el determinismo.
249        anotar "$n" "$H" "reproduce (tras poner al día un artefacto derivado)"
250        rm -rf "$GUARDA/$D" "$GUARDA/$D.r1"
251      else
252        printf "  ✗ %-26s NO-DETERMINISMO (dos reconstrucciones difieren entre sí)\n" "$n"
253        dif=$((dif+1)); DIVERGEN="$DIVERGEN $n"
254        anotar "$n" "$H" "NO-DETERMINISMO"
255        "$HAMMER" why-differs "$GUARDA/$D.r1" "$STORE/$D" 2>&1 | tail -4 | sed 's/^/       /'
256        # ⚠ NO se borran los ejemplares. Borrarlos destruía la evidencia justo en el único caso que
257        # este guardián existe para encontrar: decía «no reproduce» y tiraba las copias con las que
258        # se podía averiguar POR QUÉ. Ocupan disco a propósito.
259        mkdir -p "$STORE/.divergen"; rm -rf "$STORE/.divergen/$D" "$STORE/.divergen/$D.r1"
260        mv "$GUARDA/$D" "$STORE/.divergen/$D" 2>/dev/null
261        mv "$GUARDA/$D.r1" "$STORE/.divergen/$D.r1" 2>/dev/null
262        printf "       ejemplares guardados en %s/.divergen/ para poder mirarlos\n" "$STORE"
263      fi
264      PENDIENTE=$(echo "$PENDIENTE" | sed "s| $D.r1||")
265    fi
266  else
267    # El rebuild falló: restaurar y NO contarlo como divergencia (no es lo mismo «no reproduce» que
268    # «no construye acá»). Distinguirlos importa: mezclarlos inventaría un problema de determinismo.
269    printf "  ⚠ %-26s no construyó (artefacto restaurado)\n" "$n"; fallo=$((fallo+1))
270    rm -rf "$STORE/$D"; mv "$GUARDA/$D" "$STORE/$D"
271  fi
272  PENDIENTE=$(echo "$PENDIENTE" | sed "s| $D||")
273done
274
275echo "════════════════════════════════════════════════════════════"
276echo "  REPRODUCEN: $ok · DERIVA: $deriva · NO-DETERMINISMO: $dif · no construyeron: $fallo · sin artefacto: $saltada"
277[ "$deriva" -gt 0 ] && echo "  ~ la deriva NO es un fallo: el artefacto guardado quedó viejo y ya se puso al día"
278[ "$dif" -gt 0 ] && echo "  ⚠ divergen:$DIVERGEN"
279[ "$dif" -eq 0 ] && [ $((ok + deriva)) -gt 0 ] && echo "  ✅ PUERTA SUPERADA: 0 no-determinismos sobre $((ok + deriva)) verificadas"
280exit $(( dif > 0 ? 1 : 0 ))