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

codex_autorunner/integrations/telegram/handlers/commands/execution.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import dataclasses
 import json
 import logging
 import math
@@ -27,16 +28,23 @@ from .....agents.opencode.runtime import (
     split_model_id,
 )
 from .....agents.opencode.supervisor import OpenCodeSupervisorError
-from .....core.about_car import CAR_CONTEXT_HINT, CAR_CONTEXT_KEYWORDS
+from .....core.app_server_threads import (
+    PMA_KEY,
+    PMA_OPENCODE_KEY,
+    AppServerThreadRegistry,
+)
 from .....core.config import load_repo_config
+from .....core.context_awareness import CAR_AWARENESS_BLOCK
 from .....core.injected_context import wrap_injected_context
 from .....core.logging_utils import log_event
+from .....core.pma_context import build_hub_snapshot, format_pma_prompt, load_pma_prompt
 from .....core.state import now_iso
 from .....core.utils import canonicalize_path
 from .....integrations.github.service import GitHubService
 from ....app_server.client import (
     CodexAppServerClient,
     CodexAppServerDisconnected,
+    CodexAppServerResponseError,
     _normalize_sandbox_policy,
 )
 from ...adapter import (
@@ -75,6 +83,7 @@ from ...helpers import (
     find_github_links,
     is_interrupt_status,
 )
+from ...state import topic_key as build_topic_key
 
 if TYPE_CHECKING:
     from ...state import TelegramTopicRecord
@@ -547,18 +556,11 @@ class ExecutionCommands(SharedHelpers):
         return f"{prompt_text}{separator}{injection}", True
 
     def _maybe_inject_car_context(self, prompt_text: str) -> tuple[str, bool]:
-        if not prompt_text or not prompt_text.strip():
-            return prompt_text, False
-        lowered = prompt_text.lower()
-        if "about_car.md" in lowered:
-            return prompt_text, False
-        if CAR_CONTEXT_HINT in prompt_text:
+        if CAR_AWARENESS_BLOCK in prompt_text:
             return prompt_text, False
-        if not any(keyword in lowered for keyword in CAR_CONTEXT_KEYWORDS):
-            return prompt_text, False
-        separator = "\n" if prompt_text.endswith("\n") else "\n\n"
-        injection = wrap_injected_context(CAR_CONTEXT_HINT)
-        return f"{prompt_text}{separator}{injection}", True
+        if not prompt_text or not prompt_text.strip():
+            return CAR_AWARENESS_BLOCK, True
+        return f"{CAR_AWARENESS_BLOCK}\n\n{prompt_text}", True
 
     def _maybe_inject_outbox_context(
         self,
@@ -1046,6 +1048,8 @@ class ExecutionCommands(SharedHelpers):
         missing_thread_message: Optional[str],
         transcript_message_id: Optional[int],
         transcript_text: Optional[str],
+        pma_thread_registry: Optional[AppServerThreadRegistry] = None,
+        pma_thread_key: Optional[str] = None,
     ) -> _TurnRunResult | _TurnRunFailure:
         supervisor = getattr(self, "_opencode_supervisor", None)
         if supervisor is None:
@@ -1109,6 +1113,7 @@ class ExecutionCommands(SharedHelpers):
                 transcript_text,
             )
 
+        pma_mode = bool(pma_thread_registry and pma_thread_key)
         try:
             if not thread_id:
                 if not allow_new_thread:
@@ -1164,27 +1169,34 @@ class ExecutionCommands(SharedHelpers):
                         rollout_path=record.rollout_path,
                     )
 
-                record = await self._router.update_topic(
-                    message.chat_id, message.thread_id, apply
-                )
+                if pma_mode:
+                    pma_thread_registry.set_thread_id(pma_thread_key, thread_id)
+                else:
+                    record = await self._router.update_topic(
+                        message.chat_id, message.thread_id, apply
+                    )
             else:
-                record = await self._router.set_active_thread(
-                    message.chat_id, message.thread_id, thread_id
-                )
+                if not pma_mode:
+                    record = await self._router.set_active_thread(
+                        message.chat_id, message.thread_id, thread_id
+                    )
 
