alissa-tools-github-revloop 0.31.9__tar.gz → 0.31.10__tar.gz

{alissa_tools_github_revloop-0.31.9/src/main/alissa_tools_github_revloop.egg-info → alissa_tools_github_revloop-0.31.10}/PKG-INFO

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

{alissa_tools_github_revloop-0.31.9 → alissa_tools_github_revloop-0.31.10}/src/main/alissa/tools/github/revloop/alissa.py

@@ -527,6 +527,32 @@ def parse_commit_readiness(blob: object) -> "tuple[str | None, str, str | None]"
     return _commit_classed(match.group(1), match.group(2))
 
 
+# The contract version the reviewer judged against (issue #155; Studio
+# design `loop-operator-surface.md` §6.4, lanes L10/L11): the reviewer reads
+# the task at round start and records `**Contract:** v<n>` under the reviewed
+# head. The same markdown tolerance as the readiness lines -- an optional
+# bullet, optional bold around the label with the colon inside or outside --
+# but the `v` is REQUIRED: L11 has not shipped the line yet, and without it any
+# prose that opens with `Contract` and a number (`Contract 3 criteria
+# re-checked`) would set the version (PR #156 round 1). Absent (every
+# envelope written before L11 ships) reads as None, never as v1: the event's
+# key is then null, the design's "absent" case, rather than a version nobody
+# recorded.
+_CONTRACT_RE = re.compile(
+    r"^[ \t]*(?:[-*+][ \t]+)?(?:\*\*)?[ \t]*Contract[ \t]*:?[ \t]*(?:\*\*)?"
+    r"[ \t]*:?[ \t]*(?:\*\*)?[ \t]*v(\d{1,9})\b",
+    re.MULTILINE,
+)
+
+
+def parse_contract_version(blob: object) -> "int | None":
+    """The `Contract: v<n>` an envelope records, as an int, or None."""
+    if not isinstance(blob, str):
+        return None
+    match = _CONTRACT_RE.search(blob)
+    return None if match is None else int(match.group(1))
+
+
 @dataclass(frozen=True)
 class Task:
     ref: str  # TASK-<taskNumber>
@@ -829,6 +855,9 @@ class VerdictEnvelope:
     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.
+
+    `contract_version` is the envelope's `Contract: v<n>` (issue #155), or
+    None when it records none -- read for the `round.verdict` event only.
     """
 
     verdict: str
@@ -836,6 +865,7 @@ class VerdictEnvelope:
     readiness_reason: str = ""
     commit_readiness: "str | None" = None
     commit_readiness_reason: str = ""
+    contract_version: "int | None" = None
 
 
 @dataclass(frozen=True)
@@ -854,11 +884,16 @@ class TaskDetail:
     `verdict` is None when no envelope on the task parses -- the normal round-1
     case, indistinguishable here from "no verdict of record yet", which is what
     the caller wants it to mean anyway.
+
+    `envelope` is that same newest envelope whole (issue #155): the
+    `round.verdict` event of a session-closed round reads its readiness and
+    contract version off the read that already knew the verdict word.
     """
 
     task: Task
     verdicts: int
     verdict: "str | None"
+    envelope: "VerdictEnvelope | None" = None
 
 
 class Alissa:
@@ -1182,10 +1217,12 @@ class Alissa:
             task = _task_from_row(data)
             if task is None:
                 return None
+            envelope = self._newest_envelope(data)
             return TaskDetail(
                 task=task,
                 verdicts=self._count_verdicts(data),
-                verdict=self._newest_verdict(data),
+                verdict=None if envelope is None else envelope.verdict,
+                envelope=envelope,
             )
         except Exception:  # pragma: no cover - defence in depth
             log.exception("could not parse task payload for %s", ref)
@@ -1348,6 +1385,9 @@ class Alissa:
                     commit, commit_reason, _ = parse_commit_readiness(content)
                     if commit is None:
                         commit, commit_reason, _ = parse_commit_readiness(title)
+                    contract = parse_contract_version(content)
+                    if contract is None:
+                        contract = parse_contract_version(title)
                     found.append(
                         (Alissa._created_key(item.get("createdAt")),
                          index,
@@ -1357,6 +1397,7 @@ class Alissa:
                              readiness_reason=reason,
                              commit_readiness=commit,
                              commit_readiness_reason=commit_reason,
+                             contract_version=contract,
                          ))
                     )
                     break

