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

codex_autorunner/core/config.py

@@ -1,6 +1,7 @@
 import dataclasses
 import ipaddress
 import json
+import logging
 import os
 import shlex
 from os import PathLike
@@ -10,6 +11,9 @@ from typing import IO, Any, Dict, List, Mapping, Optional, Union, cast
 import yaml
 
 from ..housekeeping import HousekeepingConfig, parse_housekeeping_config
+from .path_utils import ConfigPathError, resolve_config_path
+
+logger = logging.getLogger("codex_autorunner.core.config")
 
 DOTENV_AVAILABLE = True
 try:
@@ -48,13 +52,18 @@ DEFAULT_REPO_CONFIG: Dict[str, Any] = {
     "version": CONFIG_VERSION,
     "mode": "repo",
     "docs": {
-        "todo": ".codex-autorunner/TODO.md",
-        "progress": ".codex-autorunner/PROGRESS.md",
-        "opinions": ".codex-autorunner/OPINIONS.md",
-        "spec": ".codex-autorunner/SPEC.md",
-        "summary": ".codex-autorunner/SUMMARY.md",
-        "snapshot": ".codex-autorunner/SNAPSHOT.md",
-        "snapshot_state": ".codex-autorunner/snapshot_state.json",
+        "active_context": ".codex-autorunner/workspace/active_context.md",
+        "decisions": ".codex-autorunner/workspace/decisions.md",
+        "spec": ".codex-autorunner/workspace/spec.md",
+    },
+    "review": {
+        "enabled": True,
+        "agent": "opencode",
+        "model": "zai-coding-plan/glm-4.7",
+        "subagent_agent": "subagent",
+        "subagent_model": "zai-coding-plan/glm-4.7-flashx",
+        "reasoning": None,
+        "max_wallclock_seconds": None,
     },
     "codex": {
         "binary": "codex",
@@ -77,16 +86,52 @@ DEFAULT_REPO_CONFIG: Dict[str, Any] = {
         },
         "opencode": {
             "binary": "opencode",
+            "subagent_models": {
+                "subagent": "zai-coding-plan/glm-4.7-flashx",
+            },
         },
     },
     "prompt": {
         "prev_run_max_chars": 6000,
         "template": ".codex-autorunner/prompt.txt",
     },
+    "security": {
+        "redact_run_logs": True,
+    },
     "runner": {
         "sleep_seconds": 5,
         "stop_after_runs": None,
         "max_wallclock_seconds": None,
+        "no_progress_threshold": 3,
+        "review": {
+            "enabled": False,
+            "trigger": {
+                "on_todos_complete": True,
+                "on_no_progress_stop": True,
+                "on_max_runs_stop": True,
+                "on_stop_requested": False,
+                "on_error_exit": False,
+            },
+            "agent": None,
+            "model": None,
+            "reasoning": None,
+            "max_wallclock_seconds": None,
+            "context": {
+                "primary_docs": ["spec", "decisions"],
+                "include_docs": ["active_context"],
+                "include_last_run_artifacts": True,
+                "max_doc_chars": 20000,
+            },
+            "artifacts": {
+                "attach_to_last_run_index": True,
+                "write_to_review_runs_dir": True,
+            },
+        },
+    },
+    "ticket_flow": {
+        "approval_mode": "yolo",
+        # Keep ticket_flow deterministic by default; surfaces can tighten this.
+        "default_approval_decision": "accept",
     },
     "git": {
         "auto_commit": False,
@@ -98,34 +143,33 @@ DEFAULT_REPO_CONFIG: Dict[str, Any] = {
         "sync_commit_mode": "auto",  # none|auto|always
         # Bounds the agentic sync step in GitHubService.sync_pr (seconds).
         "sync_agent_timeout_seconds": 1800,
-        "pr_flow": {
-            "enabled": True,
-            "max_cycles": 3,
-            "stop_condition": "no_issues",
-            "max_implementation_runs": None,
-            "max_wallclock_seconds": None,
-            "review": {
-                "include_codex": True,
-                "include_github": True,
-                "include_checks": True,
-            },
-            "chatops": {
-                "enabled": False,
-                "poll_interval_seconds": 60,
-                "allow_users": [],
-                "allow_associations": [],
-                "ignore_bots": True,
-            },
-        },
+    },
+    "update": {
+        "skip_checks": False,
     },
     "app_server": {
         "command": ["codex", "app-server"],
         "state_root": "~/.codex-autorunner/workspaces",
+        "auto_restart": True,
         "max_handles": 20,
         "idle_ttl_seconds": 3600,
         "turn_timeout_seconds": 28800,
+        "turn_stall_timeout_seconds": 60,
+        "turn_stall_poll_interval_seconds": 2,
+        "turn_stall_recovery_min_interval_seconds": 10,
         "request_timeout": None,
+        "client": {
+            "max_message_bytes": 50 * 1024 * 1024,
+            "oversize_preview_bytes": 4096,
+            "max_oversize_drain_bytes": 100 * 1024 * 1024,
+            "restart_backoff_initial_seconds": 0.5,
+            "restart_backoff_max_seconds": 30.0,
+            "restart_backoff_jitter_ratio": 0.1,
+        },
         "prompts": {
+            # NOTE: These keys are legacy names kept for config compatibility.
+            # The workspace cutover uses tickets + workspace docs + unified file chat; only
+            # the "autorunner" prompt is currently used by the app-server prompt builder.
             "doc_chat": {
                 "max_chars": 12000,
                 "message_max_chars": 2000,
@@ -145,6 +189,9 @@ DEFAULT_REPO_CONFIG: Dict[str, Any] = {
             },
         },
     },
+    "opencode": {
+        "session_stall_timeout_seconds": 60,
+    },
     "server": {
         "host": "127.0.0.1",
         "port": 4173,
@@ -208,6 +255,20 @@ DEFAULT_REPO_CONFIG: Dict[str, Any] = {
             "timeout_ms": 120000,
             "max_output_chars": 3800,
         },
+        "cache": {
+            "cleanup_interval_seconds": 300,
+            "coalesce_buffer_ttl_seconds": 60,
+            "media_batch_buffer_ttl_seconds": 60,
+            "model_pending_ttl_seconds": 1800,
+            "pending_approval_ttl_seconds": 600,
+            "pending_question_ttl_seconds": 600,
+            "reasoning_buffer_ttl_seconds": 900,
+            "selection_state_ttl_seconds": 1800,
+            "turn_preview_ttl_seconds": 900,
+            "progress_stream_ttl_seconds": 900,
+            "oversize_warning_ttl_seconds": 3600,
+            "update_id_persist_interval_seconds": 60,
+        },
         "command_registration": {
             "enabled": True,
             "scopes": [
@@ -215,12 +276,18 @@ DEFAULT_REPO_CONFIG: Dict[str, Any] = {
                 {"type": "all_group_chats", "language_code": ""},
             ],
         },
-        "state_file": ".codex-autorunner/telegram_state.json",
+        "opencode_command": None,
+        "state_file": ".codex-autorunner/telegram_state.sqlite3",
         "app_server_command_env": "CAR_TELEGRAM_APP_SERVER_COMMAND",
         "app_server_command": ["codex", "app-server"],
         "app_server": {
             "max_handles": 20,
             "idle_ttl_seconds": 3600,
+            "turn_timeout_seconds": 28800,
+        },
+        "agent_timeouts": {
+            "codex": 28800,
+            "opencode": 28800,
         },
         "polling": {
             "timeout_seconds": 30,
@@ -334,6 +401,16 @@ DEFAULT_REPO_CONFIG: Dict[str, Any] = {
                 "max_total_bytes": 100_000_000,
                 "max_age_days": 30,
             },
+            {
+                "name": "review_runs",
+                "kind": "directory",
+                "path": ".codex-autorunner/review/runs",
+                "glob": "*",
+                "recursive": True,
+                "max_files": 100,
+                "max_total_bytes": 500_000_000,
+                "max_age_days": 30,
+            },
         ],
     },
 }
@@ -343,12 +420,16 @@ REPO_DEFAULT_KEYS = {
     "codex",
     "prompt",
     "runner",
+    "ticket_flow",
     "git",
     "github",
+    "update",
     "notifications",
     "voice",
     "log",
     "server_log",
+    "review",
+    "opencode",
 }
 DEFAULT_REPO_DEFAULTS = {
     key: json.loads(json.dumps(DEFAULT_REPO_CONFIG[key])) for key in REPO_DEFAULT_KEYS
@@ -357,10 +438,12 @@ REPO_SHARED_KEYS = {
     "agents",
     "server",
     "app_server",
+    "opencode",
     "telegram_bot",
     "terminal",
     "static_assets",
     "housekeeping",
+    "update",
 }
 
 DEFAULT_HUB_CONFIG: Dict[str, Any] = {
@@ -373,6 +456,9 @@ DEFAULT_HUB_CONFIG: Dict[str, Any] = {
         },
         "opencode": {
             "binary": "opencode",
+            "subagent_models": {
+                "subagent": "zai-coding-plan/glm-4.7-flashx",
+            },
         },
     },
     "terminal": {
@@ -420,6 +506,20 @@ DEFAULT_HUB_CONFIG: Dict[str, Any] = {
             "timeout_ms": 120000,
             "max_output_chars": 3800,
         },
+        "cache": {
+            "cleanup_interval_seconds": 300,
+            "coalesce_buffer_ttl_seconds": 60,
+            "media_batch_buffer_ttl_seconds": 60,
+            "model_pending_ttl_seconds": 1800,
+            "pending_approval_ttl_seconds": 600,
+            "pending_question_ttl_seconds": 600,
+            "reasoning_buffer_ttl_seconds": 900,
+            "selection_state_ttl_seconds": 1800,
+            "turn_preview_ttl_seconds": 900,
+            "progress_stream_ttl_seconds": 900,
+            "oversize_warning_ttl_seconds": 3600,
+            "update_id_persist_interval_seconds": 60,
+        },
         "command_registration": {
             "enabled": True,
             "scopes": [
@@ -427,12 +527,14 @@ DEFAULT_HUB_CONFIG: Dict[str, Any] = {
                 {"type": "all_group_chats", "language_code": ""},
             ],
         },
-        "state_file": ".codex-autorunner/telegram_state.json",
+        "opencode_command": None,
+        "state_file": ".codex-autorunner/telegram_state.sqlite3",
         "app_server_command_env": "CAR_TELEGRAM_APP_SERVER_COMMAND",
         "app_server_command": ["codex", "app-server"],
         "app_server": {
             "max_handles": 20,
             "idle_ttl_seconds": 3600,
+            "turn_timeout_seconds": 28800,
         },
         "polling": {
             "timeout_seconds": 30,
@@ -456,13 +558,28 @@ DEFAULT_HUB_CONFIG: Dict[str, Any] = {
             "backup_count": 3,
         },
     },
+    "update": {
+        "skip_checks": False,
+    },
     "app_server": {
         "command": ["codex", "app-server"],
         "state_root": "~/.codex-autorunner/workspaces",
+        "auto_restart": True,
         "max_handles": 20,
         "idle_ttl_seconds": 3600,
         "turn_timeout_seconds": 28800,
+        "turn_stall_timeout_seconds": 60,
+        "turn_stall_poll_interval_seconds": 2,
+        "turn_stall_recovery_min_interval_seconds": 10,
         "request_timeout": None,
+        "client": {
+            "max_message_bytes": 50 * 1024 * 1024,
+            "oversize_preview_bytes": 4096,
+            "max_oversize_drain_bytes": 100 * 1024 * 1024,
+            "restart_backoff_initial_seconds": 0.5,
+            "restart_backoff_max_seconds": 30.0,
+            "restart_backoff_jitter_ratio": 0.1,
+        },
         "prompts": {
             "doc_chat": {
                 "max_chars": 12000,
@@ -483,6 +600,9 @@ DEFAULT_HUB_CONFIG: Dict[str, Any] = {
             },
         },
     },
+    "opencode": {
+        "session_stall_timeout_seconds": 60,
+    },
     "server": {
         "host": "127.0.0.1",
         "port": 4173,
@@ -590,6 +710,12 @@ class ConfigError(Exception):
     """Raised when configuration is invalid."""
 
 
+__all__ = [
+    "ConfigError",
+    "ConfigPathError",
+]
+
+
 @dataclasses.dataclass
 class LogConfig:
     path: Path
@@ -634,21 +760,43 @@ class AppServerPromptsConfig:
     autorunner: AppServerAutorunnerPromptConfig
 
 
+@dataclasses.dataclass
+class AppServerClientConfig:
+    max_message_bytes: int
+    oversize_preview_bytes: int
+    max_oversize_drain_bytes: int
+    restart_backoff_initial_seconds: float
+    restart_backoff_max_seconds: float
+    restart_backoff_jitter_ratio: float
+
+
 @dataclasses.dataclass
 class AppServerConfig:
     command: List[str]
     state_root: Path
+    auto_restart: Optional[bool]
     max_handles: Optional[int]
     idle_ttl_seconds: Optional[int]
     turn_timeout_seconds: Optional[float]
+    turn_stall_timeout_seconds: Optional[float]
+    turn_stall_poll_interval_seconds: Optional[float]
+    turn_stall_recovery_min_interval_seconds: Optional[float]
     request_timeout: Optional[float]
+    client: AppServerClientConfig
     prompts: AppServerPromptsConfig
 
 
+@dataclasses.dataclass
+class OpenCodeConfig:
+    session_stall_timeout_seconds: Optional[float]
+
+
 @dataclasses.dataclass(frozen=True)
 class AgentConfig:
     binary: str
     serve_command: Optional[List[str]]
+    base_url: Optional[str]
+    subagent_models: Optional[Dict[str, str]]
 
 
 @dataclasses.dataclass
@@ -657,6 +805,7 @@ class RepoConfig:
     root: Path
     version: int
     mode: str
+    security: Dict[str, Any]
     docs: Dict[str, Path]
     codex_binary: str
     codex_args: List[str]
@@ -669,9 +818,13 @@ class RepoConfig:
     runner_sleep_seconds: int
     runner_stop_after_runs: Optional[int]
     runner_max_wallclock_seconds: Optional[int]
+    runner_no_progress_threshold: int
+    ticket_flow: Dict[str, Any]
     git_auto_commit: bool
     git_commit_message_template: str
+    update_skip_checks: bool
     app_server: AppServerConfig
+    opencode: OpenCodeConfig
     server_host: str
     server_port: int
     server_base_path: str
@@ -719,7 +872,9 @@ class HubConfig:
     repo_server_inherit: bool
     update_repo_url: str
     update_repo_ref: str
+    update_skip_checks: bool
     app_server: AppServerConfig
+    opencode: OpenCodeConfig
     server_host: str
     server_port: int
     server_base_path: str
@@ -950,9 +1105,19 @@ def _parse_app_server_config(
     cfg = cfg if isinstance(cfg, dict) else {}
     command = _parse_command(cfg.get("command", defaults.get("command")))
     state_root_raw = cfg.get("state_root", defaults.get("state_root"))
-    state_root = Path(str(state_root_raw)).expanduser()
-    if not state_root.is_absolute():
-        state_root = root / state_root
+    if state_root_raw is None:
+        raise ConfigError("app_server.state_root is required")
+    state_root = resolve_config_path(
+        state_root_raw,
+        root,
+        allow_home=True,
+        scope="app_server.state_root",
+    )
+    auto_restart_raw = cfg.get("auto_restart", defaults.get("auto_restart"))
+    if auto_restart_raw is None:
+        auto_restart = None
+    else:
+        auto_restart = bool(auto_restart_raw)
     max_handles_raw = cfg.get("max_handles", defaults.get("max_handles"))
     max_handles = int(max_handles_raw) if max_handles_raw is not None else None
     if max_handles is not None and max_handles <= 0:
@@ -969,29 +1134,119 @@ def _parse_app_server_config(
     )
     if turn_timeout_seconds is not None and turn_timeout_seconds <= 0:
         turn_timeout_seconds = None
+    stall_timeout_raw = cfg.get(
+        "turn_stall_timeout_seconds", defaults.get("turn_stall_timeout_seconds")
+    )
+    turn_stall_timeout_seconds = (
+        float(stall_timeout_raw) if stall_timeout_raw is not None else None
+    )
+    if turn_stall_timeout_seconds is not None and turn_stall_timeout_seconds <= 0:
+        turn_stall_timeout_seconds = None
+    stall_poll_raw = cfg.get(
+        "turn_stall_poll_interval_seconds",
+        defaults.get("turn_stall_poll_interval_seconds"),
+    )
+    turn_stall_poll_interval_seconds = (
+        float(stall_poll_raw) if stall_poll_raw is not None else None
+    )
+    if (
+        turn_stall_poll_interval_seconds is not None
+        and turn_stall_poll_interval_seconds <= 0
+    ):
+        turn_stall_poll_interval_seconds = defaults.get(
+            "turn_stall_poll_interval_seconds"
+        )
+    stall_recovery_raw = cfg.get(
+        "turn_stall_recovery_min_interval_seconds",
+        defaults.get("turn_stall_recovery_min_interval_seconds"),
+    )
+    turn_stall_recovery_min_interval_seconds = (
+        float(stall_recovery_raw) if stall_recovery_raw is not None else None
+    )
+    if (
+        turn_stall_recovery_min_interval_seconds is not None
+        and turn_stall_recovery_min_interval_seconds < 0
+    ):
+        turn_stall_recovery_min_interval_seconds = defaults.get(
+            "turn_stall_recovery_min_interval_seconds"
+        )
     request_timeout_raw = cfg.get("request_timeout", defaults.get("request_timeout"))
     request_timeout = (
         float(request_timeout_raw) if request_timeout_raw is not None else None
     )
     if request_timeout is not None and request_timeout <= 0:
         request_timeout = None
+    client_defaults = defaults.get("client")
+    client_defaults = client_defaults if isinstance(client_defaults, dict) else {}
+    client_cfg_raw = cfg.get("client")
+    client_cfg = client_cfg_raw if isinstance(client_cfg_raw, dict) else {}
+
+    def _client_int(key: str) -> int:
+        value = client_cfg.get(key, client_defaults.get(key))
+        value = int(value) if value is not None else 0
+        if value <= 0:
+            value = int(client_defaults.get(key) or 0)
+        return value
+
+    def _client_float(key: str, *, allow_zero: bool = False) -> float:
+        value = client_cfg.get(key, client_defaults.get(key))
+        value = float(value) if value is not None else 0.0
+        if value < 0 or (not allow_zero and value <= 0):
+            value = float(client_defaults.get(key) or 0.0)
+        return value
+
     prompt_defaults = defaults.get("prompts")
     prompts = _parse_app_server_prompts_config(cfg.get("prompts"), prompt_defaults)
     return AppServerConfig(
         command=command,
         state_root=state_root,
+        auto_restart=auto_restart,
         max_handles=max_handles,
         idle_ttl_seconds=idle_ttl_seconds,
         turn_timeout_seconds=turn_timeout_seconds,
+        turn_stall_timeout_seconds=turn_stall_timeout_seconds,
+        turn_stall_poll_interval_seconds=turn_stall_poll_interval_seconds,
+        turn_stall_recovery_min_interval_seconds=turn_stall_recovery_min_interval_seconds,
         request_timeout=request_timeout,
+        client=AppServerClientConfig(
+            max_message_bytes=_client_int("max_message_bytes"),
+            oversize_preview_bytes=_client_int("oversize_preview_bytes"),
+            max_oversize_drain_bytes=_client_int("max_oversize_drain_bytes"),
+            restart_backoff_initial_seconds=_client_float(
+                "restart_backoff_initial_seconds"
+            ),
+            restart_backoff_max_seconds=_client_float("restart_backoff_max_seconds"),
+            restart_backoff_jitter_ratio=_client_float(
+                "restart_backoff_jitter_ratio", allow_zero=True
+            ),
+        ),
         prompts=prompts,
     )
 
 
+def _parse_opencode_config(
+    cfg: Optional[Dict[str, Any]],
+    _root: Path,
+    defaults: Optional[Dict[str, Any]],
+) -> OpenCodeConfig:
+    cfg = cfg if isinstance(cfg, dict) else {}
+    defaults = defaults if isinstance(defaults, dict) else {}
+    stall_timeout_raw = cfg.get(
+        "session_stall_timeout_seconds",
+        defaults.get("session_stall_timeout_seconds"),
+    )
+    stall_timeout_seconds = (
+        float(stall_timeout_raw) if stall_timeout_raw is not None else None
+    )
+    if stall_timeout_seconds is not None and stall_timeout_seconds <= 0:
+        stall_timeout_seconds = None
+    return OpenCodeConfig(session_stall_timeout_seconds=stall_timeout_seconds)
+
+
 def _parse_agents_config(
-    cfg: Dict[str, Any], defaults: Dict[str, Any]
+    cfg: Optional[Dict[str, Any]], defaults: Dict[str, Any]
 ) -> Dict[str, AgentConfig]:
-    raw_agents = cfg.get("agents")
+    raw_agents = cfg.get("agents") if cfg else None
     if not isinstance(raw_agents, dict):
         raw_agents = defaults.get("agents", {})
     agents: Dict[str, AgentConfig] = {}
@@ -1004,9 +1259,15 @@ def _parse_agents_config(
         serve_command = None
         if "serve_command" in agent_cfg:
             serve_command = _parse_command(agent_cfg.get("serve_command"))
+        base_url = agent_cfg.get("base_url")
+        subagent_models = agent_cfg.get("subagent_models")
+        if not isinstance(subagent_models, dict):
+            subagent_models = None
         agents[str(agent_id)] = AgentConfig(
-            binary=str(binary),
-            serve_command=serve_command if serve_command else None,
+            binary=binary,
+            serve_command=serve_command,
+            base_url=base_url,
+            subagent_models=subagent_models,
         )
     return agents
 
@@ -1019,9 +1280,14 @@ def _parse_static_assets_config(
     if not isinstance(cfg, dict):
         cfg = defaults
     cache_root_raw = cfg.get("cache_root", defaults.get("cache_root"))
-    cache_root = Path(str(cache_root_raw))
-    if not cache_root.is_absolute():
-        cache_root = root / cache_root
+    if cache_root_raw is None:
+        raise ConfigError("static_assets.cache_root is required")
+    cache_root = resolve_config_path(
+        cache_root_raw,
+        root,
+        allow_home=True,
+        scope="static_assets.cache_root",
+    )
     max_cache_entries = int(
         cfg.get("max_cache_entries", defaults.get("max_cache_entries", 0))
     )
@@ -1057,9 +1323,8 @@ def load_dotenv_for_root(root: Path) -> None:
                 # Prefer repo-local .env over inherited process env to avoid stale keys
                 # (common when running via launchd/daemon or with a global shell export).
                 load_dotenv(dotenv_path=candidate, override=True)
-    except Exception:
-        # Never fail config loading due to dotenv issues.
-        pass
+    except OSError as exc:
+        logger.debug("Failed to load .env file: %s", exc)
 
 
 def _parse_dotenv_fallback(path: Path) -> Dict[str, str]:
@@ -1126,6 +1391,21 @@ def load_hub_config_data(config_path: Path) -> Dict[str, Any]:
 
 def _resolve_hub_config_path(start: Path) -> Path:
     config_path = find_nearest_hub_config_path(start)
+    if not config_path:
+        # Auto-initialize hub config if missing in the current directory or parents.
+        # If we are in a git repo, we'll initialize a hub there.
+        try:
+            from .utils import find_repo_root
+
+            target_root = find_repo_root(start)
+        except Exception:
+            target_root = start
+
+        from ..bootstrap import seed_hub_files
+
+        seed_hub_files(target_root)
+        config_path = find_nearest_hub_config_path(target_root)
+
     if not config_path:
         raise ConfigError(
             f"Missing hub config file; expected to find {CONFIG_FILENAME} in {start} or parents (use --hub to specify)"
@@ -1171,7 +1451,7 @@ def derive_repo_config(
 def _resolve_repo_root(start: Path) -> Path:
     search_dir = start.resolve() if start.is_dir() else start.resolve().parent
     for current in [search_dir] + list(search_dir.parents):
-        if (current / ".codex-autorunner" / "state.json").exists():
+        if (current / ".codex-autorunner" / "state.sqlite3").exists():
             return current
         if (current / ".git").exists():
             return current
@@ -1191,15 +1471,9 @@ def load_repo_config(start: Path, hub_path: Optional[Path] = None) -> RepoConfig
 def _build_repo_config(config_path: Path, cfg: Dict[str, Any]) -> RepoConfig:
     root = config_path.parent.parent.resolve()
     docs = {
-        "todo": Path(cfg["docs"]["todo"]),
-        "progress": Path(cfg["docs"]["progress"]),
-        "opinions": Path(cfg["docs"]["opinions"]),
+        "active_context": Path(cfg["docs"]["active_context"]),
+        "decisions": Path(cfg["docs"]["decisions"]),
         "spec": Path(cfg["docs"]["spec"]),
-        "summary": Path(cfg["docs"]["summary"]),
-        "snapshot": Path(cfg["docs"].get("snapshot", ".codex-autorunner/SNAPSHOT.md")),
-        "snapshot_state": Path(
-            cfg["docs"].get("snapshot_state", ".codex-autorunner/snapshot_state.json")
-        ),
     }
     voice_cfg = cfg.get("voice") if isinstance(cfg.get("voice"), dict) else {}
     voice_cfg = cast(Dict[str, Any], voice_cfg)
@@ -1220,12 +1494,19 @@ def _build_repo_config(config_path: Path, cfg: Dict[str, Any]) -> RepoConfig:
         cfg.get("notifications") if isinstance(cfg.get("notifications"), dict) else {}
     )
     notifications_cfg = cast(Dict[str, Any], notifications_cfg)
+    security_cfg = cfg.get("security") if isinstance(cfg.get("security"), dict) else {}
+    security_cfg = cast(Dict[str, Any], security_cfg)
     log_cfg = cfg.get("log", {})
     log_cfg = cast(Dict[str, Any], log_cfg if isinstance(log_cfg, dict) else {})
     server_log_cfg = cfg.get("server_log", {}) or {}
     server_log_cfg = cast(
         Dict[str, Any], server_log_cfg if isinstance(server_log_cfg, dict) else {}
     )
+    update_cfg = cfg.get("update")
+    update_cfg = cast(
+        Dict[str, Any], update_cfg if isinstance(update_cfg, dict) else {}
+    )
+    update_skip_checks = bool(update_cfg.get("skip_checks", False))
     return RepoConfig(
         raw=cfg,
         root=root,
@@ -1243,13 +1524,20 @@ def _build_repo_config(config_path: Path, cfg: Dict[str, Any]) -> RepoConfig:
         runner_sleep_seconds=int(cfg["runner"]["sleep_seconds"]),
         runner_stop_after_runs=cfg["runner"].get("stop_after_runs"),
         runner_max_wallclock_seconds=cfg["runner"].get("max_wallclock_seconds"),
+        runner_no_progress_threshold=int(cfg["runner"].get("no_progress_threshold", 3)),
         git_auto_commit=bool(cfg["git"].get("auto_commit", False)),
         git_commit_message_template=str(cfg["git"].get("commit_message_template")),
+        update_skip_checks=update_skip_checks,
+        ticket_flow=cast(Dict[str, Any], cfg.get("ticket_flow") or {}),
         app_server=_parse_app_server_config(
             cfg.get("app_server"),
             root,
             DEFAULT_REPO_CONFIG["app_server"],
         ),
+        opencode=_parse_opencode_config(
+            cfg.get("opencode"), root, DEFAULT_REPO_CONFIG.get("opencode")
+        ),
+        security=security_cfg,
         server_host=str(cfg["server"].get("host")),
         server_port=int(cfg["server"].get("port")),
         server_base_path=_normalize_base_path(cfg["server"].get("base_path", "")),
@@ -1303,6 +1591,29 @@ def _build_hub_config(config_path: Path, cfg: Dict[str, Any]) -> HubConfig:
             "max_bytes": log_cfg["max_bytes"],
             "backup_count": log_cfg["backup_count"],
         }
+
+    log_path_str = log_cfg["path"]
+    try:
+        log_path = resolve_config_path(log_path_str, root, scope="log.path")
+    except ConfigPathError as exc:
+        raise ConfigError(str(exc)) from exc
+
+    server_log_path_str = str(server_log_cfg.get("path", log_cfg["path"]))
+    try:
+        server_log_path = resolve_config_path(
+            server_log_path_str,
+            root,
+            scope="server_log.path",
+        )
+    except ConfigPathError as exc:
+        raise ConfigError(str(exc)) from exc
+
+    update_cfg = cfg.get("update")
+    update_cfg = cast(
+        Dict[str, Any], update_cfg if isinstance(update_cfg, dict) else {}
+    )
+    update_skip_checks = bool(update_cfg.get("skip_checks", False))
+
     return HubConfig(
         raw=cfg,
         root=root,
@@ -1318,11 +1629,15 @@ def _build_hub_config(config_path: Path, cfg: Dict[str, Any]) -> HubConfig:
         repo_server_inherit=bool(hub_cfg.get("repo_server_inherit", True)),
         update_repo_url=str(hub_cfg.get("update_repo_url", "")),
         update_repo_ref=str(hub_cfg.get("update_repo_ref", "main")),
+        update_skip_checks=update_skip_checks,
         app_server=_parse_app_server_config(
             cfg.get("app_server"),
             root,
             DEFAULT_HUB_CONFIG["app_server"],
         ),
+        opencode=_parse_opencode_config(
+            cfg.get("opencode"), root, DEFAULT_HUB_CONFIG.get("opencode")
+        ),
         server_host=str(cfg["server"]["host"]),
         server_port=int(cfg["server"]["port"]),
         server_base_path=_normalize_base_path(cfg["server"].get("base_path", "")),
@@ -1331,12 +1646,12 @@ def _build_hub_config(config_path: Path, cfg: Dict[str, Any]) -> HubConfig:
         server_allowed_hosts=list(cfg["server"].get("allowed_hosts") or []),
         server_allowed_origins=list(cfg["server"].get("allowed_origins") or []),
         log=LogConfig(
-            path=root / log_cfg["path"],
+            path=log_path,
             max_bytes=int(log_cfg["max_bytes"]),
             backup_count=int(log_cfg["backup_count"]),
         ),
         server_log=LogConfig(
-            path=root / str(server_log_cfg.get("path", log_cfg["path"])),
+            path=server_log_path,
             max_bytes=int(server_log_cfg.get("max_bytes", log_cfg["max_bytes"])),
             backup_count=int(
                 server_log_cfg.get("backup_count", log_cfg["backup_count"])
@@ -1402,6 +1717,12 @@ def _validate_app_server_config(cfg: Dict[str, Any]) -> None:
         app_server_cfg.get("state_root", ""), str
     ):
         raise ConfigError("app_server.state_root must be a string path")
+    if (
+        "auto_restart" in app_server_cfg
+        and app_server_cfg.get("auto_restart") is not None
+    ):
+        if not isinstance(app_server_cfg.get("auto_restart"), bool):
+            raise ConfigError("app_server.auto_restart must be boolean or null")
     for key in ("max_handles", "idle_ttl_seconds"):
         if key in app_server_cfg and app_server_cfg.get(key) is not None:
             if not isinstance(app_server_cfg.get(key), int):
@@ -1420,6 +1741,47 @@ def _validate_app_server_config(cfg: Dict[str, Any]) -> None:
     ):
         if not isinstance(app_server_cfg.get("request_timeout"), (int, float)):
             raise ConfigError("app_server.request_timeout must be a number or null")
+    for key in (
+        "turn_stall_timeout_seconds",
+        "turn_stall_poll_interval_seconds",
+        "turn_stall_recovery_min_interval_seconds",
+    ):
+        if key in app_server_cfg and app_server_cfg.get(key) is not None:
+            if not isinstance(app_server_cfg.get(key), (int, float)):
+                raise ConfigError(f"app_server.{key} must be a number or null")
+    client_cfg = app_server_cfg.get("client")
+    if client_cfg is not None:
+        if not isinstance(client_cfg, dict):
+            raise ConfigError("app_server.client must be a mapping if provided")
+        for key in (
+            "max_message_bytes",
+            "oversize_preview_bytes",
+            "max_oversize_drain_bytes",
+        ):
+            if key in client_cfg:
+                value = client_cfg.get(key)
+                if not isinstance(value, int):
+                    raise ConfigError(f"app_server.client.{key} must be an integer")
+                if value <= 0:
+                    raise ConfigError(f"app_server.client.{key} must be > 0")
+        for key in (
+            "restart_backoff_initial_seconds",
+            "restart_backoff_max_seconds",
+            "restart_backoff_jitter_ratio",
+        ):
+            if key in client_cfg:
+                value = client_cfg.get(key)
+                if not isinstance(value, (int, float)):
+                    raise ConfigError(
+                        f"app_server.client.{key} must be a number if provided"
+                    )
+                if key == "restart_backoff_jitter_ratio":
+                    if value < 0:
+                        raise ConfigError(
+                            "app_server.client.restart_backoff_jitter_ratio must be >= 0"
+                        )
+                elif value <= 0:
+                    raise ConfigError(f"app_server.client.{key} must be > 0")
     prompts = app_server_cfg.get("prompts")
     if prompts is not None:
         if not isinstance(prompts, dict):
@@ -1463,6 +1825,35 @@ def _validate_app_server_config(cfg: Dict[str, Any]) -> None:
                     )
 
 
+def _validate_opencode_config(cfg: Dict[str, Any]) -> None:
+    opencode_cfg = cfg.get("opencode")
+    if opencode_cfg is None:
+        return
+    if not isinstance(opencode_cfg, dict):
+        raise ConfigError("opencode section must be a mapping if provided")
+    if (
+        "session_stall_timeout_seconds" in opencode_cfg
+        and opencode_cfg.get("session_stall_timeout_seconds") is not None
+    ):
+        if not isinstance(
+            opencode_cfg.get("session_stall_timeout_seconds"), (int, float)
+        ):
+            raise ConfigError(
+                "opencode.session_stall_timeout_seconds must be a number or null"
+            )
+
+
+def _validate_update_config(cfg: Dict[str, Any]) -> None:
+    update_cfg = cfg.get("update")
+    if update_cfg is None:
+        return
+    if not isinstance(update_cfg, dict):
+        raise ConfigError("update section must be a mapping if provided")
+    if "skip_checks" in update_cfg and update_cfg.get("skip_checks") is not None:
+        if not isinstance(update_cfg.get("skip_checks"), bool):
+            raise ConfigError("update.skip_checks must be boolean or null")
+
+
 def _validate_agents_config(cfg: Dict[str, Any]) -> None:
     agents_cfg = cfg.get("agents")
     if agents_cfg is None:
@@ -1491,18 +1882,15 @@ def _validate_repo_config(cfg: Dict[str, Any], *, root: Path) -> None:
     for key, value in docs.items():
         if not isinstance(value, str) or not value:
             raise ConfigError(f"docs.{key} must be a non-empty string path")
-        path = Path(value)
-        if path.is_absolute():
-            raise ConfigError(f"docs.{key} must be a relative path under repo root")
-        if ".." in path.parts:
-            raise ConfigError(f"docs.{key} must not contain '..' segments")
         try:
-            (root / path).resolve().relative_to(root)
-        except ValueError as exc:
-            raise ConfigError(
-                f"docs.{key} must resolve under repo root ({root})"
-            ) from exc
-    for key in ("todo", "progress", "opinions", "spec", "summary"):
+            resolve_config_path(
+                value,
+                root,
+                scope=f"docs.{key}",
+            )
+        except ConfigPathError as exc:
+            raise ConfigError(str(exc)) from exc
+    for key in ("active_context", "decisions", "spec"):
         if not isinstance(docs.get(key), str) or not docs[key]:
             raise ConfigError(f"docs.{key} must be a non-empty string path")
     _validate_agents_config(cfg)
@@ -1555,6 +1943,18 @@ def _validate_repo_config(cfg: Dict[str, Any], *, root: Path) -> None:
         val = runner.get(k)
         if val is not None and not isinstance(val, int):
             raise ConfigError(f"runner.{k} must be an integer or null")
+    ticket_flow_cfg = cfg.get("ticket_flow")
+    if ticket_flow_cfg is not None and not isinstance(ticket_flow_cfg, dict):
+        raise ConfigError("ticket_flow section must be a mapping if provided")
+    if isinstance(ticket_flow_cfg, dict):
+        if "approval_mode" in ticket_flow_cfg and not isinstance(
+            ticket_flow_cfg.get("approval_mode"), str
+        ):
+            raise ConfigError("ticket_flow.approval_mode must be a string")
+        if "default_approval_decision" in ticket_flow_cfg and not isinstance(
+            ticket_flow_cfg.get("default_approval_decision"), str
+        ):
+            raise ConfigError("ticket_flow.default_approval_decision must be a string")
     git = cfg.get("git")
     if not isinstance(git, dict):
         raise ConfigError("git section must be a mapping")
@@ -1578,69 +1978,7 @@ def _validate_repo_config(cfg: Dict[str, Any], *, root: Path) -> None:
             github.get("sync_agent_timeout_seconds"), int
         ):
             raise ConfigError("github.sync_agent_timeout_seconds must be an integer")
-        pr_flow = github.get("pr_flow")
-        if pr_flow is not None:
-            if not isinstance(pr_flow, dict):
-                raise ConfigError("github.pr_flow must be a mapping if provided")
-            if "enabled" in pr_flow and not isinstance(pr_flow.get("enabled"), bool):
-                raise ConfigError("github.pr_flow.enabled must be boolean")
-            if "max_cycles" in pr_flow and not isinstance(
-                pr_flow.get("max_cycles"), int
-            ):
-                raise ConfigError("github.pr_flow.max_cycles must be an integer")
-            if "stop_condition" in pr_flow and not isinstance(
-                pr_flow.get("stop_condition"), str
-            ):
-                raise ConfigError("github.pr_flow.stop_condition must be a string")
-            for key in ("max_implementation_runs", "max_wallclock_seconds"):
-                val = pr_flow.get(key)
-                if val is not None and not isinstance(val, int):
-                    raise ConfigError(
-                        f"github.pr_flow.{key} must be an integer or null"
-                    )
-            review_cfg = pr_flow.get("review")
-            if review_cfg is not None:
-                if not isinstance(review_cfg, dict):
-                    raise ConfigError("github.pr_flow.review must be a mapping")
-                for key in ("include_codex", "include_github", "include_checks"):
-                    if key in review_cfg and not isinstance(review_cfg.get(key), bool):
-                        raise ConfigError(
-                            f"github.pr_flow.review.{key} must be boolean"
-                        )
-            chatops_cfg = pr_flow.get("chatops")
-            if chatops_cfg is not None:
-                if not isinstance(chatops_cfg, dict):
-                    raise ConfigError("github.pr_flow.chatops must be a mapping")
-                if "enabled" in chatops_cfg and not isinstance(
-                    chatops_cfg.get("enabled"), bool
-                ):
-                    raise ConfigError("github.pr_flow.chatops.enabled must be boolean")
-                if "poll_interval_seconds" in chatops_cfg and not isinstance(
-                    chatops_cfg.get("poll_interval_seconds"), int
-                ):
-                    raise ConfigError(
-                        "github.pr_flow.chatops.poll_interval_seconds must be an integer"
-                    )
-                for key in ("allow_users", "allow_associations"):
-                    if key in chatops_cfg and not isinstance(
-                        chatops_cfg.get(key), list
-                    ):
-                        raise ConfigError(
-                            f"github.pr_flow.chatops.{key} must be a list"
-                        )
-                if "ignore_bots" in chatops_cfg and not isinstance(
-                    chatops_cfg.get("ignore_bots"), bool
-                ):
-                    raise ConfigError(
-                        "github.pr_flow.chatops.ignore_bots must be boolean"
-                    )
-                if chatops_cfg.get("enabled", False):
-                    allow_users = chatops_cfg.get("allow_users") or []
-                    allow_assoc = chatops_cfg.get("allow_associations") or []
-                    if not allow_users and not allow_assoc:
-                        raise ConfigError(
-                            "github.pr_flow.chatops.enabled requires at least one of allow_users or allow_associations to be non-empty"
-                        )
+
     server = cfg.get("server")
     if not isinstance(server, dict):
         raise ConfigError("server section must be a mapping")
@@ -1658,6 +1996,8 @@ def _validate_repo_config(cfg: Dict[str, Any], *, root: Path) -> None:
         raise ConfigError("server.auth_token_env must be a string if provided")
     _validate_server_security(server)
     _validate_app_server_config(cfg)
+    _validate_opencode_config(cfg)
+    _validate_update_config(cfg)
     notifications_cfg = cfg.get("notifications")
     if notifications_cfg is not None:
         if not isinstance(notifications_cfg, dict):
@@ -1760,9 +2100,13 @@ def _validate_repo_config(cfg: Dict[str, Any], *, root: Path) -> None:
     log_cfg = cfg.get("log")
     if not isinstance(log_cfg, dict):
         raise ConfigError("log section must be a mapping")
-    for key in ("path",):
-        if not isinstance(log_cfg.get(key, ""), str):
-            raise ConfigError(f"log.{key} must be a string path")
+    if "path" in log_cfg:
+        if not isinstance(log_cfg["path"], str):
+            raise ConfigError("log.path must be a string path")
+        try:
+            resolve_config_path(log_cfg["path"], root, scope="log.path")
+        except ConfigPathError as exc:
+            raise ConfigError(str(exc)) from exc
     for key in ("max_bytes", "backup_count"):
         if not isinstance(log_cfg.get(key, 0), int):
             raise ConfigError(f"log.{key} must be an integer")
@@ -1770,10 +2114,15 @@ def _validate_repo_config(cfg: Dict[str, Any], *, root: Path) -> None:
     if server_log_cfg is not None and not isinstance(server_log_cfg, dict):
         raise ConfigError("server_log section must be a mapping or null")
     if isinstance(server_log_cfg, dict):
-        if "path" in server_log_cfg and not isinstance(
-            server_log_cfg.get("path", ""), str
-        ):
-            raise ConfigError("server_log.path must be a string path")
+        if "path" in server_log_cfg:
+            if not isinstance(server_log_cfg["path"], str):
+                raise ConfigError("server_log.path must be a string path")
+            try:
+                resolve_config_path(
+                    server_log_cfg["path"], root, scope="server_log.path"
+                )
+            except ConfigPathError as exc:
+                raise ConfigError(str(exc)) from exc
         for key in ("max_bytes", "backup_count"):
             if key in server_log_cfg and not isinstance(server_log_cfg.get(key), int):
                 raise ConfigError(f"server_log.{key} must be an integer")
@@ -1792,6 +2141,8 @@ def _validate_hub_config(cfg: Dict[str, Any]) -> None:
     if "repo" in cfg:
         raise ConfigError("repo section is no longer supported; use repo_defaults")
     _validate_agents_config(cfg)
+    _validate_opencode_config(cfg)
+    _validate_update_config(cfg)
     repo_defaults = cfg.get("repo_defaults")
     if repo_defaults is not None:
         if not isinstance(repo_defaults, dict):
@@ -1918,6 +2269,21 @@ def _validate_housekeeping_config(cfg: Dict[str, Any]) -> None:
                     )
             if "path" in rule and not isinstance(rule.get("path"), str):
                 raise ConfigError(f"housekeeping.rules[{idx}].path must be a string")
+            if "path" in rule:
+                path_value = rule.get("path")
+                if not isinstance(path_value, str) or not path_value:
+                    raise ConfigError(
+                        f"housekeeping.rules[{idx}].path must be a non-empty string path"
+                    )
+                path = Path(path_value)
+                if path.is_absolute():
+                    raise ConfigError(
+                        f"housekeeping.rules[{idx}].path must be relative or start with '~'"
+                    )
+                if ".." in path.parts:
+                    raise ConfigError(
+                        f"housekeeping.rules[{idx}].path must not contain '..' segments"
+                    )
             if "glob" in rule and not isinstance(rule.get("glob"), str):
                 raise ConfigError(
                     f"housekeeping.rules[{idx}].glob must be a string if provided"
@@ -2075,6 +2441,29 @@ def _validate_telegram_bot_config(cfg: Dict[str, Any]) -> None:
                 raise ConfigError(f"telegram_bot.shell.{key} must be an integer")
             if isinstance(value, int) and value <= 0:
                 raise ConfigError(f"telegram_bot.shell.{key} must be greater than 0")
+    cache_cfg = telegram_cfg.get("cache")
+    if cache_cfg is not None and not isinstance(cache_cfg, dict):
+        raise ConfigError("telegram_bot.cache must be a mapping if provided")
+    if isinstance(cache_cfg, dict):
+        for key in (
+            "cleanup_interval_seconds",
+            "coalesce_buffer_ttl_seconds",
+            "media_batch_buffer_ttl_seconds",
+            "model_pending_ttl_seconds",
+            "pending_approval_ttl_seconds",
+            "pending_question_ttl_seconds",
+            "reasoning_buffer_ttl_seconds",
+            "selection_state_ttl_seconds",
+            "turn_preview_ttl_seconds",
+            "progress_stream_ttl_seconds",
+            "oversize_warning_ttl_seconds",
+            "update_id_persist_interval_seconds",
+        ):
+            value = cache_cfg.get(key)
+            if value is not None and not isinstance(value, (int, float)):
+                raise ConfigError(f"telegram_bot.cache.{key} must be a number")
+            if isinstance(value, (int, float)) and value <= 0:
+                raise ConfigError(f"telegram_bot.cache.{key} must be > 0")
     command_reg_cfg = telegram_cfg.get("command_registration")
     if command_reg_cfg is not None and not isinstance(command_reg_cfg, dict):
         raise ConfigError("telegram_bot.command_registration must be a mapping")
@@ -2112,14 +2501,47 @@ def _validate_telegram_bot_config(cfg: Dict[str, Any]) -> None:
                     raise ConfigError(
                         "telegram_bot.command_registration.scopes.language_code must be a string or null"
                     )
+    if "trigger_mode" in telegram_cfg and not isinstance(
+        telegram_cfg.get("trigger_mode"), str
+    ):
+        raise ConfigError("telegram_bot.trigger_mode must be a string")
     if "state_file" in telegram_cfg and not isinstance(
         telegram_cfg.get("state_file"), str
     ):
         raise ConfigError("telegram_bot.state_file must be a string path")
+    if (
+        "opencode_command" in telegram_cfg
+        and not isinstance(telegram_cfg.get("opencode_command"), (list, str))
+        and telegram_cfg.get("opencode_command") is not None
+    ):
+        raise ConfigError("telegram_bot.opencode_command must be a list or string")
     if "app_server_command" in telegram_cfg and not isinstance(
         telegram_cfg.get("app_server_command"), (list, str)
     ):
         raise ConfigError("telegram_bot.app_server_command must be a list or string")
+    app_server_cfg = telegram_cfg.get("app_server")
+    if app_server_cfg is not None and not isinstance(app_server_cfg, dict):
+        raise ConfigError("telegram_bot.app_server must be a mapping if provided")
+    if isinstance(app_server_cfg, dict):
+        if (
+            "turn_timeout_seconds" in app_server_cfg
+            and app_server_cfg.get("turn_timeout_seconds") is not None
+            and not isinstance(app_server_cfg.get("turn_timeout_seconds"), (int, float))
+        ):
+            raise ConfigError(
+                "telegram_bot.app_server.turn_timeout_seconds must be a number or null"
+            )
+    agent_timeouts_cfg = telegram_cfg.get("agent_timeouts")
+    if agent_timeouts_cfg is not None and not isinstance(agent_timeouts_cfg, dict):
+        raise ConfigError("telegram_bot.agent_timeouts must be a mapping if provided")
+    if isinstance(agent_timeouts_cfg, dict):
+        for _key, value in agent_timeouts_cfg.items():
+            if value is None:
+                continue
+            if not isinstance(value, (int, float)):
+                raise ConfigError(
+                    "telegram_bot.agent_timeouts values must be numbers or null"
+                )
     polling_cfg = telegram_cfg.get("polling")
     if polling_cfg is not None and not isinstance(polling_cfg, dict):
         raise ConfigError("telegram_bot.polling must be a mapping if provided")