-            user_preview = _preview_from_text(prompt_text, RESUME_PREVIEW_USER_LIMIT)
-            await self._router.update_topic(
-                message.chat_id,
-                message.thread_id,
-                lambda record: _set_thread_summary(
-                    record,
-                    thread_id,
-                    user_preview=user_preview,
-                    last_used_at=now_iso(),
-                    workspace_path=record.workspace_path,
-                    rollout_path=record.rollout_path,
-                ),
-            )
+            if not pma_mode:
+                user_preview = _preview_from_text(
+                    prompt_text, RESUME_PREVIEW_USER_LIMIT
+                )
+                await self._router.update_topic(
+                    message.chat_id,
+                    message.thread_id,
+                    lambda record: _set_thread_summary(
+                        record,
+                        thread_id,
+                        user_preview=user_preview,
+                        last_used_at=now_iso(),
+                        workspace_path=record.workspace_path,
+                        rollout_path=record.rollout_path,
+                    ),
+                )
 
             pending_seed = None
             pending_seed_thread_id = record.pending_compact_seed_thread_id
@@ -1924,11 +1936,43 @@ class ExecutionCommands(SharedHelpers):
         missing_thread_message: Optional[str],
         transcript_message_id: Optional[int],
         transcript_text: Optional[str],
+        pma_thread_registry: Optional[AppServerThreadRegistry] = None,
+        pma_thread_key: Optional[str] = None,
     ) -> _TurnRunResult | _TurnRunFailure:
         turn_handle = None
         turn_key: Optional[TurnKey] = None
         turn_started_at: Optional[float] = None
 
+        def _is_missing_thread_error(exc: Exception) -> bool:
+            if not isinstance(exc, CodexAppServerResponseError):
+                return False
+            message = str(exc).lower()
+            return "thread not found" in message
+
+        async def _start_new_thread(agent: str) -> Optional[str]:
+            nonlocal record
+            workspace_path = record.workspace_path
+            if not workspace_path:
+                return None
+            thread = await client.thread_start(workspace_path, agent=agent)
+            if not await self._require_thread_workspace(
+                message, workspace_path, thread, action="thread_start"
+            ):
+                return None
+            new_thread_id = _extract_thread_id(thread)
+            if not new_thread_id:
+                return None
+            if pma_mode and pma_thread_registry and pma_thread_key:
+                pma_thread_registry.set_thread_id(pma_thread_key, new_thread_id)
+            elif not pma_mode:
+                record = await self._apply_thread_result(
+                    message.chat_id,
+                    message.thread_id,
+                    thread,
+                    active_thread_id=new_thread_id,
+                )
+            return new_thread_id
+
         try:
             client = await self._client_for_workspace(record.workspace_path)
         except AppServerUnavailableError as exc:
@@ -1966,6 +2010,7 @@ class ExecutionCommands(SharedHelpers):
                 failure_message, None, transcript_message_id, transcript_text
             )
 
+        pma_mode = bool(pma_thread_registry and pma_thread_key)
         try:
             if not thread_id:
                 if not allow_new_thread:
@@ -1986,26 +2031,8 @@ class ExecutionCommands(SharedHelpers):
                         transcript_message_id,
                         transcript_text,
                     )
-                workspace_path = record.workspace_path
-                if not workspace_path:
-                    return _TurnRunFailure(
-                        "Workspace missing.",
-                        None,
-                        transcript_message_id,
-                        transcript_text,
-                    )
                 agent = self._effective_agent(record)
-                thread = await client.thread_start(workspace_path, agent=agent)
-                if not await self._require_thread_workspace(
-                    message, workspace_path, thread, action="thread_start"
-                ):
-                    return _TurnRunFailure(
-                        "Thread workspace mismatch.",
-                        None,
-                        transcript_message_id,
-                        transcript_text,
-                    )
-                thread_id = _extract_thread_id(thread)
+                thread_id = await _start_new_thread(agent)
                 if not thread_id:
                     failure_message = "Failed to start a new thread."
                     if send_failure_response:
@@ -2021,18 +2048,13 @@ class ExecutionCommands(SharedHelpers):
                         transcript_message_id,
                         transcript_text,
                     )
-                record = await self._apply_thread_result(
-                    message.chat_id,
-                    message.thread_id,
-                    thread,
-                    active_thread_id=thread_id,
-                )
             else:
-                record = await self._router.set_active_thread(
-                    message.chat_id, message.thread_id, thread_id
-                )
+                if not pma_mode:
+                    record = await self._router.set_active_thread(
+                        message.chat_id, message.thread_id, thread_id
+                    )
 
