@ikon85/agent-workflow-kit 0.27.1 → 0.29.0

package/scripts/marker_lib.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""Shared exact-value HTML marker lookup for issue identity."""
+
+from __future__ import annotations
+
+import json
+import re
+from collections.abc import Callable
+
+
+MARKER_KINDS = frozenset({
+    "prd-source-id",
+    "program-leaf-source",
+    "program-stub-source",
+    "wave-stub-source",
+})
+
+
+class UnknownMarkerKind(ValueError):
+    """Raised when a caller requests a marker outside the public grammar."""
+
+
+def marker_value(body: str, kind: str) -> str | None:
+    """Return one allowlisted marker value from a body, trimmed exactly once."""
+    if kind not in MARKER_KINDS:
+        raise UnknownMarkerKind(f"unknown marker kind: {kind}")
+    match = re.search(rf"<!--\s*{re.escape(kind)}:\s*([^>]+?)\s*-->", body)
+    return match.group(1).strip() if match else None
+
+
+def first_marker(body: str, kinds: tuple[str, ...]) -> tuple[str, str] | None:
+    """Return the first body-ordered marker among validated allowlisted kinds."""
+    unknown = next((kind for kind in kinds if kind not in MARKER_KINDS), None)
+    if unknown:
+        raise UnknownMarkerKind(f"unknown marker kind: {unknown}")
+    alternatives = "|".join(re.escape(kind) for kind in kinds)
+    match = re.search(rf"<!--\s*({alternatives}):\s*([^>]+?)\s*-->", body)
+    return (match.group(1), match.group(2).strip()) if match else None
+
+
+def _issues_from_pages(raw: str) -> list[dict]:
+    pages = json.loads(raw)
+    if not pages:
+        return []
+    if isinstance(pages[0], dict):
+        return pages
+    return [issue for page in pages for issue in page]
+
+
+def marker_verdict(issues: list[dict]) -> str:
+    """Map exact identity matches onto the four-way consumer decision."""
+    if not issues:
+        return "create"
+    if len(issues) > 1:
+        return "STOP"
+    return "update" if issues[0]["state"] == "open" else "user-decision"
+
+
+def find_by_marker(repo: str, kind: str, slug: str,
+                   gh: Callable[[list[str]], str]) -> dict:
+    """Scan every issue state and return exact marker matches plus a verdict."""
+    marker_value("", kind)  # validate before making a network call
+    raw = gh([
+        "api", "--paginate", "--slurp", "--method", "GET",
+        f"repos/{repo}/issues", "-f", "state=all", "-f", "per_page=100",
+    ])
+    matches = [
+        {"number": issue["number"], "state": issue["state"]}
+        for issue in _issues_from_pages(raw)
+        if "pull_request" not in issue
+        and marker_value(issue.get("body") or "", kind) == slug
+    ]
+    return {
+        "count": len(matches),
+        "issues": matches,
+        "verdict": marker_verdict(matches),
+    }
+
+
+def reconcile_after_create(repo: str, kind: str, slug: str,
+                           created_number: int,
+                           gh: Callable[[list[str]], str]) -> dict:
+    """Re-scan after create and fail closed unless that open issue is unique."""
+    result = find_by_marker(repo, kind, slug, gh)
+    expected = [{"number": created_number, "state": "open"}]
+    if result["issues"] != expected:
+        result["verdict"] = "STOP"
+    return result

package/scripts/pr-body-check.py

@@ -4,7 +4,7 @@ pr-body-check.py — mechanical guard for the PR-body conventions that were unti
 now prose-only.
 
 Called by `wrapup` Step 0c AFTER the PR has been created/reused, BEFORE the
-merge gate. Turns three instruction-only rules into a check that actually fires:
+merge gate. Turns four instruction-only rules into a check that actually fires:
 
   1. Anker-Slice (Issue HAS a parent) → body MUST contain `Part of #<parent>`
      and MUST NOT contain a close-keyword on the **parent anchor** number
@@ -16,9 +16,12 @@ merge gate. Turns three instruction-only rules into a check that actually fires:
      auto-close never fires, wrapup Step 5b lesson).
   3. `**Retro:**`-Pflichtzeile present in one of the Slice-7 forms
      (`gefahren …` | `übersprungen …`), with a space after the marker.
+  4. Exactly one valid `E2E-NA: <reason>` trailer in the immutable pull-request
+     range requires active `E2E: n/a — <reason>` PR-body evidence.
 
-Scope: this script checks ONLY the closes/Part-of anchor rule and the
-`**Retro:**` line. It does NOT parse or validate `annahme-drift` markers
+Scope: this script checks ONLY the closes/Part-of anchor rule, the
+`**Retro:**` line, and E2E exemption evidence. It does NOT parse or validate
+`annahme-drift` markers
 (those are prose-/judgment-driven in wrapup Step 0c + 5e, deliberately not
 mechanised — R2-F6). The annahme-drift block therefore runs BEFORE this
 check in wrapup Step 0c so the body the script sees is final.
@@ -34,7 +37,7 @@ thin shell. NOT a hook — `wrapup` invokes it (Design).
 
 Usage:
   pr-body-check.py [--branch <name>] [--issue <n>] [--parent <n>|FREI]
-                   [--body-file <path>]
+                   [--body-file <path>] [--base-sha <sha>] [--head-sha <sha>]
 All flags optional; unset → derived from the current branch + live PR via gh.
 
 Audit log: .claude/logs/pr-body-check.log
@@ -47,6 +50,11 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 from board_config import ConfigError, load_board_config  # noqa: E402
+from pr_body_e2e import (  # noqa: E402
+    check_e2e_na_line,
+    fetch_has_e2e_na_trailer,
+    fetch_pr_range,
+)
 
 try:
     _CFG = load_board_config()
@@ -122,7 +130,8 @@ def _part_of(body: str, n: int) -> bool:
         rf"\b{PART_OF_RE_SRC}(?::\s*|\s+)#0*{n}(?!\d)", body or "", re.IGNORECASE))
 
 
-def check_pr_body(body: str, issue: int, parent, is_anchor: bool = False):
+def check_pr_body(body: str, issue: int, parent, is_anchor: bool = False,
+                  has_e2e_na_trailer: bool = False):
     """Return a list of violation strings ([] = green).
 
     parent is the anchor issue number, or None for an atomar Leaf.
