alissa-tools-github-revloop 0.16.11__tar.gz → 0.16.12__tar.gz

{alissa_tools_github_revloop-0.16.11/src/main/alissa_tools_github_revloop.egg-info → alissa_tools_github_revloop-0.16.12}/PKG-INFO

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

{alissa_tools_github_revloop-0.16.11 → alissa_tools_github_revloop-0.16.12}/src/main/alissa/tools/github/revloop/alissa.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 import logging
 import re
 from dataclasses import dataclass
+from datetime import datetime
 from pathlib import Path
 
 from .proc import CommandError, run, run_json
@@ -190,17 +191,25 @@ def _task_from_row(row: object) -> "Task | None":
 
 @dataclass(frozen=True)
 class TaskDetail:
-    """One task as `alissa task get` sees it: the task itself, plus the CR6
-    verdict envelopes already on it.
-
-    The two travel together because they come out of ONE payload. The decide
-    path needs both (is this still the PR's open review task? how many rounds
-    has it recorded?), and reading them separately would cost two task fetches
-    per PR per poll where the CLI already returns everything in one.
+    """One task as `alissa task get` sees it: the task itself, plus everything
+    the decide path reads off its CR6 verdict evidence.
+
+    All three travel together because they come out of ONE payload. The decide
+    path needs every one of them (is this still the PR's open review task? how
+    many rounds has it recorded? what did the newest round decide?), and
+    `_count_verdicts` and `_newest_verdict` are deliberately written as mirrors
+    over the same evidence array -- so reading them apart would mean fetching
+    and re-parsing the same task two and three times per PR per poll, which is
+    the exact cost this whole path exists to stop paying.
+
+    `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.
     """
 
     task: Task
     verdicts: int
+    verdict: "str | None"
 
 
 class Alissa:
@@ -251,7 +260,11 @@ class Alissa:
             task = _task_from_row(data)
             if task is None:
                 return None
-            return TaskDetail(task=task, verdicts=self._count_verdicts(data))
+            return TaskDetail(
+                task=task,
+                verdicts=self._count_verdicts(data),
+                verdict=self._newest_verdict(data),
+            )
         except Exception:  # pragma: no cover - defence in depth
             log.exception("could not parse task payload for %s", ref)
             return None
@@ -316,6 +329,44 @@ class Alissa:
             log.exception("could not parse verdict evidence for %s", task_ref)
             return None
 
+    @staticmethod
+    def _created_key(value: object) -> tuple[int, float]:
+        """One evidence item's `createdAt`, as a sortable stamp.
+
+        `alissa task get --json` dates evidence with epoch MILLISECONDS as an
+        int; the API's other surfaces (and hand-written fixtures) use an ISO-8601
+        string. Both are normalised here to one float, because the previous key
+        -- `created if isinstance(created, str) else ""` -- collapsed every real
+        item to the empty string, leaving `max` to keep the FIRST element of an
+        all-equal set. Evidence comes back oldest-first, so on live data the
+        OLDEST verdict won: a PR whose round 1 was request_changes and round 2
+        approve never converged through the envelope branch (TASK-194837655).
+
+        Normalising rather than widening the isinstance is deliberate: a task
+        carrying both shapes would produce `(str, ...)` and `(int, ...)` keys
+        that raise TypeError the moment sorting compared them.
+
+        Returns `(has_stamp, seconds)`. An absent or unparseable stamp is
+        `(0, 0.0)` and sorts FIRST, preserving the old rule that a dated
+        envelope always beats one that lost its timestamp.
+        """
+        if isinstance(value, bool):  # bool is an int; never a timestamp
+            return (0, 0.0)
+        if isinstance(value, (int, float)):
+            seconds = float(value)
+            # Milliseconds, by magnitude: 1e11 seconds is the year 5138, while
+            # 1e11 milliseconds is 1973 -- so anything above it is ms, and a
+            # task holding both units still orders correctly.
+            if abs(seconds) > 1e11:
+                seconds /= 1000.0
+            return (1, seconds)
+        if isinstance(value, str) and value:
+            try:
+                return (1, datetime.fromisoformat(value.replace("Z", "+00:00")).timestamp())
+            except ValueError:
+                return (0, 0.0)
+        return (0, 0.0)
+
     @staticmethod
     def _newest_verdict(payload: object) -> str | None:
         """Pick the newest parseable verdict out of a task's evidence array.
@@ -329,8 +380,8 @@ class Alissa:
         if not isinstance(evidence, list):
             return None
 
-        found: list[tuple[str, str]] = []
-        for item in evidence:
+        found: list[tuple[tuple[int, float], int, str]] = []
+        for index, item in enumerate(evidence):
             if not isinstance(item, dict):
                 continue
             title = item.get("title")
@@ -340,18 +391,21 @@ class Alissa:
                     continue
                 match = _VERDICT_RE.search(blob)
                 if match:
-                    created = item.get("createdAt")
                     found.append(
-                        (created if isinstance(created, str) else "", match.group(1).lower())
+                        (Alissa._created_key(item.get("createdAt")),
+                         index,
+                         match.group(1).lower())
                     )
                     break
 
         if not found:
             return None
-        # ISO-8601 timestamps sort lexicographically. Undated evidence sorts
-        # first (empty string), so a dated envelope always wins over one that
-        # lost its timestamp.
-        return max(found, key=lambda pair: pair[0])[1]
+        # Newest stamp wins; undated evidence sorts first, so a dated envelope
+        # always beats one that lost its timestamp (see _created_key). The
+        # append INDEX breaks ties: evidence comes back oldest-first, so two
+        # envelopes sharing a stamp resolve to the later-recorded one rather
+        # than to whichever `max` happened to reach first.
+        return max(found, key=lambda item: (item[0], item[1]))[2]
 
     def count_verdicts(self, task_ref: str) -> int:
         """How many CR6 verdict envelopes are on the review task.

{alissa_tools_github_revloop-0.16.11 → alissa_tools_github_revloop-0.16.12}/src/main/alissa/tools/github/revloop/loop.py

@@ -27,6 +27,7 @@ from .alissa import (
     ManagedSession,
     SessionRef,
     Task,
+    TaskDetail,
     is_review_task_for,
     session_repo_slug,
 )
@@ -872,6 +873,56 @@ class Decision:
     reenqueued: bool = False
 
 
+@dataclass(frozen=True)
+class ResolvedTask:
+    """One PR's review task as the decide path resolved it THIS pass.
+
+    Carries what the resolution happened to learn, and -- the part that matters
+    -- whether it learned it. The two resolution paths read different things:
+
+    * the CACHED path fetches the task by ref to check the mapping still holds,
+      so the whole evidence array comes with it and both the round count and the
+      newest verdict are free;
+    * the SEARCH path matches TITLES out of the task corpus, so it reads the
+      matched task afterwards to learn both -- and only when THAT read fails
+      does it fall back to a bare `count_verdicts` and know no verdict.
+
+    Hence `verdict_read`, rather than letting `verdict=None` stand for both "no
+    envelope parses" and "nobody looked". Convergence treats a None verdict as
+    "not approved"; conflating the two would silently refuse to close a round
+    that had in fact approved, every time the mapping was resolved by search.
+    """
+
+    task: "Task | None"
+    verdicts: int = 0
+    verdict: "str | None" = None
+    verdict_read: bool = False
+
+    @classmethod
+    def from_detail(cls, detail: TaskDetail) -> "ResolvedTask":
+        """One `alissa task get` payload answered all three questions.
+
+        The `verdict_read=True` invariant lives here rather than at the call
+        sites: it is a property of having read a task detail, and every path
+        that reads one gets it the same way.
+        """
+        return cls(
+            task=detail.task,
+            verdicts=detail.verdicts,
+            verdict=detail.verdict,
+            verdict_read=True,
+        )
+
+    def newest_verdict(self, alissa: Alissa) -> "str | None":
+        """The newest CR6 verdict envelope, fetching it only if this resolution
+        did not already have it in hand."""
+        if self.task is None:
+            return None
+        if self.verdict_read:
+            return self.verdict
+        return alissa.latest_verdict(self.task.ref)
+
+
 @dataclass(frozen=True)
 class ChecksGate:
     """What the head's CI rollup does to a round's APPROVE verdict.
@@ -994,8 +1045,8 @@ class ReviewWatcher:
             self._pass_tasks = self.alissa.list_tasks()
         return self._pass_tasks
 
-    def _review_task(self, pr: PullRequest) -> tuple["Task | None", int]:
-        """This PR's open CR2 review task and its verdict count, cheaply.
+    def _review_task(self, pr: PullRequest) -> "ResolvedTask":
+        """This PR's open CR2 review task and what its evidence says, cheaply.
 
         The decide path needs the review task on every pass of every open
         round, and the only way to FIND one is to search the actor's whole
@@ -1019,13 +1070,31 @@ class ReviewWatcher:
         Fail-open is the whole contract: every degradation here lands on "do
         what the daemon did before the cache existed", and none of them can
         answer "no review task" unless a successful search actually said so.
+
+        TWO consequences of resolving from cache, both accepted rather than
+        overlooked (PR #68 round 1):
+
+        * A cached hit does NOT re-check CR2 uniqueness. The duplicate-task
+          alarm lives in `find_review_task`, which only runs on a miss, so a
+          second open review task created for this PR AFTER the mapping was
+          cached goes unreported and the daemon keeps counting envelopes on the
+          one it pinned. Detecting it needs the corpus, and not fetching the
+          corpus is the point -- relocating the check is TASK-317167904.
+        * VALIDATING the review task drops the mapping, because
+          `is_review_task_for` requires an open task and the search cannot find
+          a terminal one either, so `evaluate` falls back to the GitHub review
+          count -- the fallback `_completed_rounds` deliberately avoids. That is
+          pre-existing and unchanged, but this path now HAS a durable ref that
+          could survive validation; it is not used because a terminal task can
+          never become open again, so a retained ref would have no disproof and
+          its row would be immortal. Settling that is TASK-1897198077.
         """
         cached = self.state.review_task(pr.full_name, pr.number)
         if cached is not None:
             detail = self.alissa.get_task(cached)
             if detail is not None:
                 if is_review_task_for(pr.owner, pr.repo, pr.number, detail.task):
-                    return detail.task, detail.verdicts
+                    return ResolvedTask.from_detail(detail)
                 log.info(
                     "%s: cached review task %s no longer matches (title=%r "
                     "status=%s) — re-resolving",
@@ -1048,10 +1117,24 @@ class ReviewWatcher:
             # no open review task for this PR, whatever the cache said.
             if cached is not None:
                 self.state.forget_review_task(pr.full_name, pr.number)
-            return None, 0
+            return ResolvedTask(task=None)
 
         self.state.record_review_task(pr.full_name, pr.number, task.ref)
-        return task, self.alissa.count_verdicts(task.ref)
+        # The search matched a TITLE out of the corpus; the round count and the
+        # verdict both live in the task's evidence, and ONE read returns both.
+        # Reading it here rather than paying `count_verdicts` now and
+        # `latest_verdict` again from convergence is the same saving the cached
+        # path makes -- and it matters most in the degraded state this whole
+        # change serves: an unreadable ledger sends EVERY PR down this path on
+        # EVERY pass (PR #69 round 1).
+        detail = self.alissa.get_task(task.ref)
+        if detail is not None:
+            return ResolvedTask.from_detail(detail)
+        # That read failed, so the verdict is genuinely unknown -- left UNREAD
+        # rather than defaulted to None, which convergence would take as "no
+        # approve" and lose a closed round. Falls back to exactly the two-read
+        # behaviour this path had before.
+        return ResolvedTask(task=task, verdicts=self.alissa.count_verdicts(task.ref))
 
     # -- per-PR decision ---------------------------------------------------
 
@@ -1082,9 +1165,10 @@ class ReviewWatcher:
         # Fall back to the substantive-review count only before the review task
         # exists (round 1). Looked up here (not in _spawn) because both the count
         # and convergence need it.
-        task, verdicts = self._review_task(pr)
+        resolved = self._review_task(pr)
+        task = resolved.task
         native = countable_rounds(my_reviews)
-        completed = verdicts if task is not None else native
+        completed = resolved.verdicts if task is not None else native
 
         # A round is not over until its verdict exists as a native review by
         # the reviewer identity (issue #51). An envelope ahead of the native
@@ -1114,7 +1198,7 @@ class ReviewWatcher:
             # anything else the round is still open and nothing may follow it.
             return self._close_round_natively(pr, task, round_=completed)
 
-        converged = self._convergence_reason(my_reviews, task, pr.head_sha)
+        converged = self._convergence_reason(my_reviews, resolved, pr.head_sha)
         if converged is not None:
             # THE terminal branch: a verdict of record exists at the current
             # head, so no round k+1 can be owed from here -- every path that
@@ -1972,7 +2056,7 @@ class ReviewWatcher:
         )
 
     def _convergence_reason(
-        self, my_reviews: list[Review], task: Task | None, head_sha: str
+        self, my_reviews: list[Review], resolved: "ResolvedTask", head_sha: str
     ) -> str | None:
         """Why the loop is done, or None if it is not.
 
@@ -2033,9 +2117,14 @@ class ReviewWatcher:
             return None
 
         # Only checkable once a review task exists; before that there is
-        # nowhere for a verdict to have been recorded.
-        if task is not None and self.alissa.latest_verdict(task.ref) == VERDICT_APPROVE:
-            return f"newest verdict envelope on {task.ref} reads approve"
+        # nowhere for a verdict to have been recorded. On the cached path the
+        # envelope was already read back with the task, so this costs nothing;
+        # on the search path it is the one fetch that still has to happen.
+        if (
+            resolved.task is not None
+            and resolved.newest_verdict(self.alissa) == VERDICT_APPROVE
+        ):
+            return f"newest verdict envelope on {resolved.task.ref} reads approve"
 
         return None
 
@@ -3043,9 +3132,18 @@ class ReviewWatcher:
         # DRY-RUN IS EXEMPT, and vacuously so: it already suppresses every side
         # effect AND every correctness write (`_spawn` skips record_spawn, the
         # reaper logs instead of killing, the drift/cap-out/deferral paths
-        # return before both their comment and their record). Its only ledger
-        # write is the snapshot, which this module classifies as best-effort
-        # telemetry and which _write_snapshot writes in dry-run deliberately.
+        # return before both their comment and their record). The ledger writes
+        # it may still take are the snapshot and the review-task cache
+        # (`_review_task` runs in dry-run and both records and forgets
+        # mappings) -- both classified by this module as best-effort telemetry,
+        # both absorbed by _write_telemetry, and neither a decision the daemon
+        # has to remember. Writing the cache in dry-run is deliberate: a
+        # dry-run pass that learns a mapping hands it to the next production
+        # pass, and suppressing it would make the two disagree about ledger
+        # contents for no correctness reason. The cost on a read-only volume is
+        # a reconnect attempt on the first failure of the streak plus
+        # streak-limited warnings, which is the same best-effort behaviour the
+        # snapshot has always had there.
         # So the gate would protect nothing there and cost the operator the one
         # tool that answers "what would you do right now" -- asked, precisely,
         # during the substrate incident this whole change is about.

{alissa_tools_github_revloop-0.16.11 → alissa_tools_github_revloop-0.16.12}/src/main/alissa/tools/github/revloop/state.py

@@ -157,6 +157,12 @@ CREATE TABLE IF NOT EXISTS verdict_posts (
 -- losing the whole table only costs one title search per PR (see
 -- loop._review_task). That is why this is best-effort like the snapshots
 -- above, not a correctness write.
+--
+-- Rows are never pruned, unlike poll_snapshots and like grants: one row per PR
+-- ever sighted (a few hundred, for this daemon's repo set, forever), and a
+-- stale row costs exactly one disproved read the first time that PR is seen
+-- again. `resolved_at` is retained for inspection -- when was this mapping last
+-- confirmed by a search -- and nothing in the daemon reads it.
 CREATE TABLE IF NOT EXISTS review_tasks (
     repo        TEXT    NOT NULL,
     number      INTEGER NOT NULL,
@@ -905,8 +911,10 @@ class State:
         """Remember which review task a PR resolved to. Best-effort.
 
         REPLACE, not IGNORE: re-resolving is how a mapping is corrected, so the
-        newest answer has to win. `resolved_at` is when the mapping was last
-        confirmed by a search, which is the audit question worth answering.
+        newest answer has to win. `resolved_at` records when the mapping was
+        last confirmed by a search; it is kept for inspection (the age of a
+        mapping is the first thing worth knowing if one is ever suspected) and
+        no query, log line or console view reads it.
 
         A database error here is absorbed exactly like a snapshot's: the cache
         is an optimization, and a pass that cannot persist it still decides the

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

@@ -0,0 +1 @@
+0.16.12

{alissa_tools_github_revloop-0.16.11 → alissa_tools_github_revloop-0.16.12/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.16.11
+Version: 0.16.12
 Summary: ALISSA-TOOLS-GITHUB-REVLOOP
 Home-page: https://alissa.app
 Author: Fahera

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

@@ -1 +0,0 @@
-0.16.11