aiuse 3.2.0__tar.gz → 3.2.2__tar.gz

{aiuse-3.2.0/src/aiuse.egg-info → aiuse-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiuse
-Version: 3.2.0
+Version: 3.2.2
 Summary: Aggregate AI subscription/API usage and flag use-it-or-lose-it allotments
 Author: djbclark
 License-Expression: MIT

{aiuse-3.2.0 → aiuse-3.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aiuse"
-version = "3.2.0"
+version = "3.2.2"
 description = "Aggregate AI subscription/API usage and flag use-it-or-lose-it allotments"
 readme = "README.md"
 requires-python = ">=3.11"

{aiuse-3.2.0 → aiuse-3.2.2}/src/aiuse/__init__.py

@@ -1,3 +1,3 @@
 """Aggregate provider quotas and flag use-it-or-lose-it allotments."""
 
-__version__ = "3.2.0"
+__version__ = "3.2.2"

{aiuse-3.2.0 → aiuse-3.2.2}/src/aiuse/analysis/selfdescribe.py

@@ -317,6 +317,11 @@ def summary_line(pool: Mapping[str, Any]) -> str:
     provider = str(pool.get("provider") or "?")
     family = pool.get("pool_family")
     lead = f"{provider} {family}" if family else provider
+    # The command you actually type, when it is not the provider id: `cursor`
+    # opens the editor (the agent is cursor-agent), antigravity is `agy`.
+    binary = pool.get("cli_binary")
+    if binary and str(binary) != provider:
+        lead += f" [{binary}]"
     segments: list[str] = []
     for window in pool.get("windows") or []:
         label = str(window.get("label") or "?")

{aiuse-3.2.0 → aiuse-3.2.2}/src/aiuse/report.py

@@ -280,7 +280,7 @@ def render_report(
     lines.append(s.bold("=" * width))
     title = "AI USAGE — USE IT OR LOSE IT (full)"
     lines.append(s.bold(s.cyan(title)))
-    meta = f"Collected at {snapshot.collected_at.isoformat()}"
+    meta = f"Collected at {format_clock(snapshot.collected_at, date=True)}"
     meta += f" · {n_accounts} account{'s' if n_accounts != 1 else ''}"
     if n_actionable:
         meta += f" · {n_actionable} alert{'s' if n_actionable != 1 else ''}"
@@ -1703,6 +1703,14 @@ def _priority_account_line(
     return f"{_priority_tag(s, band)} {body}"
 
 
+def format_clock(when: datetime, *, seconds: bool = False, date: bool = False) -> str:
+    """Local 12-hour time as people say it: ``9:02pm``, ``9:02:07pm``, ``Sat Oct 5 9:02pm``."""
+    local = when.astimezone()
+    clock = f"{local.hour % 12 or 12}:{local:%M}" + (f":{local:%S}" if seconds else "")
+    clock += "am" if local.hour < 12 else "pm"
+    return f"{local:%a %b} {local.day} {clock}" if date else clock
+
+
 def render_stderr_meta(
     snapshot: Snapshot,
     alerts: list[UseOrLoseAlert],
@@ -1715,7 +1723,7 @@ def render_stderr_meta(
     n_accounts = len(accounts)
     n_actionable = sum(1 for a in alerts if a.urgency not in (Urgency.INFO, Urgency.NONE))
     lines: list[str] = []
-    meta = f"Collected at {snapshot.collected_at.isoformat()}"
+    meta = f"Collected at {format_clock(snapshot.collected_at, date=True)}"
     meta += f" · {n_accounts} account{'s' if n_accounts != 1 else ''}"
     if n_actionable:
         meta += f" · {n_actionable} alert{'s' if n_actionable != 1 else ''}"

{aiuse-3.2.0 → aiuse-3.2.2}/src/aiuse/sampler.py

@@ -24,7 +24,7 @@ import os
 import sys
 from concurrent.futures import Future, ThreadPoolExecutor
 from dataclasses import dataclass, field
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any, Callable
 
@@ -109,6 +109,15 @@ def decide(state: dict[str, Any], settings: dict[str, float], now: datetime, *,
     return Decision("full", f"{tier} tier")
 
 
+def schedule(state: dict[str, Any], settings: dict[str, float]) -> tuple[datetime, datetime, str] | None:
+    """``(previous sample, next sample due, tier)``, or None before the first sample."""
+    last = _parse(state.get("last_sample_at"))
+    if last is None:
+        return None
+    tier = state.get("tier") if state.get("tier") in TIERS else "idle"
+    return last, last + timedelta(seconds=settings[f"{tier}_interval"]), str(tier)
+
+
 def _series(snapshot: Snapshot) -> dict[str, dict[str, Any]]:
     out: dict[str, dict[str, Any]] = {}
     for account in snapshot.accounts:

{aiuse-3.2.0 → aiuse-3.2.2}/src/aiuse/watch.py

@@ -20,7 +20,7 @@ from aiuse.analysis.local_runtimes import maybe_local_runtime_alerts
 from aiuse.analysis.use_or_lose import analyze_use_or_lose
 from aiuse.collectors.runner import run_collectors
 from aiuse.models import Snapshot, UseOrLoseAlert, utcnow
-from aiuse.report import render_clock_matrix, render_stderr_meta
+from aiuse.report import _strip_ansi, format_clock, render_clock_matrix, render_stderr_meta
 
 DEFAULT_INTERVAL_S = 600.0
 MIN_INTERVAL_S = 5.0
@@ -57,25 +57,115 @@ def parse_interval(value: str | float | int) -> float:
     return seconds
 
 
-def collect_watch_frame(config: dict[str, Any]) -> tuple[Snapshot, list[UseOrLoseAlert]]:
-    """One live collect + analysis pass (same as a normal CLI run)."""
-    snapshot = run_collectors(config)
-    alerts = analyze_use_or_lose(snapshot, config)
-    alerts.extend(maybe_local_runtime_alerts(snapshot, config=config))
+def _overlay_burst_samples(snapshot: Snapshot) -> bool:
+    """Replace accounts with any newer burst-tier reading. True if one applied.
+
+    During a burst the sampler reads the burning providers every few minutes
+    into partial samples, while full snapshots stay 15 minutes apart. The
+    board is most useful exactly then, so it shows the newer reading for those
+    providers and the full snapshot for everything else.
+    """
+    from aiuse.analysis.history import account_key, partial_sample_dir
+    from aiuse.ledger import load_json_range
+    from aiuse.models import canonical_provider
+    from aiuse.serve import _snapshot_from_accounts_dict
+
+    applied = False
+    for row in load_json_range(partial_sample_dir(), snapshot.collected_at, None):
+        for fresh in _snapshot_from_accounts_dict(row).accounts:
+            if fresh.error or not fresh.windows:
+                continue
+            provider = canonical_provider(fresh.provider)
+            same = [i for i, a in enumerate(snapshot.accounts) if canonical_provider(a.provider) == provider]
+            exact = [i for i in same if account_key(snapshot.accounts[i].account) == account_key(fresh.account)]
+            # A provider-scoped reading belongs to the provider's only account.
+            target = exact[0] if exact else same[0] if len(same) == 1 else None
+            if target is None:
+                continue
+            fresh.account = fresh.account or snapshot.accounts[target].account
+            snapshot.accounts[target] = fresh
+            applied = True
+    return applied
+
+
+def _frame_from_disk(max_age: float, config: dict[str, Any]) -> tuple[Snapshot, list[UseOrLoseAlert]] | None:
+    """The newest full snapshot on disk, if it is younger than ``max_age`` seconds."""
+    from aiuse.analysis.history import load_recent_snapshots
+    from aiuse.serve import _alerts_from_dicts, _disk_row_age_ok, _snapshot_from_accounts_dict
+
+    rows = load_recent_snapshots(max_count=1)
+    if not rows or not _disk_row_age_ok(rows[0], max_age):
+        return None
+    snapshot = _snapshot_from_accounts_dict(rows[0])
+    if _overlay_burst_samples(snapshot):
+        # The stored alerts describe the older readings; re-derive them.
+        alerts = analyze_use_or_lose(snapshot, config)
+        alerts.extend(maybe_local_runtime_alerts(snapshot, config=config))
+        return snapshot, alerts
+    return snapshot, _alerts_from_dicts(rows[0].get("alerts") or [])
+
+
+def collect_watch_frame(
+    config: dict[str, Any], *, max_age: float | None = None
+) -> tuple[Snapshot, list[UseOrLoseAlert]]:
+    """One frame for the board, sharing one polling pipeline with ``aiuse sample``.
+
+    With ``max_age`` set, a snapshot the scheduled sampler (or anything else)
+    wrote within that many seconds is shown as is: the board and the sampler
+    are not two clocks polling the same vendors. Otherwise this collects, and
+    records the result the way a sample does — snapshot, token ledger, sampler
+    state — so the scheduled job sees a fresh sample and skips its own.
+    """
     raw_analysis = config.get("analysis")
     analysis_cfg: dict[str, Any] = raw_analysis if isinstance(raw_analysis, dict) else {}
-    if should_persist_snapshots(analysis_cfg):
+    persist = should_persist_snapshots(analysis_cfg)
+    if max_age and persist:
+        cached = _frame_from_disk(max_age, config)
+        if cached is not None:
+            return cached
+
+    from aiuse import sampler
+    from aiuse.ledger import save_ledger
+
+    ledger_sample = None
+    if persist:
+        snapshot, ledger_sample, _ledger_error = sampler.collect_with_ledger(config, run_collectors)
+    else:
+        snapshot = run_collectors(config)
+    alerts = analyze_use_or_lose(snapshot, config)
+    alerts.extend(maybe_local_runtime_alerts(snapshot, config=config))
+    if persist:
+        retention = int(analysis_cfg.get("snapshot_retention_days") or 90)
         try:
-            save_snapshot(
-                snapshot,
-                alerts,
-                retention_days=int(analysis_cfg.get("snapshot_retention_days") or 90),
-            )
+            save_snapshot(snapshot, alerts, retention_days=retention)
+            if ledger_sample is not None:
+                save_ledger(ledger_sample, collected_at=snapshot.collected_at, retention_days=retention)
+            settings = sampler.sampling_settings(config)
+            sampler.save_state(sampler.advance_state(sampler.load_state(), snapshot, settings, partial=False))
         except OSError:
             pass
     return snapshot, alerts
 
 
+_schedule_cache: tuple[float, tuple[datetime, datetime, str] | None] | None = None
+
+
+def _sample_schedule(config: dict[str, Any]) -> tuple[datetime, datetime, str] | None:
+    """When ``aiuse sample`` last ran and is next due. Re-read every 2 seconds:
+    the board redraws four times a second and the state file changes rarely."""
+    global _schedule_cache
+    from aiuse import sampler
+
+    if _schedule_cache is not None and time.monotonic() - _schedule_cache[0] < 2.0:
+        return _schedule_cache[1]
+    try:
+        value = sampler.schedule(sampler.load_state(), sampler.sampling_settings(config))
+    except Exception:  # noqa: BLE001 — a header detail must never take the board down
+        value = None
+    _schedule_cache = (time.monotonic(), value)
+    return value
+
+
 def render_watch_board(
     snapshot: Snapshot | None,
     alerts: list[UseOrLoseAlert],
@@ -87,11 +177,21 @@ def render_watch_board(
     next_in: float | None = None,
     collecting_for: float | None = None,
     error: str | None = None,
+    now: datetime | None = None,
+    sample_schedule: tuple[datetime, datetime, str] | None = None,
 ) -> str:
-    """Header + clock matrix + optional footer for the alternate-screen board."""
+    """Header + clock matrix + optional footer for the alternate-screen board.
+
+    ``last`` is when the data on the board was collected, which is not when
+    the board last refreshed: a frame can come from a snapshot the scheduled
+    sampler wrote some minutes ago.
+    """
     header_bits = ["aiuse watch"]
-    if last_at is not None:
-        header_bits.append(f"last: {last_at.astimezone().strftime('%H:%M:%S')}")
+    if now is not None:
+        header_bits.append(f"now: {format_clock(now, seconds=True)}")
+    data_at = snapshot.collected_at if snapshot is not None else last_at
+    if data_at is not None:
+        header_bits.append(f"last: {format_clock(data_at, seconds=True)}")
     else:
         header_bits.append("last: —")
     if collecting_for is not None:
@@ -101,14 +201,25 @@ def render_watch_board(
         header_bits.append(f"next in {mins}:{secs:02d}")
     header_bits.append("q/esc quit")
     lines = [" · ".join(header_bits)]
+    if sample_schedule is not None:
+        previous, due, tier = sample_schedule
+        overdue = " (due)" if now is not None and due <= now else ""
+        lines.append(
+            f"sampler: previous {format_clock(previous, seconds=True)}"
+            f" · next {format_clock(due, seconds=True)}{overdue} · {tier} tier"
+        )
     if error:
         lines.append(f"collect error: {error}")
     if snapshot is not None:
-        lines.append(render_clock_matrix(alerts, snapshot=snapshot, config=config, color=color).rstrip())
+        matrix = render_clock_matrix(alerts, snapshot=snapshot, config=config, color=color).rstrip()
+        lines.append(matrix)
         if not quiet:
             footer = render_stderr_meta(snapshot, alerts, color=color).rstrip()
             if footer:
-                lines.append(footer)
+                # Centered under the table, like the legend lines above it.
+                width = max((len(_strip_ansi(row)) for row in matrix.splitlines()), default=0)
+                for row in footer.splitlines():
+                    lines.append(" " * max(0, (width - len(_strip_ansi(row))) // 2) + row)
     else:
         lines.append("waiting for first collection…")
     return "\n".join(lines)
@@ -223,7 +334,7 @@ class WatchRuntime:
         return max(0.0, self.next_due - self.now())
 
 
-def _collect_process_entry(config: dict[str, Any], send: Any) -> None:
+def _collect_process_entry(config: dict[str, Any], send: Any, max_age: float | None = None) -> None:
     """Collect in an isolated process so an in-flight refresh is cancellable."""
     if os.name == "posix":
         try:
@@ -231,7 +342,7 @@ def _collect_process_entry(config: dict[str, Any], send: Any) -> None:
         except OSError:
             pass
     try:
-        snapshot, alerts = collect_watch_frame(config)
+        snapshot, alerts = collect_watch_frame(config, max_age=max_age)
         send.send(("ok", snapshot, alerts))
     except BaseException as exc:  # noqa: BLE001 — return a board error instead of losing the worker
         try:
@@ -245,8 +356,9 @@ def _collect_process_entry(config: dict[str, Any], send: Any) -> None:
 class _WatchCollectionProcess:
     """One cancellable live-collection process for interactive watch mode."""
 
-    def __init__(self, config: dict[str, Any]) -> None:
+    def __init__(self, config: dict[str, Any], max_age: float | None = None) -> None:
         self.config = config
+        self.max_age = max_age
         methods = multiprocessing.get_all_start_methods()
         self.context: Any = multiprocessing.get_context("fork" if "fork" in methods else "spawn")
         self.process: multiprocessing.Process | None = None
@@ -256,7 +368,7 @@ class _WatchCollectionProcess:
         recv, send = self.context.Pipe(duplex=False)
         process = self.context.Process(
             target=_collect_process_entry,
-            args=(self.config, send),
+            args=(self.config, send, self.max_age),
             name="aiuse-watch-collect",
             daemon=True,
         )
@@ -337,7 +449,7 @@ def run_watch(
     out = stdout if stdout is not None else sys.stdout
     err = stderr if stderr is not None else sys.stderr
     color = False if no_color else None
-    collect_fn = collect or (lambda: collect_watch_frame(config))
+    collect_fn = collect or (lambda: collect_watch_frame(config, max_age=interval))
     runtime = WatchRuntime(interval=interval, collect=collect_fn, now=now or time.monotonic)
 
     if once:
@@ -353,6 +465,8 @@ def run_watch(
                 next_in=None,
                 collecting_for=None,
                 error=runtime.error,
+                now=utcnow(),
+                sample_schedule=_sample_schedule(config),
             ),
             file=out,
         )
@@ -384,7 +498,7 @@ def run_watch(
     )
     reader = key_reader or StdinKeyReader()
     stop = threading.Event()
-    process_worker = _WatchCollectionProcess(config) if collect is None else None
+    process_worker = _WatchCollectionProcess(config, max_age=interval) if collect is None else None
 
     def start_worker(fn: Callable[[], None]) -> None:
         if process_worker is not None:
@@ -423,6 +537,8 @@ def run_watch(
                     next_in=runtime.next_in(),
                     collecting_for=runtime.collecting_for(),
                     error=runtime.error,
+                    now=utcnow(),
+                    sample_schedule=_sample_schedule(config),
                 )
             )
 

{aiuse-3.2.0 → aiuse-3.2.2/src/aiuse.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiuse
-Version: 3.2.0
+Version: 3.2.2
 Summary: Aggregate AI subscription/API usage and flag use-it-or-lose-it allotments
 Author: djbclark
 License-Expression: MIT

{aiuse-3.2.0 → aiuse-3.2.2}/tests/test_selfdescribe.py

@@ -435,3 +435,13 @@ def test_plain_output_never_bare_percentage():
             for match in bare.finditer(line):
                 tail = line[match.start() :]
                 assert labeled.search(tail), f"bare percentage {match.group()!r} in line: {line!r}"
+
+
+def test_summary_line_names_the_binary_when_it_differs_from_the_provider_id():
+    from aiuse.analysis.selfdescribe import summary_line
+
+    window = {"label": "Cursor Auto", "state": "ok", "used_percent": 1.0, "headroom_percent": 99.0}
+    cursor = {"provider": "cursor", "pool_family": "auto", "cli_binary": "cursor-agent", "windows": [window]}
+    assert summary_line(cursor).startswith("cursor auto [cursor-agent]: Cursor Auto: ok")
+    codex = {"provider": "codex", "pool_family": None, "cli_binary": "codex", "windows": [window]}
+    assert summary_line(codex).startswith("codex: ")

{aiuse-3.2.0 → aiuse-3.2.2}/tests/test_watch.py

@@ -205,7 +205,7 @@ def test_run_watch_stops_default_collection_process_on_quit(monkeypatch):
     instances = []
 
     class FakeProcessWorker:
-        def __init__(self, config):
+        def __init__(self, config, max_age=None):
             self.config = config
             self.started = False
             self.stop_calls = 0
@@ -307,3 +307,114 @@ def test_collect_watch_frame_persists_when_enabled(monkeypatch):
     monkeypatch.setattr("aiuse.watch.save_snapshot", lambda *a, **k: saved.append(True) or "/tmp/x")
     collect_watch_frame({"analysis": {"persist_snapshots": True}})
     assert saved == [True]
+
+
+def test_watch_frame_reuses_a_fresh_snapshot_instead_of_collecting(monkeypatch):
+    """The board rides the scheduled sampler's data rather than polling beside it."""
+    from aiuse.analysis.history import save_snapshot
+
+    save_snapshot(_snap(), [])
+    monkeypatch.setattr("aiuse.watch.run_collectors", lambda _c: pytest.fail("must not collect"))
+    snapshot, alerts = collect_watch_frame({"analysis": {"persist_snapshots": True}}, max_age=600)
+    assert [a.provider for a in snapshot.accounts] == [a.provider for a in _snap().accounts]
+    assert alerts == []
+
+
+def test_watch_frame_collects_when_the_snapshot_is_stale_and_records_a_sample(monkeypatch):
+    from datetime import timedelta
+
+    from aiuse import sampler
+    from aiuse.analysis.history import load_recent_snapshots, save_snapshot
+
+    old = _snap()
+    old.collected_at -= timedelta(hours=2)
+    save_snapshot(old, [])
+    calls: list[int] = []
+    monkeypatch.setattr("aiuse.watch.run_collectors", lambda _c: calls.append(1) or _snap())
+    monkeypatch.setattr("aiuse.watch.analyze_use_or_lose", lambda *_a, **_k: [])
+    monkeypatch.setattr("aiuse.watch.maybe_local_runtime_alerts", lambda *_a, **_k: [])
+    collect_watch_frame({"analysis": {"persist_snapshots": True}}, max_age=600)
+    assert calls == [1] and len(load_recent_snapshots(retention_days=10_000)) == 2
+    # The scheduled job now sees a sample this recent and skips its own.
+    state = sampler.load_state()
+    assert sampler.decide(state, sampler.sampling_settings(None), _snap().collected_at).action == "skip"
+
+
+def test_board_header_shows_now_data_time_and_the_sampler_schedule():
+    from datetime import datetime, timedelta, timezone
+
+    from aiuse import sampler
+    from aiuse.report import format_clock
+    from aiuse.watch import render_watch_board
+
+    snap = _snap()
+    snap.collected_at = datetime(2026, 10, 3, 12, 0, 5, tzinfo=timezone.utc)
+    now = snap.collected_at + timedelta(minutes=7)
+    state = {"tier": "active", "last_sample_at": snap.collected_at.isoformat()}
+    schedule = sampler.schedule(state, sampler.sampling_settings(None))
+    assert schedule is not None and schedule[1] == snap.collected_at + timedelta(minutes=15)
+    board = render_watch_board(snap, [], color=False, quiet=True, now=now, sample_schedule=schedule)
+    header, sampler_line = board.splitlines()[:2]
+
+    def hms(value):
+        return format_clock(value, seconds=True)
+
+    assert f"now: {hms(now)}" in header and f"last: {hms(snap.collected_at)}" in header
+    assert sampler_line == f"sampler: previous {hms(snap.collected_at)} · next {hms(schedule[1])} · active tier"
+    late = render_watch_board(snap, [], color=False, quiet=True, now=now + timedelta(hours=1), sample_schedule=schedule)
+    assert "(due)" in late.splitlines()[1]
+    assert sampler.schedule({}, sampler.sampling_settings(None)) is None
+
+
+def test_watch_frame_overlays_newer_burst_samples_on_the_full_snapshot(monkeypatch):
+    from datetime import timedelta
+
+    from aiuse.analysis.history import save_snapshot
+
+    def account(provider: str, used: float, source: str = "codexbar") -> AccountUsage:
+        window = QuotaWindow(label=f"{provider} weekly", used_percent=used, window_minutes=10080)
+        return AccountUsage(
+            source=source, provider=provider, billing_kind=BillingKind.SUBSCRIPTION_WINDOW, windows=[window]
+        )
+
+    full_at = utcnow() - timedelta(minutes=5)
+    save_snapshot(Snapshot(collected_at=full_at, accounts=[account("clinepass", 40), account("codex", 10)]), [])
+    for minutes, used in ((2, 44), (4, 47)):
+        burst = Snapshot(collected_at=full_at + timedelta(minutes=minutes), accounts=[account("clinepass", used)])
+        save_snapshot(burst, [], partial_providers=["clinepass"])
+    # A burst reading older than the full snapshot must not roll it back.
+    stale = Snapshot(collected_at=full_at - timedelta(minutes=3), accounts=[account("codex", 1)])
+    save_snapshot(stale, [], partial_providers=["codex"])
+
+    monkeypatch.setattr("aiuse.watch.run_collectors", lambda _c: pytest.fail("must not collect"))
+    seen: list[Snapshot] = []
+    monkeypatch.setattr("aiuse.watch.analyze_use_or_lose", lambda snap, _c: seen.append(snap) or [])
+    monkeypatch.setattr("aiuse.watch.maybe_local_runtime_alerts", lambda *_a, **_k: [])
+    snapshot, _alerts = collect_watch_frame({"analysis": {"persist_snapshots": True}}, max_age=600)
+    used = {a.provider: a.windows[0].used_percent for a in snapshot.accounts}
+    assert used == {"clinepass": 47, "codex": 10}
+    assert seen == [snapshot], "alerts are re-derived from the overlaid readings"
+
+
+def test_format_clock_is_twelve_hour_without_leading_zeros():
+    from datetime import datetime
+
+    from aiuse.report import format_clock
+
+    evening = datetime(2026, 10, 3, 21, 2, 7).astimezone()
+    assert format_clock(evening) == "9:02pm"
+    assert format_clock(evening, seconds=True) == "9:02:07pm"
+    assert format_clock(evening, date=True) == "Sat Oct 3 9:02pm"
+    assert format_clock(datetime(2026, 10, 3, 0, 5).astimezone()) == "12:05am"
+    assert format_clock(datetime(2026, 10, 3, 12, 0).astimezone()) == "12:00pm"
+
+
+def test_board_footer_is_centered_under_the_table():
+    from aiuse.watch import render_watch_board
+
+    rows = render_watch_board(_snap(), [], color=False).splitlines()
+    width = max(len(r) for r in rows[: rows.index(next(r for r in rows if "Collected at" in r))] if "watch" not in r)
+    meta = next(r for r in rows if "Collected at" in r)
+    left = len(meta) - len(meta.lstrip())
+    assert left == max(0, (width - len(meta.strip())) // 2)
+    assert "am ·" in meta or "pm ·" in meta