fix: resolve cross-node chat [echo] bug

Root causes:
1. Gradio race condition: peer_dropdown.change updates peer_id textbox
async, but clicking Send before update completes sends to empty recipient
which falls back to self → 'direct' → [echo].
Fix: pass both peer_dropdown and peer_id as inputs to send_msg;
use peer_box when non-empty, else peer_drop (no async dependency).

2. Node ID prefix collision: local app.py used hf-space-* prefix same as
HF Space nodes. _apply_roster skips own ID, so the live Space node
(hf-space-f28143c5) was silently skipped and only stale dead nodes
appeared in the dropdown.
Fix: use SPACE_HOST env var (set only on HF) to discriminate; local
nodes now get local-* prefix (local-f28143c5), so Space nodes appear
as genuine remote peers.

Also added:
- tests/test_chat_cross_node.py: 4 integration tests for cross-node
chat delivery, history, self-send, and unknown-node cases (all pass)

app.py

@@ -175,11 +175,18 @@ def _build_node():
     from hearthnet.services.llm.service import LlmService
     from hearthnet.services.marketplace.service import MarketplaceService
 
-    # Generate a stable node_id from the HF Space hostname (so it doesn't change on restart)
-    _host = os.getenv("SPACE_HOST", socket.gethostname())
+    # Generate a stable node_id from the HF Space hostname (so it doesn't change on restart).
+    # Use SPACE_HOST env var (set only on HF Spaces) to differentiate: local nodes get
+    # "local-*" prefix so they never collide with live "hf-space-*" peers in the relay.
+    _space_host = os.getenv("SPACE_HOST", "")
+    _host = _space_host or socket.gethostname()
     _suffix = hashlib.sha256(_host.encode()).hexdigest()[:8]
-    _node_id = f"hf-space-{_suffix}"
-    _display = os.getenv("SPACE_TITLE", f"HearthNet Space ({_suffix})")
+    if _space_host:
+        _node_id = f"hf-space-{_suffix}"
+        _display = os.getenv("SPACE_TITLE", f"HearthNet Space ({_suffix})")
+    else:
+        _node_id = f"local-{_suffix}"
+        _display = os.getenv("SPACE_TITLE", f"HearthNet Local ({_suffix})")
 
     node = HearthNode(
         node_id=_node_id,

hearthnet/ui/tabs/chat.py

@@ -74,10 +74,12 @@ def build_chat_tab(bus=None):
             peers = _get_known_peers(bus)
             return gr.update(choices=peers, value=peers[0] if peers else None)
 
-        async def load_history(peer):
+        async def load_history(peer_drop, peer_box):
+            # peer_box wins if filled; fall back to dropdown selection
+            peer = (peer_box or peer_drop or "").strip()
             if bus is None:
                 return [{"role": "assistant", "content": "⚠️ Bus not connected"}]
-            target = peer.strip() if peer else None
+            target = peer if peer else None
             try:
                 r = await bus.call("chat.history", (1, 0), {"input": {"peer": target}})
                 msgs = r.get("output", {}).get("messages", [])
@@ -98,7 +100,10 @@ def build_chat_tab(bus=None):
             except Exception as e:
                 return [{"role": "assistant", "content": f"Error loading history: {e}"}]
 
-        async def send_msg(peer, msg, history):
+        async def send_msg(peer_drop, peer_box, msg, history):
+            # peer_box wins when filled; fall back to dropdown (avoids Gradio race condition
+            # where dropdown.change hasn't updated peer_box before Send fires)
+            peer = (peer_box or peer_drop or "").strip()
             if not msg.strip():
                 return history, "", gr.update(visible=False)
             history = history or []
@@ -113,7 +118,7 @@ def build_chat_tab(bus=None):
                     gr.update(visible=False),
                 )
 
-            recipient = peer.strip() if peer else getattr(bus, "node_id_full", "")
+            recipient = peer if peer else getattr(bus, "node_id_full", "")
             if recipient == "*":
                 all_peers = _get_known_peers(bus)
                 if not all_peers:
