alissa-tools-github-revloop 0.27.0__tar.gz → 0.28.0__tar.gz

{alissa_tools_github_revloop-0.27.0/src/main/alissa_tools_github_revloop.egg-info → alissa_tools_github_revloop-0.28.0}/PKG-INFO

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

{alissa_tools_github_revloop-0.27.0 → alissa_tools_github_revloop-0.28.0}/src/main/alissa/tools/github/revloop/__main__.py

@@ -11,6 +11,7 @@ from pathlib import Path
 from .config import (
     HUB_ADD,
     HUB_SKIP,
+    LOOP_EVENTS_ENV,
     ON_MISSING_CREATE,
     ON_MISSING_SKIP,
     ON_MISSING_SPAWN,
@@ -200,6 +201,31 @@ def build_parser() -> argparse.ArgumentParser:
         f"invisible to this daemon. Overridden by ${TASK_LIST_BOW_ENV}",
     )
 
+    events = over.add_mutually_exclusive_group()
+    events.add_argument(
+        "--loop-events",
+        dest="loop_events_enabled",
+        action="store_true",
+        default=None,
+        help="push loop telemetry (rounds spawned, verdicts, cap-outs, "
+        "stability holds, stalls, checks holds) to Studio's POST "
+        "/v1/loop-events once per poll pass — best-effort, never fatal. "
+        f"Overridden by ${LOOP_EVENTS_ENV}",
+    )
+    events.add_argument(
+        "--no-loop-events",
+        dest="loop_events_enabled",
+        action="store_false",
+        help="do not push loop telemetry even if the config enables it",
+    )
+    over.add_argument(
+        "--alissa-endpoint",
+        dest="alissa_endpoint",
+        metavar="URL",
+        help="the Alissa API base the loop-events client posts to "
+        "(default: https://api.alissa.app)",
+    )
+
     dry = over.add_mutually_exclusive_group()
     dry.add_argument(
         "--dry-run",
@@ -242,6 +268,8 @@ def overrides_from(args: argparse.Namespace) -> dict:
         "review_task_miss_ttl_polls": args.review_task_miss_ttl_polls,
         "task_list_self_scope": args.task_list_self_scope,
         "task_list_bow_id": args.task_list_bow_id,
+        "loop_events_enabled": args.loop_events_enabled,
+        "alissa_endpoint": args.alissa_endpoint,
         "dry_run": args.dry_run,
     }
 

alissa_tools_github_revloop-0.28.0/src/main/alissa/tools/github/revloop/alissa_client.py