{alissa_tools_github_revloop-0.31.9 → alissa_tools_github_revloop-0.31.10}/src/main/alissa/tools/github/revloop/loop.py

@@ -100,6 +100,10 @@ from .loop_events import (
     auth_rejected_prefix,
     build_emitter,
     credential_identity,
+    recorded_round_verdicts,
+    round_verdict_kind,
+    round_verdict_prefix,
+    ROUND_VERDICT_PREFIX,
 )
 from .proc import CommandError
 from .state import State
@@ -136,6 +140,22 @@ STALLED_DEFER_MULTIPLE = 2
 # of the operator noticing nothing.
 VERDICT_POST_GRACE_SECONDS = 5 * 60
 
+# The `round.verdict` word for each native post event (issue #155): the
+# verdict of record is what GitHub holds, so an approve the CI gate turned into
+# a REQUEST_CHANGES or a COMMENT reports as that (PR #156 round 1).
+_POSTED_VERDICT = {
+    EVENT_APPROVE: VERDICT_APPROVE,
+    EVENT_REQUEST_CHANGES: VERDICT_REQUEST_CHANGES,
+    EVENT_COMMENT: "comment",
+}
+
+# How far back the round-verdict sweep looks in the spawn ledger
+# (`sweep_round_verdicts`). A session-closed round is recorded within a poll
+# or two of its envelope landing; the window bounds what a round whose
+# verdict NEVER lands (a PR closed mid-round, a session that died with the
+# request already withdrawn) costs: one task read per pass, for a day.
+ROUND_VERDICT_SWEEP_WINDOW_SECONDS = 24 * 60 * 60
+
 # Failed post attempts before the daemon stops treating it as transient and
 # pages a human. It keeps retrying afterwards -- the round stays OPEN either
 # way, which is the invariant -- but a permanent failure (a revoked token, a
@@ -2250,6 +2270,10 @@ class ResolvedTask:
     verdicts: int = 0
     verdict: "str | None" = None
     verdict_read: bool = False
+    # The newest envelope whole, when the resolution read a task detail
+    # (issue #155): the session-closed round's `round.verdict` reads its
+    # readiness and contract version off it. None on the bare-count fallback.
+    envelope: "VerdictEnvelope | None" = None
 
     @classmethod
     def from_detail(cls, detail: TaskDetail) -> "ResolvedTask":
@@ -2264,6 +2288,7 @@ class ResolvedTask:
             verdicts=detail.verdicts,
             verdict=detail.verdict,
             verdict_read=True,
+            envelope=detail.envelope,
         )
 
     def newest_verdict(self, alissa: Alissa) -> "str | None":
@@ -2988,6 +3013,12 @@ class ReviewWatcher:
         # decides nothing -- it reports; and it must run on the pass that
         # converges, since a converged PR leaves the search set.
         self._observe_session_readiness(pr, my_reviews, completed)
+        # Same placement, same reason (issue #155): a session-closed round's
+        # verdict of record is recorded for `round.verdict` on the pass that
+        # sees it -- including the pass that converges.
+        self._observe_round_verdict(
+            pr, resolved, my_reviews, completed, task is not None and owed <= native,
+        )
 
         if task is not None and owed > native:
             # Terminal for this pass either way. On a landed post the review
@@ -4289,6 +4320,21 @@ class ReviewWatcher:
         )
         class_term = readiness_class_term(posted_value, posted_class)
         readiness_name = "commit-readiness" if plan else "readiness"
+        # The verdict of record, for the `round.verdict` event (issue #155):
+        # what the posted review CARRIES -- the readiness read back off the
+        # emitted trailer, so an approve whose envelope had no line reads
+        # `operator` with the unclassed marker, exactly what the merge edge
+        # will see -- and nothing on a degraded or request_changes post. The
+        # verdict word is the POSTED event's, not the envelope's: an approve
+        # the CI gate downgraded is a `request_changes` or `comment` on
+        # GitHub, and an event saying `approve` would count an approval the
+        # merge edge never acts on (PR #156 round 1).
+        self._record_round_verdict(
+            pr, round_, judged, _POSTED_VERDICT.get(event, verdict),
+            posted_value if trailer else None, posted_class,
+            envelope.contract_version if envelope is not None else None,
+            task.ref,
+        )
         readiness_note = (
             f" {readiness_name}={readiness_value}{class_term}" if trailer else ""
         )
