chore: remove CLAUDE.md and stale config files

core/archipelago/src/api/handler/node_message.rs

@@ -9,6 +9,7 @@ impl ApiHandler {
         #[derive(serde::Deserialize)]
         struct Incoming {
             from_pubkey: Option<String>,
+            from_name: Option<String>,
             message: Option<String>,
             signature: Option<String>,
             #[serde(default)]
@@ -67,7 +68,8 @@ impl ApiHandler {
             tracing::info!("Received message from {}: {}", safe_from, safe_msg);
             let clean_from = sanitize_html(from);
             let clean_msg = sanitize_html(&plaintext);
-            node_msg::store_received(&clean_from, &clean_msg).await;
+            let clean_name = incoming.from_name.as_deref().map(sanitize_html);
+            node_msg::store_received(&clean_from, &clean_msg, clean_name.as_deref()).await;
         }
         Ok(build_response(StatusCode::OK, "application/json", hyper::Body::from(r#"{"ok":true}"#)))
     }

core/archipelago/src/api/rpc/dispatcher.rs

@@ -288,6 +288,7 @@ impl RpcHandler {
             "mesh.peers" => self.handle_mesh_peers().await,
             "mesh.messages" => self.handle_mesh_messages(params).await,
             "mesh.send" => self.handle_mesh_send(params).await,
+            "mesh.send-channel" => self.handle_mesh_send_channel(params).await,
             "mesh.broadcast" => self.handle_mesh_broadcast().await,
             "mesh.configure" => self.handle_mesh_configure(params).await,
             "mesh.send-invoice" => self.handle_mesh_send_invoice(params).await,

core/archipelago/src/api/rpc/mesh/messaging.rs

@@ -40,6 +40,42 @@ impl RpcHandler {
         }))
     }
 
+    /// mesh.send-channel — Send a text message to a mesh channel (broadcast).
+    pub(in crate::api::rpc) async fn handle_mesh_send_channel(
+        &self,
+        params: Option<serde_json::Value>,
+    ) -> Result<serde_json::Value> {
+        let params = params.ok_or_else(|| anyhow::anyhow!("Missing params"))?;
+
+        let channel = params
+            .get("channel")
+            .and_then(|v| v.as_u64())
+            .unwrap_or(0) as u8;
+
+        let message = params
+            .get("message")
+            .and_then(|v| v.as_str())
+            .ok_or_else(|| anyhow::anyhow!("Missing message"))?;
+
+        if message.is_empty() {
+            anyhow::bail!("Message cannot be empty");
+        }
+
+        let service = self.mesh_service.read().await;
+        let svc = service
+            .as_ref()
+            .ok_or_else(|| anyhow::anyhow!("Mesh service not running. Enable mesh first."))?;
+
+        let msg = svc.send_channel_message(channel, message).await?;
+        info!(channel, "Sent mesh channel message");
+
+        Ok(serde_json::json!({
+            "sent": true,
+            "message_id": msg.id,
+            "channel": channel,
+        }))
+    }
+
     /// mesh.broadcast — Broadcast our node identity over mesh.
     pub(in crate::api::rpc) async fn handle_mesh_broadcast(&self) -> Result<serde_json::Value> {
         let service = self.mesh_service.read().await;

core/archipelago/src/api/rpc/peers.rs

@@ -101,12 +101,16 @@ impl RpcHandler {
                 || format!("{}.onion", n.onion) == onion)
             .map(|n| n.pubkey.clone());
 
+        // Include our node name so the recipient can display it
+        let node_name = data.server_info.name.clone();
+
         node_message::send_to_peer(
             onion,
             &pubkey,
             message,
             Some(node_id.signing_key()),
             recipient_pubkey.as_deref(),
+            node_name.as_deref(),
         ).await?;
         Ok(serde_json::json!({ "ok": true, "sent_to": onion }))
     }