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

codex_autorunner/{core/review.py → flows/review/service.py}

@@ -10,15 +10,20 @@ import zipfile
 from pathlib import Path
 from typing import Any, Optional
 
-from ..agents.opencode.run_prompt import OpenCodeRunConfig, run_opencode_prompt
-from ..agents.opencode.supervisor import OpenCodeSupervisor
-from ..agents.registry import has_capability, validate_agent_id
-from ..integrations.app_server.supervisor import WorkspaceAppServerSupervisor
-from .config import RepoConfig
-from .engine import Engine
-from .locks import FileLock, FileLockBusy, FileLockError, process_alive, read_lock_info
-from .state import now_iso
-from .utils import atomic_write, read_json
+from ...agents.opencode.run_prompt import OpenCodeRunConfig, run_opencode_prompt
+from ...agents.opencode.supervisor import OpenCodeSupervisor
+from ...agents.registry import has_capability, validate_agent_id
+from ...core.config import RepoConfig
+from ...core.locks import (
+    FileLock,
+    FileLockBusy,
+    FileLockError,
+    process_alive,
+    read_lock_info,
+)
+from ...core.runtime import RuntimeContext
+from ...core.state import now_iso
+from ...core.utils import atomic_write, read_json
 
 REVIEW_STATE_VERSION = 1
 REVIEW_TIMEOUT_SECONDS = 3600
@@ -247,7 +252,7 @@ Stop digging deeper when:
 """
 REVIEW_PROMPT_SPEC_PROGRESS = """# Autorunner Final Review (Spec + Progress Focus)
 
-You are coordinating a multi-agent review immediately after an autorunner loop completes. The goal is to validate work against SPEC.md and PROGRESS.md, not to suggest generic code style fixes.
+You are coordinating a multi-agent review immediately after an autorunner loop completes. The goal is to validate work against spec.md, not to suggest generic code style fixes.
 
 ## Required Scratchpad + Output
 
@@ -264,16 +269,16 @@ You are coordinating a multi-agent review immediately after an autorunner loop c
 
 ## Source of Truth + Focus
 
-* Read AUTORUNNER_CONTEXT.md first. It contains the exit reason, SPEC.md, PROGRESS.md, optional TODO/SUMMARY, and the last-run artifacts (output/diff/plan excerpts).
-* Treat SPEC.md + PROGRESS.md as contracts: extract explicit requirements, promised validation steps, and open questions.
+* Read AUTORUNNER_CONTEXT.md first. It contains the exit reason, spec.md, and last-run artifacts (output/diff/plan excerpts).
+* Treat spec.md as the contract: extract explicit requirements, promised validation steps, and open questions.
 * Derive must-hold invariants directly from SPEC (not generic guesses).
 * Buckets should be anchored to spec sections mapped to implementation areas, plus any recently changed/critical modules from AUTORUNNER_CONTEXT.md.
 
 ## North Star
 
-* Spec compliance and claim verification over style.
-* High-signal risks and regressions that would violate SPEC/PROGRESS commitments.
-* Trackable output that can be turned into TODO items.
+* Spec compliance over style.
+* High-signal risks and regressions that would violate spec commitments.
+* Trackable output that can be turned into tickets.
 
 ## Phase 0: Setup (Coordinator)
 
@@ -283,8 +288,7 @@ Prepare scratchpad files under {{scratchpad_dir}} (see list above).
 
 1) Read AUTORUNNER_CONTEXT.md and summarize:
    * Project shape and runtime assumptions
-   * SPEC requirements + invariants
-   * PROGRESS claims + validation evidence
+   * Spec requirements + invariants
    * Open questions/gaps
 2) Define buckets in BUCKETS.md:
    * Buckets by review dimension + code areas (spec sections → code paths)
@@ -294,7 +298,6 @@ Prepare scratchpad files under {{scratchpad_dir}} (see list above).
 
 Launch subagents by review dimension:
 * Spec compliance agent: requirement → evidence mapping.
-* Progress verification agent: PROGRESS claims → repo/tests evidence.
 * Risk & regression agent: likely failure modes introduced by recent changes.
 * Optional: Test adequacy agent if tests are in-scope.
 
