refactor: align internal Rust names with proto/CLI naming convention

NodeApi trait methods, handler structs, and REST/MCP function names now
follow the same noun-verb pattern used by the management protocol and
CLI/REPL (e.g. hint_set, route_del, peer_disconnect). OpenAPI
operationIds updated to match (e.g. peersList, peerDisconnect,
infoGet). Stale comments referencing old names cleaned up.

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

Author: maxholman

crates/api/src/handlers.rs

@@ -29,9 +29,9 @@ pub struct StatsResponse {
     pub active_flows: u64,
 }
 
-/// Node status response.
+/// Node info response.
 #[derive(Debug, Serialize)]
-pub struct StatusResponse {
+pub struct InfoResponse {
     pub name: String,
     pub version: String,
     pub role: String,
@@ -133,9 +133,9 @@ pub struct PingResponseBody {
     pub role: String,
 }
 
-/// Set hint request body.
+/// Hint set request body.
 #[derive(Debug, Deserialize)]
-pub struct SetHintRequestBody {
+pub struct HintSetRequestBody {
     pub level: String,
     pub role: String,
 }
@@ -183,7 +183,7 @@ pub async fn events(
     )
 }
 
-pub async fn info(State(state): State<ApiState>) -> Result<Json<StatusResponse>, StatusCode> {
+pub async fn info(State(state): State<ApiState>) -> Result<Json<InfoResponse>, StatusCode> {
     let resp = state
         .ipc
         .lock()
@@ -195,7 +195,7 @@ pub async fn info(State(state): State<ApiState>) -> Result<Json<StatusResponse>,
     match resp.response {
         Some(management_response::Response::Info(s)) => {
             let role = s.role().to_string();
-            Ok(Json(StatusResponse {
+            Ok(Json(InfoResponse {
                 name: s.package_name,
                 version: s.version,
                 role,
@@ -280,7 +280,7 @@ pub async fn peers(State(state): State<ApiState>) -> Result<Json<PeersResponse>,
     }
 }
 
-pub async fn disconnect_peer(
+pub async fn peer_disconnect(
     State(state): State<ApiState>,
     Path(name): Path<String>,
 ) -> (StatusCode, Json<SuccessResponse>) {
@@ -644,7 +644,7 @@ pub async fn ping(State(state): State<ApiState>) -> Result<Json<PingResponseBody
     }
 }
 
-pub async fn ping_peer(
+pub async fn peer_ping(
     State(state): State<ApiState>,
     Path(peer): Path<String>,
 ) -> Result<Json<PingResponseBody>, StatusCode> {
@@ -704,9 +704,9 @@ pub async fn shutdown(State(state): State<ApiState>) -> (StatusCode, Json<Succes
     }
 }
 
-pub async fn set_hint(
+pub async fn hint_set(
     State(state): State<ApiState>,
-    Json(req): Json<SetHintRequestBody>,
+    Json(req): Json<HintSetRequestBody>,
 ) -> (StatusCode, Json<SuccessResponse>) {
     let level = match req.level.as_str() {
         "prefer" => HintLevel::Prefer,
@@ -787,7 +787,7 @@ pub async fn set_hint(
     }
 }
 
-pub async fn clear_hints(State(state): State<ApiState>) -> (StatusCode, Json<SuccessResponse>) {
+pub async fn hint_set_auto(State(state): State<ApiState>) -> (StatusCode, Json<SuccessResponse>) {
     let resp = state
         .ipc
         .lock()

crates/api/src/lib.rs

@@ -65,7 +65,7 @@ pub fn router(state: State) -> Router {
         .route("/info", get(handlers::info))
         .route("/stats", get(handlers::stats))
         .route("/peers", get(handlers::peers))
-        .route("/peers/{name}", delete(handlers::disconnect_peer))
+        .route("/peers/{name}", delete(handlers::peer_disconnect))
         .route(
             "/routes",
             get(handlers::list_routes).post(handlers::add_route),
@@ -76,11 +76,11 @@ pub fn router(state: State) -> Router {
         .route("/listen", post(handlers::listen))
         .route("/disconnect", post(handlers::disconnect))
         .route("/ping", get(handlers::ping))
-        .route("/ping/{peer}", get(handlers::ping_peer))
+        .route("/ping/{peer}", get(handlers::peer_ping))
         .route("/shutdown", post(handlers::shutdown))
         .route(
             "/hints",
-            put(handlers::set_hint).delete(handlers::clear_hints),
+            put(handlers::hint_set).delete(handlers::hint_set_auto),
         )
         .layer(middleware::from_fn(move |req, next| {
             let auth = auth.clone();

crates/core/src/control/handler.rs

@@ -33,8 +33,8 @@ struct NodeState {
 /// Shared node state handle, cloneable and cheaply updatable.
 ///
 /// Consumers call [`SharedNodeState::update_role`], [`SharedNodeState::update_capabilities`],
-/// etc. after negotiation or listening starts so that `wallhack info` /
-/// `wallhack_status` reflects the real state of the daemon.
+/// etc. after negotiation or listening starts so that `wallhack info`
+/// reflects the real state of the daemon.
 #[derive(Clone, Debug)]
 pub struct SharedNodeState(Arc<ArcSwap<NodeState>>);
 
@@ -148,7 +148,7 @@ impl Handler {
     /// Returns a handle to the shared node state.
     ///
     /// Callers (daemon modes) use this to update role, capabilities, and
-    /// listen/connect state after negotiation so that `status()` reports
+    /// listen/connect state after negotiation so that `info()` reports
     /// accurate information.
     #[must_use]
     pub fn node_state(&self) -> SharedNodeState {
@@ -396,9 +396,9 @@ impl crate::node_api::NodeApi for Handler {
         self.metrics.snapshot()
     }
 
-    fn status(&self) -> crate::node_api::NodeStatus {
+    fn info(&self) -> crate::node_api::NodeInfo {
         let state = self.state.load();
-        crate::node_api::NodeStatus {
+        crate::node_api::NodeInfo {
             role: state.role,
             peer_addr: state.peer_addr.clone(),
             capabilities: state.capabilities,
@@ -441,7 +441,7 @@ impl crate::node_api::NodeApi for Handler {
         Ok(())
     }
 
-    fn remove_route(&self, cidr: &crate::Cidr) -> crate::node_api::Result<()> {
+    fn route_del(&self, cidr: &crate::Cidr) -> crate::node_api::Result<()> {
         if let Some(entry) = self.routes.remove(cidr) {
             let _ = self
                 .route_updates
@@ -452,7 +452,7 @@ impl crate::node_api::NodeApi for Handler {
         }
     }
 
-    fn disconnect_peer(&self, peer: String) -> crate::node_api::Result<()> {
+    fn peer_disconnect(&self, peer: String) -> crate::node_api::Result<()> {
         // Try name prefix first, then fall back to exact address match.
         // Used by REPL/CLI where prefix matching is convenient.
         let peer_info = self.peers.find_by_prefix(&peer).or_else(|e| {
@@ -467,7 +467,7 @@ impl crate::node_api::NodeApi for Handler {
         Ok(())
     }
 
-    fn disconnect_peer_by_id(&self, id: String) -> crate::node_api::Result<()> {
+    fn peer_disconnect_by_id(&self, id: String) -> crate::node_api::Result<()> {
         // Exact match on registry key. Used by REST API where the id
         // is taken directly from the peers list.
         if self.peers.get(&id).is_none() {
@@ -481,12 +481,12 @@ impl crate::node_api::NodeApi for Handler {
         self.state.load().role
     }
 
-    fn set_hint(&self, hint: RoleHint) -> crate::node_api::Result<()> {
+    fn hint_set(&self, hint: RoleHint) -> crate::node_api::Result<()> {
         self.hint_tx.send_replace(Some(hint));
         Ok(())
     }
 
-    fn clear_hints(&self) -> crate::node_api::Result<()> {
+    fn hint_set_auto(&self) -> crate::node_api::Result<()> {
         self.hint_tx.send_replace(None);
         Ok(())
     }
@@ -738,7 +738,7 @@ mod tests {
     }
 
     #[test]
-    fn test_status_indeterminate_role() {
+    fn test_info_indeterminate_role() {
         let metrics = Arc::new(Metrics::default());
         let peers = Arc::new(Registry::new());
         let routes = RouteTable::shared();
@@ -754,7 +754,7 @@ mod tests {
             tokio::sync::broadcast::channel(16).0,
         );
 
-        let status = crate::node_api::NodeApi::status(&handler);
+        let status = crate::node_api::NodeApi::info(&handler);
         assert_eq!(status.role, NodeRole::Indeterminate);
     }
 
@@ -795,7 +795,7 @@ mod tests {
     }
 
     #[test]
-    fn test_status_reflects_node_state_updates() {
+    fn test_info_reflects_node_state_updates() {
         let handler = Handler::new(
             HandlerConfig::new(
                 NodeRole::Indeterminate,
@@ -809,7 +809,7 @@ mod tests {
         );
 
         // Initially indeterminate with no capabilities.
-        let status = crate::node_api::NodeApi::status(&handler);
+        let status = crate::node_api::NodeApi::info(&handler);
         assert_eq!(status.role, NodeRole::Indeterminate);
         assert!(!status.capabilities.tun_capable);
         assert!(!status.capabilities.listening);
@@ -825,15 +825,15 @@ mod tests {
             interactive: false,
         });
 
-        let status = crate::node_api::NodeApi::status(&handler);
+        let status = crate::node_api::NodeApi::info(&handler);
         assert_eq!(status.role, NodeRole::Entry);
         assert!(status.capabilities.tun_capable);
 
         // Simulate listen address being set.
         let addr: SocketAddr = "0.0.0.0:4433".parse().unwrap();
         state.set_listen_addr(addr);
 
-        let status = crate::node_api::NodeApi::status(&handler);
+        let status = crate::node_api::NodeApi::info(&handler);
         assert_eq!(status.listen_addr, Some(addr));
         assert!(status.capabilities.listening);
     }

crates/core/src/ipc.rs

@@ -290,7 +290,7 @@ fn dispatch_request(request: &ManagementRequest, api: &dyn NodeApi) -> Managemen
         Some(management_request::Request::Ping(req)) => {
             if req.peer.is_empty() {
                 // Ping the daemon itself
-                let status = api.status();
+                let status = api.info();
                 management_response::Response::Ping(PingResponse {
                     uptime_ms: status.uptime_ms,
                     version: status.version,
@@ -309,7 +309,7 @@ fn dispatch_request(request: &ManagementRequest, api: &dyn NodeApi) -> Managemen
         }
 
         Some(management_request::Request::Info(_)) => {
-            let s = api.status();
+            let s = api.info();
             management_response::Response::Info(InfoResponse {
                 role: management::NodeRole::from(s.role).into(),
                 connected: false, // deprecated — derive from peer count instead
@@ -366,7 +366,7 @@ fn dispatch_request(request: &ManagementRequest, api: &dyn NodeApi) -> Managemen
         },
 
         Some(management_request::Request::RouteDel(req)) => match req.cidr.parse() {
-            Ok(cidr) => match api.remove_route(&cidr) {
+            Ok(cidr) => match api.route_del(&cidr) {
                 Ok(()) => management_response::Response::Ok(OkResponse {}),
                 Err(e) => error_response(&e),
             },
@@ -378,9 +378,9 @@ fn dispatch_request(request: &ManagementRequest, api: &dyn NodeApi) -> Managemen
 
         Some(management_request::Request::PeerDisconnect(req)) => {
             let result = if req.exact {
-                api.disconnect_peer_by_id(req.peer.clone())
+                api.peer_disconnect_by_id(req.peer.clone())
             } else {
-                api.disconnect_peer(req.peer.clone())
+                api.peer_disconnect(req.peer.clone())
             };
             match result {
                 Ok(()) => management_response::Response::Ok(OkResponse {}),
@@ -430,13 +430,13 @@ fn dispatch_request(request: &ManagementRequest, api: &dyn NodeApi) -> Managemen
                 level: level.into(),
                 target: target.into(),
             };
-            match api.set_hint(hint) {
+            match api.hint_set(hint) {
                 Ok(()) => management_response::Response::Ok(OkResponse {}),
                 Err(e) => error_response(&e),
             }
         }
 
-        Some(management_request::Request::HintSetAuto(_)) => match api.clear_hints() {
+        Some(management_request::Request::HintSetAuto(_)) => match api.hint_set_auto() {
             Ok(()) => management_response::Response::Ok(OkResponse {}),
             Err(e) => error_response(&e),
         },

crates/core/src/node_api.rs

@@ -80,9 +80,9 @@ pub struct Metrics {
     pub packets_dropped: u64,
 }
 
-/// Overall node status information.
+/// Overall node info.
 #[derive(Debug, Clone)]
-pub struct NodeStatus {
+pub struct NodeInfo {
     /// Node's role.
     pub role: NodeRole,
     /// Peer address (if connected).
@@ -153,7 +153,7 @@ pub trait NodeApi: Send + Sync {
     /// Get list of directly connected peers.
     ///
     /// For entry nodes: returns all connected exit/relay nodes.
-    /// For exit nodes with relay capability: returns downstream connected nodes.
+    /// For exit nodes with relay capability: returns accepted peer connections.
     /// For standard exit nodes: returns empty (no peers).
     fn peers(&self) -> Vec<PeerInfo>;
 
@@ -165,8 +165,8 @@ pub trait NodeApi: Send + Sync {
     /// Get traffic and connection metrics.
     fn metrics(&self) -> Metrics;
 
-    /// Get overall node status.
-    fn status(&self) -> NodeStatus;
+    /// Get overall node info.
+    fn info(&self) -> NodeInfo;
 
     /// Connect to a peer.
     ///
@@ -197,30 +197,30 @@ pub trait NodeApi: Send + Sync {
     /// Peer must be directly connected.
     fn add_route(&self, cidr: Cidr, peer: String) -> Result<()>;
 
-    /// Remove a route by CIDR.
+    /// Delete a route by CIDR.
     ///
     /// Only supported on entry nodes. Returns error for exit/relay nodes.
-    fn remove_route(&self, cidr: &Cidr) -> Result<()>;
+    fn route_del(&self, cidr: &Cidr) -> Result<()>;
 
     /// Disconnect a specific peer by name prefix or address.
     ///
     /// Supports prefix matching for REPL/CLI convenience.
-    fn disconnect_peer(&self, peer: String) -> Result<()>;
+    fn peer_disconnect(&self, peer: String) -> Result<()>;
 
     /// Disconnect a specific peer by exact registry id.
     ///
     /// Used by the REST API where the id comes directly from the peers list.
-    fn disconnect_peer_by_id(&self, id: String) -> Result<()>;
+    fn peer_disconnect_by_id(&self, id: String) -> Result<()>;
 
     /// Get the current negotiated role.
     fn current_role(&self) -> NodeRole;
 
     /// Apply a role hint at runtime.
     ///
     /// Triggers re-negotiation if the node is in auto mode.
-    /// `role <target>` in the REPL is shorthand for `set_hint(Fixed, target)`.
-    fn set_hint(&self, hint: RoleHint) -> Result<()>;
+    /// `role <target>` in the REPL is shorthand for `hint_set(Fixed, target)`.
+    fn hint_set(&self, hint: RoleHint) -> Result<()>;
 
     /// Remove all hints (both startup and runtime).
-    fn clear_hints(&self) -> Result<()>;
+    fn hint_set_auto(&self) -> Result<()>;
 }

crates/daemon/src/mode/mod.rs

@@ -115,7 +115,7 @@ pub(crate) fn spawn_heartbeat(
     peer_name: String,
     peers: Arc<Registry>,
 ) -> tokio::task::JoinHandle<()> {
-    // Register control channel so disconnect_peer can send messages to this peer.
+    // Register control channel so peer_disconnect can send messages to this peer.
     peers.register_control(&peer_name, &control_tx);
 
     tokio::spawn(async move {

crates/mcp/src/tools.rs

@@ -42,7 +42,7 @@ pub struct AddrParams {
 }
 
 #[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
-pub struct SetHintParams {
+pub struct HintSetParams {
     /// Hint level: "prefer", "exclude", or "fixed"
     pub level: String,
     /// Target role: "entry", "exit", or "relay"
@@ -117,7 +117,7 @@ impl WallhackServer {
         .await
     }
 
-    #[tool(description = "Remove a route by CIDR")]
+    #[tool(description = "Delete a route by CIDR")]
     async fn route_del(
         &self,
         Parameters(params): Parameters<RouteDelParams>,
@@ -183,7 +183,7 @@ impl WallhackServer {
     )]
     async fn hint_set(
         &self,
-        Parameters(params): Parameters<SetHintParams>,
+        Parameters(params): Parameters<HintSetParams>,
     ) -> Result<String, rmcp::ErrorData> {
         let level = match params.level.as_str() {
             "prefer" => HintLevel::Prefer,