alissa-tools-github-reviewloop 0.4.0__tar.gz → 0.6.0__tar.gz

{alissa_tools_github_reviewloop-0.4.0/src/main/alissa_tools_github_reviewloop.egg-info → alissa_tools_github_reviewloop-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-reviewloop
-Version: 0.4.0
+Version: 0.6.0
 Summary: ALISSA-TOOLS-GITHUB-REVIEWLOOP
 Home-page: https://alissa.app
 Author: Fahera

{alissa_tools_github_reviewloop-0.4.0 → alissa_tools_github_reviewloop-0.6.0}/src/main/alissa/tools/github/reviewloop/alissa.py

@@ -154,6 +154,48 @@ class Alissa:
         # lost its timestamp.
         return max(found, key=lambda pair: pair[0])[1]
 
+    def count_verdicts(self, task_ref: str) -> int:
+        """How many CR6 verdict envelopes are on the review task.
+
+        One envelope per completed round (CR7, append-only), so this is the
+        authoritative round count -- unlike the GitHub review count it cannot be
+        thrown off by an empty-bodied review or two reviews in one cycle. Never
+        raises: absent, empty, or malformed evidence degrades to 0 (round 1)
+        rather than taking the loop down.
+        """
+        try:
+            data = run_json(["alissa", "task", "get", task_ref, "--json"], timeout=90)
+        except CommandError as exc:
+            log.warning("could not read verdict evidence for %s: %s", task_ref, exc)
+            return 0
+        except Exception:  # pragma: no cover - defence in depth
+            log.exception("unexpected failure reading verdict evidence for %s", task_ref)
+            return 0
+        try:
+            return self._count_verdicts(data)
+        except Exception:  # pragma: no cover - defence in depth
+            log.exception("could not count verdict evidence for %s", task_ref)
+            return 0
+
+    @staticmethod
+    def _count_verdicts(payload: object) -> int:
+        """Count evidence items carrying a verdict envelope. Mirrors
+        `_newest_verdict`'s tolerant parsing -- one match per item at most."""
+        if not isinstance(payload, dict):
+            return 0
+        evidence = payload.get("evidence")
+        if not isinstance(evidence, list):
+            return 0
+        count = 0
+        for item in evidence:
+            if not isinstance(item, dict):
+                continue
+            for blob in (item.get("title"), item.get("markdownContent")):
+                if isinstance(blob, str) and _VERDICT_RE.search(blob):
+                    count += 1
+                    break
+        return count
+
     def enqueue_reviewer(
         self,
         *,
@@ -185,6 +227,27 @@ class Alissa:
 
         run(argv, timeout=60)
 
+        # Reviewers are one-shot per round (CR3): once the session finishes and is
+        # reaped, it must never be respawned. Make that explicit so a self-kill or
+        # a daemon reap can't trigger a respawn loop. Best-effort — an older CLI
+        # without `queue set` should not fail the enqueue.
+        try:
+            run(["alissa", "tmux", "queue", "set", session, "respawn", "off"],
+                timeout=30, check=False)
+        except CommandError:  # pragma: no cover - defence in depth
+            log.warning("could not set respawn off for %s", session)
+
+    def kill_session(self, session: str, *, dry_run: bool = False) -> None:
+        """Kill a finished reviewer's managed session to free its worker slot.
+
+        Best-effort and idempotent-friendly: the session may already be gone (the
+        reviewer self-killed), so a non-zero exit is not an error here.
+        """
+        if dry_run:
+            log.info("[dry-run] would kill session %s", session)
+            return
+        run(["alissa", "tmux", "kill", session], timeout=30, check=False)
+
     def add_repo_to_workspace(
         self, owner: str, repo: str, workspace_root: Path, *, dry_run: bool = False
     ) -> None:

{alissa_tools_github_reviewloop-0.4.0 → alissa_tools_github_reviewloop-0.6.0}/src/main/alissa/tools/github/reviewloop/loop.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 
 import logging
 import re
+import secrets
 import time
 from dataclasses import dataclass
 from enum import Enum
@@ -43,6 +44,16 @@ _CLOSE_THE_ROUND = (
     "request_changes. "
 )
 
+# Reviewers are one-shot per round (CR3), so a finished session should not linger
+# holding a worker slot. The daemon reaps it as a backstop, but the fast path is
+# the reviewer releasing its own slot as its very last action. {session} is the
+# reviewer's own managed session name, injected at spawn.
+_RELEASE_SLOT = (
+    "FINALLY, and only once the round is fully closed above (review registered "
+    "AND verdict recorded), release your worker slot as your last action: run "
+    "`alissa tmux kill {session}`. Do nothing after it."
+)
+
 ROUND_1_DIRECTIVE = (
     "You are a PR REVIEWER, not an implementer. {assignment} "
     "Load the alissa-code-review skill and follow procedures/review-a-pr.md: "
@@ -51,7 +62,8 @@ ROUND_1_DIRECTIVE = (
     "move the task to pending_validation. "
     + _CLOSE_THE_ROUND +
     "NEVER push commits, merge, or change PR state. "
-    "Do NOT create further ali-* sessions."
+    "Do NOT create further ali-* sessions. "
+    + _RELEASE_SLOT
 )
 
 ROUND_K_DIRECTIVE = (
@@ -63,7 +75,8 @@ ROUND_K_DIRECTIVE = (
     "round-{round} verdict envelope, move the task to pending_validation. "
     + _CLOSE_THE_ROUND +
     "NEVER push commits, merge, or change PR state. "
-    "Do NOT create further ali-* sessions."
+    "Do NOT create further ali-* sessions. "
+    + _RELEASE_SLOT
 )
 
 ESCALATION_COMMENT = (
@@ -93,9 +106,17 @@ class Decision:
 
 
 def session_name(pr: PullRequest, round_: int) -> str:
-    """tmux-safe, unique per (repo, pr, round)."""
+    """A tmux-safe reviewer session name, unique per spawn.
+
+    The `review-<repo>-pr<n>-r<round>` prefix stays human-readable, but a short
+    random nonce is appended so a re-used or miscounted round number can never
+    collide with a still-live session (a collision wedges the worker -- the
+    original 'stuck' failure). Safe to be non-deterministic: the generated name
+    is recorded in the spawn ledger and is what gets reaped / self-killed, so the
+    daemon never re-derives it.
+    """
     repo = re.sub(r"[^A-Za-z0-9-]", "-", pr.repo).strip("-").lower()
-    return f"review-{repo}-pr{pr.number}-r{round_}"
+    return f"review-{repo}-pr{pr.number}-r{round_}-{secrets.token_hex(3)}"
 
 
 class ReviewWatcher:
@@ -131,11 +152,25 @@ class ReviewWatcher:
             )
 
         my_reviews = self.github.my_reviews(owner, repo, number)
-        completed = len(my_reviews)
 
-        # Looked up here rather than inside _spawn: convergence needs the ref
-        # too. _spawn still handles `task is None` exactly as before.
+        # The review task (CR2) is the round record: one verdict envelope per
+        # round (CR7), so counting envelopes is the authoritative "rounds
+        # completed" -- immune to the GitHub heuristics that drift. A round whose
+        # review has an empty body undercounts (round_ repeats -> the session name
+        # collides -> the worker wedges); two reviews in one cycle overcount.
+        # 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 = self.alissa.find_review_task(owner, repo, number)
+        completed = (
+            self.alissa.count_verdicts(task.ref) if task is not None
+            else len(my_reviews)
+        )
+
+        # Backstop: reap the sessions of rounds that have already landed a review
+        # (the fast path is the reviewer self-killing, but it may forget). A round
+        # <= completed is done; its session, if we still have it, can be killed.
+        self._reap_finished(pr.full_name, number, completed)
 
         converged = self._convergence_reason(my_reviews, task)
         if converged is not None:
@@ -189,6 +224,31 @@ class ReviewWatcher:
 
         return None
 
+    def _reap_finished(self, repo: str, number: int, completed: int) -> None:
+        """Kill the managed session of every round whose review has landed.
+
+        A round `<= completed` is done (its review was submitted), so its session
+        is finished and should not hold a worker slot. The reviewer self-kills as
+        the fast path; this is the backstop for when it forgets. Idempotent — each
+        session is killed at most once (recorded in the ledger) — never runs in
+        dry-run, and best-effort: a reap failure (or an already-gone session) must
+        not take the poll down.
+        """
+        if self.config.dry_run or completed < 1:
+            return
+        for round_ in range(1, completed + 1):
+            row = self.state.get_spawn(repo, number, round_)
+            if row is None or self.state.is_reaped(row["session"]):
+                continue
+            session = row["session"]
+            try:
+                self.alissa.kill_session(session)
+            except Exception:  # pragma: no cover - defence in depth
+                log.exception("failed to reap session %s", session)
+                continue
+            self.state.record_reap(session)
+            log.info("reaped finished reviewer session %s (round %d done)", session, round_)
+
     # -- actions -----------------------------------------------------------
 
     def _spawn(self, pr: PullRequest, round_: int, task: Task | None) -> Decision:
@@ -210,16 +270,16 @@ class ReviewWatcher:
         else:
             assignment = f"You've been assigned Alissa review task {task.ref}."
 
+        name = session_name(pr, round_)
         template = ROUND_1_DIRECTIVE if round_ == 1 else ROUND_K_DIRECTIVE
         directive = template.format(
-            assignment=assignment, round=round_, cap=self.config.round_cap
+            assignment=assignment, round=round_, cap=self.config.round_cap, session=name
         )
 
         hub, problem = self._ensure_hub(pr)
         if problem is not None:
             return Decision(Action.SKIPPED, problem, round_)
 
-        name = session_name(pr, round_)
         self.alissa.enqueue_reviewer(
             session=name,
             directive=directive,

{alissa_tools_github_reviewloop-0.4.0 → alissa_tools_github_reviewloop-0.6.0}/src/main/alissa/tools/github/reviewloop/state.py

@@ -31,6 +31,11 @@ CREATE TABLE IF NOT EXISTS escalations (
     escalated_at INTEGER NOT NULL,
     PRIMARY KEY (repo, number, head_sha)
 );
+
+CREATE TABLE IF NOT EXISTS reaps (
+    session   TEXT    NOT NULL PRIMARY KEY,
+    reaped_at INTEGER NOT NULL
+);
 """
 
 
@@ -81,6 +86,19 @@ class State:
         )
         self._db.commit()
 
+    def is_reaped(self, session: str) -> bool:
+        row = self._db.execute(
+            "SELECT 1 FROM reaps WHERE session=?", (session,)
+        ).fetchone()
+        return row is not None
+
+    def record_reap(self, session: str) -> None:
+        self._db.execute(
+            "INSERT OR REPLACE INTO reaps (session, reaped_at) VALUES (?,?)",
+            (session, int(time.time())),
+        )
+        self._db.commit()
+
     def escalated(self, repo: str, number: int, head_sha: str) -> bool:
         row = self._db.execute(
             "SELECT 1 FROM escalations WHERE repo=? AND number=? AND head_sha=?",

alissa_tools_github_reviewloop-0.6.0/src/main/alissa/tools/github/reviewloop/version

@@ -0,0 +1 @@
+0.6.0

{alissa_tools_github_reviewloop-0.4.0 → alissa_tools_github_reviewloop-0.6.0/src/main/alissa_tools_github_reviewloop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-reviewloop
-Version: 0.4.0
+Version: 0.6.0
 Summary: ALISSA-TOOLS-GITHUB-REVIEWLOOP
 Home-page: https://alissa.app
 Author: Fahera

alissa_tools_github_reviewloop-0.4.0/src/main/alissa/tools/github/reviewloop/version

@@ -1 +0,0 @@
-0.4.0