@@ -4975,6 +5021,208 @@ class ReviewWatcher:
             deferred=True,
         )
 
+    def _record_round_verdict(
+        self,
+        pr: PullRequest,
+        round_: int,
+        head: str,
+        verdict: "str | None",
+        readiness: "str | None",
+        klass: "str | None",
+        contract_version: "int | None",
+        task_ref: "str | None",
+    ) -> bool:
+        """Record round `round_`'s verdict of record ONCE, as the ledger row
+        the `round.verdict` loop event derives from (issue #155; see
+        loop_events.round_verdict_kind).
+
+        Once per (PR, round): the first record wins, whichever path wrote it
+        -- the native post records at post time, a session-closed round on
+        the first pass that sees it. Never under `--dry-run`, which shares
+        the production ledger and must leave no durable row behind (see
+        `_warn_identity_drift`). True when THIS call wrote the row.
+        """
+        if self.config.dry_run:
+            return False
+        prefix = round_verdict_prefix(round_)
+        if any(
+            row["repo"] == pr.full_name and int(row["number"]) == pr.number
+            for row in self.state.read_pings(kind_prefix=prefix)
+        ):
+            return False
+        self.state.record_ping(
+            pr.full_name, pr.number,
+            round_verdict_kind(
+                round_, head, verdict, readiness, klass, contract_version, task_ref,
+            ),
+        )
+        return True
+
+    def _observe_round_verdict(
+        self,
+        pr: PullRequest,
+        resolved: "ResolvedTask",
+        my_reviews: list[Review],
+        round_: int,
+        closed_by_session: bool,
+    ) -> bool:
+        """Record a SESSION-closed round's verdict of record (issue #155).
+        True when this call recorded it.
+
+        The round is `round_` (the envelopes counted on the review task) and
+        it is the session's when its own review exists on GitHub
+        (`closed_by_session`: the native count has caught up with the
+        envelopes) and the daemon neither posted nor abandoned a fallback for
+        it. The verdict, the readiness and the contract version come from the
+        envelope -- the verdict of record (D3) -- with the readiness mapped
+        exactly as the native post maps it (readiness_trailer, read back with
+        the trailer grammar): an approve whose envelope names none is
+        `operator`, unclassed. A request_changes carries no readiness. The
+        head is the session's own newest review's commit, else the head the
+        round was queued against (`_round_review_head`).
+
+        Reached from two places, because a session's own review consumes the
+        review request and so drops its PR out of the search that feeds
+        evaluate() at exactly the moment its round closes: evaluate() for a
+        PR still in the search, and `sweep_round_verdicts` -- search-
+        independent, off the spawn ledger -- for every other one (PR #156
+        round 1). Once per round either way (`_record_round_verdict`).
+
+        Observation only: nothing is posted or narrated, and a resolution
+        that did not read the envelope (the bare-count fallback) records
+        nothing this pass -- the next pass reads it on the cached path.
+        """
+        envelope = resolved.envelope
+        if (
+            not closed_by_session
+            or resolved.task is None
+            or envelope is None
+            or round_ < 1
+            or envelope.verdict not in (VERDICT_APPROVE, VERDICT_REQUEST_CHANGES)
+        ):
+            return False
+        row = self.state.get_verdict_post(pr.full_name, pr.number, round_)
+        if row is not None and (row["posted_at"] or row["abandoned_at"]):
+            return False  # the native path's round: recorded there, or released
+        readiness = klass = None
+        if envelope.verdict == VERDICT_APPROVE:
+            if is_plan_pr(self.config, pr):
+                readiness, _, klass = parse_commit_trailer(commit_readiness_trailer(envelope))
+            else:
+                readiness, _, klass = parse_trailer(readiness_trailer(envelope))
+        head = self._round_review_head(pr, my_reviews, round_)
+        return self._record_round_verdict(
+            pr, round_, head, envelope.verdict, readiness, klass,
+            envelope.contract_version, resolved.task.ref,
+        )
+
+    def _round_review_head(
+        self, pr: PullRequest, my_reviews: list[Review], round_: int
+    ) -> str:
+        """The commit round `round_`'s session review judged.
+
+        NOT simply the newest review (PR #156 round 1): on the first pass after
+        an upgrade, and on any pass where round k+1's session has submitted its
+        review but not yet written its envelope, the envelope count still says
+        k while the newest review is k+1's -- and round k would be keyed on
+        k+1's commit. Nor "the newest review on the queued head": a round
+        re-requested without a push shares its queued head with the round
+        before it, whose review is then the match.
+
+        So it is the review `countable_rounds` counts as this round's -- the
+        first one whose prefix of the list reaches it -- discounting the
+        abandoned rounds, which hold an envelope and no review. When no prefix
+        reaches it (the reviews list lags), the head the round was queued
+        against (`_judged_head`).
+        """
+        target = round_ - self.state.abandoned_rounds(pr.full_name, pr.number)
+        for i, rev in enumerate(my_reviews if target >= 1 else []):
+            if countable_rounds(my_reviews[:i + 1]) >= target:
+                if rev.commit_id:
+                    return rev.commit_id
+                break
+        return self._judged_head(pr, round_)
+
+    def sweep_round_verdicts(self, searched: "set[tuple[str, int]]") -> int:
+        """Record the session-closed rounds the search can no longer see.
+        Runs every poll, after the per-PR evaluate loop. Returns the number of
+        rounds recorded this pass.
+
+        evaluate() is fed by the review-requested:@me search, and a reviewer
+        session's own review CLEARS that request -- so a round the session
+        closed leaves the search at the moment its verdict lands. Recording it
+        only from evaluate() deferred round k to the re-request of round k+1
+        and never recorded a terminal round at all: the final approve, a
+        request_changes nobody re-requests, a cap-out (PR #156 round 1, the
+        same trap the reap sweep's docstring names). This sweep is search-
+        independent for the same reason the reap sweep is: it starts from the
+        spawn ledger, which cannot lose a round.
+
+        Candidates: the NEWEST spawn row of each PR, spawned inside
+        ROUND_VERDICT_SWEEP_WINDOW_SECONDS, whose round has no `round-verdict:`
+        row yet, and whose PR this pass's search did not return (evaluate()
+        already looked at those). Older rounds of a PR were recorded by the
+        evaluate() pass that spawned their successor, which the search fed.
+
+        Cost, per candidate per pass: one task read by the ledger's task ref --
+        the reap sweep's choice, for its reason: find_review_task's open-status
+        filter loses a review task validated right after the final approve,
+        which is precisely the round this sweep exists for. Only when that read
+        shows the round's envelope landed does the sweep fetch the PR and its
+        reviews (two calls), and then the round is recorded and stops being a
+        candidate. A spawn row with no task ref (a round 1 recorded before the
+        review task existed) falls back to the cached PR -> task mapping, and
+        is skipped when there is none.
+
+        Not gated on `watches`: the round was spawned by this daemon, and a
+        repo dropping out of the allowlist after its final approve must not
+        lose the verdict. Never in `--dry-run` (nothing would be recorded).
+        Best-effort: a failed read skips the candidate until the next pass.
+        """
+        if self.config.dry_run:
+            return 0
+        since = time.time() - ROUND_VERDICT_SWEEP_WINDOW_SECONDS
+        newest: dict[tuple[str, int], dict] = {}
+        for row in self.state.read_spawns(since=since):
+            key = (row["repo"], int(row["number"]))
+            if key not in newest or int(row["round"]) > int(newest[key]["round"]):
+                newest[key] = row
+        recorded = recorded_round_verdicts(
+            self.state.read_pings(kind_prefix=ROUND_VERDICT_PREFIX)
+        )
+        count = 0
+        for (full_name, number), row in sorted(newest.items()):
+            round_ = int(row["round"])
+            if (full_name, number) in searched or (full_name, number, round_) in recorded:
+                continue
+            ref = row["task_ref"] or self.state.review_task(full_name, number)
+            if not ref or "/" not in full_name:
+                continue
+            owner, repo = full_name.split("/", 1)
+            try:
+                detail = self.alissa.get_task(ref)
+                if detail is None or detail.verdicts < round_:
+                    continue  # unreadable, or the round's envelope has not landed
+                pr = self.github.pull_request(owner, repo, number)
+                my_reviews = self.github.my_reviews(owner, repo, number)
+            except RateLimited:
+                raise
+            except CommandError as exc:
+                log.debug("round-verdict sweep: %s#%d skipped: %s", full_name, number, exc)
+                continue
+            resolved = ResolvedTask.from_detail(detail)
+            owed = resolved.verdicts - self.state.abandoned_rounds(full_name, number)
+            if self._observe_round_verdict(
+                pr, resolved, my_reviews, resolved.verdicts,
+                owed <= countable_rounds(my_reviews),
+            ):
+                log.info(
+                    "%s round %d: session-closed verdict recorded off-search",
+                    pr.slug, resolved.verdicts,
+                )
+                count += 1
+        return count
+
     def _observe_session_readiness(
         self, pr: PullRequest, my_reviews: list[Review], round_: int
     ) -> None:
