journal-query CLI, machined, polkit con grants reales, GNOME boot test

- ente-journalctl: bin nuevo en ente-journald-compat. Lee
  ~/.local/share/ente/journal/index.log, parse timestamp:source:unit:sha,
  filtra --unit/--source/--since/--grep/--tail, restituye blobs desde CAS
  y formatea (pretty | --json). Default extrae MESSAGE de journald native.
- compat-machined: org.freedesktop.machine1.Manager con
  ListMachines/GetMachine/Register/Terminate. Lista vacía + NotFound —
  apps que llaman al boot ya no quedan en timeout.
- compat-polkit: query_policy() consulta el bus interno por el cap
  POLKIT_DECISION_IFACE con blob (pid_be|uid_be|action_id_utf8). Si hay
  proveedor su byte de respuesta gobierna; si no, default-allow.
  Anuncia POLKIT_SERVICE_IFACE (separado para evitar recursión).
- docs/gnome-boot-test.md: procedimiento end-to-end para arrancar GNOME
  con ente-zero como PID 1 en QEMU. scripts/build-rootfs.sh overlaya
  binarios + symlink /init. scripts/run-vm.sh boot QEMU con KVM y GTK.
  docs/seed-gnome-test.k Card Semilla con genesis para 8 shims +
  dbus-daemon + NetworkManager + gdm.

8 compat-shims operativos en paralelo cubriendo: logind, hostnamed,
timedated, localed, journald, resolved, polkit, machined.

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

crates/ente-polkit-compat/src/main.rs

@@ -14,11 +14,11 @@
 //! CheckAuthorization solicita un token al graph y devuelve true/false
 //! según el resultado.
 
-use ente_bus::{BusClient, BusRequest, BusResponse};
+use ente_bus::{BusClient, BusRequest, BusResponse, POLKIT_DECISION_IFACE, POLKIT_SERVICE_IFACE};
 use ente_card::Capability;
 use std::collections::HashMap;
 use tokio::signal::unix::{signal, SignalKind};
-use tracing::{info, warn};
+use tracing::{debug, info, warn};
 use tracing_subscriber::EnvFilter;
 use zbus::{fdo, interface, zvariant::OwnedValue};
 
@@ -73,9 +73,12 @@ impl PolkitAuthority {
             .and_then(|v| u32::try_from(v).ok());
         let uid = subj_details.get("uid")
             .and_then(|v| u32::try_from(v).ok());
-        info!(%action_id, %subj_kind, ?pid, ?uid, "CheckAuthorization → ALLOW");
-        // Always-yes: fractal confía en todos sus Entes (auth real está en el bus).
-        Ok((true, false, HashMap::new()))
+
+        // Pregunta al bus interno del fractal si hay un policy provider.
+        // Si lo hay, su decisión gobierna. Si no (NoProvider), default = allow.
+        let decision = query_policy(&action_id, pid, uid).await;
+        info!(%action_id, %subj_kind, ?pid, ?uid, ?decision, "CheckAuthorization");
+        Ok((decision.allow, false, HashMap::new()))
     }
 
     async fn check_authorization_by_async(
@@ -175,11 +178,62 @@ type EnumeratedAction = (
 /// Aquí `(string)` * 5 + 2 timestamps. Simplificamos al subset relevante.
 type TemporaryAuth = (String, String, (String, HashMap<String, OwnedValue>), u64, u64);
 
+/// Resultado de una consulta de policy al fractal.
+#[derive(Debug)]
+struct PolicyDecision {
+    allow: bool,
+    /// Origen: "fractal" si vino del bus, "default-allow" si no había proveedor.
+    source: &'static str,
+}
+
+/// Pregunta al bus interno: ¿hay alguien que decida sobre `action_id`?
+/// Wire format del blob: `pid_u32_be | uid_u32_be | action_id_utf8`.
+/// El proveedor responde con `Invoked { result: [0|1] }` — 1 = allow.
+async fn query_policy(action_id: &str, pid: Option<u32>, uid: Option<u32>) -> PolicyDecision {
+    let mut blob = Vec::with_capacity(8 + action_id.len());
+    blob.extend_from_slice(&pid.unwrap_or(0).to_be_bytes());
+    blob.extend_from_slice(&uid.unwrap_or(0).to_be_bytes());
+    blob.extend_from_slice(action_id.as_bytes());
+
+    let mut client = match BusClient::from_env().await {
+        Ok(c) => c,
+        Err(e) => {
+            debug!(?e, "no bus client — default allow");
+            return PolicyDecision { allow: true, source: "no-bus" };
+        }
+    };
+    let req = BusRequest::Invoke {
+        cap: Capability::Endpoint {
+            interface: POLKIT_DECISION_IFACE,
+            version: 1,
+        },
+        blob,
+    };
+    match client.call(req).await {
+        Ok(BusResponse::Invoked { result }) => {
+            let allow = result.first().copied().unwrap_or(1) != 0;
+            PolicyDecision { allow, source: "fractal" }
+        }
+        Ok(BusResponse::Error(msg)) if msg.contains("sin proveedor") => {
+            // No hay policy provider — default allow.
+            PolicyDecision { allow: true, source: "default-allow" }
+        }
+        Ok(other) => {
+            warn!(?other, "policy: respuesta inesperada — default allow");
+            PolicyDecision { allow: true, source: "default-allow" }
+        }
+        Err(e) => {
+            warn!(?e, "policy: bus call falló — default allow");
+            PolicyDecision { allow: true, source: "default-allow" }
+        }
+    }
+}
+
 async fn announce_to_fractal() {
     if let Ok(mut client) = BusClient::from_env().await {
         let req = BusRequest::Announce {
             capabilities: vec![Capability::Endpoint {
-                interface: ente_card::InterfaceId([0xa4; 16]),
+                interface: POLKIT_SERVICE_IFACE,
                 version: 1,
             }],
         };