codex-autorunner 0.1.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

codex_autorunner/integrations/telegram/service.py

@@ -5,24 +5,27 @@ import collections
 import json
 import logging
 import os
-import shlex
 import socket
 import time
+from datetime import datetime
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Coroutine, Optional, Sequence
+from typing import TYPE_CHECKING, Any, Callable, Coroutine, Optional, Sequence
 
 if TYPE_CHECKING:
     from .progress_stream import TurnProgressTracker
     from .state import TelegramTopicRecord
 
 from ...agents.opencode.supervisor import OpenCodeSupervisor
+from ...core.flows.models import FlowRunRecord
 from ...core.locks import process_alive
 from ...core.logging_utils import log_event
 from ...core.request_context import reset_conversation_id, set_conversation_id
 from ...core.state import now_iso
-from ...core.utils import resolve_executable, resolve_opencode_binary
+from ...core.text_delta_coalescer import TextDeltaCoalescer
+from ...core.utils import build_opencode_supervisor
 from ...housekeeping import HousekeepingConfig, run_housekeeping_for_roots
 from ...manifest import load_manifest
+from ...tickets.replies import dispatch_reply, ensure_reply_dirs, resolve_reply_paths
 from ...voice import VoiceConfig, VoiceService
 from ..app_server.supervisor import WorkspaceAppServerSupervisor
 from .adapter import (
@@ -36,25 +39,16 @@ from .adapter import (
 )
 from .commands_registry import build_command_payloads, diff_command_lists
 from .config import (
+    AppServerUnavailableError,
     TelegramBotConfig,
     TelegramBotConfigError,
     TelegramBotLockError,
     TelegramMediaCandidate,
 )
 from .constants import (
-    CACHE_CLEANUP_INTERVAL_SECONDS,
-    COALESCE_BUFFER_TTL_SECONDS,
     DEFAULT_INTERRUPT_TIMEOUT_SECONDS,
     DEFAULT_WORKSPACE_STATE_ROOT,
-    MEDIA_BATCH_BUFFER_TTL_SECONDS,
-    MODEL_PENDING_TTL_SECONDS,
-    OVERSIZE_WARNING_TTL_SECONDS,
-    PENDING_APPROVAL_TTL_SECONDS,
-    PROGRESS_STREAM_TTL_SECONDS,
-    REASONING_BUFFER_TTL_SECONDS,
-    SELECTION_STATE_TTL_SECONDS,
-    TURN_PREVIEW_TTL_SECONDS,
-    UPDATE_ID_PERSIST_INTERVAL_SECONDS,
+    QUEUED_PLACEHOLDER_TEXT,
     TurnKey,
 )
 from .dispatch import dispatch_update
@@ -64,6 +58,7 @@ from .handlers.approvals import TelegramApprovalHandlers
 from .handlers.commands import build_command_specs
 from .handlers.commands_runtime import TelegramCommandHandlers
 from .handlers.messages import _CoalescedBuffer
+from .handlers.questions import TelegramQuestionHandlers
 from .handlers.selections import TelegramSelectionHandlers
 from .helpers import (
     ModelOption,
@@ -82,39 +77,20 @@ from .state import (
     parse_topic_key,
     topic_key,
 )
+from .ticket_flow_bridge import TelegramTicketFlowBridge
 from .transport import TelegramMessageTransport
 from .types import (
     CompactState,
     ModelPickerState,
     PendingApproval,
+    PendingQuestion,
     ReviewCommitSelectionState,
     SelectionState,
     TurnContext,
 )
 from .voice import TelegramVoiceManager
 
-
-def _parse_command(raw: Optional[str]) -> list[str]:
-    if not raw:
-        return []
-    try:
-        return [part for part in shlex.split(raw) if part]
-    except ValueError:
-        return []
-
-
-def _command_available(command: list[str], *, workspace_root: Path) -> bool:
-    if not command:
-        return False
-    entry = str(command[0]).strip()
-    if not entry:
-        return False
-    if os.path.sep in entry or (os.path.altsep and os.path.altsep in entry):
-        path = Path(entry)
-        if not path.is_absolute():
-            path = workspace_root / path
-        return path.is_file() and os.access(path, os.X_OK)
-    return resolve_executable(entry) is not None
+TICKET_FLOW_WATCH_INTERVAL_SECONDS = 20
 
 
 def _build_opencode_supervisor(
@@ -122,38 +98,22 @@ def _build_opencode_supervisor(
     *,
     logger: logging.Logger,
 ) -> Optional[OpenCodeSupervisor]:
-    raw_command = os.environ.get("CAR_OPENCODE_COMMAND")
-    command = _parse_command(raw_command)
+    opencode_command = config.opencode_command or None
     opencode_binary = config.agent_binaries.get("opencode")
-    if not command and opencode_binary:
-        command = [
-            opencode_binary,
-            "serve",
-            "--hostname",
-            "127.0.0.1",
-            "--port",
-            "0",
-        ]
-    resolved_source = None
-    if command:
-        resolved_source = command[0]
-    elif opencode_binary:
-        resolved_source = opencode_binary
-    resolved_binary = resolve_opencode_binary(resolved_source)
-    if command:
-        if resolved_binary:
-            command[0] = resolved_binary
-    else:
-        if resolved_binary:
-            command = [
-                resolved_binary,
-                "serve",
-                "--hostname",
-                "127.0.0.1",
-                "--port",
-                "0",
-            ]
-    if not command or not _command_available(command, workspace_root=config.root):
+
+    supervisor = build_opencode_supervisor(
+        opencode_command=opencode_command,
+        opencode_binary=opencode_binary,
+        workspace_root=config.root,
+        logger=logger,
+        request_timeout=None,
+        max_handles=config.app_server_max_handles,
+        idle_ttl_seconds=config.app_server_idle_ttl_seconds,
+        base_env=None,
+        subagent_models=None,
+    )
+
+    if supervisor is None:
         log_event(
             logger,
             logging.INFO,
@@ -161,16 +121,28 @@ def _build_opencode_supervisor(
             reason="command_missing",
         )
         return None
-    username = os.environ.get("OPENCODE_SERVER_USERNAME")
-    password = os.environ.get("OPENCODE_SERVER_PASSWORD")
-    return OpenCodeSupervisor(
-        command,
-        logger=logger,
-        max_handles=config.app_server_max_handles,
-        idle_ttl_seconds=config.app_server_idle_ttl_seconds,
-        username=username if username and password else None,
-        password=password if username and password else None,
-    )
+
+    return supervisor
+
+
+def _next_reply_seq_sync(reply_history_dir: Any) -> int:
+    from pathlib import Path
+
+    path = Path(reply_history_dir)
+    if not path.exists() or not path.is_dir():
+        return 1
+    existing: list[int] = []
+    _SEQ_RE = __import__("re").compile(r"^[0-9]{4}$")
+    for child in path.iterdir():
+        try:
+            if not child.is_dir():
+                continue
+            if not _SEQ_RE.fullmatch(child.name):
+                continue
+            existing.append(int(child.name))
+        except OSError:
+            continue
+    return (max(existing) + 1) if existing else 1
 
 
 class TelegramBotService(
@@ -178,6 +150,7 @@ class TelegramBotService(
     TelegramMessageTransport,
     TelegramNotificationHandlers,
     TelegramApprovalHandlers,
+    TelegramQuestionHandlers,
     TelegramSelectionHandlers,
     TelegramCommandHandlers,
 ):
@@ -193,6 +166,8 @@ class TelegramBotService(
         housekeeping_config: Optional[HousekeepingConfig] = None,
         update_repo_url: Optional[str] = None,
         update_repo_ref: Optional[str] = None,
+        update_skip_checks: bool = False,
+        app_server_auto_restart: Optional[bool] = None,
     ) -> None:
         self._config = config
         self._logger = logger or logging.getLogger(__name__)
@@ -200,6 +175,8 @@ class TelegramBotService(
         self._manifest_path = manifest_path
         self._update_repo_url = update_repo_url
         self._update_repo_ref = update_repo_ref
+        self._update_skip_checks = update_skip_checks
+        self._app_server_auto_restart = app_server_auto_restart
         self._allowlist = config.allowlist()
         self._store = TelegramStateStore(
             config.state_file, default_approval_mode=config.defaults.approval_mode
@@ -213,6 +190,7 @@ class TelegramBotService(
             approval_handler=self._handle_approval_request,
             notification_handler=self._handle_app_server_notification,
             logger=self._logger,
+            auto_restart=self._app_server_auto_restart,
             max_handles=config.app_server_max_handles,
             idle_ttl_seconds=config.app_server_idle_ttl_seconds,
         )
@@ -220,7 +198,16 @@ class TelegramBotService(
             config,
             logger=self._logger,
         )
-        self._bot = TelegramBotClient(config.bot_token or "", logger=self._logger)
+        poll_timeout = float(config.poll_timeout_seconds)
+        request_timeout = config.poll_request_timeout_seconds
+        if request_timeout is None:
+            # Keep HTTP timeout above long-poll timeout to avoid ReadTimeout churn.
+            request_timeout = max(poll_timeout + 5.0, 10.0)
+        self._bot = TelegramBotClient(
+            config.bot_token or "",
+            logger=self._logger,
+            timeout_seconds=float(request_timeout),
+        )
         self._poller = TelegramUpdatePoller(
             self._bot, allowed_updates=config.poll_allowed_updates
         )
@@ -242,15 +229,25 @@ class TelegramBotService(
                 )
         self._turn_semaphore: Optional[asyncio.Semaphore] = None
         self._turn_contexts: dict[TurnKey, TurnContext] = {}
-        self._reasoning_buffers: dict[str, str] = {}
+        self._reasoning_buffers: dict[str, TextDeltaCoalescer] = {}
         self._turn_preview_text: dict[TurnKey, str] = {}
         self._turn_preview_updated_at: dict[TurnKey, float] = {}
         self._turn_progress_trackers: dict[TurnKey, "TurnProgressTracker"] = {}
         self._turn_progress_rendered: dict[TurnKey, str] = {}
         self._turn_progress_updated_at: dict[TurnKey, float] = {}
         self._turn_progress_tasks: dict[TurnKey, asyncio.Task[None]] = {}
+        self._turn_progress_heartbeat_tasks: dict[TurnKey, asyncio.Task[None]] = {}
+        self._turn_progress_locks: dict[TurnKey, asyncio.Lock] = {}
         self._oversize_warnings: set[TurnKey] = set()
         self._pending_approvals: dict[str, PendingApproval] = {}
+        self._pending_questions: dict[str, PendingQuestion] = {}
+        self._ticket_flow_pause_targets: dict[str, str] = {}
+        self._ticket_flow_bridge = TelegramTicketFlowBridge(
+            logger=self._logger,
+            store=self._store,
+            pause_targets=self._ticket_flow_pause_targets,
+            send_message_with_outbox=self._send_message_with_outbox,
+        )
         self._resume_options: dict[str, SelectionState] = {}
         self._bind_options: dict[str, SelectionState] = {}
         self._update_options: dict[str, SelectionState] = {}
@@ -265,6 +262,8 @@ class TelegramBotService(
         self._media_batch_locks: dict[str, asyncio.Lock] = {}
         self._outbox_inflight: set[str] = set()
         self._outbox_lock: Optional[asyncio.Lock] = None
+        self._queued_placeholder_map: dict[tuple[int, int], int] = {}
+        self._queued_placeholder_timestamps: dict[tuple[int, int], float] = {}
         self._bot_username: Optional[str] = None
         self._token_usage_by_thread: "collections.OrderedDict[str, dict[str, Any]]" = (
             collections.OrderedDict()
@@ -274,6 +273,7 @@ class TelegramBotService(
         )
         self._outbox_task: Optional[asyncio.Task[None]] = None
         self._cache_cleanup_task: Optional[asyncio.Task[None]] = None
+        self._ticket_flow_watch_task: Optional[asyncio.Task[None]] = None
         self._cache_timestamps: dict[str, dict[object, float]] = {}
         self._last_update_ids: dict[str, int] = {}
         self._last_update_persisted_at: dict[str, float] = {}
@@ -302,10 +302,10 @@ class TelegramBotService(
         self._command_specs = build_command_specs(self)
         self._instance_lock_path: Optional[Path] = None
 
-    def _housekeeping_roots(self) -> list[Path]:
+    async def _housekeeping_roots(self) -> list[Path]:
         roots: set[Path] = set()
         try:
-            state = self._store.load()
+            state = await self._store.load()
             for record in state.topics.values():
                 if isinstance(record.workspace_path, str) and record.workspace_path:
                     roots.add(Path(record.workspace_path).expanduser().resolve())
@@ -332,6 +332,81 @@ class TelegramBotService(
             roots.add(self._config.root.resolve())
         return sorted(roots)
 
+    async def _gather_workspace_roots(self) -> list[Path]:
+        roots: set[Path] = set()
+        try:
+            state = await self._store.load()
+            for record in state.topics.values():
+                if isinstance(record.workspace_path, str) and record.workspace_path:
+                    roots.add(Path(record.workspace_path).expanduser().resolve())
+        except Exception as exc:
+            log_event(
+                self._logger,
+                logging.WARNING,
+                "telegram.prewarm.state_failed",
+                exc=exc,
+            )
+        return sorted(roots)
+
+    async def _prewarm_workspace_clients(self) -> None:
+        workspace_roots = await self._gather_workspace_roots()
+        if not workspace_roots:
+            log_event(
+                self._logger,
+                logging.INFO,
+                "telegram.prewarm.skipped",
+                reason="no_workspaces",
+            )
+            return
+
+        log_event(
+            self._logger,
+            logging.INFO,
+            "telegram.prewarm.started",
+            workspace_count=len(workspace_roots),
+            workspaces=[str(p) for p in workspace_roots],
+        )
+
+        sem = asyncio.Semaphore(3)
+        prewarmed_count = 0
+        failed_count = 0
+
+        async def prewarm_one(workspace_root: Path) -> None:
+            nonlocal prewarmed_count, failed_count
+            async with sem:
+                try:
+                    await self._app_server_supervisor.get_client(workspace_root)
+                    prewarmed_count += 1
+                    log_event(
+                        self._logger,
+                        logging.INFO,
+                        "telegram.prewarm.client_ready",
+                        workspace_root=str(workspace_root),
+                    )
+                except Exception as exc:
+                    failed_count += 1
+                    log_event(
+                        self._logger,
+                        logging.WARNING,
+                        "telegram.prewarm.client_failed",
+                        workspace_root=str(workspace_root),
+                        exc=exc,
+                    )
+
+        await asyncio.gather(
+            *[prewarm_one(root) for root in workspace_roots],
+            return_exceptions=True,
+        )
+
+        log_event(
+            self._logger,
+            logging.INFO,
+            "telegram.prewarm.completed",
+            workspace_count=len(workspace_roots),
+            prewarmed_count=prewarmed_count,
+            failed_count=failed_count,
+        )
+
     async def _housekeeping_loop(self) -> None:
         config = self._housekeeping_config
         if config is None or not config.enabled:
@@ -339,7 +414,7 @@ class TelegramBotService(
         interval = max(config.interval_seconds, 1)
         while True:
             try:
-                roots = self._housekeeping_roots()
+                roots = await self._housekeeping_roots()
                 if roots:
                     await asyncio.to_thread(
                         run_housekeeping_for_roots,
@@ -485,11 +560,17 @@ class TelegramBotService(
             await self._restore_pending_approvals()
             await self._outbox_manager.restore()
             await self._voice_manager.restore()
-            self._prime_poller_offset()
+            await self._prime_poller_offset()
             self._outbox_task = asyncio.create_task(self._outbox_manager.run_loop())
             self._voice_task = asyncio.create_task(self._voice_manager.run_loop())
             self._housekeeping_task = asyncio.create_task(self._housekeeping_loop())
             self._cache_cleanup_task = asyncio.create_task(self._cache_cleanup_loop())
+            self._ticket_flow_watch_task = asyncio.create_task(
+                self._ticket_flow_bridge.watch_ticket_flow_pauses(
+                    TICKET_FLOW_WATCH_INTERVAL_SECONDS
+                )
+            )
+            self._spawn_task(self._prewarm_workspace_clients())
             log_event(
                 self._logger,
                 logging.INFO,
@@ -505,6 +586,10 @@ class TelegramBotService(
                 media_enabled=self._config.media.enabled,
                 media_images=self._config.media.images,
                 media_voice=self._config.media.voice,
+                app_server_turn_timeout_seconds=self._config.app_server_turn_timeout_seconds,
+                agent_turn_timeout_seconds=dict(
+                    self._config.agent_turn_timeout_seconds
+                ),
                 poller_offset=self._poller.offset,
             )
             try:
@@ -532,7 +617,7 @@ class TelegramBotService(
                         timeout=self._config.poll_timeout_seconds
                     )
                     if self._poller.offset is not None:
-                        self._record_poll_offset(updates)
+                        await self._record_poll_offset(updates)
                 except Exception as exc:
                     log_event(
                         self._logger,
@@ -570,6 +655,12 @@ class TelegramBotService(
                         await self._cache_cleanup_task
                     except asyncio.CancelledError:
                         pass
+                if self._ticket_flow_watch_task is not None:
+                    self._ticket_flow_watch_task.cancel()
+                    try:
+                        await self._ticket_flow_watch_task
+                    except asyncio.CancelledError:
+                        pass
                 if self._spawned_tasks:
                     for task in list(self._spawned_tasks):
                         task.cancel()
@@ -593,6 +684,15 @@ class TelegramBotService(
                         "telegram.app_server.close_failed",
                         exc=exc,
                     )
+                try:
+                    await self._store.close()
+                except Exception as exc:
+                    log_event(
+                        self._logger,
+                        logging.WARNING,
+                        "telegram.state.close_failed",
+                        exc=exc,
+                    )
                 self._release_instance_lock()
 
     async def _prime_bot_identity(self) -> None:
@@ -694,8 +794,8 @@ class TelegramBotService(
                 order_changed=diff.order_changed,
             )
 
-    def _prime_poller_offset(self) -> None:
-        last_update_id = self._store.get_last_update_id_global()
+    async def _prime_poller_offset(self) -> None:
+        last_update_id = await self._store.get_last_update_id_global()
         if not isinstance(last_update_id, int) or isinstance(last_update_id, bool):
             return
         offset = last_update_id + 1
@@ -708,16 +808,15 @@ class TelegramBotService(
             poller_offset=offset,
         )
 
-    def _record_poll_offset(self, updates: Sequence[TelegramUpdate]) -> None:
+    async def _record_poll_offset(self, updates: Sequence[TelegramUpdate]) -> None:
         offset = self._poller.offset
         if offset is None:
             return
         last_update_id = offset - 1
         if last_update_id < 0:
             return
-        stored = self._store.update_last_update_id_global(last_update_id)
-        if updates:
-            max_update_id = max(update.update_id for update in updates)
+        stored = await self._store.update_last_update_id_global(last_update_id)
+        max_update_id = max((update.update_id for update in updates), default=None)
         log_event(
             self._logger,
             logging.INFO,
@@ -772,6 +871,9 @@ class TelegramBotService(
                 task = self._turn_progress_tasks.pop(key, None)
                 if task and not task.done():
                     task.cancel()
+                heartbeat_task = self._turn_progress_heartbeat_tasks.pop(key, None)
+                if heartbeat_task and not heartbeat_task.done():
+                    heartbeat_task.cancel()
             elif cache_name == "oversize_warnings":
                 self._oversize_warnings.discard(key)
             elif cache_name == "coalesced_buffers":
@@ -804,63 +906,209 @@ class TelegramBotService(
                 self._model_pending.pop(key, None)
             elif cache_name == "pending_approvals":
                 self._pending_approvals.pop(key, None)
+            elif cache_name == "pending_questions":
+                self._pending_questions.pop(key, None)
 
     async def _cache_cleanup_loop(self) -> None:
-        interval = max(CACHE_CLEANUP_INTERVAL_SECONDS, 1.0)
+        interval = max(self._config.cache.cleanup_interval_seconds, 1.0)
         while True:
             await asyncio.sleep(interval)
             self._evict_expired_cache_entries(
-                "reasoning_buffers", REASONING_BUFFER_TTL_SECONDS
+                "reasoning_buffers", self._config.cache.reasoning_buffer_ttl_seconds
+            )
+            self._evict_expired_cache_entries(
+                "turn_preview", self._config.cache.turn_preview_ttl_seconds
             )
-            self._evict_expired_cache_entries("turn_preview", TURN_PREVIEW_TTL_SECONDS)
             self._evict_expired_cache_entries(
-                "progress_trackers", PROGRESS_STREAM_TTL_SECONDS
+                "progress_trackers", self._config.cache.progress_stream_ttl_seconds
             )
             self._evict_expired_cache_entries(
-                "oversize_warnings", OVERSIZE_WARNING_TTL_SECONDS
+                "oversize_warnings", self._config.cache.oversize_warning_ttl_seconds
             )
             self._evict_expired_cache_entries(
-                "coalesced_buffers", COALESCE_BUFFER_TTL_SECONDS
+                "coalesced_buffers", self._config.cache.coalesce_buffer_ttl_seconds
             )
             self._evict_expired_cache_entries(
-                "media_batch_buffers", MEDIA_BATCH_BUFFER_TTL_SECONDS
+                "media_batch_buffers",
+                self._config.cache.media_batch_buffer_ttl_seconds,
             )
             self._evict_expired_cache_entries(
-                "resume_options", SELECTION_STATE_TTL_SECONDS
+                "resume_options", self._config.cache.selection_state_ttl_seconds
             )
             self._evict_expired_cache_entries(
-                "bind_options", SELECTION_STATE_TTL_SECONDS
+                "bind_options", self._config.cache.selection_state_ttl_seconds
             )
             self._evict_expired_cache_entries(
-                "agent_options", SELECTION_STATE_TTL_SECONDS
+                "agent_options", self._config.cache.selection_state_ttl_seconds
             )
             self._evict_expired_cache_entries(
-                "update_options", SELECTION_STATE_TTL_SECONDS
+                "update_options", self._config.cache.selection_state_ttl_seconds
             )
             self._evict_expired_cache_entries(
-                "update_confirm_options", SELECTION_STATE_TTL_SECONDS
+                "update_confirm_options",
+                self._config.cache.selection_state_ttl_seconds,
             )
             self._evict_expired_cache_entries(
-                "review_commit_options", SELECTION_STATE_TTL_SECONDS
+                "review_commit_options",
+                self._config.cache.selection_state_ttl_seconds,
             )
             self._evict_expired_cache_entries(
-                "review_commit_subjects", SELECTION_STATE_TTL_SECONDS
+                "review_commit_subjects",
+                self._config.cache.selection_state_ttl_seconds,
             )
             self._evict_expired_cache_entries(
-                "pending_review_custom", SELECTION_STATE_TTL_SECONDS
+                "pending_review_custom",
+                self._config.cache.selection_state_ttl_seconds,
             )
             self._evict_expired_cache_entries(
-                "compact_pending", SELECTION_STATE_TTL_SECONDS
+                "compact_pending", self._config.cache.selection_state_ttl_seconds
             )
             self._evict_expired_cache_entries(
-                "model_options", SELECTION_STATE_TTL_SECONDS
+                "model_options", self._config.cache.selection_state_ttl_seconds
             )
             self._evict_expired_cache_entries(
-                "model_pending", MODEL_PENDING_TTL_SECONDS
+                "model_pending", self._config.cache.model_pending_ttl_seconds
             )
             self._evict_expired_cache_entries(
-                "pending_approvals", PENDING_APPROVAL_TTL_SECONDS
+                "pending_approvals", self._config.cache.pending_approval_ttl_seconds
+            )
+            self._evict_expired_cache_entries(
+                "pending_questions", self._config.cache.pending_question_ttl_seconds
+            )
+            now = time.monotonic()
+            expired_placeholders = []
+            for key, timestamp in self._queued_placeholder_timestamps.items():
+                if (now - timestamp) > self._config.cache.pending_approval_ttl_seconds:
+                    expired_placeholders.append(key)
+            for key in expired_placeholders:
+                self._queued_placeholder_map.pop(key, None)
+                self._queued_placeholder_timestamps.pop(key, None)
+
+    @staticmethod
+    def _parse_last_active(record: "TelegramTopicRecord") -> float:
+        raw = getattr(record, "last_active_at", None)
+        if isinstance(raw, str):
+            try:
+                return datetime.strptime(raw, "%Y-%m-%dT%H:%M:%SZ").timestamp()
+            except ValueError:
+                return float("-inf")
+        return float("-inf")
+
+    def _select_ticket_flow_topic(
+        self, entries: list[tuple[str, "TelegramTopicRecord"]]
+    ) -> Optional[tuple[str, "TelegramTopicRecord"]]:
+        return self._ticket_flow_bridge._select_ticket_flow_topic(entries)
+
+    @staticmethod
+    def _set_ticket_dispatch_marker(
+        value: Optional[str],
+    ) -> "Callable[[TelegramTopicRecord], None]":
+        def apply(topic: "TelegramTopicRecord") -> None:
+            topic.last_ticket_dispatch_seq = value
+
+        return apply
+
+    async def _ticket_flow_watch_loop(self) -> None:
+        await self._ticket_flow_bridge.watch_ticket_flow_pauses(
+            TICKET_FLOW_WATCH_INTERVAL_SECONDS
+        )
+
+    async def _watch_ticket_flow_pauses(self) -> None:
+        await self._ticket_flow_bridge._scan_and_notify_pauses()
+
+    async def _notify_ticket_flow_pause(
+        self,
+        workspace_root: Path,
+        entries: list[tuple[str, "TelegramTopicRecord"]],
+    ) -> None:
+        await self._ticket_flow_bridge._notify_ticket_flow_pause(
+            workspace_root, entries
+        )
+
+    def _load_ticket_flow_pause(
+        self, workspace_root: Path
+    ) -> Optional[tuple[str, str, str]]:
+        return self._ticket_flow_bridge._load_ticket_flow_pause(workspace_root)
+
+    def _latest_dispatch_seq(self, history_dir: Path) -> Optional[str]:
+        return self._ticket_flow_bridge._latest_dispatch_seq(history_dir)
+
+    def _format_ticket_flow_pause_reason(self, record: "FlowRunRecord") -> str:
+        return self._ticket_flow_bridge._format_ticket_flow_pause_reason(record)
+
+    def _format_ticket_flow_pause_message(
+        self, run_id: str, seq: str, content: str
+    ) -> str:
+        return self._ticket_flow_bridge._format_ticket_flow_pause_message(
+            run_id, seq, content
+        )
+
+    def _get_paused_ticket_flow(
+        self, workspace_root: Path, preferred_run_id: Optional[str] = None
+    ) -> Optional[tuple[str, FlowRunRecord]]:
+        return self._ticket_flow_bridge.get_paused_ticket_flow(
+            workspace_root, preferred_run_id=preferred_run_id
+        )
+
+    async def _write_user_reply_from_telegram(
+        self,
+        workspace_root: Path,
+        run_id: str,
+        run_record: FlowRunRecord,
+        message: TelegramMessage,
+        text: str,
+        files: Optional[list[tuple[str, bytes]]] = None,
+    ) -> tuple[bool, str]:
+        try:
+            input_data = dict(run_record.input_data or {})
+            runs_dir_raw = input_data.get("runs_dir")
+            runs_dir = (
+                Path(runs_dir_raw)
+                if isinstance(runs_dir_raw, str) and runs_dir_raw
+                else Path(".codex-autorunner/runs")
             )
+            reply_paths = resolve_reply_paths(
+                workspace_root=workspace_root, runs_dir=runs_dir, run_id=run_id
+            )
+            ensure_reply_dirs(reply_paths)
+
+            cleaned_text = text.strip()
+            raw = cleaned_text
+            if raw and not raw.endswith("\n"):
+                raw += "\n"
+
+            await asyncio.to_thread(
+                reply_paths.user_reply_path.write_text, raw, encoding="utf-8"
+            )
+
+            if files:
+                for filename, data in files:
+                    dest = reply_paths.reply_dir / filename
+                    dest.parent.mkdir(parents=True, exist_ok=True)
+                    await asyncio.to_thread(dest.write_bytes, data)
+
+            seq = await asyncio.to_thread(
+                lambda: _next_reply_seq_sync(reply_paths.reply_history_dir)
+            )
+            dispatch, errors = await asyncio.to_thread(
+                dispatch_reply, reply_paths, next_seq=seq
+            )
+            if errors:
+                return False, "\n".join(errors)
+            if dispatch is None:
+                return False, "Failed to archive reply"
+            return (
+                True,
+                f"Reply archived (seq {dispatch.seq}). Use /flow resume to continue.",
+            )
+        except Exception as exc:
+            self._logger.warning(
+                "Failed to write USER_REPLY.md from Telegram",
+                exc=exc,
+                workspace_root=str(workspace_root),
+                run_id=run_id,
+            )
+            return False, f"Failed to write reply: {exc}"
 
     async def _interrupt_timeout_check(
         self, key: str, turn_id: str, message_id: int
@@ -890,8 +1138,8 @@ class TelegramBotService(
         chat_id: int,
         thread_id: Optional[int],
     ) -> None:
-        key = self._resolve_topic_key(chat_id, thread_id)
-        record = self._router.get_topic(key)
+        key = await self._resolve_topic_key(chat_id, thread_id)
+        record = await self._router.get_topic(key)
         if record and record.agent == "opencode":
             session_id = record.active_thread_id
             workspace_path = record.workspace_path
@@ -943,9 +1191,21 @@ class TelegramBotService(
             runtime.interrupt_turn_id = None
             runtime.interrupt_requested = False
             return
-        client = await self._client_for_workspace(
-            record.workspace_path if record else None
-        )
+        try:
+            client = await self._client_for_workspace(
+                record.workspace_path if record else None
+            )
+        except AppServerUnavailableError:
+            runtime.interrupt_requested = False
+            if runtime.interrupt_message_id is not None:
+                await self._edit_message_text(
+                    chat_id,
+                    runtime.interrupt_message_id,
+                    "Interrupt failed (app-server unavailable).",
+                )
+                runtime.interrupt_message_id = None
+                runtime.interrupt_turn_id = None
+            return
         if client is None:
             runtime.interrupt_requested = False
             if runtime.interrupt_message_id is not None:
@@ -992,23 +1252,36 @@ class TelegramBotService(
         await message_handlers.handle_edited_message(self, message)
 
     async def _handle_message_inner(
-        self, message: TelegramMessage, *, topic_key: Optional[str] = None
+        self,
+        message: TelegramMessage,
+        *,
+        topic_key: Optional[str] = None,
+        placeholder_id: Optional[int] = None,
     ) -> None:
-        await message_handlers.handle_message_inner(self, message, topic_key=topic_key)
+        await message_handlers.handle_message_inner(
+            self, message, topic_key=topic_key, placeholder_id=placeholder_id
+        )
 
     def _coalesce_key_for_topic(self, key: str, user_id: Optional[int]) -> str:
         return message_handlers.coalesce_key_for_topic(self, key, user_id)
 
-    def _coalesce_key(self, message: TelegramMessage) -> str:
-        return message_handlers.coalesce_key(self, message)
+    async def _coalesce_key(self, message: TelegramMessage) -> str:
+        return await message_handlers.coalesce_key(self, message)
 
     async def _buffer_coalesced_message(
-        self, message: TelegramMessage, text: str
+        self,
+        message: TelegramMessage,
+        text: str,
+        *,
+        placeholder_id: Optional[int] = None,
     ) -> None:
-        await message_handlers.buffer_coalesced_message(self, message, text)
+        await message_handlers.buffer_coalesced_message(
+            self, message, text, placeholder_id=placeholder_id
+        )
 
     async def _coalesce_flush_after(self, key: str) -> None:
-        await message_handlers.coalesce_flush_after(self, key)
+        window_seconds = self._config.coalesce_window_seconds
+        await message_handlers.coalesce_flush_after(self, key, window_seconds)
 
     async def _flush_coalesced_message(self, message: TelegramMessage) -> None:
         await message_handlers.flush_coalesced_message(self, message)
@@ -1041,10 +1314,19 @@ class TelegramBotService(
         return message_handlers.select_voice_candidate(message)
 
     async def _handle_media_message(
-        self, message: TelegramMessage, runtime: Any, caption_text: str
+        self,
+        message: TelegramMessage,
+        runtime: Any,
+        caption_text: str,
+        *,
+        placeholder_id: Optional[int] = None,
     ) -> None:
         await message_handlers.handle_media_message(
-            self, message, runtime, caption_text
+            self,
+            message,
+            runtime,
+            caption_text,
+            placeholder_id=placeholder_id,
         )
 
     def _with_conversation_id(
@@ -1052,14 +1334,25 @@ class TelegramBotService(
     ) -> str:
         return _with_conversation_id(message, chat_id=chat_id, thread_id=thread_id)
 
-    def _should_process_update(self, key: str, update_id: int) -> bool:
+    async def _should_process_update(self, key: str, update_id: int) -> bool:
         if not isinstance(update_id, int):
             return True
         if isinstance(update_id, bool):
             return True
         last_id = self._last_update_ids.get(key)
         if last_id is None:
-            record = self._store.get_topic(key)
+            record = None
+            try:
+                record = await self._store.get_topic(key)
+            except Exception as exc:
+                log_event(
+                    self._logger,
+                    logging.WARNING,
+                    "telegram.update_id.load.failed",
+                    exc=exc,
+                    topic_key=key,
+                    update_id=update_id,
+                )
             last_id = record.last_update_id if record else None
             if isinstance(last_id, int) and not isinstance(last_id, bool):
                 self._last_update_ids[key] = last_id
@@ -1068,19 +1361,31 @@ class TelegramBotService(
         if isinstance(last_id, int) and update_id <= last_id:
             return False
         self._last_update_ids[key] = update_id
-        self._maybe_persist_update_id(key, update_id)
+        try:
+            await self._maybe_persist_update_id(key, update_id)
+        except Exception as exc:
+            log_event(
+                self._logger,
+                logging.WARNING,
+                "telegram.update_id.persist.failed",
+                exc=exc,
+                topic_key=key,
+                update_id=update_id,
+            )
         return True
 
-    def _maybe_persist_update_id(self, key: str, update_id: int) -> None:
+    async def _maybe_persist_update_id(self, key: str, update_id: int) -> None:
         now = time.monotonic()
         last_persisted = self._last_update_persisted_at.get(key, 0.0)
-        if (now - last_persisted) < UPDATE_ID_PERSIST_INTERVAL_SECONDS:
+        if (
+            now - last_persisted
+        ) < self._config.cache.update_id_persist_interval_seconds:
             return
 
         def apply(record: "TelegramTopicRecord") -> None:
             record.last_update_id = update_id
 
-        self._store.update_topic(key, apply)
+        await self._store.update_topic(key, apply)
         self._last_update_persisted_at[key] = now
 
     async def _handle_callback(self, callback: TelegramCallbackQuery) -> None:
@@ -1096,6 +1401,72 @@ class TelegramBotService(
         else:
             self._spawn_task(wrapped())
 
+    async def _maybe_send_queued_placeholder(
+        self, message: TelegramMessage, *, topic_key: str
+    ) -> Optional[int]:
+        runtime = self._router.runtime_for(topic_key)
+        is_busy = runtime.current_turn_id is not None or runtime.queue.pending() > 0
+        if not is_busy:
+            return None
+        placeholder_id = await self._send_placeholder(
+            message.chat_id,
+            thread_id=message.thread_id,
+            reply_to=message.message_id,
+            text=QUEUED_PLACEHOLDER_TEXT,
+        )
+        if placeholder_id is None:
+            return None
+        self._set_queued_placeholder(
+            message.chat_id, message.message_id, placeholder_id
+        )
+        log_event(
+            self._logger,
+            logging.INFO,
+            "telegram.placeholder.queued",
+            topic_key=topic_key,
+            chat_id=message.chat_id,
+            thread_id=message.thread_id,
+            message_id=message.message_id,
+            placeholder_id=placeholder_id,
+        )
+        return placeholder_id
+
+    def _wrap_placeholder_work(
+        self,
+        *,
+        chat_id: int,
+        placeholder_id: Optional[int],
+        work: Any,
+    ) -> Any:
+        if placeholder_id is None:
+            return work
+
+        async def wrapped() -> Any:
+            try:
+                return await work()
+            finally:
+                await self._delete_message(chat_id, placeholder_id)
+
+        return wrapped
+
+    def _claim_queued_placeholder(self, chat_id: int, message_id: int) -> Optional[int]:
+        placeholder_id = self._queued_placeholder_map.pop((chat_id, message_id), None)
+        self._queued_placeholder_timestamps.pop((chat_id, message_id), None)
+        return placeholder_id
+
+    def _get_queued_placeholder(self, chat_id: int, message_id: int) -> Optional[int]:
+        return self._queued_placeholder_map.get((chat_id, message_id))
+
+    def _set_queued_placeholder(
+        self, chat_id: int, message_id: int, placeholder_id: int
+    ) -> None:
+        self._queued_placeholder_map[(chat_id, message_id)] = placeholder_id
+        self._queued_placeholder_timestamps[(chat_id, message_id)] = time.monotonic()
+
+    def _clear_queued_placeholder(self, chat_id: int, message_id: int) -> None:
+        self._queued_placeholder_map.pop((chat_id, message_id), None)
+        self._queued_placeholder_timestamps.pop((chat_id, message_id), None)
+
     def _wrap_topic_work(self, key: str, work: Any) -> Any:
         conversation_id = None
         try: