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# `takana why-differs` compara los dos árboles y nombra la causa si divergen.
31#
32# ── ADEMÁS DE MEDIR REPRODUCIBILIDAD, ESTE SCRIPT ES EL CENSO DE LA DEUDA INVISIBLE ────────────
33# «no construyó» no es ruido del verificador: es EL hallazgo. Un artefacto sellado dice que ALGUIEN
34# lo construyó alguna vez con ALGÚN lab, no que se construya HOY — y el lab rueda (Alpine edge). La
35# única forma de convertir «N recetas podrían estar rotas» en un número es reconstruirlas, y este
36# script es lo único que lo hace SIN RIESGO, porque aparta en vez de borrar y restaura si el build
37# falla (ver la red de seguridad, abajo).
38#
39# Medido el 2026-09-12 barriendo las 15 recetas CMake baratas del corpus:
40#
41#     REPRODUCEN: 9 · DERIVA: 1 · NO-DETERMINISMO: 0 · no construyeron: 5
42#
43# Cinco selladas y rotas a la vez (`brotli`, `json-c`, `libjpeg-turbo`, `libjpeg-turbo-shared`,
44# `libtiff-shared`), todas por el mismo crash del `lld` de zig con el `--dependency-file` que CMake
45# ≥3.27 emite. Ninguna métrica del repo podía verlo: el grafo las contaba `sealed`.
46#
47# ⇒ **Barrer por FAMILIA de sistema de build es lo que hace el censo legible**: si el fallo es del
48# toolchain, se concentra en una familia y el patrón salta a la vista. Barrer al azar lo diluye.
49#
50# ── LA RED DE SEGURIDAD ────────────────────────────────────────────────────────────────────────
51# Si el rebuild FALLA (y fallará en alguna: hay recetas que sólo construyen en ciertas máquinas), el
52# artefacto original se RESTAURA. Un verificador que destruye lo que verifica es peor que no tenerlo.
53# Por eso se APARTA en vez de borrar, y hay `trap` para reponer lo pendiente si se interrumpe.
54#
55# ⚠ El apartadero vive DENTRO del store (`store/.verificar-repro`), no en `/tmp`. Estaba en `/tmp` y
56# eso rompía la promesa de arriba en tres sitios a la vez: `/tmp` es tmpfs, así que apartar copiaba
57# el artefacto a RAM en una caja de 7,6 GiB sin swap; al ser otro sistema de ficheros el `mv` no era
58# un rename atómico sino copiar-y-borrar, así que una interrupción a mitad lo dejaba en ninguna
59# parte; y lo que sobreviviera se perdía al reiniciar. Costó un artefacto el 2026-09-05. Dentro del
60# store el `mv` es instantáneo y lo apartado SOBREVIVE a un kill: la corrida siguiente lo repone sola
61# antes de empezar. Y cuando hay NO-DETERMINISMO de verdad, los dos ejemplares se conservan en
62# `store/.divergen/` — antes se borraban, o sea que el guardián tiraba la única evidencia justo en el
63# caso que existe para encontrar.
64#
65# Uso:   scripts/verificar-repro.sh [receta.toml ...]      (sin args: muestra por clase)
66# Env:   STORE (def ./store)   N (def 30, tamaño de la muestra)
67set -uo pipefail
68ROOT="$(cd "$(dirname "$0")/.." && pwd)"; cd "$ROOT"
69STORE="${STORE:-./store}"; HAMMER="${TAKANA:-${HAMMER:-./target/release/takana}}"; N="${N:-30}"
70
71# ⚠ EL MIRROR SE ACTIVA ACÁ, Y NO ES COMODIDAD: sin él, toda receta cuya fuente viva SÓLO en nuestro
72# mirror —las que llevan una URL `.invalid` a propósito (ADR 0013): `firefox-pgo-profile`, los dos
73# modelos de IA— no se puede reconstruir, y este guardián lo informa como «no construyó». Medido el
74# 2026-09-12: `ia-modelo-embeddings` dio REPRODUCE y `ia-modelo-chat` «no construyó», y la única
75# diferencia entre las dos era que el tar de la primera **seguía en el caché local**. O sea que el
76# veredicto dependía de la suerte del caché, que es exactamente lo que un gate no puede permitirse.
77# Es aditivo (ADR 0013): si el fichero no está, todo sigue como antes.
78if [ -f scripts/fuentes/mirror-env.sh ]; then
79  # shellcheck disable=SC1091
80  . scripts/fuentes/mirror-env.sh >/dev/null 2>&1 || true
81fi
82
83# ── EL LOCK LO TOMA EL SCRIPT, Y ANTES DE TOCAR NADA ───────────────────────────────────────────
84# Este script llama a `takana build`, y la regla 1 del repo es que todo build va envuelto en el
85# `flock` de la granja: dos builds que compartan una dep se pisan el árbol de `work/sources` y lo
86# rompen PARA SIEMPRE (ADR 0012). Lo toma el script y no quien lo llama, por lo mismo que en
87# `poda-fuentes.sh`: así no hay forma de correrlo mal — y correrlo mal fue exactamente lo que pasó.
88#
89# `-E 3` importa: sin él, «no conseguí el lock» sale como exit 1, que es lo que este script usa para
90# «hay divergencias». Un guardián que informa «el corpus no reproduce» cuando lo que pasó es que
91# había otro build corriendo es peor que uno que no corre.
92if [ -z "${VERIFICAR_REPRO_CON_LOCK:-}" ]; then
93  export VERIFICAR_REPRO_CON_LOCK=1
94  flock -w 120 -E 3 "$ROOT/work/.farm-build.lock" "$0" "$@"
95  rc=$?
96  [ "$rc" -eq 3 ] && echo "── verificar-repro: build en vuelo (lock no tomado en 120s) ⇒ no toco nada"
97  exit "$rc"
98fi
99
100# ── ⚠ EL APARTADERO VA DENTRO DEL STORE, NO EN /tmp ────────────────────────────────────────────
101# Para verificar hay que sacar el artefacto de su sitio y dejar que takana lo reconstruya. Ese
102# `mv` era a un `mktemp -d`, o sea a `/tmp`, y ahí se juntan tres cosas que costaron un artefacto
103# el 2026-09-05:
104#
105#   1. `/tmp` es **tmpfs** en gioser: mover un artefacto ahí lo copia a RAM, en una máquina de
106#      7,6 GiB y swap 0, compitiendo con el build que se está verificando.
107#   2. Al ser otro sistema de ficheros, `mv` NO es un rename atómico sino copiar-y-borrar. Si el
108#      proceso muere a mitad, el artefacto no está ni en un sitio ni en el otro.
109#   3. Y lo que quede ahí se pierde al reiniciar.
110#
111# Dentro del store el `mv` es un rename instantáneo, no cuesta RAM ni disco, y **sobrevive a un
112# kill**: lo que quedó apartado sigue en disco y la próxima corrida lo repone sola. El apartadero
113# empieza por punto, como `.dmerge`, y los consumidores del store filtran por `^[0-9a-f]{64}-`.
114GUARDA="$STORE/.verificar-repro"; mkdir -p "$GUARDA"; PENDIENTE=""
115
116restaurar_todo() {
117  for h in $PENDIENTE; do
118    [ -d "$GUARDA/$h" ] && [ ! -d "$STORE/$h" ] && mv "$GUARDA/$h" "$STORE/$h" && echo "  ↩ restaurado $h"
119  done
120  rmdir "$GUARDA" 2>/dev/null || true
121}
122trap restaurar_todo EXIT INT TERM
123
124# Repone lo que dejó apartado una corrida ANTERIOR que no llegó a su trap. Sin esto el apartadero
125# es un agujero silencioso: el artefacto existe, no está donde se lo busca, y el grafo lo llama
126# `debt` sin que nadie sepa por qué.
127for d in "$GUARDA"/*; do
128  b=$(basename "$d"); [ -d "$d" ] || continue
129  case "$b" in '*') continue ;; esac
130  if [ -d "$STORE/$b" ]; then rm -rf "$d"; else mv "$d" "$STORE/$b"; echo "  ↩ repuesto de una corrida anterior: $b"; fi
131done
132
133# ── EL LIBRO DE LO YA VERIFICADO ───────────────────────────────────────────────────────────────
134# Sin registro, cada corrida es una muestra aleatoria que se olvida: nadie puede decir qué fracción
135# del corpus se verificó nunca, y las mismas recetas salen sorteadas una y otra vez mientras otras
136# no se miran jamás. La clave es (receta, ArtifactHash) — el hash de HOY. Si la receta o cualquiera
137# de sus deps cambia, el hash cambia, la entrada deja de casar y hay que volver a verificar. Un
138# «ya lo verifiqué» que sobrevive a un re-hash sería una mentira; éste no puede.
139LIBRO="${LIBRO:-docs/state/repro-verificado.tsv}"
140[ -s "$LIBRO" ] || printf '%s\n' \
141  '# repro-verificado.tsv — qué artefactos se comprobaron que REPRODUCEN bit a bit, y cuándo.' \
142  '#' \
143  '# Clave = (receta, ArtifactHash). El hash resume la receta MÁS su cierre de deps, así que una' \
144  '# entrada deja de casar en cuanto algo aguas arriba cambia: no se puede dar por verificado lo' \
145  '# que ya no es lo mismo. Lo escribe scripts/verificar-repro.sh; se lee para medir cobertura y' \
146  '# para no volver a sortear lo ya hecho.' \
147  '#' \
148  '# receta<TAB>hash<TAB>fecha<TAB>veredicto' > "$LIBRO"
149
150# ── PODAR EL ÁRBOL DE FUENTES TRAS CADA VEREDICTO SANO ─────────────────────────────────────────
151# Un barrido deja un árbol extraído por receta en `work/sources` y no limpia hasta el final: en el
152# hub eso llevó el disco del 95% al 98% dos veces el 2026-09-05, y un disco lleno se lee como receta
153# rota ([[disco-lleno-se-lee-como-receta-rota]]). Guardarlos no vale nada para el barrido, porque
154# `fetch.rs` borra y re-extrae el árbol en CADA build por diseño.
155#
156# Pero sólo se poda cuando el veredicto es SANO. Si algo falló o divergió, el árbol es justamente lo
157# que hace falta para mirarlo: un verificador que limpia la escena del problema que acaba de
158# encontrar sirve para poco.
159#
160# ⚠ Sólo el árbol de ESTA receta. Las deps que se hayan extraído se quedan: son compartidas, y
161# borrarlas mientras otra cosa las usa es el ADR 0012.
162podar_fuentes() {
163  [ -n "${1:-}" ] || return 0
164  rm -rf "$ROOT/work/sources/$1"-* 2>/dev/null || true
165}
166
167ya_verificado() { grep -qF "$(printf '%s\t%s\t' "$1" "$2")" "$LIBRO" 2>/dev/null; }
168anotar() { printf '%s\t%s\t%s\t%s\n' "$1" "$2" "$(date -u +%F)" "$3" >> "$LIBRO"; }
169
170# `--coverage`: qué fracción del corpus PRESENTE en este store se comprobó, al hash de hoy. Es la
171# pregunta que el libro existe para poder contestar — antes no había forma de saberlo.
172if [ "${1:-}" = "--coverage" ]; then
173  tot=0; hechas=0; sin_art=0
174  for f in recipes/*.toml recipes/incoming-*/*.toml; do
175    [ -f "$f" ] || continue
176    nn=$(awk -F'"' '/^name[[:space:]]*=/{print $2; exit}' "$f"); [ -n "$nn" ] || nn=$(basename "$f" .toml)
177    hh=$("$HAMMER" --store "$STORE" hash "$f" 2>/dev/null | tail -1 | sed 's/^b3://')
178    [ -n "$hh" ] || continue
179    [ -d "$STORE/$hh-$nn" ] || { sin_art=$((sin_art+1)); continue; }
180    tot=$((tot+1)); ya_verificado "$nn" "$hh" && hechas=$((hechas+1))
181  done
182  echo "── cobertura de reproducibilidad (contra el hash de HOY)"
183  echo "   verificadas   $hechas de $tot artefactos presentes en $STORE"
184  echo "   sin artefacto $sin_art (selladas en otro lado, o en deuda: acá no hay qué comparar)"
185  exit 0
186fi
187
188if [ $# -gt 0 ]; then RECETAS="$*"
189else
190  # Muestra por CLASE de build: si sólo se verifican paquetes C con meson, el resultado no dice nada
191  # de Rust ni de Go, que son justamente donde el no-determinismo suele vivir (codegen paralelo,
192  # orden de símbolos, timestamps de módulos).
193  # ── `MAX_SECONDS`: sortear sólo entre builds BARATOS ─────────────────────────────────────────
194  # Elegir muestra «por artefacto chico» es una trampa: el artefacto de `nodejs` pesa 0,2 MB y su
195  # build son horas de V8. Lo que hace cara una verificación es el TIEMPO DE CONSTRUIR, y ese dato
196  # ya existe — `scripts/farm/build-timed.sh` deja un sidecar por build en `store/.times/` y llega
197  # con la cosecha. Con `MAX_SECONDS=60` la muestra sale de ahí.
198  #
199  # Las recetas SIN medición quedan fuera cuando se pone el tope: no se puede prometer que algo es
200  # barato sin haberlo medido nunca. El modo de ampliar esa lista no es relajar el filtro sino
201  # correr builds instrumentados en el worker, que es donde el tiempo se mide.
202  #
203  # ⚠ DOS LÍMITES DEL NÚMERO, medidos el 2026-09-05 con `MAX_SECONDS=45` en el hub:
204  #   · El sidecar lo escribe el WORKER. Una receta Rust que allá tarda 40 s con la caché de cargo
205  #     caliente puede tardar muchos minutos acá en frío — `angle-grinder` y `amp` entraron por el
206  #     filtro y se comieron el disco. El tope acota el build DE ESA RECETA en LA MÁQUINA QUE LO
207  #     MIDIÓ, no acá.
208  #   · Y no cuenta la CASCADA: `takana build` reconstruye las deps que falten en el store local, y
209  #     eso no está en el tiempo del sidecar. Es la misma sorpresa que dio `gjs`, cuyo grafo decía
210  #     «una receta» y se puso a rehacer spidermonkey entero.
211  # ⇒ con disco justo, mejor pasar las recetas a mano que confiar en el tope.
212  if [ -n "${MAX_SECONDS:-}" ]; then
213    TODOS=$(python3 - "$MAX_SECONDS" <<'PY'
214import glob, json, os, sys, re
215from statistics import median
216cap = float(sys.argv[1])
217m = {}
218for f in glob.glob("store/.times/*.json"):
219    try: d = json.load(open(f))
220    except Exception: continue
221    if d.get("name") and isinstance(d.get("seconds"), (int, float)):
222        m.setdefault(d["name"], []).append(d["seconds"])
223baratas = {k for k, v in m.items() if median(v) < cap}
224for ruta in glob.glob("recipes/*.toml") + glob.glob("recipes/incoming-wlr/*.toml"):
225    txt = open(ruta, encoding="utf8", errors="replace").read(4000)
226    mm = re.search(r'^name\s*=\s*"([^"]+)"', txt, re.M)
227    if mm and mm.group(1) in baratas:
228        print(ruta)
229PY
230)
231    [ -n "$TODOS" ] || { echo "── no hay recetas medidas por debajo de ${MAX_SECONDS}s (¿falta store/.times?)"; exit 0; }
232  fi
233
234  # Se sortea entre lo que NO está en el libro, para que corridas sucesivas ACUMULEN cobertura en
235  # vez de repetir las mismas. Con `TODO=1` se sortea entre todas (para re-verificar a propósito).
236  TODOS=$(ls recipes/*.toml recipes/incoming-wlr/*.toml 2>/dev/null)
237  if [ -z "${TODO:-}" ]; then
238    PENDIENTES=""
239    for f in $TODOS; do
240      nn=$(awk -F'"' '/^name[[:space:]]*=/{print $2; exit}' "$f"); [ -n "$nn" ] || nn=$(basename "$f" .toml)
241      hh=$("$HAMMER" --store "$STORE" hash "$f" 2>/dev/null | tail -1 | sed 's/^b3://')
242      [ -n "$hh" ] || continue
243      ya_verificado "$nn" "$hh" || PENDIENTES="$PENDIENTES $f"
244    done
245    [ -n "$PENDIENTES" ] && TODOS="$PENDIENTES"
246  fi
247  RECETAS=$(printf '%s\n' $TODOS | shuf -n "$N" --random-source=/dev/zero | tr '\n' ' ')
248fi
249
250
251ok=0; dif=0; fallo=0; saltada=0; deriva=0; DIVERGEN=""
252for f in $RECETAS; do
253  [ -f "$f" ] || continue
254  n=$(awk -F'"' '/^name[[:space:]]*=/{print $2; exit}' "$f"); [ -n "$n" ] || n=$(basename "$f" .toml)
255  H=$("$HAMMER" --store "$STORE" hash "$f" 2>/dev/null | tail -1 | sed 's/^b3://')
256  [ -n "$H" ] || { saltada=$((saltada+1)); continue; }
257  D="$H-$n"
258  [ -d "$STORE/$D" ] || { saltada=$((saltada+1)); continue; }
259
260  # ⚠ Si el apartado FALLA, todo lo que sigue es basura: el `why-differs` de después compara contra
261  # algo que no existe, devuelve error, y un error leído como «difieren» inventa un no-determinismo.
262  # Pasó el 2026-09-05 con 47 recetas sanas de una sola tanda. Falla ruidoso y se salta la receta.
263  mkdir -p "$GUARDA"
264  if ! mv "$STORE/$D" "$GUARDA/$D" 2>/dev/null; then
265    printf "  ⚠ %-26s no pude apartar el artefacto ⇒ SIN VEREDICTO\n" "$n"
266    fallo=$((fallo+1)); continue
267  fi
268  PENDIENTE="$PENDIENTE $D"
269  if "$HAMMER" --store "$STORE" build "$f" >/dev/null 2>&1 && [ -d "$STORE/$D" ]; then
270    # `why-differs` devuelve no-cero tanto si DIFIEREN como si NO PUDO comparar (una ruta que no
271    # existe, por ejemplo). Tratar las dos igual es inventar un veredicto: se mira su salida.
272    cmp_out=$("$HAMMER" why-differs "$GUARDA/$D" "$STORE/$D" 2>&1); cmp_rc=$?
273    if [ "$cmp_rc" -ne 0 ] && printf '%s' "$cmp_out" | grep -qiE '^Error:|no existe'; then
274      printf "  ⚠ %-26s no pude comparar (%s) ⇒ SIN VEREDICTO\n" "$n" \
275        "$(printf '%s' "$cmp_out" | head -1 | cut -c1-60)"
276      fallo=$((fallo+1))
277      rm -rf "$STORE/$D"; mv "$GUARDA/$D" "$STORE/$D"
278      PENDIENTE=$(echo "$PENDIENTE" | sed "s| $D||")
279      continue
280    fi
281    if [ "$cmp_rc" -eq 0 ]; then
282      printf "  ✓ %-26s REPRODUCE\n" "$n"; ok=$((ok+1))
283      anotar "$n" "$H" "reproduce"
284      rm -rf "$GUARDA/$D"; podar_fuentes "$n"
285    else
286      # ── DERIVA vs NO-DETERMINISMO: SE DECIDE ACÁ, NO EN LA CABEZA DE QUIEN LEE ──────────────
287      # Que el guardado difiera de una reconstrucción de hoy puede ser dos cosas MUY distintas:
288      # DERIVA (el artefacto es viejo y el lab se movió) o NO-DETERMINISMO (mismas entradas, mismo
289      # lab, salidas distintas). La cabecera decía «corré el script dos veces y mirá la segunda»,
290      # y eso deja el veredicto a cargo de que alguien se acuerde — con lo que la primera corrida
291      # informa «DIVERGE» sobre cosas sanas y entrena a no creerle.
292      #
293      # Una segunda reconstrucción lo resuelve sin ambigüedad: si las DOS coinciden entre sí, el
294      # que estaba fuera de fecha era el guardado ⇒ deriva. Si no coinciden, es no-determinismo de
295      # verdad. Sólo se paga el rebuild extra cuando ya hubo una diferencia.
296      mv "$STORE/$D" "$GUARDA/$D.r1"; PENDIENTE="$PENDIENTE $D.r1"
297      # ⚠ «la segunda reconstrucción FALLÓ» NO es «difiere». Meterlas en la misma rama fue un error
298      # mío del 2026-09-05 y lo pagó el libro: se llenó el disco a mitad de una tanda, los rebuilds
299      # empezaron a morir por ENOSPC, y quedaron anotadas 21 recetas sanas como NO-DETERMINISMO —
300      # un registro falso y persistente, que es peor que no tener registro. Es la misma trampa de
301      # siempre: un disco lleno se lee como receta rota, y la pista es que mueren varias seguidas.
302      # El script original ya distinguía «no reproduce» de «no construye acá»; esto lo restituye.
303      if ! "$HAMMER" --store "$STORE" build "$f" >/dev/null 2>&1 || [ ! -d "$STORE/$D" ]; then
304        printf "  ⚠ %-26s la 2ª reconstrucción no construyó ⇒ SIN VEREDICTO (no lo anoto)\n" "$n"
305        fallo=$((fallo+1))
306        rm -rf "$STORE/$D"; mv "$GUARDA/$D" "$STORE/$D"; rm -rf "$GUARDA/$D.r1"
307        PENDIENTE=$(echo "$PENDIENTE" | sed "s| $D.r1||;s| $D||")
308        continue
309      fi
310      if "$HAMMER" why-differs "$GUARDA/$D.r1" "$STORE/$D" >/dev/null 2>&1; then
311        printf "  ~ %-26s DERIVA (el guardado era viejo; dos reconstrucciones coinciden)\n" "$n"
312        deriva=$((deriva+1))
313        # Se anota igual: las dos reconstrucciones coincidieron entre sí, que es justo lo que
314        # significa «reproduce». Lo viejo era el ejemplar guardado, no el determinismo.
315        anotar "$n" "$H" "reproduce (tras poner al día un artefacto derivado)"
316        podar_fuentes "$n"
317        rm -rf "$GUARDA/$D" "$GUARDA/$D.r1"
318      else
319        printf "  ✗ %-26s NO-DETERMINISMO (dos reconstrucciones difieren entre sí)\n" "$n"
320        dif=$((dif+1)); DIVERGEN="$DIVERGEN $n"
321        anotar "$n" "$H" "NO-DETERMINISMO"
322        "$HAMMER" why-differs "$GUARDA/$D.r1" "$STORE/$D" 2>&1 | tail -4 | sed 's/^/       /'
323        # ⚠ NO se borran los ejemplares. Borrarlos destruía la evidencia justo en el único caso que
324        # este guardián existe para encontrar: decía «no reproduce» y tiraba las copias con las que
325        # se podía averiguar POR QUÉ. Ocupan disco a propósito.
326        mkdir -p "$STORE/.divergen"; rm -rf "$STORE/.divergen/$D" "$STORE/.divergen/$D.r1"
327        mv "$GUARDA/$D" "$STORE/.divergen/$D" 2>/dev/null
328        mv "$GUARDA/$D.r1" "$STORE/.divergen/$D.r1" 2>/dev/null
329        printf "       ejemplares guardados en %s/.divergen/ para poder mirarlos\n" "$STORE"
330      fi
331      PENDIENTE=$(echo "$PENDIENTE" | sed "s| $D.r1||")
332    fi
333  else
334    # El rebuild falló: restaurar y NO contarlo como divergencia (no es lo mismo «no reproduce» que
335    # «no construye acá»). Distinguirlos importa: mezclarlos inventaría un problema de determinismo.
336    printf "  ⚠ %-26s no construyó (artefacto restaurado)\n" "$n"; fallo=$((fallo+1))
337    rm -rf "$STORE/$D"; mv "$GUARDA/$D" "$STORE/$D"
338  fi
339  PENDIENTE=$(echo "$PENDIENTE" | sed "s| $D||")
340done
341
342echo "════════════════════════════════════════════════════════════"
343echo "  REPRODUCEN: $ok · DERIVA: $deriva · NO-DETERMINISMO: $dif · no construyeron: $fallo · sin artefacto: $saltada"
344[ "$deriva" -gt 0 ] && echo "  ~ la deriva NO es un fallo: el artefacto guardado quedó viejo y ya se puso al día"
345[ "$dif" -gt 0 ] && echo "  ⚠ divergen:$DIVERGEN"
346[ "$dif" -eq 0 ] && [ $((ok + deriva)) -gt 0 ] && echo "  ✅ PUERTA SUPERADA: 0 no-determinismos sobre $((ok + deriva)) verificadas"
347exit $(( dif > 0 ? 1 : 0 ))