code-coordinator 0.5.46__py3-none-any.whl

coord/health/registry.py

@@ -0,0 +1,240 @@
+"""The check registry (#1628).
+
+**The acceptance bar for this abstraction is that adding a check touches
+exactly one file: the new check module.**  Not the renderer, not the CLI,
+not a transport.  That is enforced two ways:
+
+1. Registration is a decorator (:func:`check`) applied in the check's own
+   module — there is no central list of checks to append to.
+2. Discovery is :func:`pkgutil.iter_modules` over ``coord.health.checks`` —
+   dropping ``coord/health/checks/foo.py`` into the package is the whole
+   installation step.  ``checks/__init__.py`` deliberately imports nothing.
+
+The other half of the contract is fail-soft.  :func:`run_all` wraps every
+probe in a bare ``except Exception`` and converts a raised probe into an
+``unknown`` result carrying the error text.  A health engine that dies on
+its weakest check reports nothing, which is worse than reporting the rest
+plus one ``?``.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import importlib
+import pkgutil
+from collections.abc import Callable, Iterable, Sequence
+from dataclasses import dataclass, field
+from typing import Any
+
+from coord.health.models import (
+    SCOPES,
+    CheckResult,
+    HealthContext,
+    Severity,
+    unknown_result,
+)
+
+# What a probe costs to run.  ``cheap`` probes are local syscalls/subprocesses
+# and the whole cheap set is budgeted under ~2s, because this eventually runs
+# on a timer on every agent.  ``network`` probes (the one PyPI simple-index
+# fetch, the ``claude -p /usage`` round trip) are skipped when the caller
+# passes ``allow_network=False``.
+COST_CHEAP = "cheap"
+COST_NETWORK = "network"
+
+ProbeFn = Callable[[HealthContext], CheckResult | Sequence[CheckResult] | None]
+
+
+@dataclass(frozen=True)
+class Check:
+    """A self-contained unit of fleet-degradation signal."""
+
+    id: str
+    scope: str
+    probe: ProbeFn
+    title: str = ""
+    description: str = ""
+    cost: str = COST_CHEAP
+    # Display/run ordering.  Lives on the check so a new module can slot
+    # itself into the report without anyone editing a renderer's list.
+    order: int = 100
+
+    def __post_init__(self) -> None:
+        if self.scope not in SCOPES:
+            raise ValueError(f"check {self.id!r}: scope must be one of {SCOPES}, got {self.scope!r}")
+        if self.cost not in (COST_CHEAP, COST_NETWORK):
+            raise ValueError(f"check {self.id!r}: cost must be 'cheap' or 'network'")
+        if not self.title:
+            object.__setattr__(self, "title", self.id)
+
+
+_REGISTRY: dict[str, Check] = {}
+_discovered = False
+
+
+def register(chk: Check) -> Check:
+    """Add *chk* to the registry.  Re-registering the same id replaces it
+    (module reload under pytest must not raise)."""
+    _REGISTRY[chk.id] = chk
+    return chk
+
+
+def check(
+    *,
+    id: str,  # noqa: A002 — matches the field name in the issue's spec
+    scope: str,
+    title: str = "",
+    description: str = "",
+    cost: str = COST_CHEAP,
+    order: int = 100,
+) -> Callable[[ProbeFn], ProbeFn]:
+    """Decorator form: register the decorated function as a check's probe.
+
+    The probe returns one :class:`CheckResult`, a sequence of them (one per
+    disk / per checkout / ...), or ``None`` for "nothing to report here".
+    """
+
+    def _wrap(fn: ProbeFn) -> ProbeFn:
+        register(
+            Check(
+                id=id,
+                scope=scope,
+                probe=fn,
+                title=title,
+                description=description,
+                cost=cost,
+                order=order,
+            )
+        )
+        return fn
+
+    return _wrap
+
+
+def discover(force: bool = False) -> None:
+    """Import every module under ``coord.health.checks`` so its decorators run.
+
+    This is the *entire* registration mechanism.  There is no list to edit.
+    """
+    global _discovered
+    if _discovered and not force:
+        return
+    from coord.health import checks as _checks_pkg
+
+    for mod in pkgutil.iter_modules(_checks_pkg.__path__):
+        if mod.name.startswith("_"):
+            continue
+        importlib.import_module(f"{_checks_pkg.__name__}.{mod.name}")
+    _discovered = True
+
+
+def all_checks() -> list[Check]:
+    """Every registered check, in stable report order."""
+    discover()
+    return sorted(_REGISTRY.values(), key=lambda c: (c.order, c.id))
+
+
+def get(check_id: str) -> Check | None:
+    discover()
+    return _REGISTRY.get(check_id)
+
+
+def run_check(chk: Check, ctx: HealthContext) -> list[CheckResult]:
+    """Run one check, fail-soft.
+
+    A probe that raises — any exception, including ``KeyboardInterrupt``'s
+    non-``Exception`` siblings excluded — yields a single ``unknown`` result
+    naming the error, and the run continues.
+    """
+    try:
+        out = chk.probe(ctx)
+    except Exception as exc:  # noqa: BLE001 — fail soft is the requirement
+        return [
+            unknown_result(
+                chk.id,
+                scope=chk.scope,
+                title=chk.title,
+                error=f"{type(exc).__name__}: {exc}",
+            )
+        ]
+    if out is None:
+        return []
+    results = [out] if isinstance(out, CheckResult) else list(out)
+    # A probe that forgets its own title/scope shouldn't produce rows the
+    # renderer can't label.  Backfill from the check definition.
+    return [
+        dataclasses.replace(r, title=chk.title) if r.title == r.check_id else r
+        for r in results
+    ]
+
+
+@dataclass
+class HealthReport:
+    """The full outcome of one registry run."""
+
+    results: list[CheckResult] = field(default_factory=list)
+    skipped: list[str] = field(default_factory=list)
+    duration_secs: float = 0.0
+
+    @property
+    def severity(self) -> Severity:
+        from coord.health.models import worst
+
+        return worst([r.severity for r in self.results])
+
+    def counts(self) -> dict[str, int]:
+        out = {s.value: 0 for s in Severity}
+        for r in self.results:
+            out[r.severity.value] += 1
+        return out
+
+    def to_dict(self) -> dict[str, Any]:
+        """The ``coord health --json`` contract (H-3/H-4 consume this)."""
+        return {
+            "schema": 1,
+            "severity": self.severity.value,
+            "counts": self.counts(),
+            "skipped": list(self.skipped),
+            "duration_secs": round(self.duration_secs, 3),
+            "results": [r.to_dict() for r in self.results],
+        }
+
+
+def run_all(
+    ctx: HealthContext,
+    *,
+    scopes: Iterable[str] | None = None,
+    only: Iterable[str] | None = None,
+) -> HealthReport:
+    """Run the registry against *ctx*.
+
+    * ``scopes`` — restrict to these scopes (``coord health --local`` passes
+      ``("machine", "checkout")``; ``fleet`` probes arrive in H-3).
+    * ``only`` — restrict to these check ids.
+    * ``ctx.allow_network`` False skips ``cost="network"`` checks, recording
+      their ids in :attr:`HealthReport.skipped` so "we didn't look" never
+      reads as "nothing wrong".
+    * ``thresholds.disabled_checks`` skips by operator config, same way.
+    """
+    import time  # noqa: PLC0415 — local so a frozen-clock test can patch it
+
+    started = time.monotonic()
+    scope_filter = set(scopes) if scopes is not None else None
+    only_filter = set(only) if only is not None else None
+    disabled = set(getattr(ctx.thresholds, "disabled_checks", ()) or ())
+
+    report = HealthReport()
+    for chk in all_checks():
+        if scope_filter is not None and chk.scope not in scope_filter:
+            continue
+        if only_filter is not None and chk.id not in only_filter:
+            continue
+        if chk.id in disabled:
+            report.skipped.append(f"{chk.id} (disabled in coordinator.yml)")
+            continue
+        if chk.cost == COST_NETWORK and not ctx.allow_network:
+            report.skipped.append(f"{chk.id} (network probe, --no-network)")
+            continue
+        report.results.extend(run_check(chk, ctx))
+    report.duration_secs = time.monotonic() - started
+    return report

coord/health/render.py

@@ -0,0 +1,82 @@
+"""Text rendering for ``coord health`` (#1628).
+
+**This module never decides anything.**  It reads ``result.severity`` and
+``result.headroom`` and lays them out; it does not look at ``result.values``
+except to pass it through, and it does not know what any particular check
+measures.  That is the whole reason a check can be added without editing a
+renderer — and the reason H-3's board projection and H-4's TUI/web renderers
+can be written against the same :meth:`CheckResult.to_dict` contract without
+re-deriving "is 86% used bad?" three more times.
+
+If you find yourself wanting to special-case a check id in here, the thing
+you actually want is another rendered field on ``CheckResult`` (like
+``threshold`` or ``trend``), populated by the probe.
+"""
+
+from __future__ import annotations
+
+from coord.health.models import CheckResult, Severity
+from coord.health.registry import HealthReport
+
+# Minimum column widths.  Columns grow to fit the widest row in the report
+# (see :func:`render_report`) rather than truncating — a clipped repo name or
+# path in a health report costs more than a ragged right edge.
+_LABEL_WIDTH = 20
+_SEVERITY_WIDTH = 5
+_HEADROOM_WIDTH = 46
+# Don't let one pathological label push every other column off the screen.
+_MAX_LABEL_WIDTH = 40
+
+
+def render_result(result: CheckResult, *, label_width: int = _LABEL_WIDTH) -> str:
+    """One report line: ``<label>  <SEVERITY>  <headroom>  <threshold>``."""
+    label = result.label.ljust(label_width)
+    severity = result.severity.label.ljust(_SEVERITY_WIDTH)
+    headroom = result.headroom
+    trailer_parts = []
+    if result.trend:
+        trailer_parts.append(result.trend)
+    # The threshold reminder is only useful next to a number that is near it.
+    # On an OK line it is clutter, so it rides along only when something is up.
+    if result.threshold and result.severity is not Severity.OK:
+        trailer_parts.append(result.threshold)
+    trailer = "  ".join(trailer_parts)
+    line = f"{label}  {severity}  {headroom}"
+    if trailer:
+        line = f"{line.ljust(label_width + _SEVERITY_WIDTH + _HEADROOM_WIDTH + 4)}  {trailer}"
+    return line.rstrip()
+
+
+def render_report(report: HealthReport, *, verbose: bool = False) -> str:
+    """The full ``coord health`` body.
+
+    ``verbose`` adds each result's ``detail`` (the "fix: ..." line) as an
+    indented continuation; without it only the headroom is shown, which is
+    what makes the report scannable at a glance.
+    """
+    label_width = min(
+        _MAX_LABEL_WIDTH,
+        max([_LABEL_WIDTH, *(len(r.label) for r in report.results)]),
+    )
+    lines: list[str] = []
+    for result in report.results:
+        lines.append(render_result(result, label_width=label_width))
+        if result.detail and (verbose or result.severity is not Severity.OK):
+            lines.append(f"{' ' * (label_width + 2)}  {result.detail}")
+    if not lines:
+        lines.append("no checks ran")
+    for skipped in report.skipped:
+        lines.append(f"{'skipped'.ljust(label_width)}  -      {skipped}")
+    lines.append(render_summary(report))
+    return "\n".join(lines)
+
+
+def render_summary(report: HealthReport) -> str:
+    """The trailer line — machine-greppable, same shape as GRAPH_HEALTH's."""
+    counts = report.counts()
+    return (
+        f"HEALTH: {report.severity.label} "
+        f"crit={counts['crit']} warn={counts['warn']} "
+        f"unknown={counts['unknown']} ok={counts['ok']} "
+        f"in {report.duration_secs:.2f}s"
+    )

coord/health/units.py

@@ -0,0 +1,60 @@
+"""Tiny rendering helpers shared by probes (#1628).
+
+These live next to the probes, not in the renderer, on purpose: a probe owns
+its ``headroom`` string end to end (see ``coord.health.models``), so the
+byte/duration formatting it needs has to be reachable without importing a
+renderer.  A renderer importing *this* is fine; a probe importing a renderer
+is the fork we're preventing.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+_GIB = 1024.0 ** 3
+
+
+def human_bytes(n: float) -> str:
+    """``78G`` / ``512M`` / ``0B`` — short enough for a one-line report."""
+    n = float(n)
+    sign = "-" if n < 0 else ""
+    n = abs(n)
+    for unit, size in (("T", 1024.0 ** 4), ("G", _GIB), ("M", 1024.0 ** 2), ("K", 1024.0)):
+        if n >= size:
+            value = n / size
+            # 43.2G reads better than 43G below 10; above that the decimal is noise.
+            return f"{sign}{value:.1f}{unit}" if value < 10 else f"{sign}{value:.0f}{unit}"
+    return f"{sign}{n:.0f}B"
+
+
+def gib(n: float) -> float:
+    """Bytes → GiB, as a float."""
+    return float(n) / _GIB
+
+
+def human_hours(seconds: float) -> str:
+    """``128.8h`` — the unit the graph-staleness incident was reported in."""
+    return f"{seconds / 3600.0:.1f}h"
+
+
+def expand(path: str | Path, home: str | Path) -> Path:
+    """``~``/``~/x`` → under *home*, everything else verbatim.
+
+    Deliberately NOT ``Path.expanduser()``: probes must expand against the
+    context's home so a test can point the whole engine at a tmp dir without
+    monkeypatching ``Path.home`` globally.
+    """
+    s = str(path)
+    if s == "~":
+        return Path(home)
+    if s.startswith("~/"):
+        return Path(home) / s[2:]
+    return Path(s)
+
+
+def shorten_path(path: str, home: str) -> str:
+    """``/home/john/src/vimcode`` → ``~/src/vimcode`` when it's under *home*."""
+    p, h = str(path), str(home).rstrip("/")
+    if h and (p == h or p.startswith(h + "/")):
+        return "~" + p[len(h):]
+    return p

coord/hooks.py

@@ -0,0 +1,106 @@
+"""Session lifecycle hooks — triggered at round completion and session end."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable
+
+from coord import github_ops
+from coord.config import Config
+from coord.models import CLOSES_ISSUE_TYPES, Board
+
+
+@dataclass
+class HookResult:
+    hook: str
+    ok: bool
+    message: str
+
+
+def run_hooks(event: str, config: Config, board: Board) -> list[HookResult]:
+    """Execute all hooks registered for *event*. Returns results."""
+    hook_names = getattr(config.hooks, event, [])
+    results: list[HookResult] = []
+    for name in hook_names:
+        fn = HOOK_REGISTRY.get(name)
+        if fn is None:
+            results.append(HookResult(hook=name, ok=False, message=f"unknown hook: {name}"))
+            continue
+        try:
+            msg = fn(config, board)
+            results.append(HookResult(hook=name, ok=True, message=msg))
+        except Exception as e:
+            results.append(HookResult(hook=name, ok=False, message=str(e)))
+    return results
+
+
+def is_round_complete(board: Board) -> bool:
+    """True when no active assignments remain (all finished or failed)."""
+    return len(board.active) == 0 and len(board.completed) > 0
+
+
+# ── Built-in hooks ──────────────────────────────────────────────────────────
+
+
+def _close_merged_issues(config: Config, board: Board) -> str:
+    """Close issues whose assignments completed successfully.
+
+    #1196 (hole 3): gated on :data:`coord.models.CLOSES_ISSUE_TYPES`, the
+    same gate ``merge_queue.py`` and the PR-body keyword already honour. An
+    opt-in hook (``KNOWN_HOOKS``, defaults empty — not enabled in this
+    repo's own config) must not contradict the #1077 invariant: a
+    "mock-author"/"test-author"/"audit" assignment's ``issue_number`` is the
+    milestone's *tracking issue* (often an epic), not something it resolved
+    — closing it here regardless of type was a loaded gun. Also routes
+    through :func:`coord.github_ops.close_issue` — the #1196 open-children
+    chokepoint — instead of a raw ``gh issue close`` call, so an epic with
+    open children is refused here too, not just on the merge path.
+    """
+    closed = []
+    for a in board.completed:
+        if a.status != "done":
+            continue
+        if a.type not in CLOSES_ISSUE_TYPES:
+            continue
+        repo = config.repo(a.repo_name)
+        if repo is None:
+            continue
+        try:
+            github_ops.close_issue(
+                repo.github,
+                a.issue_number,
+                comment=f"Closed by coordinator: assignment {a.assignment_id} completed.",
+            )
+            closed.append(f"{repo.github}#{a.issue_number}")
+        except RuntimeError:
+            pass
+    if not closed:
+        return "no issues to close"
+    return f"closed {len(closed)} issue(s): {', '.join(closed)}"
+
+
+def _summary_report(config: Config, board: Board) -> str:
+    """Generate a session/round summary."""
+    done = [a for a in board.completed if a.status == "done"]
+    failed = [a for a in board.completed if a.status == "failed"]
+    lines = [
+        f"Round {board.round_number} summary:",
+        f"  completed: {len(done)} assignment(s)",
+        f"  failed:    {len(failed)} assignment(s)",
+        f"  active:    {len(board.active)} assignment(s) still running",
+    ]
+    if done:
+        lines.append("  done:")
+        for a in done:
+            lines.append(f"    - {a.repo_name} #{a.issue_number}: {a.issue_title}")
+    if failed:
+        lines.append("  failed:")
+        for a in failed:
+            lines.append(f"    - {a.repo_name} #{a.issue_number}: {a.issue_title}")
+    return "\n".join(lines)
+
+
+HOOK_REGISTRY: dict[str, Callable[[Config, Board], str]] = {
+    "close_merged_issues": _close_merged_issues,
+    "summary_report": _summary_report,
+}

coord/housekeeping.py

@@ -0,0 +1,204 @@
+"""#762: bound DB growth by archiving stale terminal board rows.
+
+The ``coord serve`` board grew unbounded (every assignment ever dispatched stayed
+in ``assignments`` forever), bloating the ``/board`` projection until it overran
+the TUI's fetch timeout and blanked the whole board.  Part 1 caps the *wire*
+(``coord.dao.board_projection``); this module bounds the *storage*: it **moves**
+(never deletes) terminal assignments older than the archive window — plus their
+notifications — into ``assignments_archive`` / ``notifications_archive`` so the
+hot tables stay small while the cost/token/timing history is preserved for
+analytics.
+
+Two guarantees make the sweep safe:
+
+* It reuses :func:`coord.dao.compute_board_keep_ids` (the *same* keep logic as the
+  board projection) with a **wider** window than the projection, so the protected
+  set here is always a superset of what the projection keeps — archiving can never
+  drop a row the board still shows.
+* It only ever archives rows whose status is terminal, as a belt-and-suspenders
+  guard on top of the keep set.
+
+The sweep runs automatically on a low-cadence daemon tick and on demand via
+``coord housekeeping`` (which routes through the daemon — the canonical DB lives
+there).
+"""
+
+from __future__ import annotations
+
+import os
+import sqlite3
+import time
+
+from coord.dao import (
+    TERMINAL_STATUSES,
+    _KEEP_INDEX_COLUMNS,
+    compute_board_keep_ids,
+)
+from coord.db import get_connection
+
+# Terminal rows older than this many days (and not referenced by anything live)
+# are eligible to move to the archive.  Deliberately wider than the board
+# projection window (``COORD_BOARD_RETENTION_DAYS``, default 14) so the live
+# table always retains everything the wire shows, with margin for any logic that
+# reaches back through ``build_board``.  0 disables archiving.
+_DEFAULT_ARCHIVE_RETENTION_DAYS = 30
+
+_ASSIGNMENTS = "assignments"
+_ASSIGNMENTS_ARCHIVE = "assignments_archive"
+_NOTIFICATIONS = "notifications"
+_NOTIFICATIONS_ARCHIVE = "notifications_archive"
+_BATCH = 400  # keep IN(...) clauses well under SQLite's 999-variable limit
+
+
+def _archive_retention_days() -> int:
+    try:
+        return int(
+            os.environ.get(
+                "COORD_ARCHIVE_RETENTION_DAYS", _DEFAULT_ARCHIVE_RETENTION_DAYS
+            )
+        )
+    except (TypeError, ValueError):
+        return _DEFAULT_ARCHIVE_RETENTION_DAYS
+
+
+def _archive_cutoff(now: float | None = None) -> float | None:
+    days = _archive_retention_days()
+    if days <= 0:
+        return None
+    return (time.time() if now is None else now) - days * 86400.0
+
+
+def _columns(conn: sqlite3.Connection, table: str) -> list[tuple[str, str]]:
+    """Return ``[(name, type), ...]`` for *table* (empty if it doesn't exist)."""
+    return [
+        (r[1], r[2] or "TEXT")
+        for r in conn.execute(f"PRAGMA table_info({table})").fetchall()  # noqa: S608
+    ]
+
+
+def _ensure_archive_mirror(conn: sqlite3.Connection, src: str, dst: str) -> list[str]:
+    """Create/extend *dst* so it has every column of *src* (no constraints — the
+    archive is dumb storage).  Robust to future ``ALTER TABLE`` on *src*.
+
+    Returns the shared column-name list to use for the copy.
+    """
+    src_cols = _columns(conn, src)
+    dst_existing = {name for name, _ in _columns(conn, dst)}
+    if not dst_existing:
+        coldefs = ", ".join(f'"{name}" {ctype}' for name, ctype in src_cols)
+        conn.execute(f"CREATE TABLE {dst} ({coldefs})")  # noqa: S608
+    else:
+        for name, ctype in src_cols:
+            if name not in dst_existing:
+                conn.execute(f'ALTER TABLE {dst} ADD COLUMN "{name}" {ctype}')  # noqa: S608
+    return [name for name, _ in src_cols]
+
+
+def _move_rows(
+    conn: sqlite3.Connection,
+    src: str,
+    dst: str,
+    key_col: str,
+    ids: list[str],
+) -> None:
+    """Copy then delete rows of *src* whose *key_col* is in *ids* (batched)."""
+    cols = _ensure_archive_mirror(conn, src, dst)
+    collist = ", ".join(f'"{c}"' for c in cols)
+    for i in range(0, len(ids), _BATCH):
+        batch = ids[i : i + _BATCH]
+        placeholders = ",".join("?" for _ in batch)
+        conn.execute(
+            f"INSERT INTO {dst} ({collist}) SELECT {collist} FROM {src} "  # noqa: S608
+            f"WHERE {key_col} IN ({placeholders})",
+            batch,
+        )
+        conn.execute(
+            f"DELETE FROM {src} WHERE {key_col} IN ({placeholders})",  # noqa: S608
+            batch,
+        )
+
+
+def sweep(*, dry_run: bool = False, now: float | None = None) -> dict:
+    """Archive stale terminal assignments + their notifications.
+
+    Returns ``{"archived_assignments": N, "archived_notifications": M,
+    "dry_run": bool, "retention_days": D}``.  ``archived_*`` are the counts that
+    were (or, for ``dry_run``, would be) moved.  A no-op returns zeros.
+
+    Conservative by construction: nothing active, recent (within the archive
+    window), queued-for-merge, latest-of-an-open-issue, or review-linked to any
+    such row is ever moved.
+    """
+    cutoff = _archive_cutoff(now)
+    result = {
+        "archived_assignments": 0,
+        "archived_notifications": 0,
+        "dry_run": dry_run,
+        "retention_days": _archive_retention_days(),
+    }
+    if cutoff is None:
+        return result  # archiving disabled
+
+    conn = get_connection()
+    index = [
+        dict(r)
+        for r in conn.execute(
+            f"SELECT {_KEEP_INDEX_COLUMNS} FROM {_ASSIGNMENTS}"  # noqa: S608
+        ).fetchall()
+    ]
+    mq_ids = {
+        r["assignment_id"]
+        for r in conn.execute(
+            f"SELECT assignment_id FROM merge_queue"  # noqa: S608
+        ).fetchall()
+        if r["assignment_id"]
+    }
+    open_keys = {
+        (r["repo_name"], r["number"])
+        for r in conn.execute(
+            "SELECT repo_name, number FROM issues WHERE LOWER(state) != 'closed'"
+        ).fetchall()
+    }
+    protected = compute_board_keep_ids(index, mq_ids, open_keys, cutoff)
+
+    candidates = [
+        r["assignment_id"]
+        for r in index
+        if r["assignment_id"]
+        and r["assignment_id"] not in protected
+        and (r["status"] or "").lower() in TERMINAL_STATUSES
+    ]
+    candidate_set = set(candidates)
+
+    # Notifications to archive: those belonging to an archived assignment, plus
+    # old notifications not referencing a still-protected assignment.
+    notif_ids = [
+        r["assignment_id"]
+        for r in conn.execute(
+            f"SELECT assignment_id, posted_at FROM {_NOTIFICATIONS}"  # noqa: S608
+        ).fetchall()
+        if r["assignment_id"]
+        and (
+            r["assignment_id"] in candidate_set
+            or (
+                (r["posted_at"] is not None and r["posted_at"] < cutoff)
+                and r["assignment_id"] not in protected
+            )
+        )
+    ]
+
+    result["archived_assignments"] = len(candidates)
+    result["archived_notifications"] = len(notif_ids)
+    if dry_run or (not candidates and not notif_ids):
+        return result
+
+    with conn:
+        if notif_ids:
+            _move_rows(
+                conn, _NOTIFICATIONS, _NOTIFICATIONS_ARCHIVE, "assignment_id", notif_ids
+            )
+        if candidates:
+            _move_rows(
+                conn, _ASSIGNMENTS, _ASSIGNMENTS_ARCHIVE, "assignment_id", candidates
+            )
+    return result