@@ -165,6 +174,7 @@ def check_pr_body(body: str, issue: int, parent, is_anchor: bool = False):
             "Pflichtzeile `**Retro:** gefahren — …` oder "
             "`**Retro:** übersprungen — <Grund>` fehlt.")
 
+    violations.extend(check_e2e_na_line(body, has_e2e_na_trailer))
     return violations
 
 
@@ -207,12 +217,23 @@ def fetch_is_anchor(number: int) -> bool:
     return "type:cluster" in out.splitlines()
 
 
+def resolve_has_e2e_na(args, branch: str) -> bool:
+    """Explicit test overrides win; otherwise use immutable GitHub PR SHAs."""
+    if args.base_sha or args.head_sha:
+        base_sha, head_sha = args.base_sha, args.head_sha
+    else:
+        base_sha, head_sha = fetch_pr_range(branch)
+    return fetch_has_e2e_na_trailer(base_sha, head_sha)
+
+
 def main() -> int:
     ap = argparse.ArgumentParser(description=__doc__.splitlines()[1])
     ap.add_argument("--branch", help="default: current git branch")
     ap.add_argument("--issue", type=int, help="override branch-derived issue #")
     ap.add_argument("--parent", help="override parent (number or FREI)")
     ap.add_argument("--body-file", help="read PR body from file instead of gh")
+    ap.add_argument("--base-sha", help="override immutable PR base SHA")
+    ap.add_argument("--head-sha", help="override immutable PR head SHA")
     args = ap.parse_args()
 
     branch = args.branch or current_branch()
@@ -244,7 +265,14 @@ def main() -> int:
         parent = fetch_parent(issue)
 
     is_anchor = fetch_is_anchor(issue) if parent is None else False
-    violations = check_pr_body(body, issue, parent, is_anchor=is_anchor)
+    has_e2e_na = resolve_has_e2e_na(args, branch)
+    violations = check_pr_body(
+        body,
+        issue,
+        parent,
+        is_anchor=is_anchor,
+        has_e2e_na_trailer=has_e2e_na,
+    )
     kind = ("Anker-Slice" if parent is not None
             else "Wave-PR" if is_anchor else "Leaf")
     log(f"branch={branch} issue={issue} parent={parent} kind={kind} "

package/scripts/pr_body_e2e.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+"""Couple a valid E2E-NA trailer to active PR-body evidence."""
+from __future__ import annotations
+
+import json
+import re
+import subprocess
+
+
+E2E_NA_LINE_RE = re.compile(
+    r"^E2E:\s*n/a\s*—\s*\S", re.IGNORECASE | re.MULTILINE
+)
+
+
+def _run(cmd: list[str], timeout=15):
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
+        return result.returncode, result.stdout.strip()
+    except Exception:
+        return -1, ""
+
+
+def check_e2e_na_line(body: str, has_e2e_na_trailer: bool) -> list[str]:
+    """Require non-empty body evidence only when a valid trailer exists."""
+    if not has_e2e_na_trailer or E2E_NA_LINE_RE.search(body or ""):
+        return []
+    return [
+        "E2E-NA trailer found in the pull-request range, but required "
+        "`E2E: n/a — <reason>` evidence is missing from the PR body."
+    ]
+
+
+def _git(args: list[str], cwd=None) -> str:
+    result = subprocess.run(
+        ["git", *args], cwd=cwd, capture_output=True, text=True, timeout=15
+    )
+    if result.returncode != 0:
+        raise RuntimeError(result.stderr.strip())
+    return result.stdout
+
+
+def _collect_e2e_na_trailers(base_sha: str, head_sha: str, cwd=None) -> list[str]:
+    raw = _git(
+        [
+            "log",
+            f"{base_sha}..{head_sha}",
+            "--format=%x00%(trailers:key=E2E-NA,unfold)",
+        ],
+        cwd=cwd,
+    )
+    values = []
+    for chunk in raw.split("\x00"):
+        for line in chunk.splitlines():
+            if line.startswith("E2E-NA:"):
+                values.append(line.removeprefix("E2E-NA:").strip())
+    return values
+
+
+def fetch_has_e2e_na_trailer(base_sha, head_sha, cwd=None) -> bool:
+    """Return true for exactly one non-empty trailer; unreadable ranges are false."""
+    if not base_sha or not head_sha:
+        return False
+    try:
+        values = _collect_e2e_na_trailers(base_sha, head_sha, cwd=cwd)
+    except Exception:
+        return False
+    return len(values) == 1 and bool(values[0].strip())
+
+
+def fetch_pr_range(branch: str):
+    """Return GitHub's immutable PR base/head SHAs, or an unreadable range."""
+    rc, out = _run(
+        ["gh", "pr", "view", branch, "--json", "baseRefOid,headRefOid"]
+    )
+    if rc != 0 or not out:
+        return None, None
+    try:
+        data = json.loads(out)
+    except (json.JSONDecodeError, TypeError):
+        return None, None
+    if not isinstance(data, dict):
+        return None, None
+    return data.get("baseRefOid"), data.get("headRefOid")

package/scripts/render-anchor.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+"""Pure rendering for a lean Tier-2 anchor and its full PRD archive."""
+
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from pathlib import Path
+from typing import NamedTuple
+
+from marker_lib import marker_value
+
+
+PLAN_REVISION_RE = re.compile(
+    r"^\s*\*\*plan_revision:\*\*\s*(r\d+)\s*$"
+)
+PLAN_REVISION_LOOKALIKE_RE = re.compile(r"^\s*\*\*plan_revision:\*\*.*$")
+HTML_MARKER_RE = re.compile(
+    r"^\s*<!--\s*(prd-source-id|prd-content-fp|prd):\s*([^>\r\n]+?)\s*-->\s*$"
+)
+HTML_COMMENT_RE = re.compile(r"^\s*<!--.*-->\s*$")
+
+
+class RenderedDocuments(NamedTuple):
+    """The two byte-stable documents produced by one render."""
+
+    anchor_body: str
+    archive_body: str
+
+
+def _canonical_marker(line: str) -> tuple[str, str] | None:
+    revision = PLAN_REVISION_RE.fullmatch(line)
+    if revision:
+        return ("plan_revision", revision.group(1))
+    marker = HTML_MARKER_RE.fullmatch(line)
+    if not marker:
+        return None
+    kind = marker.group(1)
+    if kind == "prd-source-id":
+        value = marker_value(line, kind)
+        return (kind, value) if value is not None else None
+    return (kind, "")
+
+
+def _strip_head_markers(source: str) -> tuple[list[str], str]:
+    revisions: list[str] = []
+    end = 0
+    kept: list[str] = []
+    for line in source.splitlines(keepends=True):
+        bare = line.rstrip("\r\n")
+        marker = _canonical_marker(bare)
+        if (
+            not bare.strip()
+            or marker
+            or HTML_COMMENT_RE.fullmatch(bare)
+            or PLAN_REVISION_LOOKALIKE_RE.fullmatch(bare)
+        ):
+            end += len(line)
+            if marker:
+                if marker[0] == "plan_revision":
+                    revisions.append(marker[1])
+            else:
+                kept.append(line)
+            continue
+        break
+    if not any(line.strip() for line in kept):
+        kept = []
+    while kept and not kept[0].strip():
+        kept.pop(0)
+    return revisions, "".join(kept) + source[end:]
+
+
+def render_documents(anchor_template: str, prd_body: str) -> RenderedDocuments:
+    """Return the filled anchor template and marker-free PRD archive."""
+    revisions, archive_source = _strip_head_markers(prd_body)
+    if len(revisions) != 1:
+        raise ValueError("source PRD head must have exactly one canonical plan_revision")
+    revision = revisions[0]
+    archive_header = (
+        f"📄 Full PRD (archive, {revision}) — "
+        "the body carries navigation/decisions only\n\n"
+    )
+    return RenderedDocuments(anchor_template, archive_header + archive_source)
+
+
+def _parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Render one filled Tier-2 anchor or its marker-free PRD archive."
+    )
+    parser.add_argument("--template", type=Path, required=True)
+    parser.add_argument("--prd", type=Path, required=True)
+    parser.add_argument("--document", choices=("anchor", "archive"), required=True)
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _parse_args(argv)
+    rendered = render_documents(
+        args.template.read_bytes().decode("utf-8"),
+        args.prd.read_bytes().decode("utf-8"),
+    )
+    output = (
+        rendered.anchor_body if args.document == "anchor" else rendered.archive_body
+    )
+    sys.stdout.buffer.write(output.encode("utf-8"))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/test_board_sync.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+"""Behavior tests for bounded board operations; the fake seam never calls GitHub."""
+
+from __future__ import annotations
+
+import io
+import json
+import subprocess
+import unittest
+from contextlib import redirect_stderr, redirect_stdout
+from unittest.mock import patch
+
+import importlib.util
+from pathlib import Path
+
+
+SPEC = importlib.util.spec_from_file_location(
+    "board_sync_operations_test", Path(__file__).with_name("board-sync.py"))
+bs = importlib.util.module_from_spec(SPEC)
+assert SPEC.loader is not None
+SPEC.loader.exec_module(bs)
+
+
+class FakeGh:
+    def __init__(self, responses=None, failures=None):
+        self.responses = responses or {}
+        self.failures = failures or {}
+        self.calls = []
+
+    def __call__(self, args):
+        self.calls.append(args)
+        joined = " ".join(args)
+        for needle, body in self.failures.items():
+            if needle in joined:
+                error = bs.GhError("injected failure")
+                error.stdout = body
+                raise error
+        for needle, body in self.responses.items():
+            if needle in joined:
+                return body
+        return ""
+
+
+def run(fake, argv):
+    old = bs._gh
+    bs._gh = fake
+    out = io.StringIO()
+    try:
+        with redirect_stdout(out):
+            code = bs.main(argv)
+    finally:
+        bs._gh = old
+    return code, out.getvalue()
+
+
+class BoundedCalls(unittest.TestCase):
+    def test_full_board_and_ordinary_calls_have_distinct_clear_timeouts(self):
+        with patch.object(bs.subprocess, "run", side_effect=subprocess.TimeoutExpired("gh", 1)) as call:
+            with self.assertRaisesRegex(bs.GhError, "15s"):
+                bs._gh(["issue", "view", "1"])
+            self.assertEqual(call.call_args.kwargs["timeout"], 15)
+            with self.assertRaisesRegex(bs.GhError, "60s"):
+                bs._gh(["project", "item-list", "3"])
+            self.assertEqual(call.call_args.kwargs["timeout"], 60)
+
+    def test_partial_create_prints_issue_and_replay_safe_repair(self):
+        fake = FakeGh(
+            {"issue list": "[]", "issue create": "https://github.com/x/y/issues/17\n"},
+            {"project item-add": ""},
+        )
+        with patch.object(bs, "REPO", "x/y"):
+            with self.subTest("created issue remains visible"):
+                from tempfile import NamedTemporaryFile
+                with NamedTemporaryFile("w") as body:
+                    body.write("<!-- program-leaf-source: p/1 -->\n")
+                    body.flush()
+                    code, out = run(fake, ["create", "--title", "S", "--body-file", body.name])
+        self.assertEqual(code, 1)
+        self.assertIn("#17 https://github.com/x/y/issues/17", out)
+        self.assertIn("board-sync.py add --issue 17", out)
+        self.assertIn("idempotent", out)
+
+
+class WaveLookup(unittest.TestCase):
+    def test_search_finds_next_wave_without_full_scan(self):
+        fake = FakeGh({"search/issues": json.dumps({"items": [
+            {"title": f"{bs.WAVE_TITLE_PREFIX} 7 — Anchor"},
+            {"title": f"{bs.WAVE_TITLE_PREFIX} 8 / Slice 1 — Leaf"},
+        ]})})
+        code, out = run(fake, ["next-wave"])
+        self.assertEqual((code, out.strip()), (0, "9"))
+        self.assertFalse(any("item-list" in " ".join(c) for c in fake.calls))
+
+    def test_empty_search_falls_back_and_scan_skips_search(self):
+        fake = FakeGh({"search/issues": '{"items":[]}', "item-list": '{"items":[{"wave":4}]}'})
+        with redirect_stderr(io.StringIO()):
+            self.assertEqual(run(fake, ["next-wave"])[1].strip(), "5")
+        scan = FakeGh({"item-list": '{"items":[{"wave":9}]}'})
+        self.assertEqual(run(scan, ["next-wave", "--scan"])[1].strip(), "10")
+        self.assertFalse(any("search/issues" in " ".join(c) for c in scan.calls))
+
+    def test_promotion_refuses_foreign_anchor_but_allows_same_issue(self):
+        foreign = {"items": [{"number": 22, "title": f"{bs.WAVE_TITLE_PREFIX} 7 — Other"}]}
+        message = bs.wave_collision_guard(foreign, 7, 21)
+        self.assertIn("#22", message)
+        self.assertIn("next-wave", message)
+        self.assertIsNone(bs.wave_collision_guard(foreign, 7, 22))
+        leaf = {"items": [{"number": 23, "title": f"{bs.WAVE_TITLE_PREFIX} 7 / Slice 1 — X"}]}
+        self.assertIsNone(bs.wave_collision_guard(leaf, 7, 21))
+
+    def test_promote_collision_fails_before_any_write(self):
+        fake = FakeGh({
+            "--json labels": "",
+            "--json body": "Draft PRD\n",
+            "graphql": '{"data":{"repository":{"issue":{"projectItems":{"nodes":[]}}}}}',
+            "search/issues": json.dumps({"items": [
+                {"number": 22, "title": f"{bs.WAVE_TITLE_PREFIX} 7 — Other"},
+            ]}),
+        })
+        error = io.StringIO()
+        with redirect_stderr(error):
+            code, _ = run(fake, ["promote", "--issue", "21", "--wave", "7"])
+        self.assertEqual(code, 1)
+        self.assertIn("#22", error.getvalue())
+        self.assertFalse(any(c[:2] == ["issue", "edit"] for c in fake.calls))
+
+
+class TargetedLookup(unittest.TestCase):
+    @staticmethod
+    def payload(project):
+        return {"data": {"repository": {"issue": {"projectItems": {"nodes": [{
+            "id": "PVTI_x", "project": {"id": project}, "fieldValues": {"nodes": [
+                {"number": 7, "field": {"id": bs.WAVE_FIELD_ID}},
+                {"name": "Spec", "field": {"id": bs.STATUS_FIELD_ID}},
+            ]},
+        }]}}}}}
+
+    def test_item_of_returns_configured_fields(self):
+        fake = FakeGh({"graphql": json.dumps(self.payload(bs.PROJECT_NODE_ID))})
+        code, out = run(fake, ["item-of", "--issue", "21"])
+        self.assertEqual(code, 0)
+        self.assertEqual(json.loads(out), {"itemId": "PVTI_x", "wave": 7,
+                                           "status": "Spec", "cluster": None})
+
+    def test_item_of_fails_clearly_when_absent(self):
+        payload = {"data": {"repository": {"issue": {"projectItems": {"nodes": []}}}}}
+        code, out = run(FakeGh({"graphql": json.dumps(payload)}),
+                        ["item-of", "--issue", "99"])
+        self.assertEqual((code, out.strip()), (1, "NOT-ON-BOARD"))
+
+
+class ArchiveDone(unittest.TestCase):
+    def item_payload(self, count=1):
+        items = [{"id": f"D{i}", "status": bs.STATUS_ROLES["done"]} for i in range(count)]
+        items += [{"id": "OPEN", "status": bs.STATUS_ROLES["inProgress"]},
+                  {"id": "OLD", "status": bs.STATUS_ROLES["done"], "archived": True}]
+        return json.dumps({"items": items, "totalCount": len(items)})
+
+    def test_archive_defaults_to_dry_run_and_selects_only_active_done(self):
+        fake = FakeGh({"item-list": self.item_payload()})
+        code, out = run(fake, ["archive-done"])
+        self.assertEqual(code, 0)
+        self.assertIn("D0", out)
+        self.assertNotIn("OPEN", out)
+        self.assertNotIn("OLD", out)
+        self.assertFalse(any("archiveProjectV2Item" in " ".join(c) for c in fake.calls))
+
+    def test_apply_batches_at_thirty(self):
+        class BatchGh(FakeGh):
+            def __call__(self, args):
+                self.calls.append(args)
+                if "item-list" in args:
+                    return self.responses["item-list"]
+                count = " ".join(args).count("archiveProjectV2Item")
+                return json.dumps({"data": {f"a{i}": {"item": {"id": f"x{i}"}}
+                                             for i in range(count)}})
+        fake = BatchGh({"item-list": self.item_payload(31)})
+        code, out = run(fake, ["archive-done", "--apply"])
+        self.assertEqual(code, 0)
+        self.assertIn("31 of 31", out)
+        calls = [c for c in fake.calls if "archiveProjectV2Item" in " ".join(c)]
+        self.assertEqual([" ".join(c).count("archiveProjectV2Item") for c in calls], [30, 1])
+
+    def test_truncated_input_refuses_without_mutation(self):
+        fake = FakeGh({"item-list": '{"items":[{"id":"D","status":"Done"}],"totalCount":2}'})
+        err = io.StringIO()
+        with redirect_stderr(err):
+            code, _ = run(fake, ["archive-done", "--apply"])
+        self.assertEqual(code, 1)
+        self.assertIn("partial archive", err.getvalue())
+        self.assertFalse(any("archiveProjectV2Item" in " ".join(c) for c in fake.calls))
+
+    def test_apply_reports_partial_failure_and_empty_replay_is_idempotent(self):
+        body = json.dumps({"data": {"a0": {"item": {"id": "D0"}}, "a1": None},
+                           "errors": [{"path": ["a1"], "message": "already archived"}]})
+        fake = FakeGh({"item-list": self.item_payload(2)}, {"archiveProjectV2Item": body})
+        code, out = run(fake, ["archive-done", "--apply"])
+        self.assertEqual(code, 1)
+        self.assertIn("1 of 2", out)
+        self.assertIn("D1: already archived", out)
+        empty = FakeGh({"item-list": json.dumps({"items": [], "totalCount": 0})})
+        code, out = run(empty, ["archive-done", "--apply"])
+        self.assertEqual(code, 0)
+        self.assertIn("nothing to archive", out)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)