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

codex_autorunner/core/engine.py

@@ -12,11 +12,10 @@ from collections import Counter
 from datetime import datetime, timezone
 from logging.handlers import RotatingFileHandler
 from pathlib import Path
-from typing import IO, Any, Dict, Iterator, Optional, Union
+from typing import IO, Any, Iterator, Optional
 
 import yaml
 
-from ..agents.factory import create_orchestrator
 from ..agents.opencode.logging import OpenCodeEventFormatter
 from ..agents.opencode.runtime import (
     OpenCodeTurnOutput,
@@ -39,8 +38,9 @@ from ..integrations.app_server.client import (
 from ..integrations.app_server.env import build_app_server_env
 from ..integrations.app_server.supervisor import WorkspaceAppServerSupervisor
 from ..manifest import MANIFEST_VERSION
-from ..web.static_assets import missing_static_assets, resolve_static_dir
+from ..tickets.files import list_ticket_paths, ticket_is_done
 from .about_car import ensure_about_car_file
+from .adapter_utils import handle_agent_output
 from .app_server_events import AppServerEventBuffer
 from .app_server_logging import AppServerEventFormatter
 from .app_server_prompts import build_autorunner_prompt
@@ -67,9 +67,11 @@ from .locks import (
 from .notifications import NotificationManager
 from .optional_dependencies import missing_optional_dependencies
 from .prompt import build_final_summary_prompt
+from .redaction import redact_text
 from .review_context import build_spec_progress_review_context
 from .run_index import RunIndexStore
 from .state import RunnerState, load_state, now_iso, save_state, state_lock
+from .static_assets import missing_static_assets, resolve_static_dir
 from .utils import (
     RepoNotFoundError,
     atomic_write,
@@ -134,6 +136,7 @@ class Engine:
         self._run_index_store = RunIndexStore(self.state_path)
         self.lock_path = self.repo_root / ".codex-autorunner" / "lock"
         self.stop_path = self.repo_root / ".codex-autorunner" / "stop"
+        self._hub_path = hub_path
         self._active_global_handler: Optional[RotatingFileHandler] = None
         self._active_run_log: Optional[IO[str]] = None
         self._app_server_threads = AppServerThreadRegistry(
@@ -142,7 +145,10 @@ class Engine:
         self._app_server_threads_lock = threading.Lock()
         self._app_server_supervisor: Optional[WorkspaceAppServerSupervisor] = None
         self._app_server_logger = logging.getLogger("codex_autorunner.app_server")
-        self._app_server_event_formatter = AppServerEventFormatter()
+        redact_enabled = self.config.security.get("redact_run_logs", True)
+        self._app_server_event_formatter = AppServerEventFormatter(
+            redact_enabled=redact_enabled
+        )
         self._app_server_events = AppServerEventBuffer()
         self._opencode_event_formatter = OpenCodeEventFormatter()
         self._opencode_supervisor: Optional[OpenCodeSupervisor] = None
@@ -262,41 +268,21 @@ class Engine:
         return None
 
     def todos_done(self) -> bool:
-        return self.docs.todos_done()
+        # Ticket-first mode: completion is determined by ticket files, not TODO.md.
+        ticket_dir = self.repo_root / ".codex-autorunner" / "tickets"
+        ticket_paths = list_ticket_paths(ticket_dir)
+        if not ticket_paths:
+            return False
+        return all(ticket_is_done(path) for path in ticket_paths)
 
     def summary_finalized(self) -> bool:
-        """Return True if SUMMARY.md contains the finalization marker."""
-        try:
-            text = self.docs.read_doc("summary")
-        except (FileNotFoundError, OSError) as exc:
-            self._app_server_logger.debug("Failed to read SUMMARY.md: %s", exc)
-            return False
-        return SUMMARY_FINALIZED_MARKER in (text or "")
+        # Legacy docs finalization no longer applies (no SUMMARY doc).
+        return True
 
     def _stamp_summary_finalized(self, run_id: int) -> None:
-        """
-        Append an idempotency marker to SUMMARY.md so the final summary job runs only once.
-        Users may remove the marker to force regeneration.
-        """
-        path = self.config.doc_path("summary")
-        try:
-            existing = path.read_text(encoding="utf-8") if path.exists() else ""
-        except (FileNotFoundError, OSError) as exc:
-            self._app_server_logger.debug(
-                "Failed to read SUMMARY.md for stamping: %s", exc
-            )
-            existing = ""
-        if SUMMARY_FINALIZED_MARKER in existing:
-            return
-        stamp = f"{SUMMARY_FINALIZED_MARKER_PREFIX} run_id={int(run_id)} -->\n"
-        new_text = existing
-        if new_text and not new_text.endswith("\n"):
-            new_text += "\n"
-        # Keep a blank line before the marker for readability.
-        if new_text and not new_text.endswith("\n\n"):
-            new_text += "\n"
-        new_text += stamp
-        atomic_write(path, new_text)
+        # No-op: summary file no longer exists.
+        _ = run_id
+        return
 
     async def _execute_run_step(
         self,
@@ -317,7 +303,9 @@ class Engine:
         try:
             todo_before = self.docs.read_doc("todo")
         except (FileNotFoundError, OSError) as exc:
-            self._app_server_logger.debug("Failed to read TODO.md before run: %s", exc)
+            self._app_server_logger.debug(
+                "Failed to read TODO.md before run %s: %s", run_id, exc
+            )
             todo_before = ""
         state = load_state(self.state_path)
         selected_agent = (state.autorunner_agent_override or "codex").strip().lower()
@@ -332,8 +320,23 @@ class Engine:
         self._update_state("running", run_id, None, started=True)
         self._last_run_interrupted = False
         self._start_run_telemetry(run_id)
+
+        actor: dict[str, Any] = {
+            "backend": "codex_app_server",
+            "agent_id": validated_agent,
+            "surface": "hub" if self._hub_path else "cli",
+        }
+        mode: dict[str, Any] = {
+            "approval_policy": state.autorunner_approval_policy or "never",
+            "sandbox": state.autorunner_sandbox_mode or "dangerFullAccess",
+        }
+        runner_cfg = self.config.raw.get("runner") or {}
+        review_cfg = runner_cfg.get("review")
+        if isinstance(review_cfg, dict):
+            mode["review_enabled"] = bool(review_cfg.get("enabled"))
+
         with self._run_log_context(run_id):
-            self._write_run_marker(run_id, "start")
+            self._write_run_marker(run_id, "start", actor=actor, mode=mode)
             if validated_agent == "opencode":
                 exit_code = await self._run_opencode_app_server_async(
                     prompt,
@@ -353,7 +356,9 @@ class Engine:
         try:
             todo_after = self.docs.read_doc("todo")
         except (FileNotFoundError, OSError) as exc:
-            self._app_server_logger.debug("Failed to read TODO.md after run: %s", exc)
+            self._app_server_logger.debug(
+                "Failed to read TODO.md after run %s: %s", run_id, exc
+            )
             todo_after = ""
         todo_delta = self._compute_todo_attribution(todo_before, todo_after)
         todo_snapshot = self._build_todo_snapshot(todo_before, todo_after)
@@ -380,6 +385,7 @@ class Engine:
                 "thread_total_after": telemetry.token_total,
             }
         artifacts: dict[str, str] = {}
+        redact_enabled = self.config.security.get("redact_run_logs", True)
         if telemetry and telemetry.plan is not None:
             try:
                 plan_content = (
@@ -391,25 +397,39 @@ class Engine:
                 )
             except (TypeError, ValueError) as exc:
                 self._app_server_logger.debug(
-                    "Failed to serialize plan to JSON: %s", exc
+                    "Failed to serialize plan to JSON for run %s: %s", run_id, exc
                 )
                 plan_content = json.dumps(
                     {"plan": str(telemetry.plan)}, ensure_ascii=True, indent=2
                 )
+            if redact_enabled:
+                plan_content = redact_text(plan_content)
             plan_path = self._write_run_artifact(run_id, "plan.json", plan_content)
             artifacts["plan_path"] = str(plan_path)
         if telemetry and telemetry.diff is not None:
-            diff_content = (
-                telemetry.diff
-                if isinstance(telemetry.diff, str)
-                else json.dumps(
-                    telemetry.diff, ensure_ascii=True, indent=2, default=str
+            normalized_diff = self._normalize_diff_payload(telemetry.diff)
+            if normalized_diff is not None:
+                diff_content = (
+                    normalized_diff
+                    if isinstance(normalized_diff, str)
+                    else json.dumps(
+                        normalized_diff, ensure_ascii=True, indent=2, default=str
+                    )
                 )
-            )
-            diff_path = self._write_run_artifact(run_id, "diff.patch", diff_content)
-            artifacts["diff_path"] = str(diff_path)
+                if redact_enabled:
+                    diff_content = redact_text(diff_content)
+                diff_path = self._write_run_artifact(run_id, "diff.patch", diff_content)
+                artifacts["diff_path"] = str(diff_path)
         if artifacts:
             run_updates["artifacts"] = artifacts
+        if redact_enabled:
+            from .redaction import get_redaction_patterns
+
+            run_updates["security"] = {
+                "redaction_enabled": True,
+                "redaction_version": "1.0",
+                "redaction_patterns": get_redaction_patterns(),
+            }
         if run_updates:
             self._merge_run_index_entry(run_id, run_updates)
         self._clear_run_telemetry(run_id)
@@ -457,7 +477,7 @@ class Engine:
                 text = run_log.read_text(encoding="utf-8")
             except (FileNotFoundError, OSError) as exc:
                 self._app_server_logger.debug(
-                    "Failed to read previous run log: %s", exc
+                    "Failed to read previous run log for run %s: %s", run_id, exc
                 )
                 text = ""
             if text:
@@ -508,10 +528,12 @@ class Engine:
             try:
                 return run_log.read_text(encoding="utf-8")
             except (FileNotFoundError, OSError) as exc:
-                self._app_server_logger.debug("Failed to read run log block: %s", exc)
+                self._app_server_logger.debug(
+                    "Failed to read run log block for run %s: %s", run_id, exc
+                )
                 return None
         if index_entry:
-            block = self._read_log_range(index_entry)
+            block = self._read_log_range(run_id, index_entry)
             if block is not None:
                 return block
         if not self.log_path.exists():
@@ -555,7 +577,7 @@ class Engine:
                 return "\n".join(buf) if buf else None
         except (FileNotFoundError, OSError, ValueError) as exc:
             self._app_server_logger.debug(
-                "Failed to read full log for run block: %s", exc
+                "Failed to read full log for run %s block: %s", run_id, exc
             )
             return None
         return None
@@ -582,7 +604,7 @@ class Engine:
                 self._active_run_log.flush()
             except (OSError, IOError) as exc:
                 self._app_server_logger.warning(
-                    "Failed to write to active run log: %s", exc
+                    "Failed to write to active run log for run %s: %s", run_id, exc
                 )
         else:
             run_log = self._run_log_path(run_id)
@@ -607,7 +629,7 @@ class Engine:
                 f.write(_json.dumps(event_data) + "\n")
         except (OSError, IOError) as exc:
             self._app_server_logger.warning(
-                "Failed to write event to events log: %s", exc
+                "Failed to write event to events log for run %s: %s", run_id, exc
             )
 
     def _ensure_log_path(self) -> None:
@@ -623,14 +645,25 @@ class Engine:
         (self.log_path.parent / "runs").mkdir(parents=True, exist_ok=True)
 
     def _write_run_marker(
-        self, run_id: int, marker: str, exit_code: Optional[int] = None
+        self,
+        run_id: int,
+        marker: str,
+        exit_code: Optional[int] = None,
+        *,
+        actor: Optional[dict[str, Any]] = None,
+        mode: Optional[dict[str, Any]] = None,
     ) -> None:
         suffix = ""
         if marker == "end":
             suffix = f" (code {exit_code})"
             self._emit_event(run_id, "run.finished", exit_code=exit_code)
         elif marker == "start":
-            self._emit_event(run_id, "run.started")
+            payload: dict[str, Any] = {}
+            if actor is not None:
+                payload["actor"] = actor
+            if mode is not None:
+                payload["mode"] = mode
+            self._emit_event(run_id, "run.started", **payload)
         text = f"=== run {run_id} {marker}{suffix} ==="
         offset = self._emit_global_line(text)
         if self._active_run_log is not None:
@@ -639,14 +672,18 @@ class Engine:
                 self._active_run_log.flush()
             except (OSError, IOError) as exc:
                 self._app_server_logger.warning(
-                    "Failed to write marker to active run log: %s", exc
+                    "Failed to write marker to active run log for run %s: %s",
+                    run_id,
+                    exc,
                 )
         else:
             self._ensure_run_log_dir()
             run_log = self._run_log_path(run_id)
             with run_log.open("a", encoding="utf-8") as f:
                 f.write(f"{text}\n")
-        self._update_run_index(run_id, marker, offset, exit_code)
+        self._update_run_index(
+            run_id, marker, offset, exit_code, actor=actor, mode=mode
+        )
 
     def _emit_global_line(self, text: str) -> Optional[tuple[int, int]]:
         if self._active_global_handler is None:
@@ -715,7 +752,7 @@ class Engine:
                     handler.close()
                 except (OSError, IOError) as exc:
                     self._app_server_logger.debug(
-                        "Failed to close run log handler: %s", exc
+                        "Failed to close run log handler for run %s: %s", run_id, exc
                     )
 
     def _start_run_telemetry(self, run_id: int) -> None:
@@ -747,6 +784,29 @@ class Engine:
                 return
             self._run_telemetry = None
 
+    @staticmethod
+    def _normalize_diff_payload(diff: Any) -> Optional[Any]:
+        if diff is None:
+            return None
+        if isinstance(diff, str):
+            return diff if diff.strip() else None
+        if isinstance(diff, dict):
+            # Prefer meaningful fields if present.
+            for key in ("diff", "patch", "content", "value"):
+                if key in diff:
+                    val = diff.get(key)
+                    if isinstance(val, str) and val.strip():
+                        return val
+                    if val not in (None, "", [], {}, ()):
+                        return diff
+            for val in diff.values():
+                if isinstance(val, str) and val.strip():
+                    return diff
+                if val not in (None, "", [], {}, ()):
+                    return diff
+            return None
+        return diff
+
     def _maybe_update_run_index_telemetry(
         self, run_id: int, min_interval_seconds: float = 3.0
     ) -> None:
@@ -821,13 +881,12 @@ class Engine:
             if method == "turn/plan/updated":
                 telemetry.plan = params.get("plan") if "plan" in params else params
             if method == "turn/diff/updated":
-                diff = (
-                    params.get("diff")
-                    or params.get("patch")
-                    or params.get("content")
-                    or params.get("value")
-                )
-                telemetry.diff = diff if diff is not None else params
+                diff: Any = None
+                for key in ("diff", "patch", "content", "value"):
+                    if key in params:
+                        diff = params.get(key)
+                        break
+                telemetry.diff = diff if diff is not None else params or None
         if run_id is None:
             return
         for line in self._app_server_event_formatter.format_event(message):
@@ -847,7 +906,10 @@ class Engine:
         """
         try:
             state = load_state(self.state_path)
-        except Exception:
+        except Exception as exc:
+            self._app_server_logger.warning(
+                "Failed to load state during run index reconciliation: %s", exc
+            )
             return
 
         active_pid: Optional[int] = None
@@ -870,7 +932,10 @@ class Engine:
         now = now_iso()
         try:
             index = self._run_index_store.load_all()
-        except Exception:
+        except Exception as exc:
+            self._app_server_logger.warning(
+                "Failed to load run index during reconciliation: %s", exc
+            )
             return
 
         for key, entry in index.items():
@@ -917,7 +982,10 @@ class Engine:
                         ),
                     },
                 )
-            except Exception:
+            except Exception as exc:
+                self._app_server_logger.warning(
+                    "Failed to reconcile run index entry for run %d: %s", run_id, exc
+                )
                 continue
 
     def _merge_run_index_entry(self, run_id: int, updates: dict[str, Any]) -> None:
@@ -929,6 +997,9 @@ class Engine:
         marker: str,
         offset: Optional[tuple[int, int]],
         exit_code: Optional[int],
+        *,
+        actor: Optional[dict[str, Any]] = None,
+        mode: Optional[dict[str, Any]] = None,
     ) -> None:
         self._run_index_store.update_marker(
             run_id,
@@ -937,6 +1008,8 @@ class Engine:
             exit_code,
             log_path=str(self.log_path),
             run_log_path=str(self._run_log_path(run_id)),
+            actor=actor,
+            mode=mode,
         )
 
     def _list_from_counts(self, source: list[str], counts: Counter[str]) -> list[str]:
@@ -1021,7 +1094,10 @@ class Engine:
                 entry_id = int(key)
             except (TypeError, ValueError) as exc:
                 self._app_server_logger.debug(
-                    "Failed to parse run index key '%s': %s", key, exc
+                    "Failed to parse run index key '%s' while resolving run %s: %s",
+                    key,
+                    run_id,
+                    exc,
                 )
                 continue
             if entry_id >= run_id:
@@ -1106,7 +1182,7 @@ class Engine:
         atomic_write(path, content)
         return path
 
-    def _read_log_range(self, entry: dict) -> Optional[str]:
+    def _read_log_range(self, run_id: int, entry: dict) -> Optional[str]:
         start = entry.get("start_offset")
         end = entry.get("end_offset")
         if start is None or end is None:
@@ -1115,7 +1191,9 @@ class Engine:
             start_offset = int(start)
             end_offset = int(end)
         except (TypeError, ValueError) as exc:
-            self._app_server_logger.debug("Failed to parse log range offsets: %s", exc)
+            self._app_server_logger.debug(
+                "Failed to parse log range offsets for run %s: %s", run_id, exc
+            )
             return None
         if end_offset < start_offset:
             return None
@@ -1131,7 +1209,9 @@ class Engine:
                 data = f.read(end_offset - start_offset)
             return data.decode("utf-8", errors="replace")
         except (FileNotFoundError, OSError) as exc:
-            self._app_server_logger.debug("Failed to read log range: %s", exc)
+            self._app_server_logger.debug(
+                "Failed to read log range for run %s: %s", run_id, exc
+            )
             return None
 
     def _build_app_server_prompt(self, prev_output: Optional[str]) -> str:
@@ -1166,107 +1246,6 @@ class Engine:
                 return 1
             raise
 
-    async def _run_agent_turn_async(
-        self,
-        agent_id: str,
-        prompt: str,
-        run_id: int,
-        *,
-        external_stop_flag: Optional[threading.Event] = None,
-    ) -> int:
-        orchestrator = self._get_orchestrator(agent_id)
-        if orchestrator is None:
-            self.log_line(
-                run_id,
-                f"error: agent '{agent_id}' backend is not configured",
-            )
-            return 1
-
-        thread_key = f"autorunner.{agent_id}"
-        with state_lock(self.state_path):
-            state = load_state(self.state_path)
-        effective_model = state.autorunner_model_override or self.config.codex_model
-        effective_effort = (
-            state.autorunner_effort_override or self.config.codex_reasoning
-        )
-
-        with self._app_server_threads_lock:
-            conversation_id = self._app_server_threads.get_thread_id(thread_key)
-            if not conversation_id:
-                try:
-                    conversation_info = (
-                        await orchestrator.create_or_resume_conversation(
-                            self.repo_root, agent_id
-                        )
-                    )
-                    conversation_id = conversation_info.id
-                    self._app_server_threads.set_thread_id(thread_key, conversation_id)
-                except Exception as exc:
-                    self.log_line(
-                        run_id, f"error: failed to create conversation: {exc}"
-                    )
-                    return 1
-
-        if conversation_id:
-            self._update_run_telemetry(run_id, thread_id=conversation_id)
-
-        approval_policy = state.autorunner_approval_policy or "never"
-        sandbox_mode = state.autorunner_sandbox_mode or "dangerFullAccess"
-        if sandbox_mode == "workspaceWrite":
-            sandbox_policy: Union[Dict[str, Any], str] = {
-                "type": "workspaceWrite",
-                "writableRoots": [str(self.repo_root)],
-                "networkAccess": bool(state.autorunner_workspace_write_network),
-            }
-        else:
-            sandbox_policy = sandbox_mode
-
-        stop_event = asyncio.Event()
-        stop_task: Optional[asyncio.Task] = None
-
-        if external_stop_flag:
-            stop_task = asyncio.create_task(
-                self._wait_for_stop(external_stop_flag, stop_event)
-            )
-
-        try:
-            result = await orchestrator.run_turn(
-                self.repo_root,
-                conversation_id,
-                prompt,
-                model=effective_model,
-                reasoning=effective_effort,
-                approval_mode=approval_policy,
-                sandbox_policy=sandbox_policy,
-                should_stop=stop_event.is_set,
-            )
-            if result.get("status") != "completed":
-                self.log_line(
-                    run_id, f"error: turn failed with status {result.get('status')}"
-                )
-                return 1
-            output = result.get("output", "")
-            if output:
-                self._log_app_server_output(run_id, output.splitlines())
-                output_path = self._write_run_artifact(run_id, "output.txt", output)
-                self._merge_run_index_entry(
-                    run_id, {"artifacts": {"output_path": str(output_path)}}
-                )
-            return 0
-        except Exception as exc:
-            self.log_line(run_id, f"error: {exc}")
-            return 1
-        finally:
-            if stop_task is not None:
-                stop_task.cancel()
-                with contextlib.suppress(asyncio.CancelledError):
-                    await stop_task
-            if stop_event.is_set():
-                await orchestrator.interrupt_turn(
-                    self.repo_root, conversation_id, grace_seconds=30.0
-                )
-                self._last_run_interrupted = True
-
     async def _run_codex_app_server_async(
         self,
         prompt: str,
@@ -1379,15 +1358,13 @@ class Engine:
                 supervisor=supervisor,
             )
             self._last_run_interrupted = interrupted
-            self._log_app_server_output(run_id, turn_result.agent_messages)
-            output_text = "\n\n".join(turn_result.agent_messages).strip()
-            if output_text:
-                output_path = self._write_run_artifact(
-                    run_id, "output.txt", output_text
-                )
-                self._merge_run_index_entry(
-                    run_id, {"artifacts": {"output_path": str(output_path)}}
-                )
+            handle_agent_output(
+                self._log_app_server_output,
+                self._write_run_artifact,
+                self._merge_run_index_entry,
+                run_id,
+                turn_result.agent_messages,
+            )
             if turn_result.errors:
                 for error in turn_result.errors:
                     self.log_line(run_id, f"error: {error}")
@@ -1419,13 +1396,12 @@ class Engine:
         msg = self.config.git_commit_message_template.replace(
             "{run_id}", str(run_id)
         ).replace("#{run_id}", str(run_id))
-        paths = [
-            self.config.doc_path("todo"),
-            self.config.doc_path("progress"),
-            self.config.doc_path("opinions"),
-            self.config.doc_path("spec"),
-            self.config.doc_path("summary"),
-        ]
+        paths = []
+        for key in ("active_context", "decisions", "spec"):
+            try:
+                paths.append(self.config.doc_path(key))
+            except KeyError:
+                pass
         add_paths = [str(p.relative_to(self.repo_root)) for p in paths if p.exists()]
         if not add_paths:
             return
@@ -1465,9 +1441,19 @@ class Engine:
             env_builder=env_builder,
             logger=self._app_server_logger,
             notification_handler=self._handle_app_server_notification,
+            auto_restart=config.auto_restart,
             max_handles=config.max_handles,
             idle_ttl_seconds=config.idle_ttl_seconds,
             request_timeout=config.request_timeout,
+            turn_stall_timeout_seconds=config.turn_stall_timeout_seconds,
+            turn_stall_poll_interval_seconds=config.turn_stall_poll_interval_seconds,
+            turn_stall_recovery_min_interval_seconds=config.turn_stall_recovery_min_interval_seconds,
+            max_message_bytes=config.client.max_message_bytes,
+            oversize_preview_bytes=config.client.oversize_preview_bytes,
+            max_oversize_drain_bytes=config.client.max_oversize_drain_bytes,
+            restart_backoff_initial_seconds=config.client.restart_backoff_initial_seconds,
+            restart_backoff_max_seconds=config.client.restart_backoff_max_seconds,
+            restart_backoff_jitter_ratio=config.client.restart_backoff_jitter_ratio,
         )
 
     def _ensure_app_server_supervisor(
@@ -1509,6 +1495,7 @@ class Engine:
             request_timeout=config.request_timeout,
             max_handles=config.max_handles,
             idle_ttl_seconds=config.idle_ttl_seconds,
+            session_stall_timeout_seconds=self.config.opencode.session_stall_timeout_seconds,
             base_env=None,
             subagent_models=subagent_models,
         )
@@ -1536,22 +1523,6 @@ class Engine:
         except Exception as exc:
             self._app_server_logger.warning("opencode supervisor close failed: %s", exc)
 
-    def _get_orchestrator(self, agent_id: str):
-        if agent_id == "opencode":
-            opencode_sup = self._ensure_opencode_supervisor()
-            if opencode_sup is None:
-                return None
-            return create_orchestrator(agent_id, opencode_supervisor=opencode_sup)
-        else:
-            app_server_sup = self._ensure_app_server_supervisor(
-                lambda workspace_root, workspace_id, state_dir: {}
-            )
-            return create_orchestrator(
-                agent_id,
-                codex_supervisor=app_server_sup,
-                codex_events=self._app_server_events,
-            )
-
     async def _wait_for_stop(
         self,
         external_stop_flag: Optional[threading.Event],
@@ -1669,8 +1640,9 @@ class Engine:
                     await client.get_session(thread_id)
                 except Exception as exc:
                     self._app_server_logger.debug(
-                        "Failed to get existing opencode session '%s': %s",
+                        "Failed to get existing opencode session '%s' for run %s: %s",
                         thread_id,
+                        run_id,
                         exc,
                     )
                     self._app_server_threads.reset_thread(key)
@@ -1742,11 +1714,13 @@ class Engine:
                 client,
                 session_id=thread_id,
                 workspace_path=str(self.repo_root),
+                model_payload=model_payload,
                 permission_policy=permission_policy,
                 question_policy="auto_first_option",
                 should_stop=active.interrupt_event.is_set,
                 part_handler=_opencode_part_handler,
                 ready_event=ready_event,
+                stall_timeout_seconds=self.config.opencode.session_stall_timeout_seconds,
             )
         )
         with contextlib.suppress(asyncio.TimeoutError):
@@ -1843,7 +1817,12 @@ class Engine:
                     output_result = OpenCodeTurnOutput(
                         text=fallback.text, error=fallback.error
                     )
+                    self.log_line(run_id, "info: opencode fallback message used")
         finally:
+            # Flush buffered reasoning deltas before cleanup, so partial reasoning is still logged
+            # even when the turn is aborted, times out, or is interrupted.
+            for line in self._opencode_event_formatter.flush_all_reasoning():
+                self.log_line(run_id, f"stdout: {line}" if line else "stdout: ")
             stop_task.cancel()
             with contextlib.suppress(asyncio.CancelledError):
                 await stop_task
@@ -1854,17 +1833,20 @@ class Engine:
             if opencode_turn_started:
                 await supervisor.mark_turn_finished(self.repo_root)
 
-        output = output_result.text
-        if output:
-            self._log_app_server_output(run_id, [output])
-            output_text = output.strip()
-            if output_text:
-                output_path = self._write_run_artifact(
-                    run_id, "output.txt", output_text
-                )
-                self._merge_run_index_entry(
-                    run_id, {"artifacts": {"output_path": str(output_path)}}
-                )
+        if not output_result.text:
+            self.log_line(
+                run_id,
+                "info: opencode returned empty output (error=%s)"
+                % (output_result.error or "none"),
+            )
+        if output_result.text:
+            handle_agent_output(
+                self._log_app_server_output,
+                self._write_run_artifact,
+                self._merge_run_index_entry,
+                run_id,
+                output_result.text,
+            )
         if output_result.error:
             self.log_line(
                 run_id, f"error: opencode session error: {output_result.error}"
@@ -1894,8 +1876,10 @@ class Engine:
             )
         )
         no_progress_count = 0
-        last_outstanding_count = len(self.docs.todos()[0])
-        last_done_count = len(self.docs.todos()[1])
+        ticket_dir = self.repo_root / ".codex-autorunner" / "tickets"
+        initial_tickets = list_ticket_paths(ticket_dir)
+        last_done_count = sum(1 for path in initial_tickets if ticket_is_done(path))
+        last_outstanding_count = len(initial_tickets) - last_done_count
         exit_reason: Optional[str] = None
 
         try:
@@ -1949,9 +1933,11 @@ class Engine:
                     break
 
                 # Check for no progress across runs
-                current_outstanding, current_done = self.docs.todos()
-                current_outstanding_count = len(current_outstanding)
-                current_done_count = len(current_done)
+                current_tickets = list_ticket_paths(ticket_dir)
+                current_done_count = sum(
+                    1 for path in current_tickets if ticket_is_done(path)
+                )
+                current_outstanding_count = len(current_tickets) - current_done_count
 
                 # Check if there was any meaningful progress
                 has_progress = (
@@ -1959,25 +1945,55 @@ class Engine:
                     or current_done_count != last_done_count
                 )
 
-                # Check if there was any meaningful output (diff, files changed, etc.)
+                # Check if there was any meaningful output (diff, plan, etc.)
                 has_output = False
-                try:
-                    output_path = (
-                        self.repo_root
-                        / ".codex-autorunner"
-                        / "runs"
-                        / f"run-{run_id}"
-                        / "output.txt"
-                    )
-                    if output_path.exists():
-                        output_content = output_path.read_text(encoding="utf-8").strip()
-                        # Consider it output if there's meaningful text (not just empty or whitespace)
-                        has_output = len(output_content) > 100
-                except (OSError, IOError):
-                    pass
+                run_entry = self._run_index_store.get_entry(run_id)
+                if run_entry:
+                    artifacts = run_entry.get("artifacts", {})
+                    if isinstance(artifacts, dict):
+                        diff_path = artifacts.get("diff_path")
+                        if diff_path:
+                            try:
+                                diff_content = (
+                                    Path(diff_path).read_text(encoding="utf-8").strip()
+                                )
+                                has_output = len(diff_content) > 0
+                            except (OSError, IOError):
+                                pass
+                        if not has_output:
+                            plan_path = artifacts.get("plan_path")
+                            if plan_path:
+                                try:
+                                    plan_content = (
+                                        Path(plan_path)
+                                        .read_text(encoding="utf-8")
+                                        .strip()
+                                    )
+                                    has_output = len(plan_content) > 0
+                                except (OSError, IOError):
+                                    pass
 
                 if not has_progress and not has_output:
                     no_progress_count += 1
+
+                    evidence = {
+                        "outstanding_count": current_outstanding_count,
+                        "done_count": current_done_count,
+                        "has_diff": bool(
+                            run_entry
+                            and isinstance(run_entry.get("artifacts"), dict)
+                            and run_entry["artifacts"].get("diff_path")
+                        ),
+                        "has_plan": bool(
+                            run_entry
+                            and isinstance(run_entry.get("artifacts"), dict)
+                            and run_entry["artifacts"].get("plan_path")
+                        ),
+                        "run_id": run_id,
+                    }
+                    self._emit_event(
+                        run_id, "run.no_progress", count=no_progress_count, **evidence
+                    )
                     self.log_line(
                         run_id,
                         f"info: no progress detected ({no_progress_count}/{self.config.runner_no_progress_threshold} runs without progress)",
@@ -2030,12 +2046,16 @@ class Engine:
                 for line in tb.splitlines():
                     self.log_line(run_id, f"traceback: {line}")
             except (OSError, IOError) as exc:
-                self._app_server_logger.error("Failed to log run_loop crash: %s", exc)
+                self._app_server_logger.error(
+                    "Failed to log run_loop crash for run %s: %s", run_id, exc
+                )
             try:
                 self._update_state("error", run_id, 1, finished=True)
             except (OSError, IOError) as exc:
                 self._app_server_logger.error(
-                    "Failed to update state after run_loop crash: %s", exc
+                    "Failed to update state after run_loop crash for run %s: %s",
+                    run_id,
+                    exc,
                 )
         finally:
             try:
@@ -2044,7 +2064,9 @@ class Engine:
                     last_exit_code=last_exit_code,
                 )
             except Exception as exc:
-                self._app_server_logger.warning("End-of-run review failed: %s", exc)
+                self._app_server_logger.warning(
+                    "End-of-run review failed for run %s: %s", run_id, exc
+                )
             await self._close_app_server_supervisor()
             await self._close_opencode_supervisor()
         # IMPORTANT: lock ownership is managed by the caller (CLI/Hub/Server runner).
@@ -2208,8 +2230,12 @@ class Engine:
         started: bool = False,
         finished: bool = False,
     ) -> None:
+        prev_status: Optional[str] = None
+        last_run_started_at: Optional[str] = None
+        last_run_finished_at: Optional[str] = None
         with state_lock(self.state_path):
             current = load_state(self.state_path)
+            prev_status = current.status
             last_run_started_at = current.last_run_started_at
             last_run_finished_at = current.last_run_finished_at
             runner_pid = current.runner_pid
@@ -2237,6 +2263,18 @@ class Engine:
                 repo_to_session=current.repo_to_session,
             )
             save_state(self.state_path, new_state)
+        if run_id > 0 and prev_status != status:
+            payload: dict[str, Any] = {
+                "from_status": prev_status,
+                "to_status": status,
+            }
+            if exit_code is not None:
+                payload["exit_code"] = exit_code
+            if started and last_run_started_at:
+                payload["started_at"] = last_run_started_at
+            if finished and last_run_finished_at:
+                payload["finished_at"] = last_run_finished_at
+            self._emit_event(run_id, "run.state_changed", **payload)
 
 
 def clear_stale_lock(lock_path: Path) -> bool:
@@ -2612,26 +2650,4 @@ def doctor(start_path: Path) -> DoctorReport:
                 "Install git or disable worktrees.",
             )
 
-    telegram_cfg = None
-    if isinstance(config.raw, dict):
-        telegram_cfg = config.raw.get("telegram_bot")
-    if isinstance(telegram_cfg, dict) and telegram_cfg.get("enabled") is True:
-        missing_telegram = missing_optional_dependencies((("httpx", "httpx"),))
-        if missing_telegram:
-            deps_list = ", ".join(missing_telegram)
-            _append_check(
-                checks,
-                "telegram.dependencies",
-                "error",
-                f"Telegram is enabled but missing optional deps: {deps_list}",
-                "Install with `pip install codex-autorunner[telegram]`.",
-            )
-        else:
-            _append_check(
-                checks,
-                "telegram.dependencies",
-                "ok",
-                "Telegram dependencies are installed.",
-            )
-
     return DoctorReport(checks=checks)