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/takana}"; 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
120# ── PODAR EL ÁRBOL DE FUENTES TRAS CADA VEREDICTO SANO ─────────────────────────────────────────
121# Un barrido deja un árbol extraído por receta en `work/sources` y no limpia hasta el final: en el
122# hub eso llevó el disco del 95% al 98% dos veces el 2026-09-05, y un disco lleno se lee como receta
123# rota ([[disco-lleno-se-lee-como-receta-rota]]). Guardarlos no vale nada para el barrido, porque
124# `fetch.rs` borra y re-extrae el árbol en CADA build por diseño.
125#
126# Pero sólo se poda cuando el veredicto es SANO. Si algo falló o divergió, el árbol es justamente lo
127# que hace falta para mirarlo: un verificador que limpia la escena del problema que acaba de
128# encontrar sirve para poco.
129#
130# ⚠ Sólo el árbol de ESTA receta. Las deps que se hayan extraído se quedan: son compartidas, y
131# borrarlas mientras otra cosa las usa es el ADR 0012.
132podar_fuentes() {
133  [ -n "${1:-}" ] || return 0
134  rm -rf "$ROOT/work/sources/$1"-* 2>/dev/null || true
135}
136
137ya_verificado() { grep -qF "$(printf '%s\t%s\t' "$1" "$2")" "$LIBRO" 2>/dev/null; }
138anotar() { printf '%s\t%s\t%s\t%s\n' "$1" "$2" "$(date -u +%F)" "$3" >> "$LIBRO"; }
139
140# `--coverage`: qué fracción del corpus PRESENTE en este store se comprobó, al hash de hoy. Es la
141# pregunta que el libro existe para poder contestar — antes no había forma de saberlo.
142if [ "${1:-}" = "--coverage" ]; then
143  tot=0; hechas=0; sin_art=0
144  for f in recipes/*.toml recipes/incoming-*/*.toml; do
145    [ -f "$f" ] || continue
146    nn=$(awk -F'"' '/^name[[:space:]]*=/{print $2; exit}' "$f"); [ -n "$nn" ] || nn=$(basename "$f" .toml)
147    hh=$("$HAMMER" --store "$STORE" hash "$f" 2>/dev/null | tail -1 | sed 's/^b3://')
148    [ -n "$hh" ] || continue
149    [ -d "$STORE/$hh-$nn" ] || { sin_art=$((sin_art+1)); continue; }
150    tot=$((tot+1)); ya_verificado "$nn" "$hh" && hechas=$((hechas+1))
151  done
152  echo "── cobertura de reproducibilidad (contra el hash de HOY)"
153  echo "   verificadas   $hechas de $tot artefactos presentes en $STORE"
154  echo "   sin artefacto $sin_art (selladas en otro lado, o en deuda: acá no hay qué comparar)"
155  exit 0
156fi
157
158if [ $# -gt 0 ]; then RECETAS="$*"
159else
160  # Muestra por CLASE de build: si sólo se verifican paquetes C con meson, el resultado no dice nada
161  # de Rust ni de Go, que son justamente donde el no-determinismo suele vivir (codegen paralelo,
162  # orden de símbolos, timestamps de módulos).
163  # ── `MAX_SECONDS`: sortear sólo entre builds BARATOS ─────────────────────────────────────────
164  # Elegir muestra «por artefacto chico» es una trampa: el artefacto de `nodejs` pesa 0,2 MB y su
165  # build son horas de V8. Lo que hace cara una verificación es el TIEMPO DE CONSTRUIR, y ese dato
166  # ya existe — `scripts/farm/build-timed.sh` deja un sidecar por build en `store/.times/` y llega
167  # con la cosecha. Con `MAX_SECONDS=60` la muestra sale de ahí.
168  #
169  # Las recetas SIN medición quedan fuera cuando se pone el tope: no se puede prometer que algo es
170  # barato sin haberlo medido nunca. El modo de ampliar esa lista no es relajar el filtro sino
171  # correr builds instrumentados en el worker, que es donde el tiempo se mide.
172  #
173  # ⚠ DOS LÍMITES DEL NÚMERO, medidos el 2026-09-05 con `MAX_SECONDS=45` en el hub:
174  #   · El sidecar lo escribe el WORKER. Una receta Rust que allá tarda 40 s con la caché de cargo
175  #     caliente puede tardar muchos minutos acá en frío — `angle-grinder` y `amp` entraron por el
176  #     filtro y se comieron el disco. El tope acota el build DE ESA RECETA en LA MÁQUINA QUE LO
177  #     MIDIÓ, no acá.
178  #   · Y no cuenta la CASCADA: `hammer build` reconstruye las deps que falten en el store local, y
179  #     eso no está en el tiempo del sidecar. Es la misma sorpresa que dio `gjs`, cuyo grafo decía
180  #     «una receta» y se puso a rehacer spidermonkey entero.
181  # ⇒ con disco justo, mejor pasar las recetas a mano que confiar en el tope.
182  if [ -n "${MAX_SECONDS:-}" ]; then
183    TODOS=$(python3 - "$MAX_SECONDS" <<'PY'
184import glob, json, os, sys, re
185from statistics import median
186cap = float(sys.argv[1])
187m = {}
188for f in glob.glob("store/.times/*.json"):
189    try: d = json.load(open(f))
190    except Exception: continue
191    if d.get("name") and isinstance(d.get("seconds"), (int, float)):
192        m.setdefault(d["name"], []).append(d["seconds"])
193baratas = {k for k, v in m.items() if median(v) < cap}
194for ruta in glob.glob("recipes/*.toml") + glob.glob("recipes/incoming-wlr/*.toml"):
195    txt = open(ruta, encoding="utf8", errors="replace").read(4000)
196    mm = re.search(r'^name\s*=\s*"([^"]+)"', txt, re.M)
197    if mm and mm.group(1) in baratas:
198        print(ruta)
199PY
200)
201    [ -n "$TODOS" ] || { echo "── no hay recetas medidas por debajo de ${MAX_SECONDS}s (¿falta store/.times?)"; exit 0; }
202  fi
203
204  # Se sortea entre lo que NO está en el libro, para que corridas sucesivas ACUMULEN cobertura en
205  # vez de repetir las mismas. Con `TODO=1` se sortea entre todas (para re-verificar a propósito).
206  TODOS=$(ls recipes/*.toml recipes/incoming-wlr/*.toml 2>/dev/null)
207  if [ -z "${TODO:-}" ]; then
208    PENDIENTES=""
209    for f in $TODOS; do
210      nn=$(awk -F'"' '/^name[[:space:]]*=/{print $2; exit}' "$f"); [ -n "$nn" ] || nn=$(basename "$f" .toml)
211      hh=$("$HAMMER" --store "$STORE" hash "$f" 2>/dev/null | tail -1 | sed 's/^b3://')
212      [ -n "$hh" ] || continue
213      ya_verificado "$nn" "$hh" || PENDIENTES="$PENDIENTES $f"
214    done
215    [ -n "$PENDIENTES" ] && TODOS="$PENDIENTES"
216  fi
217  RECETAS=$(printf '%s\n' $TODOS | shuf -n "$N" --random-source=/dev/zero | tr '\n' ' ')
218fi
219
220
221ok=0; dif=0; fallo=0; saltada=0; deriva=0; DIVERGEN=""
222for f in $RECETAS; do
223  [ -f "$f" ] || continue
224  n=$(awk -F'"' '/^name[[:space:]]*=/{print $2; exit}' "$f"); [ -n "$n" ] || n=$(basename "$f" .toml)
225  H=$("$HAMMER" --store "$STORE" hash "$f" 2>/dev/null | tail -1 | sed 's/^b3://')
226  [ -n "$H" ] || { saltada=$((saltada+1)); continue; }
227  D="$H-$n"
228  [ -d "$STORE/$D" ] || { saltada=$((saltada+1)); continue; }
229
230  # ⚠ Si el apartado FALLA, todo lo que sigue es basura: el `why-differs` de después compara contra
231  # algo que no existe, devuelve error, y un error leído como «difieren» inventa un no-determinismo.
232  # Pasó el 2026-09-05 con 47 recetas sanas de una sola tanda. Falla ruidoso y se salta la receta.
233  mkdir -p "$GUARDA"
234  if ! mv "$STORE/$D" "$GUARDA/$D" 2>/dev/null; then
235    printf "  ⚠ %-26s no pude apartar el artefacto ⇒ SIN VEREDICTO\n" "$n"
236    fallo=$((fallo+1)); continue
237  fi
238  PENDIENTE="$PENDIENTE $D"
239  if "$HAMMER" --store "$STORE" build "$f" >/dev/null 2>&1 && [ -d "$STORE/$D" ]; then
240    # `why-differs` devuelve no-cero tanto si DIFIEREN como si NO PUDO comparar (una ruta que no
241    # existe, por ejemplo). Tratar las dos igual es inventar un veredicto: se mira su salida.
242    cmp_out=$("$HAMMER" why-differs "$GUARDA/$D" "$STORE/$D" 2>&1); cmp_rc=$?
243    if [ "$cmp_rc" -ne 0 ] && printf '%s' "$cmp_out" | grep -qiE '^Error:|no existe'; then
244      printf "  ⚠ %-26s no pude comparar (%s) ⇒ SIN VEREDICTO\n" "$n" \
245        "$(printf '%s' "$cmp_out" | head -1 | cut -c1-60)"
246      fallo=$((fallo+1))
247      rm -rf "$STORE/$D"; mv "$GUARDA/$D" "$STORE/$D"
248      PENDIENTE=$(echo "$PENDIENTE" | sed "s| $D||")
249      continue
250    fi
251    if [ "$cmp_rc" -eq 0 ]; then
252      printf "  ✓ %-26s REPRODUCE\n" "$n"; ok=$((ok+1))
253      anotar "$n" "$H" "reproduce"
254      rm -rf "$GUARDA/$D"; podar_fuentes "$n"
255    else
256      # ── DERIVA vs NO-DETERMINISMO: SE DECIDE ACÁ, NO EN LA CABEZA DE QUIEN LEE ──────────────
257      # Que el guardado difiera de una reconstrucción de hoy puede ser dos cosas MUY distintas:
258      # DERIVA (el artefacto es viejo y el lab se movió) o NO-DETERMINISMO (mismas entradas, mismo
259      # lab, salidas distintas). La cabecera decía «corré el script dos veces y mirá la segunda»,
260      # y eso deja el veredicto a cargo de que alguien se acuerde — con lo que la primera corrida
261      # informa «DIVERGE» sobre cosas sanas y entrena a no creerle.
262      #
263      # Una segunda reconstrucción lo resuelve sin ambigüedad: si las DOS coinciden entre sí, el
264      # que estaba fuera de fecha era el guardado ⇒ deriva. Si no coinciden, es no-determinismo de
265      # verdad. Sólo se paga el rebuild extra cuando ya hubo una diferencia.
266      mv "$STORE/$D" "$GUARDA/$D.r1"; PENDIENTE="$PENDIENTE $D.r1"
267      # ⚠ «la segunda reconstrucción FALLÓ» NO es «difiere». Meterlas en la misma rama fue un error
268      # mío del 2026-09-05 y lo pagó el libro: se llenó el disco a mitad de una tanda, los rebuilds
269      # empezaron a morir por ENOSPC, y quedaron anotadas 21 recetas sanas como NO-DETERMINISMO —
270      # un registro falso y persistente, que es peor que no tener registro. Es la misma trampa de
271      # siempre: un disco lleno se lee como receta rota, y la pista es que mueren varias seguidas.
272      # El script original ya distinguía «no reproduce» de «no construye acá»; esto lo restituye.
273      if ! "$HAMMER" --store "$STORE" build "$f" >/dev/null 2>&1 || [ ! -d "$STORE/$D" ]; then
274        printf "  ⚠ %-26s la 2ª reconstrucción no construyó ⇒ SIN VEREDICTO (no lo anoto)\n" "$n"
275        fallo=$((fallo+1))
276        rm -rf "$STORE/$D"; mv "$GUARDA/$D" "$STORE/$D"; rm -rf "$GUARDA/$D.r1"
277        PENDIENTE=$(echo "$PENDIENTE" | sed "s| $D.r1||;s| $D||")
278        continue
279      fi
280      if "$HAMMER" why-differs "$GUARDA/$D.r1" "$STORE/$D" >/dev/null 2>&1; then
281        printf "  ~ %-26s DERIVA (el guardado era viejo; dos reconstrucciones coinciden)\n" "$n"
282        deriva=$((deriva+1))
283        # Se anota igual: las dos reconstrucciones coincidieron entre sí, que es justo lo que
284        # significa «reproduce». Lo viejo era el ejemplar guardado, no el determinismo.
285        anotar "$n" "$H" "reproduce (tras poner al día un artefacto derivado)"
286        podar_fuentes "$n"
287        rm -rf "$GUARDA/$D" "$GUARDA/$D.r1"
288      else
289        printf "  ✗ %-26s NO-DETERMINISMO (dos reconstrucciones difieren entre sí)\n" "$n"
290        dif=$((dif+1)); DIVERGEN="$DIVERGEN $n"
291        anotar "$n" "$H" "NO-DETERMINISMO"
292        "$HAMMER" why-differs "$GUARDA/$D.r1" "$STORE/$D" 2>&1 | tail -4 | sed 's/^/       /'
293        # ⚠ NO se borran los ejemplares. Borrarlos destruía la evidencia justo en el único caso que
294        # este guardián existe para encontrar: decía «no reproduce» y tiraba las copias con las que
295        # se podía averiguar POR QUÉ. Ocupan disco a propósito.
296        mkdir -p "$STORE/.divergen"; rm -rf "$STORE/.divergen/$D" "$STORE/.divergen/$D.r1"
297        mv "$GUARDA/$D" "$STORE/.divergen/$D" 2>/dev/null
298        mv "$GUARDA/$D.r1" "$STORE/.divergen/$D.r1" 2>/dev/null
299        printf "       ejemplares guardados en %s/.divergen/ para poder mirarlos\n" "$STORE"
300      fi
301      PENDIENTE=$(echo "$PENDIENTE" | sed "s| $D.r1||")
302    fi
303  else
304    # El rebuild falló: restaurar y NO contarlo como divergencia (no es lo mismo «no reproduce» que
305    # «no construye acá»). Distinguirlos importa: mezclarlos inventaría un problema de determinismo.
306    printf "  ⚠ %-26s no construyó (artefacto restaurado)\n" "$n"; fallo=$((fallo+1))
307    rm -rf "$STORE/$D"; mv "$GUARDA/$D" "$STORE/$D"
308  fi
309  PENDIENTE=$(echo "$PENDIENTE" | sed "s| $D||")
310done
311
312echo "════════════════════════════════════════════════════════════"
313echo "  REPRODUCEN: $ok · DERIVA: $deriva · NO-DETERMINISMO: $dif · no construyeron: $fallo · sin artefacto: $saltada"
314[ "$deriva" -gt 0 ] && echo "  ~ la deriva NO es un fallo: el artefacto guardado quedó viejo y ya se puso al día"
315[ "$dif" -gt 0 ] && echo "  ⚠ divergen:$DIVERGEN"
316[ "$dif" -eq 0 ] && [ $((ok + deriva)) -gt 0 ] && echo "  ✅ PUERTA SUPERADA: 0 no-determinismos sobre $((ok + deriva)) verificadas"
317exit $(( dif > 0 ? 1 : 0 ))