@@ -155,14 +160,16 @@ def build_chat_tab(bus=None):
                 return history, "", gr.update(visible=False)
 
         refresh_peers_btn.click(refresh_peers, outputs=peer_dropdown)
-        history_btn.click(load_history, inputs=peer_id, outputs=chat_out)
+        # Pass BOTH dropdown and textbox so send_msg can pick the authoritative value
+        # even if the dropdown.change callback hasn't propagated to peer_id yet.
+        history_btn.click(load_history, inputs=[peer_dropdown, peer_id], outputs=chat_out)
         send_btn.click(
             send_msg,
-            inputs=[peer_id, msg_input, chat_out],
+            inputs=[peer_dropdown, peer_id, msg_input, chat_out],
             outputs=[chat_out, msg_input, status_out],
         )
         msg_input.submit(
             send_msg,
-            inputs=[peer_id, msg_input, chat_out],
+            inputs=[peer_dropdown, peer_id, msg_input, chat_out],
             outputs=[chat_out, msg_input, status_out],
         )

tests/test_chat_cross_node.py

@@ -0,0 +1,76 @@
+"""Integration test: cross-node chat delivery (M10).
+
+Verifies that chat.send from node A to node B:
+ - calls chat.deliver on B's bus
+ - B stores the message
+ - chat.history on B shows the message
+ - delivery status is "delivered" (not "queued" or "direct")
+
+Uses in-process InMemoryTransport so no relay/HTTP needed.
+"""
+from __future__ import annotations
+
+import pytest
+from hearthnet.bus import InMemoryTransport
+
+
+@pytest.fixture()
+def two_nodes():
+    from hearthnet.node import HearthNode
+
+    net = InMemoryTransport()
+    alice = HearthNode("node-alice", "Alice", "ed25519:test", transport=net)
+    alice.install_demo_services()
+    net.register(alice.bus)
+
+    bob = HearthNode("node-bob", "Bob", "ed25519:test", transport=net)
+    bob.install_demo_services()
+    net.register(bob.bus)
+
+    return alice, bob
+
+
+@pytest.mark.asyncio
+async def test_chat_send_cross_node_delivers(two_nodes):
+    alice, bob = two_nodes
+
+    r = await alice.bus.call(
+        "chat.send", (1, 0), {"input": {"recipient": "node-bob", "body": "Hello Bob!"}}
+    )
+    status = r.get("output", {}).get("delivered")
+    assert status == "delivered", f"Expected 'delivered', got {status!r}"
+
+
+@pytest.mark.asyncio
+async def test_chat_history_shows_received_message(two_nodes):
+    alice, bob = two_nodes
+
+    await alice.bus.call(
+        "chat.send", (1, 0), {"input": {"recipient": "node-bob", "body": "Hi from Alice"}}
+    )
+
+    r = await bob.bus.call("chat.history", (1, 0), {"input": {"peer": "node-alice"}})
+    msgs = r.get("output", {}).get("messages", [])
+    assert len(msgs) == 1, f"Expected 1 message in Bob's history, got {len(msgs)}"
+    assert msgs[0]["body"] == "Hi from Alice"
+    assert msgs[0]["from"] == "node-alice"
+
+
+@pytest.mark.asyncio
+async def test_self_send_returns_direct(two_nodes):
+    alice, _ = two_nodes
+    r = await alice.bus.call(
+        "chat.send", (1, 0), {"input": {"recipient": "node-alice", "body": "hi me"}}
+    )
+    status = r.get("output", {}).get("delivered")
+    assert status == "direct", f"Expected 'direct' for self-send, got {status!r}"
+
+
+@pytest.mark.asyncio
+async def test_send_to_unknown_node_returns_queued(two_nodes):
+    alice, _ = two_nodes
+    r = await alice.bus.call(
+        "chat.send", (1, 0), {"input": {"recipient": "node-nobody", "body": "hello?"}}
+    )
+    status = r.get("output", {}).get("delivered")
+    assert status == "queued", f"Expected 'queued' for unknown node, got {status!r}"