@@ -7264,6 +7512,19 @@ class ReviewWatcher:
 
         self._note_deferrals(results)
 
+        # AFTER the evaluate loop (which records the rounds of every PR the
+        # search returned) and BEFORE the loop-events push, so a round the
+        # sweep records this pass is emitted this pass. Search-independent on
+        # purpose: see sweep_round_verdicts. Telemetry, so never fatal to the
+        # pass -- the same promise _emit_loop_events keeps -- except for the
+        # rate limit, whose backoff belongs to run_forever.
+        try:
+            self.sweep_round_verdicts(live_keys)
+        except RateLimited:
+            raise
+        except Exception:
+            log.warning("round-verdict sweep failed; retried next pass", exc_info=True)
+
         # Persist one poll_snapshots row per pass, built entirely from the
         # Decision list already in hand plus the reap count -- no new GitHub
         # calls. Written in dry-run too: a snapshot OBSERVES the pass, it is

{alissa_tools_github_revloop-0.31.9 → alissa_tools_github_revloop-0.31.10}/src/main/alissa/tools/github/revloop/loop_events.py

@@ -76,6 +76,21 @@ round) -- `round.spawned`, `round.verdict`, `round.abandoned`,
 `round.capped` and both gates' `checks.held` -- carries `data.kind: "plan"`.
 A code round carries no `kind` at all, so every pre-existing payload is
 unchanged byte for byte.
