fix: RAG seeding timeout + robust agent mode with always-on corpus search

RAG: Remove the 60s join() that killed the seed thread before 78+ docs
could finish embedding. Seeding now runs fully in background as a daemon
thread. Added per-file error logging and a completion summary print.

Agent mode: Replace fragile ReAct loop (requires model to emit exact
action:{JSON} format — unreliable on 1B models) with a guaranteed
search-first strategy:
1. Always call rag.federated_query (local + LAN + internet peers)
2. Optionally list marketplace peers
3. Inject all gathered context into LLM system message and answer
Agent steps panel shows what was searched, what was found, and the final
answer — giving full transparency without depending on model's JSON output.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

app.py

@@ -359,16 +359,18 @@ def _build_node():
             _app_root / "assets" / "initial_docs",
         ]
         _text_suffixes = {".md", ".txt", ".rst"}
+        _ingested = 0
+        _failed = 0
         for _doc_dir in _doc_dirs:
             if not _doc_dir.exists():
                 continue
             for _doc_file in sorted(_doc_dir.rglob("*")):
                 if _doc_file.suffix.lower() not in _text_suffixes:
                     continue
-                with contextlib.suppress(Exception):
+                try:
                     _text = _doc_file.read_text(encoding="utf-8", errors="replace")
                     if len(_text.strip()) < 80:
-                        continue  # skip near-empty or placeholder files
+                        continue
                     _title = _doc_file.stem.replace("-", " ").replace("_", " ").title()
                     _doc_id = f"file:{_doc_file.relative_to(_app_root).as_posix()}"
                     await rag.handle_ingest(
@@ -387,6 +389,11 @@ def _build_node():
                             deadline_ms=0,
                         )
                     )
+                    _ingested += 1
+                except Exception as _ie:
+                    _failed += 1
+                    print(f"[hearthnet] seed ingest failed {_doc_file.name}: {_ie}")
+        print(f"[hearthnet] seed corpus done: {_ingested} docs ingested, {_failed} failed")
 
     # Run seed corpus in a dedicated thread with its own event loop to avoid
     # conflicts with any loop already running (e.g. Gradio's internal loop).
@@ -398,14 +405,17 @@ def _build_node():
         asyncio.set_event_loop(loop)
         try:
             loop.run_until_complete(_seed_corpus())
-        except Exception:
-            pass
+        except Exception as _e:
+            print(f"[hearthnet] seed corpus failed: {_e}")
         finally:
             loop.close()
 
+    # Run seeding as a pure background daemon — do NOT join() with a short
+    # timeout. 78+ docs × embedding time >> 60 s, so a join would kill the
+    # thread before most docs are stored. Gradio starts serving immediately;
+    # docs become available for RAG queries as they are ingested.
     _seed_thread = threading.Thread(target=_seed_in_thread, daemon=True, name="hearthnet-seed")
     _seed_thread.start()
-    _seed_thread.join(timeout=60)  # wait up to 60 s; don't block Space startup indefinitely
 
     # Register this node's LLM model as an expert in the MoE registry so
     # route_expert tool calls return meaningful results instead of an empty list.

hearthnet/ui/tabs/ask.py

@@ -249,55 +249,130 @@ to the best available LLM node — either on this device or on a peer.
             if model and model != "auto":
                 params["model"] = model
 
-            # --- Agent mode: multi-step ReAct loop over real mesh tools --------
+            # --- Agent mode -------------------------------------------------------
+            # Strategy: always execute a real corpus search first (guaranteed to
+            # work regardless of model size), then let the LLM synthesise an
+            # answer with that context. Additional ReAct tool calls are shown
+            # as steps if the model happens to emit them in the right format.
             if agent:
-                from hearthnet.services.llm.tools import default_tool_set
+                steps: list[dict] = []
 