@@ -0,0 +1,191 @@
+"""Alissa REST access — the one write loop telemetry needs (issue #112).
+
+This is the SECOND Alissa adapter in the package, and the split is deliberate.
+`alissa.py` shells out to the `alissa` CLI, which is the daemon's established
+Alissa idiom for everything it does today (the review-task search, the tmux
+queue, the CR6 envelope reads). Loop telemetry needs a thing that idiom cannot
+supply: the CLI has no loop-events command, and it cannot attach the actor
+identity `POST /v1/loop-events` keys its rows by — the API stores events under
+the token's principal user, which is exactly the credential this daemon's
+`ALISSA_API_TOKEN` already carries.
+
+So the one write goes over the REST API directly, in the shape devloop's
+`alissa_client.py` adopted (PR #91 there): stdlib `urllib` only — the
+distribution ships no third-party runtime dependency and this must not be the
+change that adds one — a bearer token from the environment, bounded timeouts,
+and errors classified into a small taxonomy instead of leaking raw urllib
+exceptions. The CLI adapter stays untouched for everything else.
+
+The caller here is a BEST-EFFORT emitter (`loop_events`): its answer to every
+bucket is the same — warn once and let the pass complete — so the taxonomy
+exists for the log line, which should say "your token is wrong" (permanent,
+operator-fixable) differently from "the API blinked".
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import urllib.error
+import urllib.request
+
+log = logging.getLogger(__name__)
+
+DEFAULT_ENDPOINT = "https://api.alissa.app"
+
+# The env var the `alissa` CLI itself reads, so a daemon whose CLI is already
+# authenticated needs no second secret.
+ENV_TOKEN = "ALISSA_API_TOKEN"
+
+# The ingest cap: POST /v1/loop-events takes 1-200 events per call. The
+# EMITTER splits batches at this bound; the client refuses an oversized one
+# rather than silently posting a request the API will 400.
+MAX_EVENTS_PER_POST = 200
+
+
+class _RefuseRedirects(urllib.request.HTTPRedirectHandler):
+    """Refuse every redirect instead of following it (PR #113 round 1).
+
+    The default handler copies the request's headers — `Authorization`
+    included — onto the redirected request, ACROSS HOSTS, so a 30x from
+    whatever `alissa_endpoint` names would hand the bearer token to the
+    redirect target (and 301/302/303 would downgrade the POST to a GET that
+    ingests nothing while reading as success). A redirected ingest cannot
+    succeed anyway, so refusal beats strip-and-follow: returning None makes
+    urllib raise the 30x as an HTTPError, which the taxonomy reports like any
+    other unexpected status.
+    """
+
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        return None
+
+
+# One opener for the module: default handlers with only the redirect
+# behaviour replaced, built once because handler construction is not free
+# and every client shares the same policy.
+_opener = urllib.request.build_opener(_RefuseRedirects())
+
+
+class AlissaError(Exception):
+    """Base of the taxonomy. `status` is 0 for a transport failure (there was
+    no HTTP response to carry one)."""
+
+    def __init__(self, status: int, detail: object, code: "str | None" = None):
+        super().__init__(f"HTTP {status}: {detail}" if status else str(detail))
+        self.status = status
+        self.detail = detail
+        self.code = code
+
+
+class AlissaAuthError(AlissaError):
+    """401/403, or no token at all. Permanent and operator-fixable — retrying
+    it every pass only writes the same warning again."""
+
+
+class AlissaTransient(AlissaError):
+    """408/429/5xx and every transport failure (DNS, refused, timeout). The
+    'the API blinked' bucket — re-emission next pass is the retry, and the
+    deterministic dedupe keys are what make it harmless."""
+
+
+class AlissaClient:
+    """The one write, with the transport hidden behind the taxonomy.
+
+    Reads `ALISSA_API_TOKEN` from the environment; `base` defaults to the
+    public API. Both are constructor arguments so a test never needs the
+    network and an operator can point a daemon at another deployment
+    (`alissa_endpoint` in the config)."""
+
+    def __init__(
+        self,
+        token: "str | None" = None,
+        base: "str | None" = None,
+        *,
+        timeout: int = 30,
+    ):
+        self.base = (base or DEFAULT_ENDPOINT).rstrip("/")
+        self._token = token if token is not None else os.environ.get(ENV_TOKEN)
+        self._timeout = timeout
+
+    def _request(self, path: str, payload: dict) -> object:
+        """One POST. Every failure leaves as a taxonomy exception — the caller
+        never sees a raw urllib error or an HTTP status."""
+        if not self._token:
+            # No token at all is an auth condition, not a transport one: the
+            # operator must set the env var. Fail the way a 401 would, so the
+            # emitter's warning reads as permanent rather than transient.
+            raise AlissaAuthError(0, f"{ENV_TOKEN} is not set")
+
+        req = urllib.request.Request(
+            f"{self.base}{path}",
+            method="POST",
+            data=json.dumps(payload).encode("utf-8"),
+            headers={
+                "Accept": "application/json",
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {self._token}",
+            },
+        )
+        try:
+            with _opener.open(req, timeout=self._timeout) as resp:
+                raw = resp.read().decode("utf-8")
+        except urllib.error.HTTPError as exc:
+            raise self._classify(exc) from None
+        except urllib.error.URLError as exc:
+            raise AlissaTransient(0, str(exc.reason)) from None
+        except (TimeoutError, OSError) as exc:  # pragma: no cover - defence
+            # A socket timeout on the READ does not arrive as URLError.
+            raise AlissaTransient(0, str(exc)) from None
+        try:
+            return json.loads(raw) if raw.strip() else {}
+        except json.JSONDecodeError as exc:
+            # A 2xx that is not JSON is a contract violation, not a retry
+            # signal -- but it must not escape as a bare ValueError either,
+            # because the emitter catches AlissaError and nothing else.
+            raise AlissaError(200, f"response was not JSON ({exc})") from None
+
+    @staticmethod
+    def _classify(exc: "urllib.error.HTTPError") -> AlissaError:
+        """Map an HTTP error onto the taxonomy. The API sends JSON error
+        bodies (`{"error": CODE, "message": ...}`); the code rides along when
+        present, but classification keys on the STATUS — codes are advisory,
+        statuses are the contract."""
+        detail: object = exc.read().decode("utf-8", "replace")
+        code: "str | None" = None
+        try:
+            parsed = json.loads(detail)  # type: ignore[arg-type]
+        except (json.JSONDecodeError, TypeError):
+            parsed = None
+        if isinstance(parsed, dict):
+            detail = parsed
+            raw_code = parsed.get("error")
+            code = raw_code if isinstance(raw_code, str) else None
+
+        status = exc.code
+        if status in (401, 403):
+            return AlissaAuthError(status, detail, code)
+        if status in (408, 429) or 500 <= status <= 599:
+            return AlissaTransient(status, detail, code)
+        return AlissaError(status, detail, code)
+
+    def post_loop_events(self, events: "list[dict]") -> dict:
+        """Ingest one batch of loop events (`POST /v1/loop-events`).
+
+        The API is idempotent on `(user, dedupeKey)`, so re-posting a batch —
+        which is exactly what the emitter does after a failed pass — lands as
+        silent duplicates, never as errors or overwrites. Returns the API's
+        `{"accepted": N, "duplicates": M}` payload (empty dict when the body
+        was empty), for the caller's debug line.
+
+        An oversized batch is refused HERE, loudly: the API fails the whole
+        call at >200 events, and the emitter owns the splitting, so reaching
+        this guard is a code defect rather than an operational condition.
+        """
+        if len(events) > MAX_EVENTS_PER_POST:
+            raise ValueError(
+                f"post_loop_events takes at most {MAX_EVENTS_PER_POST} events "
+                f"per call, got {len(events)} — the emitter must split"
+            )
+        payload = self._request("/v1/loop-events", {"events": events})
+        return payload if isinstance(payload, dict) else {}

{alissa_tools_github_revloop-0.27.0 → alissa_tools_github_revloop-0.28.0}/src/main/alissa/tools/github/revloop/config.py

@@ -6,12 +6,15 @@ Settings come from three layers, later winning over earlier:
 2. a JSON config file (see `resolve_config_path`)
 3. CLI arguments
 
-`task_list_bow_id` adds a fourth above them all — the environment
-(`ALISSA_REVIEW_TASK_BOW`, see `env_task_list_bow_id`). It is the only key that
-does, and the reason is that it is the only one a second entry point needs:
-`alissa-pr-review` builds its own `Alissa` client with no config file and no
-argv of the daemon's, so an id that lives only in the file or the flags reaches
-the poll loop and silently misses that call site.
+Two keys add a fourth layer above them all — the environment. `task_list_bow_id`
+(`ALISSA_REVIEW_TASK_BOW`, see `env_task_list_bow_id`) has it because it is the
+one key a second entry point needs: `alissa-pr-review` builds its own `Alissa`
+client with no config file and no argv of the daemon's, so an id that lives only
+in the file or the flags reaches the poll loop and silently misses that call
+site. `loop_events_enabled` (`ALISSA_REV_LOOP_EVENTS_ENABLED`, see
+`env_loop_events_enabled`) has it because a container deployment toggles
+telemetry with one variable and no config-file edit (issue #112); the env wins
+over both other layers so the two env-backed keys share one precedence story.
 
 `workspace_root` is deliberately **not** a config key — it is a property of the
 running process, not of the settings. That lets one config file drive several
@@ -28,6 +31,7 @@ import re
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Mapping
+from urllib.parse import urlsplit
 
 # A POSIX-ish environment variable name -- what `reviewer_token_env` must be.
 _ENV_NAME_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
@@ -147,6 +151,8 @@ CONFIG_KEYS = (
     "review_task_miss_ttl_polls",
     "task_list_self_scope",
     "task_list_bow_id",
+    "loop_events_enabled",
+    "alissa_endpoint",
     "dry_run",
 )
 
@@ -156,6 +162,81 @@ CONFIG_KEYS = (
 TASK_LIST_BOW_ENV = "ALISSA_REVIEW_TASK_BOW"
 
 
+# The environment variable toggling loop telemetry (issue #112). Like
+# TASK_LIST_BOW_ENV it outranks both the config file and the CLI flag — see the
+# module docstring for the shared precedence story.
+LOOP_EVENTS_ENV = "ALISSA_REV_LOOP_EVENTS_ENABLED"
+
+# The default Studio API base the loop-events client posts to. Mirrors
+# alissa_client.DEFAULT_ENDPOINT (a test pins the two together); defined here
+# too so config stays importable without the client module.
+DEFAULT_ALISSA_ENDPOINT = "https://api.alissa.app"
+
+# The boolean spellings the env layer accepts, matching the container
+# renderer's contract for its other boolean (ALISSA_TASK_LIST_SELF_SCOPE):
+# anything else is REFUSED rather than read as false, because a silently-false
+# typo is indistinguishable from the default it was trying to change.
+_ENV_TRUE = frozenset({"1", "true", "yes", "on"})
+_ENV_FALSE = frozenset({"0", "false", "no", "off"})
+
+# Hosts a cleartext `alissa_endpoint` is allowed to name. The loop-events
+# client sends a bearer token with every POST, so a non-https endpoint puts
+# that token on the wire — refused at load, except toward the machine itself
+# (a local stub or port-forward, which is how the client is tested against a
+# fake ingest).
+_LOOPBACK_HOSTS = frozenset({"localhost", "127.0.0.1", "::1"})
+
+
+def _validate_alissa_endpoint(endpoint: str) -> str:
+    """`endpoint`, or a ValueError naming why it cannot carry a credential.
+
+    https is the rule; http is allowed only toward loopback. Anything else —
+    a bare host, another scheme, an unparsable value — is refused at load,
+    where the operator reads `config error`, rather than discovered as a
+    token on a cleartext hop (PR #113 round 1, minor).
+    """
+    parts = urlsplit(endpoint)
+    # A host is required on BOTH branches (PR #113 round 2, nit): a bare
+    # "https://" parses with the right scheme and no host, and would then
+    # fail on the wire as a per-pass transient WARN — the exact symptom this
+    # load-time check exists to prevent.
+    if parts.scheme == "https" and parts.hostname:
+        return endpoint
+    if parts.scheme == "http" and parts.hostname in _LOOPBACK_HOSTS:
+        return endpoint
+    raise ValueError(
+        f"alissa_endpoint must be an https:// URL with a host (or http:// "
+        f"toward loopback — localhost, 127.0.0.1, ::1 — for a local stub): "
+        f"the loop-events client sends a bearer token with every request, "
+        f"and a cleartext endpoint puts it on the wire. Got {endpoint!r}"
+    )
+
+
+def env_loop_events_enabled(
+    environ: "Mapping[str, str] | None" = None,
+) -> "bool | None":
+    """The loop-events toggle from the environment, or None when unset.
+
+    None and empty are the SAME answer — an exported-but-empty variable is how
+    a container renders "unset" (the Dockerfile bakes empty ENV defaults), and
+    it must fall through to the file/CLI layers rather than read as false. A
+    non-boolean spelling raises: the startup phase turns a ValueError into
+    `config error` + exit 2, which is where a typo belongs.
+    """
+    raw = (os.environ if environ is None else environ).get(LOOP_EVENTS_ENV)
+    value = (raw or "").strip().lower()
+    if not value:
+        return None
+    if value in _ENV_TRUE:
+        return True
+    if value in _ENV_FALSE:
+        return False
+    raise ValueError(
+        f"{LOOP_EVENTS_ENV} must be a boolean "
+        f"(1/0, true/false, yes/no, on/off), got {raw!r}"
+    )
+
+
 def env_task_list_bow_id(environ: "Mapping[str, str] | None" = None) -> "str | None":
     """The review BOW id from the environment, or None when it is not set.
 
@@ -496,6 +577,20 @@ class Config:
     # get the id wrong (a repo's `autodev:` feed BOW; a `mirrorInstanceId`).
     task_list_bow_id: str | None = None
 
+    # Whether the loop pushes its telemetry — rounds spawned, verdicts posted,
+    # cap-outs, stability holds, stalls, checks holds, grants, reaps — to
+    # Studio's `POST /v1/loop-events` once per poll pass (issue #112). OFF by
+    # default: telemetry is an outbound write to an external service, and an
+    # existing deployment must not start posting because it upgraded. Toggled
+    # by the env var LOOP_EVENTS_ENV above the file and the CLI. Best-effort
+    # when on: a failed push is one WARN and the pass completes.
+    loop_events_enabled: bool = False
+
+    # The Alissa/Studio API base the loop-events client posts to. One knob so
+    # a staging deployment can point telemetry somewhere else; everything else
+    # about the client (its bearer token) comes from the environment.
+    alissa_endpoint: str = DEFAULT_ALISSA_ENDPOINT
+
     dry_run: bool = False
 
     def __post_init__(self) -> None:
@@ -603,6 +698,26 @@ class Config:
         # takes and answers with nobody's tasks.
         bow_id = (bow_id or "").strip() or None
 
+        # The loop-events toggle's env layer, applied after the CLI overrides
+        # like the BOW id's above and for the same reason: the variable is how
+        # a container flips telemetry without editing a file on its volume.
+        env_events = env_loop_events_enabled(environ)
+        if env_events is not None:
+            raw["loop_events_enabled"] = env_events
+
+        endpoint = raw.get("alissa_endpoint", cls.alissa_endpoint)
+        if not isinstance(endpoint, str):
+            raise ValueError(
+                f"alissa_endpoint must be a URL string, got a "
+                f"{type(endpoint).__name__}"
+            )
+        # "" falls back to the default rather than building a client with an
+        # empty base — the same unset-means-default reading every optional
+        # string key here has.
+        endpoint = _validate_alissa_endpoint(
+            endpoint.strip() or cls.alissa_endpoint
+        )
+
         mode = raw.get("on_missing_review_task", ON_MISSING_SPAWN)
         if mode not in _MISSING_MODES:
             raise ValueError(
@@ -781,6 +896,8 @@ class Config:
             review_task_miss_ttl_polls=miss_ttl,
             task_list_self_scope=bool(raw.get("task_list_self_scope", False)),
             task_list_bow_id=bow_id,
+            loop_events_enabled=bool(raw.get("loop_events_enabled", False)),
+            alissa_endpoint=endpoint,
             dry_run=bool(raw.get("dry_run", False)),
         )
 

{alissa_tools_github_revloop-0.27.0 → alissa_tools_github_revloop-0.28.0}/src/main/alissa/tools/github/revloop/loop.py

@@ -56,6 +56,7 @@ from .ghclient import (
     countable_rounds,
     verdict_marker,
 )
+from .loop_events import LoopEventsEmitter, build_emitter
 from .proc import CommandError
 from .state import State
 
@@ -1604,6 +1605,14 @@ class ReviewWatcher:
             task_list_bow_id=config.task_list_bow_id,
         )
         self.state = state or State(config.state_db)
+        # The Studio loop-telemetry push (issue #112), or None when the knob
+        # is off — the disabled default costs nothing: no client, no read, no
+        # log line. Built through the seam so tests swap in a fake client.
+        self._loop_events: LoopEventsEmitter | None = (
+            build_emitter(self.state, endpoint=config.alissa_endpoint)
+            if config.loop_events_enabled
+            else None
+        )
         # (repo, number, comment id) of every re-entry directive already
         # refused in this process -- see _log_ignored_ack.
         self._ignored_acks: set[tuple[str, int, int]] = set()
@@ -2896,7 +2905,9 @@ class ReviewWatcher:
             else f" — CI gate: the rollup at {judged[:8]} is {gate.state}, so the "
             f"{verdict} envelope did not post as an APPROVE"
         )
