docassert 0.8.1__tar.gz → 0.10.0__tar.gz

{docassert-0.8.1/docassert.egg-info → docassert-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docassert
-Version: 0.8.1
+Version: 0.10.0
 Summary: Unit testing for business documents — validate structured Markdown docs against a configurable audit standard.
 Author: C4G Enterprises Inc.
 License: Apache-2.0

{docassert-0.8.1 → docassert-0.10.0}/docassert/__init__.py

@@ -5,4 +5,4 @@ standard: deterministic structural checks that gate a merge, plus optional
 AI-graded semantic checks that advise.
 """
 
-__version__ = "0.8.1"
+__version__ = "0.10.0"

docassert-0.10.0/docassert/bridge/board.py

@@ -0,0 +1,126 @@
+"""Projects v2 board operations (require a token with the `project` scope).
+
+The board is a *view* over the bridge-managed issues: every Feature and Story
+issue becomes a project item carrying Type, Doc, and PMO Project fields. All
+mutations are idempotent: re-adding an existing item returns it, and field
+writes converge on the same values.
+"""
+from __future__ import annotations
+
+from .gh import GhRunner
+
+FIELD_SPECS: dict[str, dict] = {
+    "Type": {"dataType": "SINGLE_SELECT", "options": ["Feature", "Story"]},
+    "Doc": {"dataType": "TEXT"},
+    "PMO Project": {"dataType": "TEXT"},
+}
+
+_FIELDS_QUERY = """
+query($owner: String!, $number: Int!) {
+  user(login: $owner) {
+    projectV2(number: $number) {
+      id
+      title
+      fields(first: 30) {
+        nodes {
+          ... on ProjectV2FieldCommon { id name dataType }
+          ... on ProjectV2SingleSelectField { id name dataType options { id name } }
+        }
+      }
+    }
+  }
+}
+"""
+
+
+def create_project(gh: GhRunner, title: str) -> dict:
+    viewer = gh.graphql("query { viewer { id login } }")["viewer"]
+    data = gh.graphql(
+        """
+        mutation($owner: ID!, $title: String!) {
+          createProjectV2(input: {ownerId: $owner, title: $title}) {
+            projectV2 { id number title }
+          }
+        }
+        """,
+        owner=viewer["id"], title=title)
+    return data["createProjectV2"]["projectV2"]
+
+
+def get_project(gh: GhRunner, owner: str, number: int) -> dict:
+    proj = gh.graphql(_FIELDS_QUERY, owner=owner, number=number)["user"]["projectV2"]
+    fields = {}
+    for node in proj["fields"]["nodes"]:
+        if not node:
+            continue
+        fields[node["name"]] = {
+            "id": node["id"],
+            "dataType": node.get("dataType"),
+            "options": {o["name"]: o["id"] for o in node.get("options", [])},
+        }
+    return {"id": proj["id"], "title": proj["title"], "fields": fields}
+
+
+def ensure_fields(gh: GhRunner, owner: str, number: int) -> dict:
+    """Create any missing bridge fields, then return the refreshed project."""
+    project = get_project(gh, owner, number)
+    for name, spec in FIELD_SPECS.items():
+        if name in project["fields"]:
+            continue
+        if spec["dataType"] == "SINGLE_SELECT":
+            opts = ", ".join(
+                f'{{name: "{o}", color: GRAY, description: ""}}'
+                for o in spec["options"])
+            gh.graphql(
+                "mutation($p: ID!, $n: String!) { createProjectV2Field(input: {"
+                "projectId: $p, dataType: SINGLE_SELECT, name: $n, "
+                f"singleSelectOptions: [{opts}]"
+                "}) { projectV2Field { ... on ProjectV2FieldCommon { id } } } }",
+                p=project["id"], n=name)
+        else:
+            gh.graphql(
+                "mutation($p: ID!, $n: String!) { createProjectV2Field(input: {"
+                "projectId: $p, dataType: TEXT, name: $n"
+                "}) { projectV2Field { ... on ProjectV2FieldCommon { id } } } }",
+                p=project["id"], n=name)
+    return get_project(gh, owner, number)
+
+
+def add_item(gh: GhRunner, project_id: str, content_id: str) -> str:
+    data = gh.graphql(
+        "mutation($p: ID!, $c: ID!) { addProjectV2ItemById(input: {"
+        "projectId: $p, contentId: $c}) { item { id } } }",
+        p=project_id, c=content_id)
+    return data["addProjectV2ItemById"]["item"]["id"]
+
+
+def set_text(gh: GhRunner, project_id: str, item_id: str, field_id: str,
+             value: str) -> None:
+    gh.graphql(
+        "mutation($p: ID!, $i: ID!, $f: ID!, $v: String!) {"
+        "updateProjectV2ItemFieldValue(input: {projectId: $p, itemId: $i, "
+        "fieldId: $f, value: {text: $v}}) { projectV2Item { id } } }",
+        p=project_id, i=item_id, f=field_id, v=value)
+
+
+def set_option(gh: GhRunner, project_id: str, item_id: str, field_id: str,
+               option_id: str) -> None:
+    gh.graphql(
+        "mutation($p: ID!, $i: ID!, $f: ID!, $o: String!) {"
+        "updateProjectV2ItemFieldValue(input: {projectId: $p, itemId: $i, "
+        "fieldId: $f, value: {singleSelectOptionId: $o}}) "
+        "{ projectV2Item { id } } }",
+        p=project_id, i=item_id, f=field_id, o=option_id)
+
+
+def sync_items(gh: GhRunner, project: dict, entries: list[dict]) -> int:
+    """entries: [{node_id, doc_id, type ('Feature'|'Story'), pmo_project}]."""
+    f = project["fields"]
+    type_field, doc_field, pmo_field = f["Type"], f["Doc"], f["PMO Project"]
+    for e in entries:
+        item = add_item(gh, project["id"], e["node_id"])
+        set_option(gh, project["id"], item, type_field["id"],
+                   type_field["options"][e["type"]])
+        set_text(gh, project["id"], item, doc_field["id"], e["doc_id"])
+        set_text(gh, project["id"], item, pmo_field["id"], e["pmo_project"])
+    return len(entries)

{docassert-0.8.1 → docassert-0.10.0}/docassert/bridge/gh.py

@@ -15,11 +15,22 @@ class GhError(RuntimeError):
 
 
 class GhRunner:
-    """Executes gh commands. Tests substitute a fake with the same interface."""
+    """Executes gh commands. Tests substitute a fake with the same interface.
+
+    `token` overrides GH_TOKEN for this runner only, so board operations can
+    use the project-scoped credential while issue operations keep the
+    default one.
+    """
+
+    def __init__(self, token: str | None = None) -> None:
+        self._env: dict[str, str] | None = None
+        if token:
+            import os
+            self._env = dict(os.environ, GH_TOKEN=token)
 
     def run(self, args: list[str], input_: str | None = None) -> str:
         proc = subprocess.run(["gh", *args], capture_output=True, text=True,
-                              input=input_)
+                              input=input_, env=self._env)
         if proc.returncode != 0:
             raise GhError(proc.stderr.strip() or f"gh {' '.join(args)} failed")
         return proc.stdout
@@ -44,7 +55,8 @@ class DryRunner(GhRunner):
 
     MUTATING = ("-X POST", "-X PATCH", "-X PUT", "-X DELETE", "mutation")
 
-    def __init__(self) -> None:
+    def __init__(self, token: str | None = None) -> None:
+        super().__init__(token)
         self.planned: list[str] = []
 
     def run(self, args: list[str], input_: str | None = None) -> str:

{docassert-0.8.1 → docassert-0.10.0}/docassert/bridge/ops.py

@@ -46,8 +46,14 @@ def _index(issues: list[dict]) -> dict[str, dict]:
 
 
 def scaffold(plan: BridgePlan, gh: G.GhRunner, repo: str,
-             docs_url: str | None = None) -> list[str]:
-    """Make the repo's issues match the plan. Returns human-readable actions."""
+             docs_url: str | None = None,
+             board_cfg: dict | None = None) -> list[str]:
+    """Make the repo's issues match the plan. Returns human-readable actions.
+
+    board_cfg (optional): {"gh": GhRunner with project scope, "owner": login,
+    "number": int, "init": bool} — mirrors every managed issue onto the
+    Projects v2 board with Type/Doc/PMO Project fields.
+    """
     actions: list[str] = []
     for name, (color, desc) in LABELS.items():
         G.ensure_label(gh, repo, name, color, desc)
