Merge meshroller-50: mesh-AI assistant (#50) into release train

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

@@ -397,6 +397,11 @@ impl RpcHandler {
             "mesh.deadman-status" => self.handle_mesh_deadman_status().await,
             "mesh.deadman-configure" => self.handle_mesh_deadman_configure(params).await,
             "mesh.deadman-checkin" => self.handle_mesh_deadman_checkin().await,
+            "mesh.assistant-status" => self.handle_mesh_assistant_status().await,
+            "mesh.assistant-configure" => self.handle_mesh_assistant_configure(params).await,
+            "mesh.schedule-message" => self.handle_mesh_schedule_message(params).await,
+            "mesh.list-scheduled" => self.handle_mesh_list_scheduled().await,
+            "mesh.cancel-scheduled" => self.handle_mesh_cancel_scheduled(params).await,
             "mesh.test-send" => self.handle_mesh_test_send(params).await,
 
             // Transport layer (unified routing)

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

@@ -0,0 +1,169 @@
+//! Mesh-AI assistant RPCs (issue #50): read/update the local assistant config
+//! and report whether a local Ollama is available (for the install deep-link).
+
+use super::super::RpcHandler;
+use anyhow::Result;
+use std::time::Duration;
+
+/// Default model when the node hasn't picked one (kept in sync with the mesh
+/// assistant handler's `DEFAULT_MODEL`).
+const DEFAULT_MODEL: &str = "qwen2.5-coder";
+
+impl RpcHandler {
+    /// mesh.assistant-status — current settings + local Ollama availability.
+    pub(in crate::api::rpc) async fn handle_mesh_assistant_status(
+        &self,
+    ) -> Result<serde_json::Value> {
+        let cfg = {
+            let service = self.mesh_service.read().await;
+            let svc = service
+                .as_ref()
+                .ok_or_else(|| anyhow::anyhow!("Mesh service not running"))?;
+            svc.assistant_config().await
+        };
+
+        let (ollama_detected, models) = detect_ollama().await;
+        let claude_available = tokio::fs::metadata(
+            self.config.data_dir.join("secrets/claude-api-key"),
+        )
+        .await
+        .is_ok();
+        Ok(serde_json::json!({
+            "enabled": cfg.enabled,
+            "model": cfg.model,
+            "trusted_only": cfg.trusted_only,
+            "backend": cfg.backend,
+            "default_model": DEFAULT_MODEL,
+            "ollama_detected": ollama_detected,
+            "claude_available": claude_available,
+            "models": models,
+        }))
+    }
+
+    /// mesh.assistant-configure — update assistant settings live.
+    /// Params: `enabled?: bool`, `trusted_only?: bool`,
+    /// `model?: string|null` (string sets, null clears to default, absent leaves).
+    pub(in crate::api::rpc) async fn handle_mesh_assistant_configure(
+        &self,
+        params: Option<serde_json::Value>,
+    ) -> Result<serde_json::Value> {
+        let params = params.unwrap_or_default();
+        let service = self.mesh_service.read().await;
+        let svc = service
+            .as_ref()
+            .ok_or_else(|| anyhow::anyhow!("Mesh service not running"))?;
+
+        let enabled = params.get("enabled").and_then(|v| v.as_bool());
+        let trusted_only = params.get("trusted_only").and_then(|v| v.as_bool());
+        let backend = params
+            .get("backend")
+            .and_then(|v| v.as_str())
+            .map(|s| s.to_string());
+        // model: key present + string => set; present + null => clear; absent => leave
+        let model = if let Some(v) = params.get("model") {
+            Some(v.as_str().map(|s| s.to_string()))
+        } else {
+            None
+        };
+
+        svc.configure_assistant(enabled, model, trusted_only, backend)
+            .await?;
+        let cfg = svc.assistant_config().await;
+        Ok(serde_json::json!({
+            "enabled": cfg.enabled,
+            "model": cfg.model,
+            "trusted_only": cfg.trusted_only,
+            "backend": cfg.backend,
+        }))
+    }
+
+    /// mesh.schedule-message — queue a message to send at a future time.
+    /// Params: `body: string`, `fire_at: i64` (unix secs), and one of
+    /// `contact_id: u32` (DM) or `channel: u8` (broadcast).
+    pub(in crate::api::rpc) async fn handle_mesh_schedule_message(
+        &self,
+        params: Option<serde_json::Value>,
+    ) -> Result<serde_json::Value> {
+        let p = params.ok_or_else(|| anyhow::anyhow!("Missing params"))?;
+        let body = p
+            .get("body")
+            .and_then(|v| v.as_str())
+            .ok_or_else(|| anyhow::anyhow!("body is required"))?
+            .to_string();
+        let fire_at = p
+            .get("fire_at")
+            .and_then(|v| v.as_i64())
+            .ok_or_else(|| anyhow::anyhow!("fire_at (unix seconds) is required"))?;
+        let contact_id = p.get("contact_id").and_then(|v| v.as_u64()).map(|v| v as u32);
+        let channel = p.get("channel").and_then(|v| v.as_u64()).map(|v| v as u8);
+        if contact_id.is_none() && channel.is_none() {
+            anyhow::bail!("either contact_id or channel is required");
+        }
+
+        let service = self.mesh_service.read().await;
+        let svc = service
+            .as_ref()
+            .ok_or_else(|| anyhow::anyhow!("Mesh service not running"))?;
+        let msg = svc.scheduler.add(contact_id, channel, body, fire_at).await?;
+        Ok(serde_json::to_value(msg)?)
+    }
+
+    /// mesh.list-scheduled — list queued messages (sorted by fire time).
+    pub(in crate::api::rpc) async fn handle_mesh_list_scheduled(
+        &self,
+    ) -> Result<serde_json::Value> {
+        let service = self.mesh_service.read().await;
+        let svc = service
+            .as_ref()
+            .ok_or_else(|| anyhow::anyhow!("Mesh service not running"))?;
+        let messages = svc.scheduler.list().await;
+        Ok(serde_json::json!({ "messages": messages }))
+    }
+
+    /// mesh.cancel-scheduled — remove a queued message by id.
+    pub(in crate::api::rpc) async fn handle_mesh_cancel_scheduled(
+        &self,
+        params: Option<serde_json::Value>,
+    ) -> Result<serde_json::Value> {
+        let id = params
+            .as_ref()
+            .and_then(|p| p.get("id"))
+            .and_then(|v| v.as_u64())
+            .ok_or_else(|| anyhow::anyhow!("id is required"))?;
+        let service = self.mesh_service.read().await;
+        let svc = service
+            .as_ref()
+            .ok_or_else(|| anyhow::anyhow!("Mesh service not running"))?;
+        let cancelled = svc.scheduler.cancel(id).await?;
+        Ok(serde_json::json!({ "cancelled": cancelled }))
+    }
+}
+
+/// Probe the local Ollama HTTP API; return (detected, model_names).
+async fn detect_ollama() -> (bool, Vec<String>) {
+    let client = match reqwest::Client::builder()
+        .timeout(Duration::from_secs(2))
+        .build()
+    {
+        Ok(c) => c,
+        Err(_) => return (false, Vec::new()),
+    };
+    match client.get("http://localhost:11434/api/tags").send().await {
+        Ok(resp) if resp.status().is_success() => {
+            let json: serde_json::Value = resp.json().await.unwrap_or_default();
+            let models = json
+                .get("models")
+                .and_then(|m| m.as_array())
+                .map(|arr| {
+                    arr.iter()
+                        .filter_map(|m| {
+                            m.get("name").and_then(|n| n.as_str()).map(|s| s.to_string())
+                        })
+                        .collect()
+                })
+                .unwrap_or_default();
+            (true, models)
+        }
+        _ => (false, Vec::new()),
+    }
+}

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

@@ -1,3 +1,4 @@
+mod assistant;
 mod bitcoin_ops;
 mod messaging;
 mod safety;

core/archipelago/src/mesh/listener/assist.rs

@@ -0,0 +1,347 @@
+//! Mesh-AI assistant (issue #50) — answers `AssistQuery` messages with this
+//! node's local LLM and sends the reply back over the mesh.
+//!
+//! This is the Rust-native lift of Meshroller's "LLM bridge": a trusted peer
+//! asks a question over meshcore, an internet/compute-bearing node runs it
+//! through a local model (Ollama) and streams the answer back in capped,
+//! ordered chunks. Airtime is scarce, so the reply is length-capped and each
+//! asker is limited to one in-flight query.
+
+use super::super::message_types::{self, AssistResponsePayload, MeshMessageType};
+use super::bitcoin::send_to_peer;
+use super::{MeshCommand, MeshState};
+use crate::federation::TrustLevel;
+use std::path::Path;
+use std::sync::Arc;
+use std::time::Duration;
+use tracing::{info, warn};
+
+/// Local Ollama generate endpoint (same host the Ollama app binds).
+const OLLAMA_URL: &str = "http://localhost:11434/api/generate";
+/// Default model when the node hasn't configured one (matches Meshroller).
+const DEFAULT_MODEL: &str = "qwen2.5-coder";
+/// Anthropic Messages API (called with the shared proxy token).
+const CLAUDE_URL: &str = "https://api.anthropic.com/v1/messages";
+/// Default Claude model — Haiku 4.5: fast + cheap, ideal for short mesh answers.
+const CLAUDE_DEFAULT_MODEL: &str = "claude-haiku-4-5-20251001";
+/// Max time to wait on the model before giving up.
+const OLLAMA_TIMEOUT: Duration = Duration::from_secs(60);
+/// Hard cap on answer length sent over the radio — keeps airtime sane.
+const MAX_REPLY_CHARS: usize = 480;
+/// Characters of answer text per `AssistResponse` chunk.
+const CHUNK_CHARS: usize = 160;
+/// Tighter cap for plain-text channel replies (bare `!ai` clients) — these
+/// aren't reassembled by an archipelago UI, so keep them to a couple frames.
+const CHANNEL_REPLY_CHARS: usize = 200;
+
+/// Where an answer should go.
+pub(super) enum AssistReply {
+    /// Typed `AssistResponse` chunks addressed to one peer — the archipelago
+    /// UI path (rich, reassembled, correlated by `req_id`).
+    Typed { contact_id: u32 },
+    /// Plain-text broadcast on a mesh channel — the bare `!ai` path, so any
+    /// client (including non-archipelago meshcore/Meshtastic nodes) sees it.
+    ChannelText { channel: u8 },
+}
+
+/// Entry point: gate the query, run the model, send the answer back via the
+/// requested reply path. Spawned off the radio loop so it never blocks.
+pub(super) async fn run_assist(
+    prompt: String,
+    model_override: Option<String>,
+    req_id: u64,
+    asker_contact_id: u32,
+    sender_name: String,
+    reply: AssistReply,
+    state: Arc<MeshState>,
+) {
+    let asker = asker_contact_id;
+
+    // Trust + block gate.
+    if !is_sender_allowed(&state, asker).await {
+        warn!(
+            from = asker,
+            name = %sender_name,
+            "AssistQuery denied — sender not permitted by assistant policy"
+        );
+        // Silent on the wire (no airtime spent on denials); surface to the UI.
+        let _ = state.event_tx.send(super::super::types::MeshEvent::AssistResponseReady {
+            req_id,
+            to_contact_id: asker,
+            error: Some("denied".to_string()),
+        });
+        return;
+    }
+
+    // One in-flight query per asker.
+    {
+        let mut inflight = state.assist_inflight.write().await;
+        if !inflight.insert(asker) {
+            warn!(from = asker, "AssistQuery dropped — asker already has one in flight");
+            return;
+        }
+    }
+
+    let _ = state.event_tx.send(super::super::types::MeshEvent::AssistQueryReceived {
+        from_contact_id: asker,
+        prompt: prompt.clone(),
+    });
+
+    let (backend, configured_model) = {
+        let a = state.assistant.read().await;
+        (a.backend.clone(), a.model.clone())
+    };
+    let is_claude = backend == "claude";
+    let default_model = if is_claude { CLAUDE_DEFAULT_MODEL } else { DEFAULT_MODEL };
+    let model = model_override
+        .or(configured_model)
+        .unwrap_or_else(|| default_model.to_string());
+
+    info!(from = asker, req_id, backend = %backend, model = %model, "Answering AI query over mesh");
+
+    let result = if is_claude {
+        call_claude(&state.data_dir, &model, &prompt).await
+    } else {
+        call_ollama(&model, &prompt).await
+    };
+
+    match result {
+        Ok(answer) => {
+            send_reply(&state, &reply, req_id, &answer).await;
+            let _ = state.event_tx.send(super::super::types::MeshEvent::AssistResponseReady {
+                req_id,
+                to_contact_id: asker,
+                error: None,
+            });
+        }
+        Err(e) => {
+            warn!(req_id, "AI query failed: {}", e);
+            send_failure(&state, &reply, req_id, "AI unavailable").await;
+            let _ = state.event_tx.send(super::super::types::MeshEvent::AssistResponseReady {
+                req_id,
+                to_contact_id: asker,
+                error: Some(e.to_string()),
+            });
+        }
+    }
+
+    state.assist_inflight.write().await.remove(&asker);
+}
+
+/// Whether `sender_contact_id` may invoke the assistant under the node's policy.
+/// Always denies user-blocked contacts. With `trusted_only`, requires a
+/// federation-Trusted match on the peer's pubkey or DID.
+async fn is_sender_allowed(state: &Arc<MeshState>, sender_contact_id: u32) -> bool {
+    let (pubkey_hex, did) = {
+        let peers = state.peers.read().await;
+        match peers.get(&sender_contact_id) {
+            Some(p) => (p.pubkey_hex.clone(), p.did.clone()),
+            None => (None, None),
+        }
+    };
+
+    // Never answer a user-blocked contact, regardless of policy.
+    if let Some(ref pk) = pubkey_hex {
+        if state
+            .contacts
+            .read()
+            .await
+            .get(pk)
+            .map(|c| c.blocked)
+            .unwrap_or(false)
+        {
+            return false;
+        }
+    }
+
+    if !state.assistant.read().await.trusted_only {
+        return true;
+    }
+
+    // Trusted-only: match against the federation trust list.
+    let nodes = crate::federation::load_nodes(&state.data_dir)
+        .await
+        .unwrap_or_default();
+    nodes.iter().any(|n| {
+        n.trust_level == TrustLevel::Trusted
+            && (Some(&n.pubkey) == pubkey_hex.as_ref() || Some(&n.did) == did.as_ref())
+    })
+}
+
+/// Cap the answer to `MAX_REPLY_CHARS`, appending a marker when truncated.
+/// Returns (text_to_send, was_truncated).
+fn cap_reply(answer: &str) -> (String, bool) {
+    let trimmed = answer.trim();
+    if trimmed.chars().count() <= MAX_REPLY_CHARS {
+        return (trimmed.to_string(), false);
+    }
+    let capped: String = trimmed.chars().take(MAX_REPLY_CHARS).collect();
+    (format!("{capped}…(truncated)"), true)
+}
+
+/// Send a successful answer via the requested reply path.
+async fn send_reply(state: &Arc<MeshState>, reply: &AssistReply, req_id: u64, answer: &str) {
+    match reply {
+        AssistReply::Typed { contact_id } => {
+            let (text, _) = cap_reply(answer);
+            send_typed_chunks(state, *contact_id, req_id, &text).await;
+        }
+        AssistReply::ChannelText { channel } => {
+            let text = cap_channel(answer);
+            send_channel_text(state, *channel, &text).await;
+        }
+    }
+}
+
+/// Send a failure notice via the requested reply path.
+async fn send_failure(state: &Arc<MeshState>, reply: &AssistReply, req_id: u64, msg: &str) {
+    match reply {
+        AssistReply::Typed { contact_id } => {
+            let payload = AssistResponsePayload {
+                req_id,
+                text: String::new(),
+                seq: 0,
+                done: true,
+                error: Some(msg.to_string()),
+            };
+            send_typed_response(state, *contact_id, &payload).await;
+        }
+        AssistReply::ChannelText { channel } => {
+            send_channel_text(state, *channel, &format!("AI: {msg}")).await;
+        }
+    }
+}
+
+/// Split the answer into ordered `AssistResponse` chunks and send each back to
+/// the asker on the encrypted, peer-addressed path (archipelago UI path).
+async fn send_typed_chunks(state: &Arc<MeshState>, dest_contact_id: u32, req_id: u64, text: &str) {
+    let chars: Vec<char> = text.chars().collect();
+    let chunks: Vec<String> = if chars.is_empty() {
+        vec![String::new()]
+    } else {
+        chars.chunks(CHUNK_CHARS).map(|c| c.iter().collect()).collect()
+    };
+    let last = chunks.len().saturating_sub(1);
+    for (i, chunk) in chunks.into_iter().enumerate() {
+        let payload = AssistResponsePayload {
+            req_id,
+            text: chunk,
+            seq: i as u16,
+            done: i == last,
+            error: None,
+        };
+        send_typed_response(state, dest_contact_id, &payload).await;
+    }
+}
+
+/// Encode an `AssistResponse` payload and send it to a peer.
+async fn send_typed_response(
+    state: &Arc<MeshState>,
+    dest_contact_id: u32,
+    payload: &AssistResponsePayload,
+) {
+    let bytes = match message_types::encode_payload(payload) {
+        Ok(b) => b,
+        Err(e) => {
+            warn!("Failed to encode AssistResponse: {}", e);
+            return;
+        }
+    };
+    let envelope = message_types::TypedEnvelope::new(MeshMessageType::AssistResponse, bytes);
+    match envelope.to_wire() {
+        Ok(wire) => send_to_peer(state, dest_contact_id, wire).await,
+        Err(e) => warn!("Failed to encode AssistResponse envelope: {}", e),
+    }
+}
+
+/// Broadcast a plain-text answer on a channel for bare `!ai` clients.
+async fn send_channel_text(state: &Arc<MeshState>, channel: u8, text: &str) {
+    let _ = state
+        .send_cmd(MeshCommand::BroadcastChannel {
+            channel,
+            payload: text.as_bytes().to_vec(),
+        })
+        .await;
+}
+
+/// Cap a plain-text channel reply to a couple of frames.
+fn cap_channel(answer: &str) -> String {
+    let trimmed = answer.trim();
+    if trimmed.chars().count() <= CHANNEL_REPLY_CHARS {
+        return format!("AI: {trimmed}");
+    }
+    let capped: String = trimmed.chars().take(CHANNEL_REPLY_CHARS).collect();
+    format!("AI: {capped}…")
+}
+
+/// Call the local Ollama model and return the generated text.
+async fn call_ollama(model: &str, prompt: &str) -> anyhow::Result<String> {
+    let client = reqwest::Client::builder().timeout(OLLAMA_TIMEOUT).build()?;
+    let body = serde_json::json!({
+        "model": model,
+        "prompt": prompt,
+        "stream": false,
+    });
+    let resp = client.post(OLLAMA_URL).json(&body).send().await?;
+    if !resp.status().is_success() {
+        anyhow::bail!("Ollama returned HTTP {}", resp.status());
+    }
+    let json: serde_json::Value = resp.json().await?;
+    let text = json
+        .get("response")
+        .and_then(|r| r.as_str())
+        .unwrap_or("")
+        .to_string();
+    if text.trim().is_empty() {
+        anyhow::bail!("Ollama returned an empty response");
+    }
+    Ok(text)
+}
+
+/// Call Claude via the Anthropic Messages API using the node's shared proxy
+/// token at `secrets/claude-api-key`. Keeps answers short for radio airtime.
+async fn call_claude(data_dir: &Path, model: &str, prompt: &str) -> anyhow::Result<String> {
+    let key = tokio::fs::read_to_string(data_dir.join("secrets/claude-api-key"))
+        .await
+        .map_err(|_| anyhow::anyhow!("Claude API key not configured on this node"))?;
+    let key = key.trim();
+    if key.is_empty() {
+        anyhow::bail!("Claude API key is empty");
+    }
+    let client = reqwest::Client::builder().timeout(OLLAMA_TIMEOUT).build()?;
+    let body = serde_json::json!({
+        "model": model,
+        "max_tokens": 512,
+        "system": "You answer questions over a low-bandwidth radio mesh. Reply in at most two short sentences. No markdown, no preamble.",
+        "messages": [{ "role": "user", "content": prompt }],
+    });
+    let resp = client
+        .post(CLAUDE_URL)
+        .header("x-api-key", key)
+        .header("anthropic-version", "2023-06-01")
+        .header("content-type", "application/json")
+        .json(&body)
+        .send()
+        .await?;
+    if !resp.status().is_success() {
+        let status = resp.status();
+        let txt = resp.text().await.unwrap_or_default();
+        anyhow::bail!(
+            "Claude API HTTP {}: {}",
+            status,
+            txt.chars().take(180).collect::<String>()
+        );
+    }
+    let json: serde_json::Value = resp.json().await?;
+    // `content` is an array of blocks; take the first text block.
+    let text = json
+        .get("content")
+        .and_then(|c| c.as_array())
+        .and_then(|arr| arr.iter().find_map(|b| b.get("text").and_then(|t| t.as_str())))
+        .unwrap_or("")
+        .to_string();
+    if text.trim().is_empty() {
+        anyhow::bail!("Claude returned an empty response");
+    }
+    Ok(text)
+}

core/archipelago/src/mesh/listener/bitcoin.rs

@@ -445,7 +445,9 @@ async fn encrypt_for_peer(state: &Arc<MeshState>, contact_id: u32, typed_wire: &
 /// Send raw wire bytes to a specific peer by contact_id.
 /// Encrypts directed messages via ratchet or shared secret when available.
 /// Falls back to channel 0 broadcast (plaintext) if peer's pubkey is unknown.
-async fn send_to_peer(state: &Arc<MeshState>, contact_id: u32, typed_wire: Vec<u8>) {
+/// `pub(super)` so sibling handlers (e.g. the AI assistant) can reply on the
+/// same encrypted, peer-addressed path the relay handlers use.
+pub(super) async fn send_to_peer(state: &Arc<MeshState>, contact_id: u32, typed_wire: Vec<u8>) {
     let peers = state.peers.read().await;
     if let Some(peer) = peers.get(&contact_id) {
         if let Some(ref pk) = peer.pubkey_hex {

core/archipelago/src/mesh/listener/decode.rs

@@ -352,6 +352,45 @@ pub(super) async fn store_plain_message(
     state.store_message(msg.clone()).await;
     state.status.write().await.messages_received += 1;
     let _ = state.event_tx.send(MeshEvent::MessageReceived(msg));
+
+    // Mesh-AI assistant (issue #50): a plain `!ai`/`!ask <question>` on the
+    // channel is answered by this node's local model when the assistant is on.
+    // Reply goes back as plain channel text so bare (non-archipelago) clients
+    // see it. The trust/rate gate lives in run_assist.
+    if state.assistant.read().await.enabled {
+        if let Some(prompt) = strip_ai_trigger(text) {
+            if !prompt.is_empty() {
+                let req_id = state.next_id().await;
+                let prompt = prompt.to_string();
+                let name = peer_name.to_string();
+                let st = Arc::clone(state);
+                tokio::spawn(async move {
+                    super::assist::run_assist(
+                        prompt,
+                        None,
+                        req_id,
+                        contact_id,
+                        name,
+                        super::assist::AssistReply::ChannelText { channel: 0 },
+                        st,
+                    )
+                    .await;
+                });
+            }
+        }
+    }
+}
+
+/// Recognise a `!ai`/`!ask ` command prefix (case-insensitive) and return the
+/// trimmed question after it, or `None` if the text isn't an AI command.
+fn strip_ai_trigger(text: &str) -> Option<&str> {
+    let t = text.trim_start();
+    for p in ["!ai ", "!ask "] {
+        if t.len() >= p.len() && t[..p.len()].eq_ignore_ascii_case(p) {
+            return Some(t[p.len()..].trim());
+        }
+    }
+    None
 }
 
 /// Handle a received identity broadcast from a peer.

core/archipelago/src/mesh/listener/dispatch.rs

@@ -681,6 +681,80 @@ pub(crate) async fn handle_typed_envelope_direct(
             .await;
         }
 
+        Some(MeshMessageType::AssistQuery) => {
+            match message_types::decode_payload::<message_types::AssistQueryPayload>(&envelope.v) {
+                Ok(query) => {
+                    if !state.assistant.read().await.enabled {
+                        debug!(
+                            from = sender_contact_id,
+                            "AssistQuery ignored — assistant disabled on this node"
+                        );
+                        return;
+                    }
+                    info!(
+                        from = sender_contact_id,
+                        req_id = query.req_id,
+                        "AI query received over mesh"
+                    );
+                    let json = payload_to_json(&query);
+                    store_typed_message(
+                        state,
+                        sender_contact_id,
+                        sender_name,
+                        &query.prompt,
+                        "assist_query",
+                        json,
+                        Some(envelope.seq),
+                    )
+                    .await;
+                    // Run the model + reply off the radio loop. Typed query →
+                    // typed chunked reply back to the asking peer.
+                    let assist_state = Arc::clone(state);
+                    let name = sender_name.to_string();
+                    tokio::spawn(async move {
+                        super::assist::run_assist(
+                            query.prompt,
+                            query.model,
+                            query.req_id,
+                            sender_contact_id,
+                            name,
+                            super::assist::AssistReply::Typed {
+                                contact_id: sender_contact_id,
+                            },
+                            assist_state,
+                        )
+                        .await;
+                    });
+                }
+                Err(e) => warn!("Failed to decode AssistQuery payload: {}", e),
+            }
+        }
+
+        Some(MeshMessageType::AssistResponse) => {
+            match message_types::decode_payload::<message_types::AssistResponsePayload>(&envelope.v)
+            {
+                Ok(resp) => {
+                    let display = resp
+                        .error
+                        .clone()
+                        .map(|e| format!("AI error: {e}"))
+                        .unwrap_or_else(|| resp.text.clone());
+                    let json = payload_to_json(&resp);
+                    store_typed_message(
+                        state,
+                        sender_contact_id,
+                        sender_name,
+                        &display,
+                        "assist_response",
+                        json,
+                        Some(envelope.seq),
+                    )
+                    .await;
+                }
+                Err(e) => warn!("Failed to decode AssistResponse payload: {}", e),
+            }
+        }
+
         _ => {
             debug!(
                 msg_type = ?msg_type,

core/archipelago/src/mesh/listener/frames.rs

@@ -3,8 +3,8 @@
 use super::super::message_types::TypedEnvelope;
 use super::super::protocol;
 use super::decode::{
-    is_mc_chunk_frame, resolve_peer, store_plain_message, try_base64_typed, try_chunk_reassemble,
+    handle_identity_received, is_mc_chunk_frame, resolve_peer, store_plain_message,
-    try_decrypt_base64, try_decrypt_ratchet_base64,
+    try_base64_typed, try_chunk_reassemble, try_decrypt_base64, try_decrypt_ratchet_base64,
 };
 use super::dispatch::handle_typed_message;
 use super::MeshState;
@@ -18,7 +18,6 @@ pub(super) async fn handle_frame(
     state: &Arc<MeshState>,
     our_x25519_secret: &[u8; 32],
 ) -> bool {
-    let _ = our_x25519_secret; // reserved for future per-frame decryption
     match frame.code {
         protocol::PUSH_NEW_CONTACT | protocol::PUSH_CONTACT_ADVERT => {
             info!(
@@ -109,7 +108,8 @@ pub(super) async fn handle_frame(
             match protocol::parse_channel_msg_v3_raw(&frame.data) {
                 Ok((channel_idx, payload)) => {
                     if !payload.is_empty() {
-                        handle_channel_payload(state, channel_idx, &payload).await;
+                        handle_channel_payload(state, channel_idx, &payload, our_x25519_secret)
+                            .await;
                     }
                 }
                 Err(e) => warn!("Failed to parse v3 channel message: {}", e),
@@ -121,7 +121,8 @@ pub(super) async fn handle_frame(
             match protocol::parse_channel_msg_v1_raw(&frame.data) {
                 Ok((channel_idx, payload)) => {
                     if !payload.is_empty() {
-                        handle_channel_payload(state, channel_idx, &payload).await;
+                        handle_channel_payload(state, channel_idx, &payload, our_x25519_secret)
+                            .await;
                     }
                 }
                 Err(e) => warn!("Failed to parse channel message: {}", e),
@@ -146,7 +147,12 @@ pub(super) async fn handle_frame(
 /// local mesh peer pubkeys (or we can't tell), the inner payload is
 /// dispatched through the direct-message path so it lands in the right
 /// chat. Otherwise it's handled as a normal channel text/typed message.
-async fn handle_channel_payload(state: &Arc<MeshState>, channel_idx: u8, payload: &[u8]) {
+async fn handle_channel_payload(
+    state: &Arc<MeshState>,
+    channel_idx: u8,
+    payload: &[u8],
+    our_x25519_secret: &[u8; 32],
+) {
     // DM-via-channel wrapper (text form): the channel text carries an
     // ASCII "@DM:<base64>" token somewhere in the body. We locate the
     // marker anywhere in the payload (the firmware auto-prepends the
@@ -326,6 +332,36 @@ async fn handle_channel_payload(state: &Arc<MeshState>, channel_idx: u8, payload
         return;
     }
 
+    // Archipelago identity broadcast (`ARCHY:`): upsert the sender's real
+    // archipelago identity (DID + ed25519 + x25519) so trust-gating and
+    // encrypted DMs work over BOTH meshcore and Meshtastic — the latter
+    // otherwise only exposes synthetic node keys. Keyed by the archipelago
+    // pubkey (federation_peer_contact_id) so it MERGES with the federation-
+    // seeded peer instead of creating a duplicate chat thread. Not stored as
+    // a chat message.
+    if let Ok(text) = std::str::from_utf8(payload) {
+        if let Some((did, ed_hex, x_hex)) =
+            super::super::protocol::parse_identity_broadcast(text)
+        {
+            // Ignore our own identity echoed back by the radio/channel.
+            if ed_hex.eq_ignore_ascii_case(&state.our_ed_pubkey_hex) {
+                return;
+            }
+            let contact_id = super::super::federation_peer_contact_id(&ed_hex);
+            handle_identity_received(
+                contact_id,
+                0,
+                &did,
+                &ed_hex,
+                &x_hex,
+                state,
+                our_x25519_secret,
+            )
+            .await;
+            return;
+        }
+    }
+
     // Regular channel broadcast (not DM-wrapped)
     let chan_contact_id = u32::MAX - (channel_idx as u32);
     let chan_name = format!("Channel {}", channel_idx);

core/archipelago/src/mesh/listener/mod.rs

@@ -7,6 +7,7 @@
 //! - Reconnects on device disconnect
 //! - Manages peer cache and message store
 
+mod assist;
 mod bitcoin;
 mod decode;
 pub(crate) mod dispatch;
@@ -123,6 +124,30 @@ pub struct MeshState {
     /// persistent contact table from regenerating rows the user just
     /// wiped. Persisted to `mesh-ignored-radio-contacts.json`.
     pub radio_contact_blocklist: RwLock<HashSet<String>>,
+    /// Mesh-AI assistant settings (issue #50): whether this node answers
+    /// AssistQuery messages with its local LLM, and who may ask. Live-updatable
+    /// so the UI toggle applies without restarting the listener.
+    pub assistant: RwLock<AssistantConfig>,
+    /// Data dir — lets dispatch handlers reach disk-backed stores (e.g. the
+    /// federation trust list used to gate AI queries) without threading a path
+    /// through every call.
+    pub data_dir: std::path::PathBuf,
+    /// Contact-ids with an AI query currently being answered. Caps each asker to
+    /// one in-flight query so a peer can't flood the node's compute / airtime.
+    pub assist_inflight: RwLock<HashSet<u32>>,
+}
+
+/// Mesh-AI assistant configuration, snapshotted from `MeshConfig` at startup.
+#[derive(Debug, Clone)]
+pub struct AssistantConfig {
+    /// Answer AssistQuery messages with the local LLM.
+    pub enabled: bool,
+    /// Model to use; None → the backend's built-in default.
+    pub model: Option<String>,
+    /// Restrict asking to federation-Trusted peers (vs. anyone on the mesh).
+    pub trusted_only: bool,
+    /// AI backend: "claude" (shared proxy token) or "ollama" (local model).
+    pub backend: String,
 }
 
 /// Contact metadata kept alongside MeshState.peers. Pinned contacts sort to
@@ -156,6 +181,8 @@ impl MeshState {
         receive_block_headers: bool,
         session_manager: Arc<super::session::SessionManager>,
         our_ed_pubkey_hex: String,
+        assistant: AssistantConfig,
+        data_dir: std::path::PathBuf,
     ) -> (
         Arc<Self>,
         broadcast::Receiver<MeshEvent>,
@@ -196,6 +223,9 @@ impl MeshState {
             our_ed_pubkey_hex,
             blob_store: RwLock::new(None),
             radio_contact_blocklist: RwLock::new(HashSet::new()),
+            assistant: RwLock::new(assistant),
+            data_dir,
+            assist_inflight: RwLock::new(HashSet::new()),
         });
         (state, rx, cmd_rx)
     }

core/archipelago/src/mesh/listener/session.rs

@@ -363,9 +363,9 @@ pub(super) async fn run_mesh_session(
     state: &Arc<MeshState>,
     preferred_path: Option<&str>,
     our_did: &str,
-    _our_ed_pubkey_hex: &str,
+    our_ed_pubkey_hex: &str,
     our_x25519_secret: &[u8; 32],
-    _our_x25519_pubkey_hex: &str,
+    our_x25519_pubkey_hex: &str,
     server_name: Option<&str>,
     shutdown: &mut tokio::sync::watch::Receiver<bool>,
     cmd_rx: &mut mpsc::Receiver<MeshCommand>,
@@ -424,6 +424,19 @@ pub(super) async fn run_mesh_session(
         warn!("Failed to send initial advert: {}", e);
     }
 
+    // Archipelago identity advert (`ARCHY:2:{ed}:{x25519}`): broadcast as channel
+    // text so peers can bind our radio presence to our DID + keys. The firmware
+    // advert alone carries the meshcore key (and nothing on Meshtastic), so this
+    // is what makes trust-gating + encrypted DMs work across BOTH transports.
+    let identity_advert = super::super::protocol::encode_identity_broadcast(
+        our_did,
+        our_ed_pubkey_hex,
+        our_x25519_pubkey_hex,
+    );
+    if let Err(e) = device.send_channel_text(0, identity_advert.as_bytes()).await {
+        warn!("Failed to broadcast archipelago identity: {}", e);
+    }
+
     // Fetch existing contacts from the device
     refresh_contacts(&mut device, state).await;
 
@@ -491,6 +504,11 @@ pub(super) async fn run_mesh_session(
                 } else {
                     consecutive_write_failures = 0;
                 }
+                // Re-broadcast archipelago identity so peers that joined since
+                // startup (or missed it) can bind our DID/keys.
+                if let Err(e) = device.send_channel_text(0, identity_advert.as_bytes()).await {
+                    warn!("Failed to re-broadcast archipelago identity: {}", e);
+                }
                 refresh_contacts(&mut device, state).await;
             }
 

core/archipelago/src/mesh/message_types.rs

@@ -70,6 +70,12 @@ pub enum MeshMessageType {
     /// MCIIXXTT framing) and the peer has no Tor path. Recipient writes the
     /// bytes to its local BlobStore on reassembly.
     ContentInline = 23,
+    /// "Ask the node's AI" — a prompt to be answered by the receiving node's
+    /// local LLM (issue #50). Gated by the assistant config + trust policy.
+    AssistQuery = 24,
+    /// Reply to an AssistQuery — a chunk of the LLM's answer, addressed back to
+    /// the asker by `req_id`. Long answers span multiple chunks (`seq`/`done`).
+    AssistResponse = 25,
 }
 
 impl MeshMessageType {
@@ -99,6 +105,8 @@ impl MeshMessageType {
             21 => Some(Self::ChannelInvite),
             22 => Some(Self::ContactCard),
             23 => Some(Self::ContentInline),
+            24 => Some(Self::AssistQuery),
+            25 => Some(Self::AssistResponse),
             _ => None,
         }
     }
@@ -132,6 +140,8 @@ impl MeshMessageType {
             "channel_invite" => Some(Self::ChannelInvite),
             "contact_card" => Some(Self::ContactCard),
             "content_inline" => Some(Self::ContentInline),
+            "assist_query" => Some(Self::AssistQuery),
+            "assist_response" => Some(Self::AssistResponse),
             _ => None,
         }
     }
@@ -162,6 +172,8 @@ impl MeshMessageType {
             Self::ChannelInvite => "channel_invite",
             Self::ContactCard => "contact_card",
             Self::ContentInline => "content_inline",
+            Self::AssistQuery => "assist_query",
+            Self::AssistResponse => "assist_response",
         }
     }
 }
@@ -407,6 +419,37 @@ pub struct LightningRelayPayload {
     pub request_id: u64,
 }
 
+/// "Ask the node's AI" request (issue #50). Sent to a peer running a local
+/// LLM; answered with one or more `AssistResponsePayload` chunks.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AssistQueryPayload {
+    /// Asker-chosen id correlating the query with its response chunks.
+    pub req_id: u64,
+    /// The natural-language prompt.
+    pub prompt: String,
+    /// Optional model override; falls back to the responder's configured model.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub model: Option<String>,
+}
+
+/// One chunk of an AI answer, addressed back to the asker by `req_id`.
+/// Airtime is scarce, so long answers are capped and split into ordered chunks.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AssistResponsePayload {
+    pub req_id: u64,
+    /// This chunk's text.
+    pub text: String,
+    /// 0-based chunk index.
+    #[serde(default)]
+    pub seq: u16,
+    /// True on the final chunk.
+    #[serde(default)]
+    pub done: bool,
+    /// Set instead of `text` when the query failed (model unreachable, denied…).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+
 /// Lightning relay response (proof of payment).
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct LightningRelayResponsePayload {

core/archipelago/src/mesh/mod.rs

@@ -14,6 +14,7 @@ pub mod message_types;
 pub mod outbox;
 pub mod protocol;
 pub mod ratchet;
+pub mod scheduler;
 pub mod serial;
 pub mod session;
 pub mod steganography;
@@ -180,6 +181,26 @@ pub struct MeshConfig {
     /// Set to false to disable encryption for debugging or rollback.
     #[serde(default = "default_true")]
     pub encrypt_relay_messages: bool,
+    /// Answer AI queries (AssistQuery) from peers using this node's local LLM
+    /// (issue #50). Off by default — the node only becomes a mesh AI on opt-in.
+    #[serde(default)]
+    pub assistant_enabled: bool,
+    /// Ollama model used to answer AI queries. None → the built-in default.
+    #[serde(default)]
+    pub assistant_model: Option<String>,
+    /// When true (default), only federation-Trusted peers may ask; when false,
+    /// any peer on the mesh may ask (spends this node's compute + airtime).
+    #[serde(default = "default_true")]
+    pub assistant_trusted_only: bool,
+    /// Which AI backend answers queries: "claude" (the shared Claude proxy
+    /// token at secrets/claude-api-key — default for now, works without a
+    /// local GPU) or "ollama" (a local model on this node).
+    #[serde(default = "default_assistant_backend")]
+    pub assistant_backend: String,
+}
+
+fn default_assistant_backend() -> String {
+    "claude".to_string()
 }
 
 fn default_true() -> bool {
@@ -199,6 +220,10 @@ impl Default for MeshConfig {
             receive_block_headers: true,
             steganography_mode: steganography::SteganographyMode::Normal,
             encrypt_relay_messages: true,
+            assistant_enabled: false,
+            assistant_model: None,
+            assistant_trusted_only: true,
+            assistant_backend: default_assistant_backend(),
         }
     }
 }
@@ -327,6 +352,7 @@ pub struct MeshService {
     deadman_handle: Option<tokio::task::JoinHandle<()>>,
     block_announcer_handle: Option<tokio::task::JoinHandle<()>>,
     presence_handle: Option<tokio::task::JoinHandle<()>>,
+    scheduler_handle: Option<tokio::task::JoinHandle<()>>,
     cmd_rx: Option<tokio::sync::mpsc::Receiver<listener::MeshCommand>>,
     // Crypto identity for this node
     our_did: String,
@@ -340,6 +366,8 @@ pub struct MeshService {
     pub block_header_cache: Arc<BlockHeaderCache>,
     pub relay_tracker: Arc<RelayTracker>,
     pub dead_man_switch: Arc<DeadManSwitch>,
+    /// Scheduled / queued outbound mesh messages (issue #50, phase 1.7).
+    pub scheduler: Arc<scheduler::MeshScheduler>,
 }
 
 impl MeshService {
@@ -368,6 +396,13 @@ impl MeshService {
             config.receive_block_headers,
             Arc::clone(&session_manager),
             ed_pubkey_hex.to_string(),
+            listener::AssistantConfig {
+                enabled: config.assistant_enabled,
+                model: config.assistant_model.clone(),
+                trusted_only: config.assistant_trusted_only,
+                backend: config.assistant_backend.clone(),
+            },
+            data_dir.to_path_buf(),
         );
 
         // Derive X25519 keys from Ed25519 identity
@@ -424,6 +459,7 @@ impl MeshService {
             deadman_handle: None,
             block_announcer_handle: None,
             presence_handle: None,
+            scheduler_handle: None,
             cmd_rx: Some(cmd_rx),
             our_did: did.to_string(),
             our_ed_pubkey_hex: ed_pubkey_hex.to_string(),
@@ -434,6 +470,7 @@ impl MeshService {
             block_header_cache,
             relay_tracker,
             dead_man_switch,
+            scheduler: Arc::new(scheduler::MeshScheduler::load(data_dir).await),
         })
     }
 
@@ -511,6 +548,20 @@ impl MeshService {
         });
         self.deadman_handle = Some(dms_handle);
 
+        // Scheduled-message task (issue #50, phase 1.7): fires queued messages
+        // when due, retrying peer DMs until the peer is back in range.
+        let sched = Arc::clone(&self.scheduler);
+        let sched_state = Arc::clone(&self.state);
+        let sched_shutdown = self
+            .shutdown_tx
+            .as_ref()
+            .ok_or_else(|| anyhow::anyhow!("Shutdown channel not initialized"))?
+            .subscribe();
+        let sched_handle = tokio::spawn(async move {
+            scheduler::run_scheduler(sched, sched_state, sched_shutdown).await;
+        });
+        self.scheduler_handle = Some(sched_handle);
+
         // Spawn block header announcer (internet-connected nodes only)
         if self.config.announce_block_headers {
             let bha_state = Arc::clone(&self.state);
@@ -661,6 +712,10 @@ impl MeshService {
             handle.abort();
             let _ = handle.await;
         }
+        if let Some(handle) = self.scheduler_handle.take() {
+            handle.abort();
+            let _ = handle.await;
+        }
         if let Some(handle) = self.block_announcer_handle.take() {
             handle.abort();
             let _ = handle.await;
@@ -1332,6 +1387,51 @@ impl MeshService {
         Ok(())
     }
 
+    /// Current mesh-AI assistant settings (issue #50).
+    pub async fn assistant_config(&self) -> listener::AssistantConfig {
+        self.state.assistant.read().await.clone()
+    }
+
+    /// Update the mesh-AI assistant settings live (no listener restart) and
+    /// persist them to the mesh config. `model: Some(None)` clears the override
+    /// (falls back to the built-in default); `None` leaves a field unchanged.
+    pub async fn configure_assistant(
+        &self,
+        enabled: Option<bool>,
+        model: Option<Option<String>>,
+        trusted_only: Option<bool>,
+        backend: Option<String>,
+    ) -> Result<()> {
+        {
+            let mut a = self.state.assistant.write().await;
+            if let Some(e) = enabled {
+                a.enabled = e;
+            }
+            if let Some(m) = model {
+                a.model = m;
+            }
+            if let Some(t) = trusted_only {
+                a.trusted_only = t;
+            }
+            if let Some(b) = backend {
+                a.backend = b;
+            }
+        }
+        // Persist by updating the on-disk config (the in-memory `self.config`
+        // snapshot stays as-is; the live `state.assistant` is the runtime
+        // source of truth and is re-seeded from disk on the next start).
+        let mut cfg = load_config(&self.data_dir).await.unwrap_or_default();
+        {
+            let a = self.state.assistant.read().await;
+            cfg.assistant_enabled = a.enabled;
+            cfg.assistant_model = a.model.clone();
+            cfg.assistant_trusted_only = a.trusted_only;
+            cfg.assistant_backend = a.backend.clone();
+        }
+        save_config(&self.data_dir, &cfg).await?;
+        Ok(())
+    }
+
     /// Update mesh configuration.
     pub async fn configure(&mut self, config: MeshConfig) -> Result<()> {
         save_config(&self.data_dir, &config).await?;

core/archipelago/src/mesh/scheduler.rs

@@ -0,0 +1,213 @@
+//! Scheduled / queued mesh messages (issue #50, phase 1.7).
+//!
+//! A small persisted queue of messages to send at a future time. A background
+//! task fires due messages via the listener. A message addressed to a peer that
+//! isn't currently in the contact table stays queued and retries on later ticks
+//! — i.e. it sends itself when the peer comes back in range.
+
+use super::listener::{MeshCommand, MeshState};
+use anyhow::{Context, Result};
+use serde::{Deserialize, Serialize};
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use tokio::fs;
+use tokio::sync::{watch, RwLock};
+use tracing::warn;
+
+const SCHEDULER_FILE: &str = "mesh-scheduled.json";
+/// Wake interval for firing due messages.
+const TICK_SECS: u64 = 10;
+/// Drop a still-undeliverable message after this many attempts (~1h at 10s).
+const MAX_ATTEMPTS: u32 = 360;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ScheduledMessage {
+    pub id: u64,
+    /// Direct-message target (peer contact_id), or None for a channel broadcast.
+    #[serde(default)]
+    pub contact_id: Option<u32>,
+    /// Channel to broadcast on, or None for a direct message.
+    #[serde(default)]
+    pub channel: Option<u8>,
+    pub body: String,
+    /// Unix seconds when the message becomes due.
+    pub fire_at: i64,
+    #[serde(default)]
+    pub attempts: u32,
+}
+
+pub struct MeshScheduler {
+    path: PathBuf,
+    queue: RwLock<Vec<ScheduledMessage>>,
+    next_id: RwLock<u64>,
+}
+
+impl MeshScheduler {
+    pub async fn load(data_dir: &Path) -> Self {
+        let path = data_dir.join(SCHEDULER_FILE);
+        let queue: Vec<ScheduledMessage> = match fs::read_to_string(&path).await {
+            Ok(s) => serde_json::from_str(&s).unwrap_or_default(),
+            Err(_) => Vec::new(),
+        };
+        let next = queue.iter().map(|m| m.id).max().unwrap_or(0) + 1;
+        Self {
+            path,
+            queue: RwLock::new(queue),
+            next_id: RwLock::new(next),
+        }
+    }
+
+    async fn save(&self) -> Result<()> {
+        let json = {
+            let q = self.queue.read().await;
+            serde_json::to_string_pretty(&*q).context("serialize scheduled queue")?
+        };
+        if let Some(parent) = self.path.parent() {
+            fs::create_dir_all(parent).await.ok();
+        }
+        fs::write(&self.path, json)
+            .await
+            .context("write scheduled queue")?;
+        Ok(())
+    }
+
+    pub async fn add(
+        &self,
+        contact_id: Option<u32>,
+        channel: Option<u8>,
+        body: String,
+        fire_at: i64,
+    ) -> Result<ScheduledMessage> {
+        let id = {
+            let mut n = self.next_id.write().await;
+            let id = *n;
+            *n += 1;
+            id
+        };
+        let msg = ScheduledMessage {
+            id,
+            contact_id,
+            channel,
+            body,
+            fire_at,
+            attempts: 0,
+        };
+        self.queue.write().await.push(msg.clone());
+        self.save().await?;
+        Ok(msg)
+    }
+
+    pub async fn list(&self) -> Vec<ScheduledMessage> {
+        let mut v = self.queue.read().await.clone();
+        v.sort_by_key(|m| m.fire_at);
+        v
+    }
+
+    pub async fn cancel(&self, id: u64) -> Result<bool> {
+        let removed = {
+            let mut q = self.queue.write().await;
+            let before = q.len();
+            q.retain(|m| m.id != id);
+            q.len() != before
+        };
+        if removed {
+            self.save().await?;
+        }
+        Ok(removed)
+    }
+}
+
+/// Background loop: every `TICK_SECS`, fire any due messages.
+pub async fn run_scheduler(
+    scheduler: Arc<MeshScheduler>,
+    state: Arc<MeshState>,
+    mut shutdown: watch::Receiver<bool>,
+) {
+    let mut interval = tokio::time::interval(std::time::Duration::from_secs(TICK_SECS));
+    loop {
+        tokio::select! {
+            _ = interval.tick() => fire_due(&scheduler, &state).await,
+            _ = shutdown.changed() => {
+                if *shutdown.borrow() { return; }
+            }
+        }
+    }
+}
+
+async fn fire_due(scheduler: &Arc<MeshScheduler>, state: &Arc<MeshState>) {
+    let now = chrono::Utc::now().timestamp();
+    let due: Vec<ScheduledMessage> = scheduler
+        .queue
+        .read()
+        .await
+        .iter()
+        .filter(|m| m.fire_at <= now)
+        .cloned()
+        .collect();
+    if due.is_empty() {
+        return;
+    }
+
+    let mut delivered: Vec<u64> = Vec::new();
+    let mut failed: Vec<u64> = Vec::new();
+    for msg in &due {
+        if try_send(state, msg).await {
+            delivered.push(msg.id);
+        } else {
+            failed.push(msg.id);
+        }
+    }
+
+    let mut to_remove = delivered;
+    {
+        let mut q = scheduler.queue.write().await;
+        for m in q.iter_mut() {
+            if failed.contains(&m.id) {
+                m.attempts += 1;
+                if m.attempts >= MAX_ATTEMPTS {
+                    warn!(id = m.id, attempts = m.attempts, "Dropping undeliverable scheduled message");
+                    to_remove.push(m.id);
+                }
+            }
+        }
+        q.retain(|m| !to_remove.contains(&m.id));
+    }
+    let _ = scheduler.save().await;
+}
+
+/// Hand a due message to the radio. Returns true if it was sent (or should be
+/// dropped); false to keep it queued for a later retry (peer not in range yet).
+async fn try_send(state: &Arc<MeshState>, msg: &ScheduledMessage) -> bool {
+    let payload = msg.body.clone().into_bytes();
+    if let Some(channel) = msg.channel {
+        return state
+            .send_cmd(MeshCommand::BroadcastChannel { channel, payload })
+            .await
+            .is_ok();
+    }
+    if let Some(contact_id) = msg.contact_id {
+        let pubkey = {
+            let peers = state.peers.read().await;
+            peers.get(&contact_id).and_then(|p| p.pubkey_hex.clone())
+        };
+        if let Some(pk) = pubkey {
+            if let Ok(bytes) = hex::decode(&pk) {
+                if bytes.len() >= 6 {
+                    let mut dest = [0u8; 6];
+                    dest.copy_from_slice(&bytes[..6]);
+                    return state
+                        .send_cmd(MeshCommand::SendText {
+                            dest_pubkey_prefix: dest,
+                            payload,
+                        })
+                        .await
+                        .is_ok();
+                }
+            }
+        }
+        // Peer unknown / not in range yet — keep queued, retry next tick.
+        return false;
+    }
+    warn!("Scheduled message has neither channel nor contact_id — dropping");
+    true
+}

core/archipelago/src/mesh/types.rs

@@ -161,4 +161,15 @@ pub enum MeshEvent {
         payment_hash: Option<String>,
         error: Option<String>,
     },
+    /// An AI query arrived from a peer and was accepted for answering (#50).
+    AssistQueryReceived {
+        from_contact_id: u32,
+        prompt: String,
+    },
+    /// A local-AI answer finished sending back to the asker (or failed) (#50).
+    AssistResponseReady {
+        req_id: u64,
+        to_contact_id: u32,
+        error: Option<String>,
+    },
 }

neode-ui/src/stores/mesh.ts

@@ -125,6 +125,26 @@ export interface BlockHeader {
   announced_by: string
 }
 
+export interface AssistantStatus {
+  enabled: boolean
+  model: string | null
+  trusted_only: boolean
+  backend: string
+  default_model: string
+  ollama_detected: boolean
+  claude_available: boolean
+  models: string[]
+}
+
+export interface ScheduledMessage {
+  id: number
+  contact_id: number | null
+  channel: number | null
+  body: string
+  fire_at: number
+  attempts: number
+}
+
 export interface NodePosition {
   lat: number
   lng: number
@@ -577,6 +597,59 @@ export const useMeshStore = defineStore('mesh', () => {
   const blockHeaders = ref<BlockHeader[]>([])
   const latestBlockHeight = ref(0)
 
+  // Mesh-AI assistant (issue #50)
+  const assistantStatus = ref<AssistantStatus | null>(null)
+
+  async function fetchAssistantStatus() {
+    try {
+      assistantStatus.value = await rpcClient.call<AssistantStatus>({ method: 'mesh.assistant-status' })
+    } catch {
+      // Assistant not available (mesh service down)
+    }
+  }
+
+  async function configureAssistant(config: {
+    enabled?: boolean
+    model?: string | null
+    trusted_only?: boolean
+    backend?: string
+  }) {
+    const res = await rpcClient.call<Partial<AssistantStatus>>({
+      method: 'mesh.assistant-configure',
+      params: config,
+    })
+    await fetchAssistantStatus()
+    return res
+  }
+
+  // Scheduled / queued mesh messages (issue #50, phase 1.7)
+  const scheduledMessages = ref<ScheduledMessage[]>([])
+
+  async function fetchScheduledMessages() {
+    try {
+      const res = await rpcClient.call<{ messages: ScheduledMessage[] }>({ method: 'mesh.list-scheduled' })
+      scheduledMessages.value = res.messages || []
+    } catch {
+      scheduledMessages.value = []
+    }
+  }
+
+  async function scheduleMessage(params: {
+    contact_id?: number
+    channel?: number
+    body: string
+    fire_at: number
+  }) {
+    const res = await rpcClient.call<ScheduledMessage>({ method: 'mesh.schedule-message', params })
+    await fetchScheduledMessages()
+    return res
+  }
+
+  async function cancelScheduledMessage(id: number) {
+    await rpcClient.call({ method: 'mesh.cancel-scheduled', params: { id } })
+    await fetchScheduledMessages()
+  }
+
   async function fetchDeadmanStatus() {
     try {
       deadmanStatus.value = await rpcClient.call<AlertStatus>({ method: 'mesh.deadman-status' })
@@ -696,6 +769,13 @@ export const useMeshStore = defineStore('mesh', () => {
     fetchDeadmanStatus,
     configureDeadman,
     deadmanCheckin,
+    assistantStatus,
+    fetchAssistantStatus,
+    configureAssistant,
+    scheduledMessages,
+    fetchScheduledMessages,
+    scheduleMessage,
+    cancelScheduledMessage,
     fetchBlockHeaders,
     relayTransaction,
     relayLightning,

neode-ui/src/views/Mesh.vue

@@ -8,6 +8,7 @@ import AnimatedLogo from '@/components/AnimatedLogo.vue'
 import MeshMap from '@/components/MeshMap.vue'
 import MeshBitcoinPanel from '@/views/mesh/MeshBitcoinPanel.vue'
 import MeshDeadmanPanel from '@/views/mesh/MeshDeadmanPanel.vue'
+import MeshAssistantPanel from '@/views/mesh/MeshAssistantPanel.vue'
 import { rpcClient } from '@/api/rpc-client'
 import { wsClient } from '@/api/websocket'
 import '@/views/mesh/mesh-styles.css'
@@ -255,10 +256,10 @@ async function clearAllMesh() {
 }
 
 // Phase 4: Off-grid Bitcoin + Dead Man's Switch
-const activeTab = ref<'chat' | 'bitcoin' | 'deadman' | 'map'>('chat')
+const activeTab = ref<'chat' | 'bitcoin' | 'deadman' | 'assistant' | 'map'>('chat')
 
 // Tools tab for 3rd column on wide desktop and mobile below-chat
-const toolsTab = ref<'bitcoin' | 'deadman' | 'map'>('bitcoin')
+const toolsTab = ref<'bitcoin' | 'deadman' | 'assistant' | 'map'>('bitcoin')
 
 // Panel visibility computeds
 const showChatPanel = computed(() =>
@@ -276,6 +277,12 @@ const showDeadmanPanel = computed(() => {
   if (isMobile.value && !mobileShowChat.value) return toolsTab.value === 'deadman'
   return activeTab.value === 'deadman'
 })
+const showAssistantPanel = computed(() => {
+  if (isVeryWideDesktop.value) return true
+  if (isWideDesktop.value) return toolsTab.value === 'assistant'
+  if (isMobile.value && !mobileShowChat.value) return toolsTab.value === 'assistant'
+  return activeTab.value === 'assistant'
+})
 const showMapPanel = computed(() => {
   if (isVeryWideDesktop.value) return true
   if (isWideDesktop.value) return toolsTab.value === 'map'
@@ -1489,17 +1496,16 @@ function isImageMime(mime?: string): boolean {
         <!-- Tab bar (medium desktop only) -->
         <div v-if="showTabBar" class="mesh-tab-bar">
           <button class="mesh-tab" :class="{ active: activeTab === 'chat' }" @click="activeTab = 'chat'">Chat</button>
-          <button class="mesh-tab" :class="{ active: activeTab === 'bitcoin' }" @click="activeTab = 'bitcoin'">
+          <button class="mesh-tab" :class="{ active: activeTab === 'bitcoin' }" @click="activeTab = 'bitcoin'">Bitcoin</button>
-            Off-Grid Bitcoin
-            <span v-if="mesh.latestBlockHeight > 0" class="mesh-tab-badge">{{ mesh.latestBlockHeight }}</span>
-          </button>
           <button class="mesh-tab" :class="{ active: activeTab === 'deadman' }" @click="activeTab = 'deadman'">
             Dead Man
             <span v-if="mesh.deadmanStatus?.triggered" class="mesh-tab-badge mesh-tab-badge-alert">!</span>
           </button>
+          <button class="mesh-tab" :class="{ active: activeTab === 'assistant' }" @click="activeTab = 'assistant'">
+            AI
+          </button>
           <button class="mesh-tab" :class="{ active: activeTab === 'map' }" @click="activeTab = 'map'">
             Map
-            <span v-if="mesh.nodePositions.size > 0" class="mesh-tab-badge">{{ mesh.nodePositions.size }}</span>
           </button>
         </div>
 
@@ -1775,21 +1781,19 @@ function isImageMime(mime?: string): boolean {
         <!-- Tools panels (3rd column on wide screens) -->
         <div class="mesh-tools-wrapper" data-controller-zone="mesh-tools">
           <div v-if="isWideDesktop && !isVeryWideDesktop" class="mesh-tools-tab-bar">
-            <button class="mesh-tab" :class="{ active: toolsTab === 'bitcoin' }" @click="toolsTab = 'bitcoin'">
+            <button class="mesh-tab" :class="{ active: toolsTab === 'bitcoin' }" @click="toolsTab = 'bitcoin'">Bitcoin</button>
-              Off-Grid Bitcoin
-              <span v-if="mesh.latestBlockHeight > 0" class="mesh-tab-badge">{{ mesh.latestBlockHeight }}</span>
-            </button>
             <button class="mesh-tab" :class="{ active: toolsTab === 'deadman' }" @click="toolsTab = 'deadman'">
               Dead Man
               <span v-if="mesh.deadmanStatus?.triggered" class="mesh-tab-badge mesh-tab-badge-alert">!</span>
             </button>
-            <button class="mesh-tab" :class="{ active: toolsTab === 'map' }" @click="toolsTab = 'map'">
+            <button class="mesh-tab" :class="{ active: toolsTab === 'assistant' }" @click="toolsTab = 'assistant'">
-              Map
+              AI
-              <span v-if="mesh.nodePositions.size > 0" class="mesh-tab-badge">{{ mesh.nodePositions.size }}</span>
             </button>
+            <button class="mesh-tab" :class="{ active: toolsTab === 'map' }" @click="toolsTab = 'map'">Map</button>
           </div>
           <MeshBitcoinPanel v-if="showBitcoinPanel" />
           <MeshDeadmanPanel v-if="showDeadmanPanel" />
+          <MeshAssistantPanel v-if="showAssistantPanel" />
           <div v-if="showMapPanel" class="glass-card mesh-map-panel"><MeshMap /></div>
         </div>
       </div>
@@ -1797,22 +1801,20 @@ function isImageMime(mime?: string): boolean {
       <!-- Mobile tools: show under peers list on first view -->
       <div v-if="showMobileTools" class="mesh-mobile-tools">
         <div class="mesh-tools-tab-bar">
-          <button class="mesh-tab" :class="{ active: toolsTab === 'bitcoin' }" @click="toolsTab = 'bitcoin'">
+          <button class="mesh-tab" :class="{ active: toolsTab === 'bitcoin' }" @click="toolsTab = 'bitcoin'">Bitcoin</button>
-            Off-Grid Bitcoin
-            <span v-if="mesh.latestBlockHeight > 0" class="mesh-tab-badge">{{ mesh.latestBlockHeight }}</span>
-          </button>
           <button class="mesh-tab" :class="{ active: toolsTab === 'deadman' }" @click="toolsTab = 'deadman'">
             Dead Man
             <span v-if="mesh.deadmanStatus?.triggered" class="mesh-tab-badge mesh-tab-badge-alert">!</span>
           </button>
-          <button class="mesh-tab" :class="{ active: toolsTab === 'map' }" @click="toolsTab = 'map'">
+          <button class="mesh-tab" :class="{ active: toolsTab === 'assistant' }" @click="toolsTab = 'assistant'">
-            Map
+            AI
-            <span v-if="mesh.nodePositions.size > 0" class="mesh-tab-badge">{{ mesh.nodePositions.size }}</span>
           </button>
+          <button class="mesh-tab" :class="{ active: toolsTab === 'map' }" @click="toolsTab = 'map'">Map</button>
         </div>
         <div v-if="showMapPanel" class="glass-card mesh-map-panel"><MeshMap /></div>
         <MeshBitcoinPanel v-if="showBitcoinPanel" />
         <MeshDeadmanPanel v-if="showDeadmanPanel" />
+        <MeshAssistantPanel v-if="showAssistantPanel" />
       </div>
     </div>
 

neode-ui/src/views/mesh/MeshAssistantPanel.vue

@@ -0,0 +1,155 @@
+<script setup lang="ts">
+import { ref, computed, watch, onMounted } from 'vue'
+import { useMeshStore } from '@/stores/mesh'
+import ToggleSwitch from '@/components/ToggleSwitch.vue'
+
+const mesh = useMeshStore()
+const saving = ref(false)
+
+const status = computed(() => mesh.assistantStatus)
+const enabled = ref(false)
+const model = ref('') // '' = use the backend's default model
+const policy = ref<'trusted' | 'anyone'>('trusted')
+const backend = ref<'claude' | 'ollama'>('claude')
+
+// Sync local controls from the fetched status.
+watch(
+  status,
+  (s) => {
+    if (!s) return
+    enabled.value = s.enabled
+    model.value = s.model ?? ''
+    policy.value = s.trusted_only ? 'trusted' : 'anyone'
+    backend.value = s.backend === 'ollama' ? 'ollama' : 'claude'
+  },
+  { immediate: true },
+)
+
+onMounted(() => {
+  mesh.fetchAssistantStatus()
+})
+
+const claudeReady = computed(() => status.value?.claude_available ?? false)
+const ollamaReady = computed(() => status.value?.ollama_detected ?? false)
+const availableModels = computed(() => status.value?.models ?? [])
+const defaultModel = computed(() =>
+  backend.value === 'claude' ? 'Claude Haiku 4.5' : status.value?.default_model ?? 'qwen2.5-coder',
+)
+// The selected backend is usable when its provider is available.
+const backendReady = computed(() =>
+  backend.value === 'claude' ? claudeReady.value : ollamaReady.value,
+)
+
+async function apply(partial: {
+  enabled?: boolean
+  model?: string | null
+  trusted_only?: boolean
+  backend?: string
+}) {
+  saving.value = true
+  try {
+    await mesh.configureAssistant(partial)
+  } finally {
+    saving.value = false
+  }
+}
+
+function onToggle(val: boolean) {
+  enabled.value = val
+  apply({ enabled: val })
+}
+function onBackend() {
+  // Reset the model override when switching backend (models differ).
+  model.value = ''
+  apply({ backend: backend.value, model: null })
+}
+function onModel() {
+  apply({ model: model.value === '' ? null : model.value })
+}
+function onPolicy() {
+  apply({ trusted_only: policy.value === 'trusted' })
+}
+</script>
+
+<template>
+  <div class="glass-card mesh-assistant-panel">
+    <h3 class="mesh-panel-title">AI Assistant</h3>
+    <p class="mesh-panel-sub">Answer questions over the mesh with AI</p>
+
+    <!-- Backend chooser -->
+    <div class="mesh-assistant-field">
+      <label class="mesh-bitcoin-label">AI backend</label>
+      <select v-model="backend" class="mesh-bitcoin-input mesh-bitcoin-input-sm" @change="onBackend">
+        <option value="claude">Claude (shared token — no GPU needed)</option>
+        <option value="ollama">Local model (Ollama on this node)</option>
+      </select>
+    </div>
+
+    <!-- Provider missing -> guidance / deep-link -->
+    <div v-if="status && backend === 'ollama' && !ollamaReady" class="mesh-assistant-install">
+      <p class="text-sm text-white/70 mb-3">
+        Local mode needs the <strong>Ollama</strong> app installed and running.
+      </p>
+      <RouterLink to="/dashboard/marketplace/ollama" class="glass-button mesh-assistant-install-btn">
+        Install AI (Ollama)
+      </RouterLink>
+    </div>
+    <div v-else-if="status && backend === 'claude' && !claudeReady" class="mesh-assistant-install">
+      <p class="text-sm text-white/70">
+        No Claude API token is configured on this node yet. Add one in Settings to use the shared
+        Claude backend, or switch to a local model.
+      </p>
+    </div>
+
+    <!-- Enable toggle -->
+    <button
+      type="button"
+      class="w-full flex items-center gap-4 p-4 rounded-xl border transition-all text-left"
+      :class="enabled ? 'bg-white/10 border-orange-500/40' : 'bg-black/20 border-white/10 hover:border-white/20'"
+      :style="!backendReady ? 'opacity:0.5;cursor:not-allowed' : ''"
+      @click="backendReady && onToggle(!enabled)"
+    >
+      <svg class="w-5 h-5 shrink-0" :class="enabled ? 'text-orange-400' : 'text-white/40'" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9.75 17L9 20l-1 1h8l-1-1-.75-3M3 13h18M5 17h14a2 2 0 002-2V5a2 2 0 00-2-2H5a2 2 0 00-2 2v10a2 2 0 002 2z" />
+      </svg>
+      <div class="flex-1 min-w-0">
+        <p class="text-sm font-medium" :class="enabled ? 'text-white/95' : 'text-white/70'">
+          {{ enabled ? 'Answering mesh AI queries' : 'Answer mesh AI queries' }}
+        </p>
+        <p class="text-xs text-white/50 mt-0.5">Peers can ask this node's AI over the radio</p>
+      </div>
+      <ToggleSwitch :model-value="enabled" @click.stop @update:model-value="backendReady && onToggle($event)" />
+    </button>
+
+    <template v-if="enabled">
+      <div v-if="backend === 'ollama'" class="mesh-assistant-field">
+        <label class="mesh-bitcoin-label">Model</label>
+        <select v-model="model" class="mesh-bitcoin-input mesh-bitcoin-input-sm" @change="onModel">
+          <option value="">Default ({{ defaultModel }})</option>
+          <option v-for="m in availableModels" :key="m" :value="m">{{ m }}</option>
+        </select>
+      </div>
+      <div v-else class="mesh-assistant-field">
+        <label class="mesh-bitcoin-label">Model</label>
+        <input v-model="model" class="mesh-bitcoin-input mesh-bitcoin-input-sm" :placeholder="defaultModel" @change="onModel" />
+      </div>
+
+      <div class="mesh-assistant-field">
+        <label class="mesh-bitcoin-label">Who can ask</label>
+        <select v-model="policy" class="mesh-bitcoin-input mesh-bitcoin-input-sm" @change="onPolicy">
+          <option value="trusted">Trusted nodes only</option>
+          <option value="anyone">Anyone on the mesh</option>
+        </select>
+        <p class="text-xs text-white/40 mt-1">
+          {{ policy === 'anyone'
+            ? 'Any peer can spend this node\'s AI budget + airtime.'
+            : 'Only federation-trusted peers may ask.' }}
+        </p>
+      </div>
+
+      <p class="text-xs text-white/50 mt-2">
+        Ask from any client by sending <code>!ai &lt;question&gt;</code> on the mesh channel.
+      </p>
+    </template>
+  </div>
+</template>

neode-ui/src/views/mesh/mesh-styles.css

@@ -47,9 +47,11 @@
 .mesh-columns-very-wide .mesh-tools-wrapper { display: grid; grid-template-rows: minmax(0, 1fr) minmax(0, 0.85fr) minmax(0, 1fr); gap: 12px; overflow: hidden; }
 .mesh-columns-very-wide .mesh-tools-wrapper .mesh-bitcoin-panel,
 .mesh-columns-very-wide .mesh-tools-wrapper .mesh-deadman-panel,
+.mesh-columns-very-wide .mesh-tools-wrapper .mesh-assistant-panel,
 .mesh-columns-very-wide .mesh-tools-wrapper .mesh-map-panel { min-height: 0; height: 100%; overflow: hidden; }
 .mesh-columns-wide:not(.mesh-columns-very-wide) .mesh-tools-wrapper .mesh-bitcoin-panel,
 .mesh-columns-wide:not(.mesh-columns-very-wide) .mesh-tools-wrapper .mesh-deadman-panel,
+.mesh-columns-wide:not(.mesh-columns-very-wide) .mesh-tools-wrapper .mesh-assistant-panel,
 .mesh-columns-wide:not(.mesh-columns-very-wide) .mesh-tools-wrapper .mesh-map-panel { flex: 1 1 auto; min-height: 0; height: auto; }
 .mesh-columns-very-wide .mesh-tools-tab-bar { display: none; }
 .mesh-columns-wide .mesh-mobile-back-btn,
@@ -154,12 +156,14 @@
   .mesh-mobile-tools { margin-top: 12px; display: flex; flex-direction: column; gap: 12px; }
   .mesh-mobile-tools .mesh-tools-tab-bar { display: flex; gap: 2px; background: rgba(0,0,0,0.3); border-radius: 10px; padding: 3px; }
   .mesh-mobile-tools :deep(.mesh-bitcoin-panel),
+  .mesh-mobile-tools :deep(.mesh-assistant-panel),
   .mesh-mobile-tools :deep(.mesh-deadman-panel) { min-height: 320px; max-height: min(68dvh, 620px); overflow-y: auto; }
   .mesh-mobile-tools .mesh-map-panel { min-height: 360px; max-height: min(68dvh, 620px); overflow: hidden; }
   .mesh-status-grid { grid-template-columns: repeat(2, 1fr); }
   .mesh-chat-back { display: block; }
   .mobile-hidden { display: none !important; }
   :deep(.mesh-bitcoin-panel),
+  :deep(.mesh-assistant-panel),
   :deep(.mesh-deadman-panel) { flex: none; cursor: pointer; flex-shrink: 0; }
   .mesh-mobile-back-btn:hover { color: rgba(255, 255, 255, 0.9); }
 }
@@ -223,7 +227,11 @@
 
 /* Bitcoin & Deadman panels (child components) */
 .mesh-bitcoin-panel,
-.mesh-deadman-panel { padding: 16px; display: flex; flex-direction: column; gap: 12px; flex: 1; min-height: 0; overflow-y: auto; }
+.mesh-deadman-panel,
+.mesh-assistant-panel { padding: 16px; display: flex; flex-direction: column; gap: 12px; flex: 1; min-height: 0; overflow-y: auto; }
+.mesh-assistant-field { display: flex; flex-direction: column; gap: 4px; }
+.mesh-assistant-install { padding: 12px; background: rgba(251,146,60,0.08); border: 1px solid rgba(251,146,60,0.25); border-radius: 10px; }
+.mesh-assistant-install-btn { display: inline-block; text-align: center; padding: 8px 14px; font-size: 0.8rem; }
 .mesh-panel-title { font-size: 1rem; font-weight: 700; color: rgba(255,255,255,0.95); margin: 0; }
 .mesh-panel-sub { font-size: 0.8rem; color: rgba(255,255,255,0.45); margin: -4px 0 0; }
 .mesh-bitcoin-section { display: flex; flex-direction: column; gap: 8px; }