diff --git a/plugins/platforms/dingtalk/adapter.py b/plugins/platforms/dingtalk/adapter.py
index bee8d6b3a5..52137ebf50 100644
--- a/plugins/platforms/dingtalk/adapter.py
+++ b/plugins/platforms/dingtalk/adapter.py
@@ -503,16 +503,19 @@ class DingTalkAdapter(BasePlatformAdapter):
         metadata = metadata or {}
         logger.debug("[%s] send() chat_id=%s card_enabled=%s", self.name, chat_id, bool(self._card_template_id and self._card_sdk))
         session_webhook = metadata.get("session_webhook") or (self._get_valid_webhook(chat_id) or ("",))[0]
+        is_final_reply = reply_to is not None
         if not session_webhook:
-            logger.warning("[%s] No valid session_webhook for chat_id=%s", self.name, chat_id)
-            return SendResult(success=False, error="No valid session_webhook available. Reply must follow an incoming message.")
+            # No live webhook (fresh gateway restart, or the webhook expired): the reply would be
+            # silently dropped. Fall back to the robot oToMessages API so the chat still gets output.
+            logger.warning("[%s] No valid session_webhook for chat_id=%s -> robot fallback", self.name, chat_id)
+            return await self._send_via_robot_fallback(chat_id, content, is_final_reply)
         if not self._http_client:
             return SendResult(success=False, error="HTTP client not initialized")
         current_message = self._message_contexts.get(chat_id)
         # ``reply_to`` is only set by base.py:_send_with_retry for the FINAL reply to an inbound message;
         # tool-progress, commentary and stream first-sends leave it None. It decides (1) finalize-on-create
         # (intermediate cards stay open so edits don't flicker) and (2) whether to fire the Done reaction.
-        is_final_reply = reply_to is not None
+        # (is_final_reply is computed above, before the webhook check.)
         if self._card_template_id and current_message and self._card_sdk:
             await self._close_streaming_siblings(chat_id)  # close lingering tool-progress cards before creating a new one
             result = await self._create_and_stream_card(chat_id, current_message, content, finalize=is_final_reply)
@@ -532,13 +535,40 @@ class DingTalkAdapter(BasePlatformAdapter):
                     self._fire_done_reaction(chat_id)
                 return SendResult(success=True, message_id=uuid.uuid4().hex[:12])
             logger.warning("[%s] Send failed HTTP %d: %s", self.name, resp.status_code, resp.text[:200])
+            if resp.status_code >= 400:  # expired/consumed webhook: don't lose the message
+                return await self._send_via_robot_fallback(chat_id, content, is_final_reply)
             return SendResult(success=False, error=f"HTTP {resp.status_code}: {resp.text[:200]}")
         except httpx.TimeoutException:
-            return SendResult(success=False, error="Timeout sending message to DingTalk")
+            return await self._send_via_robot_fallback(chat_id, content, is_final_reply)
         except Exception as e:
             logger.error("[%s] Send error: %s", self.name, e)
             return SendResult(success=False, error=str(e))
 
+    # Fallback sender used when no live session webhook exists (e.g. right after a gateway restart, or the
+    # webhook expired). Shells out to the proven robot-API helper, which resolves the recipient staff id from
+    # DINGTALK_PUSH_USERID or the last inbound dingtalk DM in state.db (so it works without a live session).
+    _ROBOT_FALLBACK_CMD = "/root/.hermes/bin/dingtalk-push"
+
+    async def _send_via_robot_fallback(self, chat_id: str, content: str, is_final_reply: bool) -> SendResult:
+        text = content[: self.MAX_MESSAGE_LENGTH]
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                self._ROBOT_FALLBACK_CMD, text,
+                stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.STDOUT)
+            out, _ = await asyncio.wait_for(proc.communicate(), timeout=30)
+            if proc.returncode == 0:
+                logger.info("[%s] Sent via robot fallback (no session_webhook) chat_id=%s", self.name, chat_id)
+                if is_final_reply:
+                    self._fire_done_reaction(chat_id)
+                return SendResult(success=True, message_id=uuid.uuid4().hex[:12])
+            logger.warning("[%s] Robot fallback rc=%s out=%s", self.name, proc.returncode, (out or b"")[:200])
+            return SendResult(success=False, error=f"robot fallback rc={proc.returncode}: {(out or b'')[:120]!r}")
+        except FileNotFoundError:
+            return SendResult(success=False, error=f"robot fallback helper missing: {self._ROBOT_FALLBACK_CMD}")
+        except Exception as e:
+            logger.error("[%s] Robot fallback error: %s", self.name, e)
+            return SendResult(success=False, error=f"robot fallback error: {e}")
+
     async def send_typing(self, chat_id: str, metadata=None) -> None:
         """DingTalk does not support typing indicators."""
 
