feat(brahman-handshake+ente-zero): denylist + hot reload de policy de peers

Consolida PeerAllowlist + nueva denylist en un unico PeerPolicy con
allow + deny + hot reload via notify. Cubre los dos pendientes
documentados en el commit anterior y simplifica la API hacia un solo
punto de entrada.

API consolidada en brahman_handshake::peer_policy:
- PeerPolicy::open() — todo permitido (default).
- PeerPolicy::from_sets(allow, deny) — politica inline para tests.
- PeerPolicy::from_files(allow_path?, deny_path?) — carga ambos
  archivos opcionales.
- PeerPolicy::evaluate(peer) -> Decision { Admit | DeniedByDenylist
  | NotInAllowlist }. Decision lleva reason() para logging.
- PeerPolicy::reload() — recarga atomica desde paths asociados.
  Si un archivo falla, conserva la version anterior (un typo no
  baja la politica activa).
- PeerPolicy::spawn_watcher() -> JoinHandle — vigila los archivos
  via notify, debounce 250ms (coalesce de eventos por save), recarga
  atomica al detectar cambio.

Orden de evaluacion: deny-first.
1. peer in denylist -> DeniedByDenylist.
2. allowlist set y peer no in allowlist -> NotInAllowlist.
3. resto -> Admit.

Deny gana sobre allow (un peer en ambas es rechazado): la denylist
es la primitiva de "kill switch".

Watcher: vigila el directorio padre del archivo, no el archivo
mismo. Razon: editores tipicos hacen rename-and-replace que rompe
el watch del archivo pero no del dir. Filtra eventos por path al
procesar.

Wire en server: ServerConfig.allowlist -> ServerConfig.policy:
Option<PeerPolicy> (rename, scope local).

Wire en Arje (ente-zero): nueva env BRAHMAN_PEER_DENYLIST complementa
BRAHMAN_PEER_ALLOWLIST. setup_brahman_policy carga + spawn watcher
y devuelve (policy, JoinHandle) — el handle se conserva en main
para que el thread no aborte.

Activacion completa con todas las capas:
  BRAHMAN_LISTEN_MULTIADDR=/ip4/0.0.0.0/tcp/4101 \\
  BRAHMAN_PEER_ALLOWLIST=/etc/brahman/allow.txt \\
  BRAHMAN_PEER_DENYLIST=/etc/brahman/deny.txt \\
  ente-zero
# Editar deny.txt en caliente entra en efecto en ~250ms sin restart.

Tests: 10 unit en peer_policy (incluido watcher_reloads_on_file_change
con notify real) + 1 E2E nuevo libp2p_handshake_denylist_blocks_
listed_peer. 30 tests verdes en brahman-handshake. Sin regresion en
ente-zero.

Lo que cierra: politica completa (open/allow/deny/both), hot reload
sin restart, atomicidad de la recarga, resiliencia ante typos.

Pendientes futuros: aplicar policy a nivel de swarm via
libp2p_allow_block_list::Behaviour (rechazar antes del Noise
handshake), rotacion de keypair sin perder peer_id.

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

@@ -58,7 +58,7 @@ fn sock_path(name: &str) -> std::path::PathBuf {
 #[tokio::test]
 async fn full_handshake_roundtrip() {
     let path = sock_path("happy");
-    let server = Server::bind(&path, ServerConfig { init_attached: true, broker: None, net: None, allowlist: None }).unwrap();
+    let server = Server::bind(&path, ServerConfig { init_attached: true, broker: None, net: None, policy: None }).unwrap();
 
     let session_handle = tokio::spawn({
         async move {
@@ -195,7 +195,7 @@ async fn broker_registers_and_unregisters_with_session() {
             init_attached: false,
             broker: Some(broker.clone()),
             net: None,
-            allowlist: None,
+            policy: None,
         },
     )
     .unwrap();
@@ -239,7 +239,7 @@ async fn broker_matches_two_live_modules() {
             init_attached: false,
             broker: Some(broker.clone()),
             net: None,
-            allowlist: None,
+            policy: None,
         },
     )
     .unwrap();
@@ -316,7 +316,7 @@ async fn match_event_pushed_on_producer_arrival() {
             init_attached: false,
             broker: Some(broker.clone()),
             net: None,
-            allowlist: None,
+            policy: None,
         },
     )
     .unwrap();

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

@@ -85,7 +85,7 @@ async fn dht_discovery_finds_remote_provider() {
                 init_attached: true,
                 broker: Some(a_broker.clone()),
                 net: Some(a_net.clone()), // ← clave Fase 2: anuncia al DHT
-                allowlist: None,
+                policy: None,
             },
         )
         .unwrap(),
@@ -172,7 +172,7 @@ async fn dht_discovery_negative_unknown_flow() {
                 init_attached: true,
                 broker: Some(a_broker),
                 net: Some(a_net.clone()),
-                allowlist: None,
+                policy: None,
             },
         )
         .unwrap(),
