diff --git a/README.md b/README.md
index e2c0b22..1220530 100644
--- a/README.md
+++ b/README.md
@@ -313,6 +313,19 @@ volume.
 Agents send with `scripts/whatsapp-push.py` and resolve contacts with
 `scripts/whatsapp-contacts.py`.
 
+Sends to a **first-contact recipient** (a number whose device list the bridge
+has not cached) can stall in the usync device-list lookup while the link — and
+`/health` — stay green. The gateway handles this itself: on a usync failure it
+retries against the recipient's **LID** when the store knows one (any contact
+who has messaged this account before — that path delivers where the raw-number
+lookup stalls), then once more after a backoff (`WHATSAPP_SEND_USYNC_RETRIES`,
+default 1; `WHATSAPP_SEND_USYNC_BACKOFF`, default 15 s), without ever re-sending
+the parts of a multi-part send that already went out. If every attempt fails,
+the pending send terminates with a clear error on `/sends`, and `/health`
+reports `recipient_lookup_ok: false` (shown as a warning on `/gateways`; the
+evidence decays after `WHATSAPP_RECIPIENT_LOOKUP_TTL`, default 30 min, since it
+cannot be re-probed safely).
+
 ### Telegram accounts
 
 Telegram is reached through the sibling `telegram-gateway` service, which logs in
diff --git a/scripts/web-gateway.py b/scripts/web-gateway.py
index 96eb9c1..5e5593f 100644
--- a/scripts/web-gateway.py
+++ b/scripts/web-gateway.py
@@ -1621,6 +1621,7 @@ def _start_conv_turn(cid: str) -> None:
 
 _SEND_SINGLE_RE = re.compile(r"^/sends/([^/]+)/([^/]+?)/?$")
 _SEND_ACTION_RE = re.compile(r"^/sends/([^/]+)/([^/]+)/(approve|reject)/?$")
+_SEND_STATUS_RE = re.compile(r"^/sends/([^/]+)/([^/]+)/status/?$")
 _GATEWAY_HEALTH_RE = re.compile(r"^/gateways/([A-Za-z0-9._-]+)/health/?$")
 _GATEWAY_QR_RE = re.compile(r"^/gateways/([A-Za-z0-9._-]+)/qr/?$")
 
