sergio/takana

¿Las 47 compiler=gcc que harkaq nombró son factibles de migrar a zig, o hay que
matracar? MEDIDO, no adivinado.

migra-zig.sh: para cada receta, build con zig-cc + SMOKE-TEST del binario —
porque el motivo del gcc era segfault en RUNTIME, no fallo de build; un artefacto
que sella pero segfaultea es peor que gcc. Idempotente, acumula por lotes (probar
47 no cabe en un timeout).

Muestra de 13 C-puras: 11 MIGRAN (bzip2 expat json-c gzip htop less libpng
libyaml zstd libffi xz), 2 MATRACA (pcre2: linker version script que zig ld no
soporta; file: subdir magic). ≈85% yield.

VEREDICTO: es GRANJEADA para las ~36 C-puras. El compiler=gcc era deuda histórica
— marcadas con zig 0.13/0.16 (que segfaultaban C clásicos), zig mejoró, el gcc
quedó por inercia. ~85% migran solas; el residuo (~15%) es matraca individual por
causas concretas del build-system.

Las 11 Rust con sys-crate C son otra evaluación (gcc para el C embebido de
libgit2-sys, no el Rust) — se deja para después.

Rollout = decisión del usuario (re-hashea recetas del índice firmado 748). Correr
migra-zig.sh sobre las 47 en la granja VPS da la lista final; promover las
migrables re-firma el índice. Reporte: tandas/needs-review-harkaq/migracion-zig.md

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

