SDD 30 §4b: la seed de producto ya sale de la RECETA — y openssh reproduce bit a bit

El emisor lee la receta que viaja DENTRO del artefacto sellado (el sidecar
.hammer/recipe.toml) y no de recipes/, porque seal_product_rootfs sirve a las
DOS vetas —product desde recetas locales y product_from_repo desde el repo
firmado— y sólo una tiene recipes/ a mano. El sidecar es la única fuente que
ambas comparten, que es lo que sostiene que converjan al mismo product-rootfs.

LA TRAMPA QUEDA ARMADA, NO CERRADA: el sidecar no entra al ArtifactHash, así que
un artefacto anterior al bloque [[service]] es un cache-hit válido que no se
reconstruye solo. Si el emisor devolviera lista vacía sin protestar, el producto
saldría booteando, verde y SIN SSHD. Falla ruidosamente, y hay un test que exige
que el mensaje siga explicando la causa Y dando el arreglo (regla 3 del
CLAUDE.md: un ausente falla ruidosamente, un vacío llega hasta el final diciendo
que todo fue bien).

LA MIGRACIÓN, CON CONTROL, y el hecho nuevo que dejó: openssh no estaba
certificado como reproducible ("el criterio es construye y corre", dice su
receta). Manifiesto de 33 sha256+modos ANTES de tocar nada, respaldo por
hardlink, borrado, rebuild bajo flock -o, comparación. Resultado: 33/33
ficheros, modos idénticos, y la ÚNICA diferencia en todo el árbol es
.hammer/recipe.toml. openssh REPRODUCE BIT A BIT.

Gotcha que costó el primer intento: store/ es bind-mount de /dev/sdb y work/
vive en /dev/sdc ⇒ `cp -al` cruza mounts y muere con EXDEV. El respaldo va
DENTRO del mount del store; un dot-dir ahí es invisible para store-gc.sh, que
sólo mira dirs ^[0-9a-f]{64}-.

crates/takana-bootstrap/src/lib.rs

@@ -540,19 +540,75 @@ pub fn verify_attestation(rootfs_dir: &Path) -> Result<AttestReport> {
     Ok(report)
 }
 
+/// Las Cards de servicio que aportan los componentes de servicio, **leídas de la receta que viaja
+/// DENTRO de cada artefacto sellado** (el sidecar de provenance `.hammer/recipe.toml`).
+///
+/// Por qué del sidecar y no del directorio de recetas: [`seal_product_rootfs`] sirve a las DOS
+/// vetas —`product` desde recetas locales y `product_from_repo` desde el repo firmado— y sólo una
+/// tiene `recipes/` a mano. El sidecar es la única fuente que ambas comparten, y así las dos
+/// convergen al mismo `product-rootfs`, que es la propiedad que esa función existe para sostener.
+///
+/// Sólo entran las de `scope = "system"`: una Card de sesión en el `genesis` arrancaría antes de que
+/// exista `XDG_RUNTIME_DIR` o un usuario logueado (ver `takana_core::service::Scope`).
+///
+/// ⚠ **Falla RUIDOSAMENTE si no sale ninguna**, y la razón es una trampa concreta: el sidecar **no
+/// entra en el `ArtifactHash`**, así que un artefacto sellado antes de que la receta declarara sus
+/// servicios sigue siendo un cache-hit válido y **no se reconstruye solo**. Si esto devolviera una
+/// lista vacía sin protestar, el producto saldría sin sshd —booteando, verde y sin acceso— que es
+/// exactamente la clase de fallo que este proyecto ya pagó con los artefactos vacíos.
+fn service_cards(
+    store: &Store,
+    services: &[(String, ArtifactHash)],
+) -> Result<Vec<serde_json::Value>> {
+    let mut cards = Vec::new();
+    let mut sin_sidecar = Vec::new();
+    for (nombre, hash) in services {
+        let recipe = match store.recipe_for_hash(hash.as_str()) {
+            Ok(Some(r)) => r,
+            Ok(None) => {
+                sin_sidecar.push(nombre.clone());
+                continue;
+            }
+            Err(e) => return Err(Error::Other(format!("sidecar de `{nombre}` ilegible: {e}"))),
+        };
+        for s in &recipe.services {
+            if s.scope == takana_core::service::Scope::System {
+                cards.push(s.card());
+            }
+        }
+    }
+    if cards.is_empty() {
+        return Err(Error::Other(format!(
+            "ningún componente de servicio ({}) declara un servicio de sistema.\n\
+             Casi seguro los artefactos son ANTERIORES al bloque `[[service]]`: el sidecar no entra \
+             en el ArtifactHash, así que siguen siendo cache-hit válidos y no se reconstruyen solos.\n\
+             Arreglo: borrar el artefacto del store y reconstruirlo (`flock -o work/.farm-build.lock \
+             takana build recipes/<receta>.toml`), comparando el árbol nuevo con el viejo.{}",
+            services.iter().map(|(n, _)| n.as_str()).collect::<Vec<_>>().join(", "),
+            if sin_sidecar.is_empty() {
+                String::new()
+            } else {
+                format!("\nSin sidecar siquiera: {}", sin_sidecar.join(", "))
+            }
+        )));
+    }
+    Ok(cards)
+}
+
 /// Seed de producto = la seed base con los cards de servicio APENDADOS al `genesis`. Composición vía
 /// `serde_json` (takana sigue autocontenido: no depende de `card-core`). Determinista ⇒ el
 /// `product-rootfs` es reproducible. El núcleo (hammerd + getty) se preserva tal cual.
