fix(chat): wire ChatService with bus in app.py so cross-node sends deliver

The HF Space / UI entry point constructed ChatService without a bus=
reference, so _deliver_remote short-circuited to 'queued' before ever
attempting remote delivery. Pass bus=node.bus (matching node.py wiring)
so local->peer chat is delivered over the bus transport.

Verified live: local browser UI -> HF Space now reports 'delivered' and
the message lands in the Space chat log.

Add regression tests covering manual ChatService wiring + the no-bus
failure mode. Tidy stray blank lines in relay_client.

app.py

@@ -378,7 +378,7 @@ def _build_node():
 
     # Marketplace, Chat, Files — now durably event-sourced where supported.
     node.bus.register_service(MarketplaceService(event_log=event_log, node_id=node.node_id))
-    node.bus.register_service(ChatService(node.node_id, event_log=event_log))
+    node.bus.register_service(ChatService(node.node_id, event_log=event_log, bus=node.bus))
     node.bus.register_service(FileService())
 
     return node

hearthnet/transport/relay_client.py

@@ -336,8 +336,6 @@ class RelayClient:
             self._bus.registry.update_from_peer_manifest(record, manifest)
 
 
-
-
 class RelayStrategy:
     """Adapts a :class:`RelayClient` to the bus ``DeliveryStrategy`` protocol."""
 

tests/test_chat_cross_node.py

@@ -74,3 +74,44 @@ async def test_send_to_unknown_node_returns_queued(two_nodes):
     )
     status = r.get("output", {}).get("delivered")
     assert status == "queued", f"Expected 'queued' for unknown node, got {status!r}"
+
+
+@pytest.mark.asyncio
+async def test_manually_wired_chat_service_delivers():
+    """Regression: a ChatService registered manually (as app.py / the HF Space
+    entry point does) must receive a ``bus=`` reference, otherwise
+    ``_deliver_remote`` short-circuits to ``"queued"`` before attempting
+    delivery. Mirrors the app.py wiring to guard against that regression.
+    """
+    from hearthnet.node import HearthNode
+    from hearthnet.services.chat.service import ChatService
+
+    net = InMemoryTransport()
+    alice = HearthNode("node-alice", "Alice", "ed25519:test", transport=net)
+    # Wire chat exactly like app.py: explicit bus= argument is required.
+    alice.bus.register_service(ChatService(alice.node_id, bus=alice.bus))
+    net.register(alice.bus)
+
+    bob = HearthNode("node-bob", "Bob", "ed25519:test", transport=net)
+    bob.bus.register_service(ChatService(bob.node_id, bus=bob.bus))
+    net.register(bob.bus)
+
+    r = await alice.bus.call(
+        "chat.send", (1, 0), {"input": {"recipient": "node-bob", "body": "wired"}}
+    )
+    assert r.get("output", {}).get("delivered") == "delivered"
+
+
+@pytest.mark.asyncio
+async def test_chat_service_without_bus_cannot_deliver():
+    """A ChatService constructed without a bus reference can only queue —
+    documents the failure mode the app.py wiring fix prevents.
+    """
+    from hearthnet.services.chat.service import ChatService
+
+    svc = ChatService("node-alice")  # no bus=
+    status = await svc._deliver_remote(
+        {"to": "node-bob", "from": "node-alice", "body": "x", "event_id": "e1"}
+    )
+    assert status == "queued"
+