ccgram 2.2.2__tar.gz → 2.2.4__tar.gz

{ccgram-2.2.2 → ccgram-2.2.4}/.claude/rules/architecture.md

@@ -4,8 +4,8 @@
 graph TB
     subgraph bot["Telegram Bot — bot.py"]
         direction TB
-        BotCore["Topic routing · /history · /sessions\nStatus messages · Interactive UI\nMessage queue + worker · MarkdownV2"]
-        BotSub1["markdown_v2.py\nMD → MarkdownV2 + expandable quotes"]
+        BotCore["Topic routing · /history · /sessions\nStatus messages · Interactive UI\nMessage queue + worker · Entity formatting"]
+        BotSub1["entity_formatting.py\nMD → plain text + MessageEntity offsets"]
         BotSub2["telegram_sender.py\nsplit_message — 4096 limit"]
         Terminal["terminal_parser.py + screen_buffer.py\npyte VT100 · interactive UI detection\nspinner parsing · separator detection"]
     end
@@ -143,7 +143,7 @@ graph TB
 - **Hook-based event system** — Claude Code hooks (SessionStart, Notification, Stop, StopFailure, SessionEnd, SubagentStart, SubagentStop, TeammateIdle, TaskCompleted) write to `session_map.json` and `events.jsonl`. SessionMonitor reads both: session_map for session tracking, events.jsonl for instant event dispatch (interactive UI, done detection, API error alerting, session lifecycle, subagent status, team notifications). Terminal scraping remains as fallback. Missing hooks are detected at startup with an actionable warning.
 - **Multi-pane awareness** — Windows with multiple panes (e.g. Claude Code agent teams) are scanned for interactive prompts in non-active panes. Blocked panes are auto-surfaced as inline keyboard alerts. `/panes` command lists all panes with status and per-pane screenshot buttons. Callback data format extended to include pane_id: `"aq:enter:@12:%5"`.
 - **Tool use ↔ tool result pairing** — `tool_use_id` tracked across poll cycles; tool result edits the original tool_use Telegram message in-place.
-- **MarkdownV2 with fallback** — All messages go through `safe_reply`/`safe_edit`/`safe_send` which convert via `telegramify-markdown` and fall back to plain text on parse failure.
+- **Entity-based formatting** — All messages go through `safe_reply`/`safe_edit`/`safe_send` which convert markdown to plain text + `MessageEntity` offsets via `telegramify-markdown`, falling back to plain text on failure. No parse errors possible.
 - **No truncation at parse layer** — Full content preserved; splitting at send layer respects Telegram's 4096 char limit with expandable quote atomicity.
 - Only sessions registered in `session_map.json` (via hook) are monitored.
 - Notifications delivered to users via thread bindings (topic → window_id → session).

{ccgram-2.2.2 → ccgram-2.2.4}/CHANGELOG.md

@@ -4,8 +4,26 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+## [2.2.4] - 2026-03-20
+
+### Added
+- Switch to entity-based Telegram formatting ([#34](https://github.com/alexei-led/ccgram/pull/34))
+
+## [2.2.3] - 2026-03-20
+
+### Documentation
+- Update CHANGELOG.md for v2.2.3
+
+
+### Fixed
+- Respect Telegram cooldown period and log version at startup
+
 ## [2.2.2] - 2026-03-20
 
+### Documentation
+- Update CHANGELOG.md for v2.2.2
+
+
 ### Fixed
 - Handle Telegram flood control during startup command registration
 

{ccgram-2.2.2 → ccgram-2.2.4}/CLAUDE.md

@@ -38,7 +38,7 @@ ccgram --autoclose-dead 0              # Disable auto-close for dead sessions
 - **1 Topic = 1 Window = 1 Session** — all internal routing keyed by tmux window ID (`@0`, `@12`), not window name. Window names kept as display names. Same directory can have multiple windows.
 - **Topic-only** — no backward-compat for non-topic mode. No `active_sessions`, no `/list`, no General topic routing.
 - **No message truncation** at parse layer — splitting only at send layer (`split_message`, 4096 char limit).
-- **MarkdownV2 only** — use `safe_reply`/`safe_edit`/`safe_send` helpers (auto fallback to plain text). Internal queue/UI code calls bot API directly with its own fallback.
+- **Entity-based formatting** — use `safe_reply`/`safe_edit`/`safe_send` helpers which convert markdown to plain text + MessageEntity offsets (no parse errors possible, auto fallback to plain text). Internal queue/UI code calls bot API directly with its own fallback.
 - **Hook-based session tracking** — Claude Code hooks (SessionStart, Notification, Stop, StopFailure, SessionEnd, SubagentStart, SubagentStop, TeammateIdle, TaskCompleted) write to `session_map.json` and `events.jsonl`; monitor polls both to detect session changes and deliver instant event notifications. Missing hooks are detected at startup with an actionable warning.
 - **Message queue per user** — FIFO ordering, message merging (3800 char limit), tool_use/tool_result pairing.
 - **Rate limiting** — 1.1s minimum interval between messages per user via `rate_limit_send()`.

{ccgram-2.2.2 → ccgram-2.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ccgram
-Version: 2.2.2
+Version: 2.2.4
 Summary: CCGram — manage AI coding agents from Telegram via tmux
 Project-URL: Homepage, https://github.com/alexei-led/ccgram
 Project-URL: Repository, https://github.com/alexei-led/ccgram
@@ -120,7 +120,7 @@ Each Telegram Forum topic binds to one tmux window running an agent CLI. Message
 
 - Assistant responses, thinking content, tool use/result pairs, and command output
 - Live status line showing what the agent is currently doing
-- MarkdownV2 formatting with automatic plain text fallback
+- Entity-based formatting with automatic plain text fallback
 
 **Session management**
 

{ccgram-2.2.2 → ccgram-2.2.4}/README.md

@@ -79,7 +79,7 @@ Each Telegram Forum topic binds to one tmux window running an agent CLI. Message
 
 - Assistant responses, thinking content, tool use/result pairs, and command output
 - Live status line showing what the agent is currently doing
-- MarkdownV2 formatting with automatic plain text fallback
+- Entity-based formatting with automatic plain text fallback
 
 **Session management**
 

{ccgram-2.2.2 → ccgram-2.2.4}/src/ccgram/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.2.2'
-__version_tuple__ = version_tuple = (2, 2, 2)
+__version__ = version = '2.2.4'
+__version_tuple__ = version_tuple = (2, 2, 4)
 
 __commit_id__ = commit_id = None

{ccgram-2.2.2 → ccgram-2.2.4}/src/ccgram/cc_commands.py

@@ -290,37 +290,37 @@ async def register_commands(
 
     from telegram.error import RetryAfter
 
-    max_attempts = 3
-    for attempt in range(1, max_attempts + 1):
-        try:
-            if scope is None:
-                await bot.delete_my_commands()
-                await bot.set_my_commands(bot_commands)
-            else:
-                await bot.delete_my_commands(scope=scope)
-                await bot.set_my_commands(bot_commands, scope=scope)
-            break
-        except RetryAfter as e:
-            retry_secs = min(
-                60,
-                (
-                    e.retry_after
-                    if isinstance(e.retry_after, int)
-                    else int(e.retry_after.total_seconds())
-                ),
+    max_startup_wait = 120  # Don't block startup longer than this
+
+    try:
+        if scope is None:
+            await bot.delete_my_commands()
+            await bot.set_my_commands(bot_commands)
+        else:
+            await bot.delete_my_commands(scope=scope)
+            await bot.set_my_commands(bot_commands, scope=scope)
+    except RetryAfter as e:
+        retry_secs = (
+            e.retry_after
+            if isinstance(e.retry_after, int)
+            else int(e.retry_after.total_seconds())
+        )
+        if retry_secs > max_startup_wait:
+            logger.warning(
+                "Telegram flood control: %ds cooldown, skipping command registration"
+                " (will retry in 10min refresh cycle)",
+                retry_secs,
             )
-            if attempt < max_attempts:
-                logger.warning(
-                    "Telegram flood control registering commands, retry in %ds (attempt %d/%d)",
-                    retry_secs,
-                    attempt,
-                    max_attempts,
-                )
-                await asyncio.sleep(retry_secs)
-            else:
-                logger.warning(
-                    "Telegram flood control registering commands, giving up after %d attempts",
-                    max_attempts,
-                )
-                return
+            return
+        logger.warning(
+            "Telegram flood control: retrying command registration in %ds",
+            retry_secs,
+        )
+        await asyncio.sleep(retry_secs)
+        if scope is None:
+            await bot.delete_my_commands()
+            await bot.set_my_commands(bot_commands)
+        else:
+            await bot.delete_my_commands(scope=scope)
+            await bot.set_my_commands(bot_commands, scope=scope)
     logger.info("Registered %d bot commands (%d CC)", len(bot_commands), cc_count)

ccgram-2.2.4/src/ccgram/entity_formatting.py

@@ -0,0 +1,203 @@
+"""Markdown → Telegram entity-based formatting layer.
+
+Converts markdown text (with expandable blockquote sentinels) to plain text
+plus a list of telegram.MessageEntity objects. Entity-based formatting uses
+character offsets — there is no syntax to parse and no parse errors are possible.
+
+Key function: convert_to_entities(text) → (str, list[MessageEntity]).
+"""
+
+import re
+
+from telegram import MessageEntity as TelegramEntity
+
+from telegramify_markdown import config as _tm_config
+from telegramify_markdown import convert as _tm_convert
+from telegramify_markdown import utf16_len as _utf16_len
+from telegramify_markdown.entity import MessageEntity as _LibEntity
+
+from .providers.base import EXPANDABLE_QUOTE_END, EXPANDABLE_QUOTE_START
+
+# Disable auto-promotion of long blockquotes to expandable blockquotes —
+# ccgram manages expandable quotes exclusively through sentinel tokens.
+_tm_config.get_runtime_config().cite_expandable = False
+
+_EXPQUOTE_RE = re.compile(
+    re.escape(EXPANDABLE_QUOTE_START) + r"([\s\S]*?)" + re.escape(EXPANDABLE_QUOTE_END)
+)
+
+# Max rendered chars for a single expandable quote block.
+# Leaves room for surrounding text within Telegram's 4096 char message limit.
+_EXPQUOTE_MAX_RENDERED = 3800
+
+# Minimum characters to bother including a partial line during truncation
+_MIN_PARTIAL_LINE_LEN = 20
+
+_FENCE_RE = re.compile(r"^(`{3,}|~{3,})", re.MULTILINE)
+_INDENTED_CODE_RE = re.compile(r"(?<=\n\n)((?:    .+\n?)+)")
+_INDENTED_LINE_RE = re.compile(r"^    ", re.MULTILINE)
+
+
+def _strip_indented_code_blocks(text: str) -> str:
+    """Strip 4-space indentation that CommonMark treats as code blocks.
+
+    Claude Code uses fenced ``` blocks for code; indented blocks in its
+    output are typically continuation text, not code.  Pyromark (CommonMark)
+    converts 4-space-indented paragraphs into code blocks, so we strip
+    the leading spaces before conversion.
+
+    Fenced code blocks are left untouched — only non-fenced segments
+    are processed.
+    """
+    # Split text into alternating (outside-fence, inside-fence) segments
+    parts: list[str] = []
+    inside_fence = False
+    fence_marker = ""
+    last_end = 0
+
+    for m in _FENCE_RE.finditer(text):
+        marker = m.group(1)
+        if not inside_fence:
+            # Entering a fenced block — process the preceding non-fenced text
+            parts.append(_deindent(text[last_end : m.start()], last_end == 0))
+            inside_fence = True
+            fence_marker = marker  # e.g. "```" or "~~~~~"
+            last_end = m.start()
+        elif marker[0] == fence_marker[0] and len(marker) >= len(fence_marker):
+            # Closing fence — keep fenced content verbatim
+            end = m.end()
+            parts.append(text[last_end:end])
+            last_end = end
+            inside_fence = False
+            fence_marker = ""
+
+    # Remaining text after last fence (or entire text if no fences)
+    tail = text[last_end:]
+    if inside_fence:
+        # Unclosed fence — keep verbatim
+        parts.append(tail)
+    else:
+        parts.append(_deindent(tail, last_end == 0))
+
+    return "".join(parts)
+
+
+def _deindent(text: str, is_start: bool) -> str:
+    """Strip 4-space indented code blocks from a non-fenced text segment."""
+    if is_start:
+        text = re.sub(
+            r"^((?:    .+\n?)+)",
+            lambda m: _INDENTED_LINE_RE.sub("", m.group(0)),
+            text,
+        )
+    return _INDENTED_CODE_RE.sub(
+        lambda m: _INDENTED_LINE_RE.sub("", m.group(0)),
+        text,
+    )
+
+
+def _lib_entity_to_telegram(ent: _LibEntity, offset_shift: int = 0) -> TelegramEntity:
+    """Convert a telegramify_markdown MessageEntity to telegram.MessageEntity."""
+    return TelegramEntity(
+        type=ent.type,
+        offset=ent.offset + offset_shift,
+        length=ent.length,
+        url=ent.url,
+        language=ent.language,
+        custom_emoji_id=ent.custom_emoji_id,
+    )
+
+
+def _convert_segment(text: str) -> tuple[str, list[TelegramEntity]]:
+    """Convert a markdown segment (no expandable quote sentinels) to entities."""
+    preprocessed = _strip_indented_code_blocks(text)
+    plain, lib_entities = _tm_convert(preprocessed)
+    tg_entities = [_lib_entity_to_telegram(e) for e in lib_entities]
+    return plain, tg_entities
+
+
+def _truncate_quote_text(text: str) -> tuple[str, bool]:
+    """Truncate expandable quote text to fit within budget.
+
+    Returns (truncated_text, was_truncated).
+    """
+    if _utf16_len(text) <= _EXPQUOTE_MAX_RENDERED:
+        return text, False
+
+    lines = text.split("\n")
+    built: list[str] = []
+    total_len = 0
+    suffix = "\n… (truncated)"
+    budget = _EXPQUOTE_MAX_RENDERED - _utf16_len(suffix)
+
+    for line in lines:
+        line_cost = _utf16_len(line) + 1  # +1 for newline
+        if total_len + line_cost > budget:
+            remaining = budget - total_len - 1  # -1 for newline
+            if remaining > _MIN_PARTIAL_LINE_LEN:
+                built.append(line[:remaining])
+            built.append("… (truncated)")
+            return "\n".join(built), True
+        built.append(line)
+        total_len += line_cost
+
+    return "\n".join(built), True
+
+
+def convert_to_entities(text: str) -> tuple[str, list[TelegramEntity]]:
+    """Convert markdown text with expandable quote sentinels to plain text + entities.
+
+    Expandable blockquote sections (marked by sentinel tokens) are extracted
+    and converted to expandable_blockquote entities. Non-quote segments are
+    converted via telegramify_markdown.convert() for standard formatting.
+
+    Entity-based formatting uses character offsets — no syntax to parse,
+    no parse errors possible.
+    """
+    # Split text by expandable quote sentinels
+    segments: list[tuple[bool, str]] = []  # (is_quote, inner_content)
+    last_end = 0
+    for m in _EXPQUOTE_RE.finditer(text):
+        if m.start() > last_end:
+            segments.append((False, text[last_end : m.start()]))
+        segments.append((True, m.group(1)))  # Inner content without sentinels
+        last_end = m.end()
+    if last_end < len(text):
+        segments.append((False, text[last_end:]))
+
+    if not segments:
+        return _convert_segment(text)
+
+    result_text = ""
+    result_entities: list[TelegramEntity] = []
+
+    for is_quote, segment in segments:
+        if is_quote:
+            quote_text, _was_truncated = _truncate_quote_text(segment)
+            offset = _utf16_len(result_text)
+            length = _utf16_len(quote_text)
+            result_entities.append(
+                TelegramEntity(
+                    type=TelegramEntity.EXPANDABLE_BLOCKQUOTE,
+                    offset=offset,
+                    length=length,
+                )
+            )
+            result_text += quote_text
+        else:
+            plain, entities = _convert_segment(segment)
+            offset_shift = _utf16_len(result_text)
+            for ent in entities:
+                result_entities.append(
+                    TelegramEntity(
+                        type=ent.type,
+                        offset=ent.offset + offset_shift,
+                        length=ent.length,
+                        url=ent.url,
+                        language=ent.language,
+                        custom_emoji_id=ent.custom_emoji_id,
+                    )
+                )
+            result_text += plain
+
+    return result_text, result_entities

{ccgram-2.2.2 → ccgram-2.2.4}/src/ccgram/handlers/__init__.py

@@ -3,7 +3,7 @@
 This package contains the Telegram bot handlers split by functionality:
   - callback_data: Callback data constants (CB_* prefixes)
   - message_queue: Per-user message queue management
-  - message_sender: Safe message sending helpers with MarkdownV2 fallback
+  - message_sender: Safe message sending helpers with entity-based formatting
   - history: Message history pagination
   - directory_browser: Directory selection UI
   - interactive_ui: Interactive UI (AskUserQuestion, Permission Prompt, etc.)

{ccgram-2.2.2 → ccgram-2.2.4}/src/ccgram/handlers/directory_browser.py

@@ -329,7 +329,7 @@ def build_mode_picker(
         ],
         [
             InlineKeyboardButton(
-                "🚀 YOLO",
+                "🎲 YOLO",
                 callback_data=f"{CB_MODE_SELECT}{provider_name}:yolo",
             )
         ],

{ccgram-2.2.2 → ccgram-2.2.4}/src/ccgram/handlers/interactive_ui.py

@@ -285,8 +285,7 @@ async def handle_interactive_ui(
         "Sending interactive UI to user %d for window_id %s", user_id, window_id
     )
     _send_cooldowns[ikey] = now
-    # Send as plain text — terminal content has characters like (, _, .
-    # that MarkdownV2 conversion would mangle.
+    # Send as plain text — terminal content should not be formatted.
     sent: Message | None = None
     await rate_limit_send(chat_id)
     try:

{ccgram-2.2.2 → ccgram-2.2.4}/src/ccgram/handlers/message_queue.py

@@ -24,7 +24,8 @@ from typing import Literal
 from telegram import Bot, InlineKeyboardButton, InlineKeyboardMarkup
 from telegram.error import RetryAfter, TelegramError
 
-from ..markdown_v2 import convert_markdown
+import contextlib
+
 from ..session import session_manager
 from ..providers import get_provider_for_window
 from ..tmux_manager import tmux_manager
@@ -37,8 +38,7 @@ from .callback_data import (
     CB_STATUS_SCREENSHOT,
     NOTIFY_MODE_ICONS,
 )
-from .message_sender import NO_LINK_PREVIEW, rate_limit_send_message
-import contextlib
+from .message_sender import edit_with_fallback, rate_limit_send_message
 
 # Top-level loop resilience: catch any error to keep the worker alive
 _LoopError = (TelegramError, OSError, RuntimeError, ValueError)
@@ -46,10 +46,10 @@ _LoopError = (TelegramError, OSError, RuntimeError, ValueError)
 logger = structlog.get_logger()
 
 # Merge limit for content messages
-MERGE_MAX_LENGTH = 3800  # Leave room for markdown conversion overhead
+MERGE_MAX_LENGTH = 3800  # Leave room within Telegram's 4096 char message limit
 
 # Batch limits for tool call chains
-# Keep conservative: header + entries + result text + separators + MarkdownV2 escaping
+# Keep conservative: header + entries + result text + separators
 # must fit 4096 chars. Worst case: 10 * (250 + 85 + 6) + 20 ≈ 3430 chars.
 BATCH_MAX_LENGTH = 2800
 BATCH_MAX_ENTRIES = 10
@@ -422,26 +422,13 @@ async def _process_batch_task(bot: Bot, user_id: int, task: MessageTask) -> None
         if sent:
             batch.telegram_msg_id = sent.message_id
     else:
-        # Edit existing batch message (MarkdownV2 with plain text fallback)
-        md_text = convert_markdown(batch_text)
-        try:
-            await bot.edit_message_text(
-                chat_id=chat_id,
-                message_id=batch.telegram_msg_id,
-                text=md_text,
-                parse_mode="MarkdownV2",
-                link_preview_options=NO_LINK_PREVIEW,
-            )
-        except RetryAfter:
-            raise
-        except TelegramError:
-            with contextlib.suppress(TelegramError):
-                await bot.edit_message_text(
-                    chat_id=chat_id,
-                    message_id=batch.telegram_msg_id,
-                    text=batch_text,
-                    link_preview_options=NO_LINK_PREVIEW,
-                )
+        # Edit existing batch message with entity-based formatting
+        await edit_with_fallback(
+            bot,
+            chat_id,
+            batch.telegram_msg_id,
+            batch_text,
+        )
 
 
 async def _flush_batch(bot: Bot, user_id: int, thread_id_or_0: int) -> None:
@@ -470,25 +457,12 @@ async def _flush_batch(bot: Bot, user_id: int, thread_id_or_0: int) -> None:
         return
 
     # Final edit with all results resolved
-    md_text = convert_markdown(batch_text)
-    try:
-        await bot.edit_message_text(
-            chat_id=chat_id,
-            message_id=batch.telegram_msg_id,
-            text=md_text,
-            parse_mode="MarkdownV2",
-            link_preview_options=NO_LINK_PREVIEW,
-        )
-    except RetryAfter:
-        raise
-    except TelegramError:
-        with contextlib.suppress(TelegramError):
-            await bot.edit_message_text(
-                chat_id=chat_id,
-                message_id=batch.telegram_msg_id,
-                text=batch_text,
-                link_preview_options=NO_LINK_PREVIEW,
-            )
+    await edit_with_fallback(
+        bot,
+        chat_id,
+        batch.telegram_msg_id,
+        batch_text,
+    )
 
 
 async def _handle_content_task(
@@ -607,37 +581,17 @@ async def _process_content_task(bot: Bot, user_id: int, task: MessageTask) -> No
             await _do_clear_status_message(bot, user_id, thread_id)
             # Join all parts for editing (merged content goes together)
             full_text = "\n\n".join(task.parts)
-            try:
-                await bot.edit_message_text(
-                    chat_id=chat_id,
-                    message_id=edit_msg_id,
-                    text=full_text,
-                    parse_mode="MarkdownV2",
-                    link_preview_options=NO_LINK_PREVIEW,
-                )
+            success = await edit_with_fallback(
+                bot,
+                chat_id,
+                edit_msg_id,
+                full_text,
+            )
+            if success:
                 await _check_and_send_status(bot, user_id, window_id, task.thread_id)
                 return
-            except RetryAfter:
-                raise
-            except TelegramError:
-                try:
-                    # Fallback: strip markdown
-                    plain_text = task.text or full_text
-                    await bot.edit_message_text(
-                        chat_id=chat_id,
-                        message_id=edit_msg_id,
-                        text=plain_text,
-                        link_preview_options=NO_LINK_PREVIEW,
-                    )
-                    await _check_and_send_status(
-                        bot, user_id, window_id, task.thread_id
-                    )
-                    return
-                except RetryAfter:
-                    raise
-                except TelegramError:
-                    logger.debug("Failed to edit tool msg %s, sending new", edit_msg_id)
-                    # Fall through to send as new message
+            logger.debug("Failed to edit tool msg %s, sending new", edit_msg_id)
+            # Fall through to send as new message
 
     # 2. Send content messages, converting status message to first content part
     first_part = True
@@ -704,35 +658,17 @@ async def _convert_status_to_content(
         return None
 
     # Edit status message to show content (remove status buttons)
-    try:
-        await bot.edit_message_text(
-            chat_id=chat_id,
-            message_id=msg_id,
-            text=content_text,
-            parse_mode="MarkdownV2",
-            reply_markup=None,
-            link_preview_options=NO_LINK_PREVIEW,
-        )
+    success = await edit_with_fallback(
+        bot,
+        chat_id,
+        msg_id,
+        content_text,
+        reply_markup=None,
+    )
+    if success:
         return msg_id
-    except RetryAfter:
-        raise
-    except TelegramError:
-        try:
-            # Fallback to plain text
-            await bot.edit_message_text(
-                chat_id=chat_id,
-                message_id=msg_id,
-                text=content_text,
-                reply_markup=None,
-                link_preview_options=NO_LINK_PREVIEW,
-            )
-            return msg_id
-        except RetryAfter:
-            raise
-        except TelegramError as e:
-            logger.debug("Failed to convert status to content: %s", e)
-            # Message might be deleted or too old, caller will send new message
-            return None
+    # Message might be deleted or too old, caller will send new message
+    return None
 
 
 def _get_idle_history(
@@ -781,36 +717,20 @@ async def _process_status_update_task(
             # Same window, text changed - edit in place
             history = _get_idle_history(user_id, thread_id, status_text)
             keyboard = build_status_keyboard(window_id, history=history)
-            try:
-                await bot.edit_message_text(
-                    chat_id=chat_id,
-                    message_id=msg_id,
-                    text=convert_markdown(status_text),
-                    parse_mode="MarkdownV2",
-                    reply_markup=keyboard,
-                    link_preview_options=NO_LINK_PREVIEW,
-                )
+            success = await edit_with_fallback(
+                bot,
+                chat_id,
+                msg_id,
+                status_text,
+                reply_markup=keyboard,
+            )
+            if success:
                 _status_msg_info[skey] = (msg_id, window_id, status_text)
-            except RetryAfter:
-                raise
-            except TelegramError:
-                try:
-                    await bot.edit_message_text(
-                        chat_id=chat_id,
-                        message_id=msg_id,
-                        text=status_text,
-                        reply_markup=keyboard,
-                        link_preview_options=NO_LINK_PREVIEW,
-                    )
-                    _status_msg_info[skey] = (msg_id, window_id, status_text)
-                except RetryAfter:
-                    raise
-                except TelegramError as e:
-                    logger.debug("Failed to edit status message: %s", e)
-                    _status_msg_info.pop(skey, None)
-                    await _do_send_status_message(
-                        bot, user_id, thread_id, window_id, status_text
-                    )
+            else:
+                _status_msg_info.pop(skey, None)
+                await _do_send_status_message(
+                    bot, user_id, thread_id, window_id, status_text
+                )
     else:
         # No existing status message, send new
         await _do_send_status_message(bot, user_id, thread_id, window_id, status_text)