+
+``round.verdict`` is posted for EVERY verdict of record (issue #155; Studio
+design `loop-operator-surface.md` §1.3, §6.4, lane L10), not only for the
+rounds the daemon closed with its native fallback post. The fact is again a
+ledger ROW: when a round's verdict of record exists -- the daemon's own
+native post landed, or the session's own review closed the round and the
+review task's envelope says what it decided -- the watcher records ONE
+`round-verdict:` ping for that (PR, round) (`round_verdict_kind`), carrying
+the verdict word, the head, the readiness the approve carries and its class,
+the envelope's `Contract: v<n>` and the review task's ref. Every
+`round.verdict` has the same six data keys -- `verdict`, `headSha`,
+`readiness`, `readinessClass`, `contractVersion`, `taskRef` -- null when
+the ledger does not know one, and is keyed on `(repo, pr, round, head)`, so a
+native post's `verdict_posts` row and its ping derive ONE event (the row's,
+with the ping folded in), never two.
 """
 
 from __future__ import annotations
@@ -133,6 +148,30 @@ ROUND_EVENT_KINDS = frozenset({
     "checks.held",
 })
 
+# The verdict-of-record row (issue #155): one per (PR, round),
+# `round-verdict:<round>@<head>:<verdict>:<readiness>:<class>:<contract>:<taskRef>`.
+# The round leads so "already recorded for this round" is one prefix read
+# (`round_verdict_prefix`); every later field is drawn from a closed
+# vocabulary or a ref/sha the daemon itself holds, and is empty when unknown.
+# `class` is the READINESS_CLASSES token, or ROUND_VERDICT_UNCLASSED on an
+# operator judgment that names none -- the marker the merge policy holds on.
+ROUND_VERDICT_PREFIX = "round-verdict:"
+_ROUND_VERDICT_RE = re.compile(
+    r"^round-verdict:(?P<round>\d+)@(?P<head>[^:@]*):(?P<verdict>[a-z_]*):"
+    r"(?P<readiness>[a-z]*):(?P<klass>[a-z-]*):(?P<contract>\d*):"
+    r"(?P<task>[A-Za-z0-9_-]*)$"
+)
+ROUND_VERDICT_UNCLASSED = "unclassed"
+# Each field's own vocabulary, the same character classes the regex above
+# reads back -- so a value the writer accepts is one the reader parses.
+_ROUND_VERDICT_FIELDS = {
+    "head": re.compile(r"^[^:@]*$"),
+    "verdict": re.compile(r"^[a-z_]*$"),
+    "klass": re.compile(r"^[a-z-]*$"),
+    "contract": re.compile(r"^\d*$"),
+    "task": re.compile(r"^[A-Za-z0-9_-]*$"),
+}
+
 # The `auth.rejected` row (issue #146): one per SESSION,
 # `auth-rejected:<session>#<round>:<source>:<matched>:<envName>:<suffix>`.
 # The session leads so "already recorded for this session" is one prefix read
@@ -216,6 +255,91 @@ def auth_rejected_key(session: str) -> str:
     return f"{SEAT}:auth.rejected:{session}"
 
 
+def round_verdict_prefix(round_: int) -> str:
+    """The prefix every `round-verdict:` row of ONE round starts with -- the
+    watcher's "already recorded" read, scoped to the PR by the row's own
+    (repo, number) columns."""
+    return f"{ROUND_VERDICT_PREFIX}{int(round_)}@"
+
+
+def round_verdict_kind(
+    round_: int,
+    head: "str | None",
+    verdict: "str | None",
+    readiness: "str | None",
+    klass: "str | None",
+    contract_version: "int | None",
+    task_ref: "str | None",
+) -> str:
+    """The ledger kind of ONE verdict of record (see ROUND_VERDICT_PREFIX).
+    A field outside its vocabulary is written empty -- the row is the
+    event's source and its grammar is closed -- and a class on anything but
+    an `operator` readiness is dropped (`auto` never carries one)."""
+    def field(value: object, name: str) -> str:
+        text = "" if value is None else str(value)
+        return text if _ROUND_VERDICT_FIELDS[name].fullmatch(text) else ""
+
+    readiness_text = readiness if readiness in ("auto", "operator") else ""
+    klass_text = (
+        field(klass or ROUND_VERDICT_UNCLASSED, "klass")
+        if readiness_text == "operator" else ""
+    )
+    contract = "" if contract_version is None else field(int(contract_version), "contract")
+    return (
+        f"{round_verdict_prefix(round_)}{field(head, 'head')}:"
+        f"{field(verdict, 'verdict')}:{readiness_text}:{klass_text}:"
+        f"{contract}:{field(task_ref, 'task')}"
+    )
+
+
+def _round_verdicts(
+    pings: "list[dict]",
+) -> "dict[tuple[str, int, int], tuple[int, dict]]":
+    """Every parseable `round-verdict:` row, by (repo, PR, round), as
+    (pinged_at, the parsed fields). One row per round by construction (the
+    watcher checks the prefix first); should two ever exist, the OLDEST --
+    the first record of the round -- wins."""
+    out: "dict[tuple[str, int, int], tuple[int, dict]]" = {}
+    for row in pings:
+        match = _ROUND_VERDICT_RE.match(str(row["kind"]))
+        if match is None:
+            continue
+        key = (row["repo"], int(row["number"]), int(match.group("round")))
+        at = int(row["pinged_at"])
+        if key in out and out[key][0] <= at:
+            continue
+        out[key] = (at, match.groupdict())
+    return out
+
+
+def recorded_round_verdicts(pings: "list[dict]") -> "set[tuple[str, int, int]]":
+    """The (repo, PR, round) of every parseable `round-verdict:` row -- the
+    round-verdict sweep's "already recorded" read, one ledger read per pass."""
+    return set(_round_verdicts(pings))
+
+
+def _verdict_data(
+    verdict: "str | None", head: str, fields: "dict | None"
+) -> "dict[str, Any]":
+    """The six keys every `round.verdict` carries (issue #155), null where
+    the ledger does not know one. `fields` is the round's parsed
+    `round-verdict:` row, or None (a `verdict_posts` row that predates it)."""
+    fields = fields or {}
+    contract = fields.get("contract") or ""
+    # The ping's word first: it is what the posted review carries, where the
+    # `verdict_posts` row stores the envelope's (an approve the CI gate
+    # downgraded is not an approve on GitHub -- PR #156 round 1). The row's
+    # word is the fallback for a row that predates the ping.
+    return {
+        "verdict": fields.get("verdict") or verdict or None,
+        "headSha": head,
+        "readiness": fields.get("readiness") or None,
+        "readinessClass": fields.get("klass") or None,
+        "contractVersion": int(contract) if contract else None,
+        "taskRef": fields.get("task") or None,
+    }
+
+
 def _ms(seconds: "int | float") -> int:
     """A ledger stamp (epoch seconds) as the API's epoch-ms `at`."""
     return int(seconds) * 1000
