SDD 30 4c: GNOME con los demonios supervisados por arje — y el control arregló colord

Los demonios de sistema pasan de lanzarse con `&` desde un script de 500 líneas
a ser Cards del `genesis`. El bloqueo que este frente daba por corpus se levantó
solo: otro agente selló evolution-data-server y gnome-shell mientras esto se
escribía, y escritorio-gnome quedó 309/309.

SE CORRIÓ UN CONTROL PRIMERO, y es lo único que hace interpretable el resultado:

  colord              control: `MURIÓ al arrancar`   cards: `ya vive (pid 175)`
  ColorManager        control: `NO apareció en 40s`  cards: `OK`
  login1/Accounts/UPower  OK en los dos
  compositor          wayland-0 y shell vivo en los dos

El fallo del control DESAPARECIÓ, y no lo buscaba: colord moría arrancado por el
script y vive arrancado por arje, con el bus ya listo porque la espera está
dentro de su argv. Sin el control, «ColorManager OK» sería un dato suelto en vez
de una diferencia. Los PIDs lo confirman: polkit=119, colord=175, upowerd=178,
accounts=180 — de antes de que el lanzador de sesión existiera.

QUÉ NO SE COMPROBÓ: no hay screendump; QEMU salió por timeout y el control
tampoco lo tuvo. La comparación es serial contra serial y lo que se afirma es
sobre los DEMONIOS, no sobre el pintado.

Las piezas donde corresponde: `takana service-cards` (UNA sola implementación de
receta→Card; el formato es contrato con card_core::Card), `targets.py
--service-paths` (une qué-es con si-arranca), y un inyector en FICHERO APARTE
porque anidar dos heredocs de python falló en vivo — el terminador del interno
cerró el externo y media cosa corrió como shell.

La espera del bus va DENTRO del argv de las 5 recetas de sistema: sin ella un
daemon arranca antes de que dbus escuche y queda en modo idle sin registrar su
nombre — un fallo que no se ve, porque el proceso vive y el bus no lo tiene. Los
5 hashes intactos. Y el guardia de gnome-start es por «¿está corriendo?», no por
una perilla: así es correcto venga de donde venga el proceso y la misma copia
sirve donde no se inyectaron cards.

crates/takana-cli/src/main.rs

@@ -49,6 +49,24 @@ enum Cmd {
         /// Ruta a la receta TOML.
         recipe: String,
     },
+    /// [SDD 30] Emite las **Cards de arje** de los servicios que declaran estas recetas
+    /// (`[[service]]`), como array JSON, para que el ensamblado de una imagen las meta en el
+    /// `genesis` de la seed.
+    ///
+    /// Existe para que la traducción `[[service]]` → Card tenga **una sola implementación**. Los
+    /// scripts de imagen ya parchean la seed con python; si además compusieran el JSON de la Card,
+    /// habría dos generadores del mismo formato divergiendo en silencio — y el formato es contrato
+    /// con `card_core::Card`, que no es nuestro.
+    ///
+    /// Por defecto sólo 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.
+    ServiceCards {
+        /// Rutas de recetas TOML. `scripts/targets.py --service-paths <perfil>` las lista.
+        recipes: Vec<String>,
+        /// Qué ámbito emitir: `system` (default), `session` o `all`.
+        #[arg(long, default_value = "system")]
+        scope: String,
+    },
     /// [Fase 0] Calcula el `ArtifactHash` de una receta SIN construir — puro sobre las recetas
     /// (source_id + compiler/target/link + patches + flags + fases + hashes de deps). No baja
     /// fuentes ni compila. Responde "¿cuál es el hash VIGENTE de esta receta?", que el store no
@@ -947,6 +965,25 @@ fn main() -> anyhow::Result<()> {
             let hash = takana_build::build(&recipe, &cfg, &store)?;
             println!("{hash}");
         }
+        Cmd::ServiceCards { recipes, scope } => {
+            use takana_core::service::Scope;
+            let filtro = match scope.as_str() {
+                "system" => Some(Scope::System),
+                "session" => Some(Scope::Session),
+                "all" => None,
+                otro => anyhow::bail!("--scope inválido: {otro} (system | session | all)"),
+            };
+            let mut cards: Vec<serde_json::Value> = Vec::new();
+            for ruta in &recipes {
+                let r = takana_core::Recipe::load_from_path(ruta)?;
+                for s in &r.services {
+                    if filtro.is_none_or(|f| f == s.scope) {
+                        cards.push(s.card());
+                    }
+                }
+            }
+            println!("{}", serde_json::to_string_pretty(&cards)?);
+        }
         Cmd::Hash { recipe, check } => {
             let store = takana_core::Store::open(&cli.store)?;
             let recipe = takana_core::Recipe::load_from_path(&recipe)?;