@@ -12,7 +12,7 @@
 from difflib import SequenceMatcher
 from datetime import datetime, timedelta, timezone
 from enum import Enum
-from typing import List, Dict, Optional, Union, Any
+from typing import List, Dict, Optional, Union, Any, get_args
 from pathlib import Path
 from urllib.parse import unquote, urlparse
 
@@ -968,6 +968,83 @@ def make_rich_input(parse_mode: str, text: str):
     return types.InputRichMessageMarkdown(markdown=text)
 
 
+# Reading a rich message is the other direction, and it needs its own walk: a
+# channel posting in this format leaves msg.message empty and carries every word
+# as Instant-View page blocks, so a reader that only looks at msg.message
+# reports the whole post as empty.
+_RICH_TEXT_TYPES = tuple(get_args(types.TypeRichText))
+
+# RichText is a recursive tree: a node either holds a plain string, wraps
+# another node, or concatenates a list of them. Dispatching on the field rather
+# than on the class keeps a node type Telegram adds later flattening instead of
+# vanishing.
+_RICH_TEXT_FIELDS = ("texts", "text", "alt", "source")
+
+# Where a page block, list item, table row or caption keeps its words. Same walk
+# covers the blocks nested inside details, collages and embedded posts.
+_PAGE_TEXT_FIELDS = (
+    "title",
+    "subtitle",
+    "author",
+    "text",
+    "caption",
+    "credit",
+    "items",
+    "blocks",
+    "rows",
+    "articles",
+)
+
+
+def rich_text_to_str(node) -> str:
+    """Flatten one RichText node into plain text.
+
+    TextCustomEmoji contributes its alt character - dropping it would silently
+    eat the emoji a channel used as a bullet or a heading marker.
+    """
+    if node is None:
+        return ""
+    if isinstance(node, str):
+        return node
+    if isinstance(node, (list, tuple)):
+        return "".join(rich_text_to_str(item) for item in node)
+    for field in _RICH_TEXT_FIELDS:
+        value = getattr(node, field, None)
+        if value is not None:
+            return rich_text_to_str(value)
+    return ""  # TextEmpty, TextImage and anything else carrying no text
+
+
+def _page_lines(node) -> List[str]:
+    """Text lines carried by a page block, list item, table row or caption."""
+    if node is None:
+        return []
+    if isinstance(node, (list, tuple)):
+        return [line for item in node for line in _page_lines(item)]
+    if isinstance(node, _RICH_TEXT_TYPES):
+        text = rich_text_to_str(node).strip()
+        return [text] if text else []
+    cells = getattr(node, "cells", None)
+    if cells is not None:  # a table row reads as one line, not one line per cell
+        row = " | ".join(line for cell in cells for line in _page_lines(cell))
+        return [row] if row else []
+    return [line for f in _PAGE_TEXT_FIELDS for line in _page_lines(getattr(node, f, None))]
+
+
+def rich_message_text(msg) -> str:
+    """Plain text of a rich (block-format) message, "" when there is none.
+
+    Each block becomes a paragraph and the lines within one block stay together,
+    so a list reads as a list instead of one run-on line. An unknown block type
+    yields nothing rather than breaking the whole message.
+    """
+    blocks = getattr(getattr(msg, "rich_message", None), "blocks", None)
+    if not blocks:
+        return ""
+    paragraphs = ("\n".join(_page_lines(block)) for block in blocks)
+    return "\n\n".join(p for p in paragraphs if p)
+
+
 def premium_required_result(action: str) -> str:
     """Structured refusal so the agent can degrade gracefully instead of sending garbage."""
     return json.dumps(
 
@@ -141,8 +141,18 @@ def message_to_dict(msg, chat_id: Optional[int] = None) -> dict:
         d["out"] = True
 
     text = sanitize_user_content(msg.message) if getattr(msg, "message", None) else ""
+    rich = False
+    if not text:
+        # Block-format posts leave .message empty and keep the words in
+        # .rich_message; without this the whole post reads back as "[empty]".
+        rich_text = rich_message_text(msg)
+        if rich_text:
+            text = sanitize_user_content(rich_text)
+            rich = True
     if text:
         d["text"] = text
+    if rich:
+        d["rich"] = True  # text rebuilt from page blocks, not a verbatim .message
 
     media_label = get_media_label(msg)
     if media_label:
@@ -327,6 +337,11 @@ def format_message_line(msg, chat_id: Optional[int] = None) -> str:
         parts.append(engagement_info)
 
     raw = sanitize_user_content(msg.message) if getattr(msg, "message", None) else ""
+    if not raw:
+        rich_text = rich_message_text(msg)
+        if rich_text:
+            raw = sanitize_user_content(rich_text)
+            parts.append("rich")
     if raw:
         safe_text = raw.replace("\n", "\\n")
     else:
 
@@ -117,3 +117,169 @@ async def test_edit_rich_both_premium_cases():
     result = json.loads(await messages._edit_rich(no, "peer", 7, "new", "rich"))
     assert result["reason"] == "telegram_premium_required"
     assert no.requests == []
+
+
+# --- reading rich messages -------------------------------------------------
+# A channel posting in the block format leaves msg.message empty and puts every
+# word into msg.rich_message, so such a post used to read back as "[empty]".
+
+types = runtime.types
+
+
+def _msg(**overrides):
+    base = dict(
+        id=224,
+        sender=None,
+        sender_id=42,
+        date="2026-09-03",
+        message="",
+        reply_to=None,
+        rich_message=None,
+    )
+    base.update(overrides)
+    return SimpleNamespace(**base)
+
+
+def _plain(text):
+    return types.TextPlain(text=text)
+
+
+def _rich(*blocks):
+    return types.RichMessage(blocks=list(blocks), photos=[], documents=[])
+
+
+def _cell(text):
+    return types.PageTableCell(
+        header=False,
+        align_center=False,
+        align_right=False,
+        valign_middle=False,
+        valign_bottom=False,
+        text=_plain(text),
+        colspan=None,
+        rowspan=None,
+    )
+
+
+def _post_like_agents_lab_224():
+    """The shape a real block-format post arrives in: a heading carrying a
+    custom emoji, an uncaptioned photo, then paragraphs."""
+    return _rich(
+        types.PageBlockHeading1(
+            text=types.TextConcat(
+                texts=[
+                    _plain("Личная CRM "),
+                    types.TextCustomEmoji(document_id=5927026418616636353, alt="🧠"),
+                ]
+            )
+        ),
+        types.PageBlockPhoto(
+            photo_id=5197653938998550234,
+            caption=types.PageCaption(text=types.TextEmpty(), credit=types.TextEmpty()),
+            spoiler=False,
+            url=None,
+            webpage_id=None,
+        ),
+        types.PageBlockParagraph(text=_plain("Первый абзац.")),
+        types.PageBlockParagraph(text=_plain("Второй абзац.")),
+    )
+
+
+def test_rich_text_flattens_every_nesting_shape():
+    node = types.TextConcat(
+        texts=[
+            _plain("plain "),
+            types.TextBold(text=_plain("bold ")),
+            types.TextUrl(text=_plain("link"), url="https://example.com", webpage_id=0),
+            types.TextCustomEmoji(document_id=1, alt="🧠"),
+            types.TextEmpty(),
+        ]
+    )
+
+    assert runtime.rich_text_to_str(node) == "plain bold link🧠"
+
+
+def test_rich_text_ignores_nodes_that_carry_no_text():
+    assert runtime.rich_text_to_str(types.TextEmpty()) == ""
+    assert runtime.rich_text_to_str(types.TextImage(document_id=1, w=10, h=10)) == ""
+    assert runtime.rich_text_to_str(None) == ""
+
+
+def test_rich_message_text_walks_blocks():
+    text = runtime.rich_message_text(_msg(rich_message=_post_like_agents_lab_224()))
+
+    # One paragraph per block; the empty photo caption contributes nothing.
+    assert text == "Личная CRM 🧠\n\nПервый абзац.\n\nВторой абзац."
+
+
+def test_rich_message_text_reaches_captions_lists_tables_and_details():
+    rich = _rich(
+        types.PageBlockVideo(
+            video_id=1,
+            caption=types.PageCaption(text=_plain("под видео"), credit=types.TextEmpty()),
+            autoplay=False,
+            loop=False,
+            spoiler=False,
+        ),
+        types.PageBlockList(
+            items=[
+                types.PageListItemText(text=_plain("первый"), checkbox=None, checked=None),
+                types.PageListItemBlocks(
+                    blocks=[types.PageBlockParagraph(text=_plain("второй"))],
+                    checkbox=None,
+                    checked=None,
+                ),
+            ]
+        ),
+        types.PageBlockTable(
+            title=types.TextEmpty(),
+            rows=[types.PageTableRow(cells=[_cell("A"), _cell("B")])],
+            bordered=False,
+            striped=False,
+        ),
+        types.PageBlockDetails(
+            blocks=[types.PageBlockParagraph(text=_plain("скрытое"))],
+            title=_plain("подробнее"),
+            open=False,
+        ),
+    )
+
+    assert runtime.rich_message_text(_msg(rich_message=rich)) == (
+        "под видео\n\nпервый\nвторой\n\nA | B\n\nподробнее\nскрытое"
+    )
+
+
+def test_rich_message_text_skips_unknown_blocks_instead_of_failing():
+    rich = _rich(
+        SimpleNamespace(),  # a block type Telegram adds after this telethon build
+        types.PageBlockParagraph(text=_plain("уцелевший абзац")),
+    )
+
+    assert runtime.rich_message_text(_msg(rich_message=rich)) == "уцелевший абзац"
+
+
+def test_rich_message_text_is_empty_without_a_rich_message():
+    assert runtime.rich_message_text(_msg()) == ""
+    assert runtime.rich_message_text(SimpleNamespace()) == ""
+
+
+def test_message_to_dict_falls_back_to_rich_message():
+    d = messages.message_to_dict(_msg(rich_message=_post_like_agents_lab_224()))
+
+    assert d["text"].startswith("Личная CRM 🧠")
+    assert d["rich"] is True
+
+
+def test_format_message_line_falls_back_to_rich_message():
+    line = messages.format_message_line(_msg(rich_message=_post_like_agents_lab_224()))
+
+    assert "Message: [empty]" not in line
+    assert "Личная CRM 🧠\\n\\nПервый абзац." in line
+    assert "rich" in line
+
+
+def test_plain_message_text_still_wins_over_rich_message():
+    msg = _msg(message="обычный текст", rich_message=_post_like_agents_lab_224())
+
+    assert messages.message_to_dict(msg)["text"] == "обычный текст"
+    assert "обычный текст" in messages.format_message_line(msg)