@@ -280,31 +404,47 @@ def _spawn_events(rows: "list[dict]") -> "list[tuple[int, dict]]":
     return out
 
 
-def _verdict_events(rows: "list[dict]") -> "list[tuple[int, dict]]":
-    """`round.verdict` for posted rows, `round.abandoned` for abandoned ones.
-
-    A row with neither `posted_at` nor `abandoned_at` is an OPEN obligation —
-    the round's native verdict has not landed — and emits nothing until it
-    closes one way or the other. `data.verdict` is omitted (never invented)
-    on rows that predate the ledger's verdict column.
-
-    COVERAGE BOUND (PR #113 round 2, major): `verdict_posts` is the
-    per-round OBLIGATION record, not the per-round record — a row exists
-    only when the reviewer session defaulted and the daemon posted the
-    native fallback verdict itself. On a fleet whose sessions post every
-    review, these two kinds are expected to be EMPTY; issue #112 maps them
-    to this table and puts the round bookkeeping a session-covering source
-    needs out of scope, so the widening is TASK-1086576582, and the README's
-    telemetry table states the bound where an operator will read it."""
+def _verdict_events(
+    rows: "list[dict]", pings: "list[dict] | None" = None
+) -> "list[tuple[int, dict]]":
+    """`round.verdict` for every verdict of record, `round.abandoned` for
+    abandoned native posts.
+
+    Two sources, one event per (repo, PR, round, head) (issue #155):
+
+    * a POSTED `verdict_posts` row -- the daemon's native fallback closed the
+      round -- derives the event at `posted_at`, with the round's
+      `round-verdict:` row folded in for readiness, class, contract and task
+      (a row that predates that ping carries them null) plus the fallback's
+      own `reviewUrl`, `attempts` and `checksHeldMs`;
+    * a `round-verdict:` row with no posted `verdict_posts` row for its round
+      -- the SESSION's own review closed it -- derives the event at the ping's
+      stamp. A round whose native post was ABANDONED derives no verdict from
+      its ping: the round was released, not judged.
+
+    A `verdict_posts` row with neither `posted_at` nor `abandoned_at` is an
+    OPEN obligation -- the round's native verdict has not landed -- and emits
+    nothing until it closes one way or the other. `data.verdict` is null
+    (never invented) on rows that predate the ledger's verdict column.
+
+    COVERAGE BOUND: the session-closed rounds are recorded from the pass that
+    first sees them, so rounds closed before the daemon ran a version with
+    the `round-verdict:` ping (0.31.10) are not backfilled -- the ledger
+    never recorded them."""
+    verdicts = _round_verdicts(pings or [])
     out = []
