alissa-tools-github-revloop 0.31.5__tar.gz → 0.31.7__tar.gz

{alissa_tools_github_revloop-0.31.5/src/main/alissa_tools_github_revloop.egg-info → alissa_tools_github_revloop-0.31.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-revloop
-Version: 0.31.5
+Version: 0.31.7
 Summary: ALISSA-TOOLS-GITHUB-REVLOOP
 Home-page: https://alissa.app
 Author: Fahera

{alissa_tools_github_revloop-0.31.5 → alissa_tools_github_revloop-0.31.7}/src/main/alissa/tools/github/revloop/alissa.py

@@ -248,12 +248,23 @@ _VERDICT_RE = re.compile(
 # own grammar; the reason runs to the end of the line and no further.
 READINESS_AUTO = "auto"
 READINESS_OPERATOR = "operator"
-_READINESS_RE = re.compile(
-    r"^[ \t]*(?:[-*+][ \t]+)?(?:\*\*)?[ \t]*Merge-Readiness[ \t]*:?[ \t]*(?:\*\*)?"
-    r"[ \t]*:?[ \t]*(?:\*\*)?(auto|operator)\b(?:\*\*)?"
-    r"(?:[ \t]*[—–-][ \t]*(.*?))?[ \t]*$",
-    re.MULTILINE,
-)
+
+
+def _envelope_line_re(key: str) -> "re.Pattern[str]":
+    """The tolerant envelope-line grammar for one readiness KEY. Two keys
+    share it (issue #148): `Merge-Readiness` on a code PR, `Commit-Readiness`
+    on a plan PR -- the same markdown tolerance, the same case-sensitive
+    value, the same first-match-wins."""
+    return re.compile(
+        r"^[ \t]*(?:[-*+][ \t]+)?(?:\*\*)?[ \t]*" + re.escape(key)
+        + r"[ \t]*:?[ \t]*(?:\*\*)?"
+        r"[ \t]*:?[ \t]*(?:\*\*)?(auto|operator)\b(?:\*\*)?"
+        r"(?:[ \t]*[—–-][ \t]*(.*?))?[ \t]*$",
+        re.MULTILINE,
+    )
+
+
+_READINESS_RE = _envelope_line_re("Merge-Readiness")
 
 # The operator reason's CLASS (issue #142). An `operator` judgment names WHY
 # the merge is a human's, and until now it did so in prose the merge edge
@@ -343,11 +354,19 @@ def _classed(value: "str | None", raw_reason: object) -> "tuple[str | None, str,
 # construction, a line this regex reads.
 READINESS_TRAILER_LABEL = "Merge-Readiness:"
 READINESS_MISSING = "missing"
-_TRAILER_RE = re.compile(
-    r"^" + re.escape(READINESS_TRAILER_LABEL)
-    + r"[ \t]*(auto|operator)(?:[ \t]*[—-][ \t]*(.+))?[ \t]*$",
-    re.MULTILINE,
-)
+
+
+def _trailer_line_re(label: str) -> "re.Pattern[str]":
+    """The strict bare-line grammar for one trailer LABEL (see _TRAILER_RE);
+    shared by the Merge- and the Commit-Readiness trailers (issue #148)."""
+    return re.compile(
+        r"^" + re.escape(label)
+        + r"[ \t]*(auto|operator)(?:[ \t]*[—-][ \t]*(.+))?[ \t]*$",
+        re.MULTILINE,
+    )
+
+
+_TRAILER_RE = _trailer_line_re(READINESS_TRAILER_LABEL)
 
 
 def parse_trailer(body: object) -> "tuple[str | None, str, str | None]":
@@ -388,6 +407,102 @@ def parse_readiness(blob: object) -> "tuple[str | None, str, str | None]":
     return _classed(match.group(1), match.group(2))
 
 
+# The Commit-Readiness judgment on a PLAN PR (issue #148; genloop design D8,
+# §6.3, §7.1). A plan PR is never a code merge candidate: what its approve
+# decides is whether merging the plan COMMITS its tasks, and orcloop's plan
+# close edge reads that off this trailer the way its merge edge reads
+# Merge-Readiness -- the same grammar with the other key:
+#
+#   Commit-Readiness: auto
+#   Commit-Readiness: operator — <class>: <one-line reason>
+#
+# Eleven classes in SEVERITY order, the enum orcloop copies verbatim: the
+# first six never auto-commit under any policy, the last five may. A task
+# file's `commitClass` draws on the last ten -- `unanchored` is the
+# refuter's alone. Same rules as the merge enum: exactly one class, the most
+# severe applicable; `auto` never carries one; an operator reason that leads
+# with no recognised token parses and reads as UNCLASSED (the hard hold).
+#
+# One rule is STRICTER than the merge grammar, because the acceptance names
+# it (c4): a class on an `auto` line is REFUSED WHOLE -- the line reads as
+# missing and the fallback holds -- rather than read as a bare `auto` with a
+# stray reason. An `auto` whose trailing text is class-shaped is a reviewer
+# that could not decide between the two forms, and the commit policy must
+# never resolve that doubt toward committing.
+COMMIT_READINESS_KEY = "Commit-Readiness"
+COMMIT_READINESS_CLASSES: "tuple[str, ...]" = (
+    "unanchored",         # the anchor does not resolve, is closed, or the sources are not its class
+    "schema-migration",   # a leaf's scope names **/schema.ts, **/migrations/**, a backfill or a migration
+    "auth-secrets",       # auth, permission gates, tokens, credentials, secrets, deploy env vars
+    "pricing-billing",    # pricing, credits, tiers, quotas, invoices, refunds
+    "customer-promise",   # copy or behaviour a customer is told about
+    "product-surface",    # a new screen, route, tool, command or exported type
+    "gate-verification",  # leaves that verify an unverified operator's-gate item
+    "drift-fix",          # leaves that make a lagging repo follow a fleet-wide contract change
+    "flaky-test",         # leaves that fix, quarantine or pin a test the loop capped out on
+    "exhaust-followup",   # leaves that carry [triage:later] replies and unpursued [minor]/[nit]
+    "doc-correction",     # leaves confined to docs, READMEs, API.md prose, design-doc pins
+)
+# The six that stay operator's under every commit policy (design §7.1).
+COMMIT_READINESS_OPERATOR_ONLY: "tuple[str, ...]" = COMMIT_READINESS_CLASSES[:6]
+COMMIT_READINESS_TRAILER_LABEL = COMMIT_READINESS_KEY + ":"
+_COMMIT_READINESS_RE = _envelope_line_re(COMMIT_READINESS_KEY)
+_COMMIT_TRAILER_RE = _trailer_line_re(COMMIT_READINESS_TRAILER_LABEL)
+_COMMIT_READINESS_CLASS_RE = re.compile(
+    r"^(" + "|".join(re.escape(klass) for klass in COMMIT_READINESS_CLASSES)
+    + r")[ \t]*:"
+)
+# What "a class on an auto line" looks like: the reason leads with a
+# `<token>:` -- a recognised class, a misspelt one or a merge-enum token
+# alike. Deliberately wider than the enum, for the reason above.
+_CLASS_SHAPED_RE = re.compile(r"^[A-Za-z][A-Za-z0-9-]*[ \t]*:")
+
+
+def classify_commit_readiness_reason(value: object, reason: object) -> "str | None":
+    """The COMMIT_READINESS_CLASSES token an `operator` reason leads with, or
+    None (auto, unclassed, misspelt, wrong case) -- classify_readiness_reason
+    over the commit enum."""
+    if value != READINESS_OPERATOR or not isinstance(reason, str):
+        return None
+    match = _COMMIT_READINESS_CLASS_RE.match(reason)
+    return match.group(1) if match else None
+
+
+def _commit_classed(
+    value: "str | None", raw_reason: object
+) -> "tuple[str | None, str, str | None]":
+    """The `(value, reason, klass)` triple both commit parsers hand back, with
+    the class-on-auto refusal applied."""
+    reason = clean_readiness_reason(raw_reason)
+    if value == READINESS_AUTO and _CLASS_SHAPED_RE.match(reason):
+        return (None, "", None)
+    return (value, reason, classify_commit_readiness_reason(value, reason))
+
+
+def parse_commit_trailer(body: object) -> "tuple[str | None, str, str | None]":
+    """`(value, reason, klass)` from the first bare `Commit-Readiness:` line of
+    a review body, or `(None, "", None)` -- parse_trailer with the other key,
+    plus the class-on-auto refusal."""
+    if not isinstance(body, str):
+        return (None, "", None)
+    match = _COMMIT_TRAILER_RE.search(body.replace("\r\n", "\n"))
+    if match is None:
+        return (None, "", None)
+    return _commit_classed(match.group(1), match.group(2))
+
+
+def parse_commit_readiness(blob: object) -> "tuple[str | None, str, str | None]":
+    """`(value, reason, klass)` from the first Commit-Readiness line of a
+    verdict envelope -- parse_readiness with the other key, plus the
+    class-on-auto refusal."""
+    if not isinstance(blob, str):
+        return (None, "", None)
+    match = _COMMIT_READINESS_RE.search(blob)
+    if match is None:
+        return (None, "", None)
+    return _commit_classed(match.group(1), match.group(2))
+
+
 @dataclass(frozen=True)
 class Task:
     ref: str  # TASK-<taskNumber>
@@ -467,6 +582,26 @@ def pane_path_argv(name: str) -> "list[str]":
     ]
 
 
+# What `#{pane_current_command}` reads on a reviewer pane whose `claude` has
+# EXITED (issue #146, devloop #140's set): the shell `alissa tmux new`
+# launched it from, back in the foreground. A live reviewer reads `node`
+# (Claude Code's runtime); a name here means the process the session was
+# spawned for is gone, whatever the session listing says about liveness.
+SHELL_COMMANDS = frozenset((
+    "bash", "sh", "zsh", "fish", "dash", "ksh", "ash", "tcsh", "csh",
+))
+
+
+def pane_command_argv(name: str) -> "list[str]":
+    """`tmux -S <socket> display-message -p -t =<real>: #{pane_current_command}`:
+    the foreground process of the session's active pane, by name."""
+    check_session_name(name)
+    return [
+        "tmux", "-S", tmux_socket(), "display-message", "-p",
+        "-t", tmux_target(name), "#{pane_current_command}",
+    ]
+
+
 def send_keys_argv(name: str, keys: "tuple[str, ...]") -> "list[str]":
     """`tmux -S <socket> send-keys -t =<real> <key>…` with every key drawn
     from `prompts.ALLOWED_KEYS`. Anything else -- a letter, a word, a path --
@@ -595,10 +730,19 @@ class ManagedSession:
         return parse_session_name(self.name)
 
 
-def _title_pattern(owner: str, repo: str, number: int) -> re.Pattern[str]:
-    """CR2 title convention: `Review PR <org>/<repo>#<n> (TASK-<origin>)`."""
+# The CR2 title's lead-in. A code PR's review task reads `Review PR …`; a PLAN
+# PR's reads `Review plan <org>/<repo>#<n> (<plan id>)` (issue #148, genloop
+# design §6.1) -- created downstream of nothing, since a plan has no origin
+# task. Both leads resolve to the same PR, so one pattern serves the daemon's
+# search, its cache check and `alissa-pr-review` alike.
+REVIEW_TASK_TITLE_LEAD = r"^Review\s+(?:PR|plan)\s+"
+
+
+def review_task_title_pattern(owner: str, repo: str, number: int) -> re.Pattern[str]:
+    """CR2 title convention: `Review PR <org>/<repo>#<n> (TASK-<origin>)`, or
+    `Review plan <org>/<repo>#<n> (<plan id>)` for a plan PR."""
     return re.compile(
-        rf"^Review PR\s+{re.escape(owner)}/{re.escape(repo)}#{number}\b",
+        rf"{REVIEW_TASK_TITLE_LEAD}{re.escape(owner)}/{re.escape(repo)}#{number}\b",
         re.IGNORECASE,
     )
 
@@ -613,7 +757,7 @@ def is_review_task_for(owner: str, repo: str, number: int, task: "Task") -> bool
     would either pin a wrong task forever or re-fetch the corpus every pass
     while disagreeing with itself.
     """
-    return bool(_title_pattern(owner, repo, number).match(task.title)) and task.is_open
+    return bool(review_task_title_pattern(owner, repo, number).match(task.title)) and task.is_open
 
 
 def _task_from_row(row: object) -> "Task | None":
@@ -656,11 +800,18 @@ class VerdictEnvelope:
     the narration reads the class back off the emitted line -- so the fact
     has one source, and a second copy here would be a reader-less field
     that could only ever drift from it (PR #143 round 1).
+
+    `commit_readiness` / `commit_readiness_reason` are the same pair for the
+    envelope's `Commit-Readiness` line (issue #148), read off the same
+    evidence item; only a PLAN PR's native post reads them, and a code PR's
+    envelope simply has none.
     """
 
     verdict: str
     readiness: "str | None" = None
     readiness_reason: str = ""
+    commit_readiness: "str | None" = None
+    commit_readiness_reason: str = ""
 
 
 @dataclass(frozen=True)
@@ -1167,6 +1318,9 @@ class Alissa:
                     readiness, reason, _ = parse_readiness(content)
                     if readiness is None:
                         readiness, reason, _ = parse_readiness(title)
+                    commit, commit_reason, _ = parse_commit_readiness(content)
+                    if commit is None:
+                        commit, commit_reason, _ = parse_commit_readiness(title)
                     found.append(
                         (Alissa._created_key(item.get("createdAt")),
                          index,
@@ -1174,6 +1328,8 @@ class Alissa:
                              verdict=match.group(1).lower(),
                              readiness=readiness,
                              readiness_reason=reason,
+                             commit_readiness=commit,
+                             commit_readiness_reason=commit_reason,
                          ))
                     )
                     break
@@ -1379,6 +1535,23 @@ class Alissa:
             log.debug("could not read the pane path of %s (%s)", name, exc)
             return ""
 
+    def pane_command(self, name: str) -> str:
+        """The session's pane current command (`#{pane_current_command}`),
+        or "" when tmux cannot answer. The first-turn death check's one
+        liveness probe (issue #146): a reviewer whose pane reads a shell
+        (`SHELL_COMMANDS`) has lost its `claude`, however alive the tmux
+        session itself is. A READ: runs under dry-run too."""
+        try:
+            argv = pane_command_argv(name)
+        except ValueError as exc:
+            log.warning("pane_command refused: %s", exc)
+            return ""
+        try:
+            return run(argv, timeout=15).strip()
+        except CommandError as exc:
+            log.debug("could not read the pane command of %s (%s)", name, exc)
+            return ""
+
     def send_keys(self, name: str, *keys: str, dry_run: bool = False) -> bool:
         """Press `keys` -- each one of `prompts.ALLOWED_KEYS`, nothing else
         -- on ONE managed session's pane. True when tmux accepted them.

{alissa_tools_github_revloop-0.31.5 → alissa_tools_github_revloop-0.31.7}/src/main/alissa/tools/github/revloop/config.py

@@ -181,6 +181,8 @@ CONFIG_KEYS = (
     "bows_refresh_polls",
     "bow_owners",
     "authors",
+    "plan_repos",
+    "plan_authors",
     "operators",
     "agent_profile",
     "reviewer_login",
@@ -231,6 +233,42 @@ REPOS_SOURCE_ENV = "ALISSA_REVIEW_REPOS_SOURCE"
 BOWS_REFRESH_POLLS_ENV = "ALISSA_REVIEW_BOWS_REFRESH_POLLS"
 BOW_OWNERS_ENV = "ALISSA_REVIEW_BOW_OWNERS"
 
+# The plan directive's two allowlists (issue #148; genloop design §6.1, D12).
+# A PR gets the PLAN directive only when all four signals hold, and two of
+# them are fleet configuration: the repository is one of `plan_repos` and the
+# author one of `plan_authors`. Same `|`/`,` rail as the bows keys, same
+# env > file > default precedence, same blank-falls-through rule.
+#
+# The plans repository is CONFIGURATION, never a literal in the code (the
+# operator's decision on issue #148 -- the design's own name for it is
+# superseded): the default names the repository by NAME under the
+# `<owner>` placeholder, which matches that name under any owner, and a
+# deployment names its own with the variable. A test proves no plans-repo
+# literal survives outside this module.
+#
+# FAIL-CLOSED, and deliberately unlike `authors`: an EMPTY `plan_authors`
+# means NO PR is a plan PR -- every PR, the plans repository's included, is
+# reviewed under the code directive. The plan directive is a different
+# contract (no code rubric, a Commit-Readiness trailer the plan close edge
+# commits on), so it must be switched on by naming the generator's login,
+# never by default. An empty `plan_repos` (the variable set to a lone
+# separator, say) means the same.
+PLAN_REPOS_ENV = "ALISSA_REVIEW_PLAN_REPOS"
+PLAN_AUTHORS_ENV = "ALISSA_REVIEW_PLAN_AUTHORS"
+PLAN_REPO_OWNER_PLACEHOLDER = "<owner>"
+DEFAULT_PLAN_REPO_NAME = "alissa-dark-factory-plans"
+DEFAULT_PLAN_REPOS: "tuple[str, ...]" = (
+    f"{PLAN_REPO_OWNER_PLACEHOLDER}/{DEFAULT_PLAN_REPO_NAME}",
+)
+# `owner/repo`, or `<owner>/repo`; GitHub's own character sets.
+_PLAN_REPO_RE = re.compile(
+    r"^(?:" + re.escape(PLAN_REPO_OWNER_PLACEHOLDER)
+    + r"|[A-Za-z0-9](?:[A-Za-z0-9-]{0,38}))/[A-Za-z0-9._-]{1,100}\Z"
+)
+# A GitHub login, or a GitHub App's `<slug>[bot]` login.
+_GITHUB_LOGIN_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9-]{0,38}(?:\[bot\])?\Z")
+_LIST_SEPARATORS = re.compile(r"[|,]")
+
 # The default Studio API base the loop-events client posts to. Mirrors
 # alissa_client.DEFAULT_ENDPOINT (a test pins the two together); defined here
 # too so config stays importable without the client module.
@@ -377,6 +415,30 @@ def env_bow_owners(environ: "Mapping[str, str] | None" = None) -> "str | None":
     return _env_text(BOW_OWNERS_ENV, environ)
 
 
+def env_plan_list(name: str, environ: "Mapping[str, str] | None" = None) -> "list[str] | None":
+    """One plan allowlist rail (`PLAN_REPOS_ENV` / `PLAN_AUTHORS_ENV`) split on
+    `|` and `,`, or None when unset/blank. A value of separators only is an
+    EMPTY list, not None: the operator said something, and what they said is
+    "nothing" -- which for these keys is the fail-closed answer."""
+    raw = _env_text(name, environ)
+    if raw is None:
+        return None
+    return [part.strip() for part in _LIST_SEPARATORS.split(raw) if part.strip()]
+
+
+def _plan_list(value: Any, key: str, what: str, shape: "re.Pattern[str]") -> "tuple[str, ...]":
+    """A plan allowlist as a tuple of validated entries. A malformed entry is
+    refused at load, naming it -- a typo in a trust gate must not read as an
+    entry that silently matches nothing."""
+    entries = _string_list(value, key, what)
+    bad = [entry for entry in entries if not shape.match(entry)]
+    if bad:
+        raise ValueError(
+            f"{key} must be a list of {what}, got {', '.join(repr(b) for b in bad)}"
+        )
+    return entries
+
+
 def normalize_bow_owners(values: "Any") -> "tuple[str, ...]":
     """Validate the `bow_owners` layer value into the authority list.
 
@@ -768,6 +830,13 @@ class Config:
     # want agent reviews.
     authors: tuple[str, ...] = ()
 
+    # The plan directive's repository and author allowlists (issue #148); see
+    # PLAN_REPOS_ENV above. `plan_repos` entries are `owner/repo` or
+    # `<owner>/repo` (any owner); `plan_authors` EMPTY means no PR is a plan
+    # PR -- fail closed, the opposite of `authors`.
+    plan_repos: tuple[str, ...] = DEFAULT_PLAN_REPOS
+    plan_authors: tuple[str, ...] = ()
+
     # GitHub logins whose re-entry ack may raise a capped PR's effective cap
     # (loop.parse_reentry_ack). Empty -- the default -- means NO ack is ever
     # honoured: the lever fails closed, because anyone who can comment on a PR
@@ -1007,6 +1076,29 @@ class Config:
             return True
         return login.lower() in {a.lower() for a in self.authors}
 
+    def is_plan_repo(self, full_name: str) -> bool:
+        """Whether `owner/repo` is a plans repository -- signal one of four.
+
+        Case-insensitive, like `watches` under bows: GitHub names are. An
+        entry whose owner is the `<owner>` placeholder matches its repository
+        name under any owner, which is how the default names the plans
+        repository without naming a fleet."""
+        owner, _, name = full_name.partition("/")
+        for entry in self.plan_repos:
+            want_owner, _, want_name = entry.partition("/")
+            if want_name.casefold() != name.casefold():
+                continue
+            if want_owner == PLAN_REPO_OWNER_PLACEHOLDER:
+                return True
+            if want_owner.casefold() == owner.casefold():
+                return True
+        return False
+
+    def is_plan_author(self, login: str) -> bool:
+        """Whether a PR by this login may be a plan PR -- signal two of four.
+        EMPTY means NOBODY (fail closed; see the field)."""
+        return bool(login) and login.lower() in {a.lower() for a in self.plan_authors}
+
     @classmethod
     def build(
         cls,
@@ -1095,6 +1187,13 @@ class Config:
         env_owners = env_bow_owners(environ)
         if env_owners is not None:
             raw["bow_owners"] = env_owners
+        # The plan allowlists (issue #148), same rail, same reason.
+        env_plan_repos = env_plan_list(PLAN_REPOS_ENV, environ)
+        if env_plan_repos is not None:
+            raw["plan_repos"] = env_plan_repos
+        env_plan_authors = env_plan_list(PLAN_AUTHORS_ENV, environ)
+        if env_plan_authors is not None:
+            raw["plan_authors"] = env_plan_authors
 
         source = raw.get("repos_source", cls.repos_source)
         if source not in _REPOS_SOURCES:
@@ -1145,6 +1244,15 @@ class Config:
         operators = _string_list(
             raw.get("operators", ()), "operators", "GitHub logins"
         )
+        plan_repos = _plan_list(
+            raw.get("plan_repos", cls.plan_repos), "plan_repos",
+            f"owner/repo (or {PLAN_REPO_OWNER_PLACEHOLDER}/repo) entries",
+            _PLAN_REPO_RE,
+        )
+        plan_authors = _plan_list(
+            raw.get("plan_authors", cls.plan_authors), "plan_authors",
+            "GitHub logins", _GITHUB_LOGIN_RE,
+        )
         if hub_mode == HUB_ADD and not repos and source == REPOS_STATIC:
             # Anyone who can request a review could otherwise cause an arbitrary
             # repo to be cloned onto this machine and opened as an agent's cwd.
@@ -1344,6 +1452,8 @@ class Config:
             bows_refresh_polls=refresh_polls,
             bow_owners=bow_owners,
             authors=authors,
+            plan_repos=plan_repos,
+            plan_authors=plan_authors,
             operators=operators,
             agent_profile=raw.get("agent_profile", "claude"),
             reviewer_login=raw.get("reviewer_login"),

{alissa_tools_github_revloop-0.31.5 → alissa_tools_github_revloop-0.31.7}/src/main/alissa/tools/github/revloop/ghclient.py

@@ -202,6 +202,13 @@ class PullRequest:
     # `requested_teams` is a separate field and is deliberately not carried,
     # because nothing in the loop may ever withdraw a team's request.
     requested_reviewers: tuple[str, ...] = ()
+    # The head BRANCH name and the PR body, read off the same payload. Two of
+    # the four signals that make a PR a PLAN PR (issue #148, genloop design
+    # §6.1): a `PLAN-<stamp>-<slug>` head ref and the plan marker on a line of
+    # its own in the body. Both are PR-author text -- they select a directive
+    # and are never interpolated into one.
+    head_ref: str = ""
+    body: str = ""
 
     @property
     def full_name(self) -> str:
@@ -311,6 +318,11 @@ class CheckRollup:
     # than the one it stands in for (see ACTIONS_FALLBACK_NOTE), so the answer
     # carries which path produced it everywhere the rollup is reported.
     via_actions_fallback: bool = False
+    # Every context read, passing ones included -- what a gate keyed on ONE
+    # named check reads (the plan-lint gate, issue #148). `failing` and
+    # `running` answer "may an approve claim this head?"; only this answers
+    # "did the check called X conclude success?".
+    contexts: tuple[CheckContext, ...] = ()
 
     @property
     def summary(self) -> str:
@@ -393,6 +405,7 @@ def rollup_of(
         running=running,
         total=len(contexts),
         via_actions_fallback=via_actions_fallback,
+        contexts=tuple(contexts),
     )
 
 
@@ -697,6 +710,8 @@ class GitHub:
                 for u in (data.get("requested_reviewers") or [])
                 if (u or {}).get("login")
             ),
+            head_ref=str((data.get("head") or {}).get("ref") or ""),
+            body=str(data.get("body") or ""),
         )
 
     def reviews(self, owner: str, repo: str, number: int) -> list[Review]: