harkaq: el clasificador distingue gcc-compilador de gcc-sonda — matar-gcc son 47 recetas

El límite del modelo que mtdev destapó, cerrado. harkaq clasificaba /usr/bin/gcc
como "sonda esperada" SIEMPRE, así que marcaba `Hermetico` a las recetas que
compilan CON el gcc de Alpine (compiler=gcc = CC=gcc, musl+GNU ld). Estuvo ciego
a la deuda de compilador todo el barrido.

Fix en harkaq-suggest: 5º arg = la receta medida. Si usa compiler=gcc, los
frontends de gcc (gcc/cpp/c89/c99/g++/cc/ld/as) dejan de ser "esperada" y pasan a
DEUDA DE COMPILADOR (matar-gcc). Para compiler=zig-cc (default, 714 recetas) gcc
sigue siendo sonda de configure — esperada, como antes. Verificado: mtdev(gcc) →
deuda de compilador; zlib(zig) → sin deuda.

EL HALLAZGO: matar-gcc no es "{kernel, cmake}" como creía la memoria del proyecto.
Son 47 recetas (36 C puro + 11 Rust con sys-crate C) que dependen del gcc de
Alpine. harkaq lo reveló sólo cuando aprendió a leer el compiler= de la receta —
antes gcc-como-sonda-esperada ocultaba una deuda mayor que toda la que sí detectó.
Reporte: tandas/needs-review-harkaq/deuda-compilador-matar-gcc.md.

Cada una usa gcc porque zig-cc la miscompila (documentado en su receta). Acción
por receta: migrar a zig cuando zig mejore, o aceptar el escape como deuda
conocida. Ahora es una deuda NOMBRADA y contada, no invisible.

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

scripts/harkaq/harkaq-suggest.py

@@ -67,6 +67,26 @@ def catalogo(recipes_dir):
     return {f[:-5] for f in os.listdir(recipes_dir) if f.endswith(".toml")}
 
 
+# Los frontends del gcc de Alpine. Son "sonda esperada" (D3) SÓLO cuando la receta compila con
+# zig (el default): el configure los sondea y zig no los usa. Pero para una receta `compiler=gcc`
+# (`CC=gcc`, el gcc de Alpine), gcc ES el compilador y su uso es DEUDA DE COMPILADOR — el frente
+# matar-gcc. Sin esta distinción, harkaq marcaba `Hermetico` recetas que dependen del gcc de
+# Alpine (47 de ellas), ciego a la deuda mayor. SDD 16, límite del modelo (2026-07-16).
+FRONTENDS_GCC = {"/usr/bin/gcc", "/usr/bin/cpp", "/usr/bin/c89", "/usr/bin/c99", "/usr/bin/g++",
+                 "/usr/bin/cc", "/usr/bin/ld", "/usr/bin/as"}
+
+
+def compiler_de(recipe_toml):
+    """`gcc` si la receta usa el gcc de Alpine como compilador, si no `zig`."""
+    try:
+        s = open(recipe_toml).read()
+    except OSError:
+        return "zig"
+    import re
+    m = re.search(r'compiler\s*=\s*"([^"]+)"', s)
+    return "gcc" if m and m.group(1) == "gcc" else "zig"
+
+
 def main():
     if len(sys.argv) < 4:
         print(__doc__.split("\n")[2].strip(), file=sys.stderr)
@@ -75,6 +95,10 @@ def main():
     politica, store = sys.argv[2], sys.argv[3]
     recipes_dir = sys.argv[4] if len(sys.argv) > 4 else os.path.join(
         os.path.dirname(os.path.abspath(store)), "recipes")
+    # 5º arg opcional: la receta que se midió. Si usa compiler=gcc, los frontends de gcc dejan de
+    # ser "esperada" y pasan a DEUDA DE COMPILADOR (matar-gcc).
+    receta_toml = sys.argv[5] if len(sys.argv) > 5 else None
+    usa_gcc = receta_toml and compiler_de(receta_toml) == "gcc"
 
     esperadas = set()
     with open(politica) as f:
@@ -82,6 +106,9 @@ def main():
             l = l.strip()
             if l.startswith("# expect "):
                 esperadas.add(l[len("# expect "):].strip())
+    # Si la receta compila con gcc, los frontends NO se perdonan: son la deuda de compilador.
+    if usa_gcc:
+        esperadas -= FRONTENDS_GCC
 
     deuda = sorted({d["path"] for d in crudo.get("denials", []) if d["path"] not in esperadas})
     if not deuda:
@@ -90,8 +117,11 @@ def main():
 
     idx = indice_del_store(store)
     recetas = catalogo(recipes_dir)
-    declarable, irreducible = {}, []
+    declarable, irreducible, compilador = {}, [], []
     for p in deuda:
+        if usa_gcc and p in FRONTENDS_GCC:
+            compilador.append(p)
+            continue
         provs = idx.get(p)
         if provs:
             # El store es autoritativo: sabe qué ficheros aporta cada artefacto.
@@ -114,6 +144,10 @@ def main():
         else:
             irreducible.append(p)
 
+    if compilador:
+        print("DEUDA DE COMPILADOR (matar-gcc) — la receta usa el gcc de Alpine (compiler=gcc):")
+        for p in compilador:
+            print(f"    {p}   → migrar a zig-cc, o aceptar como escape declarativo documentado")
     if declarable:
         print("DEUDA DECLARABLE — el store ya lo provee; falta la línea en [deps]:")
         for p, quien in declarable.items():

tandas/needs-review-harkaq/deuda-compilador-matar-gcc.md

@@ -0,0 +1,60 @@
+# Deuda de compilador (matar-gcc) — las recetas que compilan con el gcc de Alpine
+
+harkaq clasificaba `/usr/bin/gcc` como sonda esperada SIEMPRE, así que marcaba estas recetas
+`Hermetico` — ciego a que dependen del gcc de Alpine (`compiler=gcc` = CC=gcc de Alpine, musl+GNU
+ld). El arreglo (harkaq-suggest, 2026-07-16): para `compiler=gcc` los frontends de gcc son DEUDA
+DE COMPILADOR, no sonda. Esto redimensiona matar-gcc de "{kernel, cmake}" a **47 recetas**.
+
+Cada una compila con gcc porque zig-cc la miscompila/no la soporta (documentado en su receta).
+**Acción por receta:** migrar a zig-cc cuando zig mejore, o aceptar el escape como deuda conocida.
+
+## C puro (36) — candidatas a zig cuando zig mejore
+  - bzip2
+  - expat
+  - curl
+  - file
+  - freetype
+  - gzip
+  - htop
+  - json-c
+  - jq
+  - less
+  - libevent
+  - libgcrypt
+  - libgpg-error
+  - libssh2
+  - libffi
+  - libassuan
+  - libxml2
+  - libevdev
+  - linux-pam
+  - libpng
+  - libsodium
+  - libyaml
+  - libuv
+  - mtdev
+  - nano
+  - pigz
+  - pcre2
+  - procps-ng
+  - socat
+  - tig
+  - tmux
+  - vim
+  - wget
+  - xplr
+  - xz
+  - zstd
+
+## Rust con sys-crate C (11) — gcc para el C embebido (libgit2-sys, etc)
+  - broot
+  - cargo-audit
+  - cargo-cache
+  - delta
+  - gitui
+  - git-absorb
+  - helix
+  - hurl
+  - ouch
+  - yazi
+  - zellij