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

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/core/pma_delivery.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any, Optional
+
+from ..integrations.telegram.adapter import chunk_message
+from ..integrations.telegram.constants import TELEGRAM_MAX_MESSAGE_LENGTH
+from ..integrations.telegram.state import OutboxRecord, TelegramStateStore
+from .pma_sink import PmaActiveSinkStore
+from .time_utils import now_iso
+
+logger = logging.getLogger(__name__)
+
+
+async def deliver_pma_output_to_active_sink(
+    *,
+    hub_root: Path,
+    assistant_text: str,
+    turn_id: str,
+    lifecycle_event: Optional[dict[str, Any]],
+    telegram_state_path: Path,
+) -> bool:
+    if not lifecycle_event:
+        return False
+    if not assistant_text or not assistant_text.strip():
+        return False
+    if not isinstance(turn_id, str) or not turn_id:
+        return False
+
+    sink_store = PmaActiveSinkStore(hub_root)
+    sink = sink_store.load()
+    if not isinstance(sink, dict):
+        return False
+    if sink.get("kind") != "telegram":
+        return False
+
+    last_delivery = sink.get("last_delivery_turn_id")
+    if isinstance(last_delivery, str) and last_delivery == turn_id:
+        return False
+
+    chat_id = sink.get("chat_id")
+    thread_id = sink.get("thread_id")
+    if not isinstance(chat_id, int):
+        return False
+    if thread_id is not None and not isinstance(thread_id, int):
+        thread_id = None
+
+    chunks = chunk_message(
+        assistant_text, max_len=TELEGRAM_MAX_MESSAGE_LENGTH, with_numbering=True
+    )
+    if not chunks:
+        return False
+
+    store = TelegramStateStore(telegram_state_path)
+    try:
+        for idx, chunk in enumerate(chunks, 1):
+            record_id = f"pma:{turn_id}:{idx}"
+            record = OutboxRecord(
+                record_id=record_id,
+                chat_id=chat_id,
+                thread_id=thread_id,
+                reply_to_message_id=None,
+                placeholder_message_id=None,
+                text=chunk,
+                created_at=now_iso(),
+                operation="send",
+                outbox_key=record_id,
+            )
+            await store.enqueue_outbox(record)
+    except Exception:
+        logger.exception("Failed to enqueue PMA output to Telegram outbox")
+        return False
+    finally:
+        await store.close()
+
+    sink_store.mark_delivered(turn_id)
+    return True
+
+
+__all__ = ["deliver_pma_output_to_active_sink"]

