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

codex_autorunner/core/about_car.py

@@ -7,7 +7,6 @@ from .config import (
     REPO_OVERRIDE_FILENAME,
     ROOT_CONFIG_FILENAME,
     ROOT_OVERRIDE_FILENAME,
-    Config,
     find_nearest_hub_config_path,
 )
 
@@ -98,6 +97,18 @@ def build_about_car_markdown(
         f"`{decisions_disp}`\n"
         "- **Spec**: "
         f"`{spec_disp}`\n\n"
+        "## Web UI quick map (repo page)\n"
+        "- Repo view: `/repos/<repo_id>/`\n"
+        "- Tabs: **Tickets** = `.codex-autorunner/tickets/` queue.\n"
+        "- Tabs: **Inbox** = paused run dispatches/handoffs.\n"
+        "- Tabs: **Workspace** = edit `active_context.md`, `spec.md`, `decisions.md`.\n"
+        "- Tabs: **Terminal** = launches the configured `codex` binary in a PTY.\n"
+        "- Tabs: **Archive** = browse worktree snapshots.\n\n"
+        "## FileBox (attachments)\n"
+        "- Repo FileBox root: `.codex-autorunner/filebox/`.\n"
+        "- User uploads: `.codex-autorunner/filebox/inbox/`.\n"
+        "- Files to send back: `.codex-autorunner/filebox/outbox/`.\n"
+        "- Note: ticket_flow uses per-run dispatch directories; do not confuse dispatch with FileBox.\n\n"
         "## Critical rules\n"
         "- Do **not** create new copies of workspace docs elsewhere in the repo.\n"
         "- Treat `.codex-autorunner/` as intentional project structure even though it is hidden/gitignored.\n\n"
@@ -211,17 +222,6 @@ def build_tickets_agents_markdown(*, repo_root: Path) -> str:
     )
 
 
-def ensure_about_car_file(config: Config, *, force: bool = False) -> Path:
-    """Config-aware wrapper that uses configured doc paths."""
-    repo_root = config.root
-    docs = {
-        "active_context": config.doc_path("active_context"),
-        "decisions": config.doc_path("decisions"),
-        "spec": config.doc_path("spec"),
-    }
-    return ensure_about_car_file_for_repo(repo_root, doc_paths=docs, force=force)
-
-
 def ensure_ticket_flow_quickstart_file_for_repo(
     repo_root: Path, *, force: bool = False
 ) -> Path:

codex_autorunner/core/config.py

@@ -258,7 +258,7 @@ DEFAULT_REPO_CONFIG: Dict[str, Any] = {
             "files": True,
             "max_image_bytes": 10_000_000,
             "max_voice_bytes": 10_000_000,
-            "max_file_bytes": 10_000_000,
+            "max_file_bytes": 100_000_000,
             "image_prompt": (
                 "The user sent an image with no caption. Use it to continue the "
                 "conversation; if no clear task, describe the image and ask what "
@@ -542,7 +542,7 @@ DEFAULT_HUB_CONFIG: Dict[str, Any] = {
             "files": True,
             "max_image_bytes": 10_000_000,
             "max_voice_bytes": 10_000_000,
-            "max_file_bytes": 10_000_000,
+            "max_file_bytes": 100_000_000,
             "image_prompt": (
                 "The user sent an image with no caption. Use it to continue the "
                 "conversation; if no clear task, describe the image and ask what "

codex_autorunner/core/context_awareness.py

@@ -12,6 +12,7 @@ CAR’s durable control-plane lives under `.codex-autorunner/`:
   - `active_context.md` — current “north star” context; kept fresh for ongoing work.
   - `spec.md` — longer spec / acceptance criteria when needed.
   - `decisions.md` — prior decisions / tradeoffs when relevant.
+- `.codex-autorunner/filebox/` — attachments inbox/outbox used by CAR surfaces (if present).
 
 Intent signals: if the user mentions tickets, “dispatch”, “resume”, workspace docs, or `.codex-autorunner/`, they are likely referring to CAR artifacts/workflow rather than generic repo files.
 

codex_autorunner/core/pma_context.py

@@ -19,6 +19,30 @@ PMA_MAX_MESSAGES = 10
 PMA_MAX_TEXT = 800
 PMA_MAX_TEMPLATE_REPOS = 25
 PMA_MAX_TEMPLATE_FIELD_CHARS = 120
+PMA_MAX_PMA_FILES = 50
+PMA_MAX_LIFECYCLE_EVENTS = 20
+
+# Keep this short and stable; see ticket TICKET-001 for rationale.
+PMA_FASTPATH = """<pma_fastpath>
+You are PMA inside Codex Autorunner (CAR). Treat the filesystem as truth; prefer creating/updating CAR artifacts over "chat-only" plans.
+
+First-turn routine:
+1) Read <user_message> and <hub_snapshot>.
+2) If hub_snapshot.inbox has entries, handle them first (these are paused runs needing input):
+   - Summarize the dispatch question.
+   - Answer it or propose the next minimal action.
+   - Include the item.open_url so the user can jump straight to the repo Inbox tab.
+3) If the request is new work:
+   - Identify the target repo(s).
+   - Prefer hub-owned worktrees for changes.
+   - Create/adjust repo tickets under each repo's `.codex-autorunner/tickets/`.
+
+Web UI map (user perspective):
+- Hub root: `/` (repos list + global notifications).
+- Repo view: `/repos/<repo_id>/` tabs: Tickets | Inbox | Workspace | Terminal | Analytics | Archive.
+  - Tickets: edit queue; Inbox: paused run dispatches; Workspace: active_context/spec/decisions.
+</pma_fastpath>
+"""
 
 # Defaults used when hub config is not available (should be rare).
 PMA_DOCS_MAX_CHARS = 12_000
@@ -192,13 +216,170 @@ def load_pma_prompt(hub_root: Path) -> str:
         return ""
 
 
+def _render_ticket_flow_summary(summary: Optional[dict[str, Any]]) -> str:
+    if not summary:
+        return "null"
+    status = summary.get("status")
+    done_count = summary.get("done_count")
+    total_count = summary.get("total_count")
+    current_step = summary.get("current_step")
+    parts: list[str] = []
+    if status is not None:
+        parts.append(f"status={status}")
+    if done_count is not None and total_count is not None:
+        parts.append(f"done={done_count}/{total_count}")
+    if current_step is not None:
+        parts.append(f"step={current_step}")
+    if not parts:
+        return "null"
+    return " ".join(parts)
+
+
+def _render_hub_snapshot(
+    snapshot: dict[str, Any],
+    *,
+    max_repos: int = PMA_MAX_REPOS,
+    max_messages: int = PMA_MAX_MESSAGES,
+    max_text_chars: int = PMA_MAX_TEXT,
+    max_template_repos: int = PMA_MAX_TEMPLATE_REPOS,
+    max_field_chars: int = PMA_MAX_TEMPLATE_FIELD_CHARS,
+    max_pma_files: int = PMA_MAX_PMA_FILES,
+    max_lifecycle_events: int = PMA_MAX_LIFECYCLE_EVENTS,
+) -> str:
+    lines: list[str] = []
+
+    inbox = snapshot.get("inbox") or []
+    if inbox:
+        lines.append("Inbox (paused runs needing attention):")
+        for item in list(inbox)[: max(0, max_messages)]:
+            repo_id = _truncate(str(item.get("repo_id", "")), max_field_chars)
+            run_id = _truncate(str(item.get("run_id", "")), max_field_chars)
+            seq = _truncate(str(item.get("seq", "")), max_field_chars)
+            dispatch = item.get("dispatch") or {}
+            mode = _truncate(str(dispatch.get("mode", "")), max_field_chars)
+            handoff = bool(dispatch.get("is_handoff"))
+            lines.append(
+                f"- repo_id={repo_id} run_id={run_id} seq={seq} mode={mode} "
+                f"handoff={str(handoff).lower()}"
+            )
+            title = dispatch.get("title")
+            if title:
+                lines.append(f"  title: {_truncate(str(title), max_text_chars)}")
+            body = dispatch.get("body")
+            if body:
+                lines.append(f"  body: {_truncate(str(body), max_text_chars)}")
+            files = item.get("files") or []
+            if files:
+                display = [
+                    _truncate(str(name), max_field_chars)
+                    for name in list(files)[: max(0, max_pma_files)]
+                ]
+                lines.append(f"  attachments: [{', '.join(display)}]")
+            open_url = item.get("open_url")
+            if open_url:
+                lines.append(f"  open_url: {_truncate(str(open_url), max_field_chars)}")
+        lines.append("")
+
+    repos = snapshot.get("repos") or []
+    if repos:
+        lines.append("Repos:")
+        for repo in list(repos)[: max(0, max_repos)]:
+            repo_id = _truncate(str(repo.get("id", "")), max_field_chars)
+            display_name = _truncate(str(repo.get("display_name", "")), max_field_chars)
+            status = _truncate(str(repo.get("status", "")), max_field_chars)
+            last_run_id = _truncate(str(repo.get("last_run_id", "")), max_field_chars)
+            last_exit = _truncate(str(repo.get("last_exit_code", "")), max_field_chars)
+            ticket_flow = _render_ticket_flow_summary(repo.get("ticket_flow"))
+            lines.append(
+                f"- {repo_id} ({display_name}): status={status} "
+                f"last_run_id={last_run_id} last_exit_code={last_exit} "
+                f"ticket_flow={ticket_flow}"
+            )
+        lines.append("")
+
+    templates = snapshot.get("templates") or {}
+    template_repos = templates.get("repos") or []
+    template_scan = templates.get("last_scan")
+    if templates.get("enabled") or template_repos or template_scan:
+        enabled = bool(templates.get("enabled"))
+        lines.append("Templates:")
+        lines.append(f"- enabled={str(enabled).lower()}")
+        if template_repos:
+            items: list[str] = []
+            for repo in list(template_repos)[: max(0, max_template_repos)]:
+                repo_id = _truncate(str(repo.get("id", "")), max_field_chars)
+                default_ref = _truncate(
+                    str(repo.get("default_ref", "")), max_field_chars
+                )
+                trusted = bool(repo.get("trusted"))
+                items.append(f"{repo_id}@{default_ref} trusted={str(trusted).lower()}")
+            lines.append(f"- repos: [{', '.join(items)}]")
+        if template_scan:
+            repo_id = _truncate(str(template_scan.get("repo_id", "")), max_field_chars)
+            decision = _truncate(
+                str(template_scan.get("decision", "")), max_field_chars
+            )
+            severity = _truncate(
+                str(template_scan.get("severity", "")), max_field_chars
+            )
+            scanned_at = _truncate(
+                str(template_scan.get("scanned_at", "")), max_field_chars
+            )
+            lines.append(
+                f"- last_scan: {repo_id} {decision} {severity} {scanned_at}".strip()
+            )
+        lines.append("")
+
+    pma_files = snapshot.get("pma_files") or {}
+    inbox_files = pma_files.get("inbox") or []
+    outbox_files = pma_files.get("outbox") or []
+    if inbox_files or outbox_files:
+        lines.append("PMA files:")
+        if inbox_files:
+            files = [
+                _truncate(str(name), max_field_chars)
+                for name in list(inbox_files)[: max(0, max_pma_files)]
+            ]
+            lines.append(f"- inbox: [{', '.join(files)}]")
+        if outbox_files:
+            files = [
+                _truncate(str(name), max_field_chars)
+                for name in list(outbox_files)[: max(0, max_pma_files)]
+            ]
+            lines.append(f"- outbox: [{', '.join(files)}]")
+        lines.append("")
+
+    lifecycle_events = snapshot.get("lifecycle_events") or []
+    if lifecycle_events:
+        lines.append("Lifecycle events (recent):")
+        for event in list(lifecycle_events)[: max(0, max_lifecycle_events)]:
+            timestamp = _truncate(str(event.get("timestamp", "")), max_field_chars)
+            event_type = _truncate(str(event.get("event_type", "")), max_field_chars)
+            repo_id = _truncate(str(event.get("repo_id", "")), max_field_chars)
+            run_id = _truncate(str(event.get("run_id", "")), max_field_chars)
+            lines.append(
+                f"- {timestamp} {event_type} repo_id={repo_id} run_id={run_id}"
+            )
+        lines.append("")
+
+    if lines and lines[-1] == "":
+        lines.pop()
+    return "\n".join(lines)
+
+
 def format_pma_prompt(
     base_prompt: str,
     snapshot: dict[str, Any],
     message: str,
     hub_root: Optional[Path] = None,
 ) -> str:
-    snapshot_text = json.dumps(snapshot, sort_keys=True)
+    limits = snapshot.get("limits") or {}
+    snapshot_text = _render_hub_snapshot(
+        snapshot,
+        max_repos=limits.get("max_repos", PMA_MAX_REPOS),
+        max_messages=limits.get("max_messages", PMA_MAX_MESSAGES),
+        max_text_chars=limits.get("max_text_chars", PMA_MAX_TEXT),
+    )
 
     pma_docs: Optional[dict[str, Any]] = None
     if hub_root is not None:
@@ -235,6 +416,7 @@ def format_pma_prompt(
             "</pma_workspace_docs>\n\n"
         )
 
+    prompt += f"{PMA_FASTPATH}\n\n"
     prompt += (
         "<hub_snapshot>\n"
         f"{snapshot_text}\n"
@@ -493,4 +675,9 @@ async def build_hub_snapshot(
         "templates": templates,
         "pma_files": pma_files,
         "lifecycle_events": lifecycle_events,
+        "limits": {
+            "max_repos": max_repos,
+            "max_messages": max_messages,
+            "max_text_chars": max_text_chars,
+        },
     }

codex_autorunner/integrations/telegram/adapter.py

@@ -1370,7 +1370,7 @@ class TelegramBotClient:
         return bool(result) if isinstance(result, bool) else False
 
     async def download_file(
-        self, file_path: str, max_size_bytes: int = 50 * 1024 * 1024
+        self, file_path: str, max_size_bytes: int = 100 * 1024 * 1024
     ) -> bytes:
         safe_path = file_path.lstrip("/")
         url = f"{self._file_base_url}/{safe_path}"

codex_autorunner/integrations/telegram/config.py

@@ -44,7 +44,7 @@ DEFAULT_APP_SERVER_TURN_TIMEOUT_SECONDS = 28800
 DEFAULT_APPROVAL_TIMEOUT_SECONDS = 300.0
 DEFAULT_MEDIA_MAX_IMAGE_BYTES = 10 * 1024 * 1024
 DEFAULT_MEDIA_MAX_VOICE_BYTES = 10 * 1024 * 1024
-DEFAULT_MEDIA_MAX_FILE_BYTES = 10 * 1024 * 1024
+DEFAULT_MEDIA_MAX_FILE_BYTES = 100 * 1024 * 1024
 DEFAULT_MEDIA_IMAGE_PROMPT = (
     "The user sent an image with no caption. Use it to continue the "
     "conversation; if no clear task, describe the image and ask what they want."

codex_autorunner/integrations/telegram/handlers/messages.py

@@ -859,7 +859,10 @@ async def handle_media_message(
                 best = photos[0]
                 try:
                     file_info = await handlers._bot.get_file(best.file_id)
-                    data = await handlers._bot.download_file(file_info.file_path)
+                    data = await handlers._bot.download_file(
+                        file_info.file_path,
+                        max_size_bytes=handlers._config.media.max_image_bytes,
+                    )
                     filename = f"photo_{best.file_id}.jpg"
                     files.append((filename, data))
                 except Exception as exc:
@@ -868,7 +871,10 @@ async def handle_media_message(
         elif message.document:
             try:
                 file_info = await handlers._bot.get_file(message.document.file_id)
-                data = await handlers._bot.download_file(file_info.file_path)
+                data = await handlers._bot.download_file(
+                    file_info.file_path,
+                    max_size_bytes=handlers._config.media.max_file_bytes,
+                )
                 filename = (
                     message.document.file_name or f"document_{message.document.file_id}"
                 )