codex-autorunner 1.1.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

codex_autorunner/integrations/telegram/handlers/commands_runtime.py

@@ -870,7 +870,7 @@ class TelegramCommandHandlers(
         key = await self._resolve_topic_key(message.chat_id, message.thread_id)
         self._model_options.pop(key, None)
         self._model_pending.pop(key, None)
-        record = await self._router.get_topic(key)
+        record = await self._router.ensure_topic(message.chat_id, message.thread_id)
         agent = self._effective_agent(record)
         supports_effort = self._agent_supports_effort(agent)
         list_params = {
@@ -878,10 +878,17 @@ class TelegramCommandHandlers(
             "limit": DEFAULT_MODEL_LIST_LIMIT,
             "agent": agent,
         }
-        try:
-            client = await self._client_for_workspace(
-                record.workspace_path if record else None
+        workspace_path, error = self._resolve_workspace_path(record, allow_pma=True)
+        if workspace_path is None:
+            await self._send_message(
+                message.chat_id,
+                error or "Topic not bound. Use /bind <repo_id> or /bind <path>.",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
             )
+            return
+        try:
+            client = await self._client_for_workspace(workspace_path)
         except AppServerUnavailableError as exc:
             log_event(
                 self._logger,
@@ -901,16 +908,20 @@ class TelegramCommandHandlers(
         if client is None:
             await self._send_message(
                 message.chat_id,
-                "Topic not bound. Use /bind <repo_id> or /bind <path>.",
+                error or "Topic not bound. Use /bind <repo_id> or /bind <path>.",
                 thread_id=message.thread_id,
                 reply_to=message.message_id,
             )
             return
         argv = self._parse_command_args(args)
         if not argv:
+            record_for_models = self._record_with_workspace_path(record, workspace_path)
             try:
                 result = await self._fetch_model_list(
-                    record, agent=agent, client=client, list_params=list_params
+                    record_for_models,
+                    agent=agent,
+                    client=client,
+                    list_params=list_params,
                 )
             except OpenCodeSupervisorError as exc:
                 log_event(
@@ -993,9 +1004,13 @@ class TelegramCommandHandlers(
             )
             return
         if argv[0].lower() in ("list", "ls"):
+            record_for_models = self._record_with_workspace_path(record, workspace_path)
             try:
                 result = await self._fetch_model_list(
-                    record, agent=agent, client=client, list_params=list_params
+                    record_for_models,
+                    agent=agent,
+                    client=client,
+                    list_params=list_params,
                 )
             except OpenCodeSupervisorError as exc:
                 log_event(
@@ -1108,6 +1123,101 @@ class TelegramCommandHandlers(
             reply_to=message.message_id,
         )
 
+    async def _handle_pma(
+        self, message: TelegramMessage, args: str, _runtime: Any
+    ) -> None:
+        if not self._hub_root:
+            await self._send_message(
+                message.chat_id,
+                "PMA unavailable; hub root not configured.",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return
+
+        supervisor = getattr(self, "_hub_supervisor", None)
+        if supervisor and hasattr(supervisor, "hub_config"):
+            pma_config = supervisor.hub_config.pma
+            if not pma_config.enabled:
+                await self._send_message(
+                    message.chat_id,
+                    "PMA is disabled in hub config. Set pma.enabled: true to enable.",
+                    thread_id=message.thread_id,
+                    reply_to=message.message_id,
+                )
+                return
+        argv = self._parse_command_args(args)
+        action = argv[0].lower() if argv else ""
+        key = await self._resolve_topic_key(message.chat_id, message.thread_id)
+        record = await self._router.get_topic(key)
+        current = bool(record and record.pma_enabled)
+        if action in ("status", "show"):
+            enabled = current
+        elif action in ("on", "enable", "true"):
+            enabled = True
+        elif action in ("off", "disable", "false"):
+            enabled = False
+        elif action:
+            await self._send_message(
+                message.chat_id,
+                "Usage: /pma [on|off|status]",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return
+        else:
+            enabled = not current
+
+        if record is None:
+            await self._router.ensure_topic(message.chat_id, message.thread_id)
+
+        def apply_pma(record: TelegramTopicRecord) -> None:
+            record.pma_enabled = enabled
+            if enabled:
+                # Save previous binding before entering PMA mode.
+                record.pma_prev_repo_id = record.repo_id
+                record.pma_prev_workspace_path = record.workspace_path
+                record.pma_prev_workspace_id = record.workspace_id
+                record.pma_prev_active_thread_id = record.active_thread_id
+                # Mutual exclusion: PMA mode implies Hub context, so unbind specific repo.
+                record.workspace_path = None
+                record.repo_id = None
+                record.workspace_id = None
+                record.active_thread_id = None
+            else:
+                # Restore previous binding when exiting PMA mode.
+                if record.pma_prev_repo_id or record.pma_prev_workspace_path:
+                    record.repo_id = record.pma_prev_repo_id
+                    record.workspace_path = record.pma_prev_workspace_path
+                    record.workspace_id = record.pma_prev_workspace_id
+                    record.active_thread_id = record.pma_prev_active_thread_id
+                    # Clear saved previous binding after restore.
+                    record.pma_prev_repo_id = None
+                    record.pma_prev_workspace_path = None
+                    record.pma_prev_workspace_id = None
+                    record.pma_prev_active_thread_id = None
+
+        await self._router.update_topic(
+            message.chat_id,
+            message.thread_id,
+            apply_pma,
+        )
+        status = "enabled" if enabled else "disabled"
+        if enabled:
+            hint = "Use /pma off to exit. Previous repo binding saved."
+        else:
+            previous = (record and record.pma_prev_workspace_path) or None
+            if previous:
+                hint = f"Back to repo mode. Restored {previous}."
+            else:
+                hint = "Back to repo mode."
+        await self._send_message(
+            message.chat_id,
+            f"PMA mode {status}. {hint}",
+            thread_id=message.thread_id,
+            reply_to=message.message_id,
+        )
+
     async def _opencode_review_arguments(target: dict[str, Any]) -> str:
         target_type = target.get("type")
         if target_type == "uncommittedChanges":
@@ -1834,10 +1944,14 @@ class TelegramCommandHandlers(
     async def _apply_compact_summary(
         self, message: TelegramMessage, record: "TelegramTopicRecord", summary_text: str
     ) -> tuple[bool, str | None]:
-        if not record.workspace_path:
-            return (False, "Topic not bound. Use /bind <repo_id> or /bind <path>.")
+        workspace_path, error = self._resolve_workspace_path(record, allow_pma=True)
+        if not workspace_path:
+            return (
+                False,
+                error or "Topic not bound. Use /bind <repo_id> or /bind <path>.",
+            )
         try:
-            client = await self._client_for_workspace(record.workspace_path)
+            client = await self._client_for_workspace(workspace_path)
         except AppServerUnavailableError as exc:
             log_event(
                 self._logger,
@@ -1849,7 +1963,10 @@ class TelegramCommandHandlers(
             )
             return False, "App server unavailable; try again or check logs."
         if client is None:
-            return (False, "Topic not bound. Use /bind <repo_id> or /bind <path>.")
+            return (
+                False,
+                error or "Topic not bound. Use /bind <repo_id> or /bind <path>.",
+            )
         log_event(
             self._logger,
             logging.INFO,
@@ -1857,11 +1974,11 @@ class TelegramCommandHandlers(
             chat_id=message.chat_id,
             thread_id=message.thread_id,
             summary_len=len(summary_text),
-            workspace_path=record.workspace_path,
+            workspace_path=workspace_path,
         )
         try:
             agent = self._effective_agent(record)
-            thread = await client.thread_start(record.workspace_path, agent=agent)
+            thread = await client.thread_start(workspace_path, agent=agent)
         except Exception as exc:
             log_event(
                 self._logger,
@@ -1873,7 +1990,7 @@ class TelegramCommandHandlers(
             )
             return False, "Failed to start a new thread."
         if not await self._require_thread_workspace(
-            message, record.workspace_path, thread, action="thread_start"
+            message, workspace_path, thread, action="thread_start"
         ):
             return False, "Failed to start a new thread."
         new_thread_id = _extract_thread_id(thread)
@@ -1911,7 +2028,7 @@ class TelegramCommandHandlers(
     ) -> None:
         argv = self._parse_command_args(args)
         if argv and argv[0].lower() in ("soft", "summary", "summarize"):
-            record = await self._require_bound_record(message)
+            record = await self._require_bound_record(message, allow_pma=True)
             if not record:
                 return
             await self._handle_normal_message(
@@ -1919,33 +2036,51 @@ class TelegramCommandHandlers(
             )
             return
         auto_apply = bool(argv and argv[0].lower() == "apply")
-        record = await self._require_bound_record(message)
+        record = await self._require_bound_record(message, allow_pma=True)
         if not record:
             return
         key = await self._resolve_topic_key(message.chat_id, message.thread_id)
-        if not record.active_thread_id:
-            await self._send_message(
-                message.chat_id,
-                "No active thread to compact. Use /new to start one.",
-                thread_id=message.thread_id,
-                reply_to=message.message_id,
-            )
-            return
-        conflict_key = await self._find_thread_conflict(
-            record.active_thread_id, key=key
-        )
-        if conflict_key:
-            await self._router.set_active_thread(
-                message.chat_id, message.thread_id, None
-            )
-            await self._handle_thread_conflict(
-                message, record.active_thread_id, conflict_key
+        pma_enabled = bool(record.pma_enabled)
+        if pma_enabled:
+            registry = getattr(self, "_hub_thread_registry", None)
+            pma_key = self._pma_registry_key(record, message)
+            pma_thread_id = (
+                registry.get_thread_id(pma_key)
+                if registry is not None and pma_key
+                else None
+            )
+            if not pma_thread_id:
+                await self._send_message(
+                    message.chat_id,
+                    "No active PMA thread to compact. Send a message or use /new to start one.",
+                    thread_id=message.thread_id,
+                    reply_to=message.message_id,
+                )
+                return
+        else:
+            if not record.active_thread_id:
+                await self._send_message(
+                    message.chat_id,
+                    "No active thread to compact. Use /new to start one.",
+                    thread_id=message.thread_id,
+                    reply_to=message.message_id,
+                )
+                return
+            conflict_key = await self._find_thread_conflict(
+                record.active_thread_id, key=key
             )
-            return
-        verified = await self._verify_active_thread(message, record)
-        if not verified:
-            return
-        record = verified
+            if conflict_key:
+                await self._router.set_active_thread(
+                    message.chat_id, message.thread_id, None
+                )
+                await self._handle_thread_conflict(
+                    message, record.active_thread_id, conflict_key
+                )
+                return
+            verified = await self._verify_active_thread(message, record)
+            if not verified:
+                return
+            record = verified
         outcome = await self._run_turn_and_collect_result(
             message,
             runtime,
@@ -2067,9 +2202,13 @@ Compact canceled.""",
         )
         self._compact_pending.pop(key, None)
         record = await self._router.get_topic(key)
-        if record is None or not record.workspace_path:
+        if record is None:
             await self._answer_callback(callback, "Selection expired")
             return
+        workspace_path, error = self._resolve_workspace_path(record, allow_pma=True)
+        if workspace_path is None:
+            await self._answer_callback(callback, error or "Selection expired")
+            return
         if callback.chat_id is None:
             return
         await self._answer_callback(callback, "Applying summary...")
@@ -2634,14 +2773,23 @@ Summary applied.""",
     async def _handle_logout(
         self, message: TelegramMessage, _args: str, _runtime: Any
     ) -> None:
-        record = await self._require_bound_record(message)
+        record = await self._require_bound_record(message, allow_pma=True)
         if not record:
             return
-        client = await self._client_for_workspace(record.workspace_path)
+        workspace_path, error = self._resolve_workspace_path(record, allow_pma=True)
+        if workspace_path is None:
+            await self._send_message(
+                message.chat_id,
+                error or "Topic not bound. Use /bind <repo_id> or /bind <path>.",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return
+        client = await self._client_for_workspace(workspace_path)
         if client is None:
             await self._send_message(
                 message.chat_id,
-                "Topic not bound. Use /bind <repo_id> or /bind <path>.",
+                error or "Topic not bound. Use /bind <repo_id> or /bind <path>.",
                 thread_id=message.thread_id,
                 reply_to=message.message_id,
             )
@@ -2687,14 +2835,23 @@ Summary applied.""",
                 reply_to=message.message_id,
             )
             return
-        record = await self._require_bound_record(message)
+        record = await self._require_bound_record(message, allow_pma=True)
         if not record:
             return
-        client = await self._client_for_workspace(record.workspace_path)
+        workspace_path, error = self._resolve_workspace_path(record, allow_pma=True)
+        if workspace_path is None:
+            await self._send_message(
+                message.chat_id,
+                error or "Topic not bound. Use /bind <repo_id> or /bind <path>.",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return
+        client = await self._client_for_workspace(workspace_path)
         if client is None:
             await self._send_message(
                 message.chat_id,
-                "Topic not bound. Use /bind <repo_id> or /bind <path>.",
+                error or "Topic not bound. Use /bind <repo_id> or /bind <path>.",
                 thread_id=message.thread_id,
                 reply_to=message.message_id,
             )

codex_autorunner/integrations/telegram/handlers/commands_spec.py

@@ -16,6 +16,12 @@ class CommandSpec:
 
 def build_command_specs(handlers: Any) -> dict[str, CommandSpec]:
     return {
+        "repos": CommandSpec(
+            "repos",
+            "list available repositories in the hub",
+            handlers._handle_repos,
+            allow_during_turn=True,
+        ),
         "bind": CommandSpec(
             "bind",
             "bind this topic to a workspace",
@@ -23,9 +29,14 @@ def build_command_specs(handlers: Any) -> dict[str, CommandSpec]:
         ),
         "new": CommandSpec(
             "new",
-            "start a new session",
+            "start a new PMA session",
             lambda message, _args, _runtime: handlers._handle_new(message),
         ),
+        "reset": CommandSpec(
+            "reset",
+            "reset PMA thread state (clear volatile state)",
+            lambda message, _args, _runtime: handlers._handle_reset(message),
+        ),
         "resume": CommandSpec(
             "resume",
             "list or resume a previous session",
@@ -42,12 +53,6 @@ def build_command_specs(handlers: Any) -> dict[str, CommandSpec]:
             lambda message, args, _runtime: handlers._handle_flow(message, args),
             allow_during_turn=True,
         ),
-        "flow_status": CommandSpec(
-            "flow_status",
-            "show ticket flow status (alias for /flow status)",
-            lambda message, args, _runtime: handlers._handle_flow_status(message, args),
-            allow_during_turn=True,
-        ),
         "reply": CommandSpec(
             "reply",
             "reply to a paused ticket flow dispatch (prefer /flow reply)",
@@ -69,6 +74,12 @@ def build_command_specs(handlers: Any) -> dict[str, CommandSpec]:
             "set approval and sandbox policy",
             handlers._handle_approvals,
         ),
+        "pma": CommandSpec(
+            "pma",
+            "toggle PMA mode for this topic",
+            handlers._handle_pma,
+            allow_during_turn=True,
+        ),
         "status": CommandSpec(
             "status",
             "show current binding and thread status",

codex_autorunner/integrations/telegram/handlers/messages.py

@@ -75,6 +75,21 @@ def _message_text_candidate(message: TelegramMessage) -> tuple[str, str, Any]:
     return raw_text, text_candidate, entities
 
 
+def _record_with_media_workspace(
+    handlers: Any, record: Any
+) -> tuple[Any, Optional[str]]:
+    """Ensure media handlers have a workspace path, including PMA topics."""
+    if record is None:
+        return None, None
+    pma_enabled = bool(getattr(record, "pma_enabled", False))
+    if not pma_enabled:
+        return record, None
+    hub_root = getattr(handlers, "_hub_root", None)
+    if hub_root is None:
+        return None, "PMA unavailable; hub root not configured."
+    return dataclasses.replace(record, workspace_path=str(hub_root)), None
+
+
 async def _clear_pending_options(
     handlers: Any, key: str, message: TelegramMessage
 ) -> None:
@@ -352,7 +367,8 @@ async def handle_message_inner(
     record = await handlers._router.get_topic(key)
     paused = None
     workspace_root: Optional[Path] = None
-    if record and record.workspace_path:
+    pma_enabled = bool(record and getattr(record, "pma_enabled", False))
+    if not pma_enabled and record and record.workspace_path:
         workspace_root = canonicalize_path(Path(record.workspace_path))
         preferred_run_id = handlers._ticket_flow_pause_targets.get(
             str(workspace_root), None
@@ -801,6 +817,15 @@ async def handle_media_message(
         return
     key = await handlers._resolve_topic_key(message.chat_id, message.thread_id)
     record = await handlers._router.get_topic(key)
+    record, pma_error = _record_with_media_workspace(handlers, record)
+    if pma_error:
+        await handlers._send_message(
+            message.chat_id,
+            pma_error,
+            thread_id=message.thread_id,
+            reply_to=message.message_id,
+        )
+        return
     if record is None or not record.workspace_path:
         await handlers._send_message(
             message.chat_id,
@@ -834,7 +859,10 @@ async def handle_media_message(
                 best = photos[0]
                 try:
                     file_info = await handlers._bot.get_file(best.file_id)
-                    data = await handlers._bot.download_file(file_info.file_path)
+                    data = await handlers._bot.download_file(
+                        file_info.file_path,
+                        max_size_bytes=handlers._config.media.max_image_bytes,
+                    )
                     filename = f"photo_{best.file_id}.jpg"
                     files.append((filename, data))
                 except Exception as exc:
@@ -843,7 +871,10 @@ async def handle_media_message(
         elif message.document:
             try:
                 file_info = await handlers._bot.get_file(message.document.file_id)
-                data = await handlers._bot.download_file(file_info.file_path)
+                data = await handlers._bot.download_file(
+                    file_info.file_path,
+                    max_size_bytes=handlers._config.media.max_file_bytes,
+                )
                 filename = (
                     message.document.file_name or f"document_{message.document.file_id}"
                 )

codex_autorunner/integrations/telegram/helpers.py

@@ -887,12 +887,12 @@ def _format_help_text(command_specs: dict[str, CommandSpec]) -> str:
         "resume",
         "review",
         "flow",
-        "flow_status",
         "reply",
         "pr",
         "agent",
         "model",
         "approvals",
+        "pma",
         "status",
         "diff",
         "mention",
@@ -935,8 +935,6 @@ def _format_help_text(command_specs: dict[str, CommandSpec]) -> str:
         lines.append("/flow restart")
         lines.append("/flow archive [run_id] [--force]")
         lines.append("/flow reply <message>")
-        if "flow_status" in command_specs:
-            lines.append("/flow_status [run_id]")
         if "reply" in command_specs:
             lines.append("/reply <message> (legacy)")
 

codex_autorunner/integrations/telegram/runtime.py

@@ -265,8 +265,11 @@ class TelegramRuntimeHelpers:
             text = f"{prefix}{text}"
         return self._prepare_message(text)
 
-    def _render_message(self, text: str) -> tuple[str, Optional[str]]:
-        parse_mode = self._config.parse_mode
+    def _render_message(
+        self, text: str, *, parse_mode: Optional[str] = None
+    ) -> tuple[str, Optional[str]]:
+        # Allow callers to override parse_mode (needed for ad-hoc Markdown/HTML sends)
+        parse_mode = self._config.parse_mode if parse_mode is None else parse_mode
         if not parse_mode:
             return text, None
         if parse_mode == "HTML":
@@ -275,8 +278,10 @@ class TelegramRuntimeHelpers:
             return _format_telegram_markdown(text, parse_mode), parse_mode
         return text, parse_mode
 
-    def _prepare_message(self, text: str) -> tuple[str, Optional[str]]:
-        rendered, parse_mode = self._render_message(text)
+    def _prepare_message(
+        self, text: str, *, parse_mode: Optional[str] = None
+    ) -> tuple[str, Optional[str]]:
+        rendered, parse_mode = self._render_message(text, parse_mode=parse_mode)
         # Avoid parse_mode when chunking to keep markup intact.
         if parse_mode and len(rendered) <= TELEGRAM_MAX_MESSAGE_LENGTH:
             return rendered, parse_mode

codex_autorunner/integrations/telegram/service.py

@@ -16,7 +16,12 @@ if TYPE_CHECKING:
     from .state import TelegramTopicRecord
 
 from ...agents.opencode.supervisor import OpenCodeSupervisor
+from ...core.app_server_threads import (
+    AppServerThreadRegistry,
+    default_app_server_threads_path,
+)
 from ...core.flows.models import FlowRunRecord
+from ...core.hub import HubSupervisor
 from ...core.locks import process_alive
 from ...core.logging_utils import log_event
 from ...core.request_context import reset_conversation_id, set_conversation_id
@@ -173,6 +178,31 @@ class TelegramBotService(
         self._logger = logger or logging.getLogger(__name__)
         self._hub_root = hub_root
         self._manifest_path = manifest_path
+        self._hub_supervisor = None
+        self._hub_thread_registry = None
+        if self._hub_root:
+            try:
+                self._hub_supervisor = HubSupervisor.from_path(self._hub_root)
+            except Exception as exc:
+                log_event(
+                    self._logger,
+                    logging.WARNING,
+                    "telegram.pma.hub_supervisor.unavailable",
+                    hub_root=str(self._hub_root),
+                    exc=exc,
+                )
+            try:
+                self._hub_thread_registry = AppServerThreadRegistry(
+                    default_app_server_threads_path(self._hub_root)
+                )
+            except Exception as exc:
+                log_event(
+                    self._logger,
+                    logging.WARNING,
+                    "telegram.pma.thread_registry.unavailable",
+                    hub_root=str(self._hub_root),
+                    exc=exc,
+                )
         self._update_repo_url = update_repo_url
         self._update_repo_ref = update_repo_ref
         self._update_skip_checks = update_skip_checks

codex_autorunner/integrations/telegram/state.py

@@ -190,6 +190,11 @@ class TelegramTopicRecord:
     repo_id: Optional[str] = None
     workspace_path: Optional[str] = None
     workspace_id: Optional[str] = None
+    pma_enabled: bool = False
+    pma_prev_repo_id: Optional[str] = None
+    pma_prev_workspace_path: Optional[str] = None
+    pma_prev_workspace_id: Optional[str] = None
+    pma_prev_active_thread_id: Optional[str] = None
     active_thread_id: Optional[str] = None
     thread_ids: list[str] = dataclasses.field(default_factory=list)
     thread_summaries: dict[str, ThreadSummary] = dataclasses.field(default_factory=dict)
@@ -220,6 +225,29 @@ class TelegramTopicRecord:
         workspace_id = payload.get("workspace_id") or payload.get("workspaceId")
         if not isinstance(workspace_id, str):
             workspace_id = None
+        pma_enabled = payload.get("pma_enabled") or payload.get("pmaEnabled")
+        if not isinstance(pma_enabled, bool):
+            pma_enabled = False
+        pma_prev_repo_id = payload.get("pma_prev_repo_id") or payload.get(
+            "pmaPrevRepoId"
+        )
+        if not isinstance(pma_prev_repo_id, str):
+            pma_prev_repo_id = None
+        pma_prev_workspace_path = payload.get("pma_prev_workspace_path") or payload.get(
+            "pmaPrevWorkspacePath"
+        )
+        if not isinstance(pma_prev_workspace_path, str):
+            pma_prev_workspace_path = None
+        pma_prev_workspace_id = payload.get("pma_prev_workspace_id") or payload.get(
+            "pmaPrevWorkspaceId"
+        )
+        if not isinstance(pma_prev_workspace_id, str):
+            pma_prev_workspace_id = None
+        pma_prev_active_thread_id = payload.get(
+            "pma_prev_active_thread_id"
+        ) or payload.get("pmaPrevActiveThreadId")
+        if not isinstance(pma_prev_active_thread_id, str):
+            pma_prev_active_thread_id = None
         active_thread_id = payload.get("active_thread_id") or payload.get(
             "activeThreadId"
         )
@@ -301,6 +329,11 @@ class TelegramTopicRecord:
             repo_id=repo_id,
             workspace_path=workspace_path,
             workspace_id=workspace_id,
+            pma_enabled=pma_enabled,
+            pma_prev_repo_id=pma_prev_repo_id,
+            pma_prev_workspace_path=pma_prev_workspace_path,
+            pma_prev_workspace_id=pma_prev_workspace_id,
+            pma_prev_active_thread_id=pma_prev_active_thread_id,
             active_thread_id=active_thread_id,
             thread_ids=thread_ids,
             thread_summaries=thread_summaries,
@@ -324,6 +357,11 @@ class TelegramTopicRecord:
             "repo_id": self.repo_id,
             "workspace_path": self.workspace_path,
             "workspace_id": self.workspace_id,
+            "pma_enabled": self.pma_enabled,
+            "pma_prev_repo_id": self.pma_prev_repo_id,
+            "pma_prev_workspace_path": self.pma_prev_workspace_path,
+            "pma_prev_workspace_id": self.pma_prev_workspace_id,
+            "pma_prev_active_thread_id": self.pma_prev_active_thread_id,
             "active_thread_id": self.active_thread_id,
             "thread_ids": list(self.thread_ids),
             "thread_summaries": {