@@ -1793,7 +1794,10 @@ def _render_channel_send_html(detail: dict, channel: str, request_id: str, next_
     recipient = html.escape(detail.get("recipient") or detail.get("to") or "")
     cat = html.escape(detail.get("category") or "")
     msg = html.escape(detail.get("message") or "")
-    skip = html.escape(next_url) if next_url else "/sends"
+    # "Skip" jumps to the next pending request — rendered only when one exists
+    # (the nav already links back to /sends and the dashboard).
+    skip_btn = (f'  <a href="{html.escape(next_url)}" id="btn-skip" class="btn btn-skip">Skip</a>\n'
+                if next_url else "")
     meta_rows = [
         f"<tr><th>Channel</th><td>{label_e}</td></tr>",
         f"<tr><th>To</th><td>{recipient}</td></tr>",
@@ -1801,37 +1805,97 @@ def _render_channel_send_html(detail: dict, channel: str, request_id: str, next_
     ]
     status = detail.get("status") or "pending"
     if status != "pending":
+        # Status page: a "sending" entry shows a spinner and polls the JSON
+        # status endpoint client-side — no full-page refresh flicker. Success
+        # flips the spinner to a green check and auto-advances a moment later:
+        # to the next pending request when one exists, else the page tries to
+        # close itself (falling back to /sends — window.close() only works for
+        # script-opened windows). The next-request button is rendered only when
+        # a next request actually exists; a failure shows the gateway's real
+        # error and stays put so the user can read it.
         if status == "sending":
-            headline = "Sending…"
-            note = ("The gateway accepted the send and is delivering it in the "
-                    "background. This page refreshes until it completes.")
-            extra_head = '<meta http-equiv="refresh" content="2">\n'
+            icon = '<div class="spin" role="status" aria-label="sending"></div>'
+            note = "Delivering in the background…"
         elif status == "approved":
-            headline = "Sent ✓"
-            note = "The message was delivered to the channel."
-            extra_head = ""
+            icon = '<div class="check">✓</div>'
+            note = "Sent."
         elif status == "rejected":
-            headline = "Rejected"
+            icon = '<div class="cross">✕</div>'
             note = "The message was discarded without sending."
-            extra_head = ""
         else:  # "error"
-            headline = "Send failed"
+            icon = '<div class="cross">✕</div>'
             note = ("The gateway could not deliver the message: "
                     + (detail.get("error") or "unknown error"))
-            extra_head = ""
         return (
             _HTML_HEAD
             + f"<title>Retinue — {label_e} Send {rid}</title>\n"
-            + extra_head
+            # No-JS fallback only: with scripting available the page polls
+            # instead of reloading.
+            + ('<noscript><meta http-equiv="refresh" content="2"></noscript>\n'
+               if status == "sending" else "")
+            + "<style>\n"
+              "  .st-row{display:flex;align-items:center;gap:.9rem;margin:1.1rem 0}\n"
+              "  .spin{width:34px;height:34px;border:4px solid var(--line);"
+              "border-top-color:var(--accent);border-radius:50%;animation:st-spin 1s linear infinite}\n"
+              "  @keyframes st-spin{to{transform:rotate(360deg)}}\n"
+              "  .check,.cross{width:38px;height:38px;border-radius:50%;display:flex;"
+              "align-items:center;justify-content:center;font-size:1.35rem;font-weight:700}\n"
+              "  .check{background:var(--ok);color:#0b0d12}\n"
+              "  .cross{background:var(--high);color:#0b0d12}\n"
+              "</style>\n"
             + "<body>\n"
-            + f"<h1>{label_e} send: {html.escape(headline)}</h1>\n"
+            + f"<h1>{label_e} send</h1>\n"
             + f'<nav>{_NAV_HOME}<a href="/sends">↑ All pending sends</a></nav>\n'
             + '<table class="answer">\n' + "\n".join(meta_rows) + "\n</table>\n"
             + f'<pre class="msg-body">{msg}</pre>\n'
-            + f'<p class="meta">{html.escape(note)}</p>\n'
+            + f'<div class="st-row"><div id="st-icon">{icon}</div>'
+            + f'<p id="st-note" class="meta">{html.escape(note)}</p></div>\n'
             + '<div class="actions">\n'
-            + '  <a href="/sends/next" class="btn btn-skip">Next pending send</a>\n'
+            + f'  <a id="st-next" href="{html.escape(next_url or "/sends")}" class="btn btn-skip"'
+            + f' style="{"" if next_url else "display:none"}">Next pending send</a>\n'
             + "</div>\n"
+            + "<script>\n"
+              "(function(){\n"
+            + f"  var status={json.dumps(status)};\n"
+            + f"  var nextUrl={json.dumps(next_url)};\n"
+            + f"  var pollUrl={json.dumps(f'/sends/{channel}/{request_id}/status')};\n"
+            + "  var icon=document.getElementById('st-icon');\n"
+              "  var note=document.getElementById('st-note');\n"
+              "  var nextBtn=document.getElementById('st-next');\n"
+              "  function showNext(){if(nextUrl&&nextBtn){nextBtn.href=nextUrl;nextBtn.style.display='';}}\n"
+              "  function advance(){\n"
+              "    if(nextUrl){location=nextUrl;return;}\n"
+              "    window.close();\n"
+              "    setTimeout(function(){location='/sends';},400);\n"
+              "  }\n"
+              "  function terminal(st,err){\n"
+              "    if(st==='approved'){\n"
+              "      icon.innerHTML='<div class=\"check\">✓</div>';\n"
+              "      note.textContent='Sent.';\n"
+              "      setTimeout(advance,1500);\n"
+              "    }else if(st==='rejected'){\n"
+              "      icon.innerHTML='<div class=\"cross\">✕</div>';\n"
+              "      note.textContent='The message was discarded without sending.';\n"
+              "      showNext();\n"
+              "    }else{\n"
+              "      icon.innerHTML='<div class=\"cross\">✕</div>';\n"
+              "      note.textContent='The gateway could not deliver the message: '+(err||'unknown error');\n"
+              "      showNext();\n"
+              "    }\n"
+              "  }\n"
+              "  function poll(){\n"
+              "    fetch(pollUrl,{cache:'no-store'}).then(function(r){return r.json();}).then(function(b){\n"
+              "      if(b.status&&b.status!=='sending'&&b.status!=='pending'){\n"
+              "        if('next' in b){nextUrl=b.next;}\n"
+              "        terminal(b.status,b.error);\n"
+              "      }else{setTimeout(poll,1500);}\n"
+              "    }).catch(function(){setTimeout(poll,3000);});\n"
+              "  }\n"
+              "  if(status==='sending'){setTimeout(poll,1200);}\n"
+              "  else if(status==='approved'){setTimeout(advance,1500);}\n"
+              "  else{showNext();}\n"
+              "})();\n"
+              "</script>\n"
             + "</body>\n</html>\n"
         )
     return (
@@ -1847,7 +1911,7 @@ def _render_channel_send_html(detail: dict, channel: str, request_id: str, next_
           f'<button type="submit" id="btn-approve" class="btn btn-allow">Allow</button></form>\n'
         + f'  <form method="post" action="/sends/{chan}/{rid}/reject" id="form-reject">'
           f'<button type="submit" id="btn-reject" class="btn btn-deny">Deny</button></form>\n'
-        + f'  <a href="{skip}" id="btn-skip" class="btn btn-skip">Skip</a>\n'
+        + skip_btn
         + "</div>\n"
         + "<script>\n"
           "(function(){\n"
@@ -1970,6 +2034,14 @@ def _render_gateways_html(statuses: list[dict]) -> str:
             rows.append('<p class="meta">The device is still paired — no QR scan needed; '
                         'the gateway recovers on its own or reports the error above.</p>')
         elif connected:
+            # A connected gateway can still be degraded: WhatsApp reports
+            # recipient_lookup_ok: false while outbound sends to uncached
+            # (first-contact) recipients fail their device-list lookup, even
+            # though the link — and the own-JID probe — are fine (issue #120).
+            if h.get("recipient_lookup_ok") is False:
+                rl_err = h.get("recipient_lookup_error") or "device-list resolution is failing"
+                rows.append('<p class="meta">⚠ Outbound sends to new (first-contact) recipients '
+                            'are currently failing: ' + html.escape(str(rl_err)) + '</p>')
             age = h.get("last_ok_age")
             if isinstance(age, (int, float)):
                 rows.append(f'<p class="meta">Last verified {int(age)}s ago.</p>')
@@ -3485,6 +3557,11 @@ def do_GET(self):
         if gw_qr_match:
             self._handle_gateway_qr(gw_qr_match.group(1))
             return
+        send_status_match = _SEND_STATUS_RE.match(conv_path)
+        if send_status_match:
+            self._handle_channel_send_status(send_status_match.group(1),
+                                             send_status_match.group(2))
+            return
         if self.path in ("/sends", "/sends/"):
             self._send_html(200, _render_sends_index_html(_all_pending()))
         elif self.path in ("/sends/next", "/sends/next/"):
@@ -3602,8 +3679,49 @@ def _handle_channel_send_single(self, channel: str, request_id: str) -> None:
                     nxt = pending[idx + 1]
                     next_url = f"/sends/{nxt['account']}/{nxt['request_id']}"
                 break
+        else:
+            # This request is no longer in the pending list (it is sending or
+            # terminal): the "next request" is simply the first still-pending
+            # one, if any — the status page advances there after success.
+            if pending:
+                next_url = f"/sends/{pending[0]['account']}/{pending[0]['request_id']}"
         self._send_html(200, _render_channel_send_html(detail, channel, request_id, next_url))
 
+    def _handle_channel_send_status(self, account: str, request_id: str) -> None:
+        """Lean JSON status for a channel pending send.
+
+        What the send status page polls instead of reloading itself. Once the
+        send is terminal the body also carries `next` — the URL of the next
+        still-pending request, or null — so the page can auto-advance without
+        a second lookup.
+        """
+        channel, gw = _channel_gateway(account)
+        if not gw:
+            self._send_json(404, {"error": "unknown channel"})
+            return
+        url = f"{gw['base_url']}/pending-sends/{request_id}"
+        headers = {}
+        if gw.get("token"):
+            headers["Authorization"] = "Bearer " + gw["token"]
+        try:
+            req = urllib.request.Request(url, headers=headers)
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                detail = json.loads(resp.read().decode("utf-8"))
+        except urllib.error.HTTPError as exc:
+            self._send_json(exc.code, {"error": "not found" if exc.code == 404 else "gateway error"})
+            return
+        except Exception as exc:  # noqa: BLE001 - poller retries on its own
+            self._send_json(502, {"error": f"gateway unreachable: {exc}"})
+            return
+        body = {"status": detail.get("status"), "error": detail.get("error")}
+        if body["status"] not in ("pending", "sending"):
+            pending = _all_pending()
+            nxt = next((p for p in pending
+                        if not (p.get("account") == channel
+                                and p.get("request_id") == request_id)), None)
+            body["next"] = (f"/sends/{nxt['account']}/{nxt['request_id']}" if nxt else None)
+        self._send_json(200, body)
+
     def _handle_gateway_qr(self, slug: str) -> None:
         """Proxy a gateway's pairing QR (adding the token) to the /gateways page.
 
diff --git a/scripts/whatsapp-gateway.py b/scripts/whatsapp-gateway.py
index 434df9d..3ac4466 100644
--- a/scripts/whatsapp-gateway.py
+++ b/scripts/whatsapp-gateway.py
@@ -304,6 +304,13 @@ def _approval_slug(host_header) -> str:
     "iq_error": None,
     "iq_fails": 0,        # consecutive failed probes
     "iq_checked": None,
+    # Outcome of the last outbound delivery's recipient resolution (issue
+    # #120). Kept separate from the probe state: the probe usyncs our OWN JID,
+    # which can succeed while an arbitrary recipient's device-list lookup times
+    # out — see _note_recipient_lookup().
+    "recipient_lookup_ok": None,
+    "recipient_lookup_error": None,
+    "recipient_lookup_at": None,
 }
 
 # How often the probe thread completes an IQ round trip (0 disables the probe;
@@ -315,6 +322,14 @@ def _approval_slug(host_header) -> str:
 WHATSAPP_IQ_PROBE_FAILURES = int(os.environ.get("WHATSAPP_IQ_PROBE_FAILURES", "") or "2")
 # Minimum seconds between automatic reconnect attempts while IQ stays wedged.
 WHATSAPP_IQ_RECONNECT_BACKOFF = float(os.environ.get("WHATSAPP_IQ_RECONNECT_BACKOFF", "") or "600")
+# Outbound usync/device-list failures (issue #120): how many extra attempts a
+# send gets after the candidate JIDs are exhausted, and the pause before each.
+WHATSAPP_SEND_USYNC_RETRIES = int(os.environ.get("WHATSAPP_SEND_USYNC_RETRIES", "") or "1")
+WHATSAPP_SEND_USYNC_BACKOFF = float(os.environ.get("WHATSAPP_SEND_USYNC_BACKOFF", "") or "15")
+# How long a recorded recipient-lookup failure keeps /health's
+# recipient_lookup_ok at false before the evidence is considered stale (it is
+# tied to whoever was last messaged, so it decays instead of being probed).
+WHATSAPP_RECIPIENT_LOOKUP_TTL = float(os.environ.get("WHATSAPP_RECIPIENT_LOOKUP_TTL", "") or "1800")
 
 
 def _set_conn(**changes) -> None:
@@ -323,6 +338,28 @@ def _set_conn(**changes) -> None:
         _conn["last_change"] = time.time()
 
 
+def _note_recipient_lookup(ok: bool, error: str | None = None) -> None:
+    """Record the outcome of an outbound delivery's recipient resolution.
+
+    Deliberately separate from the IQ-probe state: the probe usyncs our OWN
+    JID, which can succeed while resolving an arbitrary recipient's device
+    list times out (issue #120) — folding send failures into iq_ok would flap
+    against the green probe. This is an informational health signal (exposed
+    as recipient_lookup_ok in /health and warned about on /gateways); it does
+    not flip `connected`, because a failure is tied to whoever was messaged
+    last and there is no safe way to re-probe it — the evidence decays after
+    WHATSAPP_RECIPIENT_LOOKUP_TTL instead.
+    """
+    with _CONN_LOCK:
+        _conn["recipient_lookup_at"] = time.time()
+        if ok:
+            _conn["recipient_lookup_ok"] = True
+            _conn["recipient_lookup_error"] = None
+        else:
+            _conn["recipient_lookup_ok"] = False
+            _conn["recipient_lookup_error"] = (error or "recipient lookup failed")[:500]
+
+
 def _note_iq_result(ok: bool, error: str | None = None) -> bool:
     """Fold one IQ probe result into the connection state.
 
@@ -367,6 +404,11 @@ def _health_snapshot() -> dict:
                  + (state["iq_error"] or "info query timed out"))
     connected = link_up and not iq_wedged
     qr_available = WHATSAPP_QR_PNG_PATH.exists()
+    rl_ok = state["recipient_lookup_ok"]
+    rl_error = state["recipient_lookup_error"]
+    rl_at = state["recipient_lookup_at"]
+    if rl_ok is False and rl_at and time.time() - rl_at > WHATSAPP_RECIPIENT_LOOKUP_TTL:
+        rl_ok, rl_error = None, None  # the evidence went stale
     return {
         "status": "ok",
         "configured": True,  # linking IS the configuration; nothing else is needed
@@ -380,6 +422,8 @@ def _health_snapshot() -> dict:
         # the device is still linked there, so the /gateways page must show the
         # error, not a pairing QR that cannot exist.
         "needs_repair": bool(state["logged_out"] or state["pairing"] or qr_available),
+        "recipient_lookup_ok": rl_ok,
+        "recipient_lookup_error": rl_error if rl_ok is False else None,
         "error": None if connected else error,
     }
 
@@ -796,38 +840,171 @@ def _download_media(message) -> Path | None:
     return Path(out)
 
 
+def _is_usync_error(exc: Exception) -> bool:
+    """True when a send failure is the usync/device-list resolution class.
+
+    whatsmeow reports a recipient whose device list cannot be resolved (a
+    first-contact / uncached number, issue #120) as "failed to get device
+    list: failed to send usync query: info query timed out". Only this class
+    is retried / LID-falled-back; anything else propagates unchanged.
+    """
+    text = str(exc).lower()
+    return "usync" in text or "device list" in text or "info query timed out" in text
+
+
+def _pn_to_lid(user: str) -> str | None:
+    """Resolve a phone-number user to its LID via the bridge's LID store.
+
+    The reverse of _lid_to_pn: whatsmeow keeps the PN↔LID mapping, populated
+    by inbound traffic and contact sync. A contact who has messaged this
+    account before therefore has a LID here — and per issue #120 a
+    LID-addressed send delivers where the phone-number path stalls in the
+    usync device-list lookup (the LID chat's devices are already cached from
+    the inbound). Returns None when the store holds no mapping (a true first
+    contact) or the installed neonize has no lookup method.
+    """
+    client = _wa_client
+    if client is None or not user:
+        return None
+    fn = getattr(client, "get_lid_from_pn", None)
+    if not callable(fn):
+        return None
+    from neonize.utils import build_jid  # noqa: PLC0415 - localized bridge dep
+    try:
+        with WA_CLIENT_LOCK:
+            lid = fn(build_jid(user, WA_PN_SERVER))
+    except Exception:  # noqa: BLE001 - any store miss means "no mapping"
+        return None
+    resolved = _jid_user(lid)
+    if resolved and resolved != user:
+        return resolved
+    return None
+
+
+def _build_send_ops(text: str | None, media_paths: list[Path] | None) -> list[dict]:
+    """Represent one logical send as an ordered list of per-message operations.
+
+    The first media op carries the text as its caption (WhatsApp's own
+    presentation); a standalone text op is emitted only when no media consumed
+    it. Keeping the parts explicit is what lets the retry engine resume after
+    a partial failure without re-sending the parts that already went out.
+    """
+    text = (text or "").strip()
+    ops: list[dict] = []
+    for path in media_paths or []:
+        ops.append({"kind": "media", "path": Path(path), "caption": text})
+        text = ""
+    if text:
+        ops.append({"kind": "text", "text": text})
+    return ops
+
+
+def _run_send_op(jid, op: dict) -> None:
+    """Execute one send operation against the bridge (serialized via the lock).
+
+    Deliberately per-op locking, not one lock around the whole logical send:
+    the retry engine sleeps between attempts, and holding WA_CLIENT_LOCK
+    through a backoff would block the receive callback and the IQ probe. The
+    accepted trade-off is that two concurrently-approved multi-part sends may
+    interleave their parts in a chat.
+    """
+    client = _wa_client
+    with WA_CLIENT_LOCK:
+        if op["kind"] == "text":
+            client.send_message(jid, op["text"])
+            return
+        path = op["path"]
+        data = path.read_bytes()
+        mime = mimetypes.guess_type(str(path))[0] or "application/octet-stream"
+        if mime.startswith("image/"):
+            # build_image_message derives the mime type from the bytes itself
+            # and takes no mime keyword — passing one raises TypeError.
+            msg = client.build_image_message(data, caption=op["caption"] or "")
+        else:
+            # neonize's document builder spells the parameter `mimetype`
+            # (not `mime_type`); the wrong spelling crashed every PDF send.
+            msg = client.build_document_message(
+                data, filename=path.name, caption=op["caption"] or "", mimetype=mime
+            )
+        client.send_message(jid, message=msg)
+
+
+def _send_ops_with_retry(candidates: list, ops: list[dict], runner, label: str,
+                         retries: int | None = None, backoff: float | None = None) -> None:
+    """Run `ops` in order, retrying usync/device-list failures (issue #120).
+
+    `candidates` are the JIDs to try, best first — typically the phone-number
+    JID, then the recipient's LID when the store knows one (the path that
+    delivers where the phone-number lookup stalls). After the candidates are
+    exhausted, the last one gets `retries` further attempts, each preceded by
+    `backoff` seconds. Completed ops are never re-run, so a failure between
+    the parts of a multi-part send cannot duplicate the parts already sent.
+    A non-usync failure propagates immediately. When every attempt fails, the
+    recipient-lookup health signal is recorded and a clear terminal error is
+    raised — this is what the /sends page shows (issue #116).
+    """
+    retries = WHATSAPP_SEND_USYNC_RETRIES if retries is None else retries
+    backoff = WHATSAPP_SEND_USYNC_BACKOFF if backoff is None else backoff
+    plan = [(cand, 0.0) for cand in candidates]
+    plan += [(candidates[-1], backoff)] * max(0, retries)
+    idx = 0
+    last_exc: Exception | None = None
+    for attempt_no, (jid, delay) in enumerate(plan):
+        if delay:
+            time.sleep(delay)
+        try:
+            while idx < len(ops):
+                runner(jid, ops[idx])
+                idx += 1
+            if last_exc is None:
+                _note_recipient_lookup(True)
+            else:
+                # Delivered — but only via the LID fallback / a retry. That is
+                # direct evidence that raw-number (uncached) resolution is
+                # broken right now, so record it as a lookup failure: /health
+                # and /gateways then warn while true first-contact recipients
+                # remain unreachable, instead of the rescue masking the state.
+                _note_recipient_lookup(False, "delivered via fallback/retry; raw-number "
+                                              f"usync lookup failed: {last_exc}")
+            return
+        except Exception as exc:  # noqa: BLE001 - classified below
+            if not _is_usync_error(exc):
+                raise
+            last_exc = exc
+            print(f"[whatsapp-gateway] usync/device-list failure sending to {label} "
+                  f"(attempt {attempt_no + 1}/{len(plan)}): {exc}", flush=True)
+    _note_recipient_lookup(False, str(last_exc))
+    raise RuntimeError(
+        f"could not resolve the recipient's device list after {len(plan)} attempt(s): "
+        f"{last_exc}. First-contact (uncached) recipients are currently failing this "
+        f"lookup; a recipient who has messaged this account before stays reachable, "
+        f"and a later retry may succeed."
+    )
+
+
 def _wa_send(recipient: str, text: str | None, media_paths: list[Path] | None = None) -> None:
     """Send a WhatsApp message: optional text plus any number of media files.
 
-    Serialized via WA_CLIENT_LOCK so it never races the receive callback.
+    Bridge calls are serialized via WA_CLIENT_LOCK (inside _run_send_op) so
+    they never race the receive callback. A usync/device-list failure — the
+    first-contact stall of issue #120 — is retried: first against the
+    recipient's LID when the store knows one, then after a backoff.
     """
     client = _wa_client
     if client is None:
         raise RuntimeError("WhatsApp bridge is not connected yet")
     jid = _to_jid(recipient)
-    text = (text or "").strip()
-    media_paths = media_paths or []
-
-    with WA_CLIENT_LOCK:
-        for path in media_paths:
-            data = Path(path).read_bytes()
-            mime = mimetypes.guess_type(str(path))[0] or "application/octet-stream"
-            if mime.startswith("image/"):
-                # build_image_message derives the mime type from the bytes itself
-                # and takes no mime keyword — passing one raises TypeError.
-                msg = client.build_image_message(data, caption=text or "")
-                client.send_message(jid, message=msg)
-                text = ""  # caption already carried the text with the first image
-            else:
-                # neonize's document builder spells the parameter `mimetype`
-                # (not `mime_type`); the wrong spelling crashed every PDF send.
-                msg = client.build_document_message(
-                    data, filename=Path(path).name, caption=text or "", mimetype=mime
-                )
-                client.send_message(jid, message=msg)
-                text = ""
-        if text:
-            client.send_message(jid, text)
+    ops = _build_send_ops(text, media_paths)
+    if not ops:
+        return
+    candidates = [jid]
+    server = str(_attr(jid, "Server", "server", default="")) or str(jid).rpartition("@")[2]
+    if server == WA_PN_SERVER:
+        lid_user = _pn_to_lid(_jid_user(jid))
+        if lid_user:
+            from neonize.utils import build_jid  # noqa: PLC0415 - localized bridge dep
+            candidates.append(build_jid(lid_user, WA_LID_SERVER))
+    _send_ops_with_retry(candidates, ops, _run_send_op, recipient)
 
 
 def _start_bridge() -> None:
diff --git a/tests/test_web_gateway_send_page.py b/tests/test_web_gateway_send_page.py
new file mode 100644
index 0000000..6da08de
--- /dev/null
+++ b/tests/test_web_gateway_send_page.py
@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+"""Checks for the channel-send status/approval page rendering.
+
+Covers the UX contract of the send status page (issue #116 follow-up): a
+"sending" entry renders a spinner and client-side polling (no full-page
+meta-refresh), success renders the green check and auto-advance, and the
+next-request button appears only when a next request actually exists — on the
+approval page's Skip too.
+
+    python3 tests/test_web_gateway_send_page.py
+"""
+import importlib.util
+import os
+import sys
+import tempfile
+import types
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+SCRIPTS_DIR = REPO_ROOT / "scripts"
+
+
+def _load_gateway(tmp: Path):
+    os.environ["CONVERSATIONS_DIR"] = str(tmp / "convs")
+    os.environ["CONVERSATION_DIR"] = str(tmp / "convlog")
+    os.environ["CHAMBERS_DIR"] = str(tmp / "chambers")
+    os.environ["WEB_GATEWAY_STATE"] = str(tmp / "state.json")
+    (tmp / "chambers").mkdir(parents=True, exist_ok=True)
+    if "markdown_it" not in sys.modules:
+        try:
+            import markdown_it  # noqa: F401
+        except ImportError:
+            stub = types.ModuleType("markdown_it")
+            stub.MarkdownIt = object
+            sys.modules["markdown_it"] = stub
+    sys.path.insert(0, str(SCRIPTS_DIR))
+    spec = importlib.util.spec_from_file_location(
+        "web_gateway_send_page_under_test", SCRIPTS_DIR / "web-gateway.py")
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def _detail(status, **extra):
+    return {"status": status, "recipient": "+15551112222", "category": "verify",
+            "message": "hello", **extra}
+
+
+def test_sending_page_polls_with_spinner():
+    with tempfile.TemporaryDirectory() as tmp:
+        wg = _load_gateway(Path(tmp))
+        out = wg._render_channel_send_html(_detail("sending"), "whatsapp-gateway", "a" * 32, None)
+        assert 'class="spin"' in out                      # rotating symbol
+        assert "/sends/whatsapp-gateway/" + "a" * 32 + "/status" in out  # client-side poll
+        # No unconditional full-page refresh — only the no-JS fallback.
+        assert out.count('http-equiv="refresh"') == 1 and "<noscript>" in out
+        # No next request → the next button stays hidden and nextUrl is null.
+        assert "var nextUrl=null;" in out
+        assert 'id="st-next"' in out and "display:none" in out
+
+
+def test_sending_page_with_next_shows_button():
+    with tempfile.TemporaryDirectory() as tmp:
+        wg = _load_gateway(Path(tmp))
+        out = wg._render_channel_send_html(_detail("sending"), "whatsapp-gateway", "a" * 32,
+                                           "/sends/signal-gateway/bbb")
+        assert 'var nextUrl="/sends/signal-gateway/bbb";' in out
+        assert 'id="st-next" href="/sends/signal-gateway/bbb"' in out
+        assert 'style=""' in out  # button visible
+
+
+def test_approved_page_shows_check_and_advances():
+    with tempfile.TemporaryDirectory() as tmp:
+        wg = _load_gateway(Path(tmp))
+        out = wg._render_channel_send_html(_detail("approved"), "whatsapp-gateway", "a" * 32, None)
+        assert 'class="check"' in out and "✓" in out       # green check
+        assert "setTimeout(advance,1500)" in out           # brief pause, then close/advance
+        assert "window.close()" in out
+
+
+def test_error_page_shows_gateway_error():
+    with tempfile.TemporaryDirectory() as tmp:
+        wg = _load_gateway(Path(tmp))
+        out = wg._render_channel_send_html(
+            _detail("error", error="usync query timed out"), "whatsapp-gateway", "a" * 32, None)
+        assert 'class="cross"' in out
+        assert "usync query timed out" in out
+
+
+def test_approval_page_skip_only_with_next():
+    with tempfile.TemporaryDirectory() as tmp:
+        wg = _load_gateway(Path(tmp))
+        without = wg._render_channel_send_html(_detail("pending"), "whatsapp-gateway", "a" * 32, None)
+        # No skip anchor is rendered (the lockButtons script may still name the
+        # id defensively — only the element matters).
+        assert 'id="btn-skip"' not in without
+        with_next = wg._render_channel_send_html(_detail("pending"), "whatsapp-gateway", "a" * 32,
+                                                 "/sends/signal-gateway/bbb")
+        assert 'id="btn-skip"' in with_next and "/sends/signal-gateway/bbb" in with_next
+
+
+def main() -> int:
+    tests = [test_sending_page_polls_with_spinner,
+             test_sending_page_with_next_shows_button,
+             test_approved_page_shows_check_and_advances,
+             test_error_page_shows_gateway_error,
+             test_approval_page_skip_only_with_next]
+    failures = 0
+    for test in tests:
+        try:
+            test()
+            print(f"PASS {test.__name__}")
+        except AssertionError as exc:
+            failures += 1
+            print(f"FAIL {test.__name__}: {exc}")
+    print(f"{len(tests) - failures}/{len(tests)} passed")
+    return 1 if failures else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/tests/test_whatsapp_health.py b/tests/test_whatsapp_health.py
index c764696..27e36d5 100644
--- a/tests/test_whatsapp_health.py
+++ b/tests/test_whatsapp_health.py
@@ -172,6 +172,121 @@ def test_iq_probe_real_failure_still_raises():
             raise AssertionError("expected the wedge to raise")
 
 
+# ── Outbound usync retry / LID fallback (issue #120) ──────────────────────────
+
+class _Runner:
+    """Fake op runner: fails usync-style for the JIDs in `bad`, else records."""
+
+    def __init__(self, bad=()):
+        self.bad = set(bad)
+        self.sent = []  # (jid, op-kind) in execution order
+
+    def __call__(self, jid, op):
+        if jid in self.bad:
+            raise RuntimeError("failed to get device list: failed to send usync query: "
+                               "info query timed out")
+        self.sent.append((jid, op["kind"]))
+
+
+def test_usync_error_classification():
+    with tempfile.TemporaryDirectory() as tmp:
+        wg = _load_whatsapp_gateway(tmp)
+        assert wg._is_usync_error(RuntimeError(
+            "failed to get device list: failed to send usync query: info query timed out"))
+        assert wg._is_usync_error(RuntimeError("usync query rejected"))
+        assert not wg._is_usync_error(ValueError("recipient not on WhatsApp"))
+
+
+def test_send_falls_back_to_lid():
+    with tempfile.TemporaryDirectory() as tmp:
+        wg = _load_whatsapp_gateway(tmp)
+        runner = _Runner(bad={"pn-jid"})
+        ops = wg._build_send_ops("hello", [Path(tmp) / "doc.pdf"])
+        # The first media op carries the text as caption — no separate text op.
+        assert [op["kind"] for op in ops] == ["media"]
+        assert ops[0]["caption"] == "hello"
+        # The phone-number JID stalls in usync; the cached-LID candidate — the
+        # path that delivered in the issue-#120 repro — takes over.
+        wg._send_ops_with_retry(["pn-jid", "lid-jid"], ops, runner, "+15551112222",
+                                retries=1, backoff=0)
+        assert runner.sent == [("lid-jid", "media")]
+        # The rescue itself witnessed the raw-number lookup failing, so the
+        # health signal must record the degradation — not let the fallback
+        # mask it while true first-contact recipients stay unreachable.
+        snap = wg._health_snapshot()
+        assert snap["recipient_lookup_ok"] is False
+        assert "fallback" in snap["recipient_lookup_error"]
+        # A clean first-candidate success records healthy again.
+        wg._send_ops_with_retry(["ok-jid"], wg._build_send_ops("hi", []), runner, "x",
+                                retries=0, backoff=0)
+        assert wg._health_snapshot()["recipient_lookup_ok"] is True
+
+
+def test_send_partial_failure_never_resends():
+    with tempfile.TemporaryDirectory() as tmp:
+        wg = _load_whatsapp_gateway(tmp)
+
+        sent = []
+        fails = {"n": 0}
+
+        def runner(jid, op):
+            # The first part succeeds on the first candidate; the second part
+            # (caption already consumed → "") stalls in usync once.
+            if op["caption"] == "" and fails["n"] < 1:
+                fails["n"] += 1
+                raise RuntimeError("failed to send usync query: info query timed out")
+            sent.append((jid, op["caption"]))
+
+        ops = wg._build_send_ops("hello", [Path(tmp) / "a.pdf", Path(tmp) / "b.pdf"])
+        assert [op["kind"] for op in ops] == ["media", "media"]
+        wg._send_ops_with_retry(["a", "b"], ops, runner, "x", retries=1, backoff=0)
+        # The first part went out exactly once (on the first candidate); only
+        # the failed second part was re-attempted, on the fallback candidate.
+        assert sent == [("a", "hello"), ("b", "")]
+
+
+def test_send_exhausted_records_lookup_failure():
+    with tempfile.TemporaryDirectory() as tmp:
+        wg = _load_whatsapp_gateway(tmp)
+        runner = _Runner(bad={"pn-jid"})
+        ops = wg._build_send_ops("hello", [])
+        try:
+            wg._send_ops_with_retry(["pn-jid"], ops, runner, "+15551112222",
+                                    retries=1, backoff=0)
+        except RuntimeError as exc:
+            assert "device list" in str(exc) and "First-contact" in str(exc)
+        else:
+            raise AssertionError("expected the exhausted send to raise")
+        snap = wg._health_snapshot()
+        # Informational signal only: the link stays connected (the own-JID
+        # probe is green), but the degradation is visible.
+        assert snap["recipient_lookup_ok"] is False
+        assert "usync" in snap["recipient_lookup_error"]
+        # The evidence decays instead of being cleared by a probe.
+        with wg._CONN_LOCK:
+            wg._conn["recipient_lookup_at"] -= wg.WHATSAPP_RECIPIENT_LOOKUP_TTL + 1
+        assert wg._health_snapshot()["recipient_lookup_ok"] is None
+
+
+def test_send_non_usync_error_propagates():
+    with tempfile.TemporaryDirectory() as tmp:
+        wg = _load_whatsapp_gateway(tmp)
+        calls = []
+
+        def runner(jid, op):
+            calls.append(jid)
+            raise ValueError("recipient not on WhatsApp")
+
+        ops = wg._build_send_ops("hello", [])
+        try:
+            wg._send_ops_with_retry(["a", "b"], ops, runner, "x", retries=3, backoff=0)
+        except ValueError:
+            pass
+        else:
+            raise AssertionError("expected the non-usync error to propagate")
+        assert calls == ["a"]  # no retry, no fallback
+
+
 def test_reconnect_backoff():
     with tempfile.TemporaryDirectory() as tmp:
         wg = _load_whatsapp_gateway(tmp)
@@ -191,6 +306,11 @@ def main() -> int:
              test_iq_probe_discovers_call_shape,
              test_iq_probe_shape_error_is_unsupported_not_down,
              test_iq_probe_real_failure_still_raises,
+             test_usync_error_classification,
+             test_send_falls_back_to_lid,
+             test_send_partial_failure_never_resends,
+             test_send_exhausted_records_lookup_failure,
+             test_send_non_usync_error_propagates,
              test_reconnect_backoff]
     failures = 0
     for test in tests: