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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-reviewloop
-Version: 0.7.0
+Version: 0.8.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.8.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.8.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.8.0}/src/main/alissa/tools/github/reviewloop/loop.py

@@ -30,6 +30,14 @@ log = logging.getLogger(__name__)
 # (skill failure mode: "reviewer session stalls"). The round is re-enqueued.
 STALE_ROUND_SECONDS = 90 * 60
 
+# 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.
@@ -167,11 +175,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)
@@ -244,30 +247,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 -----------------------------------------------------------
 
@@ -416,6 +524,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 +556,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.8.0/src/main/alissa/tools/github/reviewloop/state.py

@@ -0,0 +1,184 @@
+"""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
+);
+"""
+
+
+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 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.8.0/src/main/alissa/tools/github/reviewloop/version

@@ -0,0 +1 @@
+0.8.0

{alissa_tools_github_reviewloop-0.7.0 → alissa_tools_github_reviewloop-0.8.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.8.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