-            if thread_id:
+            if thread_id and not pma_mode:
                 user_preview = _preview_from_text(
                     prompt_text, RESUME_PREVIEW_USER_LIMIT
                 )
@@ -2052,7 +2074,9 @@ class ExecutionCommands(SharedHelpers):
             pending_seed = None
             pending_seed_thread_id = record.pending_compact_seed_thread_id
             if record.pending_compact_seed:
-                if pending_seed_thread_id is None:
+                if pma_mode:
+                    pending_seed = None
+                elif pending_seed_thread_id is None:
                     pending_seed = record.pending_compact_seed
                 elif thread_id and pending_seed_thread_id == thread_id:
                     pending_seed = record.pending_compact_seed
@@ -2147,14 +2171,69 @@ class ExecutionCommands(SharedHelpers):
                         PLACEHOLDER_TEXT,
                     )
 
-                turn_handle = await client.turn_start(
-                    thread_id,
-                    prompt_text,
-                    input_items=input_items,
-                    approval_policy=approval_policy,
-                    sandbox_policy=sandbox_policy,
-                    **turn_kwargs,
-                )
+                try:
+                    turn_handle = await client.turn_start(
+                        thread_id,
+                        prompt_text,
+                        input_items=input_items,
+                        approval_policy=approval_policy,
+                        sandbox_policy=sandbox_policy,
+                        **turn_kwargs,
+                    )
+                except Exception as exc:
+                    if (
+                        pma_mode
+                        and _is_missing_thread_error(exc)
+                        and pma_thread_registry
+                        and pma_thread_key
+                    ):
+                        log_event(
+                            self._logger,
+                            logging.WARNING,
+                            "telegram.pma.thread.reset",
+                            topic_key=key,
+                            chat_id=message.chat_id,
+                            thread_id=message.thread_id,
+                            codex_thread_id=thread_id,
+                            reason="thread_not_found",
+                        )
+                        pma_thread_registry.reset_thread(pma_thread_key)
+                        if not allow_new_thread:
+                            failure_message = (
+                                "PMA thread no longer exists. Send a new message to "
+                                "start a PMA thread, then retry /compact."
+                            )
+                            if send_failure_response:
+                                await self._send_message(
+                                    message.chat_id,
+                                    failure_message,
+                                    thread_id=message.thread_id,
+                                    reply_to=message.message_id,
+                                )
+                                if placeholder_id is not None:
+                                    await self._delete_message(
+                                        message.chat_id, placeholder_id
+                                    )
+                            return _TurnRunFailure(
+                                failure_message,
+                                placeholder_id,
+                                transcript_message_id,
+                                transcript_text,
+                            )
+                        agent = self._effective_agent(record)
+                        thread_id = await _start_new_thread(agent)
+                        if thread_id is None:
+                            raise
+                        turn_handle = await client.turn_start(
+                            thread_id,
+                            prompt_text,
+                            input_items=input_items,
+                            approval_policy=approval_policy,
+                            sandbox_policy=sandbox_policy,
+                            **turn_kwargs,
+                        )
+                    else:
+                        raise
                 if pending_seed:
                     await self._router.update_topic(
                         message.chat_id,
@@ -2388,6 +2467,41 @@ class ExecutionCommands(SharedHelpers):
         )
         return prompt_text
 
+    def _pma_registry_key(
+        self, record: "TelegramTopicRecord", message: Optional[TelegramMessage] = None
+    ) -> str:
+        """
+        Return PMA thread registry key.
+
+        Thread scoping decision:
+        - When require_topics is false (default): use global keys (pma/pma.opencode).
+          All Telegram topics share one PMA conversation per agent.
+        - When require_topics is true: use per-topic keys (pma.{topic_key}/pma.opencode.{topic_key}).
+          Each Telegram topic gets its own isolated PMA conversation.
+
+        This allows hubs with multiple topics to maintain separate PMA contexts
+        when require_topics is enabled, while keeping a single shared context
+        in the common case (require_topics disabled).
+        """
+        agent = self._effective_agent(record)
+        base_key = PMA_OPENCODE_KEY if agent == "opencode" else PMA_KEY
+
+        # PMA thread scoping: per-topic when require_topics is true
+        require_topics = getattr(self._config, "require_topics", False)
+        if require_topics and message is not None:
+            topic_key = build_topic_key(message.chat_id, message.thread_id)
+            return f"{base_key}.{topic_key}"
+        return base_key
+
+    async def _prepare_pma_prompt(self, message_text: str) -> Optional[str]:
+        hub_root = getattr(self, "_hub_root", None)
+        if hub_root is None:
+            return None
+        supervisor = getattr(self, "_hub_supervisor", None)
+        snapshot = await build_hub_snapshot(supervisor, hub_root=Path(hub_root))
+        base_prompt = load_pma_prompt(hub_root)
+        return format_pma_prompt(base_prompt, snapshot, message_text, hub_root=hub_root)
+
     async def _prepare_turn_context(
         self,
         message: TelegramMessage,
@@ -2493,6 +2607,26 @@ class ExecutionCommands(SharedHelpers):
     ) -> _TurnRunResult | _TurnRunFailure:
         key = await self._resolve_topic_key(message.chat_id, message.thread_id)
         record = record or await self._router.get_topic(key)