@@ -315,8 +318,8 @@ Create the final report at {{final_output_path}} with this structure:
 ## Spec-to-Implementation Matrix
 | Spec item | Status (met/partial/missing) | Evidence | Notes |
 
-## Progress Claim Verification
-- Claim: ... (cite PROGRESS.md section)
+## Spec Verification
+- Spec requirement: ... (cite spec section)
   - Verified by: ...
   - Not verified because: ...
 
@@ -388,19 +391,19 @@ def _default_state() -> dict[str, Any]:
 class ReviewService:
     def __init__(
         self,
-        engine: Engine,
+        ctx: RuntimeContext,
         *,
         opencode_supervisor: Optional[OpenCodeSupervisor] = None,
-        app_server_supervisor: Optional[WorkspaceAppServerSupervisor] = None,
+        app_server_supervisor: Optional[Any] = None,
         logger: Optional[logging.Logger] = None,
     ) -> None:
-        self.engine = engine
+        self.ctx = ctx
         self._opencode_supervisor = opencode_supervisor
         self._app_server_supervisor = app_server_supervisor
         self._logger = logger or logging.getLogger("codex_autorunner.review")
-        self._state_path = _workflow_root(engine.repo_root) / "state.json"
+        self._state_path = _workflow_root(self.ctx.repo_root) / "state.json"
         self._lock_path = (
-            engine.repo_root / ".codex-autorunner" / "locks" / "review.lock"
+            self.ctx.repo_root / ".codex-autorunner" / "locks" / "review.lock"
         )
         self._thread: Optional[threading.Thread] = None
         self._thread_lock = threading.Lock()
@@ -408,9 +411,9 @@ class ReviewService:
         self._lock_handle: Optional[FileLock] = None
 
     def _repo_config(self) -> RepoConfig:
-        if not isinstance(self.engine.config, RepoConfig):
+        if not isinstance(self.ctx.config, RepoConfig):
             raise ReviewError("Review requires a repo workspace config")
-        return self.engine.config
+        return self.ctx.config
 
     def status(self) -> dict[str, Any]:
         state = self._load_state()
@@ -433,7 +436,7 @@ class ReviewService:
                 raise ReviewBusyError("Review already running", status_code=409)
             if self._thread and self._thread.is_alive():
                 raise ReviewBusyError("Review already running", status_code=409)
-            busy_reason = self.engine.repo_busy_reason()
+            busy_reason = self.ctx.repo_busy_reason()
             if busy_reason:
                 raise ReviewConflictError(
                     f"Cannot start review: {busy_reason}", status_code=409
@@ -470,7 +473,7 @@ class ReviewService:
             state = self.status()
             if state.get("status") in ("running", "stopping"):
                 raise ReviewBusyError("Review already running", status_code=409)
-            busy_reason = self.engine.repo_busy_reason()
+            busy_reason = self.ctx.repo_busy_reason()
             if busy_reason and not ignore_repo_busy:
                 raise ReviewConflictError(
                     f"Cannot start review: {busy_reason}", status_code=409
@@ -675,7 +678,7 @@ class ReviewService:
             )
 
         run_id = state["id"]
-        runs_dir = _workflow_root(self.engine.repo_root) / "runs"
+        runs_dir = _workflow_root(self.ctx.repo_root) / "runs"
         run_dir = runs_dir / run_id
         run_dir.mkdir(parents=True, exist_ok=True)
 
@@ -730,7 +733,7 @@ class ReviewService:
         if agent_id == "codex":
             if self._app_server_supervisor is None:
                 raise ReviewError("Codex backend is not configured")
-            client = await self._app_server_supervisor.get_client(self.engine.repo_root)
+            client = await self._app_server_supervisor.get_client(self.ctx.repo_root)
             thread_id = uuid.uuid4().hex
             review_kwargs: dict[str, Any] = {}
             if state.get("model"):
@@ -741,7 +744,7 @@ class ReviewService:
                 thread_id=thread_id,
                 target={"type": "custom", "instructions": prompt},
                 delivery="inline",
-                cwd=str(self.engine.repo_root),
+                cwd=str(self.ctx.repo_root),
                 **review_kwargs,
             )
 
