Close v1 swarm: fresh-participant smoke test, join retries, README fleet note.

Retry announce/manifest while Tor circuits warm on NODE and startup bootstrap.
Add verify_swarm_fresh_participant.py for empty-volume GHCR smoke tests.

Co-authored-by: Cursor <cursoragent@cursor.com>

backend/main.py

@@ -1469,10 +1469,9 @@ def _refresh_node_peer_store(*, now: float | None = None) -> dict[str, Any]:
 
 def _swarm_bootstrap_after_transport_ready() -> None:
     try:
-        from services.mesh.mesh_swarm_runtime import announce_local_peer_to_seeds, refresh_swarm_manifest_from_seeds
+        from services.mesh.mesh_swarm_runtime import join_swarm_with_retries
 
-        announce_local_peer_to_seeds(force=True)
-        refresh_swarm_manifest_from_seeds(force=True)
+        join_swarm_with_retries(attempts=4, delay_s=15.0, force=True)
         _refresh_node_peer_store()
     except Exception:
         logger.warning("swarm bootstrap after transport ready failed", exc_info=True)

backend/services/mesh/mesh_swarm_runtime.py

@@ -389,6 +389,52 @@ def announce_local_peer_to_seeds(*, now: float | None = None, force: bool = Fals
     return {"ok": ok, "peer_url": peer_url, "results": results}
 
 
+def _announce_succeeded(announce: dict[str, Any]) -> bool:
+    if not bool(announce.get("ok")):
+        return False
+    results = announce.get("results") or []
+    return any(bool(item.get("ok")) and int(item.get("status_code") or 0) == 200 for item in results)
+
+
+def _manifest_succeeded(manifest: dict[str, Any]) -> bool:
+    if not bool(manifest.get("ok")):
+        return False
+    peer_count = int(manifest.get("merged_peer_count") or manifest.get("peer_count") or 0)
+    return peer_count >= 1
+
+
+def join_swarm_with_retries(
+    *,
+    attempts: int = 6,
+    delay_s: float = 15.0,
+    force: bool = True,
+) -> dict[str, Any]:
+    """Announce to seed and pull manifest, retrying while Tor circuits warm up."""
+    last_announce: dict[str, Any] = {"ok": False, "detail": "not attempted"}
+    last_manifest: dict[str, Any] = {"ok": False, "detail": "not attempted"}
+    tries = max(1, int(attempts))
+    pause_s = max(1.0, float(delay_s))
+    for attempt in range(tries):
+        last_announce = announce_local_peer_to_seeds(force=force)
+        last_manifest = refresh_swarm_manifest_from_seeds(force=force)
+        if _announce_succeeded(last_announce) and _manifest_succeeded(last_manifest):
+            return {
+                "ok": True,
+                "attempts": attempt + 1,
+                "announce": last_announce,
+                "manifest_pull": last_manifest,
+            }
+        if attempt + 1 < tries:
+            time.sleep(pause_s)
+    return {
+        "ok": False,
+        "attempts": tries,
+        "announce": last_announce,
+        "manifest_pull": last_manifest,
+        "detail": "swarm join incomplete after retries",
+    }
+
+
 def push_infonet_events_to_http_peers(events: list[dict[str, Any]]) -> dict[str, Any]:
     import hashlib as _hashlib_mod
     import hmac as _hmac_mod

backend/services/openclaw_infonet.py

@@ -47,10 +47,7 @@ def ensure_infonet_ready(*, join_swarm: bool = True) -> dict[str, Any]:
     """Warm Tor, enable the participant node, and optionally join the swarm."""
     from routers.ai_intel import _write_env_value
     from services.config import get_settings
-    from services.mesh.mesh_swarm_runtime import (
-        announce_local_peer_to_seeds,
-        refresh_swarm_manifest_from_seeds,
-    )
+    from services.mesh.mesh_swarm_runtime import join_swarm_with_retries
     from services.node_settings import read_node_settings, write_node_settings
     from services.tor_hidden_service import tor_service
     from services.wormhole_supervisor import _check_arti_ready
@@ -87,9 +84,11 @@ def ensure_infonet_ready(*, join_swarm: bool = True) -> dict[str, Any]:
         steps["node_enabled"] = True
 
     if join_swarm:
-        steps["announce"] = announce_local_peer_to_seeds(force=True)
-        steps["manifest_pull"] = refresh_swarm_manifest_from_seeds(force=True)
-        ok = bool(steps["announce"].get("ok")) or bool(steps["manifest_pull"].get("ok"))
+        joined = join_swarm_with_retries()
+        steps["announce"] = joined.get("announce") or {}
+        steps["manifest_pull"] = joined.get("manifest_pull") or {}
+        steps["swarm_attempts"] = joined.get("attempts")
+        ok = bool(joined.get("ok"))
     else:
         ok = True
 
@@ -102,17 +101,15 @@ def ensure_infonet_ready(*, join_swarm: bool = True) -> dict[str, Any]:
 
 
 def join_infonet_swarm() -> dict[str, Any]:
-    from services.mesh.mesh_swarm_runtime import (
-        announce_local_peer_to_seeds,
-        refresh_swarm_manifest_from_seeds,
-    )
+    from services.mesh.mesh_swarm_runtime import join_swarm_with_retries
 
-    announce = announce_local_peer_to_seeds(force=True)
-    manifest = refresh_swarm_manifest_from_seeds(force=True)
+    joined = join_swarm_with_retries()
     return {
-        "ok": bool(announce.get("ok")) or bool(manifest.get("ok")),
-        "announce": announce,
-        "manifest_pull": manifest,
+        "ok": bool(joined.get("ok")),
+        "announce": joined.get("announce") or {},
+        "manifest_pull": joined.get("manifest_pull") or {},
+        "attempts": joined.get("attempts"),
+        "detail": joined.get("detail"),
     }
 
 

backend/tests/mesh/test_swarm_join_retries.py

@@ -0,0 +1,25 @@
+from services.mesh import mesh_swarm_runtime as swarm
+
+
+def test_join_swarm_with_retries_succeeds_on_second_attempt(monkeypatch):
+    calls = {"n": 0}
+
+    def fake_announce(*, force=True):
+        calls["n"] += 1
+        if calls["n"] < 2:
+            return {"ok": False, "results": [{"ok": False, "status_code": 503}]}
+        return {"ok": True, "results": [{"ok": True, "status_code": 200}]}
+
+    def fake_manifest(*, force=True, now=None):
+        if calls["n"] < 2:
+            return {"ok": False, "detail": "manifest fetch failed"}
+        return {"ok": True, "peer_count": 3, "merged_peer_count": 3}
+
+    monkeypatch.setattr(swarm, "announce_local_peer_to_seeds", fake_announce)
+    monkeypatch.setattr(swarm, "refresh_swarm_manifest_from_seeds", fake_manifest)
+    monkeypatch.setattr(swarm.time, "sleep", lambda _s: None)
+
+    joined = swarm.join_swarm_with_retries(attempts=3, delay_s=1.0)
+
+    assert joined["ok"] is True
+    assert joined["attempts"] == 2