-        self.state.record_verdict_post(pr.full_name, pr.number, round_, url)
+        self.state.record_verdict_post(
+            pr.full_name, pr.number, round_, url, verdict=verdict
+        )
         log.info(
             "%s round %d closed: native %s review submitted as %s (%s)%s",
             pr.slug, round_, event, self.github.login, url or "no url", gate_note,
@@ -4810,8 +4821,34 @@ class ReviewWatcher:
         self._write_snapshot(
             results, reaped, duration_ms=int((time.monotonic() - started) * 1000)
         )
+        self._emit_loop_events()
         return results
 
+    def _emit_loop_events(self) -> None:
+        """Push this pass's loop telemetry to Studio, when enabled (issue
+        #112). Last thing in the pass, after the snapshot, so the batch sees
+        every ledger row the pass wrote.
+
+        Skipped in dry-run even when enabled: the ledger holds no new rows
+        from a dry-run pass, and while re-emitting old ones would be harmless
+        (idempotent keys), an outbound POST is still an act — and dry-run's
+        contract is decide-and-log only.
+
+        The emitter itself never raises for an API condition (one WARN, the
+        pass completes); the guard here is the same never-fatal promise held
+        against a code defect, so telemetry can never take down a poll.
+        """
+        if self._loop_events is None or self.config.dry_run:
+            return
+        try:
+            self._loop_events.emit_once()
+        except Exception as exc:
+            log.warning(
+                "loop-events: emitter failed unexpectedly (%s: %s) — "
+                "telemetry is best-effort, the pass completes",
+                type(exc).__name__, exc,
+            )
+
     def _note_ledger_unwritable(self) -> None:
         """Report a pass refused because the ledger cannot record it.
 

alissa_tools_github_revloop-0.28.0/src/main/alissa/tools/github/revloop/loop_events.py

@@ -0,0 +1,518 @@
+"""Loop telemetry: derive Studio loop events from the ledger, once per pass.
+
+The per-round record this daemon keeps — `verdict_posts` (first seen, attempts,
+posted/abandoned, checks-held state, review URL), `spawns`, `escalations`,
+`pings`, `grants`, `stability_notices`, `spawn_checks_holds`, `reaps` — lives
+only in `.revloop/state.db` on the deployment's volume. The Factory console
+needs rounds-to-approve, verdict mix, cap-outs and stability holds over time,
+and Studio now ingests exactly that (`POST /v1/loop-events`, issue #112). This
+module is the writer: at the end of each poll pass it derives events from the
+ledger and posts ONE batch (split at 200, the ingest cap).
+
+Design rules, all load-bearing:
+
+* **The ledger is the source, not the pass.** Events carry the LEDGER's
+  timestamps (`at` = the row's stamp, in epoch ms) and dedupe keys built from
+  the LEDGER's own keys, so however many times a row is read, it derives the
+  same event. That is what lets everything else be simple.
+
+* **Best-effort, never fatal.** A failed post is one WARN and the pass
+  completes; there is no retry queue, because there does not need to be one —
+  the watermark below does not advance on failure, so the next pass re-derives
+  and re-sends, and the deterministic keys make the re-emission land as silent
+  duplicates server-side (idempotent on `(user, dedupeKey)`).
+
+* **The watermark is in-memory and starts at zero.** Each successful emission
+  advances it to the newest ledger stamp sent. The boundary is INCLUSIVE (two
+  rows can share a second, and a strict `>` advanced to the first one's stamp
+  would lose the second forever); the standing re-post that inclusion would
+  otherwise cause is closed by remembering the dedupe keys already sent at the
+  watermark second and dropping them from the next derivation — so a quiet
+  ledger derives an EMPTY batch and no request is made. A daemon restart
+  resets both and the first pass re-sends the WHOLE ledger, batched: that is
+  the backfill, not a bug — Studio dedupes every previously-seen key and
+  keeps the history a fresh console needs. Be honest about the bound: NONE of
+  the seven tables this module reads is pruned (`poll_snapshots` is the
+  ledger's only self-bounding table, and this module does not read it), so
+  the backfill — and the per-pass re-derivation the watermark then filters —
+  is bounded only by the deployment's actual row counts. At today's volumes
+  (hundreds of rows over a deployment's life) that is a fine trade for
+  stateless simplicity; if a ledger ever outgrows it, the upgrade path is
+  pushing the `since` bound into the readers' SQL, or persisting the
+  watermark in the ledger so a restart does not backfill at all.
+
+* **Derivation is pure reads.** No GitHub call, no ledger write, no new state
+  table. A row the ledger deletes (a spawn-side CI hold whose wait ended
+  between passes) is simply not observed; a row enriched from another table
+  (`stability_notices` onto a `stability:` ping) reads whatever that table
+  says NOW, which is also what the guard itself decides from.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from .alissa_client import (
+    AlissaAuthError,
+    AlissaClient,
+    AlissaError,
+    MAX_EVENTS_PER_POST,
+)
+from .state import State
+
+log = logging.getLogger(__name__)
+
+SEAT = "revloop"
+
+# Ping-kind prefixes this module parses back out of the ledger. Kept as local
+# constants rather than imported from `loop` because loop imports THIS module
+# (the emitter is wired into the watcher), and a cycle is a worse trade than a
+# pinned duplicate: a test asserts each against loop's own constant, so a
+# renamed kind fails the suite instead of silently deriving nothing.
+STALLED_PREFIX = "stalled:"
+STABILITY_PREFIX = "stability:"
+CHECKS_UNSETTLED_PREFIX = "checks-unsettled:"
+
+
+def _ms(seconds: "int | float") -> int:
+    """A ledger stamp (epoch seconds) as the API's epoch-ms `at`."""
+    return int(seconds) * 1000
+
+
+def _event(
+    kind: str,
+    at_s: int,
+    dedupe_key: str,
+    *,
+    repo: "str | None" = None,
+    pr: "int | None" = None,
+    round_: "int | None" = None,
+    session: "str | None" = None,
+    reason: "str | None" = None,
+    data: "dict[str, Any] | None" = None,
+) -> "tuple[int, dict]":
+    """One (ledger stamp, event payload) pair, with absent fields omitted
+    rather than sent as null — the API validates shape per field."""
+    payload: dict[str, Any] = {
+        "seat": SEAT,
+        "kind": kind,
+        "at": _ms(at_s),
+        "dedupeKey": dedupe_key,
+    }
+    if repo:
+        payload["repo"] = repo
+    if pr is not None:
+        payload["prNumber"] = int(pr)
+    if round_ is not None:
+        payload["round"] = int(round_)
+    if session:
+        payload["session"] = session
+    if reason:
+        # The API caps `reason` at 2000 chars and refuses (never trims) an
+        # over-cap value, which would fail the WHOLE batch — so the trim
+        # happens here, where it costs one event's tail instead.
+        payload["reason"] = reason[:2000]
+    if data:
+        payload["data"] = data
+    return int(at_s), payload
+
+
+def _spawn_events(rows: "list[dict]") -> "list[tuple[int, dict]]":
+    out = []
+    for row in rows:
+        repo, number = row["repo"], int(row["number"])
+        head = row["head_sha"] or ""
+        data: dict[str, Any] = {"headSha": head}
+        if row.get("task_ref"):
+            data["taskRef"] = row["task_ref"]
+        out.append(_event(
+            "round.spawned",
+            int(row["spawned_at"]),
+            f"revloop:round.spawned:{repo}:{number}:{row['round']}:{head}",
+            repo=repo,
+            pr=number,
+            round_=int(row["round"]),
+            session=row["session"],
+            data=data,
+        ))
+    return out
+
+
+def _verdict_events(rows: "list[dict]") -> "list[tuple[int, dict]]":
+    """`round.verdict` for posted rows, `round.abandoned` for abandoned ones.
+
+    A row with neither `posted_at` nor `abandoned_at` is an OPEN obligation —
+    the round's native verdict has not landed — and emits nothing until it
+    closes one way or the other. `data.verdict` is omitted (never invented)
+    on rows that predate the ledger's verdict column.
+
+    COVERAGE BOUND (PR #113 round 2, major): `verdict_posts` is the
+    per-round OBLIGATION record, not the per-round record — a row exists
+    only when the reviewer session defaulted and the daemon posted the
+    native fallback verdict itself. On a fleet whose sessions post every
+    review, these two kinds are expected to be EMPTY; issue #112 maps them
+    to this table and puts the round bookkeeping a session-covering source
+    needs out of scope, so the widening is TASK-1086576582, and the README's
+    telemetry table states the bound where an operator will read it."""
+    out = []
+    for row in rows:
+        repo, number = row["repo"], int(row["number"])
+        round_, head = int(row["round"]), row["head_sha"] or ""
+        if row.get("posted_at"):
+            posted = int(row["posted_at"])
+            data: dict[str, Any] = {"headSha": head}
+            if row.get("verdict"):
+                data["verdict"] = row["verdict"]
+            if row.get("review_url"):
+                data["reviewUrl"] = row["review_url"]
+            data["attempts"] = int(row.get("attempts") or 0)
+            if row.get("checks_held_at"):
+                held = posted - int(row["checks_held_at"])
+                data["checksHeldMs"] = max(held, 0) * 1000
+            out.append(_event(
+                "round.verdict",
+                posted,
+                f"revloop:round.verdict:{repo}:{number}:{round_}:{head}",
+                repo=repo,
+                pr=number,
+                round_=round_,
+                data=data,
+            ))
+        elif row.get("abandoned_at"):
+            out.append(_event(
+                "round.abandoned",
+                int(row["abandoned_at"]),
+                f"revloop:round.abandoned:{repo}:{number}:{round_}:{head}",
+                repo=repo,
+                pr=number,
+                round_=round_,
+                reason=row.get("last_error") or None,
+                data={"headSha": head},
+            ))
+    return out
+
+
+def _capped_events(
+    rows: "list[dict]", spawns: "list[dict]"
+) -> "list[tuple[int, dict]]":
+    """`round.capped` from the escalation table (CR9 cap-outs).
+
+    The dedupe key folds the row's own `escalated_at` (PR #113 round 1,
+    major): `escalations` is keyed per head and REPLACEd in place, and a
+    re-cap-out on the SAME head is a designed path — an operator-granted
+    round consumed without an approve is a new decision, which is the whole
+    reason `loop.capout_kind` folds the granted total into its ping key. A
+    key without the stamp would make Studio swallow the re-cap-out as a
+    duplicate and under-report exactly the re-entry case. The stamp, not the
+    granted total, because the stamp is ON the row: re-deriving the same row
+    always yields the same key, while a granted total read at derive time
+    would re-key an old row during a backfill.
+
+    `escalations` carries no round of its own, so the round is read from the
+    newest spawn at or before `escalated_at` — the round in flight when THIS
+    cap-out was recorded, which stays true for a row backfilled long after
+    the PR moved on — and omitted when no spawn row qualifies."""
+    out = []
+    for row in rows:
+        repo, number = row["repo"], int(row["number"])
+        head = row["head_sha"] or ""
+        at = int(row["escalated_at"])
+        rounds = [
+            int(s["round"]) for s in spawns
+            if s["repo"] == repo and int(s["number"]) == number
+            and int(s["spawned_at"]) <= at
+        ]
+        out.append(_event(
+            "round.capped",
+            at,
+            f"revloop:round.capped:{repo}:{number}:{head}:{at}",
+            repo=repo,
+            pr=number,
+            round_=max(rounds) if rounds else None,
+            data={"headSha": head},
+        ))
+    return out
+
+
+def _ping_events(
+    rows: "list[dict]", notices: "dict[tuple[str, int], dict]"
+) -> "list[tuple[int, dict]]":
+    """`stalled`, `stability.hold` and `checks.held` out of the ping ledger.
+
+    `kind` is free-form text carrying the episode identity, so it is parsed
+    by prefix; kinds this module does not report (`activity-deferred:`,
+    `capout:`, `checks-hold:`, `verdict-post-failed:` — each the dedupe of a
+    GitHub-side comment, not a fact of its own) derive nothing.
+
+    A stability event's payload is split by provenance, deliberately
+    (PR #113 round 1, minor). `data.headSha` and `data.grantsSeen` come from
+    the ping KIND itself (`stability:<head>:<base>:<granted>`, where the
+    granted total is what the guard had accounted for when it held), so they
+    are episode-correct even for a row backfilled long after. `data.rcRounds`
+    and `round` come from the `stability_notices` join, and that table is
+    REPLACEd per episode — so those two are CURRENT-AT-DERIVATION: a
+    backfilled episode-1 ping carries the newest episode's numbers, because
+    the ledger keeps nothing episode-scoped for them. Stated here so no
+    reader mistakes the join for an episode guarantee."""
+    out = []
+    for row in rows:
+        repo, number = row["repo"], int(row["number"])
+        kind, at = str(row["kind"]), int(row["pinged_at"])
+        if kind.startswith(STALLED_PREFIX):
+            session = kind[len(STALLED_PREFIX):]
+            out.append(_event(
+                "stalled",
+                at,
+                f"revloop:stalled:{repo}:{number}:{session}",
+                repo=repo,
+                pr=number,
+                session=session,
+            ))
+        elif kind.startswith(STABILITY_PREFIX):
+            tail = kind[len(STABILITY_PREFIX):]
+            data: dict[str, Any] = {}
+            parts = tail.split(":")
+            head = parts[0]
+            if head:
+                data["headSha"] = head
+            # The kind's own granted total — episode-correct, see above.
+            if len(parts) == 3 and parts[2].isdigit():
+                data["grantsSeen"] = int(parts[2])
+            notice = notices.get((repo, number))
+            if notice is not None:
+                data["rcRounds"] = int(notice["rc_rounds"])
+            out.append(_event(
+                "stability.hold",
+                at,
+                f"revloop:stability.hold:{repo}:{number}:{tail}",
+                repo=repo,
+                pr=number,
+                round_=(int(notice["round"]) if notice is not None else None),
+                data=data or None,
+            ))
+        elif kind.startswith(CHECKS_UNSETTLED_PREFIX):
+            tail = kind[len(CHECKS_UNSETTLED_PREFIX):]
+            round_str, _, head = tail.partition(":")
+            round_ = int(round_str) if round_str.isdigit() else None
+            out.append(_event(
+                "checks.held",
+                at,
+                f"revloop:checks.held:{repo}:{number}:{round_str}:{head}",
+                repo=repo,
+                pr=number,
+                round_=round_,
+                data={"headSha": head, "gate": "verdict"},
+            ))
+    return out
+
+
+def _spawn_hold_events(rows: "list[dict]") -> "list[tuple[int, dict]]":
+    """`checks.held` from the pre-spawn CI gate's in-flight holds.
+
+    Same kind as the verdict-side hold above — both mean "this round is
+    waiting on this head's checks" — but a distinct dedupe key (`:spawn`
+    suffix) and `data.gate`, because the two waits are different facts about
+    the same round and one must not swallow the other's event."""
+    out = []
+    for row in rows:
+        repo, number = row["repo"], int(row["number"])
+        round_, head = int(row["round"]), row["head_sha"] or ""
+        out.append(_event(
+            "checks.held",
+            int(row["first_at"]),
+            f"revloop:checks.held:{repo}:{number}:{round_}:{head}:spawn",
+            repo=repo,
+            pr=number,
+            round_=round_,
+            data={"headSha": head, "gate": "spawn"},
+        ))
+    return out
+
+
+def _grant_events(rows: "list[dict]") -> "list[tuple[int, dict]]":
+    return [
+        _event(
+            "grant",
+            int(row["granted_at"]),
+            f"revloop:grant:{row['repo']}:{row['number']}:{row['comment_id']}",
+            repo=row["repo"],
+            pr=int(row["number"]),
+            data={"author": row["author"], "rounds": int(row["rounds"])},
+        )
+        for row in rows
+    ]
+
+
+def _reap_events(rows: "list[dict]") -> "list[tuple[int, dict]]":
+    # `reaped_at` folds into the key (PR #113 round 1, nit): `reaps` is
+    # REPLACEd per session name, and while names are nonce-unique per spawn
+    # today, the key should not depend on that holding forever — a re-reaped
+    # name is a new decision, and the stamp is on the row, so re-derivation
+    # stays deterministic.
+    return [
+        _event(
+            "reap",
+            int(row["reaped_at"]),
+            f"revloop:reap:{row['session']}:{int(row['reaped_at'])}",
+            session=row["session"],
+        )
+        for row in rows
+    ]
+
+
+def derive_events(state: State, *, since: int = 0) -> "list[dict]":
+    """Every loop event the ledger implies whose stamp is >= `since`,
+    oldest first.
+
+    Inclusive on the boundary on purpose: two rows can share a second, and a
+    strictly-greater filter advanced to the first one's stamp would lose the
+    second forever, while inclusion merely re-sends a key the API dedupes.
+    """
+    spawns = state.read_spawns()
+    notices = {
+        (row["repo"], int(row["number"])): row
+        for row in state.read_stability_notices()
+    }
+
+    stamped: "list[tuple[int, dict]]" = []
+    stamped += _spawn_events(spawns)
+    stamped += _verdict_events(state.read_verdict_posts())
+    stamped += _capped_events(state.read_escalations(), spawns)
+    stamped += _ping_events(state.read_pings(), notices)
+    stamped += _spawn_hold_events(state.read_spawn_checks_holds())
+    stamped += _grant_events(state.read_grants())
+    stamped += _reap_events(state.read_reaps())
+
+    stamped = [(at, event) for at, event in stamped if at >= since]
+    stamped.sort(key=lambda pair: pair[0])
+    return [event for _, event in stamped]
+
+
+class LoopEventsEmitter:
+    """The once-per-pass push, watermarked and best-effort.
+
+    Owned by the watcher when `loop_events_enabled` is on; `emit_once` is
+    called at the end of every poll pass and NEVER raises for an API or
+    transport condition — one WARN, the pass completes, and the un-advanced
+    watermark is the whole retry story (see the module docstring).
+    """
+
+    def __init__(self, state: State, client: AlissaClient):
+        self._state = state
+        self._client = client
+        # Epoch seconds of the newest ledger stamp successfully emitted.
+        # Zero until the first success, so a fresh process backfills.
+        self._since = 0
+        # The dedupe keys already sent at exactly the watermark second. The
+        # `since` filter is inclusive so a second row written in the boundary
+        # second can never be lost — this set is what stops the OTHER edge of
+        # that choice, the boundary row being re-posted every pass forever on
+        # a ledger that has stopped changing (PR #113 round 1, minor).
+        self._sent_at_watermark: "set[str]" = set()
+        # Latched True by a permanent auth failure — see emit_once. A
+        # process-lifetime latch on purpose: a restart is both how a fixed
+        # token takes effect and how the operator re-arms the emitter.
+        self._auth_failed = False
+
+    def emit_once(self) -> bool:
+        """Derive and post this pass's batch. True when everything landed
+        (an empty derivation is vacuous success).
+
+        An `AlissaAuthError` LATCHES the emitter off for the life of the
+        process (PR #113 round 1, minor): the taxonomy calls it permanent and
+        operator-fixable — a missing `ALISSA_API_TOKEN`, a token the ingest
+        403s — so re-trying it would re-derive the whole ledger and write an
+        identical WARN every poll interval for as long as the daemon runs.
+        One WARN names the fix; later passes return at a DEBUG line, and the
+        restart that installs a corrected credential also re-arms this.
+        Transient errors keep the re-send behaviour — the watermark stays
+        put and the next pass retries.
+        """
+        if self._auth_failed:
+            log.debug(
+                "loop-events: disabled since an authentication failure — "
+                "restart the daemon after fixing the credential",
+            )
+            return False
+        try:
+            events = derive_events(self._state, since=self._since)
+        except Exception as exc:
+            # A derivation failure is a ledger read gone wrong — the same
+            # best-effort telemetry classification the snapshot writer has:
+            # warn and let the pass complete, never kill the poll over it.
+            log.warning(
+                "loop-events: derivation failed (%s: %s) — skipping this "
+                "pass's telemetry; the loop keeps polling",
+                type(exc).__name__, exc,
+            )
+            return False
+        events = [
+            e for e in events
+            if not (
+                int(e["at"]) // 1000 == self._since
+                and e["dedupeKey"] in self._sent_at_watermark
+            )
+        ]
+        if not events:
+            return True
+        sent = 0
+        try:
+            for start in range(0, len(events), MAX_EVENTS_PER_POST):
+                chunk = events[start:start + MAX_EVENTS_PER_POST]
+                result = self._client.post_loop_events(chunk)
+                sent += len(chunk)
+                log.debug(
+                    "loop-events: posted %d event(s) (accepted=%s, "
+                    "duplicates=%s)",
+                    len(chunk), result.get("accepted"),
+                    result.get("duplicates"),
+                )
+        except AlissaAuthError as exc:
+            self._auth_failed = True
+            log.warning(
+                "loop-events: authentication failed (%s) — this is permanent "
+                "and operator-fixable (set/rotate the token the emitter's "
+                "client reads, then restart the daemon); loop telemetry is "
+                "now off for this process, the loop keeps polling",
+                exc,
+            )
+            return False
+        except AlissaError as exc:
+            # ONE warn per failed pass, naming how far it got; the watermark
+            # stays put so the next pass re-derives and re-sends, and the
+            # deterministic keys make the overlap land as duplicates.
+            log.warning(
+                "loop-events: post failed after %d of %d event(s) (%s) — "
+                "telemetry is best-effort, the pass completes; the next "
+                "pass re-sends (idempotent keys)",
+                sent, len(events), exc,
+            )
+            return False
+        newest = max(int(event["at"]) // 1000 for event in events)
+        boundary_keys = {
+            e["dedupeKey"] for e in events if int(e["at"]) // 1000 == newest
+        }
+        if newest == self._since:
+            # The watermark did not move (a same-second newcomer): the set
+            # GROWS, because the earlier boundary sends are still boundary.
+            self._sent_at_watermark |= boundary_keys
+        else:
+            self._since = newest
+            self._sent_at_watermark = boundary_keys
+        log.info("loop-events: %d event(s) pushed", len(events))
+        return True
+
+
+def build_emitter(
+    state: State, *, endpoint: "str | None" = None
+) -> LoopEventsEmitter:
+    """The emitter the watcher wires in when `loop_events_enabled` is on.
+
+    A seam, so tests build emitters over fake clients while the watcher's
+    call stays one line. The token comes from the environment inside
+    `AlissaClient` (the CLI's own `ALISSA_API_TOKEN`); its absence surfaces
+    as the emitter's WARN, never at construction — a daemon must boot and
+    poll whether or not telemetry can authenticate.
+    """
+    return LoopEventsEmitter(state, AlissaClient(base=endpoint))

{alissa_tools_github_revloop-0.27.0 → alissa_tools_github_revloop-0.28.0}/src/main/alissa/tools/github/revloop/state.py

@@ -144,6 +144,13 @@ CREATE TABLE IF NOT EXISTS verdict_posts (
     -- waited one bound when it waited two. NULL until (and unless) the promotion
     -- happens; the bound then reads `checks_pending_at or checks_held_at`.
     checks_pending_at INTEGER,
+    -- WHAT the round's verdict was ('approve' | 'request_changes'), stamped
+    -- when the post lands (issue #112). The ledger did not need it -- GitHub's
+    -- reviews list answers "what was decided" -- but the loop-events emitter
+    -- derives `round.verdict` from THIS table at end of pass, long after the
+    -- envelope read that knew the answer. NULL on rows that predate the
+    -- column; the emitter omits the field rather than inventing one.
+    verdict       TEXT,
     review_url    TEXT,
     last_error    TEXT,
     PRIMARY KEY (repo, number, round)
@@ -308,6 +315,7 @@ _ADDED_COLUMNS = {
         ("checks_held_at", "INTEGER"),
         ("checks_held_state", "TEXT"),
         ("checks_pending_at", "INTEGER"),
+        ("verdict", "TEXT"),
     ),
 }
 
@@ -779,21 +787,79 @@ class State:
             (repo, number),
         ).fetchone()
 
-    def read_grants(self, repo: str, number: int) -> list[dict]:
-        """One PR's grant rows, newest first (like every reader here).
-
-        Deliberately narrow: no unfiltered form and no `limit` until something
-        needs them. The console does not read this table yet -- showing "this
-        PR was re-entered by @x" in the operator inbox wants rendering as well
-        as data, so it lands as its own change rather than as unused
-        parameters here.
+    def read_grants(
+        self, repo: "str | None" = None, number: "int | None" = None
+    ) -> list[dict]:
+        """Grant rows, newest first (like every reader here) — one PR's when
+        `repo`/`number` are given, every PR's when they are not.
+
+        The unfiltered form exists for the loop-events emitter (issue #112),
+        which derives one `grant` event per honoured ack: grants are the
+        rarest rows in this ledger (one per operator comment, ever), so the
+        full read is bounded by how often a human types the ack grammar. The
+        per-PR form keeps its original callers unchanged.
+
+        A PARTIAL filter is refused (PR #113 round 2, nit): `repo` without
+        `number` would otherwise fall through to the unfiltered read and
+        answer with every PR's grants — a superset, not an error, which is
+        the quiet kind of wrong. The paired and unfiltered forms are the
+        only two forms.
         """
-        return self._read_rows(
+        if (repo is None) != (number is None):
+            raise ValueError(
+                "read_grants takes repo AND number (one PR) or neither "
+                "(every PR) — a partial filter would silently read every PR"
+            )
+        sql = (
             "SELECT repo, number, comment_id, author, rounds, granted_at "
-            "FROM grants WHERE repo=? AND number=? "
-            "ORDER BY granted_at DESC, rowid DESC",
+            "FROM grants"
+        )
+        params: tuple = ()
+        if repo is not None and number is not None:
+            sql += " WHERE repo=? AND number=?"
+            params = (repo, number)
+        sql += " ORDER BY granted_at DESC, rowid DESC"
+        return self._read_rows(sql, None, params)
+
+    # -- loop-events readers (issue #112) ----------------------------------
+    #
+    # Full-table reads for the telemetry emitter, which derives events from
+    # the ledger at end of pass and filters by timestamp itself. Each is a
+    # plain projection, newest first like every reader here; none takes a
+    # `limit`, because the emitter's bound is its own watermark and a SQL
+    # truncation would silently drop exactly the oldest rows a fresh daemon's
+    # backfill exists to send.
+
+    def read_reaps(self) -> list[dict]:
+        """Reap rows (one per session the sweep killed), newest first."""
+        return self._read_rows(
+            "SELECT session, reaped_at FROM reaps "
+            "ORDER BY reaped_at DESC, rowid DESC",
+            None,
+        )
+
+    def read_stability_notices(self) -> list[dict]:
+        """Stability-notice rows (one per PR, the guard's memory), newest
+        first. The emitter joins these onto `stability:` pings for the
+        rcRounds/grantsSeen payload; the row is REPLACEd per episode, so the
+        join reads the newest episode's numbers — which is also what the
+        guard itself decides from."""
+        return self._read_rows(
+            "SELECT repo, number, round, rc_rounds, grants_seen, noticed_at "
+            "FROM stability_notices ORDER BY noticed_at DESC, number DESC",
+            None,
+        )
+
+    def read_spawn_checks_holds(self) -> list[dict]:
+        """Pre-spawn CI holds currently in the ledger, newest first. Rows are
+        deleted when their wait ends (see `clear_spawn_checks_hold`), so this
+        is the waits in flight plus the residue of rounds that never started
+        — the emitter reports a hold while it exists, and a hold that begins
+        and ends between two passes is simply not observed (best-effort)."""
+        return self._read_rows(
+            "SELECT repo, number, round, head_sha, first_at "
+            "FROM spawn_checks_holds ORDER BY first_at DESC, number DESC",
             None,
-            (repo, number),
         )
 
     # -- native verdict posts ----------------------------------------------
@@ -1034,16 +1100,24 @@ class State:
         return int(row["n"]) if row else 0
 
     def record_verdict_post(
-        self, repo: str, number: int, round_: int, review_url: str
+        self, repo: str, number: int, round_: int, review_url: str,
+        verdict: "str | None" = None,
     ) -> None:
         """Mark the round's native verdict as landed. Bookkeeping and evidence
         only: GitHub's reviews list stays the authority on whether a native
         verdict exists, so a row lost behind the daemon's back costs one
-        duplicate post, never a round that silently counts as closed."""
+        duplicate post, never a round that silently counts as closed.
+
+        `verdict` is the round's parsed envelope verdict ('approve' or
+        'request_changes'), remembered for the loop-events emitter (issue
+        #112), which reports rounds long after the envelope read that knew the
+        answer. Optional so existing callers and tests keep their shape; None
+        leaves the column NULL and the emitter omits the field."""
         self._db.execute(
-            "UPDATE verdict_posts SET posted_at = ?, review_url = ?, last_error = NULL "
+            "UPDATE verdict_posts SET posted_at = ?, review_url = ?, "
+            "verdict = ?, last_error = NULL "
             "WHERE repo=? AND number=? AND round=?",
-            (int(time.time()), review_url, repo, number, round_),
+            (int(time.time()), review_url, verdict, repo, number, round_),
         )
         self._db.commit()
 
@@ -1052,7 +1126,8 @@ class State:
         return self._read_rows(
             "SELECT repo, number, round, first_seen_at, head_sha, attempts, "
             "last_attempt_at, posted_at, abandoned_at, checks_held_at, "
-            "checks_held_state, checks_pending_at, review_url, last_error "
+            "checks_held_state, checks_pending_at, verdict, review_url, "
+            "last_error "
             "FROM verdict_posts "
             "ORDER BY first_seen_at DESC, number DESC",
             limit,

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

@@ -0,0 +1 @@
+0.28.0

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

{alissa_tools_github_revloop-0.27.0 → alissa_tools_github_revloop-0.28.0}/src/main/alissa_tools_github_revloop.egg-info/SOURCES.txt

@@ -7,9 +7,11 @@ setup.py
 src/main/alissa/tools/github/revloop/__init__.py
 src/main/alissa/tools/github/revloop/__main__.py
 src/main/alissa/tools/github/revloop/alissa.py
+src/main/alissa/tools/github/revloop/alissa_client.py
 src/main/alissa/tools/github/revloop/config.py
 src/main/alissa/tools/github/revloop/ghclient.py
 src/main/alissa/tools/github/revloop/loop.py
+src/main/alissa/tools/github/revloop/loop_events.py
 src/main/alissa/tools/github/revloop/proc.py
 src/main/alissa/tools/github/revloop/prreview.py
 src/main/alissa/tools/github/revloop/state.py

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

@@ -1 +0,0 @@
-0.27.0