-fn product_seed_card() -> Result<String> {
+fn product_seed_card(cards: &[serde_json::Value]) -> Result<String> {
     let mut seed: serde_json::Value = serde_json::from_str(STAGE1_SEED_CARD)
         .map_err(|e| Error::Other(format!("seed base inválida: {e}")))?;
     seed["label"] = serde_json::Value::String("hammer-product".into());
-    let card: serde_json::Value = serde_json::from_str(SSHD_SERVICE_CARD)
-        .map_err(|e| Error::Other(format!("card sshd inválida: {e}")))?;
-    seed.get_mut("genesis")
+    let genesis = seed
+        .get_mut("genesis")
         .and_then(|g| g.as_array_mut())
-        .ok_or_else(|| Error::Other("seed base sin array `genesis`".into()))?
-        .push(card);
+        .ok_or_else(|| Error::Other("seed base sin array `genesis`".into()))?;
+    for c in cards {
+        genesis.push(c.clone());
+    }
     serde_json::to_string_pretty(&seed).map_err(|e| Error::Other(format!("serializar seed: {e}")))
 }
 
@@ -745,7 +801,7 @@ fn seal_product_rootfs(
     services: &[(String, ArtifactHash)],
     store: &Store,
 ) -> Result<RootfsHash> {
-    let seed = product_seed_card()?;
+    let seed = product_seed_card(&service_cards(store, services)?)?;
     let phash = product_rootfs_hash(base, userland, services, &seed);
     let store_name = "product-rootfs";
 
@@ -2070,7 +2126,7 @@ mod tests {
     fn product_seed_appends_sshd_to_base_genesis() {
         // La seed de producto = base + sshd; el núcleo (hammerd, getty) se preserva intacto y el
         // resultado es JSON válido (lo que arje-zero validará al boot).
-        let seed = product_seed_card().unwrap();
+        let seed = product_seed_card(&[card_sshd_esperada()]).unwrap();
         let v: serde_json::Value = serde_json::from_str(&seed).unwrap();
         assert_eq!(v["label"], "hammer-product");
         assert_eq!(v["payload"], "Virtual");
@@ -2083,6 +2139,35 @@ mod tests {
         assert!(sshd["supervision"]["Restart"]["initial"].is_number(), "sshd es Restart (lifecycle)");
     }
 
+    /// **El sidecar rancio NO puede pasar en silencio.**
+    ///
+    /// Es la trampa que este mecanismo tiene incorporada y que hay que dejar armada: el sidecar de
+    /// provenance **no entra en el `ArtifactHash`**, así que un artefacto sellado antes de que su
+    /// receta declarara servicios sigue siendo un cache-hit perfectamente válido y no se reconstruye
+    /// nunca solo. Si `service_cards` devolviera una lista vacía sin protestar, el producto saldría
+    /// **booteando, verde y sin sshd**. Un ausente falla ruidosamente; un vacío llega hasta el final
+    /// diciendo que todo fue bien — regla 3 del CLAUDE.md, aplicada acá antes de pagarla.
+    #[test]
+    fn service_cards_falla_ruidosamente_con_sidecar_rancio() {
+        let tmp = tempfile::tempdir().unwrap();
+        let store = Store::open(tmp.path().join("store")).unwrap();
+        // Un store sin ese artefacto ⇒ sin sidecar ⇒ sin servicios: exactamente lo que se ve cuando
+        // el artefacto es anterior al bloque `[[service]]`.
+        let servicios = [("openssh".to_string(), ArtifactHash::from_hex("ab"))];
+        let e = service_cards(&store, &servicios).unwrap_err().to_string();
+        assert!(e.contains("ningún componente de servicio"), "{e}");
+        assert!(e.contains("ArtifactHash"), "el error tiene que EXPLICAR la trampa: {e}");
+        assert!(e.contains("borrar el artefacto del store"), "y decir el arreglo: {e}");
+    }
+
+    /// La Card de `sshd` de referencia: la constante que el producto **ya bootea en QEMU**. Los
+    /// tests componen la seed con ella (no con la derivada del sidecar) a propósito: así el
+    /// esqueleto de la seed se prueba sin necesitar un store, y la equivalencia
+    /// «receta ⇒ esta misma card» la prueba `la_receta_de_openssh_reproduce_la_card_hardcodeada`.
+    fn card_sshd_esperada() -> serde_json::Value {
+        serde_json::from_str(SSHD_SERVICE_CARD).unwrap()
+    }
+
     /// **La receta produce la MISMA Card que la constante hardcodeada.**
     ///
     /// Esta es la prueba que autoriza a mover el servicio de un literal de Rust a `[[service]]` en
@@ -2113,7 +2198,7 @@ mod tests {
         let base = ArtifactHash::from_hex("ab");
         let userland = [("uutils".to_string(), ArtifactHash::from_hex("11"))];
         let svcs = [("openssh".to_string(), ArtifactHash::from_hex("cd"))];
-        let seed = product_seed_card().unwrap();
+        let seed = product_seed_card(&[card_sshd_esperada()]).unwrap();
         let a = product_rootfs_hash(&base, &userland, &svcs, &seed);
         assert_eq!(a, product_rootfs_hash(&base, &userland, &svcs, &seed), "determinista");
         let other_base = ArtifactHash::from_hex("ef");
@@ -2165,7 +2250,7 @@ mod tests {
             std::fs::write(w.join("usr/bin/netup"), b"\x7fELFfake").unwrap();
         });
 
-        let seed = product_seed_card().unwrap();
+        let seed = product_seed_card(&[card_sshd_esperada()]).unwrap();
         let userland = [("uutils".to_string(), huu)];
         let services = [("openssh".to_string(), hossh), ("netup".to_string(), hnet)];
         let staging = store.root().join("prod-staging");
@@ -2266,7 +2351,7 @@ mod tests {
             std::fs::write(w.join("usr/bin/arje-zero"), b"\x7fELF-arje-zero-CORE").unwrap();
             std::fs::write(w.join("usr/bin/hammerd"), b"\x7fELF-hammerd").unwrap();
             std::fs::write(w.join("bin/busybox"), b"\x7fELF-busybox").unwrap();
-            std::fs::write(w.join("ente/seed.card.json"), product_seed_card().unwrap()).unwrap();
+            std::fs::write(w.join("ente/seed.card.json"), product_seed_card(&[card_sshd_esperada()]).unwrap()).unwrap();
             // attest.json del producto base (con el arje-zero del NÚCLEO) — debe regenerarse.
             let a = build_attestation(w).unwrap();
             std::fs::write(w.join("ente/attest.json"), serde_json::to_string(&a).unwrap()).unwrap();
@@ -2363,7 +2448,7 @@ open(os.path.join(os.path.dirname(out),"..","..","bins-seen.txt"),"w").write("\n
         // (lo que el gate busca en las concesiones firmadas) y las rutas resolver dentro del staging.
         let staging = Path::new("/tmp/fake-staging");
         let seed: serde_json::Value =
-            serde_json::from_str(&product_seed_card().unwrap()).unwrap();
+            serde_json::from_str(&product_seed_card(&[card_sshd_esperada()]).unwrap()).unwrap();
         let bins = critical_bins_from_seed(&seed, staging);
         let labels: Vec<&str> = bins.iter().map(|(l, _)| l.as_str()).collect();
         assert_eq!(