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

codex_autorunner/integrations/telegram/handlers/commands_runtime.py

@@ -20,13 +20,12 @@ from ....agents.opencode.supervisor import OpenCodeSupervisorError
 from ....core.logging_utils import log_event
 from ....core.state import now_iso
 from ....core.update import _normalize_update_target, _spawn_update_process
+from ....core.update_paths import resolve_update_paths
 from ....core.utils import canonicalize_path
-from ....integrations.github.service import GitHubError, GitHubService
 from ...app_server.client import _normalize_sandbox_policy
 from ..adapter import (
     CompactCallback,
     InlineButton,
-    PrFlowStartCallback,
     TelegramCallbackQuery,
     TelegramCommand,
     TelegramMessage,
@@ -56,6 +55,7 @@ from ..constants import (
     TurnKey,
 )
 from ..helpers import (
+    CodexFeatureRow,
     _coerce_model_options,
     _compact_preview,
     _extract_command_result,
@@ -79,6 +79,9 @@ from ..helpers import (
     _set_rollout_path,
     _thread_summary_preview,
     _with_conversation_id,
+    derive_codex_features_command,
+    format_codex_features,
+    parse_codex_features_list,
 )
 from ..state import (
     parse_topic_key,
@@ -98,6 +101,7 @@ from .commands import (
     ApprovalsCommands,
     ExecutionCommands,
     FilesCommands,
+    FlowCommands,
     FormattingHelpers,
     GitHubCommands,
     VoiceCommands,
@@ -113,20 +117,7 @@ OUTBOX_CONTEXT_RE = re.compile(
     "(?:\\b(?:pdf|png|jpg|jpeg|gif|webp|svg|csv|tsv|json|yaml|yml|zip|tar|gz|tgz|xlsx|xls|docx|pptx|md|txt|log|html|xml)\\b|\\.(?:pdf|png|jpg|jpeg|gif|webp|svg|csv|tsv|json|yaml|yml|zip|tar|gz|tgz|xlsx|xls|docx|pptx|md|txt|log|html|xml)\\b|\\b(?:outbox)\\b)",
     re.IGNORECASE,
 )
-CAR_CONTEXT_KEYWORDS = (
-    "car",
-    "codex",
-    "todo",
-    "progress",
-    "opinions",
-    "spec",
-    "summary",
-    "autorunner",
-    "work docs",
-)
-CAR_CONTEXT_HINT = (
-    "Context: read .codex-autorunner/ABOUT_CAR.md for repo-specific rules."
-)
+
 FILES_HINT_TEMPLATE = """Inbox: {inbox}
 Outbox (pending): {outbox}
 Topic key: {topic_key}
@@ -297,7 +288,7 @@ def _iter_exception_chain(exc: BaseException) -> list[BaseException]:
 def _sanitize_error_detail(detail: str, *, limit: int = 200) -> str:
     cleaned = " ".join(detail.split())
     if len(cleaned) > limit:
-        return f"{cleaned[:limit - 3]}..."
+        return f"{cleaned[: limit - 3]}..."
     return cleaned
 
 
@@ -376,13 +367,13 @@ def _format_media_batch_failure(
 class TelegramCommandHandlers(
     WorkspaceCommands,
     GitHubCommands,
+    FlowCommands,
     FilesCommands,
     VoiceCommands,
     ExecutionCommands,
     ApprovalsCommands,
     FormattingHelpers,
 ):
-
     async def _handle_help(
         self, message: TelegramMessage, _args: str, _runtime: Any
     ) -> None:
@@ -1182,451 +1173,6 @@ class TelegramCommandHandlers(
             reply_to=message.message_id,
         )
 
-    async def _pr_flow_request(
-        self,
-        record: "TelegramTopicRecord",
-        *,
-        method: str,
-        path: str,
-        payload: Optional[dict[str, Any]] = None,
-    ) -> dict[str, Any]:
-        base, headers = self._pr_flow_api_base(record)
-        if not base:
-            raise RuntimeError(
-                "PR flow cannot start: repo server base URL could not be resolved for this chat/topic."
-            )
-        url = f"{base}{path}"
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            res = await client.request(method, url, json=payload, headers=headers)
-            res.raise_for_status()
-            data = res.json()
-            if isinstance(data, dict):
-                return data
-            return {"status": "ok", "flow": data}
-
-    def _parse_pr_flags(self, argv: list[str]) -> tuple[Optional[str], dict[str, Any]]:
-        ref: Optional[str] = None
-        flags: dict[str, Any] = {}
-        idx = 0
-        while idx < len(argv):
-            token = argv[idx]
-            if token.startswith("--"):
-                if token == "--draft":
-                    flags["draft"] = True
-                    idx += 1
-                    continue
-                if token == "--ready":
-                    flags["draft"] = False
-                    idx += 1
-                    continue
-                if token == "--base" and idx + 1 < len(argv):
-                    flags["base_branch"] = argv[idx + 1]
-                    idx += 2
-                    continue
-                if token == "--until" and idx + 1 < len(argv):
-                    until = argv[idx + 1].strip().lower()
-                    if until in ("minor", "minor_only"):
-                        flags["stop_condition"] = "minor_only"
-                    elif until in ("clean", "no_issues"):
-                        flags["stop_condition"] = "no_issues"
-                    idx += 2
-                    continue
-                if token in ("--max-cycles", "--max_cycles") and idx + 1 < len(argv):
-                    try:
-                        flags["max_cycles"] = int(argv[idx + 1])
-                    except ValueError:
-                        pass
-                    idx += 2
-                    continue
-                if token in ("--max-runs", "--max_runs") and idx + 1 < len(argv):
-                    try:
-                        flags["max_implementation_runs"] = int(argv[idx + 1])
-                    except ValueError:
-                        pass
-                    idx += 2
-                    continue
-                if token in ("--timeout", "--timeout-seconds") and idx + 1 < len(argv):
-                    try:
-                        flags["max_wallclock_seconds"] = int(argv[idx + 1])
-                    except ValueError:
-                        pass
-                    idx += 2
-                    continue
-                idx += 1
-                continue
-            if ref is None:
-                ref = token
-            idx += 1
-        return ref, flags
-
-    def _format_pr_flow_status(self, flow: dict[str, Any]) -> str:
-        status = flow.get("status") or "unknown"
-        step = flow.get("step") or "unknown"
-        cycle = flow.get("cycle") or 0
-        pr_url = flow.get("pr_url") or ""
-        lines = [f"PR flow: {status} (step: {step}, cycle: {cycle})"]
-        if pr_url:
-            lines.append(f"PR: {pr_url}")
-        return "\n".join(lines)
-
-    async def _handle_github_issue_url(
-        self, message: TelegramMessage, key: str, slug: str, number: int
-    ) -> None:
-        if key is None:
-            return
-
-        record = await self._router.get_topic(key)
-        if record is None or not record.workspace_path:
-            await self._send_message(
-                message.chat_id,
-                self._with_conversation_id(
-                    "Topic not bound. Use /bind <repo_id> or /bind <path>.",
-                    chat_id=message.chat_id,
-                    thread_id=message.thread_id,
-                ),
-                thread_id=message.thread_id,
-                reply_to=message.message_id,
-            )
-            return
-
-        try:
-            from pathlib import Path
-
-            service = GitHubService(Path(record.workspace_path), self._raw_config)
-            issue_ref = f"{slug}#{number}"
-            service.validate_issue_same_repo(issue_ref)
-        except GitHubError as exc:
-            await self._send_message(
-                message.chat_id,
-                str(exc),
-                thread_id=message.thread_id,
-                reply_to=message.message_id,
-            )
-            return
-
-        await self._offer_pr_flow_start(message, record, slug, number)
-
-    async def _offer_pr_flow_start(
-        self,
-        message: TelegramMessage,
-        record: "TelegramTopicRecord",
-        slug: str,
-        number: int,
-    ) -> None:
-        from ..adapter import (
-            InlineButton,
-            build_inline_keyboard,
-            encode_cancel_callback,
-            encode_pr_flow_start_callback,
-        )
-
-        keyboard = build_inline_keyboard(
-            [
-                [
-                    InlineButton(
-                        f"Create PR for #{number}",
-                        encode_pr_flow_start_callback(slug, number),
-                    ),
-                    InlineButton(
-                        "Cancel",
-                        encode_cancel_callback("pr_flow_offer"),
-                    ),
-                ]
-            ]
-        )
-        await self._send_message(
-            message.chat_id,
-            f"Detected GitHub issue: {slug}#{number}\nStart PR flow to create a PR?",
-            thread_id=message.thread_id,
-            reply_to=message.message_id,
-            reply_markup=keyboard,
-        )
-
-    async def _handle_pr_flow_start_callback(
-        self,
-        key: str,
-        callback: TelegramCallbackQuery,
-        parsed: PrFlowStartCallback,
-    ) -> None:
-        from ..adapter import TelegramMessage
-
-        await self._answer_callback(callback)
-        record = await self._router.get_topic(key)
-        if record is None or not record.workspace_path:
-            return
-
-        issue_ref = f"{parsed.slug}#{parsed.number}"
-        payload = {"mode": "issue", "issue": issue_ref}
-        payload["source"] = "telegram"
-        source_meta: dict[str, Any] = {}
-        if callback.chat_id is not None:
-            source_meta["chat_id"] = callback.chat_id
-        if callback.thread_id is not None:
-            source_meta["thread_id"] = callback.thread_id
-        if source_meta:
-            payload["source_meta"] = source_meta
-
-        message = TelegramMessage(
-            update_id=callback.update_id,
-            message_id=callback.message_id or 0,
-            chat_id=callback.chat_id or 0,
-            thread_id=callback.thread_id,
-            from_user_id=callback.from_user_id,
-            text="",
-            date=None,
-            is_topic_message=False,
-        )
-
-        try:
-            data = await self._pr_flow_request(
-                record,
-                method="POST",
-                path="/api/github/pr_flow/start",
-                payload=payload,
-            )
-            flow = data.get("flow") if isinstance(data, dict) else data
-        except Exception as exc:
-            detail = _format_httpx_exception(exc) or str(exc)
-            await self._send_message(
-                message.chat_id,
-                f"PR flow error: {detail}",
-                thread_id=message.thread_id,
-                reply_to=callback.message_id,
-            )
-            return
-        await self._send_message(
-            message.chat_id,
-            self._format_pr_flow_status(flow),
-            thread_id=message.thread_id,
-            reply_to=callback.message_id,
-        )
-
-    async def _handle_pr(
-        self, message: TelegramMessage, args: str, runtime: Any
-    ) -> None:
-        record = await self._require_bound_record(message)
-        if not record:
-            return
-        argv = self._parse_command_args(args)
-        if not argv:
-            await self._send_message(
-                message.chat_id,
-                "Usage: /pr start <issueRef> | /pr fix <prRef> | /pr status | /pr stop | /pr resume | /pr collect",
-                thread_id=message.thread_id,
-                reply_to=message.message_id,
-            )
-            return
-        command = argv[0].lower()
-        if command == "status":
-            try:
-                data = await self._pr_flow_request(
-                    record, method="GET", path="/api/github/pr_flow/status"
-                )
-                flow = data.get("flow") if isinstance(data, dict) else data
-            except Exception as exc:
-                detail = _format_httpx_exception(exc) or str(exc)
-                await self._send_message(
-                    message.chat_id,
-                    f"PR flow error: {detail}",
-                    thread_id=message.thread_id,
-                    reply_to=message.message_id,
-                )
-                return
-            await self._send_message(
-                message.chat_id,
-                self._format_pr_flow_status(flow),
-                thread_id=message.thread_id,
-                reply_to=message.message_id,
-            )
-            return
-        if command == "stop":
-            try:
-                data = await self._pr_flow_request(
-                    record, method="POST", path="/api/github/pr_flow/stop", payload={}
-                )
-                flow = data.get("flow") if isinstance(data, dict) else data
-            except Exception as exc:
-                detail = _format_httpx_exception(exc) or str(exc)
-                await self._send_message(
-                    message.chat_id,
-                    f"PR flow error: {detail}",
-                    thread_id=message.thread_id,
-                    reply_to=message.message_id,
-                )
-                return
-            await self._send_message(
-                message.chat_id,
-                self._format_pr_flow_status(flow),
-                thread_id=message.thread_id,
-                reply_to=message.message_id,
-            )
-            return
-        if command == "resume":
-            try:
-                data = await self._pr_flow_request(
-                    record, method="POST", path="/api/github/pr_flow/resume", payload={}
-                )
-                flow = data.get("flow") if isinstance(data, dict) else data
-            except Exception as exc:
-                detail = _format_httpx_exception(exc) or str(exc)
-                await self._send_message(
-                    message.chat_id,
-                    f"PR flow error: {detail}",
-                    thread_id=message.thread_id,
-                    reply_to=message.message_id,
-                )
-                return
-            await self._send_message(
-                message.chat_id,
-                self._format_pr_flow_status(flow),
-                thread_id=message.thread_id,
-                reply_to=message.message_id,
-            )
-            return
-        if command == "collect":
-            try:
-                data = await self._pr_flow_request(
-                    record,
-                    method="POST",
-                    path="/api/github/pr_flow/collect",
-                    payload={},
-                )
-                flow = data.get("flow") if isinstance(data, dict) else data
-            except Exception as exc:
-                detail = _format_httpx_exception(exc) or str(exc)
-                await self._send_message(
-                    message.chat_id,
-                    f"PR flow error: {detail}",
-                    thread_id=message.thread_id,
-                    reply_to=message.message_id,
-                )
-                return
-            await self._send_message(
-                message.chat_id,
-                self._format_pr_flow_status(flow),
-                thread_id=message.thread_id,
-                reply_to=message.message_id,
-            )
-            return
-        if command in ("start", "implement"):
-            ref, flags = self._parse_pr_flags(argv[1:])
-            if not ref:
-                gh = GitHubService(Path(record.workspace_path))
-                issues = await asyncio.to_thread(gh.list_open_issues, limit=5)
-                if issues:
-                    lines = ["Open issues:"]
-                    for issue in issues:
-                        num = issue.get("number")
-                        title = issue.get("title") or ""
-                        lines.append(f"- #{num} {title}".strip())
-                    lines.append("Use /pr start <issueRef> to begin.")
-                    await self._send_message(
-                        message.chat_id,
-                        "\n".join(lines),
-                        thread_id=message.thread_id,
-                        reply_to=message.message_id,
-                    )
-                    return
-                await self._send_message(
-                    message.chat_id,
-                    "Usage: /pr start <issueRef>",
-                    thread_id=message.thread_id,
-                    reply_to=message.message_id,
-                )
-                return
-            payload = {"mode": "issue", "issue": ref, **flags}
-            payload["source"] = "telegram"
-            payload["source_meta"] = {
-                "chat_id": message.chat_id,
-                "thread_id": message.thread_id,
-            }
-            try:
-                data = await self._pr_flow_request(
-                    record,
-                    method="POST",
-                    path="/api/github/pr_flow/start",
-                    payload=payload,
-                )
-                flow = data.get("flow") if isinstance(data, dict) else data
-            except Exception as exc:
-                detail = _format_httpx_exception(exc) or str(exc)
-                await self._send_message(
-                    message.chat_id,
-                    f"PR flow error: {detail}",
-                    thread_id=message.thread_id,
-                    reply_to=message.message_id,
-                )
-                return
-            await self._send_message(
-                message.chat_id,
-                self._format_pr_flow_status(flow),
-                thread_id=message.thread_id,
-                reply_to=message.message_id,
-            )
-            return
-        if command in ("fix", "pr"):
-            ref, flags = self._parse_pr_flags(argv[1:])
-            if not ref:
-                gh = GitHubService(Path(record.workspace_path))
-                prs = await asyncio.to_thread(gh.list_open_prs, limit=5)
-                if prs:
-                    lines = ["Open PRs:"]
-                    for pr in prs:
-                        num = pr.get("number")
-                        title = pr.get("title") or ""
-                        lines.append(f"- #{num} {title}".strip())
-                    lines.append("Use /pr fix <prRef> to begin.")
-                    await self._send_message(
-                        message.chat_id,
-                        "\n".join(lines),
-                        thread_id=message.thread_id,
-                        reply_to=message.message_id,
-                    )
-                    return
-                await self._send_message(
-                    message.chat_id,
-                    "Usage: /pr fix <prRef>",
-                    thread_id=message.thread_id,
-                    reply_to=message.message_id,
-                )
-                return
-            payload = {"mode": "pr", "pr": ref, **flags}
-            payload["source"] = "telegram"
-            payload["source_meta"] = {
-                "chat_id": message.chat_id,
-                "thread_id": message.thread_id,
-            }
-            try:
-                data = await self._pr_flow_request(
-                    record,
-                    method="POST",
-                    path="/api/github/pr_flow/start",
-                    payload=payload,
-                )
-                flow = data.get("flow") if isinstance(data, dict) else data
-            except Exception as exc:
-                detail = _format_httpx_exception(exc) or str(exc)
-                await self._send_message(
-                    message.chat_id,
-                    f"PR flow error: {detail}",
-                    thread_id=message.thread_id,
-                    reply_to=message.message_id,
-                )
-                return
-            await self._send_message(
-                message.chat_id,
-                self._format_pr_flow_status(flow),
-                thread_id=message.thread_id,
-                reply_to=message.message_id,
-            )
-            return
-        await self._send_message(
-            message.chat_id,
-            "Unknown /pr command. Use /pr start|fix|status|stop|resume|collect.",
-            thread_id=message.thread_id,
-            reply_to=message.message_id,
-        )
-
     async def _list_recent_commits(
         self, record: TelegramTopicRecord
     ) -> list[tuple[str, str]]:
@@ -2068,36 +1614,84 @@ class TelegramCommandHandlers(
             )
             return
         argv = self._parse_command_args(args)
-        if not argv:
+
+        async def _read_explicit_config_features() -> Optional[str]:
             try:
                 result = await client.request("config/read", {"includeLayers": False})
+            except Exception:
+                return None
+            return _format_feature_flags(result)
+
+        async def _fetch_codex_features() -> (
+            tuple[list[CodexFeatureRow], Optional[str]]
+        ):
+            features_command = derive_codex_features_command(
+                self._config.app_server_command
+            )
+            try:
+                result = await client.request(
+                    "command/exec",
+                    {
+                        "cwd": record.workspace_path,
+                        "command": features_command,
+                        "timeoutMs": 10000,
+                    },
+                )
             except Exception as exc:
                 log_event(
                     self._logger,
                     logging.WARNING,
-                    "telegram.experimental.read_failed",
+                    "telegram.experimental.exec_failed",
                     chat_id=message.chat_id,
                     thread_id=message.thread_id,
                     exc=exc,
                 )
+                return (
+                    [],
+                    "Failed to run `codex features list`; check Codex install/PATH.",
+                )
+            stdout, stderr, exit_code = _extract_command_result(result)
+            if exit_code not in (None, 0):
+                detail = stderr.strip() if isinstance(stderr, str) else ""
+                msg = f"`{' '.join(features_command)}` failed (exit {exit_code})."
+                if detail:
+                    msg = f"{msg} stderr: {detail}"
+                return [], msg
+            rows = parse_codex_features_list(stdout)
+            if not rows:
+                return (
+                    [],
+                    f"No feature rows returned by `{' '.join(features_command)}`.",
+                )
+            return rows, None
+
+        list_all = bool(argv and argv[0].lower() == "all")
+        is_list_request = not argv or list_all or argv[0].lower() in ("list", "ls")
+        if is_list_request:
+            stage_filter = None if list_all else "beta"
+            rows, error = await _fetch_codex_features()
+            if error:
+                fallback = await _read_explicit_config_features()
+                message_lines = [error]
+                if fallback and fallback.strip() != "No feature flags found.":
+                    message_lines.append("")
+                    message_lines.append("Explicit config entries (may be incomplete):")
+                    message_lines.append(fallback)
                 await self._send_message(
                     message.chat_id,
-                    _with_conversation_id(
-                        "Failed to read config; check logs for details.",
-                        chat_id=message.chat_id,
-                        thread_id=message.thread_id,
-                    ),
+                    "\n".join(message_lines),
                     thread_id=message.thread_id,
                     reply_to=message.message_id,
                 )
                 return
             await self._send_message(
                 message.chat_id,
-                _format_feature_flags(result),
+                format_codex_features(rows, stage_filter=stage_filter),
                 thread_id=message.thread_id,
                 reply_to=message.message_id,
             )
             return
+
         if len(argv) < 2:
             await self._send_message(
                 message.chat_id,
@@ -2128,9 +1722,35 @@ class TelegramCommandHandlers(
                 reply_to=message.message_id,
             )
             return
+
+        rows, error = await _fetch_codex_features()
+        if error:
+            await self._send_message(
+                message.chat_id,
+                error,
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return
+
+        normalized_feature = feature
+        if feature.startswith("features."):
+            normalized_feature = feature[len("features.") :]
+        target_row = next((row for row in rows if row.key == normalized_feature), None)
+        if target_row is None:
+            available = ", ".join(sorted(row.key for row in rows))
+            await self._send_message(
+                message.chat_id,
+                f"Unknown feature '{feature}'. Known features: {available}\n"
+                "Use /experimental all to list all stages.",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return
+
         key_path = feature if feature.startswith("features.") else f"features.{feature}"
         try:
-            await client.request(
+            write_result = await client.request(
                 "config/value/write",
                 {"keyPath": key_path, "value": value, "mergeStrategy": "replace"},
             )
@@ -2154,9 +1774,49 @@ class TelegramCommandHandlers(
                 reply_to=message.message_id,
             )
             return
+
+        post_rows, post_error = await _fetch_codex_features()
+        effective_row = None
+        if not post_error:
+            effective_row = next(
+                (row for row in post_rows if row.key == normalized_feature), None
+            )
+
+        lines = [f"Feature {key_path} set to {value}."]
+        if effective_row:
+            lines.append(
+                f"Stage: {effective_row.stage}; effective state: {effective_row.enabled}."
+            )
+        elif post_error:
+            lines.append(f"(Could not verify effective state: {post_error})")
+
+        if isinstance(write_result, dict):
+            status = write_result.get("status")
+            overridden = write_result.get("overriddenMetadata")
+            if status == "okOverridden" and isinstance(overridden, dict):
+                message_txt = overridden.get("message")
+                effective_value = overridden.get("effectiveValue")
+                layer = overridden.get("overridingLayer") or {}
+                layer_name = layer.get("name") if isinstance(layer, dict) else None
+                layer_version = (
+                    layer.get("version") if isinstance(layer, dict) else None
+                )
+                lines.append("Write was overridden by another config layer.")
+                if layer_name:
+                    layer_desc = (
+                        f"{layer_name} (version {layer_version})"
+                        if layer_version
+                        else layer_name
+                    )
+                    lines.append(f"- Overriding layer: {layer_desc}")
+                if effective_value is not None:
+                    lines.append(f"- Effective value: {effective_value}")
+                if isinstance(message_txt, str) and message_txt:
+                    lines.append(f"- Note: {message_txt}")
+
         await self._send_message(
             message.chat_id,
-            f"Feature {key_path} set to {value}.",
+            "\n".join(lines),
             thread_id=message.thread_id,
             reply_to=message.message_id,
         )
@@ -2352,7 +2012,6 @@ class TelegramCommandHandlers(
     async def _handle_compact_callback(
         self, key: str, callback: TelegramCallbackQuery, parsed: CompactCallback
     ) -> None:
-
         async def _send_compact_status(text: str) -> bool:
             try:
                 await self._send_message(
@@ -2619,7 +2278,7 @@ Summary applied.""",
         repo_ref = (self._update_repo_ref or DEFAULT_UPDATE_REPO_REF).strip()
         if not repo_ref:
             repo_ref = DEFAULT_UPDATE_REPO_REF
-        update_dir = Path.home() / ".codex-autorunner" / "update_cache"
+        update_dir = resolve_update_paths().cache_dir
         notify_reply_to = reply_to
         if notify_reply_to is None and callback is not None:
             notify_reply_to = callback.message_id
@@ -2630,6 +2289,7 @@ Summary applied.""",
                 update_dir=update_dir,
                 logger=self._logger,
                 update_target=update_target,
+                skip_checks=bool(getattr(self, "_update_skip_checks", False)),
                 notify_chat_id=chat_id,
                 notify_thread_id=thread_id,
                 notify_reply_to=notify_reply_to,
@@ -2724,7 +2384,7 @@ Summary applied.""",
         )
 
     def _update_status_path(self) -> Path:
-        return Path.home() / ".codex-autorunner" / "update_status.json"
+        return resolve_update_paths().status_path
 
     def _read_update_status(self) -> Optional[dict[str, Any]]:
         path = self._update_status_path()
@@ -2773,7 +2433,6 @@ Summary applied.""",
         timeout_seconds: float = 300.0,
         interval_seconds: float = 2.0,
     ) -> None:
-
         async def _watch() -> None:
             deadline = time.monotonic() + timeout_seconds
             while time.monotonic() < deadline:
@@ -2809,7 +2468,7 @@ Summary applied.""",
             )
 
     def _compact_status_path(self) -> Path:
-        return Path.home() / ".codex-autorunner" / "compact_status.json"
+        return resolve_update_paths().compact_status_path
 
     def _read_compact_status(self) -> Optional[dict[str, Any]]:
         path = self._compact_status_path()