feat(sidecar): WIT al sidecar — módulos conscientes vivos

Cierra el ciclo brahman-card-wit ↔ runtime: un módulo que tenga su
.wit lo parsea, lo manda en Hello, y aparece como "consciente" en el
broker y en brahman-status.

Cambios coordinados (un solo commit por la cadena de tipos):

- brahman-card::WitInterface deriva Serialize/Deserialize/Eq.
- brahman-handshake::Hello lleva wit: Option<WitInterface> (#[serde(default)]
  para tolerar Hellos antiguos en formato JSON aunque postcard exige
  presencia explícita).
- Server's register_session enruta a ResolvedCard::from_conscious cuando
  viene wit; from_agnostic cuando no.
- Client::connect queda como wrapper de connect_with(path, card,
  wit: Option<WitInterface>) — backward-compatible.
- Broker::register acepta Option<WitInterface> como tercer arg; BrokeredCard
  guarda el wit. 25 sitios de tests actualizados con `, None` (vía perl).
- brahman-sidecar::SidecarConfig.wit + helpers SidecarConfig::with_wit
  y spawn_conscious(card, wit). Log attached reporta conscious=true|false.
- brahman-status pretty-print con 🧠 + sección wit (package/world +
  imports + exports) por sesión consciente.
- Example nuevo presence-conscious: parsea protocol.wit y se presenta
  consciente.

Validación end-to-end manual:

  $ ente-zero &
  $ presence-conscious demo.conscious shared_wit/protocol.wit &
  $ brahman-status
  Sessions (1):
    01K... demo.conscious 🧠  lifecycle=Daemon
        wit: brahman:protocol@0.1.0 / module
             imports: types, handshake, lifecycle
             exports: run

Tests: 32/32 (broker 11 + card 8 + handshake codec+transport 2 + integ 7
+ admin 0 + card-wit 4). Workspace: 0 errores.

CHANGELOG.md actualizado.

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

crates/core/brahman-admin/examples/brahman-status.rs