+        pma_enabled = bool(record and getattr(record, "pma_enabled", False))
+        if pma_enabled:
+            hub_root = getattr(self, "_hub_root", None)
+            if hub_root is None:
+                failure_message = "PMA unavailable; hub root not configured."
+                if send_failure_response:
+                    await self._send_message(
+                        message.chat_id,
+                        failure_message,
+                        thread_id=message.thread_id,
+                        reply_to=message.message_id,
+                    )
+                return _TurnRunFailure(
+                    failure_message, None, transcript_message_id, transcript_text
+                )
+            if record is None:
+                from ...state import TelegramTopicRecord
+
+                record = TelegramTopicRecord(pma_enabled=True)
+            record = dataclasses.replace(record, workspace_path=str(hub_root))
         if record is None or not record.workspace_path:
             failure_message = "Topic not bound. Use /bind <repo_id> or /bind <path>."
             if send_failure_response:
@@ -2506,7 +2640,7 @@ class ExecutionCommands(SharedHelpers):
                 failure_message, None, transcript_message_id, transcript_text
             )
 
-        if record.active_thread_id:
+        if record.active_thread_id and not pma_enabled:
             conflict_key = await self._find_thread_conflict(
                 record.active_thread_id,
                 key=key,
@@ -2536,16 +2670,40 @@ class ExecutionCommands(SharedHelpers):
                 )
             record = verified
 
-        thread_id = record.active_thread_id
+        pma_thread_registry = (
+            getattr(self, "_hub_thread_registry", None) if pma_enabled else None
+        )
+        pma_thread_key = (
+            self._pma_registry_key(record, message) if pma_enabled else None
+        )
+        thread_id = None if pma_enabled else record.active_thread_id
+        if pma_enabled and pma_thread_registry and pma_thread_key:
+            thread_id = pma_thread_registry.get_thread_id(pma_thread_key)
         prompt_text = (
             text_override if text_override is not None else (message.text or "")
         )
         prompt_text = self._prepare_turn_prompt(
             prompt_text, transcript_text=transcript_text
         )
-        prompt_text, key = await self._prepare_turn_context(
-            message, prompt_text, record
-        )
+        if pma_enabled:
+            pma_prompt = await self._prepare_pma_prompt(prompt_text)
+            if pma_prompt is None:
+                failure_message = "PMA unavailable; hub snapshot failed."
+                if send_failure_response:
+                    await self._send_message(
+                        message.chat_id,
+                        failure_message,
+                        thread_id=message.thread_id,
+                        reply_to=message.message_id,
+                    )
+                return _TurnRunFailure(
+                    failure_message, None, transcript_message_id, transcript_text
+                )
+            prompt_text = pma_prompt
+        else:
+            prompt_text, key = await self._prepare_turn_context(
+                message, prompt_text, record
+            )
 
         turn_semaphore = self._ensure_turn_semaphore()
         queued = turn_semaphore.locked()
@@ -2574,6 +2732,8 @@ class ExecutionCommands(SharedHelpers):
                 missing_thread_message=missing_thread_message,
                 transcript_message_id=transcript_message_id,
                 transcript_text=transcript_text,
+                pma_thread_registry=pma_thread_registry,
+                pma_thread_key=pma_thread_key,
             )
 
         return await self._execute_codex_turn(
@@ -2592,4 +2752,6 @@ class ExecutionCommands(SharedHelpers):
             missing_thread_message=missing_thread_message,
             transcript_message_id=transcript_message_id,
             transcript_text=transcript_text,
+            pma_thread_registry=pma_thread_registry,
+            pma_thread_key=pma_thread_key,
         )