@@ -797,7 +800,7 @@ class ReviewService:
             subagent_model = review_cfg.get("subagent_model")
             if subagent_agent_id:
                 await self._opencode_supervisor.ensure_subagent_config(
-                    workspace_root=self.engine.repo_root,
+                    workspace_root=self.ctx.repo_root,
                     agent_id=subagent_agent_id,
                     model=subagent_model,
                 )
@@ -807,7 +810,7 @@ class ReviewService:
                 model=state["model"],
                 reasoning=state.get("reasoning"),
                 prompt=prompt,
-                workspace_root=str(self.engine.repo_root),
+                workspace_root=str(self.ctx.repo_root),
                 timeout_seconds=timeout_seconds,
                 interrupt_grace_seconds=REVIEW_INTERRUPT_GRACE_SECONDS,
                 permission_policy="allow",

codex_autorunner/flows/ticket_flow/definition.py

@@ -6,7 +6,13 @@ from typing import Any, Dict, Optional
 from ...core.flows.definition import EmitEventFn, FlowDefinition, StepOutcome
 from ...core.flows.models import FlowEventType, FlowRunRecord
 from ...core.utils import find_repo_root
-from ...tickets import AgentPool, TicketRunConfig, TicketRunner
+from ...manifest import ManifestError, load_manifest
+from ...tickets import (
+    DEFAULT_MAX_TOTAL_TURNS,
+    AgentPool,
+    TicketRunConfig,
+    TicketRunner,
+)
 
 
 def build_ticket_flow_definition(*, agent_pool: AgentPool) -> FlowDefinition:
@@ -30,16 +36,36 @@ def build_ticket_flow_definition(*, agent_pool: AgentPool) -> FlowDefinition:
         engine_state = dict(engine_state) if isinstance(engine_state, dict) else {}
 
         repo_root = find_repo_root()
-        workspace_root = Path(input_data.get("workspace_root") or repo_root)
+        raw_workspace = input_data.get("workspace_root") or repo_root
+        workspace_root = Path(raw_workspace)
+        if not workspace_root.is_absolute():
+            workspace_root = (Path(repo_root) / workspace_root).resolve()
+        else:
+            workspace_root = workspace_root.resolve()
+
         ticket_dir = Path(input_data.get("ticket_dir") or ".codex-autorunner/tickets")
+        if not ticket_dir.is_absolute():
+            ticket_dir = (workspace_root / ticket_dir).resolve()
+
         runs_dir = Path(input_data.get("runs_dir") or ".codex-autorunner/runs")
-        max_total_turns = int(input_data.get("max_total_turns") or 25)
+        if not runs_dir.is_absolute():
+            runs_dir = (workspace_root / runs_dir).resolve()
+        max_total_turns = int(
+            input_data.get("max_total_turns") or DEFAULT_MAX_TOTAL_TURNS
+        )
         max_lint_retries = int(input_data.get("max_lint_retries") or 3)
         max_commit_retries = int(input_data.get("max_commit_retries") or 2)
+        max_network_retries = int(input_data.get("max_network_retries") or 5)
         auto_commit = bool(
             input_data.get("auto_commit") if "auto_commit" in input_data else True
         )
+        include_previous_ticket_context = bool(
+            input_data.get("include_previous_ticket_context")
+            if "include_previous_ticket_context" in input_data
+            else False
+        )
 
+        repo_id = _resolve_ticket_flow_repo_id(workspace_root)
         runner = TicketRunner(
             workspace_root=workspace_root,
             run_id=str(record.id),
@@ -49,9 +75,12 @@ def build_ticket_flow_definition(*, agent_pool: AgentPool) -> FlowDefinition:
                 max_total_turns=max_total_turns,
                 max_lint_retries=max_lint_retries,
                 max_commit_retries=max_commit_retries,
+                max_network_retries=max_network_retries,
                 auto_commit=auto_commit,
+                include_previous_ticket_context=include_previous_ticket_context,
             ),
             agent_pool=agent_pool,