@@ -20,10 +20,20 @@ async fn main() -> anyhow::Result<()> {
         println!("  (ninguna)");
     } else {
         for s in &snap.sessions {
+            let conscious_marker = if s.wit.is_some() { " 🧠" } else { "" };
             println!(
-                "  {}  {}  lifecycle={:?}  priority={:?}",
-                s.session, s.label, s.lifecycle, s.priority
+                "  {}  {}{}  lifecycle={:?}  priority={:?}",
+                s.session, s.label, conscious_marker, s.lifecycle, s.priority
             );
+            if let Some(wit) = &s.wit {
+                println!("      wit: {} / {}", wit.package, wit.world);
+                if !wit.imports.is_empty() {
+                    println!("           imports: {}", wit.imports.join(", "));
+                }
+                if !wit.exports.is_empty() {
+                    println!("           exports: {}", wit.exports.join(", "));
+                }
+            }
             for f in &s.inputs {
                 println!("      in  {}: {:?}", f.name, f.ty);
             }

crates/core/brahman-broker/src/lib.rs

@@ -30,7 +30,7 @@
 
 use std::collections::BTreeMap;
 
-use brahman_card::{Card, Flow, Lifecycle, Priority, TypeRef};
+use brahman_card::{Card, Flow, Lifecycle, Priority, TypeRef, WitInterface};
 use serde::{Deserialize, Serialize};
 use ulid::Ulid;
 
@@ -68,10 +68,12 @@ pub struct BrokeredCard {
     pub priority: Priority,
     pub inputs: Vec<Flow>,
     pub outputs: Vec<Flow>,
+    /// Interfaz WIT extraída si el módulo es "consciente"; `None` si agnóstico.
+    pub wit: Option<WitInterface>,
 }
 
 impl BrokeredCard {
-    fn from_card(session: SessionId, card: &Card) -> Self {
+    fn from_card(session: SessionId, card: &Card, wit: Option<WitInterface>) -> Self {
         Self {
             session,
             label: card.label.clone(),
@@ -79,6 +81,7 @@ impl BrokeredCard {
             priority: card.priority,
             inputs: card.flow.input.clone(),
             outputs: card.flow.output.clone(),
+            wit,
         }
     }
 }
@@ -125,9 +128,17 @@ impl Broker {
         }
     }
 
-    /// Registra una Card. Devuelve `Some(prev)` si reemplazó una existente.
-    pub fn register(&mut self, session: SessionId, card: &Card) -> Option<BrokeredCard> {
-        self.cards.insert(session, BrokeredCard::from_card(session, card))
+    /// Registra una Card con su WIT opcional. Devuelve `Some(prev)` si
+    /// reemplazó una existente. Pasar `None` en `wit` indica módulo
+    /// agnóstico (sin contrato WIT extraído).
+    pub fn register(
+        &mut self,
+        session: SessionId,
+        card: &Card,
+        wit: Option<WitInterface>,
+    ) -> Option<BrokeredCard> {
+        self.cards
+            .insert(session, BrokeredCard::from_card(session, card, wit))
     }
 
     /// Quita una Card por sesión.
@@ -351,8 +362,8 @@ mod tests {
         );
         let s_prod = Ulid::new();
         let s_cons = Ulid::new();
-        b.register(s_prod, &producer);
-        b.register(s_cons, &consumer);
+        b.register(s_prod, &producer, None);
+        b.register(s_cons, &consumer, None);
 
         let m = b.find_producer_for(s_cons, "query").expect("match");
         assert_eq!(m.producer_label, "dht");
@@ -391,8 +402,8 @@ mod tests {
         );
         let s_prod = Ulid::new();
         let s_cons = Ulid::new();
-        b.register(s_prod, &producer);
-        b.register(s_cons, &consumer);
+        b.register(s_prod, &producer, None);
+        b.register(s_cons, &consumer, None);
 
         let m = b.find_producer_for(s_cons, "in").expect("match");
         assert_eq!(m.via, MatchStrategy::Structural);
@@ -427,9 +438,9 @@ mod tests {
                 output: vec![],
             },
         );
-        b.register(Ulid::new(), &producer);
+        b.register(Ulid::new(), &producer, None);
         let s_cons = Ulid::new();
-        b.register(s_cons, &consumer);
+        b.register(s_cons, &consumer, None);
 
         assert!(b.find_producer_for(s_cons, "in").is_none());
     }
@@ -477,10 +488,10 @@ mod tests {
                 output: vec![],
             },
         );
-        b.register(Ulid::new(), &p_struct);
-        b.register(Ulid::new(), &p_exact);
+        b.register(Ulid::new(), &p_struct, None);
+        b.register(Ulid::new(), &p_exact, None);
         let s_cons = Ulid::new();
-        b.register(s_cons, &consumer);
+        b.register(s_cons, &consumer, None);
 
         let m = b.find_producer_for(s_cons, "in").expect("match");
         // El exact gana incluso si tiene priority igual: por estrategia.
@@ -516,10 +527,10 @@ mod tests {
                 output: vec![],
             },
         );
-        b.register(Ulid::new(), &p1);
-        b.register(Ulid::new(), &p2);
+        b.register(Ulid::new(), &p1, None);
+        b.register(Ulid::new(), &p2, None);
         let s_cons = Ulid::new();
-        b.register(s_cons, &consumer);
+        b.register(s_cons, &consumer, None);
 
         let m = b.find_producer_for(s_cons, "in").expect("match");
         assert_eq!(m.producer_label, "dht-test");
@@ -545,9 +556,9 @@ mod tests {
                 output: vec![],
             },
         );
-        b.register(Ulid::new(), &p);
+        b.register(Ulid::new(), &p, None);
         let s_cons = Ulid::new();
-        b.register(s_cons, &consumer);
+        b.register(s_cons, &consumer, None);
 
         let m = b.find_producer_for(s_cons, "in").expect("match");
         assert_eq!(m.producer_label, "real-dht");