codex_autorunner/core/pma_dispatches.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Optional
+
+import yaml
+
+from ..tickets.frontmatter import parse_markdown_frontmatter
+from .time_utils import now_iso
+from .utils import atomic_write
+
+logger = logging.getLogger(__name__)
+
+PMA_DISPATCHES_DIRNAME = "dispatches"
+PMA_DISPATCH_ALLOWED_PRIORITIES = {"info", "warn", "action"}
+PMA_DISPATCH_ALLOWED_EXTS = {".md", ".markdown"}
+
+
+@dataclass(frozen=True)
+class PmaDispatch:
+    dispatch_id: str
+    title: str
+    body: str
+    priority: str
+    links: list[dict[str, str]]
+    created_at: str
+    resolved_at: Optional[str]
+    source_turn_id: Optional[str]
+    path: Path
+
+
+def _dispatches_root(hub_root: Path) -> Path:
+    return hub_root / ".codex-autorunner" / "pma" / PMA_DISPATCHES_DIRNAME
+
+
+def ensure_pma_dispatches_dir(hub_root: Path) -> Path:
+    root = _dispatches_root(hub_root)
+    root.mkdir(parents=True, exist_ok=True)
+    return root
+
+
+def _normalize_priority(value: Any) -> str:
+    if not isinstance(value, str):
+        return "info"
+    priority = value.strip().lower()
+    if priority in PMA_DISPATCH_ALLOWED_PRIORITIES:
+        return priority
+    return "info"
+
+
+def _normalize_links(value: Any) -> list[dict[str, str]]:
+    if not isinstance(value, list):
+        return []
+    links: list[dict[str, str]] = []
+    for item in value:
+        if not isinstance(item, dict):
+            continue
+        label = item.get("label")
+        href = item.get("href")
+        if not isinstance(label, str) or not isinstance(href, str):
+            continue
+        label = label.strip()
+        href = href.strip()
+        if not label or not href:
+            continue
+        links.append({"label": label, "href": href})
+    return links
+
+
+def _created_at_from_path(path: Path) -> str:
+    try:
+        stamp = path.stat().st_mtime
+    except OSError:
+        return now_iso()
+    return datetime.fromtimestamp(stamp, tz=timezone.utc).isoformat()
+
+
+def _parse_iso(value: Optional[str]) -> Optional[datetime]:
+    if not isinstance(value, str) or not value:
+        return None
+    try:
+        return datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except Exception:
+        return None
+
+
+def parse_pma_dispatch(path: Path) -> tuple[Optional[PmaDispatch], list[str]]:
+    errors: list[str] = []
+    try:
+        raw = path.read_text(encoding="utf-8")
+    except OSError as exc:
+        return None, [f"Failed to read dispatch: {exc}"]
+
+    data, body = parse_markdown_frontmatter(raw)
+    if not isinstance(data, dict):
+        data = {}
+
+    raw_title = data.get("title")
+    title = raw_title if isinstance(raw_title, str) else ""
+    body = body or ""
+    priority = _normalize_priority(data.get("priority"))
+    links = _normalize_links(data.get("links"))
+    created_at = (
+        data.get("created_at") if isinstance(data.get("created_at"), str) else None
+    )
+    resolved_at = (
+        data.get("resolved_at") if isinstance(data.get("resolved_at"), str) else None
+    )
+    source_turn_id = (
+        data.get("source_turn_id")
+        if isinstance(data.get("source_turn_id"), str)
+        else None
+    )
+
+    if not created_at:
+        created_at = _created_at_from_path(path)
+
+    dispatch_id = path.stem
+
+    dispatch = PmaDispatch(
+        dispatch_id=dispatch_id,
+        title=title,
+        body=body,
+        priority=priority,
+        links=links,
+        created_at=created_at,
+        resolved_at=resolved_at,
+        source_turn_id=source_turn_id,
+        path=path,
+    )
+    return dispatch, errors
+
+
+def list_pma_dispatches(
+    hub_root: Path,
+    *,
+    include_resolved: bool = False,
+    limit: Optional[int] = None,
+) -> list[PmaDispatch]:
+    root = ensure_pma_dispatches_dir(hub_root)
+    dispatches: list[PmaDispatch] = []
+    for child in sorted(root.iterdir(), key=lambda p: p.name):
+        if child.suffix.lower() not in PMA_DISPATCH_ALLOWED_EXTS:
+            continue
+        dispatch, errors = parse_pma_dispatch(child)
+        if errors or dispatch is None:
+            continue
+        if not include_resolved and dispatch.resolved_at:
+            continue
+        dispatches.append(dispatch)
+
+    dispatches.sort(
+        key=lambda d: _parse_iso(d.created_at)
+        or datetime.min.replace(tzinfo=timezone.utc),
+        reverse=True,
+    )
+    if isinstance(limit, int) and limit > 0:
+        dispatches = dispatches[:limit]
+    return dispatches
+
+
+def list_pma_dispatches_for_turn(hub_root: Path, turn_id: str) -> list[PmaDispatch]:
+    if not isinstance(turn_id, str) or not turn_id:
+        return []
+    dispatches = list_pma_dispatches(hub_root, include_resolved=False)
+    return [d for d in dispatches if d.source_turn_id == turn_id]
+
+
+def find_pma_dispatch_path(hub_root: Path, dispatch_id: str) -> Optional[Path]:
+    if not isinstance(dispatch_id, str) or not dispatch_id:
+        return None
+    safe_id = dispatch_id.strip()
+    if not safe_id or "/" in safe_id or "\\" in safe_id:
+        return None
+    root = ensure_pma_dispatches_dir(hub_root)
+    for ext in PMA_DISPATCH_ALLOWED_EXTS:
+        candidate = root / f"{safe_id}{ext}"
+        if candidate.exists():
+            return candidate
+    return None
+
+
+def resolve_pma_dispatch(path: Path) -> tuple[Optional[PmaDispatch], list[str]]:
+    dispatch, errors = parse_pma_dispatch(path)
+    if errors or dispatch is None:
+        return dispatch, errors
+
+    if dispatch.resolved_at:
+        return dispatch, []
+
+    data = {
+        "title": dispatch.title,
+        "priority": dispatch.priority,
+        "links": dispatch.links,
+        "created_at": dispatch.created_at,
+        "resolved_at": now_iso(),
+        "source_turn_id": dispatch.source_turn_id,
+    }
+    frontmatter = yaml.safe_dump(data, sort_keys=False).strip()
+    content = f"---\n{frontmatter}\n---\n\n{dispatch.body.strip()}\n"
+    try:
+        atomic_write(path, content)
+    except OSError as exc:
+        return dispatch, [f"Failed to resolve dispatch: {exc}"]
+
+    updated, parse_errors = parse_pma_dispatch(path)
+    if parse_errors:
+        return updated, parse_errors
+    return updated, []
+
+
+__all__ = [
+    "PmaDispatch",
+    "PMA_DISPATCHES_DIRNAME",
+    "ensure_pma_dispatches_dir",
+    "parse_pma_dispatch",
+    "list_pma_dispatches",
+    "list_pma_dispatches_for_turn",
+    "find_pma_dispatch_path",
+    "resolve_pma_dispatch",
+]

codex_autorunner/core/pma_lane_worker.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any, Awaitable, Callable, Optional
+
+from .pma_queue import PmaQueue, PmaQueueItem
+
+logger = logging.getLogger(__name__)
+
+PmaLaneExecutor = Callable[[PmaQueueItem], Awaitable[dict[str, Any]]]
+PmaLaneResultHook = Callable[
+    [PmaQueueItem, dict[str, Any]],
+    Optional[Awaitable[None]],
+]
+
+
+class PmaLaneWorker:
+    """Background worker that drains a PMA lane queue."""
+
+    def __init__(
+        self,
+        lane_id: str,
+        queue: PmaQueue,
+        executor: PmaLaneExecutor,
+        *,
+        log: Optional[logging.Logger] = None,
+        on_result: Optional[PmaLaneResultHook] = None,
+        poll_interval_seconds: float = 1.0,
+    ) -> None:
+        self.lane_id = lane_id
+        self._queue = queue
+        self._executor = executor
+        self._log = log or logger
+        self._on_result = on_result
+        self._poll_interval_seconds = max(0.1, poll_interval_seconds)
+        self._task: Optional[asyncio.Task[None]] = None
+        self._cancel_event = asyncio.Event()
+        self._lock = asyncio.Lock()
+
+    @property
+    def is_running(self) -> bool:
+        return self._task is not None and not self._task.done()
+
+    async def start(self) -> bool:
+        async with self._lock:
+            if self.is_running:
+                return False
+            self._cancel_event = asyncio.Event()
+            self._task = asyncio.create_task(self._run())
+            self._log.info("PMA lane worker started (lane_id=%s)", self.lane_id)
+            return True
+
+    async def stop(self) -> None:
+        async with self._lock:
+            task = self._task
+            if task is None:
+                return
+            self._cancel_event.set()
+        if task is not None:
+            try:
+                await task
+            finally:
+                self._log.info("PMA lane worker stopped (lane_id=%s)", self.lane_id)
+
+    async def _run(self) -> None:
+        await self._queue.replay_pending(self.lane_id)
+        while not self._cancel_event.is_set():
+            item = await self._queue.dequeue(self.lane_id)
+            if item is None:
+                await self._queue.wait_for_lane_item(
+                    self.lane_id,
+                    self._cancel_event,
+                    poll_interval_seconds=self._poll_interval_seconds,
+                )
+                continue
+
+            if self._cancel_event.is_set():
+                await self._queue.fail_item(item, "cancelled by lane stop")
+                await self._notify(item, {"status": "error", "detail": "lane stopped"})
+                continue
+
+            self._log.info(
+                "PMA lane item started (lane_id=%s item_id=%s)",
+                self.lane_id,
+                item.item_id,
+            )
+            try:
+                result = await self._executor(item)
+                await self._queue.complete_item(item, result)
+                self._log.info(
+                    "PMA lane item completed (lane_id=%s item_id=%s status=%s)",
+                    self.lane_id,
+                    item.item_id,
+                    result.get("status") if isinstance(result, dict) else None,
+                )
+                await self._notify(item, result)
+            except Exception as exc:
+                self._log.exception("Failed to process PMA queue item %s", item.item_id)
+                error_result = {"status": "error", "detail": str(exc)}
+                await self._queue.fail_item(item, str(exc))
+                self._log.info(
+                    "PMA lane item failed (lane_id=%s item_id=%s error=%s)",
+                    self.lane_id,
+                    item.item_id,
+                    str(exc),
+                )
+                await self._notify(item, error_result)
+
+    async def _notify(self, item: PmaQueueItem, result: dict[str, Any]) -> None:
+        if self._on_result is None:
+            return
+        try:
+            maybe = self._on_result(item, result)
+            if asyncio.iscoroutine(maybe):
+                await maybe
+        except Exception:
+            self._log.exception(
+                "PMA lane result hook failed (lane_id=%s item_id=%s)",
+                self.lane_id,
+                item.item_id,
+            )