+            repo_id=repo_id,
         )
 
         if emit_event is not None:
@@ -84,8 +113,28 @@ def build_ticket_flow_definition(*, agent_pool: AgentPool) -> FlowDefinition:
                 "max_total_turns": {"type": "integer"},
                 "max_lint_retries": {"type": "integer"},
                 "max_commit_retries": {"type": "integer"},
+                "max_network_retries": {"type": "integer"},
                 "auto_commit": {"type": "boolean"},
+                "include_previous_ticket_context": {"type": "boolean"},
             },
         },
         steps={"ticket_turn": _ticket_turn_step},
     )
+
+
+def _resolve_ticket_flow_repo_id(workspace_root: Path) -> str:
+    current = workspace_root
+    for _ in range(5):
+        manifest_path = current / ".codex-autorunner" / "manifest.yml"
+        if manifest_path.exists():
+            try:
+                manifest = load_manifest(manifest_path, current)
+            except ManifestError:
+                return ""
+            entry = manifest.get_by_path(current, workspace_root)
+            return entry.id if entry else ""
+        parent = current.parent
+        if parent == current:
+            break
+        current = parent
+    return ""

codex_autorunner/integrations/agents/__init__.py

@@ -1,27 +1,19 @@
-from .agent_backend import AgentBackend, AgentEvent, AgentEventType
+from .backend_orchestrator import build_backend_orchestrator
+from .codex_adapter import CodexAdapterOrchestrator
 from .codex_backend import CodexAppServerBackend
+from .opencode_adapter import OpenCodeAdapterOrchestrator
 from .opencode_backend import OpenCodeBackend