@@ -581,10 +592,10 @@ mod tests {
                 output: vec![],
             },
         );
-        b.register(Ulid::new(), &p_low);
-        b.register(Ulid::new(), &p_high);
+        b.register(Ulid::new(), &p_low, None);
+        b.register(Ulid::new(), &p_high, None);
         let s_cons = Ulid::new();
-        b.register(s_cons, &consumer);
+        b.register(s_cons, &consumer, None);
 
         let m = b.find_producer_for(s_cons, "in").expect("match");
         assert_eq!(m.producer_label, "a-dht"); // priority High > Low
@@ -617,10 +628,10 @@ mod tests {
                 output: vec![],
             },
         );
-        b.register(Ulid::new(), &p1);
-        b.register(Ulid::new(), &p2);
+        b.register(Ulid::new(), &p1, None);
+        b.register(Ulid::new(), &p2, None);
         let s_cons = Ulid::new();
-        b.register(s_cons, &consumer);
+        b.register(s_cons, &consumer, None);
 
         let m = b.find_producer_for(s_cons, "in").expect("match");
         assert_eq!(m.producer_label, "a-dht"); // alfabético gana
@@ -646,9 +657,9 @@ mod tests {
             },
         );
         let s_p = Ulid::new();
-        b.register(s_p, &p);
+        b.register(s_p, &p, None);
         let s_c = Ulid::new();
-        b.register(s_c, &consumer);
+        b.register(s_c, &consumer, None);
 
         assert!(b.find_producer_for(s_c, "in").is_some());
         b.unregister(s_p);
@@ -667,7 +678,7 @@ mod tests {
             },
         );
         let s = Ulid::new();
-        b.register(s, &same);
+        b.register(s, &same, None);
 
         // Solo una Card registrada — no hay otra que produzca string.
         assert!(b.find_producer_for(s, "in").is_none());
@@ -692,8 +703,8 @@ mod tests {
                 output: vec![flow("user-input", prim("string"), None)],
             },
         );
-        b.register(Ulid::new(), &dht);
-        b.register(Ulid::new(), &ui);
+        b.register(Ulid::new(), &dht, None);
+        b.register(Ulid::new(), &ui, None);
 
         let matches = b.all_matches();
         assert_eq!(matches.len(), 2);

crates/core/brahman-card/src/lib.rs

