alissa-tools-github-reviewloop 0.7.0__tar.gz → 0.9.0__tar.gz

{alissa_tools_github_reviewloop-0.7.0/src/main/alissa_tools_github_reviewloop.egg-info → alissa_tools_github_reviewloop-0.9.0}/PKG-INFO

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

{alissa_tools_github_reviewloop-0.7.0 → alissa_tools_github_reviewloop-0.9.0}/src/main/alissa/tools/github/reviewloop/alissa.py

@@ -44,6 +44,25 @@ class Task:
         return self.status in OPEN_STATUSES
 
 
+# The namespace loop.session_name() spawns reviewers into; the reap sweep only
+# ever considers sessions under it.
+REVIEW_SESSION_PREFIX = "review-"
+
+
+@dataclass(frozen=True)
+class ManagedSession:
+    name: str
+    status: str  # the worker's view: "idle", "busy", ...
+    # Epoch seconds of the session's last tmux activity. 0 when the CLI did
+    # not report one -- treated as "long quiet", so a missing field can never
+    # indefinitely immunize a session against the sweep.
+    last_activity: float = 0.0
+
+    @property
+    def is_idle(self) -> bool:
+        return self.status == "idle"
+
+
 def _title_pattern(owner: str, repo: str, number: int) -> re.Pattern[str]:
     """CR2 title convention: `Review PR <org>/<repo>#<n> (TASK-<origin>)`."""
     return re.compile(
@@ -237,15 +256,40 @@ class Alissa:
         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:
+    def list_review_sessions(self) -> list[ManagedSession]:
+        """The live `review-*` managed sessions, from `alissa tmux ls`.
+
+        The reap sweep's starting point. Unlike the review-requested search,
+        the live session list cannot lose a finished session, so every reap
+        candidate is reachable from here. `--live` because a session that is
+        already gone (self-killed, or killed by an operator) holds no worker
+        slot and needs no reap. Raises CommandError upward -- the sweep skips
+        this pass and tries again next poll.
+        """
+        data = run_json(["alissa", "tmux", "ls", "--json", "--live"], timeout=60) or []
+        sessions = []
+        for row in data if isinstance(data, list) else []:
+            if not isinstance(row, dict):
+                continue
+            name = row.get("name")
+            if isinstance(name, str) and name.startswith(REVIEW_SESSION_PREFIX):
+                last = row.get("lastActivity")
+                sessions.append(
+                    ManagedSession(
+                        name=name,
+                        status=str(row.get("status") or ""),
+                        last_activity=float(last) if isinstance(last, (int, float)) else 0.0,
+                    )
+                )
+        return sessions
+
+    def kill_session(self, session: str) -> 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.
+        reviewer self-killed), so a non-zero exit is not an error here. Dry-run
+        is the caller's job (the sweep decides and logs before calling).
         """
-        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(

{alissa_tools_github_reviewloop-0.7.0 → alissa_tools_github_reviewloop-0.9.0}/src/main/alissa/tools/github/reviewloop/ghclient.py

@@ -28,6 +28,9 @@ class PullRequest:
     head_sha: str
     draft: bool
     url: str
+    # "open" or "closed"; merged PRs report state "closed" AND merged True.
+    state: str = "open"
+    merged: bool = False
 
     @property
     def full_name(self) -> str:
@@ -37,6 +40,11 @@ class PullRequest:
     def slug(self) -> str:
         return f"{self.owner}/{self.repo}#{self.number}"
 
+    @property
+    def is_terminal(self) -> bool:
+        """Closed or merged: no round can ever be owed on this PR again."""
+        return self.merged or self.state != "open"
+
 
 @dataclass(frozen=True)
 class Review:
@@ -150,6 +158,8 @@ class GitHub:
             head_sha=(data.get("head") or {}).get("sha", ""),
             draft=bool(data.get("draft")),
             url=data.get("html_url", ""),
+            state=data.get("state") or "open",
+            merged=bool(data.get("merged")),
         )
 
     def reviews(self, owner: str, repo: str, number: int) -> list[Review]:

{alissa_tools_github_reviewloop-0.7.0 → alissa_tools_github_reviewloop-0.9.0}/src/main/alissa/tools/github/reviewloop/loop.py

@@ -27,9 +27,33 @@ from .state import State
 log = logging.getLogger(__name__)
 
 # A reviewer session that has not submitted after this long is presumed dead
-# (skill failure mode: "reviewer session stalls"). The round is re-enqueued.
+# (skill failure mode: "reviewer session stalls"). The round is re-enqueued --
+# but only with a second signal agreeing: the timer alone cannot tell a dead
+# session from a slow one, and a timer-only re-enqueue double-spends the round
+# (two sessions review it, both submit -- observed live twice: double round-2
+# approves on devloop's PR #11, double approves on this repo's PR #19). See
+# _defer_stale_round for the liveness signal.
 STALE_ROUND_SECONDS = 90 * 60
 
+# The floor under the liveness deferral: a live session defers the stale
+# respawn indefinitely -- correct for a genuinely slow round, silent forever
+# for a session that is wedged but still registers tmux activity. Once the
+# newest spawn's age reaches this multiple of STALE_ROUND_SECONDS, the loop
+# posts one "stalled" operator comment per deferral episode (stalled_kind)
+# and keeps deferring. 2 means the deferral itself has lasted a full extra
+# stale window beyond the point the timer first fired -- long enough that a
+# healthy round has almost always submitted by then, early enough that a
+# wedged one surfaces the same day.
+STALLED_DEFER_MULTIPLE = 2
+
+# The sweep only reaps a session that has been idle AND quiet this long. The
+# GitHub review count increments the moment a review is submitted, but the
+# reviewer still has close-out work after that (CR6 envelope, task status) --
+# and a claude session parked at its prompt between turns reports "idle", so
+# idleness alone cannot distinguish "between turns" from "done". Recent tmux
+# activity can.
+REAP_QUIET_SECONDS = 5 * 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.
@@ -88,6 +112,38 @@ ESCALATION_COMMENT = (
     "Last verdict: `{last_state}` at `{sha}`."
 )
 
+STALLED_COMMENT = (
+    "**Review round stalled?** — round {round} has been in flight {minutes} min "
+    "(stale window: {stale} min), but its reviewer session `{session}` still "
+    "shows signs of life, so the daemon keeps deferring the respawn — "
+    "respawning over a live session double-spends the round: two reviewers "
+    "work it, both submit. Is that session actually making progress? Operator "
+    "options: inspect it (`alissa tmux ls`) and, if it is wedged, kill it "
+    "(`alissa tmux kill {session}`) so the respawn proceeds next poll, or "
+    "finish the round by hand."
+)
+
+# The ping-ledger kind prefix for the stalled-deferral operator ping. Unlike
+# the cap-out escalation (terminal per head), a stall can recur, so the kind
+# is narrowed per episode -- see stalled_kind.
+ESCALATION_STALLED = "stalled"
+
+
+def stalled_kind(session: str) -> str:
+    """The ping-ledger kind that dedupes ONE deferral episode's operator ping.
+
+    Devloop's stalled_kind reasoning, transposed: a stall can recur -- every
+    spawn of every round can wedge mid-flight, and episode k's ping must not
+    silence episode k+1's. Keyed on the bare kind (or even on the round), the
+    re-enqueue of a round that wedges AGAIN would defer silently forever. The
+    session name already IS the episode identity -- nonce-unique per spawn
+    (see session_name) -- so it folds into the key. Delivery contract: the
+    ledger row lands only AFTER the comment posts (see _escalate_stalled), so
+    a transient comment failure retries next poll and the ping lands exactly
+    once per episode.
+    """
+    return f"{ESCALATION_STALLED}:{session}"
+
 
 class Action(str, Enum):
     SPAWNED = "spawned"
@@ -167,11 +223,6 @@ class ReviewWatcher:
             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, pr.head_sha)
         if converged is not None:
             return Decision(Action.CONVERGED, converged, completed)
@@ -189,9 +240,13 @@ class ReviewWatcher:
         if age is not None and age < STALE_ROUND_SECONDS:
             return Decision(Action.IN_FLIGHT, f"round {round_} enqueued {int(age)}s ago", round_)
         if age is not None:
+            deferred = self._defer_stale_round(pr, round_, age)
+            if deferred is not None:
+                return deferred
             log.warning(
                 "%s round %d has been in flight %.0f min with no submitted review "
-                "— re-enqueuing (reviewer session presumed stalled)",
+                "and its session is gone or finished — re-enqueuing (reviewer "
+                "session presumed dead)",
                 pr.slug,
                 round_,
                 age / 60,
@@ -199,6 +254,70 @@ class ReviewWatcher:
 
         return self._spawn(pr, round_, task)
 
+    def _defer_stale_round(self, pr: PullRequest, round_: int, age: float) -> Decision | None:
+        """The liveness signal under the stale timer: a deferral, or None to
+        respawn.
+
+        Staleness needs TWO signals, not one: the ledger timer says the
+        newest spawn is old, but elapsed time alone cannot tell a dead
+        session from a slow one -- a thorough round can outlast
+        STALE_ROUND_SECONDS, and a timer-only re-enqueue respawns a reviewer
+        over the still-working first one; two sessions review the same
+        round and both submit. So before respawning, consult external
+        evidence of life: the round's recorded session in the live list
+        (the reap sweep's own probe). Busy, or idle without a real quiet
+        period (mid-close-out between turns; see REAP_QUIET_SECONDS) -> the
+        round is alive, defer with a reason. Gone, or idle-finished -> dead,
+        respawn (the sweep separately handles any corpse). An unprobeable
+        live list defers too: respawning on missing evidence is exactly the
+        double-spend, and the probe retries next poll.
+
+        The deferral is floored, not unbounded: past STALLED_DEFER_MULTIPLE
+        stale windows with the session still alive, one operator ping per
+        deferral episode (stalled_kind) -- then keep deferring. This method
+        never respawns over a live session; only the operator killing the
+        session (or it finishing/dying) unblocks the respawn.
+        """
+        row = self.state.get_spawn(pr.full_name, pr.number, round_)
+        if row is None:  # age came from this row; belt and braces
+            return None
+        session = row["session"]
+        try:
+            live = {s.name: s for s in self.alissa.list_review_sessions()}
+        except CommandError as exc:
+            log.warning(
+                "%s round %d is stale but the session list is unavailable (%s) "
+                "— deferring the respawn rather than risking a double-spawned "
+                "round; the probe retries next poll",
+                pr.slug,
+                round_,
+                exc,
+            )
+            return Decision(
+                Action.IN_FLIGHT,
+                f"round {round_} is stale but liveness is unprobeable — deferring",
+                round_,
+            )
+
+        ses = live.get(session)
+        if ses is None:
+            return None  # session gone -> presumed dead -> respawn
+        if ses.is_idle and time.time() - ses.last_activity >= REAP_QUIET_SECONDS:
+            return None  # idle-finished: it died without submitting -> respawn
+
+        if (
+            age >= STALLED_DEFER_MULTIPLE * STALE_ROUND_SECONDS
+            and not self.state.pinged(pr.full_name, pr.number, stalled_kind(session))
+        ):
+            self._escalate_stalled(pr, round_, session, age)
+        return Decision(
+            Action.IN_FLIGHT,
+            f"round {round_} is stale ({int(age / 60)} min) but session "
+            f"{session} is still {'active' if ses.is_idle else 'busy'} — not "
+            f"respawning over a live reviewer",
+            round_,
+        )
+
     def _convergence_reason(
         self, my_reviews: list[Review], task: Task | None, head_sha: str
     ) -> str | None:
@@ -244,30 +363,135 @@ 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.
+    # -- reap sweep --------------------------------------------------------
+
+    def sweep_sessions(self) -> None:
+        """Kill the managed session of every finished round. Runs every poll.
+
+        The predecessor of this sweep ran inside evaluate(), which is fed by
+        the review-requested:@me search -- and submitting a review CLEARS the
+        request, so a finished round's PR vanished from the search at exactly
+        the moment its session became reapable; terminal (approved) rounds
+        were never reaped and idle reviewer sessions accumulated in the
+        worker. The sweep instead starts from the live session list, which
+        cannot lose a finished session, and works back to the round via the
+        spawn ledger. It must stay search-independent: never move it (back)
+        into the evaluate() path.
+
+        Every-poll cost, honestly: one `alissa tmux ls` when no review-*
+        session is live; otherwise one PR fetch per distinct PR with a live
+        idle quiet session, plus -- per distinct (PR, task ref) among its
+        rows -- exactly one of `alissa task get <ref>` (the row carries a
+        task ref) or the reviews fetch (it does not). The ledger ref is used
+        deliberately instead of
+        find_review_task: that would fetch the actor's ENTIRE task list per
+        PR, and its open-status filter would drop a human-validated review
+        task back onto the racier GitHub-count fallback. Only individual
+        sessions are ever killed (`alissa tmux kill <name>`) -- never the
+        server. Best-effort throughout: an undecidable session is spared and
+        looked at again next poll.
         """
-        if self.config.dry_run or completed < 1:
+        try:
+            sessions = self.alissa.list_review_sessions()
+        except CommandError as exc:
+            log.warning("reap sweep skipped: could not list sessions: %s", exc)
             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"]):
+
+        # Per-sweep memos. The PR fetch is keyed per distinct PR; the round
+        # count additionally keys on the task ref, because two spawns of one
+        # PR can disagree on it (a round-1 row recorded before the review
+        # task existed carries None). None = undecidable this pass.
+        prs: dict[tuple[str, int], PullRequest | None] = {}
+        completed_cache: dict[tuple[str, int, str | None], float | None] = {}
+
+        for ses in sessions:
+            if not ses.is_idle:
+                # A busy session is still doing something (reviewing, or
+                # closing out its round) -- never yank the slot from under it.
+                continue
+            if time.time() - ses.last_activity < REAP_QUIET_SECONDS:
+                # Idle but recently active: likely mid-close-out (the review
+                # is submitted before the envelope and task move land). Wait
+                # for a real quiet period; see REAP_QUIET_SECONDS.
+                continue
+            row = self.state.find_spawn_by_session(ses.name)
+            if row is None:
+                # Not in our ledger: another workspace's daemon (or a human)
+                # owns it. Not ours to judge.
+                continue
+            pr_key = (row["repo"], row["number"])
+            if pr_key not in prs:
+                prs[pr_key] = self._sweep_pr(row["repo"], row["number"])
+            pr = prs[pr_key]
+            if pr is None:
+                continue  # fetch failed -- spare everything on this PR
+            key = (row["repo"], row["number"], row["task_ref"])
+            if key not in completed_cache:
+                completed_cache[key] = self._completed_rounds(pr, row["task_ref"])
+            completed = completed_cache[key]
+            if completed is None or row["round"] > completed:
+                continue  # undecidable, or the round is still in flight
+            if self.config.dry_run:
+                log.info(
+                    "[dry-run] would reap finished reviewer session %s (round %d done)",
+                    ses.name, row["round"],
+                )
                 continue
-            session = row["session"]
             try:
-                self.alissa.kill_session(session)
+                self.alissa.kill_session(ses.name)
             except Exception:  # pragma: no cover - defence in depth
-                log.exception("failed to reap session %s", session)
+                log.exception("failed to reap session %s", ses.name)
                 continue
-            self.state.record_reap(session)
-            log.info("reaped finished reviewer session %s (round %d done)", session, round_)
+            # Bookkeeping only -- deliberately never consulted before a kill.
+            # The live list is the authority; gating on the reaps table would
+            # spare any session killed behind the ledger's back.
+            self.state.record_reap(ses.name)
+            log.info(
+                "reaped finished reviewer session %s (round %d done)",
+                ses.name, row["round"],
+            )
+
+    def _sweep_pr(self, repo_slug: str, number: int) -> PullRequest | None:
+        """One PR fetch for the sweep; the caller memoizes per distinct PR.
+
+        None = the fetch failed -- every session on that PR is spared this
+        pass and looked at again next poll. RateLimited propagates so
+        run_forever backs off instead of hammering the API once per session.
+        """
+        owner, _, repo = repo_slug.partition("/")
+        try:
+            return self.github.pull_request(owner, repo, number)
+        except RateLimited:
+            raise
+        except CommandError as exc:
+            log.warning("reap sweep: could not fetch %s#%d: %s", repo_slug, number, exc)
+            return None
+
+    def _completed_rounds(self, pr: PullRequest, task_ref: str | None) -> float | None:
+        """How many rounds of this PR are over, judged from GitHub/task state.
+
+        A closed or merged PR terminates every round, so it reports infinity.
+        Otherwise rounds completed = verdict envelopes on the review task (the
+        authoritative round record), addressed by the task ref the ledger
+        captured at spawn time -- NOT find_review_task, which would fetch the
+        whole task list and whose open-status filter loses validated tasks.
+        The substantive-review count is the fallback only for spawns recorded
+        before any review task existed. None means "could not tell" -- the
+        sweep spares the session and retries next poll.
+        """
+        if pr.is_terminal:
+            return float("inf")
+        if task_ref:
+            # count_verdicts never raises; unreadable evidence degrades to 0,
+            # which spares the session (round >= 1 > 0).
+            return self.alissa.count_verdicts(task_ref)
+        try:
+            return len(self.github.my_reviews(pr.owner, pr.repo, pr.number))
+        except RateLimited:
+            raise
+        except CommandError as exc:
+            log.warning("reap sweep: could not count reviews on %s: %s", pr.slug, exc)
+            return None
 
     # -- actions -----------------------------------------------------------
 
@@ -397,6 +621,51 @@ class ReviewWatcher:
 
         return warnings
 
+    def _escalate_stalled(
+        self, pr: PullRequest, round_: int, session: str, age: float
+    ) -> None:
+        """Operator ping when the liveness deferral itself runs long: the
+        session showing life is the only thing holding the respawn back, so
+        a human must check whether it is progressing or wedged. Posted once
+        per deferral EPISODE (the ping ledger row is keyed
+        stalled_kind(session); a re-enqueued round that stalls again is a
+        new session, so it pings again), and the row is recorded only AFTER
+        the comment posts: this ping is the operator's only signal for the
+        episode, so a transient comment failure must retry next poll --
+        exactly-once delivered, unlike the cap-out page (a terminal state,
+        recorded despite failure). The decision stays a deferral either way
+        -- this comments, it never respawns."""
+        body = STALLED_COMMENT.format(
+            round=round_,
+            minutes=int(age / 60),
+            stale=STALE_ROUND_SECONDS // 60,
+            session=session,
+        )
+        log.warning(
+            "STALLED %s round %d has been deferred %.0f min behind live session "
+            "%s — escalating to operator (once per episode)",
+            pr.slug,
+            round_,
+            age / 60,
+            session,
+        )
+
+        if self.config.dry_run:
+            log.info("[dry-run] would comment on %s:\n%s", pr.slug, body)
+            return
+
+        try:
+            self.github.comment(pr.owner, pr.repo, pr.number, body)
+        except CommandError as exc:
+            log.error(
+                "could not post the stalled-round comment on %s: %s — not "
+                "recording the episode; the ping retries next poll",
+                pr.slug,
+                exc,
+            )
+            return
+        self.state.record_ping(pr.full_name, pr.number, stalled_kind(session))
+
     def _escalate(self, pr: PullRequest, last_state: str, rounds: int) -> None:
         body = ESCALATION_COMMENT.format(
             rounds=rounds, last_state=last_state.lower(), sha=pr.head_sha[:8]
@@ -416,6 +685,12 @@ class ReviewWatcher:
     # -- polling -----------------------------------------------------------
 
     def poll_once(self) -> list[tuple[str, Decision]]:
+        # Sweep BEFORE evaluating: a full worker is exactly when a fresh spawn
+        # needs the slot a finished session is squatting on. Deliberately not
+        # inside the per-request loop below — the sweep must reach sessions
+        # whose PR no longer appears in the search at all.
+        self.sweep_sessions()
+
         requests = self.github.review_requests(self.config.repos)
         log.info("%d PR(s) with a review pending from %s", len(requests), self.github.login)
 
@@ -442,16 +717,21 @@ class ReviewWatcher:
         # every mode, so calling it here too would double every check.
         backoff = self.config.poll_interval
         while True:
+            # The sleep lives INSIDE the KeyboardInterrupt guard: with a 60s
+            # poll interval (up to 900s backing off) the loop spends nearly
+            # all its wall-clock sleeping, so a real Ctrl-C almost always
+            # lands there and must hit the same clean-exit path.
             try:
-                self.poll_once()
-                backoff = self.config.poll_interval
-            except RateLimited as exc:
-                backoff = min(backoff * 2, 900)
-                log.warning("rate limited (%s) — backing off %ds", exc, backoff)
-            except CommandError as exc:
-                backoff = min(backoff * 2, 900)
-                log.error("poll failed: %s — retrying in %ds", exc, backoff)
+                try:
+                    self.poll_once()
+                    backoff = self.config.poll_interval
+                except RateLimited as exc:
+                    backoff = min(backoff * 2, 900)
+                    log.warning("rate limited (%s) — backing off %ds", exc, backoff)
+                except CommandError as exc:
+                    backoff = min(backoff * 2, 900)
+                    log.error("poll failed: %s — retrying in %ds", exc, backoff)
+                time.sleep(backoff)
             except KeyboardInterrupt:
                 log.info("stopping")
                 return
-            time.sleep(backoff)

alissa_tools_github_reviewloop-0.9.0/src/main/alissa/tools/github/reviewloop/state.py

@@ -0,0 +1,218 @@
+"""Local spawn ledger.
+
+Deliberately thin: GitHub is the source of truth for how many rounds have run
+(one submitted review per round). This table exists only to stop the daemon
+double-spawning a reviewer while a round is still in flight, to map a live
+session name back to the round it was spawned for (so the reap sweep can tell
+a finished round's session from an in-flight one), and to remember that a
+cap-out was already escalated. The ledger tolerates sessions dying or being
+killed behind its back: a reap record is bookkeeping, never a precondition.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+import time
+from pathlib import Path
+
+# Shared between SCHEMA and the migration so the two can never drift.
+_SPAWNS_TABLE = """
+CREATE TABLE IF NOT EXISTS spawns (
+    repo       TEXT    NOT NULL,
+    number     INTEGER NOT NULL,
+    round      INTEGER NOT NULL,
+    head_sha   TEXT    NOT NULL,
+    session    TEXT    NOT NULL PRIMARY KEY,
+    task_ref   TEXT,
+    spawned_at INTEGER NOT NULL
+)"""
+
+SCHEMA = f"""
+{_SPAWNS_TABLE};
+
+CREATE INDEX IF NOT EXISTS spawns_by_round ON spawns (repo, number, round);
+
+CREATE TABLE IF NOT EXISTS escalations (
+    repo         TEXT    NOT NULL,
+    number       INTEGER NOT NULL,
+    head_sha     TEXT    NOT NULL,
+    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
+);
+
+CREATE TABLE IF NOT EXISTS pings (
+    repo      TEXT    NOT NULL,
+    number    INTEGER NOT NULL,
+    kind      TEXT    NOT NULL,
+    pinged_at INTEGER NOT NULL,
+    PRIMARY KEY (repo, number, kind)
+);
+"""
+
+
+class State:
+    def __init__(self, path: Path):
+        path = Path(path).expanduser()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        self._db = sqlite3.connect(str(path))
+        self._db.row_factory = sqlite3.Row
+        if self._spawns_keyed_by_round():
+            self._migrate_spawns()
+        self._db.executescript(SCHEMA)
+        self._db.commit()
+
+    def _migrate_spawns(self) -> None:
+        """Re-key an old round-keyed `spawns` by session, in ONE transaction.
+
+        Deliberately not executescript (it COMMITs the open transaction before
+        running): a crash between the rename and the copy would otherwise
+        leave an empty new `spawns` that no longer looks stale, stranding
+        every row in spawns_v0 — an empty ledger makes the sweep spare every
+        live session as "not ours". All-or-nothing instead: any failure rolls
+        back to the untouched old table and the next open retries.
+        """
+        self._db.execute("BEGIN IMMEDIATE")
+        try:
+            self._db.execute("ALTER TABLE spawns RENAME TO spawns_v0")
+            self._db.execute(_SPAWNS_TABLE)
+            self._db.execute(
+                "INSERT OR REPLACE INTO spawns "
+                "(repo, number, round, head_sha, session, task_ref, spawned_at) "
+                "SELECT repo, number, round, head_sha, session, task_ref, spawned_at "
+                "FROM spawns_v0"
+            )
+            self._db.execute("DROP TABLE spawns_v0")
+        except BaseException:
+            self._db.execute("ROLLBACK")
+            raise
+        self._db.execute("COMMIT")
+
+    def _spawns_keyed_by_round(self) -> bool:
+        """True when `spawns` still has the pre-0.8 (repo, number, round) key.
+
+        That key made `record_spawn` overwrite the row when a stalled round
+        was re-enqueued, orphaning the original -- possibly still-live --
+        session so the reap sweep spared it forever as "not ours". The key is
+        now the session name (unique per spawn, thanks to the nonce). SQLite
+        cannot alter a primary key in place, so an old table is renamed and
+        copied over exactly once on open.
+        """
+        info = self._db.execute("PRAGMA table_info(spawns)").fetchall()
+        if not info:
+            return False  # fresh database, nothing to migrate
+        return [r["name"] for r in info if r["pk"]] != ["session"]
+
+    def close(self) -> None:
+        self._db.close()
+
+    def __enter__(self) -> "State":
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.close()
+
+    def get_spawn(self, repo: str, number: int, round_: int) -> sqlite3.Row | None:
+        """The NEWEST spawn recorded for this round, or None.
+
+        A stalled round can be re-enqueued, so one round may have several
+        spawns; aging and the in-flight check are about the latest attempt.
+        """
+        return self._db.execute(
+            "SELECT * FROM spawns WHERE repo=? AND number=? AND round=? "
+            "ORDER BY spawned_at DESC, rowid DESC LIMIT 1",
+            (repo, number, round_),
+        ).fetchone()
+
+    def find_spawn_by_session(self, session: str) -> sqlite3.Row | None:
+        """The spawn a live session name belongs to, or None if it is not ours.
+
+        Session names carry a random nonce, so a name maps to at most one
+        spawn. The reap sweep starts from live tmux state and uses this to
+        recover (repo, number, round); a session with no row (another
+        workspace's daemon, or a hand-started one) is not ours to judge.
+        """
+        return self._db.execute(
+            "SELECT * FROM spawns WHERE session=?", (session,)
+        ).fetchone()
+
+    def spawn_age(self, repo: str, number: int, round_: int) -> float | None:
+        """Seconds since round `round_` was enqueued, or None if never spawned."""
+        row = self.get_spawn(repo, number, round_)
+        return None if row is None else time.time() - row["spawned_at"]
+
+    def record_spawn(
+        self,
+        *,
+        repo: str,
+        number: int,
+        round_: int,
+        head_sha: str,
+        session: str,
+        task_ref: str | None,
+    ) -> None:
+        self._db.execute(
+            "INSERT OR REPLACE INTO spawns "
+            "(repo, number, round, head_sha, session, task_ref, spawned_at) "
+            "VALUES (?,?,?,?,?,?,?)",
+            (repo, number, round_, head_sha, session, task_ref, int(time.time())),
+        )
+        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 pinged(self, repo: str, number: int, kind: str) -> bool:
+        """Whether this KIND of operator ping already went out for the PR.
+
+        Kind is free-form TEXT (devloop's escalation-kind pattern): a caller
+        narrows a kind's dedupe scope by folding identity into the string --
+        e.g. one stalled ping per deferral episode, "stalled:<session>" (see
+        loop.stalled_kind). Kept apart from `escalations`, whose key is
+        (repo, number, head_sha) and whose rows page terminal states.
+        """
+        row = self._db.execute(
+            "SELECT 1 FROM pings WHERE repo=? AND number=? AND kind=?",
+            (repo, number, kind),
+        ).fetchone()
+        return row is not None
+
+    def record_ping(self, repo: str, number: int, kind: str) -> None:
+        """Idempotent per kind: OR IGNORE keeps the FIRST ping's timestamp,
+        so `pinged_at` is an audit field for when the episode was first
+        raised, not the most recent re-raise."""
+        self._db.execute(
+            "INSERT OR IGNORE INTO pings (repo, number, kind, pinged_at) "
+            "VALUES (?,?,?,?)",
+            (repo, number, kind, 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=?",
+            (repo, number, head_sha),
+        ).fetchone()
+        return row is not None
+
+    def record_escalation(self, repo: str, number: int, head_sha: str) -> None:
+        self._db.execute(
+            "INSERT OR REPLACE INTO escalations "
+            "(repo, number, head_sha, escalated_at) VALUES (?,?,?,?)",
+            (repo, number, head_sha, int(time.time())),
+        )
+        self._db.commit()

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

@@ -0,0 +1 @@
+0.9.0

{alissa_tools_github_reviewloop-0.7.0 → alissa_tools_github_reviewloop-0.9.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.7.0
+Version: 0.9.0
 Summary: ALISSA-TOOLS-GITHUB-REVIEWLOOP
 Home-page: https://alissa.app
 Author: Fahera

alissa_tools_github_reviewloop-0.7.0/src/main/alissa/tools/github/reviewloop/state.py

@@ -1,115 +0,0 @@
-"""Local spawn ledger.
-
-Deliberately thin: GitHub is the source of truth for how many rounds have run
-(one submitted review per round). This table exists only to stop the daemon
-double-spawning a reviewer while a round is still in flight, and to remember
-that a cap-out was already escalated.
-"""
-
-from __future__ import annotations
-
-import sqlite3
-import time
-from pathlib import Path
-
-SCHEMA = """
-CREATE TABLE IF NOT EXISTS spawns (
-    repo       TEXT    NOT NULL,
-    number     INTEGER NOT NULL,
-    round      INTEGER NOT NULL,
-    head_sha   TEXT    NOT NULL,
-    session    TEXT    NOT NULL,
-    task_ref   TEXT,
-    spawned_at INTEGER NOT NULL,
-    PRIMARY KEY (repo, number, round)
-);
-
-CREATE TABLE IF NOT EXISTS escalations (
-    repo         TEXT    NOT NULL,
-    number       INTEGER NOT NULL,
-    head_sha     TEXT    NOT NULL,
-    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
-);
-"""
-
-
-class State:
-    def __init__(self, path: Path):
-        path = Path(path).expanduser()
-        path.parent.mkdir(parents=True, exist_ok=True)
-        self._db = sqlite3.connect(str(path))
-        self._db.row_factory = sqlite3.Row
-        self._db.executescript(SCHEMA)
-        self._db.commit()
-
-    def close(self) -> None:
-        self._db.close()
-
-    def __enter__(self) -> "State":
-        return self
-
-    def __exit__(self, *exc) -> None:
-        self.close()
-
-    def get_spawn(self, repo: str, number: int, round_: int) -> sqlite3.Row | None:
-        return self._db.execute(
-            "SELECT * FROM spawns WHERE repo=? AND number=? AND round=?",
-            (repo, number, round_),
-        ).fetchone()
-
-    def spawn_age(self, repo: str, number: int, round_: int) -> float | None:
-        """Seconds since round `round_` was enqueued, or None if never spawned."""
-        row = self.get_spawn(repo, number, round_)
-        return None if row is None else time.time() - row["spawned_at"]
-
-    def record_spawn(
-        self,
-        *,
-        repo: str,
-        number: int,
-        round_: int,
-        head_sha: str,
-        session: str,
-        task_ref: str | None,
-    ) -> None:
-        self._db.execute(
-            "INSERT OR REPLACE INTO spawns "
-            "(repo, number, round, head_sha, session, task_ref, spawned_at) "
-            "VALUES (?,?,?,?,?,?,?)",
-            (repo, number, round_, head_sha, session, task_ref, int(time.time())),
-        )
-        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=?",
-            (repo, number, head_sha),
-        ).fetchone()
-        return row is not None
-
-    def record_escalation(self, repo: str, number: int, head_sha: str) -> None:
-        self._db.execute(
-            "INSERT OR REPLACE INTO escalations "
-            "(repo, number, head_sha, escalated_at) VALUES (?,?,?,?)",
-            (repo, number, head_sha, int(time.time())),
-        )
-        self._db.commit()

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

@@ -1 +0,0 @@
-0.7.0