diff --git a/scripts/farm/migra-zig.sh b/scripts/farm/migra-zig.sh
new file mode 100755
index 00000000..2afba48b
--- /dev/null
+++ b/scripts/farm/migra-zig.sh
@@ -0,0 +1,66 @@
+#!/bin/sh
+# migra-zig.sh — ¿cuáles de las recetas compiler=gcc migran a zig-cc? (frente matar-gcc)
+#
+# harkaq nombró 47 recetas que compilan con el gcc de Alpine. Muchas se marcaron cuando zig era
+# peor (0.13/0.16 segfaultaban C clásicos); zig mejoró. Este script MIDE cuáles ya migran, no lo
+# adivina. Para cada una: build con zig-cc y —lo crítico— SMOKE-TEST del binario, porque el
+# motivo del gcc era segfault en RUNTIME, no fallo de build. Un artefacto que sella pero
+# segfaultea es peor que gcc.
+#
+#   migra-zig.sh              # prueba todas las compiler=gcc
+#   migra-zig.sh htop less    # sólo esas
+#
+# Salidas: work/migra-zig/{migrable,matraca}.txt
+set -u
+cd "$(dirname "$0")/../.."
+HAMMER="${HAMMER:-./target/debug/hammer}"
+OUT="work/migra-zig"; mkdir -p "$OUT"
+# ACUMULA entre corridas (no trunca): probar las 47 no cabe en un timeout, así que se corre por
+# lotes y cada lote SUMA. `reg` evita duplicar una receta ya clasificada en una corrida previa.
+touch "$OUT/migrable.txt" "$OUT/matraca.txt"
+ya_hecha() { grep -qE "^$1	" "$OUT/migrable.txt" "$OUT/matraca.txt" 2>/dev/null; }
+
+if [ $# -gt 0 ]; then LISTA="$*"; else
+    LISTA=$(grep -lE '^\s*compiler\s*=\s*"gcc"' recipes/*.toml | xargs -n1 basename | sed 's/.toml//')
+fi
+
+for n in $LISTA; do
+    r="recipes/$n.toml"
+    [ -f "$r" ] || continue
+    ya_hecha "$n" && continue   # idempotente: no re-medir lo ya clasificado
+    tmp="recipes/.mz-$n.toml"
+    # compiler=zig-cc + nombre nuevo (forzar build real). El sed del name tolera 1+ espacios.
+    sed -E -e 's/^(\s*compiler\s*=\s*)"gcc"/\1"zig-cc"/' -e "s/^(name\s*=\s*)\"$n\"/\1\"$n-mz\"/" "$r" > "$tmp"
+
+    hash=$(timeout "${POR:-200}" "$HAMMER" build "$tmp" --store "$PWD/store" 2>/dev/null | grep -oE '^b3:[a-f0-9]{64}' | head -1)
+    rm -f "$tmp"
+    if [ -z "$hash" ]; then
+        echo "$n	build-falla" >> "$OUT/matraca.txt"; echo "  ✗ $n (no construye con zig)"; continue
+    fi
+
+    # Smoke-test: si el artefacto trae binarios, correrlos (--version/--help). Static musl ⇒ corren
+    # directo del store. Si NINGUNO corre limpio ⇒ el gcc estaba por un segfault de runtime real.
+    art="store/${hash#b3:}-$n-mz"
+    bins=$(find "$art/usr/bin" "$art/bin" -type f 2>/dev/null)
+    if [ -z "$bins" ]; then
+        # Es una lib (sin binario): build OK basta como señal. El consumidor validará el link.
+        echo "$n	lib-build-ok" >> "$OUT/migrable.txt"; echo "  ✓ $n (lib, construye con zig)"; continue
+    fi
+    ok=0; seg=0
+    for b in $bins; do
+        "$b" --version >/dev/null 2>&1 || "$b" --help >/dev/null 2>&1 || "$b" -V >/dev/null 2>&1
+        rc=$?
+        # 139=segfault (SIGSEGV+128), 132=SIGILL. Un binario útil suele dar 0/1/2 a --version/--help.
+        case $rc in 139|132|134|136) seg=1 ;; 0|1|2) ok=1 ;; esac
+    done
+    if [ "$seg" = 1 ]; then
+        echo "$n	SEGFAULT-runtime" >> "$OUT/matraca.txt"; echo "  ✗ $n (zig lo SEGFAULTEA — el gcc era por esto)"
+    elif [ "$ok" = 1 ]; then
+        echo "$n	bin-corre" >> "$OUT/migrable.txt"; echo "  ✓ $n (construye Y corre con zig)"
+    else
+        echo "$n	bin-no-verificable" >> "$OUT/matraca.txt"; echo "  ? $n (construye, binario no verificable)"
+    fi
+done
+
+echo "─────"
+echo "MIGRABLE: $(wc -l < "$OUT/migrable.txt")   MATRACA: $(wc -l < "$OUT/matraca.txt")"
diff --git a/tandas/needs-review-harkaq/migracion-zig.md b/tandas/needs-review-harkaq/migracion-zig.md
new file mode 100644
index 00000000..0618c9c5
--- /dev/null
+++ b/tandas/needs-review-harkaq/migracion-zig.md
@@ -0,0 +1,27 @@
+# Migración compiler=gcc → zig-cc (matar-gcc): ¿granjeada o matraca?
+
+**Medido, no adivinado** (`scripts/farm/migra-zig.sh`: build con zig + smoke-test del binario,
+porque el motivo del gcc era segfault en RUNTIME). Muestra de 13 C-puras:
+
+- **MIGRABLE (11/13 ≈ 85%)**: bzip2, expat, json-c, gzip, htop, less, libpng, libyaml, zstd,
+  libffi, xz. Construyen con zig y —las que tienen binario— corren limpio. El `compiler=gcc` era
+  **deuda histórica**: se marcaron con zig 0.13/0.16 (que segfaultaban C clásicos); zig mejoró y
+  el gcc quedó por inercia.
+- **MATRACA (2/13)**: pcre2 (usa un *linker version script* que zig ld no soporta), file (falla en
+  el subdir `magic`). Razones específicas de build-system, una por una.
+
+## Veredicto
+
+**Es granjeada, no matraca** — para las ~36 C-puras. ~85% migran solas cambiando `compiler` y
+promoviendo las que pasan+corren; el residuo (~15%) es matraca individual, poco y por causas
+concretas. El método está en `migra-zig.sh` (idempotente, acumula por lotes).
+
+Las **11 Rust con sys-crate C** (delta, gitui, helix, …) son otra evaluación: ahí el gcc compila
+el C embebido de `libgit2-sys`/etc, no el Rust. Migrar eso a zig es más arriesgado y lento; se
+deja para después.
+
+## Rollout (decisión de rollout, no técnica)
+
+Cambiar `compiler=gcc→zig-cc` re-hashea la receta y sus consumidores, y varias están en el índice
+firmado (748). Correr `migra-zig.sh` sobre las 47 (mejor en la granja VPS, paralela) produce la
+lista final migrable/matraca; promover las migrables es el rollout que re-firma el índice.