Move nostr peer rendezvous and mDNS into dedicated module homes

Relocate the overlay peer-rendezvous subsystem out of the overloaded
src/discovery/ tree into two focused, independent homes: src/nostr/
(relay-mediated overlay endpoint advertise/resolve/auto-mesh plus NAT
traversal) and src/mdns/ (link-local DNS-SD rendezvous). The two
subsystems are independent, so they get separate homes rather than
sharing one.

Drop the ambiguous "Discovery" stem from their identifiers in favor of
"Rendezvous": NostrDiscovery -> NostrRendezvous, LanDiscovery ->
LanRendezvous, and the matching config, policy, field, and method names.
The former src/discovery.rs handoff types (EstablishedTraversal,
BootstrapHandoffResult, the punch-packet helpers) fold into
src/nostr/handoff and stay reachable via the crate-root re-exports.

Pure relocation and rename: no logic, wire-format, config-key, metric,
or tracing-target changes. The operator-facing node.rendezvous.nostr.*
and node.rendezvous.lan.* config keys and the fips-overlay-v1 advert
namespace are byte-identical. cargo fmt/build/clippy clean; lib test
suite 1547 passing (baseline unchanged).

src/node/handlers/rx_loop.rs

@@ -257,13 +257,13 @@ impl Node {
                     // is polled separately from `reload_peer_acl` because the
                     // ACL's embedded alias reloader and this snapshot are
                     // distinct resources; the `path_mtu_lookup` cache and the
-                    // `nostr_discovery` subsystem are deliberately excluded
+                    // `nostr_rendezvous` subsystem are deliberately excluded
                     // from `Reloadable` since neither reloads from a backing
                     // file (see `node::reloadable`).
                     self.reload_host_map().await;
                     self.poll_pending_connects().await;
-                    self.poll_nostr_discovery().await;
-                    self.poll_lan_discovery().await;
+                    self.poll_nostr_rendezvous().await;
+                    self.poll_lan_rendezvous().await;
                     self.resend_pending_handshakes(now_ms).await;
                     self.resend_pending_rekeys(now_ms).await;
                     self.resend_pending_session_handshakes(now_ms).await;
@@ -324,7 +324,7 @@ impl Node {
                     .bootstrap_transport_npubs
                     .get(&packet.transport_id)
                     .cloned()
-                && let Some(handle) = self.nostr_discovery_handle()
+                && let Some(handle) = self.nostr_rendezvous_handle()
             {
                 let now_ms = Self::now_ms();
                 let cooldown_secs = handle.protocol_mismatch_cooldown_secs();

src/node/lifecycle.rs

@@ -2,13 +2,13 @@
 
 use super::{Node, NodeError, NodeState};
 use crate::config::{ConnectPolicy, PeerAddress, PeerConfig};
-use crate::discovery::nostr::{
-    ADVERT_IDENTIFIER, ADVERT_VERSION, BootstrapEvent, NostrDiscovery, OverlayAdvert,
-    OverlayEndpointAdvert, OverlayTransportKind,
-};
-use crate::discovery::{BootstrapHandoffResult, EstablishedTraversal};
 use crate::node::acl::PeerAclContext;
 use crate::node::wire::build_msg1;
+use crate::nostr::{
+    ADVERT_IDENTIFIER, ADVERT_VERSION, BootstrapEvent, NostrRendezvous, OverlayAdvert,
+    OverlayEndpointAdvert, OverlayTransportKind,
+};
+use crate::nostr::{BootstrapHandoffResult, EstablishedTraversal};
 use crate::peer::PeerConnection;
 use crate::proto::fmp::{Disconnect, DisconnectReason};
 use crate::transport::{Link, LinkDirection, LinkId, TransportAddr, TransportId, packet_channel};
@@ -266,7 +266,7 @@ impl Node {
                 // would loop on the same dead address until expiry. Force a
                 // re-fetch so the next retry tick picks up fresh endpoints.
                 if matches!(e, crate::node::NodeError::NoTransportForType(_))
-                    && let Some(bootstrap) = self.nostr_discovery.clone()
+                    && let Some(bootstrap) = self.nostr_rendezvous.clone()
                 {
                     let npub = peer_config.npub.clone();
                     tokio::spawn(async move {
@@ -679,8 +679,8 @@ impl Node {
         }
     }
 
-    pub(super) async fn poll_nostr_discovery(&mut self) {
-        let Some(bootstrap) = self.nostr_discovery.clone() else {
+    pub(super) async fn poll_nostr_rendezvous(&mut self) {
+        let Some(bootstrap) = self.nostr_rendezvous.clone() else {
             return;
         };
 
@@ -826,19 +826,19 @@ impl Node {
                         tokio::spawn(async move {
                             let outcome = bootstrap.refetch_advert_for_stale_check(&npub).await;
                             match outcome {
-                                crate::discovery::nostr::NostrRefetchOutcome::Evicted => info!(
+                                crate::nostr::NostrRefetchOutcome::Evicted => info!(
                                     npub = %npub,
                                     "stale-advert sweep: peer evicted from advert cache"
                                 ),
-                                crate::discovery::nostr::NostrRefetchOutcome::Refreshed => info!(
+                                crate::nostr::NostrRefetchOutcome::Refreshed => info!(
                                     npub = %npub,
                                     "stale-advert sweep: peer republished, cache refreshed and streak reset"
                                 ),
-                                crate::discovery::nostr::NostrRefetchOutcome::SameAdvert => debug!(
+                                crate::nostr::NostrRefetchOutcome::SameAdvert => debug!(
                                     npub = %npub,
                                     "stale-advert sweep: advert unchanged, cooldown stands"
                                 ),
-                                crate::discovery::nostr::NostrRefetchOutcome::Skipped => debug!(
+                                crate::nostr::NostrRefetchOutcome::Skipped => debug!(
                                     npub = %npub,
                                     "stale-advert sweep: skipped (relay error or no advert_relays)"
                                 ),
@@ -877,7 +877,7 @@ impl Node {
     /// changing the public Nostr discovery `app` tag. The older fallback
     /// extracts a scope from the Nostr app tag used by default scoped
     /// discovery.
-    pub(super) fn lan_discovery_scope(&self) -> Option<String> {
+    pub(super) fn lan_rendezvous_scope(&self) -> Option<String> {
         if let Some(scope) = self.config().node.rendezvous.lan.scope.as_deref() {
             let scope = scope.trim();
             if !scope.is_empty() {
@@ -904,8 +904,8 @@ impl Node {
     /// Drain mDNS-discovered peers and initiate Noise IK handshakes.
     /// The handshake itself is the authentication — a spoofed mDNS advert
     /// with someone else's npub fails the IK exchange and is dropped.
-    pub(super) async fn poll_lan_discovery(&mut self) {
-        let Some(runtime) = self.lan_discovery.clone() else {
+    pub(super) async fn poll_lan_rendezvous(&mut self) {
+        let Some(runtime) = self.lan_rendezvous.clone() else {
             return;
         };
         let events = runtime.drain_events().await;
@@ -913,7 +913,7 @@ impl Node {
             return;
         }
         for event in events {
-            let crate::discovery::lan::LanEvent::Discovered(peer) = event;
+            let crate::mdns::LanEvent::Discovered(peer) = event;
             let Some((transport_id, local_addr)) =
                 self.find_udp_transport_for_remote_addr(peer.addr)
             else {
@@ -1139,7 +1139,7 @@ impl Node {
         }
 
         if self.config().node.rendezvous.nostr.enabled {
-            match NostrDiscovery::start(
+            match NostrRendezvous::start(
                 self.identity(),
                 self.config().node.rendezvous.nostr.clone(),
             )
@@ -1149,8 +1149,8 @@ impl Node {
                     if let Err(err) = self.refresh_overlay_advert(&runtime).await {
                         warn!(error = %err, "Failed to publish initial Nostr overlay advert");
                     }
-                    self.nostr_discovery = Some(runtime);
-                    self.nostr_discovery_started_at_ms = Some(Self::now_ms());
+                    self.nostr_rendezvous = Some(runtime);
+                    self.nostr_rendezvous_started_at_ms = Some(Self::now_ms());
                     info!("Nostr overlay discovery enabled");
                 }
                 Err(err) => {
@@ -1181,8 +1181,8 @@ impl Node {
                 .min_by_key(|(id, _)| id.as_u32())
                 .map(|(_, port)| port)
                 .unwrap_or(0);
-            let scope = self.lan_discovery_scope();
-            match crate::discovery::lan::LanDiscovery::start(
+            let scope = self.lan_rendezvous_scope();
+            match crate::mdns::LanRendezvous::start(
                 self.identity(),
                 scope,
                 advertised_udp_port,
@@ -1191,7 +1191,7 @@ impl Node {
             .await
             {
                 Ok(runtime) => {
-                    self.lan_discovery = Some(runtime);
+                    self.lan_rendezvous = Some(runtime);
                     info!("LAN mDNS discovery enabled");
                 }
                 Err(err) => {
@@ -1479,7 +1479,7 @@ impl Node {
             .await;
 
         // Stop Nostr overlay discovery background work and withdraw any advert.
-        if let Some(bootstrap) = self.nostr_discovery.take()
+        if let Some(bootstrap) = self.nostr_rendezvous.take()
             && let Err(e) = bootstrap.shutdown().await
         {
             warn!(error = %e, "Failed to shutdown Nostr overlay discovery");
@@ -1488,7 +1488,7 @@ impl Node {
         // Tear down LAN mDNS responder + browser. Best-effort: the
         // OS will eventually time the advert out via its TTL even if
         // we don't get a clean unregister out before the daemon exits.
-        if let Some(lan) = self.lan_discovery.take() {
+        if let Some(lan) = self.lan_rendezvous.take() {
             lan.shutdown().await;
         }
 
@@ -1629,12 +1629,12 @@ impl Node {
         if !self.config().node.rendezvous.nostr.enabled
             || !peer_config.via_nostr
             || self.config().node.rendezvous.nostr.policy
-                == crate::config::NostrDiscoveryPolicy::Disabled
+                == crate::config::NostrRendezvousPolicy::Disabled
         {
             return Vec::new();
         }
 
-        let Some(bootstrap) = self.nostr_discovery.clone() else {
+        let Some(bootstrap) = self.nostr_rendezvous.clone() else {
             return Vec::new();
         };
         let endpoints = match bootstrap.advert_endpoints_for_peer(&peer_config.npub).await {
@@ -1695,7 +1695,7 @@ impl Node {
     }
 
     async fn request_nostr_bootstrap(&self, peer_config: &PeerConfig) -> bool {
-        let Some(bootstrap) = self.nostr_discovery.clone() else {
+        let Some(bootstrap) = self.nostr_rendezvous.clone() else {
             debug!(npub = %peer_config.npub, "No Nostr overlay runtime for udp:nat address");
             return false;
         };
@@ -1831,7 +1831,7 @@ impl Node {
         )))
     }
 
-    async fn queue_open_discovery_retries(&mut self, bootstrap: &std::sync::Arc<NostrDiscovery>) {
+    async fn queue_open_discovery_retries(&mut self, bootstrap: &std::sync::Arc<NostrRendezvous>) {
         self.run_open_discovery_sweep(bootstrap, None, "per-tick")
             .await;
     }
@@ -1848,13 +1848,13 @@ impl Node {
     /// startup sweeps are distinguishable in operator-facing logs.
     pub(in crate::node) async fn run_open_discovery_sweep(
         &mut self,
-        bootstrap: &std::sync::Arc<NostrDiscovery>,
+        bootstrap: &std::sync::Arc<NostrRendezvous>,
         max_age_secs: Option<u64>,
         caller: &'static str,
     ) {
         if !self.config().node.rendezvous.nostr.enabled
             || self.config().node.rendezvous.nostr.policy
-                != crate::config::NostrDiscoveryPolicy::Open
+                != crate::config::NostrRendezvousPolicy::Open
         {
             return;
         }
@@ -2046,20 +2046,20 @@ impl Node {
     /// `node.rendezvous.nostr.enabled` and `policy == open`.
     async fn maybe_run_startup_open_discovery_sweep(
         &mut self,
-        bootstrap: &std::sync::Arc<NostrDiscovery>,
+        bootstrap: &std::sync::Arc<NostrRendezvous>,
     ) {
         if self.startup_open_discovery_sweep_done {
             return;
         }
         if !self.config().node.rendezvous.nostr.enabled
             || self.config().node.rendezvous.nostr.policy
-                != crate::config::NostrDiscoveryPolicy::Open
+                != crate::config::NostrRendezvousPolicy::Open
         {
             // Mark done so we don't keep re-checking on every tick.
             self.startup_open_discovery_sweep_done = true;
             return;
         }
-        let Some(started_at_ms) = self.nostr_discovery_started_at_ms else {
+        let Some(started_at_ms) = self.nostr_rendezvous_started_at_ms else {
             return;
         };
         let now_ms = Self::now_ms();
@@ -2192,7 +2192,7 @@ impl Node {
 
     async fn build_overlay_advert(
         &self,
-        bootstrap: &std::sync::Arc<NostrDiscovery>,
+        bootstrap: &std::sync::Arc<NostrRendezvous>,
     ) -> Option<OverlayAdvert> {
         if !self.config().node.rendezvous.nostr.enabled {
             return None;
@@ -2343,8 +2343,8 @@ impl Node {
 
     async fn refresh_overlay_advert(
         &self,
-        bootstrap: &std::sync::Arc<NostrDiscovery>,
-    ) -> Result<(), crate::discovery::nostr::BootstrapError> {
+        bootstrap: &std::sync::Arc<NostrRendezvous>,
+    ) -> Result<(), crate::nostr::BootstrapError> {
         let advert = self.build_overlay_advert(bootstrap).await;
         bootstrap.update_local_advert(advert).await
     }

src/node/mod.rs

@@ -445,17 +445,17 @@ pub struct Node {
     retry_pending: HashMap<NodeAddr, retry::RetryState>,
 
     /// Optional Nostr/STUN overlay discovery coordinator for `udp:nat` peers.
-    nostr_discovery: Option<Arc<crate::discovery::nostr::NostrDiscovery>>,
+    nostr_rendezvous: Option<Arc<crate::nostr::NostrRendezvous>>,
     /// mDNS / DNS-SD responder + browser for local-link peer discovery.
     /// Identity is unverified at this layer — the Noise XX handshake
     /// initiated against an mDNS-observed endpoint is what proves the
     /// peer holds the matching private key.
-    lan_discovery: Option<Arc<crate::discovery::lan::LanDiscovery>>,
+    lan_rendezvous: Option<Arc<crate::mdns::LanRendezvous>>,
     /// Wall-clock ms when Nostr discovery successfully started, used to
     /// schedule the one-shot startup advert sweep after a settle delay.
     /// `None` until discovery comes up; remains `None` if discovery is
     /// disabled or failed to start.
-    nostr_discovery_started_at_ms: Option<u64>,
+    nostr_rendezvous_started_at_ms: Option<u64>,
     /// Whether the one-shot startup advert sweep has run. Set to true
     /// after the first sweep fires (under `policy: open`); thereafter
     /// only the per-tick `queue_open_discovery_retries` continues.
@@ -684,9 +684,9 @@ impl Node {
             ),
             pending_connects: Vec::new(),
             retry_pending: HashMap::new(),
-            nostr_discovery: None,
-            nostr_discovery_started_at_ms: None,
-            lan_discovery: None,
+            nostr_rendezvous: None,
+            nostr_rendezvous_started_at_ms: None,
+            lan_rendezvous: None,
             startup_open_discovery_sweep_done: false,
             bootstrap_transports: HashSet::new(),
             bootstrap_transport_npubs: HashMap::new(),
@@ -846,9 +846,9 @@ impl Node {
             lookup: Lookup::new(LookupBackoff::new(), LookupForwardRateLimiter::new()),
             pending_connects: Vec::new(),
             retry_pending: HashMap::new(),
-            nostr_discovery: None,
-            nostr_discovery_started_at_ms: None,
-            lan_discovery: None,
+            nostr_rendezvous: None,
+            nostr_rendezvous_started_at_ms: None,
+            lan_rendezvous: None,
             startup_open_discovery_sweep_done: false,
             bootstrap_transports: HashSet::new(),
             bootstrap_transport_npubs: HashMap::new(),
@@ -1834,7 +1834,7 @@ impl Node {
         // Per-npub Nostr-traversal failure-state, indexed by npub for O(1)
         // per-peer lookup (empty when Nostr discovery is disabled).
         let nostr_state: std::collections::HashMap<String, _> = self
-            .nostr_discovery_handle()
+            .nostr_rendezvous_handle()
             .map(|d| {
                 d.failure_state_snapshot()
                     .into_iter()
@@ -2398,8 +2398,8 @@ impl Node {
     /// Reference to the Nostr discovery handle if discovery is enabled.
     /// Used by control queries (`show_peers` per-peer Nostr-traversal
     /// state) to read failure-state without taking shared ownership.
-    pub fn nostr_discovery_handle(&self) -> Option<&crate::discovery::nostr::NostrDiscovery> {
-        self.nostr_discovery.as_deref()
+    pub fn nostr_rendezvous_handle(&self) -> Option<&crate::nostr::NostrRendezvous> {
+        self.nostr_rendezvous.as_deref()
     }
 
     /// Iterate over all peer node IDs.

src/node/reloadable.rs

@@ -41,7 +41,7 @@
 //!   file. There is nothing to poll. (Its read side could adopt the same
 //!   lock-free `ArcSwap` shape in the future, but that is an optimization, not
 //!   a reload.)
-//! - `nostr_discovery` is an async spawned subsystem, not a snapshot of disk
+//! - `nostr_rendezvous` is an async spawned subsystem, not a snapshot of disk
 //!   state.
 //!
 //! Both [`HostMapReloadable`] and the peer ACL reloader currently stat

src/node/retry.rs

@@ -282,7 +282,7 @@ impl Node {
             // evicts if the relay has nothing, otherwise leaves it. Cheap
             // (one Filter fetch with 2s timeout) and bounded by the retry
             // backoff cadence.
-            if let Some(bootstrap) = self.nostr_discovery.clone() {
+            if let Some(bootstrap) = self.nostr_rendezvous.clone() {
                 let _ = bootstrap
                     .refetch_advert_for_stale_check(&peer_config.npub)
                     .await;
@@ -318,7 +318,7 @@ impl Node {
                     // entry expires. Force a re-fetch so the next retry tick
                     // picks up fresh endpoints.
                     if matches!(e, NodeError::NoTransportForType(_))
-                        && let Some(bootstrap) = self.nostr_discovery.clone()
+                        && let Some(bootstrap) = self.nostr_rendezvous.clone()
                     {
                         let npub = peer_config.npub.clone();
                         tokio::spawn(async move {

src/node/tests/discovery.rs

@@ -921,20 +921,20 @@ async fn test_originator_stores_path_mtu_in_cache() {
 /// Pin the iterate-filter-queue contract of `run_open_discovery_sweep`.
 ///
 /// Builds a `Node` with `nostr.policy = Open` and an empty peer list,
-/// then injects three cached adverts into a test `NostrDiscovery` and
+/// then injects three cached adverts into a test `NostrRendezvous` and
 /// asserts the sweep:
 ///   - queues a retry for an eligible (unknown, not-self) advert,
 ///   - skips the advert whose author is our own node identity, and
 ///   - skips the advert whose author is an already-connected peer.
 ///
-/// Uses `NostrDiscovery::new_for_test()` and `insert_advert_for_test()`
+/// Uses `NostrRendezvous::new_for_test()` and `insert_advert_for_test()`
 /// (both `#[cfg(test)]`-gated test escape hatches in
 /// `src/discovery/nostr/runtime.rs`) to populate the cache without
 /// requiring live relay subscriptions.
 #[tokio::test]
 async fn test_open_discovery_sweep_queues_eligible_skips_filtered() {
-    use crate::config::NostrDiscoveryPolicy;
-    use crate::discovery::nostr::{NostrDiscovery, OverlayEndpointAdvert, OverlayTransportKind};
+    use crate::config::NostrRendezvousPolicy;
+    use crate::nostr::{NostrRendezvous, OverlayEndpointAdvert, OverlayTransportKind};
     use crate::peer::ActivePeer;
     use crate::transport::LinkId;
     use std::sync::Arc;
@@ -942,7 +942,7 @@ async fn test_open_discovery_sweep_queues_eligible_skips_filtered() {
     // Build node with open-discovery enabled.
     let mut config = crate::Config::new();
     config.node.rendezvous.nostr.enabled = true;
-    config.node.rendezvous.nostr.policy = NostrDiscoveryPolicy::Open;
+    config.node.rendezvous.nostr.policy = NostrRendezvousPolicy::Open;
     let mut node = crate::Node::new(config).unwrap();
 
     // Identity of an already-connected peer; insert into node.peers
@@ -965,8 +965,8 @@ async fn test_open_discovery_sweep_queues_eligible_skips_filtered() {
     let self_npub = crate::encode_npub(&node.identity().pubkey());
     let self_node_addr = *node.identity().node_addr();
 
-    // Build a NostrDiscovery test instance and inject the three adverts.
-    let bootstrap = Arc::new(NostrDiscovery::new_for_test());
+    // Build a NostrRendezvous test instance and inject the three adverts.
+    let bootstrap = Arc::new(NostrRendezvous::new_for_test());
     let endpoint = OverlayEndpointAdvert {
         transport: OverlayTransportKind::Udp,
         addr: "203.0.113.7:2121".to_string(),
@@ -977,7 +977,7 @@ async fn test_open_discovery_sweep_queues_eligible_skips_filtered() {
         .unwrap_or(0);
     for npub in [&eligible_npub, &connected_npub, &self_npub] {
         let advert =
-            NostrDiscovery::cached_advert_for_test(npub.clone(), endpoint.clone(), now_secs);
+            NostrRendezvous::cached_advert_for_test(npub.clone(), endpoint.clone(), now_secs);
         bootstrap.insert_advert_for_test(npub.clone(), advert).await;
     }
 

src/node/tests/unit.rs

@@ -1,5 +1,5 @@
 use super::*;
-use crate::discovery::nostr::{BootstrapEvent, NostrDiscovery};
+use crate::nostr::{BootstrapEvent, NostrRendezvous};
 use crate::peer::PromotionResult;
 use crate::transport::udp::UdpTransport;
 use crate::transport::{TransportHandle, packet_channel};
@@ -171,7 +171,7 @@ async fn test_node_start_does_not_wait_for_nostr_relay_startup() {
     config.node.control.enabled = false;
     config.node.rendezvous.nostr.enabled = true;
     config.node.rendezvous.nostr.advertise = true;
-    config.node.rendezvous.nostr.policy = crate::config::NostrDiscoveryPolicy::Open;
+    config.node.rendezvous.nostr.policy = crate::config::NostrRendezvousPolicy::Open;
     config.node.rendezvous.nostr.advert_relays = vec!["wss://127.0.0.1:9".to_string()];
     config.node.rendezvous.nostr.dm_relays = vec!["wss://127.0.0.1:9".to_string()];
     config.transports.udp = crate::config::TransportInstances::Single(crate::config::UdpConfig {
@@ -189,7 +189,7 @@ async fn test_node_start_does_not_wait_for_nostr_relay_startup() {
         .unwrap();
 
     assert!(node.is_running());
-    assert!(node.nostr_discovery_handle().is_some());
+    assert!(node.nostr_rendezvous_handle().is_some());
 
     node.stop().await.unwrap();
 }
@@ -1125,14 +1125,14 @@ async fn test_nostr_traversal_failure_skips_connected_peer() {
     node.promote_connection(link_id, peer_identity, 2000)
         .unwrap();
 
-    let bootstrap = Arc::new(NostrDiscovery::new_for_test());
+    let bootstrap = Arc::new(NostrRendezvous::new_for_test());
     bootstrap.push_event_for_test(BootstrapEvent::Failed {
         peer_config: crate::config::PeerConfig::new(peer_identity.npub(), "udp", "127.0.0.1:9"),
         reason: "stale traversal failure".to_string(),
     });
-    node.nostr_discovery = Some(bootstrap.clone());
+    node.nostr_rendezvous = Some(bootstrap.clone());
 
-    node.poll_nostr_discovery().await;
+    node.poll_nostr_rendezvous().await;
 
     assert!(
         bootstrap.failure_state_snapshot().is_empty(),
@@ -1146,7 +1146,7 @@ async fn test_nostr_traversal_failure_skips_connected_peer() {
 
 #[tokio::test]
 async fn test_nostr_traversal_established_skips_connected_peer() {
-    use crate::discovery::EstablishedTraversal;
+    use crate::nostr::EstablishedTraversal;
     use std::net::UdpSocket;
 
     let mut node = make_node();
@@ -1159,7 +1159,7 @@ async fn test_nostr_traversal_established_skips_connected_peer() {
     let link_count = node.link_count();
     let connection_count = node.connection_count();
 
-    let bootstrap = Arc::new(NostrDiscovery::new_for_test());
+    let bootstrap = Arc::new(NostrRendezvous::new_for_test());
     let socket = UdpSocket::bind("127.0.0.1:0").expect("bind local UDP socket");
     let remote_addr = "127.0.0.1:9999".parse().expect("parse remote addr");
     bootstrap.push_event_for_test(BootstrapEvent::Established {
@@ -1170,9 +1170,9 @@ async fn test_nostr_traversal_established_skips_connected_peer() {
             socket,
         ),
     });
-    node.nostr_discovery = Some(bootstrap.clone());
+    node.nostr_rendezvous = Some(bootstrap.clone());
 
-    node.poll_nostr_discovery().await;
+    node.poll_nostr_rendezvous().await;
 
     assert_eq!(
         node.link_count(),
@@ -1708,14 +1708,14 @@ async fn process_pending_retries_gated_at_capacity() {
 }
 
 #[tokio::test]
-async fn poll_nostr_discovery_established_gated_at_capacity() {
-    use crate::discovery::EstablishedTraversal;
+async fn poll_nostr_rendezvous_established_gated_at_capacity() {
+    use crate::nostr::EstablishedTraversal;
     use std::net::UdpSocket;
 
     let mut node = make_node_with_max_peers(2);
     inject_dummy_peers(&mut node, 2);
 
-    let bootstrap = Arc::new(NostrDiscovery::new_for_test());
+    let bootstrap = Arc::new(NostrRendezvous::new_for_test());
     let socket = UdpSocket::bind("127.0.0.1:0").expect("bind local UDP socket");
     let remote_addr = "127.0.0.1:9999".parse().expect("parse remote addr");
     let peer_identity = Identity::generate();
@@ -1727,13 +1727,13 @@ async fn poll_nostr_discovery_established_gated_at_capacity() {
             socket,
         ),
     });
-    node.nostr_discovery = Some(bootstrap.clone());
+    node.nostr_rendezvous = Some(bootstrap.clone());
 
     let before_peers = node.peer_count();
     let before_links = node.link_count();
     let before_connections = node.connection_count();
 
-    node.poll_nostr_discovery().await;
+    node.poll_nostr_rendezvous().await;
 
     assert_eq!(
         node.peer_count(),
@@ -1753,11 +1753,11 @@ async fn poll_nostr_discovery_established_gated_at_capacity() {
 }
 
 #[test]
-fn nostr_discovery_outbound_admission_atomic_roundtrip() {
+fn nostr_rendezvous_outbound_admission_atomic_roundtrip() {
     // Verifies the runtime-side plumbing for the two NAT-traversal gate
     // points: the setter mutates the atomic and the (super-visible)
     // reader observes the value the Node-side wiring would publish.
-    let bootstrap = NostrDiscovery::new_for_test();
+    let bootstrap = NostrRendezvous::new_for_test();
     assert!(
         bootstrap.outbound_admission_allowed(),
         "default must allow (start unsaturated)"