codex-telegram 0.4.16__tar.gz → 0.5.1__tar.gz

{codex-telegram-0.4.16 → codex-telegram-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: codex-telegram
-Version: 0.4.16
+Version: 0.5.1
 Summary: Bridge for controlling the Codex App Server from Telegram and Web UI
 Author: heungtae
 License:                                  Apache License

{codex-telegram-0.4.16 → codex-telegram-0.5.1}/app_runtime/bootstrap.py

@@ -56,6 +56,7 @@ async def post_init(
     match_approval_policy: Callable[..., Any],
     to_thread: Callable[..., Awaitable[Any]],
 ) -> None:
+    state.telegram_app = app
     state.codex_client = await setup_codex_fn()
     state.command_router = command_router_factory(state.codex_client)
     state.approval_guardian = approval_guardian_factory()
@@ -95,6 +96,7 @@ async def post_shutdown(
     *,
     state_module=state,
 ) -> None:
+    state_module.telegram_app = None
     if state_module.codex_client:
         await state_module.codex_client.stop()
         state_module.codex_client = None

{codex-telegram-0.4.16 → codex-telegram-0.5.1}/bot/callbacks.py

@@ -14,6 +14,10 @@ from models import state
 from models.user import user_manager
 from codex.commands import CommandResult
 from web.runtime import event_hub
+from web.telegram_thread_selection import (
+    format_telegram_active_thread_changed_message,
+    preview_from_read_text,
+)
 
 logger = logging.getLogger("codex-telegram.bot")
 GUARDIAN_WEB_ONLY_TEXT = "Guardian settings and rules can be edited in Web UI only."
@@ -227,6 +231,12 @@ async def callback_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
             if command == "start":
                 logger.info("Executing callback action user_id=%s data=%s", user_id, data)
                 result = await run_callback_command("/start", user_id)
+                logger.info(
+                    "Telegram callback /start result user_id=%s kind=%s thread_id=%s",
+                    user_id,
+                    result.kind,
+                    result.meta.get("thread_id"),
+                )
                 await context.bot.send_message(chat_id=chat_id, text=result.text, reply_markup=_main_menu_markup(user_id))
             elif command == "menu":
                 logger.info("Executing callback action user_id=%s data=%s", user_id, data)
@@ -400,7 +410,24 @@ async def callback_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
             thread_id = data[7:]
             logger.info("Executing callback action user_id=%s data=%s", user_id, data)
             result = await state.command_router.route("/resume", [thread_id], user_id)
-            await edit_with_log(query, context, result.text, user_id, reply_markup=_main_menu_markup(user_id))
+            if result.kind == "error":
+                await edit_with_log(
+                    query,
+                    context,
+                    result.text,
+                    user_id,
+                    reply_markup=_main_menu_markup(user_id),
+                )
+                return
+            resolved_thread_id = result.meta.get("thread_id") or thread_id
+            read_result = await state.command_router.route("/read", [resolved_thread_id], user_id)
+            preview = preview_from_read_text(resolved_thread_id, read_result.text)
+            message = format_telegram_active_thread_changed_message(
+                preview,
+                project_key=user_manager.get_thread_project(resolved_thread_id),
+                resume_status="ok",
+            )
+            await edit_with_log(query, context, message, user_id, reply_markup=_main_menu_markup(user_id))
         
         elif data.startswith("fork:"):
             thread_id = data[5:]

{codex-telegram-0.4.16 → codex-telegram-0.5.1}/bot/handlers.py

@@ -21,6 +21,7 @@ from bot.features_ui import features_keyboard, features_panel_text
 from models import state
 from utils.single_instance import find_local_conflict_candidates
 from utils.local_command import run_bang_command
+from web.telegram_sync import bind_telegram_thread_to_active_web
 
 logger = logging.getLogger("codex-telegram.bot")
 _last_conflict_log_at = 0.0
@@ -182,12 +183,15 @@ async def message_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
         )
         return
 
