Match Claude's activity timeline: sparkle spinner, thought-for block with sources

docs/ARCHITECTURE.md

@@ -40,7 +40,7 @@ This speed estimate is measured, not hardcoded. There is no table of "model X do
 
 If the streaming attempt for the head-of-route model fails before showing any text, the bot falls back to a normal (non-streaming) call further down the chain, reusing the same placeholder message rather than sending a new one.
 
-In private chats every request with a real early stage (web search, media, a link or YouTube) first gets a live status bubble (`lumen_status.py`): "Searching the web…", then "Searched the web · found N" plus "Thinking… Ns" while the model call runs. The same bubble is reused: the streamed or non-streamed answer replaces the status text, so no extra message appears. Plain text without an early stage skips the bubble and shows the same "Thinking… Ns" line once streaming starts. Status phrases are fixed pipeline facts (never model reasoning or model identity) and are localized in `lumen_lang.py`.
+In private chats every request with a real early stage (web search, media, a link or YouTube) first gets a live status bubble (`lumen_status.py`) styled after Claude: an animated sparkle (Claude Code's spinner frames) plus "Searching the web", then a checkmarked "Searched the web · found N" and a "Thinking… Ns" timer while the model call runs. The same bubble is reused for the answer. At the final edit a collapsed `Thought for Ns` blockquote (with the completed steps and search source domains) is prepended above the answer, mirroring Claude's collapsible reasoning/activity block; Telegram collapses it by default. Plain text without an early stage skips the early bubble and gets the same collapsed `Thought for Ns` block once streaming finishes. Long answers split across several Telegram messages skip the block: it would not fit the per-message limit. Status phrases are fixed pipeline facts (never model reasoning or model identity) and are localized in `lumen_lang.py`.
 
 Final answers go out via `sendRichMessage` (Bot API 10.1: real tables, headings, math) with automatic fallback to plain HTML; streaming edits always use HTML. Kill-switch: `RICH_MESSAGES_ENABLED=0` (plus restart) forces legacy HTML.
 

lumen_lang.py

@@ -866,6 +866,14 @@ STRINGS: dict[str, dict[str, str]] = {
         "ru": "Пробую ещё раз",
         "uk": "Пробую ще раз",
     },
+    "progress_thought_for": {
+        "be": "Думаў {sec} с",
+        "en": "Thought for {sec}s",
+        "es": "Pensé durante {sec} s",
+        "kk": "Ойлауға {sec} с кетті",
+        "ru": "Думал {sec} с",
+        "uk": "Думав {sec} с",
+    },
     # ── Кнопки-уточнения: служебные реплики ──
     "pick_suffix": {
         "be": "\n\n(або проста напішы тэкстам)",
@@ -1003,6 +1011,7 @@ PACK_PT: dict[str, str] = {
     "status_listening": "Ouvindo.",
     "progress_searching": "Pesquisando na internet",
     "progress_search_done": "Pesquisa na internet · encontrei {count}",
+    "progress_thought_for": "Pensei por {sec}s",
     "progress_search_empty": "A pesquisa não encontrou nada",
     "progress_thinking": "Pensando… {sec}s",
     "progress_reading_link": "Lendo o link",
@@ -1111,6 +1120,7 @@ PACK_AR: dict[str, str] = {
     "status_listening": "أستمع.",
     "progress_searching": "أبحث في الإنترنت",
     "progress_search_done": "بحث في الإنترنت · وجدت {count}",
+    "progress_thought_for": "فكرت لمدة {sec} ث",
     "progress_search_empty": "لم يجد البحث شيئًا",
     "progress_thinking": "أفكر… {sec} ث",
     "progress_reading_link": "أقرأ الرابط",
@@ -1219,6 +1229,7 @@ PACK_TR: dict[str, str] = {
     "status_listening": "Dinliyorum.",
     "progress_searching": "İnternette arıyorum",
     "progress_search_done": "İnternet araması · {count} bulundu",
+    "progress_thought_for": "{sec} sn düşündüm",
     "progress_search_empty": "Arama hiçbir şey bulamadı",
     "progress_thinking": "Düşünüyorum… {sec} sn",
     "progress_reading_link": "Bağlantıyı okuyorum",
@@ -1327,6 +1338,7 @@ PACK_DE: dict[str, str] = {
     "status_listening": "Ich höre zu.",
     "progress_searching": "Ich suche im Internet",
     "progress_search_done": "Internetsuche · {count} gefunden",
+    "progress_thought_for": "{sec} s nachgedacht",
     "progress_search_empty": "Die Suche ergab nichts",
     "progress_thinking": "Ich denke nach… {sec} s",
     "progress_reading_link": "Ich lese den Link",
@@ -1435,6 +1447,7 @@ PACK_FR: dict[str, str] = {
     "status_listening": "J'écoute.",
     "progress_searching": "Je cherche sur internet",
     "progress_search_done": "Recherche web · {count} trouvés",
+    "progress_thought_for": "Réflexion pendant {sec} s",
     "progress_search_empty": "La recherche n'a rien donné",
     "progress_thinking": "Je réfléchis… {sec} s",
     "progress_reading_link": "Je lis le lien",
@@ -1543,6 +1556,7 @@ PACK_IT: dict[str, str] = {
     "status_listening": "Ti ascolto.",
     "progress_searching": "Cerco su internet",
     "progress_search_done": "Ricerca web · {count} trovati",
+    "progress_thought_for": "Ho pensato per {sec} s",
     "progress_search_empty": "La ricerca non ha trovato nulla",
     "progress_thinking": "Sto pensando… {sec} s",
     "progress_reading_link": "Sto leggendo il link",
@@ -1651,6 +1665,7 @@ PACK_HI: dict[str, str] = {
     "status_listening": "सुन रहा हूं।",
     "progress_searching": "इंटरनेट पर खोज रहा हूँ",
     "progress_search_done": "वेब खोज · {count} मिले",
+    "progress_thought_for": "{sec} सेकंड सोचा",
     "progress_search_empty": "खोज में कुछ नहीं मिला",
     "progress_thinking": "सोच रहा हूँ… {sec} से",
     "progress_reading_link": "लिंक पढ़ रहा हूँ",
@@ -1759,6 +1774,7 @@ PACK_ID: dict[str, str] = {
     "status_listening": "Mendengarkan.",
     "progress_searching": "Mencari di internet",
     "progress_search_done": "Pencarian web · {count} ditemukan",
+    "progress_thought_for": "Berpikir {sec} dtk",
     "progress_search_empty": "Pencarian tidak menemukan apa pun",
     "progress_thinking": "Berpikir… {sec} dtk",
     "progress_reading_link": "Membaca tautan",
@@ -1867,6 +1883,7 @@ PACK_MS: dict[str, str] = {
     "status_listening": "Mendengar.",
     "progress_searching": "Mencari di internet",
     "progress_search_done": "Carian web · {count} ditemui",
+    "progress_thought_for": "Berfikir {sec} saat",
     "progress_search_empty": "Carian tidak menemui apa-apa",
     "progress_thinking": "Berfikir… {sec} saat",
     "progress_reading_link": "Membaca pautan",
@@ -1975,6 +1992,7 @@ PACK_VI: dict[str, str] = {
     "status_listening": "Đang nghe.",
     "progress_searching": "Đang tìm trên internet",
     "progress_search_done": "Tìm kiếm web · tìm thấy {count}",
+    "progress_thought_for": "Đã suy nghĩ {sec} giây",
     "progress_search_empty": "Tìm kiếm không có kết quả",
     "progress_thinking": "Đang suy nghĩ… {sec} giây",
     "progress_reading_link": "Đang đọc liên kết",
@@ -2083,6 +2101,7 @@ PACK_TH: dict[str, str] = {
     "status_listening": "กำลังฟัง",
     "progress_searching": "กำลังค้นหาในอินเทอร์เน็ต",
     "progress_search_done": "ค้นหาเว็บ · พบ {count}",
+    "progress_thought_for": "คิดเป็นเวลา {sec} วิ",
     "progress_search_empty": "ค้นหาไม่พบอะไร",
     "progress_thinking": "กำลังคิด… {sec} วิ",
     "progress_reading_link": "กำลังอ่านลิงก์",
@@ -2191,6 +2210,7 @@ PACK_FA: dict[str, str] = {
     "status_listening": "گوش می‌دهم.",
     "progress_searching": "در اینترنت جستجو می‌کنم",
     "progress_search_done": "جستجوی وب · {count} یافت شد",
+    "progress_thought_for": "{sec} ثانیه فکر کردم",
     "progress_search_empty": "جستجو چیزی پیدا نکرد",
     "progress_thinking": "در حال فکر کردن… {sec} ث",
     "progress_reading_link": "در حال خواندن پیوند",
@@ -2299,6 +2319,7 @@ PACK_UR: dict[str, str] = {
     "status_listening": "سن رہا ہوں۔",
     "progress_searching": "انٹرنیٹ پر تلاش کر رہا ہوں",
     "progress_search_done": "ویب تلاش · {count} ملے",
+    "progress_thought_for": "{sec} سیکنڈ سوچا",
     "progress_search_empty": "تلاش میں کچھ نہیں ملا",
     "progress_thinking": "سوچ رہا ہوں… {sec} س",
     "progress_reading_link": "لنک پڑھ رہا ہوں",
@@ -2407,6 +2428,7 @@ PACK_UZ: dict[str, str] = {
     "status_listening": "Eshityapman.",
     "progress_searching": "Internetda qidiryapman",
     "progress_search_done": "Veb qidiruv · {count} topildi",
+    "progress_thought_for": "{sec} soniya o'yladim",
     "progress_search_empty": "Qidiruv hech narsa topmadi",
     "progress_thinking": "O'ylayapman… {sec} s",
     "progress_reading_link": "Havolani o'qiyapman",
@@ -2515,6 +2537,7 @@ PACK_BN: dict[str, str] = {
     "status_listening": "শুনছি।",
     "progress_searching": "ইন্টারনেটে খুঁজছি",
     "progress_search_done": "ওয়েব অনুসন্ধান · {count}টি পাওয়া গেছে",
+    "progress_thought_for": "{sec} সেকেন্ড ভেবেছি",
     "progress_search_empty": "অনুসন্ধানে কিছু পাওয়া যায়নি",
     "progress_thinking": "ভাবছি… {sec} সেকেন্ড",
     "progress_reading_link": "লিংক পড়ছি",
@@ -2623,6 +2646,7 @@ PACK_FIL: dict[str, str] = {
     "status_listening": "Nakikinig.",
     "progress_searching": "Naghahanap sa internet",
     "progress_search_done": "Web search · {count} ang nakita",
+    "progress_thought_for": "Nag-isip ng {sec} seg",
     "progress_search_empty": "Walang nahanap ang paghahanap",
     "progress_thinking": "Nag-iisip… {sec} seg",
     "progress_reading_link": "Binabasa ang link",
@@ -2731,6 +2755,7 @@ PACK_PL: dict[str, str] = {
     "status_listening": "Słucham.",
     "progress_searching": "Szukam w internecie",
     "progress_search_done": "Wyszukiwanie w sieci · znaleziono {count}",
+    "progress_thought_for": "Myślałem przez {sec} s",
     "progress_search_empty": "Wyszukiwanie nic nie dało",
     "progress_thinking": "Myślę… {sec} s",
     "progress_reading_link": "Czytam link",
@@ -2839,6 +2864,7 @@ PACK_NL: dict[str, str] = {
     "status_listening": "Ik luister.",
     "progress_searching": "Ik zoek op internet",
     "progress_search_done": "Webzoekopdracht · {count} gevonden",
+    "progress_thought_for": "Ik dacht {sec} s na",
     "progress_search_empty": "De zoekopdracht leverde niets op",
     "progress_thinking": "Ik denk na… {sec} s",
     "progress_reading_link": "Ik lees de link",
@@ -2947,6 +2973,7 @@ PACK_ZU: dict[str, str] = {
     "status_listening": "Ngilalele.",
     "progress_searching": "Ngisesha kuyi-inthanethi",
     "progress_search_done": "Ukusesha kuwebhu · kutholwe {count}",
+    "progress_thought_for": "Ngicabange imizuzwana engu-{sec}",
     "progress_search_empty": "Ukusesha akutholanga lutho",
     "progress_thinking": "Ngicabanga… {sec} s",
     "progress_reading_link": "Ngifunda isixhumanisi",

lumen_message_core.py

@@ -14,8 +14,9 @@ from datetime import datetime
 from typing import Any
 from zoneinfo import ZoneInfo
 
-from aiogram.enums import ChatType
+from aiogram.enums import ChatType, ParseMode
 from aiogram.types import Message, Update
+from urllib.parse import urlparse
 
 from lumen_message_parse import (
     DRAW_TRIGGER_PREFIXES,
@@ -782,6 +783,7 @@ async def _handle_message_core(message: Message, extra_media: list[tuple[bytes,
         if status is not None:
             if snippets:
                 status.add_done("progress_search_done", count=len(snippets))
+                status.set_sources([urlparse(item.get("url") or "").netloc for item in snippets])
             else:
                 status.add_done("progress_search_empty")
             await status.set_phase("progress_thinking", timed=True)
@@ -875,8 +877,17 @@ async def _handle_message_core(message: Message, extra_media: list[tuple[bytes,
             ans = note_text + "\n\n" + ans
             if reply_already_sent and status is not None:
                 # Ответ уже в статус-пузыре (стрим или переиспользование) —
-                # пометку дописываем туда же, иначе она потеряется.
-                await bot._edit_message_quietly(status.message, ans)
+                # пометку дописываем туда же вместе со свёрнутым блоком активности.
+                html_text, plain_text = status.compose_answer(ans)
+                if html_text is not None:
+                    edited = await bot._tg_call(
+                        status.message.edit_text, html_text,
+                        parse_mode=ParseMode.HTML, call_timeout=15.0,
+                    )
+                    if edited is None:
+                        await bot._tg_call(status.message.edit_text, plain_text, parse_mode=None, call_timeout=15.0)
+                else:
+                    await bot._edit_message_quietly(status.message, ans)
         if not reply_already_sent:
             await bot._safe_reply(message, ans)
         # Частичный стрим тоже «успешен» для вызывающего, но его пометка

lumen_routes.py

@@ -16,6 +16,7 @@ from datetime import date, datetime
 from typing import Any, Callable
 
 import aiohttp
+from aiogram.enums import ParseMode
 from aiogram.types import Message
 from google.genai import types
 
@@ -1101,13 +1102,29 @@ async def _run_route(
                 _note_answered("openrouter", None)
 
             if status is not None:
-                # Останавливаем анимацию статуса до записи ответа, иначе тикер
-                # перезапишет готовый текст.
-                await status.stop()
+                # Фиксируем длительность ожидания и останавливаем анимацию до
+                # записи ответа, иначе тикер перезапишет готовый текст.
+                await status.finish()
             if reusable_placeholder is not None:
                 # Готовый ответ — прямо в плейсхолдер (если влезает в одно сообщение), иначе обычным путём с разбиением.
                 fits_one_message = len(_split_text_chunks(ans, bot.TG_MAX_LEN)) == 1
-                reused = fits_one_message and await bot._edit_message_quietly(reusable_placeholder, ans)
+                reused = False
+                if fits_one_message:
+                    html_text, plain_text = status.compose_answer(ans) if status is not None else (None, ans)
+                    if html_text is not None:
+                        edited = await bot._tg_call(
+                            reusable_placeholder.edit_text, html_text,
+                            parse_mode=ParseMode.HTML, call_timeout=15.0,
+                        )
+                        reused = edited is not None
+                        if not reused:
+                            edited = await bot._tg_call(
+                                reusable_placeholder.edit_text, plain_text,
+                                parse_mode=None, call_timeout=15.0,
+                            )
+                            reused = edited is not None
+                    else:
+                        reused = await bot._edit_message_quietly(reusable_placeholder, ans)
                 if not reused:
                     await bot._delete_message_quietly(reusable_placeholder)
                 reusable_placeholder = None

lumen_status.py

@@ -1,35 +1,47 @@
-"""lumen_status.py — живой статус-плейсхолдер: этапы обработки запроса в одном сообщении (поиск, источники, таймер ожидания)."""
+"""lumen_status.py — живой статус-плейсхолдер в духе Claude: анимированная искра, этапы, «Думал N с» и свёрнутый блок активности."""
 from __future__ import annotations
 
 import asyncio
 import contextlib
-import logging
+import html
 import time
 
 from aiogram.types import Message
 
+from lumen_formatting import _is_table_separator, _md_to_html
 from lumen_lang import t as _lang_t
 
-log = logging.getLogger("bot")
-
-_PROGRESS_FRAMES = (".", "..", "…")
+# Искры как в Claude Code: кадры спиннера, а не точки.
+_SPINNER_FRAMES = ("·", "✢", "✳", "✶", "✻", "✽")
 # Страховка от утечки тикера, если обработчик упал между созданием статуса и
 # маршрутом: дольше этого статус сам себя останавливает.
 _STATUS_MAX_LIFETIME_SEC = 300.0
 
 
+def thought_block(lang: str, sec: int, answer_md: str) -> tuple[str | None, str]:
+    """Свёрнутый блок «✻ Thought for Ns» над ответом: (HTML, простой текст).
+    Таблицы возвращают None — их показываем обычным rich-путём без блока."""
+    if any(_is_table_separator(line) for line in answer_md.splitlines()):
+        return None, answer_md
+    line = "✻ " + _lang_t(lang, "progress_thought_for", sec=max(0, int(sec)))
+    html_block = "<blockquote expandable>" + html.escape(line) + "</blockquote>\n\n" + _md_to_html(answer_md)
+    return html_block, line + "\n\n" + answer_md
+
+
 class StatusMessage:
-    """Сообщение-статус: завершённые этапы + текущая фраза с анимацией или таймером.
+    """Сообщение-статус: завершённые этапы + текущая фраза с искрой и таймером.
     Все правки глотают ошибки: удалённое сообщение не должно ломать ответ."""
 
     def __init__(self, message: Message, lang: str):
         self.message = message
         self.lang = lang
         self._done: list[str] = []
+        self._sources: list[str] = []
         self._phrase_key = ""
         self._timed = False
         self._phase_started = time.monotonic()
         self._created = time.monotonic()
+        self._thought_seconds: int | None = None
         self._task: asyncio.Task | None = None
         self._stopped = False
 
@@ -50,8 +62,12 @@ class StatusMessage:
         return status
 
     def add_done(self, key: str, **kwargs: object) -> None:
-        """Завершённый этап отдельной строкой над текущей фразой."""
-        self._done.append(_lang_t(self.lang, key, **kwargs))
+        """Завершённый этап отдельной строкой с галочкой, как в трейсе Claude."""
+        self._done.append("✓ " + _lang_t(self.lang, key, **kwargs))
+
+    def set_sources(self, hosts: list[str]) -> None:
+        """Домены найденных источников для раскрытого блока активности."""
+        self._sources = [h for h in hosts if h][:5]
 
     async def set_phase(self, key: str, *, timed: bool = False) -> None:
         """Смена текущей фразы с немедленной правкой, не дожидаясь тика."""
@@ -60,18 +76,49 @@ class StatusMessage:
         with contextlib.suppress(Exception):
             await bot._tg_call(self.message.edit_text, self._render(0), parse_mode=None, call_timeout=15.0)
 
+    async def finish(self) -> None:
+        """Фиксирует длительность ожидания и останавливает анимацию."""
+        if self._thought_seconds is None:
+            self._thought_seconds = max(0, int(time.monotonic() - self._phase_started))
+        await self.stop()
+
+    def activity_prefix(self) -> tuple[str, str]:
+        """(HTML-блок для ответа, тот же блок простым текстом); пусто — активности нет."""
+        thought = self._thought_seconds if self._thought_seconds is not None else max(
+            0, int(time.monotonic() - self._phase_started))
+        lines = ["✻ " + _lang_t(self.lang, "progress_thought_for", sec=thought)]
+        lines.extend(self._done)
+        if self._phrase_key and not self._timed and self._phrase_key != "progress_thinking":
+            lines.append("✓ " + _lang_t(self.lang, self._phrase_key))
+        if self._sources:
+            lines.extend("· " + host for host in self._sources)
+        plain = "\n".join(lines)
+        html_block = "<blockquote expandable>" + "\n".join(html.escape(line) for line in lines) + "</blockquote>"
+        return html_block, plain
+
+    def compose_answer(self, answer_md: str) -> tuple[str | None, str]:
+        """Ответ с свёрнутым блоком активности: (HTML для parse_mode=HTML, простой текст).
+        Таблицы отдаём обычным путём (rich-сообщение): цитата сломала бы их разметку."""
+        if any(_is_table_separator(line) for line in answer_md.splitlines()):
+            return None, answer_md
+        html_block, plain_block = self.activity_prefix()
+        if not html_block:
+            return None, answer_md
+        return html_block + "\n\n" + _md_to_html(answer_md), plain_block + "\n\n" + answer_md
+
     def _set_phrase(self, key: str, *, timed: bool) -> None:
         self._phrase_key = key
         self._timed = timed
         self._phase_started = time.monotonic()
 
     def _render(self, frame_idx: int) -> str:
+        spark = _SPINNER_FRAMES[frame_idx % len(_SPINNER_FRAMES)]
         lines = list(self._done)
         if self._timed:
             elapsed = max(0, int(time.monotonic() - self._phase_started))
-            lines.append(_lang_t(self.lang, self._phrase_key, sec=elapsed))
+            lines.append(spark + " " + _lang_t(self.lang, self._phrase_key, sec=elapsed))
         else:
-            lines.append(_lang_t(self.lang, self._phrase_key) + _PROGRESS_FRAMES[frame_idx % len(_PROGRESS_FRAMES)])
+            lines.append(spark + " " + _lang_t(self.lang, self._phrase_key))
         return "\n".join(lines)
 
     async def _tick(self) -> None:

lumen_streaming.py

@@ -10,11 +10,12 @@ import logging
 import time
 from typing import Any
 import aiohttp
-from aiogram.enums import ParseMode
+from aiogram.enums import ChatType, ParseMode
 from aiogram.types import Message
 
 from lumen_formatting import _md_to_html, _split_text_chunks
 from lumen_lang import t as _lang_t
+from lumen_status import _SPINNER_FRAMES, thought_block
 from lumen_message_parse import _history_user_text
 from lumen_model_speed import (
     speed_key as _model_speed_key,
@@ -50,13 +51,16 @@ async def _tick_waiting_dots(placeholder: Message) -> None:
         await bot._dots_sleep(bot._DOTS_START_AFTER_SEC)
         chat = getattr(placeholder, "chat", None)
         lang = bot._chat_lang(getattr(chat, "id", None))
+        frame_idx = 0
         while True:
             elapsed = max(0, int(time.monotonic() - started))
+            spark = _SPINNER_FRAMES[frame_idx % len(_SPINNER_FRAMES)]
             with contextlib.suppress(Exception):
                 await bot._tg_call(
-                    placeholder.edit_text, _lang_t(lang, "progress_thinking", sec=elapsed),
+                    placeholder.edit_text, spark + " " + _lang_t(lang, "progress_thinking", sec=elapsed),
                     parse_mode=None, call_timeout=15.0,
                 )
+            frame_idx += 1
             await bot._dots_sleep(bot._DOTS_TICK_SEC)
     except asyncio.CancelledError:
         raise
@@ -84,8 +88,9 @@ async def _pieces_with_waiting_feedback(piece_agen, placeholder: Message, *, fir
                 with contextlib.suppress(asyncio.CancelledError):
                     await dots_task
         if status is not None:
-            # Первый кусок пришёл: текст сейчас заменит статус, анимацию гасим.
-            await status.stop()
+            # Первый кусок пришёл: фиксируем «Думал N с» и гасим анимацию —
+            # текст сейчас заменит статус.
+            await status.finish()
         yield first
         async for piece in piece_agen:
             yield piece
@@ -268,7 +273,7 @@ async def _run_streaming_reply(
             placeholder = status.message
         else:
             placeholder = await bot._tg_call(
-                message.reply, bot._t(message.chat.id, "progress_thinking", sec=0),
+                message.reply, _SPINNER_FRAMES[0] + " " + bot._t(message.chat.id, "progress_thinking", sec=0),
                 parse_mode=None, call_timeout=bot.TELEGRAM_REQUEST_TIMEOUT,
             )
         if placeholder is None:
@@ -417,6 +422,28 @@ async def _run_streaming_reply(
             # досылаем новым сообщением (_send_text внутри режет на части сам),
             # иначе пользователь его не увидит.
             await bot._safe_reply(message, full_text.strip())
+        elif len(final_chunks) == 1 and (
+            status is not None or getattr(getattr(message, "chat", None), "type", None) == ChatType.PRIVATE
+        ):
+            # Одно сообщение: сверху добавляем свёрнутый блок активности,
+            # как «Thought for Ns» в Claude. Длинный ответ не трогаем: заголовок
+            # не влез бы в лимит первого сообщения. Без раннего статуса (обычный
+            # текст) строим минимальный блок по времени до первого куска.
+            if status is not None:
+                html_text, plain_text = status.compose_answer(final_text)
+            else:
+                thought_sec = int(max(0.0, (first_piece_ts or overall_start_ts) - overall_start_ts))
+                html_text, plain_text = thought_block(bot._chat_lang(message.chat.id), thought_sec, final_text)
+            if html_text is None:
+                # Таблицы и прочий rich-контент: обычный путь без блока активности.
+                await bot._edit_message_quietly(sent_messages[-1], final_text, call_timeout=15.0)
+            else:
+                edited = await bot._tg_call(
+                    sent_messages[-1].edit_text, html_text,
+                    parse_mode=ParseMode.HTML, call_timeout=15.0,
+                )
+                if edited is None:
+                    await bot._tg_call(sent_messages[-1].edit_text, plain_text, parse_mode=None, call_timeout=15.0)
         else:
             # HTML->plain fallback — внутри _edit_message_quietly (раньше дублировался здесь вручную).
             await bot._edit_message_quietly(sent_messages[-1], final_text, call_timeout=15.0)

tests/test_bot_search.py

@@ -117,12 +117,16 @@ class _FakeStatus:
         self.message = object()
         self.done = []
         self.phases = []
+        self.sources = []
         self.stopped = False
         self.deleted = False
 
     def add_done(self, key, **kwargs):
         self.done.append((key, kwargs))
 
+    def set_sources(self, hosts):
+        self.sources = list(hosts)
+
     async def set_phase(self, key, *, timed=False):
         self.phases.append((key, timed))
 

tests/test_bot_streaming.py

@@ -712,7 +712,9 @@ def test_waiting_dots_cycles_frames_then_stops_on_cancel(monkeypatch):
     assert calls[0] == bot._DOTS_START_AFTER_SEC
     assert calls[1:] == [bot._DOTS_TICK_SEC] * 3
     assert len(placeholder.edits) == 3
-    assert all(text.startswith("Thinking") for text, _ in placeholder.edits)
+    import lumen_status
+    assert all(text[0] in lumen_status._SPINNER_FRAMES and "Thinking" in text
+               for text, _ in placeholder.edits)
     # Код языка не должен утечь в chat_state строковым ключом (прод 28.10.2026).
     assert "en" not in bot.chat_state
 
@@ -738,6 +740,30 @@ def test_streaming_fast_path_shows_no_dots_frames():
         bot.chat_state.pop(chat_id, None)
 
 
+def test_streaming_plain_text_adds_collapsed_thought_block():
+    # Даже без раннего статуса обычный ответ получает свёрнутый «Thought for Ns»,
+    # как в Claude: вопрос не ждал bubble, но финальный вид — с трейсом.
+    chat_id = 999321
+
+    async def pieces():
+        yield "Привет"
+
+    incoming = _FakeIncomingMessage(chat_id)
+    try:
+        answer, _ = asyncio.run(bot._run_streaming_reply(
+            chat_id, "Привет!", incoming, provider="openrouter", model_id="y:free",
+            piece_agen=pieces(),
+        ))
+        assert answer == "Привет"
+        final_text, parse_mode = incoming.sent[0].edits[-1]
+        assert parse_mode == bot.ParseMode.HTML
+        assert final_text.startswith("<blockquote expandable>")
+        assert "Thought for" in final_text
+        assert "Привет" in final_text
+    finally:
+        bot.chat_state.pop(chat_id, None)
+
+
 def test_streaming_reuses_status_bubble_instead_of_sending_new_placeholder():
     # Живой статус уже в чате: стрим пишет ответ в него, второго «…» нет.
     chat_id = 999320
@@ -745,10 +771,14 @@ def test_streaming_reuses_status_bubble_instead_of_sending_new_placeholder():
     class _FakeStatus:
         def __init__(self):
             self.message = _FakeSentMessage()
-            self.stopped = False
+            self.finished = False
+
+        async def finish(self):
+            self.finished = True
 
-        async def stop(self):
-            self.stopped = True
+        def compose_answer(self, answer_md):
+            return ("<blockquote expandable>✻ Thought for 1s</blockquote>\n\n" + answer_md,
+                    "✻ Thought for 1s\n\n" + answer_md)
 
     async def pieces():
         yield "Привет"
@@ -762,8 +792,10 @@ def test_streaming_reuses_status_bubble_instead_of_sending_new_placeholder():
         ))
         assert answer == "Привет"
         assert incoming.sent == []  # второй пузырь не отправлялся
-        assert status.stopped is True
-        assert status.message.edits[-1][0] == "Привет"
+        assert status.finished is True
+        final_edit = status.message.edits[-1][0]
+        assert "Привет" in final_edit
+        assert "Thought for" in final_edit
     finally:
         bot.chat_state.pop(chat_id, None)
 

tests/test_lumen_status.py

@@ -27,16 +27,24 @@ def test_status_message_renders_done_lines_and_timer(monkeypatch):
         status = await StatusMessage.start(incoming, "en", "progress_searching")
         assert status is not None
         status.add_done("progress_search_done", count=5)
+        status.set_sources(["example.com"])
         await status.set_phase("progress_thinking", timed=True)
-        await status.stop()
+        await status.finish()
         return status
 
     status = asyncio.run(scenario())
     sent = incoming.sent[0]
     assert status.message is sent
     text = sent.edits[-1][0]
-    assert "Searched the web · found 5" in text
+    assert "✓ Searched the web · found 5" in text
     assert "Thinking… 0s" in text
+    html_block, plain_block = status.activity_prefix()
+    assert html_block.startswith("<blockquote expandable>") and html_block.endswith("</blockquote>")
+    assert "Thought for 0s" in plain_block
+    assert "✓ Searched the web · found 5" in plain_block
+    assert "· example.com" in plain_block
+    # Таблицы показываются rich-сообщением: блок-цитата вернула бы None.
+    assert status.compose_answer("| a | b |\n|---|---|\n| 1 | 2 |")[0] is None
     # Язык статуса — это код языка, а не chat_id: строка "en" не должна
     # попасть в chat_state как ключ (прод 28.10.2026).
     assert "en" not in bot.chat_state