@@ -251,7 +251,7 @@ async fn dht_discovery_withdraws_on_session_cleanup() {
                 init_attached: true,
                 broker: Some(a_broker),
                 net: Some(a_net.clone()),
-                allowlist: None,
+                policy: None,
             },
         )
         .unwrap(),

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

@@ -19,7 +19,7 @@ use brahman_card::{
     CARD_SCHEMA_VERSION,
 };
 use brahman_handshake::network::{connect_libp2p, run_libp2p_accept_loop};
-use brahman_handshake::peer_allowlist::PeerAllowlist;
+use brahman_handshake::peer_policy::PeerPolicy;
 use brahman_handshake::server::{Server, ServerConfig};
 use brahman_net::{BrahmanNet, Keypair, Multiaddr, PeerId, Protocol};
 use tempfile::TempDir;
@@ -57,7 +57,7 @@ async fn libp2p_handshake_roundtrip() {
                 init_attached: true,
                 broker: Some(broker.clone()),
                 net: None,
-                allowlist: None,
+                policy: None,
             },
         )
         .unwrap(),
@@ -136,7 +136,7 @@ async fn libp2p_handshake_rejects_mismatched_signing_key() {
                 init_attached: true,
                 broker: None,
                 net: None,
-                allowlist: None,
+                policy: None,
             },
         )
         .unwrap(),
@@ -197,7 +197,10 @@ async fn libp2p_handshake_allowlist_admits_listed_rejects_others() {
                 init_attached: true,
                 broker: None,
                 net: None,
-                allowlist: Some(PeerAllowlist::from_iter([allowed_peer])),
+                policy: Some(PeerPolicy::from_sets(
+                    Some([allowed_peer].into_iter().collect()),
+                    std::collections::BTreeSet::new(),
+                )),
             },
         )
         .unwrap(),
@@ -247,3 +250,74 @@ async fn libp2p_handshake_allowlist_admits_listed_rejects_others() {
         assert_eq!(s.len(), 0, "ninguna sesión adicional registrada tras intento denegado");
     }
 }
+
+/// Denylist gate: A configura `policy` con un peer en la denylist.
+/// Modo abierto para todo lo demás (sin allowlist), pero el peer
+/// baneado es rechazado aún teniendo Ed25519 válida y peer_id que
+/// derivaría limpio del Noise handshake.
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn libp2p_handshake_denylist_blocks_listed_peer() {
+    let banned_kp = Keypair::generate_ed25519();
+    let banned_peer = banned_kp.public().to_peer_id();
+    let other_kp = Keypair::generate_ed25519();
+
+    let tmp = TempDir::new().unwrap();
+    let unix_socket = tmp.path().join("brahman-init.sock");
+    let server = Arc::new(
+        Server::bind(
+            &unix_socket,
+            ServerConfig {
+                init_attached: true,
+                broker: None,
+                net: None,
+                policy: Some(PeerPolicy::from_sets(
+                    None, // sin allowlist (abierto)
+                    [banned_peer].into_iter().collect(),
+                )),
+            },
+        )
+        .unwrap(),
+    );
+    let sessions = server.sessions();
+
+    let server_net = Arc::new(BrahmanNet::new().unwrap());
+    let server_peer = server_net.peer_id;
+    let actual = server_net
+        .listen("/ip4/127.0.0.1/tcp/0".parse().unwrap())
+        .await;
+    let mut full = actual.clone();
+    full.push(Protocol::P2p(server_peer));
+
+    tokio::spawn(run_libp2p_accept_loop(server.clone(), server_net.clone()));
+
+    // Cliente baneado: connect debe fallar.
+    let banned_net = BrahmanNet::with_keypair(banned_kp.clone()).unwrap();
+    banned_net.dial(full.clone());
+    tokio::time::sleep(Duration::from_millis(200)).await;
+
+    let card_x = sample_card("test.banned");
+    let result = connect_libp2p(&banned_net, server_peer, card_x, None, &banned_kp).await;
+    assert!(
+        result.is_err(),
+        "peer en denylist debe ser rechazado, got Ok"
+    );
+    {
+        let s = sessions.lock().await;
+        assert_eq!(s.len(), 0, "el peer baneado no debería tener sesión");
+    }
+
+    // Cliente no-baneado pasa.
+    let other_net = BrahmanNet::with_keypair(other_kp.clone()).unwrap();
+    other_net.dial(full.clone());
+    tokio::time::sleep(Duration::from_millis(200)).await;
+
+    let card_ok = sample_card("test.other");
+    let mut other_client = connect_libp2p(&other_net, server_peer, card_ok, None, &other_kp)
+        .await
+        .expect("peer fuera de denylist debe pasar");
+    {
+        let s = sessions.lock().await;
+        assert_eq!(s.len(), 1, "sesión del peer no-baneado registrada");
+    }
+    other_client.farewell().await.ok();
+}