-    if state_user.active_turn_id:
+    active_thread_running_turn_id = state_user.get_turn_for_thread(state_user.active_thread_id)
+    if not active_thread_running_turn_id and state_user.active_turn_id and not state_user.active_turn_id_by_thread:
+        active_thread_running_turn_id = state_user.active_turn_id
+    if active_thread_running_turn_id:
         await send_reply(
             update,
             (
                 "A turn is already running.\n"
-                f"turnId: {state_user.active_turn_id}\n"
+                f"turnId: {active_thread_running_turn_id}\n"
                 "Use /interrupt (or the Interrupt button) to stop it first."
             ),
             user_id,
@@ -205,6 +209,12 @@ async def message_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
             "threadId": state_user.active_thread_id,
             "input": [{"type": "text", "text": text}],
         }
+        bound_user_ids = await bind_telegram_thread_to_active_web(
+            user_id,
+            state_user.active_thread_id,
+            project_key=user_manager.get_thread_project(state_user.active_thread_id),
+            notify_web=False,
+        )
         collaboration_mode = await _require_turn_collaboration_mode(state_user)
         params["collaborationMode"] = collaboration_mode
         logger.info(
@@ -220,7 +230,11 @@ async def message_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
         turn = result.get("turn", {})
         turn_id = turn.get("id", "unknown")
         if isinstance(turn_id, str) and turn_id and turn_id != "unknown":
-            state_user.set_turn(turn_id)
+            state_user.set_turn(turn_id, state_user.active_thread_id)
+            user_manager.bind_turn(user_id, turn_id, state_user.active_thread_id)
+            for bound_user_id in bound_user_ids:
+                if bound_user_id != user_id:
+                    user_manager.bind_turn_subscriber(bound_user_id, turn_id, state_user.active_thread_id)
 
         if state_user.selected_project_path:
             await send_reply(update, f"Turn started: {turn_id}\nWorkspace: {state_user.selected_project_path}", user_id)

{codex-telegram-0.4.16 → codex-telegram-0.5.1}/codex/command_router/projects.py

@@ -210,6 +210,15 @@ class ProjectCommands:
             if isinstance(new_thread_id, str) and new_thread_id:
                 user_manager.set_active_thread(user_id, new_thread_id, project_key=selected["key"])
                 state.clear_turn()
+                if user_id > 0:
+                    from web.telegram_sync import bind_telegram_thread_to_active_web
+
+                    await bind_telegram_thread_to_active_web(
+                        user_id,
+                        new_thread_id,
+                        project_key=selected["key"],
+                        notify_web=True,
+                    )
             else:
                 user_manager.clear_active_thread(user_id)
                 thread_start_note = "\nProject switched, but failed to create a new thread. Run /start."

{codex-telegram-0.4.16 → codex-telegram-0.5.1}/codex/command_router/threads.py

@@ -126,6 +126,15 @@ class ThreadCommands:
 
         if thread_id:
             user_manager.set_active_thread(user_id, thread_id, project_key=(project or {}).get("key"))
+            if user_id > 0:
+                from web.telegram_sync import bind_telegram_thread_to_active_web
+
+                await bind_telegram_thread_to_active_web(
+                    user_id,
+                    thread_id,
+                    project_key=(project or {}).get("key"),
+                    notify_web=True,
+                )
 
         if project:
             return text_result(
@@ -149,6 +158,15 @@ class ThreadCommands:
 
         await self.ctx.codex.call("thread/resume", {"threadId": thread_id})
         user_manager.set_active_thread(user_id, thread_id)
+        if user_id > 0:
+            from web.telegram_sync import bind_telegram_thread_to_active_web
+
+            await bind_telegram_thread_to_active_web(
+                user_id,
+                thread_id,
+                project_key=user_manager.get_thread_project(thread_id),
+                notify_web=True,
+            )
         return text_result(f"Thread resumed: {thread_id}", thread_id=thread_id)
 
     async def fork(self, args: list[str], user_id: int) -> CommandResult:

{codex-telegram-0.4.16 → codex-telegram-0.5.1}/codex/event_forwarding.py

@@ -977,10 +977,16 @@ def truncate_telegram_text(text: str, footer: str) -> str:
     return text[:head_len] + suffix + footer
 
 
+def telegram_turn_footer(turn_id: str | None) -> str:
+    if isinstance(turn_id, str) and turn_id:
+        return f"\n\nturnId: {turn_id}"
+    return ""
+
+
 async def send_telegram_message(app, user_id: int, text: str, turn_id: str | None) -> None:
     if user_id <= 0 or app is None or not text.strip():
         return
-    footer = f"\n\nturnId: {turn_id or 'unknown'}"
+    footer = telegram_turn_footer(turn_id)
     try:
         await app.bot.send_message(
             chat_id=user_id,
@@ -1020,7 +1026,7 @@ async def send_telegram_file_change(app, user_id: int, payload: dict[str, Any])
     try:
         last_index = len(lines) - 1
         for index, line in enumerate(lines):
-            footer = f"\n\nturnId: {turn_id or 'unknown'}" if index == last_index else ""
+            footer = telegram_turn_footer(turn_id) if index == last_index else ""
             await app.bot.send_message(chat_id=user_id, text=truncate_telegram_text(line, footer))
             if index < last_index:
                 await asyncio.sleep(FILE_CHANGE_LINE_DELAY_SECONDS)
@@ -1034,12 +1040,60 @@ async def send_telegram_plan(app, user_id: int, payload: dict[str, Any]) -> None
         await send_telegram_message(app, user_id, f"Plan proposal\n\n{plan_text}", payload.get("turn_id"))
 
 
+def filter_telegram_targets_to_active_thread(
+    method: str,
+    target_user_ids: set[int],
+    thread_id: str | None,
+    turn_id: str | None,
+    params: dict | None,
+) -> set[int]:
+    if not target_user_ids:
+        return set()
+    payload_thread = (params or {}).get("thread")
+    parent_thread_id = (
+        payload_thread.get("forkedFromId")
+        if isinstance(payload_thread, dict) and isinstance(payload_thread.get("forkedFromId"), str)
+        else None
+    )
+    filtered: set[int] = set()
+    for user_id in target_user_ids:
+        if user_id <= 0:
+            filtered.add(user_id)
+            continue
+        active_thread_id = user_manager.get(user_id).active_thread_id
+        if (
+            isinstance(thread_id, str)
+            and thread_id
+            and (active_thread_id == thread_id or active_thread_id == parent_thread_id)
+        ):
+            filtered.add(user_id)
+            continue
+        if not thread_id and method in {"turn/completed", "turn/failed", "turn/cancelled"} and active_thread_id:
+            filtered.add(user_id)
+            continue
+        logger.info(
+            "Telegram forwarding skipped method=%s thread_id=%s turn_id=%s telegram_user_id=%s active_thread_id=%s reason=active_thread_mismatch",
+            method,
+            thread_id,
+            turn_id,
+            user_id,
+            active_thread_id,
+        )
+    return filtered
+
+
 def build_event_forwarder(app, config: ForwardingConfig):
     async def forward_event(method: str, params: dict | None):
         thread_id = extract_thread_id(method, params)
         turn_id = extract_turn_id(method, params)
         if thread_id is None and turn_id:
             thread_id = user_manager.get_turn_thread(turn_id)
+        if not turn_id and thread_id:
+            for user_id in user_manager.find_user_ids_by_thread(thread_id):
+                inferred_turn_id = user_manager.get(user_id).get_turn_for_thread(thread_id)
+                if inferred_turn_id:
+                    turn_id = inferred_turn_id
+                    break
         target_user_ids = set()
         if turn_id:
             target_user_ids.update(user_manager.find_user_ids_by_turn(turn_id))
@@ -1050,6 +1104,7 @@ def build_event_forwarder(app, config: ForwardingConfig):
             fallback_owner = user_manager.find_single_active_turn_owner()
             if fallback_owner is not None:
                 target_user_ids.add(fallback_owner)
+        target_user_ids = filter_telegram_targets_to_active_thread(method, target_user_ids, thread_id, turn_id, params)
 
         if method == "turn/started" and turn_id and target_user_ids:
             actual_mode = normalize_mode_kind((params or {}).get("collaboration_mode_kind") or (params or {}).get("collaborationModeKind"))
@@ -1076,7 +1131,7 @@ def build_event_forwarder(app, config: ForwardingConfig):
                         try:
                             await app.bot.send_message(
                                 chat_id=uid,
-                                text=truncate_telegram_text(message, f"\n\nturnId: {turn_id or 'unknown'}"),
+                                text=truncate_telegram_text(message, telegram_turn_footer(turn_id)),
                             )
                         except Exception:
                             logger.exception("Failed to forward app-server error to Telegram")
@@ -1235,12 +1290,20 @@ def build_event_forwarder(app, config: ForwardingConfig):
         if event_level(method, params) < config.threshold:
             return
         telegram_user_ids = [uid for uid in target_user_ids if uid > 0]
+        logger.info(
+            "Telegram forwarding targets method=%s thread_id=%s turn_id=%s target_user_ids=%s telegram_user_ids=%s",
+            method,
+            thread_id,
+            turn_id,
+            sorted(target_user_ids),
+            sorted(telegram_user_ids),
+        )
         if not telegram_user_ids or app is None:
             return
         message = format_event(method, params, config.rules)
         if message is None or not message.strip():
             return
-        footer = f"\n\nturnId: {turn_id or 'unknown'}"
+        footer = telegram_turn_footer(turn_id)
         for user_id in telegram_user_ids:
             logger.info(
                 "Forwarding app-server event to Telegram user_id=%s method=%s message=%s",

{codex-telegram-0.4.16 → codex-telegram-0.5.1}/codex_telegram/__init__.py

@@ -1,3 +1,3 @@
 """codex-telegram package."""
 
-__version__ = "0.4.16"
+__version__ = "0.5.1"

{codex-telegram-0.4.16 → codex-telegram-0.5.1}/codex_telegram.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: codex-telegram
-Version: 0.4.16
+Version: 0.5.1
 Summary: Bridge for controlling the Codex App Server from Telegram and Web UI
 Author: heungtae
 License:                                  Apache License

{codex-telegram-0.4.16 → codex-telegram-0.5.1}/codex_telegram.egg-info/SOURCES.txt

@@ -47,6 +47,7 @@ codex_telegram.egg-info/requires.txt
 codex_telegram.egg-info/top_level.txt
 models/__init__.py
 models/state.py
+models/telegram_bridge.py
 models/thread.py
 models/user.py
 tests/test_approval_guardian.py
@@ -82,10 +83,14 @@ web/dependencies.py
 web/routes.py
 web/runtime.py
 web/server.py
+web/telegram_sync.py
+web/telegram_thread_selection.py
 web/thread_history.py
 web/workspace.py
-web/static/dist/icons-tab-add.svg
-web/static/dist/icons-tab-close.svg
+web/static/dist/favicon.ico
 web/static/dist/index.html
-web/static/dist/assets/index-C8IolvBK.css
-web/static/dist/assets/index-ERTv2jbE.js
+web/static/dist/assets/codex-telegram-icon-black.svg
+web/static/dist/assets/codex-telegram-icon-ivory.svg
+web/static/dist/assets/codex-telegram-login-image.png
+web/static/dist/assets/index-DIOICBNe.js
+web/static/dist/assets/index-DW1AcoLg.css

{codex-telegram-0.4.16 → codex-telegram-0.5.1}/models/state.py

@@ -7,5 +7,6 @@ from codex.approval_guardian import ApprovalGuardianService
 codex_client: Any | None = None
 command_router: CommandRouter | None = None
 approval_guardian: ApprovalGuardianService | None = None
+telegram_app: Any | None = None
 codex_ready = asyncio.Event()
 update_notified: bool = False

codex-telegram-0.5.1/models/telegram_bridge.py

@@ -0,0 +1,77 @@
+from utils.config import get
+
+from .user import user_manager
+
+
+class TelegramBridgeConfigError(ValueError):
+    pass
+
+
+def single_allowed_telegram_user_id() -> int | None:
+    allowed_ids = get("users.allowed_ids", [])
+    if not isinstance(allowed_ids, list) or len(allowed_ids) != 1:
+        return None
+    try:
+        user_id = int(allowed_ids[0])
+    except (TypeError, ValueError):
+        return None
+    if user_id <= 0:
+        return None
+    return user_id
+
+
+def require_single_allowed_telegram_user_id() -> int:
+    allowed_ids = get("users.allowed_ids", [])
+    if not isinstance(allowed_ids, list) or len(allowed_ids) != 1:
+        raise TelegramBridgeConfigError(
+            "Open in Telegram requires exactly one Telegram user in users.allowed_ids."
+        )
+    try:
+        user_id = int(allowed_ids[0])
+    except (TypeError, ValueError) as exc:
+        raise TelegramBridgeConfigError(
+            "Open in Telegram requires users.allowed_ids to contain one numeric Telegram user id."
+        ) from exc
+    if user_id <= 0:
+        raise TelegramBridgeConfigError(
+            "Open in Telegram requires a positive Telegram user id in users.allowed_ids."
+        )
+    return user_id
+
+
+def bind_thread_counterparts(
+    user_id: int,
+    thread_id: str | None,
+    *,
+    project_key: str | None = None,
+    web_user_ids: list[int] | tuple[int, ...] | set[int] | None = None,
+) -> set[int]:
+    if not isinstance(thread_id, str) or not thread_id:
+        return set()
+
+    user_manager.bind_thread_subscriber(user_id, thread_id)
+    if isinstance(project_key, str) and project_key:
+        user_manager.bind_thread_project(thread_id, project_key)
+
+    bound_user_ids = {user_id}
+    telegram_user_id = single_allowed_telegram_user_id()
+    if telegram_user_id is None:
+        return bound_user_ids
+
+    if user_id > 0:
+        if user_id != telegram_user_id:
+            return bound_user_ids
+        user_manager.keep_user_thread_subscription_only(user_id, thread_id)
+        for web_user_id in web_user_ids or ():
+            if isinstance(web_user_id, int) and web_user_id < 0:
+                user_manager.bind_thread_subscriber(web_user_id, thread_id)
+                bound_user_ids.add(web_user_id)
+        return bound_user_ids
+
+    if user_id < 0:
+        telegram_state = user_manager.get(telegram_user_id)
+        if telegram_state.active_thread_id == thread_id:
+            user_manager.keep_user_thread_subscription_only(telegram_user_id, thread_id)
+            bound_user_ids.add(telegram_user_id)
+
+    return bound_user_ids

{codex-telegram-0.4.16 → codex-telegram-0.5.1}/models/user.py

@@ -152,6 +152,17 @@ class UserManager:
         if isinstance(thread_id, str) and thread_id:
             self._thread_subscribers.setdefault(thread_id, set()).add(user_id)
 
+    def remove_thread_subscriber(self, user_id: int, thread_id: str | None):
+        if not isinstance(thread_id, str) or not thread_id:
+            return
+        subscribers = self._thread_subscribers.get(thread_id)
+        if subscribers is not None:
+            subscribers.discard(user_id)
+            if not subscribers:
+                self._thread_subscribers.pop(thread_id, None)
+        if self._thread_owners.get(thread_id) == user_id:
+            self._thread_owners.pop(thread_id, None)
+
     def bind_thread_project(self, thread_id: str | None, project_key: str | None):
         if isinstance(thread_id, str) and thread_id and isinstance(project_key, str) and project_key:
             self._thread_projects[thread_id] = project_key
@@ -196,6 +207,7 @@ class UserManager:
         if isinstance(turn_id, str) and turn_id:
             self._turn_subscribers.setdefault(turn_id, set()).add(user_id)
         if isinstance(thread_id, str) and thread_id:
+            self.bind_turn_thread(turn_id, thread_id)
             self.bind_thread_subscriber(user_id, thread_id)
 
     def bind_turn(self, user_id: int, turn_id: str | None, thread_id: str | None = None):
@@ -238,6 +250,60 @@ class UserManager:
                 user_ids.add(uid)
         return user_ids
 
+    def remove_turn_subscriber(self, user_id: int, turn_id: str | None):
+        if not isinstance(turn_id, str) or not turn_id:
+            return
+        subscribers = self._turn_subscribers.get(turn_id)
+        if subscribers is not None:
+            subscribers.discard(user_id)
+            if not subscribers:
+                self._turn_subscribers.pop(turn_id, None)
+        if self._turn_owners.get(turn_id) == user_id:
+            self._turn_owners.pop(turn_id, None)
+        self.get(user_id).clear_turn(turn_id=turn_id)
+
+    def remove_user_turn_bindings_except_thread(self, user_id: int, thread_id: str | None):
+        if not isinstance(thread_id, str) or not thread_id:
+            return
+        turn_ids = set(self._turn_threads.keys())
+        turn_ids.update(
+            turn_id
+            for turn_id, subscribers in self._turn_subscribers.items()
+            if user_id in subscribers
+        )
+        turn_ids.update(
+            turn_id
+            for turn_id, owner_id in self._turn_owners.items()
+            if owner_id == user_id
+        )
+        user = self.get(user_id)
+        turn_ids.update(
+            turn_id
+            for mapped_thread_id, turn_id in user.active_turn_id_by_thread.items()
+            if mapped_thread_id != thread_id
+        )
+        for turn_id in list(turn_ids):
+            bound_thread_id = self._turn_threads.get(turn_id)
+            if bound_thread_id != thread_id:
+                self.remove_turn_subscriber(user_id, turn_id)
+                self.remove_thread_subscriber(user_id, bound_thread_id)
+
+    def keep_user_thread_subscription_only(self, user_id: int, thread_id: str | None):
+        if not isinstance(thread_id, str) or not thread_id:
+            return
+        for subscribed_thread_id in list(self._thread_subscribers.keys()):
+            if subscribed_thread_id != thread_id:
+                self.remove_thread_subscriber(user_id, subscribed_thread_id)
+        for owned_thread_id, owner_id in list(self._thread_owners.items()):
+            if owner_id == user_id and owned_thread_id != thread_id:
+                self._thread_owners.pop(owned_thread_id, None)
+        user = self.get(user_id)
+        for mapped_thread_id in list(user.active_turn_id_by_thread.keys()):
+            if mapped_thread_id != thread_id:
+                user.clear_turn(thread_id=mapped_thread_id)
+        self.remove_user_turn_bindings_except_thread(user_id, thread_id)
+        self.bind_thread_subscriber(user_id, thread_id)
+
     def clear_turn_bindings(self, turn_id: str | None):
         if not isinstance(turn_id, str) or not turn_id:
             return

{codex-telegram-0.4.16 → codex-telegram-0.5.1}/tests/test_callbacks_results.py

@@ -1,6 +1,6 @@
 import unittest
 from types import SimpleNamespace
-from unittest.mock import AsyncMock
+from unittest.mock import AsyncMock, patch
 
 from codex.commands import CommandResult
 from bot import callbacks
@@ -127,6 +127,38 @@ class CallbackResultTests(unittest.IsolatedAsyncioTestCase):
         self.assertIn("Collaboration mode set", kwargs["text"])
         self.assertIn("reply_markup", kwargs)
 
+    async def test_callback_start_routes_new_thread_and_logs_thread_id(self):
+        self.mock_router.route.return_value = CommandResult(
+            kind="text",
+            text="Thread started: thread-callback-1",
+            meta={"thread_id": "thread-callback-1"},
+        )
+        query = SimpleNamespace(
+            data="cmd:start",
+            answer=AsyncMock(),
+            edit_message_text=AsyncMock(),
+        )
+        update = SimpleNamespace(
+            callback_query=query,
+            effective_user=SimpleNamespace(id=1),
+            effective_chat=SimpleNamespace(id=100),
+        )
+
+        with patch("bot.callbacks._wait_for_codex", new=AsyncMock()), \
+             patch("bot.callbacks.logger") as mock_logger:
+            await callbacks.callback_handler(update, self.context)
+
+        self.mock_router.route.assert_awaited_once_with("/start", [], 1)
+        kwargs = self.context.bot.send_message.await_args.kwargs
+        self.assertEqual("Thread started: thread-callback-1", kwargs["text"])
+        self.assertIn("reply_markup", kwargs)
+        self.assertTrue(
+            any(
+                len(call.args) >= 4 and call.args[0] == "Telegram callback /start result user_id=%s kind=%s thread_id=%s"
+                for call in mock_logger.info.call_args_list
+            )
+        )
+
     async def test_callback_menu_shows_current_mode(self):
         user_manager.get(1).set_collaboration_mode("plan")
         query = SimpleNamespace(
@@ -207,5 +239,63 @@ class CallbackResultTests(unittest.IsolatedAsyncioTestCase):
         self.assertIn("Collaboration mode set", kwargs["text"])
         self.assertIn("reply_markup", kwargs)
 
+    async def test_callback_resume_shows_thread_changed_preview(self):
+        self.mock_router.route.side_effect = [
+            CommandResult(kind="text", text="Thread resumed: thread-1", meta={"thread_id": "thread-1"}),
+            CommandResult(
+                kind="read",
+                text=(
+                    "Thread: Existing discussion\n"
+                    "Status: active\n"
+                    "ID: thread-1\n"
+                    "Turns: 1\n"
+                    "Preview: What changed? It is synced."
+                ),
+                meta={"thread_id": "thread-1"},
+            ),
+        ]
+        query = SimpleNamespace(
+            data="resume:thread-1",
+            answer=AsyncMock(),
+            edit_message_text=AsyncMock(),
+        )
+        update = SimpleNamespace(
+            callback_query=query,
+            effective_user=SimpleNamespace(id=1),
+            effective_chat=SimpleNamespace(id=100),
+        )
+
+        await callbacks.callback_handler(update, self.context)
+
+        sent_text = query.edit_message_text.await_args.args[0]
+        self.assertIn("Telegram active thread changed", sent_text)
+        self.assertIn("Existing discussion", sent_text)
+        self.assertIn("What changed? It is synced.", sent_text)
+        self.mock_router.route.assert_any_await("/resume", ["thread-1"], 1)
+        self.mock_router.route.assert_any_await("/read", ["thread-1"], 1)
+
+    async def test_callback_resume_failure_stops_before_read(self):
+        self.mock_router.route.return_value = CommandResult(
+            kind="error",
+            text="Error: resume failed",
+        )
+        query = SimpleNamespace(
+            data="resume:thread-1",
+            answer=AsyncMock(),
+            edit_message_text=AsyncMock(),
+        )
+        update = SimpleNamespace(
+            callback_query=query,
+            effective_user=SimpleNamespace(id=1),
+            effective_chat=SimpleNamespace(id=100),
+        )
+
+        await callbacks.callback_handler(update, self.context)
+
+        sent_text = query.edit_message_text.await_args.args[0]
+        self.assertEqual("Error: resume failed", sent_text)
+        self.assertNotIn("Telegram active thread changed", sent_text)
+        self.mock_router.route.assert_awaited_once_with("/resume", ["thread-1"], 1)
+
 if __name__ == "__main__":
     unittest.main()