-from .run_event import (
-    ApprovalRequested,
-    Completed,
-    Failed,
-    OutputDelta,
-    RunEvent,
-    Started,
-    ToolCall,
+from .wiring import (
+    build_agent_backend_factory,
+    build_app_server_supervisor_factory,
 )
 
 __all__ = [
-    "AgentBackend",
-    "AgentEvent",
-    "AgentEventType",
+    "CodexAdapterOrchestrator",
     "CodexAppServerBackend",
+    "OpenCodeAdapterOrchestrator",
     "OpenCodeBackend",
-    "RunEvent",
-    "Started",
-    "OutputDelta",
-    "ToolCall",
-    "ApprovalRequested",
-    "Completed",
-    "Failed",
+    "build_agent_backend_factory",
+    "build_app_server_supervisor_factory",
+    "build_backend_orchestrator",
 ]

codex_autorunner/integrations/agents/backend_orchestrator.py

@@ -0,0 +1,302 @@
+"""
+Backend orchestrator that manages protocol-agnostic backend lifecycle.
+
+The orchestrator sits between the Engine and backend adapters, handling
+backend-specific concerns like supervisor management, event handling,
+and session/thread tracking while exposing a clean, protocol-neutral
+interface to the Engine.
+"""
+
+import asyncio
+import logging
+import threading
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, AsyncGenerator, Awaitable, Callable, Optional
+
+from ...core.app_server_threads import (
+    AppServerThreadRegistry,
+    default_app_server_threads_path,
+)
+from ...core.config import RepoConfig
+from ...core.ports.agent_backend import AgentBackend
+from ...core.ports.backend_orchestrator import (
+    BackendOrchestrator as BackendOrchestratorProtocol,
+)
+from ...core.ports.run_event import RunEvent
+from ...core.state import RunnerState
+from .codex_backend import CodexAppServerBackend
+from .opencode_backend import OpenCodeBackend
+from .wiring import AgentBackendFactory, BackendFactory
+
+NotificationHandler = Callable[[dict[str, Any]], Awaitable[None]]
+SessionIdGetter = Callable[[str], Optional[str]]
+SessionIdSetter = Callable[[str, str], None]
+
+
+@dataclass
+class BackendContext:
+    """Context for a backend run."""
+
+    agent_id: str
+    session_id: Optional[str]
+    turn_id: Optional[str]
+    thread_info: Optional[dict[str, Any]]
+
+
+class BackendOrchestrator:
+    """
+    Orchestrates backend operations, keeping Engine protocol-agnostic.
+
+    This class manages:
+    - Backend factory and lifecycle
+    - Backend-specific supervisors (Codex app server, OpenCode)
+    - Backend-specific event handling and notification routing
+    - Session/thread tracking for backends that support it
+    """
+
+    def __init__(
+        self,
+        repo_root: Path,
+        config: RepoConfig,
+        *,
+        notification_handler: Optional[NotificationHandler] = None,
+        logger: Optional[logging.Logger] = None,
+    ):
+        from .wiring import build_agent_backend_factory
+
+        self._repo_root = repo_root
+        self._config = config
+        self._logger = logger or logging.getLogger("codex_autorunner.backend")
+        self._notification_handler = notification_handler
+
+        # Backend factory manages creation and caching of backends
+        self._backend_factory: BackendFactory = build_agent_backend_factory(
+            repo_root, config
+        )
+
+        # Active backend for current run
+        self._active_backend: Optional[AgentBackend] = None
+
+        # Context tracking
+        self._context: Optional[BackendContext] = None
+
+        # Session registry for backend-specific session tracking
+        self._app_server_threads = AppServerThreadRegistry(
+            default_app_server_threads_path(repo_root)
+        )
+        self._app_server_threads_lock = threading.Lock()
+
+    async def get_backend(
+        self,
+        agent_id: str,
+        state: RunnerState,
+    ) -> AgentBackend:
+        """Get a backend instance for the given agent."""
+        backend = self._backend_factory(agent_id, state, self._notification_handler)
+        self._active_backend = backend
+        return backend
+
+    async def start_session(
+        self,
+        agent_id: str,
+        state: RunnerState,
+        session_id: Optional[str] = None,
+    ) -> str:
+        """
+        Start a backend session.
+
+        Returns the session/thread ID.
+        """
+        backend = await self.get_backend(agent_id, state)
+
+        context: dict[str, Any] = {"workspace": str(self._repo_root)}
+        if session_id:
+            context["session_id"] = session_id
+
+        target = {"workspace": str(self._repo_root)}
+
+        session = await backend.start_session(target, context)
+
+        # Track context
+        self._context = BackendContext(
+            agent_id=agent_id,
+            session_id=session,
+            turn_id=None,
+            thread_info=None,
+        )
+
+        return session
+
+    async def run_turn(
+        self,
+        agent_id: str,
+        state: RunnerState,
+        prompt: str,
+        *,
+        model: Optional[str] = None,
+        reasoning: Optional[str] = None,
+        session_key: Optional[str] = None,
+    ) -> AsyncGenerator[RunEvent, None]:
+        """
+        Run a turn on the backend.
+
+        Yields RunEvent objects.
+        """
+        reuse_session = bool(getattr(self._config, "autorunner_reuse_session", False))
+        session_id: Optional[str] = None
+        if reuse_session and session_key:
+            session_id = self.get_thread_id(session_key)
+        if reuse_session and session_id is None and self._context is not None:
+            session_id = self._context.session_id
+
+        session_id = await self.start_session(agent_id, state, session_id=session_id)
+        if reuse_session and session_key and session_id:
+            self.set_thread_id(session_key, session_id)
+
+        backend = self._active_backend
+        assert backend is not None, "backend should be initialized before run_turn"
+
+        # Configure backend if supported
+        if isinstance(backend, CodexAppServerBackend):
+            backend.configure(
+                approval_policy=state.autorunner_approval_policy or "never",
+                sandbox_policy=state.autorunner_sandbox_mode or "dangerFullAccess",
+                model=model,
+                reasoning_effort=reasoning,
+                turn_timeout_seconds=None,
+                notification_handler=self._notification_handler,
+            )
+        elif isinstance(backend, OpenCodeBackend):
+            backend.configure(
+                model=model,
+                reasoning=reasoning,
+                approval_policy=state.autorunner_approval_policy,
+            )
+
+        async for event in backend.run_turn_events(session_id, prompt):
+            yield event
+
+            # Update context from events
+            if hasattr(event, "session_id") and event.session_id:
+                if self._context:
+                    self._context.session_id = event.session_id
+
+    async def interrupt(self, agent_id: str, state: RunnerState) -> None:
+        """Interrupt the current backend session."""
+        if self._context and self._context.session_id:
+            backend = await self.get_backend(agent_id, state)
+            await backend.interrupt(self._context.session_id)
+
+    def get_context(self) -> Optional[BackendContext]:
+        """Get the current backend context."""
+        return self._context
+
+    def get_last_turn_id(self) -> Optional[str]:
+        """Get the last turn ID from the active backend."""
+        if self._active_backend:
+            return getattr(self._active_backend, "last_turn_id", None)
+        if self._context:
+            return self._context.turn_id
+        return None
+
+    def get_last_thread_info(self) -> Optional[dict[str, Any]]:
+        """Get the last thread info from the active backend."""
+        if self._active_backend:
+            return getattr(self._active_backend, "last_thread_info", None)
+        if self._context:
+            return self._context.thread_info
+        return None
+
+    def get_last_token_total(self) -> Optional[dict[str, Any]]:
+        """Get the last token total from the active backend."""
+        if self._active_backend:
+            return getattr(self._active_backend, "last_token_total", None)
+        return None
+
+    async def close_all(self) -> None:
+        """Close all backends and clean up resources."""
+        close_all = getattr(self._backend_factory, "close_all", None)
+        if close_all:
+            result = close_all()
+            if asyncio.iscoroutine(result):
+                await result
+        self._active_backend = None
+        self._context = None
+
+    def update_context(
+        self,
+        *,
+        turn_id: Optional[str] = None,
+        thread_info: Optional[dict[str, Any]] = None,
+    ) -> None:
+        """Update the backend context with new information."""
+        if self._context:
+            if turn_id:
+                self._context.turn_id = turn_id
+            if thread_info:
+                self._context.thread_info = thread_info
+
+    def get_thread_id(self, session_key: str) -> Optional[str]:
+        """Get the thread ID for a given session key."""
+        with self._app_server_threads_lock:
+            return self._app_server_threads.get_thread_id(session_key)
+
+    def set_thread_id(self, session_key: str, thread_id: str) -> None:
+        """Set the thread ID for a given session key."""
+        with self._app_server_threads_lock:
+            self._app_server_threads.set_thread_id(session_key, thread_id)
+
+    def _agent_backend_factory(self) -> Optional[AgentBackendFactory]:
+        if isinstance(self._backend_factory, AgentBackendFactory):
+            return self._backend_factory
+        return None
+
+    def ensure_opencode_supervisor(self) -> Optional[Any]:
+        """
+        Ensure OpenCode supervisor exists.
+
+        This method delegates to the backend factory for supervisor management,
+        keeping Engine protocol-agnostic.
+        """
+        factory = self._agent_backend_factory()
+        if factory is not None:
+            return factory._ensure_opencode_supervisor()
+        return None
+
+    def build_app_server_supervisor(
+        self, *, event_prefix: str, notification_handler: Optional[NotificationHandler]
+    ) -> Optional[Any]:
+        """
+        Build a Codex app server supervisor factory.
+
+        This method centralizes backend-specific supervisor creation, keeping
+        Engine protocol-agnostic.
+        """
+        from .wiring import build_app_server_supervisor_factory
+
+        factory_fn = build_app_server_supervisor_factory(
+            self._config, logger=self._logger
+        )
+        return factory_fn(event_prefix, notification_handler)
+
+
+def build_backend_orchestrator(
+    repo_root: Path, config: RepoConfig
+) -> BackendOrchestratorProtocol:
+    """
+    Build a BackendOrchestrator for protocol-agnostic backend management.
+    """
+    return BackendOrchestrator(
+        repo_root=repo_root,
+        config=config,
+        notification_handler=None,
+        logger=logging.getLogger("codex_autorunner.backend"),
+    )
+
+
+__all__ = [
+    "BackendOrchestrator",
+    "BackendContext",
+    "build_backend_orchestrator",
+]