@@ -610,7 +610,7 @@ impl TrustLevel {
 
 /// Resumen de la interfaz WIT extraída del componente WASM/WIT.
 /// Vacío para módulos agnósticos (sin contrato WIT).
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
 pub struct WitInterface {
     pub package: String,
     pub world: String,

crates/core/brahman-handshake/src/client.rs

@@ -4,7 +4,7 @@ use std::collections::VecDeque;
 use std::path::Path;
 use std::time::Duration;
 
-use brahman_card::{Card, CARD_SCHEMA_VERSION};
+use brahman_card::{Card, WitInterface, CARD_SCHEMA_VERSION};
 use thiserror::Error;
 use tokio::net::UnixStream;
 
@@ -43,9 +43,20 @@ pub struct Client {
 }
 
 impl Client {
-    /// Conecta al socket, envía Hello con la Card dada y procesa la respuesta.
+    /// Conecta como módulo agnóstico (sin WIT). Equivalente a
+    /// `connect_with(path, card, None)`.
     pub async fn connect(path: impl AsRef<Path>, card: Card) -> Result<Self, ClientError> {
-        // Pre-validamos para fallar local antes de hablar con el servidor.
+        Self::connect_with(path, card, None).await
+    }
+
+    /// Conecta al socket enviando Hello con la Card dada y opcionalmente
+    /// una `WitInterface` ya extraída. Si `wit` es `Some`, el server
+    /// registra el módulo como "consciente".
+    pub async fn connect_with(
+        path: impl AsRef<Path>,
+        card: Card,
+        wit: Option<WitInterface>,
+    ) -> Result<Self, ClientError> {
         card.validate()
             .map_err(|e| ClientError::InvalidCard(e.to_string()))?;
 
@@ -54,6 +65,7 @@ impl Client {
             schema_version: CARD_SCHEMA_VERSION,
             protocol_version: brahman_card::PROTOCOL_VERSION.to_string(),
             card,
+            wit,
         };
         write_frame(&mut stream, &Frame::Hello(hello)).await?;
 

crates/core/brahman-handshake/src/messages.rs

@@ -3,7 +3,7 @@
 //! Todos los mensajes que cruzan el wire son variantes de [`Frame`].
 
 use brahman_broker::MatchStrategy;
-use brahman_card::TypeRef;
+use brahman_card::{TypeRef, WitInterface};
 use serde::{Deserialize, Serialize};
 use ulid::Ulid;
 
@@ -11,7 +11,9 @@ use ulid::Ulid;
 pub type SessionId = Ulid;
 
 /// Saludo inicial del módulo. Lleva la Card completa para que el servidor
-/// la valide e indexe.
+/// la valide e indexe. Opcionalmente, una `WitInterface` ya extraída — si
+/// está presente, el módulo es "consciente" y el server lo registra como
+/// `ResolvedCard::from_conscious`; si no, como `from_agnostic`.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Hello {
     /// Versión del schema de Card que el cliente sigue.
@@ -20,6 +22,10 @@ pub struct Hello {
     pub protocol_version: String,
     /// Tarjeta de Presentación.
     pub card: brahman_card::Card,
+    /// Interfaz WIT extraída por el cliente (típicamente con
+    /// `brahman-card-wit`). `None` si el módulo es agnóstico.
+    #[serde(default)]
+    pub wit: Option<WitInterface>,
 }
 
 /// Respuesta del servidor a un `Hello` aceptado.

crates/core/brahman-handshake/src/server.rs

@@ -6,7 +6,7 @@ use std::sync::Arc;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use brahman_broker::{Broker, Endpoint};
-use brahman_card::{Card, ResolvedCard, CARD_SCHEMA_VERSION};
+use brahman_card::{Card, ResolvedCard, WitInterface, CARD_SCHEMA_VERSION};
 use tokio::net::{UnixListener, UnixStream};
 use tokio::sync::{mpsc, Mutex};
 use tracing::{debug, warn};
@@ -367,7 +367,7 @@ impl Session {
         }
 
         let session_id = Ulid::new();
-        self.register_session(session_id, hello.card).await;
+        self.register_session(session_id, hello.card, hello.wit).await;
 
         let ack = HelloAck {
             server_version: crate::HANDSHAKE_VERSION.to_string(),
@@ -381,11 +381,23 @@ impl Session {
     }
 
     /// Indexa la sesión: ResolvedCard en sessions + Card en broker (si hay).
-    async fn register_session(&self, session_id: SessionId, card: Card) {
+    /// Si `wit` está presente, el módulo se registra como "consciente".
+    async fn register_session(
+        &self,
+        session_id: SessionId,
+        card: Card,
+        wit: Option<WitInterface>,
+    ) {
         if let Some(broker) = &self.config.broker {
-            broker.lock().await.register(session_id, &card);
+            broker
+                .lock()
+                .await
+                .register(session_id, &card, wit.clone());
         }
-        let resolved = ResolvedCard::from_agnostic(card);
+        let resolved = match wit {
+            Some(w) => ResolvedCard::from_conscious(card, w),
+            None => ResolvedCard::from_agnostic(card),
+        };
         self.sessions.lock().await.insert(session_id, resolved);
     }
 

crates/core/brahman-handshake/tests/handshake.rs

@@ -124,6 +124,7 @@ async fn server_rejects_protocol_mismatch() {
         schema_version: CARD_SCHEMA_VERSION,
         protocol_version: "999.0.0".into(),
         card: sample_card("future-module"),
+        wit: None,
     };
     write_frame(&mut stream, &Frame::Hello(hello)).await.unwrap();