@@ -80,6 +86,28 @@ def scaffold(plan: BridgePlan, gh: G.GhRunner, repo: str,
             if pnode and cnode:
                 G.add_sub_issue(gh, pnode, cnode)
 
+    if board_cfg:
+        from . import board as B
+        bgh = board_cfg["gh"]
+        if board_cfg.get("init"):
+            project = B.ensure_fields(bgh, board_cfg["owner"], board_cfg["number"])
+            actions.append(f"board: fields ensured on '{project['title']}'")
+        else:
+            project = B.get_project(bgh, board_cfg["owner"], board_cfg["number"])
+        entries = []
+        for f in plan.features:
+            issue = by_key.get(f.id)
+            if issue and issue.get("node_id"):
+                entries.append({"node_id": issue["node_id"], "doc_id": f.id,
+                                "type": "Feature", "pmo_project": f.project})
+            for s in f.stories:
+                sissue = by_key.get(s.id)
+                if sissue and sissue.get("node_id"):
+                    entries.append({"node_id": sissue["node_id"], "doc_id": s.id,
+                                    "type": "Story", "pmo_project": f.project})
+        n = B.sync_items(bgh, project, entries)
+        actions.append(f"board: {n} item(s) synced to '{project['title']}'")
+
     for sk in plan.skipped:
         actions.append(f"skipped {sk['id']}: {sk['reason']}")
     return actions
@@ -143,9 +171,28 @@ def reconcile(plan: BridgePlan, gh: G.GhRunner, repo: str) -> tuple[list[str], i
 
 
 def status(plan: BridgePlan, gh: G.GhRunner, repo: str) -> dict:
-    """Read-only: delivery progress per feature from issue states."""
-    by_key = _index(G.list_issues(gh, repo))
-    out: dict = {"projects": []}
+    """Read-only: delivery progress per feature, plus scope classification.
+
+    Unlike reconcile, this never labels or comments; it only reports, so it is
+    safe to run from the dashboard build.
+    """
+    issues = G.list_issues(gh, repo)
+    by_key = _index(issues)
+    managed = plan.managed_ids
+    unverified, orphaned = [], []
+    for issue in issues:
+        if issue.get("state") != "open":
+            continue
+        key = _marker_of(issue)
+        if key == SCOPE_REPORT_KEY:
+            continue
+        if key is None:
+            unverified.append({"number": issue["number"], "title": issue["title"]})
+        elif key not in managed:
+            orphaned.append({"number": issue["number"], "title": issue["title"],
+                             "doc": key})
+    out: dict = {"repo": repo, "projects": [],
+                 "scope": {"unverified": unverified, "orphaned": orphaned}}
     for p in plan.projects:
         feats = []
         for f in p["features"]:

{docassert-0.8.1 → docassert-0.10.0}/docassert/cli.py

@@ -232,9 +232,19 @@ def cmd_pages(args: argparse.Namespace) -> int:
         status_mod.render_badge_json(index["overall"]["rag"]))
     (out / "badges").mkdir(exist_ok=True)
 
+    execution = {}
+    if getattr(args, "execution", None):
+        import json as _json
+        data = _json.loads(Path(args.execution).read_text())
+        for proj in data.get("projects", []):
+            execution[proj["id"]] = {**proj, "scope": data.get("scope"),
+                                     "repo": data.get("repo")}
+
     plist = projects_mod.load_projects(docs_dir)
     for p in plist:
         model = status_mod.build_status(docs_dir, project=p["id"])
+        if p["id"] in execution:
+            model["execution"] = execution[p["id"]]
         (out / f"{p['id']}.html").write_text(status_mod.render_html(model))
         (out / "badges" / f"{p['id']}.json").write_text(
             status_mod.render_badge_json(model["rag"], label=p["code"].lower()))
@@ -300,8 +310,31 @@ def cmd_bridge(args: argparse.Namespace) -> int:
     plan = build_bridge_plan(args.documents_dir)
     gh = ghmod.DryRunner() if getattr(args, "dry_run", False) else ghmod.GhRunner()
 
+    if args.action == "create-board":
+        from .bridge import board as board_mod
+        token = os.environ.get(args.board_token_env, "")
+        if not token and not getattr(args, "dry_run", False):
+            print(f"docassert bridge: no token in ${args.board_token_env}", file=sys.stderr)
+            return 2
+        bgh = gh if isinstance(gh, ghmod.DryRunner) else ghmod.GhRunner(token=token)
+        proj = board_mod.create_project(bgh, args.title or "PMO board")
+        print(f"docassert bridge: created project #{proj.get('number')} '{proj.get('title')}'")
+        return 0
+
+    board_cfg = None
+    if args.project_number:
+        token = os.environ.get(args.board_token_env, "")
+        if not token and not getattr(args, "dry_run", False):
+            print(f"docassert bridge: no token in ${args.board_token_env} "
+                  "(needed for --project-number)", file=sys.stderr)
+            return 2
+        bgh = gh if isinstance(gh, ghmod.DryRunner) else ghmod.GhRunner(token=token)
+        board_cfg = {"gh": bgh, "owner": args.project_owner or args.repo.split("/")[0],
+                     "number": args.project_number, "init": args.init_board}
+
     if args.action == "scaffold":
-        actions = ops.scaffold(plan, gh, args.repo, docs_url=args.docs_url)
+        actions = ops.scaffold(plan, gh, args.repo, docs_url=args.docs_url,
+                               board_cfg=board_cfg)
         for a in actions:
             print(f"docassert bridge: {a}")
         if isinstance(gh, ghmod.DryRunner):
@@ -375,6 +408,7 @@ def main(argv: list[str] | None = None) -> int:
 
     pg = sub.add_parser("pages", help="Build the full Pages site (portfolio index + a page per project).")
     pg.add_argument("--out", default="_site", help="Output directory (default: _site).")
+    pg.add_argument("--execution", help="Optional bridge-status JSON; adds Delivery and Scope panels to project pages.")
     docs_dir_opt(pg)
     pg.set_defaults(func=cmd_pages)
 
@@ -405,13 +439,19 @@ def main(argv: list[str] | None = None) -> int:
 
 
     b = sub.add_parser("bridge", help="Execution bridge: scaffold and police the GitHub board from approved stories.")
-    b.add_argument("action", choices=["scaffold", "reconcile", "status"],
+    b.add_argument("action", choices=["scaffold", "reconcile", "status", "create-board"],
                    help="scaffold: docs -> issues/board · reconcile: police the board · status: delivery figures.")
     b.add_argument("--repo", required=True, help="Target GitHub repo (OWNER/NAME) holding the issues.")
     b.add_argument("--docs-url", help="Base URL of the documents repo, for source links in issue bodies.")
     b.add_argument("--dry-run", action="store_true", help="Print planned mutations without executing them.")
     b.add_argument("--json", action="store_true", help="status: emit JSON.")
     b.add_argument("--out", help="status --json: also write to this path.")
+    b.add_argument("--title", help="create-board: the new project's title.")
+    b.add_argument("--project-owner", help="Board owner login (default: the repo owner).")
+    b.add_argument("--project-number", type=int, help="Projects v2 board number to sync items onto.")
+    b.add_argument("--init-board", action="store_true", help="Ensure the Type/Doc/PMO Project fields exist.")
+    b.add_argument("--board-token-env", default="PROJECTS_TOKEN",
+                   help="Env var holding the project-scoped token (default: PROJECTS_TOKEN).")
     docs_dir_opt(b)
     b.set_defaults(func=cmd_bridge)
 

{docassert-0.8.1 → docassert-0.10.0}/docassert/status/render.py

@@ -205,6 +205,40 @@ def render_html(model) -> str:
                         f'{note}<table><thead><tr><th>Kind</th><th>State</th></tr></thead>'
                         f'<tbody>{req_rows}{sep}{rec_rows}</tbody></table></section>')
 
+    execution_html = ""
+    ex = model.get("execution")
+    if ex:
+        feat_rows: list[str] = []
+        for f in ex.get("features", []):
+            total = f.get("stories_total", 0) or 0
+            done = f.get("stories_closed", 0) or 0
+            pct = (100 * done // total) if total else 0
+            mark = "✓" if f.get("closed") else ""
+            issue = f' · <a href="https://github.com/{esc(ex.get("repo", ""))}/issues/{f["issue"]}">#{f["issue"]}</a>' if f.get("issue") else ""
+            feat_rows.append(
+                f'<div class="sig"><div class="sig-h"><span>{esc(f["id"])} {mark}</span>'
+                f'<span>{done}/{total} stories{issue}</span></div>'
+                f'<div class="bar"><div class="bar-f" style="width:{pct}%;background:var(--ok)"></div></div></div>')
+        overall_t = ex.get("stories_total", 0) or 0
+        overall_d = ex.get("stories_closed", 0) or 0
+        execution_html = (
+            f'<section><h2>Delivery · {overall_d}/{overall_t} stories closed</h2>'
+            '<p style="color:var(--muted);font-size:13px;margin:0 0 10px">'
+            "Read from the bridge-managed issues. Scope lives in these documents; "
+            "delivery lives on the board.</p>" + "".join(feat_rows) + "</section>")
+        scope = ex.get("scope") or {}
+        bad = scope.get("unverified", []) + scope.get("orphaned", [])
+        if bad:
+            items = "".join(
+                f'<li><a href="https://github.com/{esc(ex.get("repo", ""))}/issues/{i["number"]}">#{i["number"]}</a> {esc(i["title"])}</li>'
+                for i in bad)
+            execution_html += (
+                f'<section><h2 style="color:var(--bad)">Scope · {len(bad)} unmatched item(s)</h2>'
+                f'<ul>{items}</ul></section>')
+        else:
+            execution_html += ('<section><h2>Scope</h2><p style="color:var(--ok)">'
+                               "Every open issue matches an approved item in the documents.</p></section>")
+
     title = esc(model.get("title", "Project Status"))
     pid = model.get("project")
     back = '<a class="back" href="index.html">← all projects</a>' if pid else ""
@@ -226,6 +260,7 @@ def render_html(model) -> str:
     {c['approved']} approved{scope} · generated {gen}. Do not edit — regenerated from the documents.</p>
   <section><h2>Traceability coverage</h2>{coverage}</section>
   {document_set}
+  {execution_html}
   {problems}
   <section><h2>Open risks ({len(model['risks'])})</h2><ul>{risks}</ul></section>
   <section><h2>Latest status report</h2><p>{report}</p></section>

{docassert-0.8.1 → docassert-0.10.0/docassert.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docassert
-Version: 0.8.1
+Version: 0.10.0
 Summary: Unit testing for business documents — validate structured Markdown docs against a configurable audit standard.
 Author: C4G Enterprises Inc.
 License: Apache-2.0

{docassert-0.8.1 → docassert-0.10.0}/docassert.egg-info/SOURCES.txt

@@ -90,6 +90,7 @@ docassert/_data/templates/status-report.template.md
 docassert/_data/templates/test-cases.template.md
 docassert/_data/templates/user-story.template.md
 docassert/bridge/__init__.py
+docassert/bridge/board.py
 docassert/bridge/gh.py
 docassert/bridge/ops.py
 docassert/bridge/plan.py

{docassert-0.8.1 → docassert-0.10.0}/tests/test_badge.py

@@ -24,3 +24,25 @@ def test_pages_emits_badges(tmp_path, monkeypatch):
     assert overall["schemaVersion"] == 1 and overall["message"] in {"green", "amber", "red"}
     aur = json.loads((out / "badges" / "PRJ-001-AUR.json").read_text())
     assert aur["label"] == "aur" and aur["message"] in {"green", "amber", "red"}
+
+
+def test_pages_execution_panels(tmp_path, monkeypatch):
+    import json
+    monkeypatch.chdir(ROOT)
+    exec_file = tmp_path / "execution.json"
+    exec_file.write_text(json.dumps({
+        "repo": "o/r",
+        "projects": [{"id": "PRJ-001-AUR",
+                      "features": [{"id": "AUR-PR-014", "issue": 5,
+                                    "stories_total": 2, "stories_closed": 1,
+                                    "closed": False}],
+                      "stories_closed": 1, "stories_total": 2}],
+        "scope": {"unverified": [], "orphaned": []},
+    }))
+    out = tmp_path / "site"
+    assert main(["pages", "--out", str(out), "--execution", str(exec_file)]) == 0
+    html = (out / "PRJ-001-AUR.html").read_text()
+    assert "Delivery · 1/2 stories closed" in html
+    assert "AUR-PR-014" in html and "Every open issue matches" in html
+    other = (out / "PRJ-002-ATL.html").read_text()
+    assert "Delivery ·" not in other   # no execution data, no panel

{docassert-0.8.1 → docassert-0.10.0}/tests/test_bridge.py

@@ -247,3 +247,91 @@ def test_add_sub_issue_still_raises_on_real_errors(tmp_path):
     import pytest
     with pytest.raises(GhError):
         add_sub_issue(BoomGh(), "N1", "N2")
+
+
+# ── board ops ────────────────────────────────────────────────────────────────
+class BoardGh(FakeGh):
+    """GraphQL router for Projects v2 shapes."""
+
+    def __init__(self, existing_fields=()):
+        super().__init__()
+        self.gql: list[str] = []
+        self._fields = list(existing_fields)
+
+    def graphql(self, query, **vars_):
+        self.gql.append(query)
+        if "viewer" in query:
+            return {"viewer": {"id": "U1", "login": "tester"}}
+        if "createProjectV2(" in query:
+            return {"createProjectV2": {"projectV2": {"id": "P1", "number": 7,
+                                                      "title": vars_.get("title")}}}
+        if "projectV2(number" in query:
+            nodes = [{"id": f"F-{n}", "name": n, "dataType": "TEXT"}
+                     for n in self._fields]
+            if "Type" in self._fields:
+                for node in nodes:
+                    if node["name"] == "Type":
+                        node["dataType"] = "SINGLE_SELECT"
+                        node["options"] = [{"id": "O1", "name": "Feature"},
+                                           {"id": "O2", "name": "Story"}]
+            return {"user": {"projectV2": {"id": "P1", "title": "Board",
+                                           "fields": {"nodes": nodes}}}}
+        if "createProjectV2Field" in query:
+            self._fields.append(vars_["n"])
+            return {"createProjectV2Field": {"projectV2Field": {"id": "F-new"}}}
+        if "addProjectV2ItemById" in query:
+            return {"addProjectV2ItemById": {"item": {"id": "I1"}}}
+        if "updateProjectV2ItemFieldValue" in query:
+            return {"updateProjectV2ItemFieldValue": {"projectV2Item": {"id": "I1"}}}
+        return {}
+
+
+def test_create_project():
+    from docassert.bridge import board
+    gh = BoardGh()
+    proj = board.create_project(gh, "Refuge for Humans")
+    assert proj["number"] == 7 and proj["title"] == "Refuge for Humans"
+
+
+def test_ensure_fields_creates_missing():
+    from docassert.bridge import board
+    gh = BoardGh(existing_fields=["Status"])
+    project = board.ensure_fields(gh, "tester", 7)
+    assert set(project["fields"]) >= {"Type", "Doc", "PMO Project"}
+
+
+def test_scaffold_syncs_board(tmp_path):
+    plan = build_bridge_plan(_tree(tmp_path))
+    existing = []
+    for i, f in enumerate(plan.features):
+        e = _mk_issue(200 + i, f.id, feature_title(f))
+        e["body"] = feature_body(f, None)
+        existing.append(e)
+        for j, s in enumerate(f.stories):
+            from docassert.bridge.plan import story_title
+            e2 = _mk_issue(300 + i * 10 + j, s.id, story_title(s))
+            e2["body"] = story_body(s, None)
+            existing.append(e2)
+    gh = FakeGh(existing)
+    bgh = BoardGh(existing_fields=["Type", "Doc", "PMO Project"])
+    actions = ops.scaffold(plan, gh, "o/r",
+                           board_cfg={"gh": bgh, "owner": "tester", "number": 7,
+                                      "init": False})
+    assert any("5 item(s) synced" in a for a in actions)
+    adds = [q for q in bgh.gql if "addProjectV2ItemById" in q]
+    assert len(adds) == 5
+
+
+def test_status_includes_scope_classification(tmp_path):
+    plan = build_bridge_plan(_tree(tmp_path))
+    issues = [
+        _mk_issue(1, "TST-US-001"),
+        {"number": 2, "node_id": "N2", "state": "open", "title": "rogue",
+         "body": "no marker", "labels": []},
+        _mk_issue(3, "TST-US-999"),
+        _mk_issue(4, "TST-US-002", state="closed"),   # closed: not scope-checked
+    ]
+    data = ops.status(plan, FakeGh(issues), "o/r")
+    assert data["repo"] == "o/r"
+    assert [i["number"] for i in data["scope"]["unverified"]] == [2]
+    assert [i["doc"] for i in data["scope"]["orphaned"]] == ["TST-US-999"]