fix: corpus dropdown, LLM error display, chat UX, invite endpoint, getting started text

- ask.py: _get_corpora() scans rag.list_corpora + registry for rag.query entries
Refresh Corpora button added
LLM errors surfaced as text instead of silent 'No response'
- chat.py: show MY node_id, HF Space single-node note, broadcast with '*',
delivery status 'direct'/'queued' shown clearly, auto echo for self-msg
- getting_started.py: remove 'pip install hearthnet' (not on PyPI), link to HF Space
- settings.py: invite uses SPACE_HOST env var on HF Space (not 127.0.0.1)
- app.py: stable node_id from SPACE_HOST hash, register rag.list_corpora capability

app.py

@@ -163,6 +163,10 @@ def _build_node():
     Uses HfLocalBackend (SmolLM2-135M) so inference works without Ollama.
     Falls back to _UnavailableBackend if transformers is not installed.
     """
+    import hashlib
+    import os
+    import socket
+
     from hearthnet.node import HearthNode
     from hearthnet.services.chat.service import ChatService
     from hearthnet.services.demo import RagService as DemoRagService
@@ -171,10 +175,16 @@ 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())
+    _suffix = hashlib.sha256(_host.encode()).hexdigest()[:8]
+    _node_id = f"hf-space-{_suffix}"
+    _display = os.getenv("SPACE_TITLE", f"HearthNet Space ({_suffix})")
+
     node = HearthNode(
-        node_id="hf-space",
-        display_name="HearthNet Space",
-        community_id="ed25519:hf-space-demo",
+        node_id=_node_id,
+        display_name=_display,
+        community_id="ed25519:hf-space-community",
     )
 
     # LLM — HF Transformers backend (SmolLM2 by default)
@@ -253,6 +263,17 @@ def _build_node():
     rag.documents = list(SEED_CORPUS)
     node.bus.register_service(rag)
 
+    # Register a synthetic rag.list_corpora so the Ask tab can discover corpora
+    from hearthnet.bus.capability import CapabilityDescriptor, RouteRequest
+
+    async def _list_corpora(req: RouteRequest) -> dict:
+        return {"output": {"corpora": ["community"]}, "meta": {}}
+
+    node.bus.register_capability(
+        CapabilityDescriptor(name="rag.list_corpora", version=(1, 0)),
+        _list_corpora,
+    )
+
     # Marketplace, Chat, Files
     node.bus.register_service(MarketplaceService())
     node.bus.register_service(ChatService(node.node_id))

hearthnet/ui/tabs/ask.py

@@ -14,9 +14,40 @@ Spec: docs/M04-llm.md, docs/M05-rag.md, docs/M03-bus.md §4
 from __future__ import annotations
 
 
+def _get_corpora(bus) -> list[str]:
+    """Scan the bus registry for all rag.query corpus names."""
+    if bus is None:
+        return []
+    corpora: list[str] = []
+    try:
+        # Try rag.list_corpora capability first (real RagService has it)
+        import asyncio
+        loop = asyncio.new_event_loop()
+        r = loop.run_until_complete(bus.call("rag.list_corpora", (1, 0), {"input": {}}))
+        loop.close()
+        corpora = r.get("output", {}).get("corpora", [])
+    except Exception:
+        pass
+    if not corpora:
+        # Fallback: inspect registry for rag.query entries and extract corpus param
+        try:
+            all_entries = list(bus.registry.all())
+            for entry in all_entries:
+                if entry.descriptor.name == "rag.query":
+                    corpus = (entry.descriptor.params or {}).get("corpus")
+                    if corpus and corpus not in corpora:
+                        corpora.append(corpus)
+        except Exception:
+            pass
+    return corpora
+
+
 def build_ask_tab(bus=None):
     import gradio as gr
 
+    corpora = _get_corpora(bus)
+    corpus_choices = ["(none)"] + corpora
+
     with gr.Column():
         gr.Markdown("""### 💬 Ask the Mesh
 
@@ -35,16 +66,17 @@ to the best available LLM node — either on this device or on a peer.
         with gr.Row():
             corpus_selector = gr.Dropdown(
                 label="RAG Corpus (leave blank for direct LLM)",
-                choices=["(none)"],
-                value="(none)",
+                choices=corpus_choices,
+                value=corpus_choices[0],
                 scale=3,
             )
             model_selector = gr.Dropdown(
                 label="Model (auto = bus picks best node)",
                 choices=["auto"],
                 value="auto",
-                scale=3,
+                scale=2,
             )
