alissa-tools-github-reviewloop 0.3.0__tar.gz → 0.5.0__tar.gz

{alissa_tools_github_reviewloop-0.3.0/src/main/alissa_tools_github_reviewloop.egg-info → alissa_tools_github_reviewloop-0.5.0}/PKG-INFO

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

{alissa_tools_github_reviewloop-0.3.0 → alissa_tools_github_reviewloop-0.5.0}/src/main/alissa/tools/github/reviewloop/alissa.py

@@ -185,6 +185,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.3.0 → alissa_tools_github_reviewloop-0.5.0}/src/main/alissa/tools/github/reviewloop/loop.py

@@ -29,14 +29,40 @@ log = logging.getLogger(__name__)
 # (skill failure mode: "reviewer session stalls"). The round is re-enqueued.
 STALE_ROUND_SECONDS = 90 * 60
 
+# The closing contract is spelled out in both directives (not just the skill)
+# because it is the reviewer's most-skipped step: on re-review, sessions produce
+# findings but never register the review on the PR, or stop without a verdict.
+_CLOSE_THE_ROUND = (
+    "CLOSE THE ROUND — both are mandatory or the round does not count: "
+    "(1) SUBMIT your review so it lands as one registered review record ON the "
+    "PR (gh pr review / the reviews API) and confirm it with "
+    "`gh api repos/<org>/<repo>/pulls/<n>/reviews` — findings left only in your "
+    "session do not exist; (2) end with a decisive verdict — approve OR "
+    "request_changes, never neither, never comment-only. You are read-only: "
+    "never commit or fix, even a one-character typo — a needed fix IS "
+    "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: "
     "hydrate the task and the PR it names, review per the rubric, post "
     "severity-tagged comments via gh pr review, record the verdict evidence, "
     "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 = (
@@ -46,8 +72,10 @@ ROUND_K_DIRECTIVE = (
     "including its round-k section: verify the triage of every prior finding, "
     "verify the fixes, sweep the new diff with the full rubric, record a "
     "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 = (
@@ -117,6 +145,11 @@ class ReviewWatcher:
         my_reviews = self.github.my_reviews(owner, repo, number)
         completed = 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)
+
         # Looked up here rather than inside _spawn: convergence needs the ref
         # too. _spawn still handles `task is None` exactly as before.
         task = self.alissa.find_review_task(owner, repo, number)
@@ -173,6 +206,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:
@@ -194,16 +252,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.3.0 → alissa_tools_github_reviewloop-0.5.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.5.0/src/main/alissa/tools/github/reviewloop/version

@@ -0,0 +1 @@
+0.5.0

{alissa_tools_github_reviewloop-0.3.0 → alissa_tools_github_reviewloop-0.5.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.3.0
+Version: 0.5.0
 Summary: ALISSA-TOOLS-GITHUB-REVIEWLOOP
 Home-page: https://alissa.app
 Author: Fahera

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

@@ -1 +0,0 @@
-0.3.0