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

codex_autorunner/tickets/agent_pool.py

@@ -5,7 +5,8 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Callable, Optional, cast
 
-from ..agents.opencode.runtime import collect_opencode_output
+from ..agents.opencode.constants import DEFAULT_TICKET_MODEL
+from ..agents.opencode.runtime import collect_opencode_output, split_model_id
 from ..agents.opencode.supervisor import OpenCodeSupervisor
 from ..core.config import RepoConfig
 from ..core.flows.models import FlowEventType
@@ -29,6 +30,10 @@ class AgentTurnRequest:
     options: Optional[dict[str, Any]] = None
     # Optional flow event emitter (for live streaming).
     emit_event: Optional[EmitEventFn] = None
+    # Optional list of additional messages to send in the same turn.
+    # Each message is a dict with a "text" field. Agents that support
+    # multiple messages will receive all of them; others may queue them.
+    additional_messages: Optional[list[dict[str, Any]]] = None
 
 
 @dataclass(frozen=True)
@@ -178,6 +183,7 @@ class AgentPool:
             max_handles=app_server_cfg.max_handles,
             idle_ttl_seconds=app_server_cfg.idle_ttl_seconds,
             session_stall_timeout_seconds=self._config.opencode.session_stall_timeout_seconds,
+            max_text_chars=self._config.opencode.max_text_chars,
             base_env=None,
             subagent_models=subagent_models,
         )
@@ -185,8 +191,8 @@ class AgentPool:
             raise RuntimeError(
                 "OpenCode supervisor unavailable (missing opencode command/binary)."
             )
-        self._opencode_supervisor = supervisor
-        return supervisor
+        self._opencode_supervisor = cast(OpenCodeSupervisor, supervisor)
+        return self._opencode_supervisor
 
     async def close(self) -> None:
         if self._app_server_supervisor is not None:
@@ -248,6 +254,19 @@ class AgentPool:
                 turn_kwargs["model"] = req.options["model"]
             if req.options.get("reasoning"):
                 turn_kwargs["effort"] = req.options["reasoning"]
+
+        # Build input items - main prompt plus any additional messages
+        input_items: Optional[list[dict[str, Any]]] = None
+        if req.additional_messages:
+            input_items = [{"type": "text", "text": req.prompt}]
+            for msg in req.additional_messages:
+                if isinstance(msg, dict):
+                    text = msg.get("text", "")
+                    if text and text.strip():
+                        input_items.append({"type": "text", "text": text})
+        if input_items:
+            turn_kwargs["input_items"] = input_items
+
         turn_handle = await client.turn_start(thread_id, req.prompt, **turn_kwargs)
         if req.emit_event is not None:
             self._active_emitters[turn_handle.turn_id] = req.emit_event
@@ -274,6 +293,24 @@ class AgentPool:
         client = handle
         directory = str(req.workspace_root)
 
+        options = req.options if isinstance(req.options, dict) else {}
+        model_raw = options.get("model")
+        model_payload = None
+        if isinstance(model_raw, dict):
+            provider_id = model_raw.get("providerID") or model_raw.get("providerId")
+            model_id = model_raw.get("modelID") or model_raw.get("modelId")
+            if provider_id and model_id:
+                model_payload = {"providerID": provider_id, "modelID": model_id}
+        elif isinstance(model_raw, str) and model_raw.strip():
+            model_payload = split_model_id(model_raw.strip())
+        if model_payload is None:
+            model_payload = split_model_id(DEFAULT_TICKET_MODEL)
+
+        variant = None
+        reasoning_raw = options.get("reasoning")
+        if isinstance(reasoning_raw, str) and reasoning_raw.strip():
+            variant = reasoning_raw.strip()
+
         session_id = req.conversation_id
         if not session_id:
             created = await client.create_session(title="ticket", directory=directory)
@@ -281,7 +318,18 @@ class AgentPool:
             if not session_id:
                 raise RuntimeError("OpenCode create_session returned no session id")
 
-        prompt_response = await client.prompt_async(session_id, message=req.prompt)
+        # Send main prompt and any additional messages
+        # OpenCode processes messages sequentially; agents that queue will handle them
+        prompt_response = await client.prompt_async(
+            session_id, message=req.prompt, model=model_payload, variant=variant
+        )
+        if req.additional_messages:
+            for msg in req.additional_messages:
+                text = msg.get("text", "") if isinstance(msg, dict) else ""
+                if text and text.strip():
+                    await client.prompt_async(
+                        session_id, message=text, model=model_payload, variant=variant
+                    )
 
         import uuid
 
@@ -340,6 +388,7 @@ class AgentPool:
             client,
             session_id=session_id,
             workspace_path=directory,
+            model_payload=model_payload,
             part_handler=_part_handler if req.emit_event is not None else None,
         )
 

codex_autorunner/tickets/files.py

@@ -1,25 +1,12 @@
 from __future__ import annotations
 
-import re
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 from typing import Optional
 
 from .frontmatter import parse_markdown_frontmatter
-from .lint import lint_ticket_frontmatter
+from .lint import lint_ticket_frontmatter, parse_ticket_index
 from .models import TicketDoc, TicketFrontmatter
 
-_TICKET_NAME_RE = re.compile(r"^TICKET-(\d+)\.md$", re.IGNORECASE)
-
-
-def parse_ticket_index(name: str) -> Optional[int]:
-    match = _TICKET_NAME_RE.match(name)
-    if not match:
-        return None
-    try:
-        return int(match.group(1))
-    except ValueError:
-        return None
-
 
 def list_ticket_paths(ticket_dir: Path) -> list[Path]:
     if not ticket_dir.exists() or not ticket_dir.is_dir():
@@ -51,11 +38,14 @@ def read_ticket(path: Path) -> tuple[Optional[TicketDoc], list[str]]:
     data, body = parse_markdown_frontmatter(raw)
     idx = parse_ticket_index(path.name)
     if idx is None:
-        return None, ["Invalid ticket filename; expected TICKET-<number>.md"]
+        return None, [
+            "Invalid ticket filename; expected TICKET-<number>[suffix].md (e.g. TICKET-001-foo.md)"
+        ]
 
     frontmatter, errors = lint_ticket_frontmatter(data)
     if errors:
         return None, errors
+    assert frontmatter is not None
     return TicketDoc(path=path, index=idx, frontmatter=frontmatter, body=body), []
 
 
@@ -83,3 +73,34 @@ def safe_relpath(path: Path, root: Path) -> str:
         return str(path.relative_to(root))
     except ValueError:
         return str(path)
+
+
+def normalize_ticket_dir(repo_root: Path, ticket_dir: Optional[str]) -> Path:
+    """Normalize a user-supplied ticket directory and ensure it stays in-tree."""
+
+    base = (repo_root / ".codex-autorunner").resolve(strict=False)
+    if not ticket_dir:
+        return base / "tickets"
+
+    cleaned = str(ticket_dir).strip()
+    if not cleaned:
+        return base / "tickets"
+    if "\\" in cleaned:
+        raise ValueError("Ticket directory may not include backslashes.")
+
+    raw_path = Path(cleaned)
+    if raw_path.is_absolute():
+        candidate = raw_path.resolve(strict=False)
+    else:
+        relative = PurePosixPath(cleaned)
+        if relative.is_absolute() or ".." in relative.parts:
+            raise ValueError("Ticket directory must be a relative path.")
+        candidate = (repo_root / relative).resolve(strict=False)
+
+    try:
+        candidate.relative_to(base)
+    except ValueError:
+        raise ValueError(
+            "Ticket directory must live under .codex-autorunner."
+        ) from None
+    return candidate

codex_autorunner/tickets/lint.py

@@ -1,10 +1,26 @@
 from __future__ import annotations
 
+import re
+from collections import defaultdict
+from pathlib import Path
 from typing import Any, Optional, Tuple
 
 from ..agents.registry import validate_agent_id
 from .models import TicketFrontmatter
 
+# Accept TICKET-###.md or TICKET-###<suffix>.md (suffix optional), case-insensitive.
+_TICKET_NAME_RE = re.compile(r"^TICKET-(\d{3,})(?:[^/]*)\.md$", re.IGNORECASE)
+
+
+def parse_ticket_index(name: str) -> Optional[int]:
+    match = _TICKET_NAME_RE.match(name)
+    if not match:
+        return None
+    try:
+        return int(match.group(1))
+    except ValueError:
+        return None
+
 
 def _as_optional_str(value: Any) -> Optional[str]:
     if isinstance(value, str):
@@ -100,3 +116,37 @@ def lint_dispatch_frontmatter(
     normalized = dict(data)
     normalized["mode"] = mode
     return normalized, errors
+
+
+def lint_ticket_directory(ticket_dir: Path) -> list[str]:
+    """Validate ticket directory for duplicate indices.
+
+    Returns a list of error messages (empty if valid).
+
+    This check ensures that ticket indices are unique across all ticket files.
+    Duplicate indices lead to non-deterministic ordering and confusing behavior.
+    """
+
+    if not ticket_dir.exists() or not ticket_dir.is_dir():
+        return []
+
+    errors: list[str] = []
+    index_to_paths: dict[int, list[str]] = defaultdict(list)
+
+    for path in ticket_dir.iterdir():
+        if not path.is_file():
+            continue
+        idx = parse_ticket_index(path.name)
+        if idx is None:
+            continue
+        index_to_paths[idx].append(path.name)
+
+    for idx, filenames in index_to_paths.items():
+        if len(filenames) > 1:
+            filenames_str = ", ".join([f"'{f}'" for f in filenames])
+            errors.append(
+                f"Duplicate ticket index {idx:03d}: multiple files share the same index ({filenames_str}). "
+                "Rename or remove duplicates to ensure deterministic ordering."
+            )
+
+    return errors

codex_autorunner/tickets/models.py

@@ -4,6 +4,8 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Optional
 
+DEFAULT_MAX_TOTAL_TURNS = 50
+
 
 @dataclass(frozen=True)
 class TicketFrontmatter:
@@ -70,13 +72,16 @@ class DispatchRecord:
 class TicketRunConfig:
     ticket_dir: Path
     runs_dir: Path
-    max_total_turns: int = 25
+    max_total_turns: int = DEFAULT_MAX_TOTAL_TURNS
     max_lint_retries: int = 3
     max_commit_retries: int = 2
+    max_network_retries: int = 5
     auto_commit: bool = True
+    prompt_max_bytes: int = 5 * 1024 * 1024  # 5 MB default budget
     checkpoint_message_template: str = (
         "CAR checkpoint: run={run_id} turn={turn} agent={agent}"
     )
+    include_previous_ticket_context: bool = False
 
 
 @dataclass(frozen=True)

codex_autorunner/tickets/outbox.py

@@ -3,12 +3,31 @@ from __future__ import annotations
 import shutil
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Optional
+from typing import Any, Callable, Dict, Optional
 
 from .frontmatter import parse_markdown_frontmatter
 from .lint import lint_dispatch_frontmatter
 from .models import Dispatch, DispatchRecord
 
+_lifecycle_emitter: Optional[Callable[[str, str, str, Dict[str, Any]], None]] = None
+
+
+def set_lifecycle_emitter(
+    emitter: Optional[Callable[[str, str, str, Dict[str, Any]], None]],
+) -> None:
+    global _lifecycle_emitter
+    _lifecycle_emitter = emitter
+
+
+def _emit_lifecycle(
+    event_type: str, repo_id: str, run_id: str, data: Dict[str, Any]
+) -> None:
+    if _lifecycle_emitter:
+        try:
+            _lifecycle_emitter(event_type, repo_id, run_id, data)
+        except Exception:
+            pass
+
 
 @dataclass(frozen=True)
 class OutboxPaths:
@@ -103,12 +122,23 @@ def create_turn_summary(
     ticket_id: Optional[str] = None,
     agent_id: Optional[str] = None,
     turn_number: Optional[int] = None,
+    diff_stats: Optional[dict] = None,
 ) -> tuple[Optional[DispatchRecord], list[str]]:
     """Create a turn summary dispatch record for the agent's final output.
 
     This creates a synthetic dispatch with mode="turn_summary" to show
     the agent's final turn output in the dispatch history panel.
 
+    Args:
+        paths: Outbox paths for the run
+        next_seq: Sequence number for this dispatch
+        agent_output: The agent's output text
+        ticket_id: Optional ticket ID for context
+        agent_id: Optional agent ID (e.g., "codex", "opencode")
+        turn_number: Optional turn number
+        diff_stats: Optional dict with insertions/deletions/files_changed.
+            Deprecated: diff stats are now stored as FlowStore DIFF_UPDATED events.
+
     Returns (DispatchRecord, []) on success.
     Returns (None, errors) on failure.
     """
@@ -123,6 +153,8 @@ def create_turn_summary(
         extra["agent_id"] = agent_id
     if turn_number is not None:
         extra["turn_number"] = turn_number
+    # NOTE: diff_stats is intentionally not persisted into DISPATCH.md frontmatter.
+    # It is stored as structured FlowStore DIFF_UPDATED events instead.
     extra["is_turn_summary"] = True
 
     dispatch = Dispatch(
@@ -163,8 +195,10 @@ def archive_dispatch(
     *,
     next_seq: int,
     ticket_id: Optional[str] = None,
+    repo_id: str = "",
+    run_id: str = "",
 ) -> tuple[Optional[DispatchRecord], list[str]]:
-    """Archive the current dispatch and attachments to the dispatch history.
+    """Archive current dispatch and attachments to dispatch history.
 
     Moves DISPATCH.md + attachments into dispatch_history/<seq>/.
 
@@ -221,6 +255,20 @@ def archive_dispatch(
         pass
     _delete_dispatch_items(items)
 
+    # Emit lifecycle event for dispatch creation
+    if run_id:
+        _emit_lifecycle(
+            "dispatch_created",
+            repo_id,
+            run_id,
+            {
+                "seq": next_seq,
+                "mode": dispatch.mode,
+                "title": dispatch.title,
+                "ticket_id": ticket_id,
+            },
+        )
+
     return (
         DispatchRecord(
             seq=next_seq,