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

codex_autorunner/tickets/runner.py

@@ -5,12 +5,12 @@ from pathlib import Path
 from typing import Any, Callable, Optional
 
 from ..core.flows.models import FlowEventType
-from ..core.git_utils import run_git
+from ..core.git_utils import git_diff_stats, run_git
 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,10 +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="max_turns",
             )
 
         ticket_dir = self._workspace_root / self._config.ticket_dir
@@ -97,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:
@@ -106,6 +275,17 @@ class TicketRunner:
                     "No tickets found. Create tickets under "
                     f"{safe_relpath(ticket_dir, self._workspace_root)} and resume."
                 ),
+                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")
@@ -134,6 +314,16 @@ class TicketRunner:
                 )
             current_path = next_path
             state["current_ticket"] = safe_relpath(current_path, self._workspace_root)
+            # Inform listeners immediately which ticket is about to run so the UI
+            # can show the active indicator before the first turn completes.
+            if emit_event is not None:
+                emit_event(
+                    FlowEventType.STEP_PROGRESS,
+                    {
+                        "message": "Selected ticket",
+                        "current_ticket": state["current_ticket"],
+                    },
+                )
             # New ticket resets per-ticket state.
             state["ticket_turns"] = 0
             state.pop("last_agent_output", None)
@@ -148,6 +338,7 @@ class TicketRunner:
             state["status"] = "running"
             state.pop("reason", None)
             state.pop("reason_details", None)
+            state.pop("reason_code", None)
 
         _lint_raw = state.get("lint")
         lint_state: dict[str, Any] = _lint_raw if isinstance(_lint_raw, dict) else {}
@@ -176,6 +367,7 @@ class TicketRunner:
                         f"{safe_relpath(current_path, self._workspace_root)}: {exc}"
                     ),
                     current_ticket=safe_relpath(current_path, self._workspace_root),
+                    reason_code="infra_error",
                 )
 
             data, _ = parse_markdown_frontmatter(raw)
@@ -189,6 +381,7 @@ class TicketRunner:
                         "Fix the ticket frontmatter manually and resume."
                     ),
                     current_ticket=safe_relpath(current_path, self._workspace_root),
+                    reason_code="needs_user_fix",
                 )
 
             # Validate agent id unless it is the special user sentinel.
@@ -205,6 +398,7 @@ class TicketRunner:
                             f"{safe_relpath(current_path, self._workspace_root)}: {exc}"
                         ),
                         current_ticket=safe_relpath(current_path, self._workspace_root),
+                        reason_code="needs_user_fix",
                     )
 
             ticket_doc = type(
@@ -225,6 +419,7 @@ class TicketRunner:
                     reason=f"Ticket frontmatter invalid: {safe_relpath(current_path, self._workspace_root)}",
                     reason_details="Errors:\n- " + "\n- ".join(ticket_errors),
                     current_ticket=safe_relpath(current_path, self._workspace_root),
+                    reason_code="needs_user_fix",
                 )
 
         # Built-in manual user ticket.
@@ -239,6 +434,7 @@ class TicketRunner:
                     f"{safe_relpath(current_path, self._workspace_root)}"
                 ),
                 current_ticket=safe_relpath(current_path, self._workspace_root),
+                reason_code="user_pause",
             )
 
         ticket_turns = int(state.get("ticket_turns") or 0)
@@ -248,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,
@@ -315,17 +515,45 @@ 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.",
                 reason_details=f"Error: {result.error}",
                 current_ticket=safe_relpath(current_path, self._workspace_root),
+                reason_code="infra_error",
             )
 
         # Mark replies as consumed only after a successful agent turn.
         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
@@ -358,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
@@ -369,6 +601,7 @@ class TicketRunner:
                 reason="Invalid DISPATCH.md frontmatter.",
                 reason_details="Errors:\n- " + "\n- ".join(dispatch_errors),
                 current_ticket=safe_relpath(current_path, self._workspace_root),
+                reason_code="needs_user_fix",
             )
 
         if dispatch is not None:
@@ -378,6 +611,25 @@ class TicketRunner:
         # Create turn summary record for the agent's final output.
         # This appears in dispatch history as a distinct "turn summary" entry.
         turn_summary_seq = int(state.get("dispatch_seq") or 0) + 1
+
+        # Compute diff stats for this turn (changes since head_before_turn).
+        # This captures both committed and uncommitted changes made by the agent.
+        turn_diff_stats = None
+        try:
+            if head_before_turn:
+                # Compare current state (HEAD + working tree) against pre-turn commit
+                turn_diff_stats = git_diff_stats(
+                    self._workspace_root, from_ref=head_before_turn
+                )
+            else:
+                # No reference commit; show all uncommitted changes
+                turn_diff_stats = git_diff_stats(
+                    self._workspace_root, from_ref=None, include_staged=True
+                )
+        except Exception:
+            # Best-effort; don't block on stats computation errors
+            turn_diff_stats = None
+
         turn_summary, turn_summary_errors = create_turn_summary(
             outbox_paths,
             next_seq=turn_summary_seq,
@@ -385,10 +637,31 @@ class TicketRunner:
             ticket_id=current_ticket_id,
             agent_id=result.agent_id,
             turn_number=total_turns,
+            diff_stats=turn_diff_stats,
         )
         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:
@@ -402,6 +675,7 @@ class TicketRunner:
                         "Errors:\n- " + "\n- ".join(fm_errors)
                     ),
                     current_ticket=safe_relpath(current_path, self._workspace_root),
+                    reason_code="needs_user_fix",
                 )
 
             state["lint"] = {
@@ -439,7 +713,9 @@ class TicketRunner:
             reason = dispatch.dispatch.title or "Paused for user input."
             if checkpoint_error:
                 reason += f"\n\nNote: checkpoint commit failed: {checkpoint_error}"
+            state["status"] = "paused"
             state["reason"] = reason
+            state["reason_code"] = "user_pause"
             return TicketResult(
                 status="paused",
                 state=state,
@@ -495,6 +771,7 @@ class TicketRunner:
                         ),
                         reason_details="".join(details_parts),
                         current_ticket=safe_relpath(current_path, self._workspace_root),
+                        reason_code="needs_user_fix",
                     )
 
                 return TicketResult(
@@ -583,12 +860,14 @@ class TicketRunner:
         state: dict[str, Any],
         *,
         reason: str,
+        reason_code: str = "needs_user_fix",
         reason_details: Optional[str] = None,
         current_ticket: Optional[str] = None,
     ) -> TicketResult:
         state = dict(state)
         state["status"] = "paused"
         state["reason"] = reason
+        state["reason_code"] = reason_code
         if reason_details:
             state["reason_details"] = reason_details
         else:
@@ -705,56 +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 and updating the ticket file.\n\n"
-            "Key rules:\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"
-            "- Keep tickets minimal and avoid scope creep. You may create new tickets only if blocking the current SPEC.\n"
-        )
-
         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]] = []
@@ -786,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