-                async def _call_llm(msgs: list) -> str:
-                    res = await bus.call(
-                        "llm.chat",
+                # Step 1 — always search local + peer corpus
+                corpus_to_search = corpus if corpus and corpus != "(none)" else None
+                search_chunks: list[dict] = []
+                try:
+                    _sq = message
+                    _sr = await bus.call(
+                        "rag.federated_query",
                         (1, 0),
-                        {"params": dict(params), "input": {"messages": msgs}},
+                        {
+                            "input": {
+                                "query": _sq,
+                                "k": 5,
+                                **({"corpus": corpus_to_search} if corpus_to_search else {}),
+                            },
+                        },
                     )
-                    if isinstance(res, dict) and "error" in res:
-                        raise RuntimeError(res.get("message", res.get("error", "llm error")))
-                    out = res.get("output", {}) if isinstance(res, dict) else {}
-                    return (
-                        out.get("message", {}).get("content")
-                        or out.get("text")
-                        or ""
+                    search_chunks = _sr.get("output", {}).get("chunks", [])
+                    _peers = _sr.get("meta", {}).get("peers_asked", 0)
+                    steps.append({
+                        "type": "tool",
+                        "name": "search_corpus",
+                        "args": {"query": _sq, "corpus": corpus_to_search or "community"},
+                        "observation": (
+                            f"Found {len(search_chunks)} passages"
+                            + (f" (asked {_peers} peer(s))" if _peers else " (local)")
+                            + ((":\n" + "\n---\n".join(c["text"][:200] for c in search_chunks[:3])) if search_chunks else ": no results")
+                        ),
+                        "is_error": False,
+                    })
+                except Exception as _se:
+                    steps.append({
+                        "type": "tool",
+                        "name": "search_corpus",
+                        "args": {"query": message},
+                        "observation": f"Search error: {_se}",
+                        "is_error": True,
+                    })
+
+                # Step 2 — list peers on the mesh
+                try:
+                    _pl = await bus.call("market.list", (1, 0), {"input": {}})
+                    _items = _pl.get("output", {}).get("items", [])
+                    if _items:
+                        steps.append({
+                            "type": "tool",
+                            "name": "list_marketplace",
+                            "args": {},
+                            "observation": f"{len(_items)} item(s) on mesh marketplace",
+                            "is_error": False,
+                        })
+                except Exception:
+                    pass
+
+                # Step 3 — call LLM with all gathered context
+                _ctx_parts: list[str] = []
+                if search_chunks:
+                    _ctx_parts.append(
+                        "Relevant passages from HearthNet knowledge base:\n"
+                        + "\n---\n".join(
+                            f"[{c.get('metadata', {}).get('doc_title', 'doc')}] {c['text'][:600]}"
+                            for c in search_chunks[:4]
+                        )
                     )
-
-                executor = default_tool_set(bus)
-                loop_history = [
+                _safe_ctx = "\n\n".join(_ctx_parts)[:5000].replace("\x00", "")
+
+                llm_messages: list[dict] = []
+                if _safe_ctx:
+                    llm_messages.append({
+                        "role": "system",
+                        "content": (
+                            "You are the HearthNet assistant. "
+                            "Use the context below to answer the user's question accurately. "
+                            "If the context doesn't contain the answer, say so clearly.\n\n"
+                            + _safe_ctx
+                        ),
+                    })
+                llm_messages.extend(
                     {"role": h["role"], "content": _msg_text(h["content"])}
-                    for h in history[:-1]
-                ]
+                    for h in history
+                )
+
                 try:
-                    agent_result = await executor.run_react_loop(
-                        message,
-                        _call_llm,
-                        history=loop_history,
-                        max_iterations=6,
-                    )
-                    reply = agent_result["final"] or "(agent produced no final answer)"
-                    history.append({"role": "assistant", "content": reply})
-                    return (
-                        history,
-                        "",
-                        gr.update(visible=False),
-                        gr.update(visible=False),
-                        gr.update(visible=True, value=agent_result["steps"]),
-                    )
-                except Exception as exc:
-                    history.append({"role": "assistant", "content": f"❌ Agent error: {exc}"})
-                    return (
-                        history,
-                        "",
-                        gr.update(visible=False),
-                        gr.update(visible=False),
-                        gr.update(visible=True, value=[{"type": "error", "text": str(exc)}]),
+                    _llm_res = await bus.call(
+                        "llm.chat",
+                        (1, 0),
+                        {"params": dict(params), "input": {"messages": llm_messages}},
                     )
+                    if "error" in _llm_res:
+                        reply = f"⚠️ LLM error: {_llm_res.get('message', _llm_res.get('error'))}"
+                    else:
+                        _out = _llm_res.get("output", {})
+                        reply = (
+                            _out.get("message", {}).get("content")
+                            or _out.get("text")
+                            or "(no response)"
+                        )
+                    steps.append({"type": "final", "text": reply})
+                except Exception as _le:
+                    reply = f"❌ LLM error: {_le}"
+                    steps.append({"type": "final", "text": reply})
+
+                history.append({"role": "assistant", "content": reply})
+                return (
+                    history,
+                    "",
+                    gr.update(visible=bool(search_chunks), value=[
+                        {
+                            "rank": c.get("rank", i),
+                            "text": c["text"][:120],
+                            "source": c.get("metadata", {}).get("doc_title", "unknown"),
+                        }
+                        for i, c in enumerate(search_chunks)
+                    ]),
+                    gr.update(visible=False),
+                    gr.update(visible=True, value=steps),
+                )
 
             trace: dict = {"rag": None, "llm": None, "routed_to": None}
             try: