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

codex_autorunner/surfaces/web/schemas.py

@@ -86,6 +86,17 @@ class ArchiveSnapshotDetailResponse(ResponseModel):
     meta: Optional[Dict[str, Any]] = None
 
 
+class LocalRunArchiveSummary(ResponseModel):
+    run_id: str
+    archived_at: Optional[str] = None
+    has_tickets: bool = False
+    has_runs: bool = False
+
+
+class LocalRunArchivesResponse(ResponseModel):
+    archives: List[LocalRunArchiveSummary]
+
+
 class ArchiveTreeNode(ResponseModel):
     path: str
     name: str
@@ -198,6 +209,76 @@ class SessionStopRequest(Payload):
     repo_path: Optional[str] = None
 
 
+class TemplateRepoSummary(ResponseModel):
+    id: str
+    url: str
+    trusted: bool
+    default_ref: str
+
+
+class TemplateReposResponse(ResponseModel):
+    enabled: bool
+    repos: List[TemplateRepoSummary]
+
+
+class TemplateRepoCreateRequest(Payload):
+    id: str
+    url: str
+    trusted: bool = False
+    default_ref: str = Field(
+        default="main", validation_alias=AliasChoices("default_ref", "defaultRef")
+    )
+
+
+class TemplateRepoUpdateRequest(Payload):
+    url: Optional[str] = None
+    trusted: Optional[bool] = None
+    default_ref: Optional[str] = Field(
+        default=None, validation_alias=AliasChoices("default_ref", "defaultRef")
+    )
+
+
+class TemplateFetchRequest(Payload):
+    template: str
+
+
+class TemplateFetchResponse(ResponseModel):
+    content: str
+    repo_id: str
+    path: str
+    ref: str
+    commit_sha: str
+    blob_sha: str
+    trusted: bool
+    scan_decision: Optional[Dict[str, Any]] = None
+
+
+class TemplateApplyRequest(Payload):
+    template: str
+    ticket_dir: Optional[str] = Field(
+        default=None, validation_alias=AliasChoices("ticket_dir", "ticketDir")
+    )
+    at: Optional[int] = None
+    next_index: bool = Field(
+        default=True, validation_alias=AliasChoices("next_index", "nextIndex")
+    )
+    suffix: Optional[str] = None
+    set_agent: Optional[str] = Field(
+        default=None, validation_alias=AliasChoices("set_agent", "setAgent")
+    )
+    include_provenance: bool = Field(
+        default=False,
+        validation_alias=AliasChoices("include_provenance", "includeProvenance"),
+    )
+
+
+class TemplateApplyResponse(ResponseModel):
+    created_path: str
+    index: int
+    filename: str
+    metadata: Dict[str, Any]
+
+
 class SystemUpdateRequest(Payload):
     target: Optional[str] = None
 
@@ -213,24 +294,6 @@ class HubJobResponse(ResponseModel):
     error: Optional[str]
 
 
-class StateResponse(ResponseModel):
-    last_run_id: Optional[int]
-    status: str
-    last_exit_code: Optional[int]
-    last_run_started_at: Optional[str]
-    last_run_finished_at: Optional[str]
-    outstanding_count: int
-    done_count: int
-    running: bool
-    runner_pid: Optional[int]
-    lock_present: bool
-    lock_pid: Optional[int]
-    lock_freeable: bool
-    lock_freeable_reason: Optional[str]
-    terminal_idle_timeout_seconds: Optional[int]
-    codex_model: str
-
-
 class SessionSettingsResponse(ResponseModel):
     autorunner_model_override: Optional[str]
     autorunner_effort_override: Optional[str]

codex_autorunner/tickets/agent_pool.py

@@ -30,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)
@@ -179,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,
         )
@@ -249,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
@@ -300,9 +318,18 @@ class AgentPool:
             if not session_id:
                 raise RuntimeError("OpenCode create_session returned no session id")
 
+        # 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
 

codex_autorunner/tickets/files.py

@@ -1,26 +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
 
-# 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 list_ticket_paths(ticket_dir: Path) -> list[Path]:
     if not ticket_dir.exists() or not ticket_dir.is_dir():
@@ -87,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

@@ -75,10 +75,13 @@ class TicketRunConfig:
     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:
@@ -117,7 +136,8 @@ def create_turn_summary(
         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
+        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.
@@ -133,8 +153,8 @@ def create_turn_summary(
         extra["agent_id"] = agent_id
     if turn_number is not None:
         extra["turn_number"] = turn_number
-    if diff_stats:
-        extra["diff_stats"] = diff_stats
+    # 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(
@@ -175,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>/.
 
@@ -233,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,