+    closed: "set[tuple[str, int, int]]" = set()
     for row in rows:
         repo, number = row["repo"], int(row["number"])
         round_, head = int(row["round"]), row["head_sha"] or ""
+        if row.get("posted_at") or row.get("abandoned_at"):
+            closed.add((repo, number, round_))
         if row.get("posted_at"):
             posted = int(row["posted_at"])
-            data: dict[str, Any] = {"headSha": head}
-            if row.get("verdict"):
-                data["verdict"] = row["verdict"]
+            pinged = verdicts.get((repo, number, round_))
+            data: dict[str, Any] = _verdict_data(
+                row.get("verdict"), head, None if pinged is None else pinged[1]
+            )
             if row.get("review_url"):
                 data["reviewUrl"] = row["review_url"]
             data["attempts"] = int(row.get("attempts") or 0)
@@ -331,6 +471,19 @@ def _verdict_events(rows: "list[dict]") -> "list[tuple[int, dict]]":
                 reason=row.get("last_error") or None,
                 data={"headSha": head},
             ))
+    for (repo, number, round_), (at, fields) in verdicts.items():
+        if (repo, number, round_) in closed:
+            continue
+        head = fields["head"]
+        out.append(_event(
+            "round.verdict",
+            at,
+            f"revloop:round.verdict:{repo}:{number}:{round_}:{head}",
+            repo=repo,
+            pr=number,
+            round_=round_,
+            data=_verdict_data(None, head, fields),
+        ))
     return out
 
 