+            refresh_corpora_btn = gr.Button("🔄 Refresh Corpora", size="sm", scale=1)
 
         chatbot = gr.Chatbot(
             label="Conversation",
@@ -65,6 +97,10 @@ to the best available LLM node — either on this device or on a peer.
             sources_out = gr.JSON(label="📚 RAG Sources", visible=False, scale=2)
             route_out = gr.JSON(label="🛣️ Routing Trace", visible=False, scale=2)
 
+        def refresh_corpora():
+            choices = ["(none)"] + _get_corpora(bus)
+            return gr.update(choices=choices, value=choices[0])
+
         async def handle_send(message: str, history: list, corpus: str, model: str):
             if not message.strip():
                 return history, "", gr.update(visible=False), gr.update(visible=False)
@@ -132,14 +168,25 @@ to the best available LLM node — either on this device or on a peer.
                     (1, 0),
                     {"params": params, "input": {"messages": llm_messages}},
                 )
-                reply = result.get("output", {}).get("message", {}).get("content", "No response")
-                routed_via_llm = result.get("_routed_via", "local")
-                trace["llm"] = {
-                    "capability": "llm.chat",
-                    "model_requested": model if model != "auto" else "(any)",
-                    "routed_via": routed_via_llm,
-                }
-                trace["routed_to"] = routed_via_llm
+
+                # Surface errors clearly instead of showing "No response"
+                if "error" in result:
+                    err_msg = result.get("message", result.get("error", "unknown error"))
+                    reply = f"⚠️ LLM error: {err_msg}"
+                    trace["llm"] = {"error": err_msg}
+                else:
+                    reply = (
+                        result.get("output", {}).get("message", {}).get("content")
+                        or result.get("output", {}).get("text")
+                        or "(empty response — model may still be loading)"
+                    )
+                    routed_via_llm = result.get("_routed_via", "local")
+                    trace["llm"] = {
+                        "capability": "llm.chat",
+                        "model_requested": model if model != "auto" else "(any)",
+                        "routed_via": routed_via_llm,
+                    }
+                    trace["routed_to"] = routed_via_llm
 
                 history.append({"role": "assistant", "content": reply})
 
@@ -160,6 +207,7 @@ to the best available LLM node — either on this device or on a peer.
                     gr.update(visible=True, value=trace),
                 )
 
+        refresh_corpora_btn.click(refresh_corpora, outputs=corpus_selector)
         send_btn.click(
             handle_send,
             inputs=[msg_input, chatbot, corpus_selector, model_selector],

hearthnet/ui/tabs/chat.py

@@ -6,71 +6,121 @@ from __future__ import annotations
 def build_chat_tab(bus=None):
     import gradio as gr
 
+    my_node_id = getattr(bus, "node_id_full", None) if bus else None
+
     with gr.Column():
         gr.Markdown("""### 💬 Direct Messages
 
 Send and receive messages between HearthNet nodes (M10).
 Messages are **event-sourced** with Lamport clocks — delivery order is deterministic
 even when nodes reconnect after an offline period.
+""")
+
+        if my_node_id:
+            gr.Markdown(
+                f"**Your Node ID** (share this so others can message you):\n\n"
+                f"```\n{my_node_id}\n```"
+            )
 
+        gr.Markdown("""
 **How to use:**
-1. Enter the recipient's Node ID (copy from their Settings tab)
-2. Click **Load History** to see past messages
+1. Enter a **Recipient Node ID** — copy it from their Settings tab
+2. Click **Load History** to see past messages  
 3. Type a message and press **Send**
 
-The delivery confirmation shows whether the message was:
+**Send to all peers:** use `*` as the recipient to broadcast to every known peer.
+
+**Delivery status:**
+- `direct` — sent to yourself (same node)
 - `queued` — stored locally, will deliver when recipient reconnects
-- `delivered` — recipient acknowledged receipt
+- `delivered` — recipient on a live peer node acknowledged receipt
+
+> On the **HF Space** (single node): only self-messages (`direct`) work.  
+> For real peer messaging, run two local nodes — see Getting Started.
 """)
 
         with gr.Row():
-            peer_id = gr.Textbox(label="Recipient Node ID", placeholder="ed25519:...", scale=4)
+            peer_id = gr.Textbox(
+                label="Recipient Node ID",
+                placeholder=f"e.g. {my_node_id or 'ed25519:...'}  (use * for broadcast)",
+                scale=4,
+            )
             history_btn = gr.Button("Load History", scale=1)
 
-        chat_out = gr.Chatbot(label="Messages", height=300)
+        chat_out = gr.Chatbot(label="Messages", height=340)
 
         with gr.Row():
-            msg_input = gr.Textbox(label="Message", scale=7)
+            msg_input = gr.Textbox(label="Message", placeholder="Type a message…", scale=7)
             send_btn = gr.Button("Send", scale=1, variant="primary")
-        send_result = gr.JSON(visible=False)
+
+        status_out = gr.Markdown(visible=False)
 
         async def load_history(peer):
             if bus is None:
-                return [{"role": "assistant", "content": "Bus not connected"}]
+                return [{"role": "assistant", "content": "⚠️ Bus not connected"}]
+            target = peer.strip() if peer else None
             try:
-                r = await bus.call("chat.history", (1, 0), {"input": {"peer": peer or None}})
+                r = await bus.call("chat.history", (1, 0), {"input": {"peer": target}})
                 msgs = r.get("output", {}).get("messages", [])
+                if not msgs:
+                    return [{"role": "assistant", "content": "(no messages yet)"}]
                 result = []
+                node_me = getattr(bus, "node_id_full", "me")
                 for m in msgs:
-                    result.append(
-                        {"role": "user", "content": f"[{m.get('from', '?')}]: {m.get('body', '')}"}
-                    )
+                    sender = m.get("from", "?")
+                    is_mine = sender == node_me
+                    result.append({
+                        "role": "user" if is_mine else "assistant",
+                        "content": f"{'You' if is_mine else sender}: {m.get('body', '')}",
+                    })
                 return result
             except Exception as e:
-                return [{"role": "assistant", "content": f"Error: {e}"}]
+                return [{"role": "assistant", "content": f"Error loading history: {e}"}]
 
         async def send_msg(peer, msg, history):
-            if not peer or not msg:
+            if not msg.strip():
                 return history, "", gr.update(visible=False)
             history = history or []
             if bus is None:
-                history = history + [
-                    {"role": "user", "content": msg},
-                    {"role": "assistant", "content": "⚠️ Bus not connected"},
-                ]
-                return history, "", gr.update(visible=False)
-            try:
-                r = await bus.call(
-                    "chat.send",
-                    (1, 0),
-                    {"input": {"recipient": peer, "body": msg}},
+                return (
+                    history + [
+                        {"role": "user", "content": msg},
+                        {"role": "assistant", "content": "⚠️ Bus not connected"},
+                    ],
+                    "",
+                    gr.update(visible=False),
                 )
-                status = r.get("output", {}).get("delivered", "sent")
+
+            # Broadcast to all peers if * used
+            recipient = peer.strip() if peer else getattr(bus, "node_id_full", "")
+            if recipient == "*":
+                # Send to all known peers
+                peers_snapshot = getattr(bus, "topology_snapshot", lambda: None)()
+                all_peers = [p.get("node_id") for p in (getattr(peers_snapshot, "peers", []) or [])]
+                if not all_peers:
+                    all_peers = [getattr(bus, "node_id_full", recipient)]
+                results = []
+                for p in all_peers:
+                    try:
+                        r = await bus.call("chat.send", (1, 0), {"input": {"recipient": p, "body": msg}})
+                        results.append(r.get("output", {}).get("delivered", "queued"))
+                    except Exception:
+                        results.append("error")
+                history = history + [{"role": "user", "content": f"[broadcast to {len(all_peers)} peers] {msg}"}]
+                note = f"✓ Broadcast sent to {len(all_peers)} peer(s): {results}"
+                return history, "", gr.update(visible=True, value=note)
+
+            try:
+                r = await bus.call("chat.send", (1, 0), {"input": {"recipient": recipient, "body": msg}})
+                status = r.get("output", {}).get("delivered", "queued")
                 history = history + [
                     {"role": "user", "content": msg},
-                    {"role": "assistant", "content": f"✓ delivered={status}"},
                 ]
-                return history, "", gr.update(visible=True, value=r.get("output"))
+                if status == "direct":
+                    # Self-message — also show it as received
+                    history.append({"role": "assistant", "content": f"[echo] {msg}"})
+                note = f"✓ {status} → `{recipient}`"
+                return history, "", gr.update(visible=True, value=note)
             except Exception as e:
                 history = history + [
                     {"role": "user", "content": msg},
@@ -82,5 +132,10 @@ The delivery confirmation shows whether the message was:
         send_btn.click(
             send_msg,
             inputs=[peer_id, msg_input, chat_out],
-            outputs=[chat_out, msg_input, send_result],
+            outputs=[chat_out, msg_input, status_out],
+        )
+        msg_input.submit(
+            send_msg,
+            inputs=[peer_id, msg_input, chat_out],
+            outputs=[chat_out, msg_input, status_out],
         )

hearthnet/ui/tabs/getting_started.py

@@ -18,23 +18,20 @@ capabilities, files, and community posts — no central server required.
 ## Quick Start (any device with Python)
 
 ```bash
-# 1. Install from source (pip install hearthnet coming once published to PyPI)
+# 1. Clone the repo (PyPI package coming soon — use git clone for now)
 git clone https://huggingface.co/spaces/build-small-hackathon/HearthNet
 cd HearthNet
 pip install -e .
 
-# 2. Run a node
+# 2. Run your local node
 python -m hearthnet.cli run
 
 # 3. Open the UI
 # http://localhost:7860
 ```
 
-Other devices on the **same Wi-Fi/LAN discover this node automatically** (mDNS).
-No configuration needed for same-network peers.
-
-> **PyPI package**: `pip install hearthnet` will work once the package is published.
-> Until then use `pip install -e .` from the cloned repo.
+The **HF Space** above is the public demo — single node, SmolLM2-135M, no real peer mesh.  
+A **local install** gives you Ollama/llama.cpp models, real peer discovery, file sharing, and chat.
 
 ---
 

hearthnet/ui/tabs/settings.py

@@ -158,37 +158,56 @@ Set `relay_url` in `~/.hearthnet/config.toml` for cross-internet connections.
                 if bus is None:
                     return "<p style='color:#f44'>Bus not connected — run as a real node.</p>", ""
                 try:
+                    import os
                     from pathlib import Path
 
                     from hearthnet.identity.keys import load_or_generate
                     from hearthnet.ui.onboarding import encode_invite, make_invite
 
                     kp = load_or_generate(Path.home() / ".hearthnet" / "keys")
+                    # Detect whether we're on HF Space or local
+                    hf_space_host = os.getenv("SPACE_HOST")  # e.g. build-small-hackathon-hearthnet.hf.space
+                    if hf_space_host:
+                        public_host = hf_space_host
+                        public_port = 443
+                        transport = "https"
+                    else:
+                        port_obj = getattr(config, "transport", None)
+                        public_port = getattr(port_obj, "port", 7080) if port_obj else 7080
+                        public_host = "127.0.0.1"
+                        transport = "http"
+
                     cm_prov = getattr(bus, "community_manifest_provider", None)
                     cm = cm_prov() if cm_prov else None
                     if cm is None:
-                        port_obj = getattr(config, "transport", None)
-                        port_val = getattr(port_obj, "port", 7080) if port_obj else 7080
                         link = (
                             f"hnvite://v1/{bus.node_id_full}"
-                            f"?host=127.0.0.1&port={port_val}&level={level}"
+                            f"?host={public_host}&port={public_port}&transport={transport}&level={level}"
                         )
-                        return _qr_svg(link), link
-                    from hearthnet.identity.manifest import Endpoint
-
-                    blob = make_invite(
-                        invitee_node_id_full=invitee or "ed25519:any",
-                        inviter_kp=kp,
-                        community_manifest=cm,
-                        bootstrap_endpoints=[
-                            Endpoint(transport="http", host="127.0.0.1", port=7080)
-                        ],
-                        initial_level=level,
-                    )
-                    link = encode_invite(blob)
-                    return _qr_svg(link), link
+                        qr_data = link
+                    else:
+                        from hearthnet.identity.manifest import Endpoint
+
+                        blob = make_invite(
+                            invitee_node_id_full=invitee or "ed25519:any",
+                            inviter_kp=kp,
+                            community_manifest=cm,
+                            bootstrap_endpoints=[
+                                Endpoint(transport=transport, host=public_host, port=public_port)
+                            ],
+                            initial_level=level,
+                        )
+                        link = encode_invite(blob)
+                        qr_data = link
+
+                    note = ""
+                    if hf_space_host:
+                        note = f"\n\n> ℹ️ This invite uses the **HF Space URL** (`{public_host}`). Peers outside the Space can use it."
+                    else:
+                        note = f"\n\n> ℹ️ Host is `{public_host}:{public_port}`. Make sure this is reachable by the invitee."
+                    return _qr_svg(qr_data), link + note
                 except Exception as exc:
-                    return f"<p style='color:#f44'>Error: {exc}</p>", ""
+                    return f"<p style='color:#f44'>Error: {exc}</p>", f"Error: {exc}"
 
             make_invite_btn.click(
                 gen_invite,