licencias: campo license en la receta — de 0 a 228 de 1141, sin re-hashear nada

La deuda legal bloqueante del SDD 19 §2.1. Medido hoy: **0 de 1141 recetas** declaraban
licencia, no «5 de 771» como decía el informe anterior. Los dos números estaban mal: los
«5» eran falsos positivos de `grep license` (el paquete `addlicense`, el paquete
`cargo-bundle-licenses`, una línea `install .../share/licenses/` y un comentario), y las
recetas son 1141. Contar con `grep -l <palabra>` sobre TOML cuenta comentarios y nombres,
no campos; `scripts/licencias.sh` cuenta el campo de verdad (clave en la raíz, antes del
primer `[table]`).

LO QUE HACE LA DEUDA PAGABLE: `Recipe::hash_inputs` es una LISTA BLANCA — sólo entran
source, compiler, target, link, patches, flags, phases y deps. `license` no entra, igual
que `evidence` y `slots`. Por eso se puede poblar en las recetas YA SELLADAS sin mover un
solo ArtifactHash. Verificado, no supuesto: en 40 recetas modificadas se comparó el hash
con y sin la línea — 40 idénticos, 0 cambiados. Si el campo entrara al hash, declarar la
licencia costaría reconstruir el corpus entero y no se haría nunca. Clavado con el test
`licencia_round_trip_y_no_afecta_el_hash`.

TRAMPA DE TOML: una clave suelta después de un `[table]` pertenece a esa tabla. Puesta al
final del fichero, `license` acaba dentro de `[deps]` y se pierde EN SILENCIO, porque serde
ignora los campos que no conoce — no hay error, simplemente no está. Va arriba, junto a
`name` y `version`; el sembrador la inserta tras `version`.

NO SE ADIVINA. Declarar mal una licencia es peor que dejarla vacía: convierte un hueco
visible en una afirmación falsa. Sólo se puebla desde una tabla curada entrada por entrada
(`docs/licencias-conocidas.tsv`); lo que no tiene evidencia queda vacío y se CUENTA.
Concretamente se descartó el atajo «k* = KDE ⇒ LGPL»: en este catálogo `kail`, `kind`,
`ko`, `kopia`, `krew`, `kustomize`, `kyverno`, `katana`, `kibi`, `kmon` y toda la familia
`kube*` son herramientas Go sin relación con KDE. El nombre no es evidencia.

Quedan 913, casi todas CLIs Go/Rust importados en masa — y ésas sí son automatizables con
evidencia real: Cargo.toml trae el campo `license` y los módulos Go traen su LICENSE en el
árbol. El cierre estructural es capturarlo en la fase de fetch, que ya descarga y extrae
cada tarball, y inyectar el texto en `hammer pack` (aguas abajo del ArtifactHash) en vez de
en la fase install (que sí re-hashearía).

De paso, respaldo-storagebox.sh reordenado por valor irreemplazable y con zstd: medido en
la oficina, el uplink da 8 Mbps iguales por cable y por wifi ⇒ 128 G no caben en una
sentada, así que sube primero el cerebro (estado + repo) y `--partial-dir` hace que cortar
a mitad de un artefacto no tire lo ya subido.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

crates/hammer-core/src/recipe.rs

@@ -26,6 +26,24 @@ pub struct Recipe {
     /// (`crate::compat`) contra el estado instalado, no el build.
     #[serde(default, skip_serializing_if = "Slots::is_empty")]
     pub slots: Slots,
+    /// **Bajo qué términos se redistribuye este paquete.** Expresión SPDX (`"GPL-2.0-or-later"`,
+    /// `"MIT OR Apache-2.0"`, `"LGPL-2.1-only AND BSD-3-Clause"`).
+    ///
+    /// No es burocracia: al distribuir BINARIOS, la GPL y familia obligan a acompañarlos del texto
+    /// de la licencia y a poder entregar la fuente correspondiente. Una distro que no sabe bajo qué
+    /// términos redistribuye lo que empaqueta no puede cumplir ninguna de las dos cosas, y eso es
+    /// bloqueante para publicar (SDD 19 §2.1). Medido el 2026-08-07: **0 de 1141 recetas** lo
+    /// declaraban.
+    ///
+    /// Igual que `evidence` y `slots`, **NO entra en `hash_inputs`** — y acá esa propiedad es la que
+    /// hace la deuda pagable: describe términos legales, no identidad del build, así que se puede
+    /// poblar en las 1141 recetas YA SELLADAS sin mover un solo `ArtifactHash` ni invalidar el
+    /// baseline de reproducibilidad. Si entrara al hash, poner la licencia costaría reconstruir el
+    /// corpus entero y por eso no se habría hecho nunca.
+    ///
+    /// `None` = deuda declarada, no «sin licencia». `scripts/licencias.sh` mide la cobertura.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub license: Option<String>,
     /// Directorio base contra el que se resuelven rutas relativas de la receta
     /// (típicamente, `patches`). Lo fija `load_from_path`; al deserializar puro queda vacío.
     #[serde(skip, default)]
@@ -800,6 +818,42 @@ expected_output = "b3:deadbeef"
         );
     }
 
+    #[test]
+    fn licencia_round_trip_y_no_afecta_el_hash() {
+        // ESTE TEST ES LA RAZÓN DE QUE LA DEUDA DE LICENCIAS SEA PAGABLE.
+        //
+        // El 2026-08-07 ninguna de las 1141 recetas declaraba licencia, y sin ese dato la distro no
+        // puede cumplir la GPL al redistribuir binarios (SDD 19 §2.1). Poblarlo sólo es viable si
+        // NO mueve el `ArtifactHash`: si lo moviera, poner la licencia significaría reconstruir el
+        // corpus entero y perder el baseline de reproducibilidad, y nadie lo haría nunca.
+        //
+        // `hash_inputs` es una lista blanca, así que la propiedad se cumple por construcción — pero
+        // se clava acá para que nadie la rompa por descuido metiendo el campo en el hash.
+        // La línea va DELANTE: en TOML una clave suelta después de un `[table]` pertenece a esa
+        // tabla, no a la raíz. Puesta al final, `license` acabaría dentro de `[deps]` y se perdería
+        // en silencio (serde ignora campos desconocidos). Es el mismo cuidado que hay que tener al
+        // poblar las recetas: el campo va arriba, junto a `name` y `version`.
+        let con_toml = format!("license = \"GPL-3.0-or-later\"\n{SAMPLE}");
+        let con = Recipe::from_toml(&con_toml).unwrap();
+        assert_eq!(con.license.as_deref(), Some("GPL-3.0-or-later"));
+
+        // Round-trip por TOML: serializa y vuelve a parsear ⇒ misma licencia.
+        let re = Recipe::from_toml(&con.to_toml().unwrap()).unwrap();
+        assert_eq!(re.license, con.license);
+
+        // Una receta sin el campo parsea igual (las 1141 existentes no se tocan para compilar).
+        let sin = Recipe::from_toml(SAMPLE).unwrap();
+        assert_eq!(sin.license, None);
+
+        // Y el hash es el MISMO con y sin licencia.
+        assert_eq!(
+            sin.hash_inputs(&[]).unwrap(),
+            con.hash_inputs(&[]).unwrap(),
+            "la licencia NO debe entrar en hash_inputs: si entrara, declararla re-hashearía las \
+             1141 recetas ya selladas y tiraría el baseline de reproducibilidad"
+        );
+    }
+
     #[test]
     fn slots_validate_rechaza_hash_sin_prefijo() {
         let mut s = Slots::default();