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

codex_autorunner/integrations/telegram/service.py

@@ -7,24 +7,25 @@ import logging
 import os
 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.text_delta_coalescer import TextDeltaCoalescer
-from ...core.utils import (
-    build_opencode_supervisor,
-)
+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 (
@@ -45,21 +46,9 @@ from .config import (
     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,
-    PENDING_QUESTION_TTL_SECONDS,
-    PROGRESS_STREAM_TTL_SECONDS,
     QUEUED_PLACEHOLDER_TEXT,
-    REASONING_BUFFER_TTL_SECONDS,
-    SELECTION_STATE_TTL_SECONDS,
-    TURN_PREVIEW_TTL_SECONDS,
-    UPDATE_ID_PERSIST_INTERVAL_SECONDS,
     TurnKey,
 )
 from .dispatch import dispatch_update
@@ -88,6 +77,7 @@ from .state import (
     parse_topic_key,
     topic_key,
 )
+from .ticket_flow_bridge import TelegramTicketFlowBridge
 from .transport import TelegramMessageTransport
 from .types import (
     CompactState,
@@ -100,17 +90,19 @@ from .types import (
 )
 from .voice import TelegramVoiceManager
 
+TICKET_FLOW_WATCH_INTERVAL_SECONDS = 20
+
 
 def _build_opencode_supervisor(
     config: TelegramBotConfig,
     *,
     logger: logging.Logger,
 ) -> Optional[OpenCodeSupervisor]:
-    raw_command = os.environ.get("CAR_OPENCODE_COMMAND")
+    opencode_command = config.opencode_command or None
     opencode_binary = config.agent_binaries.get("opencode")
 
     supervisor = build_opencode_supervisor(
-        opencode_command=[raw_command] if raw_command else None,
+        opencode_command=opencode_command,
         opencode_binary=opencode_binary,
         workspace_root=config.root,
         logger=logger,
@@ -133,6 +125,26 @@ def _build_opencode_supervisor(
     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(
     TelegramRuntimeHelpers,
     TelegramMessageTransport,
@@ -154,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__)
@@ -161,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
@@ -174,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,
         )
@@ -224,6 +241,13 @@ class TelegramBotService(
         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] = {}
@@ -249,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] = {}
@@ -540,6 +565,11 @@ class TelegramBotService(
             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,
@@ -557,6 +587,9 @@ class TelegramBotService(
                 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:
@@ -622,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()
@@ -871,73 +910,206 @@ class TelegramBotService(
                 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", PENDING_QUESTION_TTL_SECONDS
+                "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) > PENDING_APPROVAL_TTL_SECONDS:
+                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
     ) -> None:
@@ -1205,7 +1377,9 @@ class TelegramBotService(
     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:

codex_autorunner/integrations/telegram/state.py

@@ -205,6 +205,7 @@ class TelegramTopicRecord:
     rollout_path: Optional[str] = None
     approval_mode: str = APPROVAL_MODE_YOLO
     last_active_at: Optional[str] = None
+    last_ticket_dispatch_seq: Optional[str] = None
 
     @classmethod
     def from_dict(
@@ -291,6 +292,11 @@ class TelegramTopicRecord:
         last_active_at = payload.get("last_active_at") or payload.get("lastActiveAt")
         if not isinstance(last_active_at, str):
             last_active_at = None
+        last_ticket_dispatch_seq = payload.get(
+            "last_ticket_dispatch_seq"
+        ) or payload.get("lastTicketDispatchSeq")
+        if not isinstance(last_ticket_dispatch_seq, str):
+            last_ticket_dispatch_seq = None
         return cls(
             repo_id=repo_id,
             workspace_path=workspace_path,
@@ -310,6 +316,7 @@ class TelegramTopicRecord:
             rollout_path=rollout_path,
             approval_mode=approval_mode,
             last_active_at=last_active_at,
+            last_ticket_dispatch_seq=last_ticket_dispatch_seq,
         )
 
     def to_dict(self) -> dict[str, Any]:
@@ -335,6 +342,7 @@ class TelegramTopicRecord:
             "rollout_path": self.rollout_path,
             "approval_mode": self.approval_mode,
             "last_active_at": self.last_active_at,
+            "last_ticket_dispatch_seq": self.last_ticket_dispatch_seq,
         }
 
 
@@ -444,6 +452,10 @@ class OutboxRecord:
     attempts: int = 0
     last_error: Optional[str] = None
     last_attempt_at: Optional[str] = None
+    next_attempt_at: Optional[str] = None
+    operation: Optional[str] = None
+    message_id: Optional[int] = None
+    outbox_key: Optional[str] = None
 
     @classmethod
     def from_dict(cls, payload: dict[str, Any]) -> Optional["OutboxRecord"]:
@@ -459,6 +471,10 @@ class OutboxRecord:
         attempts = payload.get("attempts", 0)
         last_error = payload.get("last_error")
         last_attempt_at = payload.get("last_attempt_at")
+        next_attempt_at = payload.get("next_attempt_at")
+        operation = payload.get("operation")
+        message_id = payload.get("message_id")
+        outbox_key = payload.get("outbox_key")
         if not isinstance(record_id, str) or not record_id:
             return None
         if not isinstance(chat_id, int):
@@ -481,6 +497,14 @@ class OutboxRecord:
             last_error = None
         if not isinstance(last_attempt_at, str):
             last_attempt_at = None
+        if not isinstance(next_attempt_at, str):
+            next_attempt_at = None
+        if not isinstance(operation, str):
+            operation = None
+        if message_id is not None and not isinstance(message_id, int):
+            message_id = None
+        if not isinstance(outbox_key, str):
+            outbox_key = None
         return cls(
             record_id=record_id,
             chat_id=chat_id,
@@ -492,6 +516,10 @@ class OutboxRecord:
             attempts=attempts,
             last_error=last_error,
             last_attempt_at=last_attempt_at,
+            next_attempt_at=next_attempt_at,
+            operation=operation,
+            message_id=message_id,
+            outbox_key=outbox_key,
         )
 
     def to_dict(self) -> dict[str, Any]:
@@ -506,6 +534,10 @@ class OutboxRecord:
             "attempts": self.attempts,
             "last_error": self.last_error,
             "last_attempt_at": self.last_attempt_at,
+            "next_attempt_at": self.next_attempt_at,
+            "operation": self.operation,
+            "message_id": self.message_id,
+            "outbox_key": self.outbox_key,
         }
 
 
@@ -674,6 +706,27 @@ class TelegramStateStore:
     async def get_topic(self, key: str) -> Optional[TelegramTopicRecord]:
         return await self._run(self._get_topic_sync, key)
 
+    async def list_topics(self) -> dict[str, TelegramTopicRecord]:
+        """Return all stored topics keyed by topic_key."""
+        return await self._run(self._list_topics_sync)
+
+    def _list_topics_sync(self) -> dict[str, TelegramTopicRecord]:
+        conn = self._ensure_connection()
+        cursor = conn.execute("SELECT topic_key, payload_json FROM telegram_topics")
+        topics: dict[str, TelegramTopicRecord] = {}
+        for key, payload_json in cursor.fetchall():
+            try:
+                payload = (
+                    json.loads(payload_json) if isinstance(payload_json, str) else {}
+                )
+            except Exception:
+                payload = {}
+            record = TelegramTopicRecord.from_dict(
+                payload, default_approval_mode=self._default_approval_mode
+            )
+            topics[str(key)] = record
+        return topics
+
     async def get_topic_scope(self, key: str) -> Optional[str]:
         return await self._run(self._get_topic_scope_sync, key)
 
@@ -807,6 +860,11 @@ class TelegramStateStore:
         loop = asyncio.get_running_loop()
         return await loop.run_in_executor(self._executor, func, *args)
 
+    def _ensure_connection(self) -> sqlite3.Connection:
+        # Backwards-compatible helper used by older call sites.
+        # _connection_sync() remains the single source of truth for opening the DB.
+        return self._connection_sync()
+
     def _connection_sync(self) -> sqlite3.Connection:
         if self._connection is None:
             conn = connect_sqlite(self._path)
@@ -927,16 +985,41 @@ class TelegramStateStore:
                     thread_id INTEGER,
                     created_at TEXT NOT NULL,
                     updated_at TEXT NOT NULL,
+                    next_attempt_at TEXT,
+                    operation TEXT,
+                    message_id INTEGER,
+                    outbox_key TEXT,
                     payload_json TEXT NOT NULL
                 )
                 """
             )
+            # Ensure legacy DBs gain the newer columns before creating indexes that
+            # reference them. The ALTERs are idempotent and cheap.
+            for col, col_type in [
+                ("next_attempt_at", "TEXT"),
+                ("operation", "TEXT"),
+                ("message_id", "INTEGER"),
+                ("outbox_key", "TEXT"),
+            ]:
+                try:
+                    conn.execute(
+                        f"ALTER TABLE telegram_outbox ADD COLUMN {col} {col_type}"
+                    )
+                except sqlite3.OperationalError:
+                    pass
             conn.execute(
                 """
                 CREATE INDEX IF NOT EXISTS idx_tg_outbox_created
                     ON telegram_outbox(created_at)
                 """
             )
+            conn.execute(
+                """
+                CREATE INDEX IF NOT EXISTS idx_tg_outbox_key
+                    ON telegram_outbox(outbox_key)
+                    WHERE outbox_key IS NOT NULL
+                """
+            )
             conn.execute(
                 """
                 CREATE TABLE IF NOT EXISTS telegram_pending_voice (
@@ -1019,7 +1102,10 @@ class TelegramStateStore:
     def _load_legacy_state_json(self, path: Path) -> Optional[TelegramState]:
         try:
             payload = json.loads(path.read_text(encoding="utf-8"))
-        except (OSError, json.JSONDecodeError):
+        except (OSError, json.JSONDecodeError, UnicodeDecodeError):
+            # The path may already be a SQLite file (e.g., state_file still ends
+            # with .json after the migration to SQLite). In that case, ignore the
+            # legacy load attempt and treat the DB as the source of truth.
             return None
         if not isinstance(payload, dict):
             return None
@@ -1748,14 +1834,22 @@ class TelegramStateStore:
                     thread_id,
                     created_at,
                     updated_at,
+                    next_attempt_at,
+                    operation,
+                    message_id,
+                    outbox_key,
                     payload_json
                 )
-                VALUES (?, ?, ?, ?, ?, ?)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                 ON CONFLICT(record_id) DO UPDATE SET
                     chat_id=excluded.chat_id,
                     thread_id=excluded.thread_id,
                     created_at=excluded.created_at,
                     updated_at=excluded.updated_at,
+                    next_attempt_at=excluded.next_attempt_at,
+                    operation=excluded.operation,
+                    message_id=excluded.message_id,
+                    outbox_key=excluded.outbox_key,
                     payload_json=excluded.payload_json
                 """,
                 (
@@ -1764,6 +1858,10 @@ class TelegramStateStore:
                     record.thread_id,
                     record.created_at,
                     updated_at,
+                    record.next_attempt_at,
+                    record.operation,
+                    record.message_id,
+                    record.outbox_key,
                     payload_json,
                 ),
             )