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

codex_autorunner/tickets/runner.py

@@ -10,7 +10,7 @@ from ..workspace.paths import workspace_doc_path
 from .agent_pool import AgentPool, AgentTurnRequest
 from .files import list_ticket_paths, read_ticket, safe_relpath, ticket_is_done
 from .frontmatter import parse_markdown_frontmatter
-from .lint import lint_ticket_frontmatter
+from .lint import lint_ticket_directory, lint_ticket_frontmatter
 from .models import TicketFrontmatter, TicketResult, TicketRunConfig
 from .outbox import (
     archive_dispatch,
@@ -18,11 +18,154 @@ from .outbox import (
     ensure_outbox_dirs,
     resolve_outbox_paths,
 )
-from .replies import ensure_reply_dirs, parse_user_reply, resolve_reply_paths
+from .replies import (
+    dispatch_reply,
+    ensure_reply_dirs,
+    next_reply_seq,
+    parse_user_reply,
+    resolve_reply_paths,
+)
 
 _logger = logging.getLogger(__name__)
 
 WORKSPACE_DOC_MAX_CHARS = 4000
+TRUNCATION_MARKER = "\n\n[... TRUNCATED ...]\n\n"
+
+
+def _truncate_text_by_bytes(text: str, max_bytes: int) -> str:
+    """Truncate text to fit within max_bytes UTF-8 encoded size."""
+    if max_bytes <= 0:
+        return ""
+    normalized = text or ""
+    encoded = normalized.encode("utf-8")
+    if len(encoded) <= max_bytes:
+        return normalized
+    marker_bytes = len(TRUNCATION_MARKER.encode("utf-8"))
+    if max_bytes <= marker_bytes:
+        return TRUNCATION_MARKER.encode("utf-8")[:max_bytes].decode(
+            "utf-8", errors="ignore"
+        )
+    target_bytes = max_bytes - marker_bytes
+    truncated = encoded[:target_bytes].decode("utf-8", errors="ignore")
+    return truncated + TRUNCATION_MARKER
+
+
+def _is_network_error(error_message: str) -> bool:
+    """Check if an error message indicates a transient network issue.
+
+    Returns True if the error appears to be network-related and retryable.
+    This includes connection errors, timeouts, and transport failures.
+    """
+    if not error_message:
+        return False
+    error_lower = error_message.lower()
+    network_indicators = [
+        "network error",
+        "connection",
+        "timeout",
+        "transport error",
+        "disconnected",
+        "unreachable",
+        "reconnecting",
+        "connection refused",
+        "connection reset",
+        "connection broken",
+        "temporary failure",
+    ]
+    return any(indicator in error_lower for indicator in network_indicators)
+
+
+def _preserve_ticket_structure(ticket_block: str, max_bytes: int) -> str:
+    """Truncate ticket block while preserving prefix and ticket frontmatter.
+
+    ticket_block format:
+        "\\n\\n<CAR_CURRENT_TICKET_FILE>\\nPATH: ...\\n<TICKET_MARKDOWN>\\n"
+        "{ticket_raw_content}\\n</TICKET_MARKDOWN>\\n</CAR_CURRENT_TICKET_FILE>\\n"
+    where ticket_raw_content itself contains markdown frontmatter.
+    """
+    if len(ticket_block.encode("utf-8")) <= max_bytes:
+        return ticket_block
+
+    # ticket_block structure:
+    #   "<CAR_CURRENT_TICKET_FILE>\n"
+    #   "PATH: {rel_ticket}\n"
+    #   "<TICKET_MARKDOWN>\n"
+    #   "---\n" - ticket frontmatter start
+    #   "agent: ...\n"
+    #   "done: ...\n"
+    #   "title: ...\n"
+    #   "goal: ...\n"
+    #   "---\n" - ticket frontmatter end (what we want to preserve)
+    #   ticket body...
+    #   "</TICKET_MARKDOWN>\n"
+    #   "</CAR_CURRENT_TICKET_FILE>\n"
+
+    # Find the frontmatter markers after <TICKET_MARKDOWN>.
+    marker = "\n---\n"
+    ticket_md_idx = ticket_block.find("<TICKET_MARKDOWN>")
+    if ticket_md_idx == -1:
+        return _truncate_text_by_bytes(ticket_block, max_bytes)
+
+    first_marker_idx = ticket_block.find(marker, ticket_md_idx)
+    if first_marker_idx == -1:
+        return _truncate_text_by_bytes(ticket_block, max_bytes)
+
+    second_marker_idx = ticket_block.find(marker, first_marker_idx + 1)
+    if second_marker_idx == -1:
+        return _truncate_text_by_bytes(ticket_block, max_bytes)
+
+    # Preserve everything up to and including the second marker
+    preserve_end = second_marker_idx + len(marker)
+    preserved_part = ticket_block[:preserve_end]
+
+    # Check if we still have room (account for truncation marker that will be added)
+    preserved_bytes = len(preserved_part.encode("utf-8"))
+    marker_bytes = len(TRUNCATION_MARKER.encode("utf-8"))
+    remaining_bytes = max(max_bytes - preserved_bytes, 0)
+
+    if remaining_bytes > 0:
+        body = ticket_block[preserve_end:]
+        # Account for marker in the body budget
+        body_budget = max(remaining_bytes - marker_bytes, 0)
+        truncated_body = _truncate_text_by_bytes(body, body_budget)
+        return preserved_part + truncated_body
+
+    # Not enough room even for preserved part, fall back to simple truncation
+    return _truncate_text_by_bytes(ticket_block, max_bytes)
+
+
+def _shrink_prompt(
+    *,
+    max_bytes: int,
+    render: Callable[[], str],
+    sections: dict[str, str],
+    order: list[str],
+) -> str:
+    """Shrink prompt by truncating sections in order of priority."""
+    prompt = render()
+    if len(prompt.encode("utf-8")) <= max_bytes:
+        return prompt
+
+    for key in order:
+        if len(prompt.encode("utf-8")) <= max_bytes:
+            break
+        value = sections.get(key, "")
+        if not value:
+            continue
+        overflow = len(prompt.encode("utf-8")) - max_bytes
+        value_bytes = len(value.encode("utf-8"))
+        new_limit = max(value_bytes - overflow, 0)
+
+        if key == "ticket_block":
+            sections[key] = _preserve_ticket_structure(value, new_limit)
+        else:
+            sections[key] = _truncate_text_by_bytes(value, new_limit)
+        prompt = render()
+
+    if len(prompt.encode("utf-8")) > max_bytes:
+        prompt = _truncate_text_by_bytes(prompt, max_bytes)
+
+    return prompt
 
 
 class TicketRunner:
@@ -41,11 +184,13 @@ class TicketRunner:
         run_id: str,
         config: TicketRunConfig,
         agent_pool: AgentPool,
+        repo_id: str = "",
     ):
         self._workspace_root = workspace_root
         self._run_id = run_id
         self._config = config
         self._agent_pool = agent_pool
+        self._repo_id = repo_id
 
     async def step(
         self,
@@ -73,11 +218,17 @@ class TicketRunner:
         commit_retries = int(commit_state.get("retries") or 0)
         # Global counters.
         total_turns = int(state.get("total_turns") or 0)
+
+        _network_raw = state.get("network_retry")
+        network_retry_state: dict[str, Any] = (
+            _network_raw if isinstance(_network_raw, dict) else {}
+        )
+        network_retries = int(network_retry_state.get("retries") or 0)
         if total_turns >= self._config.max_total_turns:
             return self._pause(
                 state,
                 reason=f"Max turns reached ({self._config.max_total_turns}). Review tickets and resume.",
-                reason_code="needs_user_fix",
+                reason_code="max_turns",
             )
 
         ticket_dir = self._workspace_root / self._config.ticket_dir
@@ -98,6 +249,23 @@ class TicketRunner:
             run_id=self._run_id,
         )
         ensure_reply_dirs(reply_paths)
+        if reply_paths.user_reply_path.exists():
+            next_seq = next_reply_seq(reply_paths.reply_history_dir)
+            archived, errors = dispatch_reply(reply_paths, next_seq=next_seq)
+            if errors:
+                return self._pause(
+                    state,
+                    reason="Failed to archive USER_REPLY.md.",
+                    reason_details="Errors:\n- " + "\n- ".join(errors),
+                    reason_code="needs_user_fix",
+                )
+            if archived is None:
+                return self._pause(
+                    state,
+                    reason="Failed to archive USER_REPLY.md.",
+                    reason_details="Errors:\n- Failed to archive reply",
+                    reason_code="needs_user_fix",
+                )
 
         ticket_paths = list_ticket_paths(ticket_dir)
         if not ticket_paths:
@@ -110,6 +278,16 @@ class TicketRunner:
                 reason_code="no_tickets",
             )
 
+        # Check for duplicate ticket indices before proceeding.
+        dir_lint_errors = lint_ticket_directory(ticket_dir)
+        if dir_lint_errors:
+            return self._pause(
+                state,
+                reason="Duplicate ticket indices detected.",
+                reason_details="Errors:\n- " + "\n- ".join(dir_lint_errors),
+                reason_code="needs_user_fix",
+            )
+
         current_ticket = state.get("current_ticket")
         current_path: Optional[Path] = (
             (self._workspace_root / current_ticket)
@@ -266,14 +444,18 @@ class TicketRunner:
         )
 
         previous_ticket_content: Optional[str] = None
-        try:
-            if current_path in ticket_paths:
-                curr_idx = ticket_paths.index(current_path)
-                if curr_idx > 0:
-                    prev_path = ticket_paths[curr_idx - 1]
-                    previous_ticket_content = prev_path.read_text(encoding="utf-8")
-        except Exception:
-            pass
+        if self._config.include_previous_ticket_context:
+            try:
+                if current_path in ticket_paths:
+                    curr_idx = ticket_paths.index(current_path)
+                    if curr_idx > 0:
+                        prev_path = ticket_paths[curr_idx - 1]
+                        content = prev_path.read_text(encoding="utf-8")
+                        previous_ticket_content = _truncate_text_by_bytes(
+                            content, 16384
+                        )
+            except Exception:
+                pass
 
         prompt = self._build_prompt(
             ticket_path=current_path,
@@ -333,6 +515,31 @@ class TicketRunner:
             state["last_agent_id"] = result.agent_id
             state["last_agent_conversation_id"] = result.conversation_id
             state["last_agent_turn_id"] = result.turn_id
+
+            # Check if this is a network error that should be retried
+            if _is_network_error(result.error):
+                network_retries += 1
+                if network_retries <= self._config.max_network_retries:
+                    state["network_retry"] = {
+                        "retries": network_retries,
+                        "last_error": result.error,
+                    }
+                    return TicketResult(
+                        status="continue",
+                        state=state,
+                        reason=(
+                            f"Network error detected (attempt {network_retries}/{self._config.max_network_retries}): {result.error}\n"
+                            "Retrying automatically..."
+                        ),
+                        current_ticket=safe_relpath(current_path, self._workspace_root),
+                        agent_output=result.text,
+                        agent_id=result.agent_id,
+                        agent_conversation_id=result.conversation_id,
+                        agent_turn_id=result.turn_id,
+                    )
+
+            # Not a network error or retries exhausted - pause for user intervention
+            state.pop("network_retry", None)
             return self._pause(
                 state,
                 reason="Agent turn failed. Fix the issue and resume.",
@@ -345,6 +552,8 @@ class TicketRunner:
         if reply_max_seq > reply_seq:
             state["reply_seq"] = reply_max_seq
         state["last_agent_output"] = result.text
+        # Clear network retry state on successful turn
+        state.pop("network_retry", None)
         state["last_agent_id"] = result.agent_id
         state["last_agent_conversation_id"] = result.conversation_id
         state["last_agent_turn_id"] = result.turn_id
@@ -377,7 +586,11 @@ class TicketRunner:
         dispatch_seq = int(state.get("dispatch_seq") or 0)
         current_ticket_id = safe_relpath(current_path, self._workspace_root)
         dispatch, dispatch_errors = archive_dispatch(
-            outbox_paths, next_seq=dispatch_seq + 1, ticket_id=current_ticket_id
+            outbox_paths,
+            next_seq=dispatch_seq + 1,
+            ticket_id=current_ticket_id,
+            repo_id=self._repo_id,
+            run_id=self._run_id,
         )
         if dispatch_errors:
             # Treat as pause: user should fix DISPATCH.md frontmatter. Keep outbox
@@ -429,6 +642,26 @@ class TicketRunner:
         if turn_summary is not None:
             state["dispatch_seq"] = turn_summary.seq
 
+            # Persist per-turn diff stats in FlowStore as a structured event
+            # instead of embedding them into DISPATCH.md metadata.
+            if emit_event is not None and isinstance(turn_diff_stats, dict):
+                try:
+                    emit_event(
+                        FlowEventType.DIFF_UPDATED,
+                        {
+                            "ticket_id": current_ticket_id,
+                            "dispatch_seq": turn_summary.seq,
+                            "insertions": int(turn_diff_stats.get("insertions") or 0),
+                            "deletions": int(turn_diff_stats.get("deletions") or 0),
+                            "files_changed": int(
+                                turn_diff_stats.get("files_changed") or 0
+                            ),
+                        },
+                    )
+                except Exception:
+                    # Best-effort; do not block ticket execution on event emission.
+                    pass
+
         # Post-turn: ticket frontmatter must remain valid.
         updated_fm, fm_errors = self._recheck_ticket_frontmatter(current_path)
         if fm_errors:
@@ -751,68 +984,41 @@ class TicketRunner:
             outbox_paths.dispatch_path, self._workspace_root
         )
 
-        header = (
-            "You are running inside Codex AutoRunner (CAR) in a ticket-based workflow.\n"
-            "Complete the current ticket by making changes in the repo.\n\n"
-            "How to operate within CAR:\n"
-            f"- Current ticket file: {rel_ticket}\n"
-            "- Ticket completion is controlled by YAML frontmatter: set 'done: true' when finished.\n"
-            "- To message the user, optionally write attachments first to the dispatch directory, then write DISPATCH.md last.\n"
-            f"  - Dispatch directory: {rel_dispatch_dir}\n"
-            f"  - DISPATCH.md path: {rel_dispatch_path}\n"
-            "    DISPATCH.md frontmatter supports: mode: notify|pause (pause will wait for a user response; notify will continue without waiting for user input).\n"
-            "    Example: `---\\nmode: pause\\n---\\nNeed clarification on X before proceeding.`\n"
-            "- No need to dispatch a final notification to the user; your final turn summary is dispatched automatically. Only dispatch if you want something important to stand out to the user, or if you need their input (pause).\n"
-            "- If you are completely blocked (missing info, unclear requirements, external dependency), dispatch with mode: pause immediately rather than guessing.\n"
-            "- You may create new tickets only if blocking the current SPEC or if the current ticket is too ambiguous and you want to scope it out further. Keep tickets minimal and avoid scope creep.\n"
-            "- Avoid stubs, TODOs, or placeholder logic. Either implement fully, create a follow-up ticket, or pause for user input.\n"
-            "- Only set 'done: true' when the ticket is truly complete. If partially done, update the ticket body with progress so the next agent can continue.\n"
-            "- Each ticket is handled by a new series of agents in a loop, where each new agent gets the context of the previous agent. No context is shared across tickets EXCEPT via the workspace files.\n"
-            "- You may update or add new workspace docs and add files under `.codex-autorunner/workspace/` to leave context for future agents.\n"
-            "- active_context and spec are ALWAYS passed to each agent and should be considered the most precious context.\n"
-            "- decisions.md: can contain conditional decision context that many only be relevant to some tickets.\n"
-            "- If you create new documents that future agents should reference, modify their tickets and leave a pointer to your new files.\n"
-            "- All files and folders under `.codex-autorunner/workspace/` are viewable and editable by the user. If you need the user's input on something, make sure it's in the workspace including copies of any artifacts they should review.\n"
-            "- Do NOT add any files under `.codex-autorunner/` to git unless they are already tracked and not gitignored."
-        )
-
         checkpoint_block = ""
         if last_checkpoint_error:
             checkpoint_block = (
-                "\n\n---\n\n"
+                "<CAR_CHECKPOINT_WARNING>\n"
                 "WARNING: The previous checkpoint git commit failed (often due to pre-commit hooks).\n"
                 "Resolve this before proceeding, or future turns may fail to checkpoint.\n\n"
                 "Checkpoint error:\n"
                 f"{last_checkpoint_error}\n"
+                "</CAR_CHECKPOINT_WARNING>"
             )
 
         commit_block = ""
         if commit_required:
             attempts_remaining = max(commit_max_attempts - commit_attempt + 1, 0)
             commit_block = (
-                "\n\n---\n\n"
-                "ACTION REQUIRED: Commit your changes, ensuring any pre-commit hooks pass.\n"
-                "- Use a meaningful commit message that matches what you implemented.\n"
-                "- If hooks fail, fix the underlying issues and retry the commit.\n"
-                f"- Attempts remaining before user intervention: {attempts_remaining}\n"
+                "<CAR_COMMIT_REQUIRED>\n"
+                "ACTION REQUIRED: The repo is dirty but the ticket is marked done.\n"
+                "Commit your changes (ensuring any pre-commit hooks pass) so the flow can advance.\n\n"
+                f"Attempts remaining before user intervention: {attempts_remaining}\n"
+                "</CAR_COMMIT_REQUIRED>"
             )
 
         if lint_errors:
             lint_block = (
-                "\n\nTicket frontmatter lint failed. Fix ONLY the ticket frontmatter to satisfy:\n- "
+                "<CAR_TICKET_FRONTMATTER_LINT_REPAIR>\n"
+                "Ticket frontmatter lint failed. Fix ONLY the ticket YAML frontmatter to satisfy:\n- "
                 + "\n- ".join(lint_errors)
-                + "\n"
+                + "\n</CAR_TICKET_FRONTMATTER_LINT_REPAIR>"
             )
         else:
             lint_block = ""
 
         reply_block = ""
         if reply_context:
-            reply_block = (
-                "\n\n---\n\nHUMAN REPLIES (from reply_history; newest since last turn):\n"
-                + reply_context
-                + "\n"
-            )
+            reply_block = reply_context
 
         workspace_block = ""
         workspace_docs: list[tuple[str, str, str]] = []
@@ -844,38 +1050,113 @@ class TicketRunner:
             blocks = ["Workspace docs (truncated; skip if not relevant):"]
             for label, rel, body in workspace_docs:
                 blocks.append(f"{label} [{rel}]:\n{body}")
-            workspace_block = "\n\n---\n\n" + "\n\n".join(blocks) + "\n"
+            workspace_block = "\n\n".join(blocks)
 
         prev_ticket_block = ""
         if previous_ticket_content:
             prev_ticket_block = (
-                "\n\n---\n\n"
-                "PREVIOUS TICKET CONTEXT (for reference only; do not edit):\n"
+                "PREVIOUS TICKET CONTEXT (truncated to 16KB; for reference only; do not edit):\n"
+                "Cross-ticket context should flow through workspace docs (active_context.md, decisions.md, spec.md) "
+                "rather than implicit previous ticket content. This is included only for legacy compatibility.\n"
                 + previous_ticket_content
-                + "\n"
             )
 
+        ticket_raw_content = ticket_path.read_text(encoding="utf-8")
         ticket_block = (
-            "\n\n---\n\n"
-            "TICKET CONTENT (edit this file to track progress; update frontmatter.done when complete):\n"
+            "<CAR_CURRENT_TICKET_FILE>\n"
             f"PATH: {rel_ticket}\n"
-            "\n" + ticket_path.read_text(encoding="utf-8")
+            "<TICKET_MARKDOWN>\n"
+            f"{ticket_raw_content}\n"
+            "</TICKET_MARKDOWN>\n"
+            "</CAR_CURRENT_TICKET_FILE>"
         )
 
         prev_block = ""
         if last_agent_output:
-            prev_block = (
-                "\n\n---\n\nPREVIOUS AGENT OUTPUT (same ticket):\n" + last_agent_output
+            prev_block = last_agent_output
+
+        sections = {
+            "prev_block": prev_block,
+            "prev_ticket_block": prev_ticket_block,
+            "workspace_block": workspace_block,
+            "reply_block": reply_block,
+            "ticket_block": ticket_block,
+        }
+
+        def render() -> str:
+            return (
+                "<CAR_TICKET_FLOW_PROMPT>\n\n"
+                "<CAR_TICKET_FLOW_INSTRUCTIONS>\n"
+                "You are running inside Codex Autorunner (CAR) in a ticket-based workflow.\n\n"
+                "Your job in this turn:\n"
+                "- Read the current ticket file.\n"
+                "- Make the required repo changes.\n"
+                "- Update the ticket file to reflect progress.\n"
+                "- Set `done: true` in the ticket YAML frontmatter only when the ticket is truly complete.\n\n"
+                "CAR orientation (80/20):\n"
+                "- `.codex-autorunner/tickets/` is the queue that drives the flow (files named `TICKET-###*.md`, processed in numeric order).\n"
+                "- `.codex-autorunner/workspace/` holds durable context shared across ticket turns (especially `active_context.md` and `spec.md`).\n"
+                "- `.codex-autorunner/ABOUT_CAR.md` is the repo-local briefing (what CAR auto-generates + helper scripts) if you need operational details.\n\n"
+                "Communicating with the user (optional):\n"
+                "- To send a message or request input, write to the dispatch directory:\n"
+                "  1) write any attachments to the dispatch directory\n"
+                "  2) write `DISPATCH.md` last\n"
+                "- `DISPATCH.md` YAML supports `mode: notify|pause`.\n"
+                "  - `pause` waits for user input; `notify` continues without waiting.\n"
+                "  - Example:\n"
+                "    ---\n"
+                "    mode: pause\n"
+                "    ---\n"
+                "    Need clarification on X before proceeding.\n"
+                "- You do not need a “final” dispatch when you finish; the runner will archive your turn output automatically. Dispatch only if you want something to stand out or you need user input.\n\n"
+                "If blocked:\n"
+                "- Dispatch with `mode: pause` rather than guessing.\n\n"
+                "Creating follow-up tickets (optional):\n"
+                "- New tickets live under `.codex-autorunner/tickets/` and follow the `TICKET-###*.md` naming pattern.\n"
+                "- If present, `.codex-autorunner/bin/ticket_tool.py` can create/insert/move tickets; `.codex-autorunner/bin/lint_tickets.py` lints ticket frontmatter (see `.codex-autorunner/ABOUT_CAR.md`).\n"
+                "Using ticket templates (optional):\n"
+                "- If you need a standard ticket pattern, prefer: `car templates fetch <repo_id>:<path>[@<ref>]`\n"
+                "  - Trusted repos skip scanning; untrusted repos are scanned (cached by blob SHA).\n\n"
+                "Workspace docs:\n"
+                "- You may update or add context under `.codex-autorunner/workspace/` so future ticket turns have durable context.\n"
+                "- Prefer referencing these docs instead of creating duplicate “shadow” docs elsewhere.\n\n"
+                "Repo hygiene:\n"
+                "- Do not add new `.codex-autorunner/` artifacts to git unless they are already tracked.\n"
+                "</CAR_TICKET_FLOW_INSTRUCTIONS>\n\n"
+                "<CAR_RUNTIME_PATHS>\n"
+                f"Current ticket file: {rel_ticket}\n"
+                f"Dispatch directory: {rel_dispatch_dir}\n"
+                f"DISPATCH.md path: {rel_dispatch_path}\n"
+                "</CAR_RUNTIME_PATHS>\n\n"
+                f"{checkpoint_block}\n\n"
+                f"{commit_block}\n\n"
+                f"{lint_block}\n\n"
+                "<CAR_WORKSPACE_DOCS>\n"
+                f"{sections['workspace_block']}\n"
+                "</CAR_WORKSPACE_DOCS>\n\n"
+                "<CAR_HUMAN_REPLIES>\n"
+                f"{sections['reply_block']}\n"
+                "</CAR_HUMAN_REPLIES>\n\n"
+                "<CAR_PREVIOUS_TICKET_REFERENCE>\n"
+                f"{sections['prev_ticket_block']}\n"
+                "</CAR_PREVIOUS_TICKET_REFERENCE>\n\n"
+                f"{sections['ticket_block']}\n\n"
+                "<CAR_PREVIOUS_AGENT_OUTPUT>\n"
+                f"{sections['prev_block']}\n"
+                "</CAR_PREVIOUS_AGENT_OUTPUT>\n\n"
+                "</CAR_TICKET_FLOW_PROMPT>"
             )
 
-        return (
-            header
-            + checkpoint_block
-            + commit_block
-            + lint_block
-            + workspace_block
-            + reply_block
-            + prev_ticket_block
-            + ticket_block
-            + prev_block
+        prompt = _shrink_prompt(
+            max_bytes=self._config.prompt_max_bytes,
+            render=render,
+            sections=sections,
+            order=[
+                "prev_block",
+                "prev_ticket_block",
+                "reply_block",
+                "workspace_block",
+                "ticket_block",
+            ],
         )
+        return prompt

{codex_autorunner-1.1.0.dist-info → codex_autorunner-1.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-autorunner
-Version: 1.1.0
+Version: 1.2.1
 Summary: Codex autorunner CLI per DESIGN-V1
 Author: Codex
 License: MIT License
@@ -85,7 +85,7 @@ The philosophy behind CAR is to let the agents do what they do best, and get out
 CAR treats tickets as the control plane and models as the execution layer. This means that we rely on agents to follow the instructions written in the tickets. If you use a sufficiently weak model, CAR may not work well for you. CAR is an amplifier for agent capabilities. Agents who like to scope creep (create too many new tickets) or reward hack (mark a ticket as done despite it being incomplete) are not a good fit for CAR.
 
 ## Interaction patterns
-CAR's core is a set of python functions surfaced as a CLI, operating on a file system. There are current 2 UIs built on top of this core.
+CAR's core is a set of python functions surfaced as a CLI, operating on a file system. There are current 3 UIs built on top of this core.
 
 ### Web UI
 The web UI is the main control plane for CAR. From here you can set up new repositories or clone existing ones, chat with agents using their TUI, and run the ticket autorunner. There are many quality-of-life features like Whisper integration, editing documents by chatting with AI (useful for mobile), viewing usage analytics, and much more. The Web UI is the most full featured user-facing interface and a good starting point for trying out CAR.
@@ -95,30 +95,23 @@ I recommend serving the web UI over Tailscale. There is an auth token option but
 ### Telegram
 Telegram is the "on-the-go" and notification hub for CAR. From here you can kick off and monitor existing tickets, set up new tickets, and chat with agents. Your primary UX here is asking the agent to do things for you rather than you doing it yourself like you would on the web UI. This is great for on-the-go work, but it doesn't have full feature parity with the web UI.
 
+### Project Manager Agent
+The project manager agent (PMA) is a way to use an AI agent to run CAR. For example instead of making/editing tickets in the UI, you can ask the PMA to do it for you. Instead of starting a ticket flow, the PMA can babysit it for you. The PMA can be accessed in the web and in Telegram, and also uses the CAR CLI directly.
+
 ## Quickstart
 
 The fastest way to get started is to pass [this setup guide](docs/AGENT_SETUP_GUIDE.md) to your favorite AI agent. The agent will walk you through installation and configuration interactively based on your environment.
 
-**TL;DR for the impatient:**
+### From source (repo checkout)
 
-# Install
-```
-pipx install codex-autorunner
-```
-# Initialize in your repo
-```
-cd /path/to/your/repo
-car init
-```
-# Verify setup
-```
-car doctor
-```
-# Create a ticket and run
-```
-car run
+If you're working from a fresh clone of this repo, you can run the repo-local CLI shim:
+
+```bash
+./car --help
 ```
 
+The shim will try `PYTHONPATH=src` first and, if dependencies are missing, will bootstrap a local `.venv` and install CAR.
+
 ## Supported models
 CAR currently supports:
 - Codex
@@ -150,5 +143,8 @@ On the go? The web UI is mobile responsive, or if you prefer you can type or voi
 ![CAR Telegram Media Voice Screenshot](docs/screenshots/telegram-media-voice.PNG)
 ![CAR Telegram Media Image Screenshot](docs/screenshots/telegram-media-image.PNG)
 
+Don't want to use the product directly? Delegate work to the PMA.
+![CAR Telegram PMA Screenshot](docs/screenshots/telegram-pma.png)
+
 ## Star history
 [![Star History Chart](https://api.star-history.com/svg?repos=Git-on-my-level/codex-autorunner&type=Date)](https://star-history.com/#Git-on-my-level/codex-autorunner&Date)