ctrlrelay 0.16.1__tar.gz → 0.16.3__tar.gz

{ctrlrelay-0.16.1 → ctrlrelay-0.16.3}/CHANGELOG.md

@@ -7,6 +7,46 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.16.3] - 2026-11-01
+
+A security fix: **upgrade every machine.** No config edit is required.
+
+### Fixed
+
+- Only issues the operator assigned to themselves are taken, as intended.
+  The check read `actor` on GitHub's `assigned` events, which is the account
+  assigned (the operator), not the one who assigned it (`assigner`), so an
+  issue anyone else assigned to the operator was taken too. It now reads
+  `assigner`, refuses an event without one, refuses an unnamed assignment
+  after the operator's last one, and reads every page of an issue's events.
+  The status page's "assigned by someone else" uses the same check (#275,
+  closes #274)
+
+## [0.16.2] - 2026-11-01
+
+Status page changes only. **No config edit is required.**
+
+### Added
+
+- The Today counters (dispatched, PRs opened, merged, failed, blocked,
+  messages sent) are buttons: each opens today's events of that kind under
+  the counters. A failed run shows why (exit code, the run's summary and its
+  stored output), a blocked one the question, PRs link to the PR. New
+  `/api/events?kind=<kind>&day=today` (#271, closes #257)
+
+### Changed
+
+- A GitHub API bucket whose reset time has passed since the last read shows
+  as "refilled at <time>, not read since" instead of "unknown"; search,
+  which refills every minute, usually shows that way (#272)
+- More space under the header and between the Machines strip and "Who has
+  what" (#271)
+
+### Fixed
+
+- The live feed now scrubs credential shapes from event details: a
+  question an agent asked could show a token on the page (#271)
+
 ## [0.16.1] - 2026-11-01
 
 Fixes the chat bridge, which did not start on 0.16.0. **No config edit is
@@ -1976,7 +2016,9 @@ pipeline).
   per-phase implementation plans (Phase 0 through Phase 4).
 - `docs/Claude_Code_Project_Guide.md` — project development guide.
 
-[Unreleased]: https://github.com/AInvirion/ctrlrelay/compare/v0.16.1...HEAD
+[Unreleased]: https://github.com/AInvirion/ctrlrelay/compare/v0.16.3...HEAD
+[0.16.3]: https://github.com/AInvirion/ctrlrelay/compare/v0.16.2...v0.16.3
+[0.16.2]: https://github.com/AInvirion/ctrlrelay/compare/v0.16.1...v0.16.2
 [0.16.1]: https://github.com/AInvirion/ctrlrelay/compare/v0.16.0...v0.16.1
 [0.16.0]: https://github.com/AInvirion/ctrlrelay/compare/v0.15.0...v0.16.0
 [0.15.0]: https://github.com/AInvirion/ctrlrelay/compare/v0.14.0...v0.15.0

{ctrlrelay-0.16.1 → ctrlrelay-0.16.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ctrlrelay
-Version: 0.16.1
+Version: 0.16.3
 Summary: Local-first orchestrator for headless coding agents across multiple GitHub repos
 Project-URL: Homepage, https://github.com/AInvirion/ctrlrelay
 Project-URL: Documentation, https://ainvirion.github.io/ctrlrelay/

{ctrlrelay-0.16.1 → ctrlrelay-0.16.3}/docs/operations.md

@@ -264,6 +264,7 @@ loopback or on the home network.
 | `/` | The page. Refreshes itself every `web.refresh_seconds`. |
 | `/api/status` | Everything on the page, as JSON (the contract is in `src/ctrlrelay/web/status.py`). A section that could not be read is `null` and `errors` says why; `[]` means "read, and empty". The feed holds at most the newest `feed_limit` (200) events: `feed_total` is how many the history window holds (`null` if unreadable) and `feed_truncated` is `true` when some were left out, in which case the page says "showing newest N of M". |
 | `/api/events?since=<epoch seconds>` | The feed, newest first, at most `limit` (200) events. Without `since`, the last `web.history_days` days. Carries the same `feed_total` and `feed_truncated`, plus the `limit` used. |
+| `/api/events?kind=<kind>&day=today` | One Today counter's events, for the server's local day, newest first, at most 200: `{kind, events, total, truncated, error}`. `kind` is `dispatched`, `pr_opened`, `merged`, `failed`, `blocked` or `message_sent`. A `failed` or `blocked` event also carries `reason`: `exit_code`, the run's `summary` (up to 500 characters) and `output_tail` (up to 2,000), both scrubbed of credential shapes again before they are sent, the `question` asked, and `session: "not found"` when the run's row is gone. `events` is `null` with `error` set when they could not be read. A query with `kind` and anything other than exactly `kind` and `day=today` is refused with 400, except that one with `since` is the feed, as before. A summary or question longer than 500 characters ends in "…". On the page, clicking a Today counter shows this list under it, read again with every refresh. |
 
 The page header shows how long ago it last heard from the server ("updated
 12s ago", ticking every second) and a dot that is green while the last good
@@ -290,7 +291,10 @@ machine last read it: `read_at`, and for `core`, `search` and `graphql` each
 `{remaining, limit, resets_at, state}` with `state` one of `ok`, `low`, `out`,
 or `unknown` once its reset time has passed (the numbers are then old), or
 `"unknown"` in place of the object for a bucket it could not read; the whole value is `"unknown"`
-before any reading. The page shows it in the **Usage** box. Low and used-up
+before any reading. The page shows it in the **Usage** box; a bucket whose
+reset time has passed since the last read shows as "refilled at <time>, not
+read since" (GitHub refills it at that time), and `search`, which refills
+every minute, usually shows that way. Low and used-up
 buckets are described in [configuration: github_api]({{ '/configuration/' | relative_url }}#github_api).
 Which bucket a `gh` command spends is worked out from the command where the
 command says: `gh api` REST paths are `core`, `gh api graphql` is `graphql`,

{ctrlrelay-0.16.1 → ctrlrelay-0.16.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ctrlrelay"
-version = "0.16.1"
+version = "0.16.3"
 description = "Local-first orchestrator for headless coding agents across multiple GitHub repos"
 readme = "README.md"
 requires-python = ">=3.12"

{ctrlrelay-0.16.1 → ctrlrelay-0.16.3}/src/ctrlrelay/core/github.py

@@ -424,17 +424,21 @@ class GitHubCLI:
     ) -> list[dict[str, Any]]:
         """List ``assigned`` events for an issue in chronological order.
 
-        Returns the GitHub issue-events payload filtered to ``event == "assigned"``.
-        Each entry includes ``actor`` (who performed the assignment) and
-        ``assignee`` (who was assigned). Used by the poller to verify that the
-        most recent self-assignment was actually performed by the operator.
+        Returns the GitHub issue-events payload filtered to ``event == "assigned"``,
+        every page of it. Each entry includes ``assigner`` (who performed the
+        assignment) and ``assignee`` (who was assigned); its ``actor`` is the
+        assignee too, not who made it (#274). Used by the poller to verify
+        that the most recent self-assignment was actually performed by the
+        operator.
         """
+        # Every page: on an issue with more than one page of events the
+        # latest assignment would otherwise be missed.
         output = await self._run_gh(
-            "api",
+            "api", "--paginate",
             f"/repos/{repo}/issues/{issue_number}/events",
-            "--jq", '[.[] | select(.event=="assigned")]',
+            "--jq", '.[] | select(.event=="assigned")',
         )
-        return json.loads(output) if output.strip() else []
+        return [json.loads(line) for line in output.splitlines() if line.strip()]
 
     async def get_issue(
         self,

{ctrlrelay-0.16.1 → ctrlrelay-0.16.3}/src/ctrlrelay/core/poller.py

@@ -617,6 +617,25 @@ class IssuePoller:
             return True
 
         events = await self.github.list_assignment_events(repo, issue_number)
+        # An assignment after the operator's last one that names nobody
+        # cannot be ruled out as a newer one by someone else: refuse rather
+        # than skip past it. One before it is overtaken and does not count.
+        last_mine = max(
+            (i for i, e in enumerate(events)
+             if (e.get("assignee") or {}).get("login") == self.username),
+            default=-1,
+        )
+        if any(not (e.get("assignee") or {}).get("login")
+               for e in events[last_mine + 1:]):
+            log_event(
+                _logger,
+                "poll.issue.foreign_assignment",
+                repo=repo,
+                number=issue_number,
+                assigner_login=None,
+                reason="assignment_without_assignee",
+            )
+            return False
         relevant = [
             e
             for e in events
@@ -634,8 +653,12 @@ class IssuePoller:
             return False
 
         # Events endpoint returns chronological order; the last one wins.
+        # Who made the assignment is ``assigner``. On an ``assigned`` event
+        # ``actor`` is the account assigned, which is always the operator
+        # here, so reading it let anyone's assignment through (#274). No
+        # ``assigner`` is treated as foreign.
         latest = relevant[-1]
-        assigner_login = (latest.get("actor") or {}).get("login")
+        assigner_login = (latest.get("assigner") or {}).get("login")
         if assigner_login == self.username:
             return True
 

{ctrlrelay-0.16.1 → ctrlrelay-0.16.3}/src/ctrlrelay/web/server.py

@@ -45,7 +45,7 @@ from ctrlrelay.core.obs import get_logger, log_event
 from ctrlrelay.core.usage import UsageStore, pause_for, usage_json
 from ctrlrelay.web.fleet import PeerReader
 from ctrlrelay.web.health import read_server_health
-from ctrlrelay.web.status import build_status, list_feed
+from ctrlrelay.web.status import DAY_KINDS, build_status, list_day_events, list_feed
 
 _logger = get_logger("web.server")
 
@@ -206,6 +206,23 @@ class _Handler(BaseHTTPRequestHandler):
             self._json(200, srv.status())
         elif url.path == "/api/events":
             query = urllib.parse.parse_qs(url.query, keep_blank_values=True)
+            if "kind" in query and "since" not in query:
+                # One Today counter's events (#257). A query with ``since``
+                # is the feed, as it was before ``kind`` existed.
+                kinds, days = query.get("kind"), query.get("day")
+                if (
+                    len(kinds) != 1 or kinds[0] not in DAY_KINDS
+                    or days != ["today"] or set(query) != {"kind", "day"}
+                ):
+                    self._json(400, {
+                        "error": "kind must be one of " + ", ".join(sorted(DAY_KINDS))
+                        + ", with day=today and nothing else",
+                    })
+                    return
+                self._json(200, list_day_events(
+                    db_path=srv.config.paths.state_db, kind=kinds[0],
+                ))
+                return
             values = query.get("since")
             if values is None:
                 since = srv.default_since()

{ctrlrelay-0.16.1 → ctrlrelay-0.16.3}/src/ctrlrelay/web/static/index.html

@@ -90,6 +90,17 @@ ul.plain > li { padding: 7px 0; border-bottom: 1px solid var(--line); }
 ul.plain > li:last-child { border-bottom: 0; }
 .today { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 8px; }
 .today .n { font-size: 22px; font-weight: 700; }
+.today button.card {
+  font: inherit; color: inherit; text-align: left; cursor: pointer; width: 100%;
+}
+.today button.card:hover { border-color: var(--accent); }
+.today button.card[aria-pressed="true"] { border-color: var(--accent); box-shadow: 0 0 0 1px var(--accent); }
+#today-list { margin-top: 10px; }
+#today-list .reason { font-size: 13px; color: var(--muted); margin: 2px 0 0; }
+#today-list pre {
+  white-space: pre-wrap; word-break: break-word; font-size: 12px; margin: 6px 0 0;
+  max-height: 260px; overflow: auto; background: var(--tag); padding: 8px; border-radius: 6px;
+}
 .feed .when { color: var(--muted); font-size: 12px; font-variant-numeric: tabular-nums; min-width: 4.5em; }
 .feed .detail { color: var(--muted); font-size: 13px; overflow-wrap: anywhere; }
 a { color: var(--accent); text-decoration: none; }
@@ -108,8 +119,8 @@ a:hover, a:focus-visible { text-decoration: underline; }
 .usage .bar { height: 6px; background: var(--line, #ddd); border-radius: 3px; margin: 2px 0 6px; }
 .usage .bar > span { display: block; height: 100%; border-radius: 3px; background: currentColor; }
 .usage .bar.high { color: var(--bad); }
-.fleet { margin: 0 20px 12px; }
-.strip { display: flex; flex-wrap: wrap; gap: 10px; }
+.fleet { margin: 18px 20px 4px; }
+.strip { display: flex; flex-wrap: wrap; gap: 10px; margin-bottom: 18px; }
 .strip .machine { border: 1px solid var(--line); border-radius: 8px; padding: 8px 12px;
   min-width: 190px; background: var(--panel); font-size: 13px; }
 .strip .machine.bad { border-color: var(--bad); }
@@ -164,6 +175,7 @@ details > summary .count { font-weight: 400; margin-left: 6px; }
     <section>
       <h2>Today</h2>
       <div id="today"><p class="unknown">loading…</p></div>
+      <div id="today-list" aria-live="polite"></div>
     </section>
   </div>
   <div>
@@ -782,18 +794,32 @@ function renderGitHubBudget(api, now, lines) {
   }
   ["core", "search", "graphql"].forEach(function (name) {
     var b = api[name];
-    if (!b || typeof b !== "object" || typeof b.remaining !== "number" ||
-        b.state === "unknown") {
-      lines.push(el("div", "line", "GitHub " + name + " unknown"));
-      return;
-    }
-    var high = b.state === "low" || b.state === "out";
-    lines.push(el("div", "line" + (high ? " high" : ""),
-      "GitHub " + name + " " + b.remaining + " of " + b.limit + " left" +
-      (b.state === "out" ? " (used up)" : "") + ", " + untilText(b.resets_at, now)));
+    var high = b && !refilled(b, now) && (b.state === "low" || b.state === "out");
+    lines.push(el("div", "line" + (high ? " high" : ""), budgetLine(name, b, now)));
   });
 }
 
+// One bucket's line. A reading whose reset time has passed is old: GitHub
+// has refilled that bucket since, so say that rather than "unknown" (search
+// refills every minute and is read every few, so it is usually in this state).
+function refilled(b, now) {
+  var reset = b && typeof b === "object" ? Date.parse(b.resets_at) : NaN;
+  return !isNaN(reset) && reset / 1000 <= now;
+}
+
+function budgetLine(name, b, now) {
+  if (!b || typeof b !== "object" || typeof b.remaining !== "number") {
+    return "GitHub " + name + " unknown";
+  }
+  if (refilled(b, now)) {
+    return "GitHub " + name + " refilled at " + clock(Date.parse(b.resets_at) / 1000) +
+      ", not read since";
+  }
+  if (b.state === "unknown") { return "GitHub " + name + " unknown"; }
+  return "GitHub " + name + " " + b.remaining + " of " + b.limit + " left" +
+    (b.state === "out" ? " (used up)" : "") + ", " + untilText(b.resets_at, now);
+}
+
 function renderUsage(data, now) {
   var target = document.getElementById("usage");
   var n = data.node;
@@ -835,21 +861,121 @@ function renderUsage(data, now) {
   put(target, lines);
 }
 
+// The event kind each Today counter counts (#257); the counter's own key
+// differs only for messages.
+var TODAY_KIND = { messages_sent: "message_sent" };
+var todayOpen = null;
+// Each list request is numbered; only the newest one may draw, so a slow
+// answer for an earlier refresh or another counter never replaces a newer one.
+var todaySeq = 0;
+// The kind whose list request is still out. A refresh does not start
+// another for it (on a slow server every answer would be overtaken and the
+// list would stay at "loading…"); a click always does.
+var todayBusy = null;
+// A refresh skipped while a request was out: read again when it lands, so
+// the list does not lag the count by more than one answer.
+var todayStale = false;
+
 function renderToday(data) {
   var target = document.getElementById("today");
   var t = data.today || {};
   var grid = el("div", "today");
   TODAY.forEach(function (pair) {
     var v = t[pair[0]];
-    var cell = el("div", "card");
+    var kind = TODAY_KIND[pair[0]] || pair[0];
+    var cell = el("button", "card");
+    cell.type = "button";
+    cell.setAttribute("aria-pressed", todayOpen === kind ? "true" : "false");
+    cell.title = "Show today's " + pair[1];
     if (typeof v === "number") { cell.appendChild(el("div", "n", v)); }
     else { cell.appendChild(el("div", "n unknown", "unknown")); }
     cell.appendChild(el("div", "muted", pair[1]));
+    cell.addEventListener("click", function () {
+      todayOpen = todayOpen === kind ? null : kind;
+      renderToday(lastData || data);
+      if (todayOpen) { put(document.getElementById("today-list"), [empty("loading…")]); }
+      loadTodayList(true);
+    });
     grid.appendChild(cell);
   });
   put(target, [grid]);
 }
 
+// The list behind the open counter, read again with every refresh so it
+// follows the count.
+function loadTodayList(force) {
+  var target = document.getElementById("today-list");
+  var kind = todayOpen;
+  if (!kind) { todaySeq++; todayBusy = null; put(target, []); return; }
+  if (!force && todayBusy === kind) { todayStale = true; return; }
+  var seq = ++todaySeq;
+  todayBusy = kind;
+  todayStale = false;
+  fetch("/api/events?kind=" + encodeURIComponent(kind) + "&day=today", { cache: "no-store" })
+    .then(function (resp) { return resp.json(); })
+    .then(function (data) { if (seq === todaySeq) { renderTodayList(data); } })
+    .catch(function (err) {
+      if (seq === todaySeq) {
+        put(target, [unknown("unknown: the list could not be read (" +
+          (err && err.message ? err.message : "error") + ")")]);
+      }
+    })
+    .then(function () {
+      if (seq !== todaySeq) { return; }
+      todayBusy = null;
+      if (todayStale && todayOpen === kind) { loadTodayList(false); }
+    });
+}
+
+function renderTodayList(data) {
+  var target = document.getElementById("today-list");
+  if (!Array.isArray(data.events)) {
+    put(target, [unknown("unknown: " + (data.error || "the list could not be read"))]);
+    return;
+  }
+  if (data.events.length === 0) { put(target, [empty("none today")]); return; }
+  var list = el("ul", "plain");
+  data.events.forEach(function (ev) {
+    var li = el("li", "card");
+    var row = el("div", "row");
+    row.appendChild(el("span", "when", clock(ev.ts)));
+    if (ev.repo) {
+      row.appendChild(ghLink(ev.url,
+        ev.repo + (typeof ev.issue_number === "number" ? "#" + ev.issue_number : ""), "repo"));
+    }
+    if (ev.session_id) { row.appendChild(el("span", "muted", ev.session_id)); }
+    li.appendChild(row);
+    var r = ev.reason;
+    if (r) {
+      if (r.session === "not found") {
+        li.appendChild(el("p", "reason", "the run's record is gone"));
+      }
+      if (typeof r.exit_code === "number") {
+        li.appendChild(el("p", "reason", "exit code " + r.exit_code));
+      }
+      if (r.question) { li.appendChild(el("p", "reason", "asked: " + r.question)); }
+      if (r.summary) { li.appendChild(el("p", "reason", r.summary)); }
+      if (r.output_tail) {
+        var more = el("details");
+        more.appendChild(el("summary", null, "output"));
+        more.appendChild(el("pre", null, r.output_tail));
+        li.appendChild(more);
+      }
+      if (!r.question && !r.summary && !r.output_tail && typeof r.exit_code !== "number"
+          && r.session !== "not found") {
+        li.appendChild(el("p", "reason", "no reason was recorded"));
+      }
+    } else {
+      var text = detailText(ev.detail);
+      if (text) { li.appendChild(el("div", "detail", text)); }
+    }
+    list.appendChild(li);
+  });
+  var note = data.truncated === true
+    ? el("p", "empty", "showing newest " + data.events.length + " of " + data.total) : null;
+  put(target, note ? [note, list] : [list]);
+}
+
 function detailText(detail) {
   if (detail === null || detail === undefined) { return ""; }
   if (typeof detail !== "object") { return String(detail); }
@@ -917,6 +1043,7 @@ function render(data) {
   renderWaiting(data);
   renderSkipped(data);
   renderToday(data);
+  loadTodayList();
   renderFleet(data, now);
   renderUsage(data, now);
   renderServer(data);

{ctrlrelay-0.16.1 → ctrlrelay-0.16.3}/src/ctrlrelay/web/status.py

@@ -87,6 +87,7 @@ import json
 import os
 import re
 import sqlite3
+import time
 import urllib.parse
 from collections.abc import Callable, Mapping
 from datetime import UTC, date, datetime, timedelta
@@ -369,9 +370,23 @@ def _event_url(repo: Any, issue_number: Any, detail: Any) -> str | None:
     return github_url(repo, issue_number)
 
 
+def _scrubbed(detail: Any) -> Any:
+    """``detail`` with credential shapes removed from its text: a question
+    the agent asked is stored as it wrote it, and the page shows it."""
+    from ctrlrelay.core.redact import redact_secrets
+
+    if isinstance(detail, dict):
+        return {k: _scrubbed(v) for k, v in detail.items()}
+    if isinstance(detail, list):
+        return [_scrubbed(v) for v in detail]
+    if isinstance(detail, str):
+        return redact_secrets(detail)
+    return detail
+
+
 def _event(row: dict[str, Any]) -> dict[str, Any]:
     ts = int(row["ts"])
-    detail = _detail(row["detail"])
+    detail = _scrubbed(_detail(row["detail"]))
     return {
         "ts": ts,
         "time": _iso(ts),
@@ -792,6 +807,103 @@ def list_feed(*, db_path: Path, since_ts: int, limit: int | None = None) -> dict
     }
 
 
+# The kinds a Today counter counts, which ``list_day_events`` lists (#257).
+DAY_KINDS = frozenset(_TODAY)
+# How much of a failed run's stored output and summary a row carries.
+REASON_TAIL_CHARS = 2000
+REASON_SUMMARY_CHARS = 500
+
+
+def _read_day_events(
+    conn: sqlite3.Connection, kind: str, start: int, end: int, limit: int,
+) -> tuple[list[dict[str, Any]], int]:
+    rows = conn.execute(
+        """SELECT e.ts, e.kind, e.repo, e.issue_number, e.session_id, e.detail,
+                  s.id AS s_id, s.claude_exit_code, s.summary, s.output_tail,
+                  s.blocked_question
+           FROM events e LEFT JOIN sessions s ON s.id = e.session_id
+           WHERE e.kind = ? AND e.ts >= ? AND e.ts < ?
+           ORDER BY e.ts DESC, e.id DESC LIMIT ?""",
+        (kind, start, end, int(limit)),
+    ).fetchall()
+    (total,) = conn.execute(
+        "SELECT count(*) FROM events WHERE kind = ? AND ts >= ? AND ts < ?",
+        (kind, start, end),
+    ).fetchone()
+    out = []
+    for r in rows:
+        row = dict(r)
+        event = _event(row)
+        if kind in ("failed", "blocked"):
+            event["reason"] = _reason(row, event["detail"])
+        out.append(event)
+    return out, int(total)
+
+
+def _cut(text: str, limit: int) -> str:
+    """``text`` up to ``limit`` characters, ending in "…" when cut."""
+    return text if len(text) <= limit else text[: limit - 1] + "…"
+
+
+def _reason(row: dict[str, Any], detail: Any) -> dict[str, Any]:
+    """Why a run failed or stopped, from what the relay stored: the exit
+    code, its summary and output tail, and the question asked, each
+    scrubbed of credential shapes again here. ``session`` says when the run's row is gone."""
+    from ctrlrelay.core.redact import redact_secrets, tail
+
+    detail = detail if isinstance(detail, dict) else {}
+    exit_code = detail.get("exit_code")
+    if not isinstance(exit_code, int) or isinstance(exit_code, bool):
+        exit_code = row.get("claude_exit_code")
+    question = detail.get("question") or row.get("blocked_question")
+    summary = row.get("summary")
+    output = row.get("output_tail")
+    reason: dict[str, Any] = {
+        "exit_code": exit_code if isinstance(exit_code, int) else None,
+        "summary": (
+            _cut(redact_secrets(summary), REASON_SUMMARY_CHARS)
+            if isinstance(summary, str) and summary else None
+        ),
+        "output_tail": (
+            tail(redact_secrets(output), REASON_TAIL_CHARS)
+            if isinstance(output, str) and output else None
+        ),
+        "question": (
+            _cut(redact_secrets(question), REASON_SUMMARY_CHARS)
+            if isinstance(question, str) and question else None
+        ),
+    }
+    if row.get("s_id") is None:
+        reason["session"] = "not found"
+    return reason
+
+
+def list_day_events(
+    *, db_path: Path, kind: str, now: int | None = None, limit: int | None = None,
+) -> dict:
+    """Today's events of one counted ``kind``, newest first, for the Today
+    counters (#257): ``{"kind", "events", "total", "truncated", "error"}``.
+    A failed or blocked event carries ``reason``. ``events`` and ``total``
+    are ``null`` when they could not be read, never an empty list."""
+    if limit is None:
+        limit = FEED_LIMIT
+    start, end = _local_day(int(now if now is not None else time.time()))
+    try:
+        events, total = _read(
+            Path(db_path),
+            lambda conn: _read_day_events(conn, kind, start, end, limit),
+        )
+    except Exception as exc:
+        return {
+            "kind": kind, "events": None, "total": None, "truncated": False,
+            "error": f"events could not be read ({db_path}): {type(exc).__name__}: {exc}",
+        }
+    return {
+        "kind": kind, "events": events, "total": total,
+        "truncated": total > len(events), "error": None,
+    }
+
+
 def make_sessions_reader(db_path: Path) -> SessionsReader:
     """A ``SessionsReader`` for ``WaitingTracker``: running sessions (oldest
     first) and repo locks, read-only. Raises on any database failure, which

{ctrlrelay-0.16.1 → ctrlrelay-0.16.3}/tests/test_github.py

@@ -460,17 +460,21 @@ class TestGitHubCLI:
         """Should return only 'assigned' events for an issue."""
         from ctrlrelay.core.github import GitHubCLI
 
-        mock_output = json.dumps([
+        # ``gh api --paginate --jq '.[] | ...'`` prints one event per line,
+        # across every page.
+        mock_output = "\n".join(json.dumps(e) for e in [
             {
                 "event": "assigned",
                 "actor": {"login": "alice"},
                 "assignee": {"login": "alice"},
+                "assigner": {"login": "alice"},
                 "created_at": "2026-01-01T00:00:00Z",
             },
             {
                 "event": "assigned",
-                "actor": {"login": "bob"},
+                "actor": {"login": "alice"},
                 "assignee": {"login": "alice"},
+                "assigner": {"login": "bob"},
                 "created_at": "2026-01-02T00:00:00Z",
             },
         ])
@@ -481,11 +485,13 @@ class TestGitHubCLI:
             events = await gh.list_assignment_events("owner/repo", 42)
 
             assert len(events) == 2
-            assert events[0]["actor"]["login"] == "alice"
-            assert events[1]["actor"]["login"] == "bob"
+            assert events[0]["assigner"]["login"] == "alice"
+            assert events[1]["assigner"]["login"] == "bob"
 
             args = mock_run.call_args[0]
-            assert "api" in args
+            assert "api" in args and "--paginate" in args
+            # Only assigned events, one per line across every page.
+            assert args[args.index("--jq") + 1] == '.[] | select(.event=="assigned")'
             assert "/repos/owner/repo/issues/42/events" in args
 
     @pytest.mark.asyncio

{ctrlrelay-0.16.1 → ctrlrelay-0.16.3}/tests/test_node_claims.py

@@ -842,7 +842,7 @@ class TestThePollerLooksAgainWhenTheClaimCouldGoStale:
         gh.list_issues_by_label = AsyncMock(return_value=[])
         gh.list_assignment_events = AsyncMock(return_value=[{
             "event": "assigned", "actor": {"login": "alice"},
-            "assignee": {"login": "alice"},
+            "assignee": {"login": "alice"}, "assigner": {"login": "alice"},
         }])
         return IssuePoller(
             github=gh, username="alice", repos=["o/r"],