@@ -385,7 +538,9 @@ def _ping_events(
     `kind` is free-form text carrying the episode identity, so it is parsed
     by prefix; kinds this module does not report (`activity-deferred:`,
     `capout:`, `checks-hold:`, `verdict-post-failed:` — each the dedupe of a
-    GitHub-side comment, not a fact of its own) derive nothing.
+    GitHub-side comment, not a fact of its own) derive nothing here, and
+    `round-verdict:` rows derive through `_verdict_events`, which joins them
+    with the native posts of the same round.
 
     A stability event's payload is split by provenance, deliberately
     (PR #113 round 1, minor). `data.headSha` and `data.grantsSeen` come from
@@ -609,9 +764,9 @@ def derive_events(state: State, *, since: int = 0) -> "list[dict]":
 
     stamped: "list[tuple[int, dict]]" = []
     stamped += _spawn_events(spawns)
-    stamped += _verdict_events(state.read_verdict_posts())
-    stamped += _capped_events(state.read_escalations(), spawns)
     pings = state.read_pings()
+    stamped += _verdict_events(state.read_verdict_posts(), pings)
+    stamped += _capped_events(state.read_escalations(), spawns)
     stamped += _ping_events(pings, notices)
     stamped += _spawn_hold_events(state.read_spawn_checks_holds())
     stamped += _grant_events(state.read_grants())

{alissa_tools_github_revloop-0.31.9 → alissa_tools_github_revloop-0.31.10}/src/main/alissa/tools/github/revloop/state.py

@@ -1895,9 +1895,14 @@ class State:
         limit: int | None = None,
         *,
         sessions: "Iterable[str] | None" = None,
+        since: "float | None" = None,
     ) -> list[dict]:
         """Spawn rows (one per enqueued reviewer round), newest first.
 
+        `since` keeps only rows spawned at or after that epoch second -- the
+        round-verdict sweep's window (loop.sweep_round_verdicts), which wants
+        the recent rounds and not the whole table every poll.
+
         `sessions` restricts the read to those session names. That is the
         bound the console's session->round pairing wants, and a recency bound
         (row count or time window) is NOT: a stale round whose session is
@@ -1913,12 +1918,18 @@ class State:
             "FROM spawns"
         )
         params: tuple = ()
+        where: list[str] = []
         if sessions is not None:
             names = tuple(sessions)
             if not names:
                 return []
-            sql += " WHERE session IN (%s)" % ",".join("?" * len(names))
+            where.append("session IN (%s)" % ",".join("?" * len(names)))
             params = names
+        if since is not None:
+            where.append("spawned_at >= ?")
+            params += (int(since),)
+        if where:
+            sql += " WHERE " + " AND ".join(where)
         sql += " ORDER BY spawned_at DESC, number DESC, round DESC"
         return self._read_rows(sql, limit, params)
 

alissa_tools_github_revloop-0.31.10/src/main/alissa/tools/github/revloop/version

@@ -0,0 +1 @@
+0.31.10

{alissa_tools_github_revloop-0.31.9 → alissa_tools_github_revloop-0.31.10/src/main/alissa_tools_github_revloop.egg-info}/PKG-INFO

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

alissa_tools_github_revloop-0.31.9/src/main/alissa/tools/github/revloop/version

@@ -1 +0,0 @@
-0.31.9