docassert 0.18.0__tar.gz → 0.20.0__tar.gz

{docassert-0.18.0/docassert.egg-info → docassert-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docassert
-Version: 0.18.0
+Version: 0.20.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.18.0 → docassert-0.20.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.18.0"
+__version__ = "0.20.0"

{docassert-0.18.0 → docassert-0.20.0}/docassert/_data/consistency.yaml

@@ -39,6 +39,12 @@ coverage:
 # (0 = no cap).
 alignment_limit: 25
 
+# Open risks move derived status to amber only at or above this
+# probability x impact score (low=1 medium=2 high/critical=3). 0 = any open
+# risk ambers (the strict pre-0.19 behavior). Exposure below the threshold
+# stays fully reported; it just doesn't flatten the headline.
+risk_amber_score: 6
+
 # Rules match in order; the first matching rule grades a link. Typed rules
 # (child_type/parent_type) come before the generic ones.
 alignment:

{docassert-0.18.0 → docassert-0.20.0}/docassert/consistency.py

@@ -49,6 +49,37 @@ def check_unique_item_ids(graph) -> CheckResult:
                        f"Duplicate item IDs: {detail}")
 
 
+def check_sequence_acyclic(graph) -> CheckResult:
+    """The `after` digraph contains no cycle (a cycle is broken sequencing)."""
+    edges: dict[str, list[str]] = {}
+    for item in graph.all_items():
+        for target in item.links.get("after", []):
+            edges.setdefault(item.id, []).append(target)
+    state: dict[str, int] = {}  # 0 visiting, 1 done
+
+    def visit(node, path):
+        if state.get(node) == 1:
+            return None
+        if state.get(node) == 0:
+            return path[path.index(node):] + [node]
+        state[node] = 0
+        for nxt in edges.get(node, []):
+            cycle = visit(nxt, path + [node])
+            if cycle:
+                return cycle
+        state[node] = 1
+        return None
+
+    for start in list(edges):
+        cycle = visit(start, [])
+        if cycle:
+            return CheckResult("sequence-acyclic", False, True,
+                               "after-cycle: " + " → ".join(cycle))
+    n = sum(len(v) for v in edges.values())
+    return CheckResult("sequence-acyclic", True, True,
+                       f"{n} after link(s), no cycles.")
+
+
 def check_referential_integrity(graph) -> CheckResult:
     broken = []
     for item in graph.all_items():
@@ -208,6 +239,7 @@ def run_consistency(documents_dir: str | Path = "documents",
     results = [
         check_unique_item_ids(graph),
         check_referential_integrity(graph),
+        check_sequence_acyclic(graph),
         check_required_links(graph, cfg),
         check_coverage(graph, cfg),
         check_profile_completeness(documents_dir),

{docassert-0.18.0 → docassert-0.20.0}/docassert/status/derive.py

@@ -116,6 +116,49 @@ def _broken_references(graph, code=None):
 _MS_RE = re.compile(r"^(?P<label>.+?)[:\u2014\u2013-]\s*(?P<date>\d{4}-\d{2}-\d{2})\.?\s*$")
 
 
+_TSHIRT = [(1, "XS"), (2, "S"), (4, "M"), (7, "L")]
+
+
+def _tshirt(points: int) -> str:
+    for cap, label in _TSHIRT:
+        if points <= cap:
+            return label
+    return "XL"
+
+
+def _features(graph, code):
+    """Every product requirement as a chartable feature: scope points =
+    traced stories + verifying acceptance criteria (document arithmetic, no
+    estimation), plus `after` sequencing resolved into topological layers."""
+    prs = [i for i in graph.by_type.get("PR", []) if not code or i.project == code]
+    feats = {}
+    for pr in prs:
+        stories = graph.children(pr.id, "traces", "US")
+        acs = graph.children(pr.id, "verifies", "AC")
+        feats[pr.id] = {
+            "id": pr.id,
+            "text": pr.text.split(". ")[0][:80],
+            "stories": len(stories),
+            "acs": len(acs),
+            "points": len(stories) + len(acs),
+            "after": [t for t in pr.links.get("after", []) if any(
+                p.id == t for p in prs)],
+            "layer": 0,
+        }
+    # Kahn layering; a cycle (gated by sequence-acyclic) degrades to layer 0
+    for _ in range(len(feats)):
+        changed = False
+        for f in feats.values():
+            want = max((feats[d]["layer"] + 1 for d in f["after"]
+                        if d in feats), default=0)
+            if want > f["layer"]:
+                f["layer"] = want
+                changed = True
+        if not changed:
+            break
+    return sorted(feats.values(), key=lambda f: (f["layer"], -f["points"], f["id"]))
+
+
 def _milestones(docs):
     """Dated charter milestones as temporal facts (never completion claims)."""
     import datetime
@@ -135,15 +178,29 @@ def _milestones(docs):
                 due = datetime.date.fromisoformat(m.group("date"))
             except ValueError:
                 continue
-            delta = (due - today).days
-            out.append({"label": m.group("label").strip(),
-                        "date": due.isoformat(),
-                        "days": delta,
-                        "when": ("today" if delta == 0 else
-                                 "elapsed" if delta < 0 else "upcoming")})
+            out.append(_ms_entry(m.group("label").strip(), due, today))
+    for d in docs:
+        if d.kind != "charter":
+            continue
+        target = (d.frontmatter.get("dates") or {}).get("target")
+        if target:
+            try:
+                due = (target if isinstance(target, datetime.date)
+                       else datetime.date.fromisoformat(str(target)))
+                if not any(x["date"] == due.isoformat() for x in out):
+                    out.append(_ms_entry("Charter target", due, today))
+            except (TypeError, ValueError):
+                pass
     return sorted(out, key=lambda x: x["date"])
 
 
+def _ms_entry(label, due, today):
+    delta = (due - today).days
+    return {"label": label, "date": due.isoformat(), "days": delta,
+            "when": ("today" if delta == 0 else
+                     "elapsed" if delta < 0 else "upcoming")}
+
+
 def _operations(docs):
     """Operations documents with their review state."""
     import datetime
@@ -231,9 +288,11 @@ def build_status(documents_dir=DOCUMENTS_DIR, project: str | None = None) -> dic
         "risks": _risks(graph, code),
         "operations": _operations(docs),
         "milestones": _milestones(docs),
+        "features": _features(graph, code),
         "broken_references": _broken_references(graph, code),
         "latest_report": _latest_report(docs),
         "completeness": completeness,
+        "risk_amber_score": int(cfg.get("risk_amber_score", 6) or 0),
     }
     model["rag"] = derive_rag(model)
     return model
@@ -313,7 +372,10 @@ def derive_rag(model) -> str:
     reported = (model["latest_report"] or {}).get("rag")
     completeness_gap = bool(comp and (comp["missing_required"] or comp["incomplete_required"]
                                       or comp["recommended_gaps"] or comp.get("unknown")))
-    open_risks = [r for r in model["risks"] if r.get("disposition", "open") == "open"]
+    threshold = model.get("risk_amber_score", 6)
+    open_risks = [r for r in model["risks"]
+                  if r.get("disposition", "open") == "open"
+                  and (threshold == 0 or r.get("score", 0) >= threshold)]
     stale_ops = [o for o in model.get("operations", []) if not o["fresh"]]
     if (coverage_gap or open_risks or stale_ops
             or reported in {"amber", "red"} or completeness_gap):

{docassert-0.18.0 → docassert-0.20.0}/docassert/status/render.py

@@ -362,77 +362,62 @@ def render_html(model) -> str:
     ex = model.get("execution") or {}
     lanes_html = ""
     feats = ex.get("features", [])
-    dated = [f for f in feats if (f.get("facts") or {}).get("created_at")]
-    if dated:
-        starts = [f["facts"]["created_at"] for f in dated]
-        ends = [(f["facts"].get("closed_at") or today.isoformat()) for f in dated]
-        bounds = [datetime.date.fromisoformat(min(starts)),
-                  max(datetime.date.fromisoformat(max(ends)), today)]
-        for m in ms:
-            try:
-                bounds[1] = max(bounds[1], datetime.date.fromisoformat(m["date"]))
-            except ValueError:
-                pass
-        w0 = bounds[0]
-        span = max((bounds[1] - w0).days + 7, 14)
-        # month gridlines
-        months = []
-        cur = datetime.date(w0.year, w0.month, 1)
-        while cur <= bounds[1]:
-            if cur >= w0:
-                months.append(cur)
-            cur = datetime.date(cur.year + (cur.month == 12), (cur.month % 12) + 1, 1)
-        month_html = "".join(
-            f'<span style="position:absolute;left:{_pct(m.isoformat(), w0, span):.2f}%;top:0;'
-            f'font-size:9px;letter-spacing:.14em;color:{_C["dim"]};padding-left:7px;">'
-            f'{m.strftime("%b").upper()}</span>' for m in months)
-        grid = ", ".join(
-            f'transparent {_pct(m.isoformat(), w0, span):.2f}%, #191d21 {_pct(m.isoformat(), w0, span):.2f}%, '
-            f'#191d21 calc({_pct(m.isoformat(), w0, span):.2f}% + 1px), transparent calc({_pct(m.isoformat(), w0, span):.2f}% + 1px)'
-            for m in months) or "transparent 0%"
+    ex_state = {}
+    for f in feats:
+        facts = f.get("facts") or {}
+        ex_state[f["id"]] = ("blocked" if "blocked" in (facts.get("labels") or [])
+                             else "done" if f.get("closed") else "open")
+    chart = model.get("features") or []
+    if chart:
+        maxp = max(f["points"] for f in chart) or 1
+        maxlayer = max(f["layer"] for f in chart)
+        ncols = maxlayer + 1
+        colw = 100.0 / ncols
         fills = {"done": f'background:rgba(63,185,80,.78);color:{_C["bg"]};',
                  "open": f'background:rgba(255,178,36,.85);color:{_C["bg"]};',
-                 "blocked": f'background:rgba(240,78,78,.82);color:{_C["bg"]};'}
-        lane_rows = []
-        for f in dated:
-            facts = f["facts"]
-            state = ("blocked" if "blocked" in (facts.get("labels") or [])
-                     else "done" if f.get("closed") else "open")
-            left = _pct(facts["created_at"], w0, span)
-            right = _pct(facts.get("closed_at") or today.isoformat(), w0, span)
-            w = max(2.0, right - left)
-            label = esc(facts.get("title") or f["id"])
-            lane_rows.append(
+                 "blocked": f'background:rgba(240,78,78,.82);color:{_C["bg"]};',
+                 "scoped": 'background:rgba(255,255,255,.05);color:#9BA1A8;border:1px dashed #3a4046;'}
+        headers = "".join(
+            f'<span style="position:absolute;left:{i * colw:.2f}%;top:0;font-size:9px;'
+            f'letter-spacing:.14em;color:{_C["dim"]};padding-left:7px;">SEQ {i + 1}</span>'
+            for i in range(ncols))
+        gridlines = ", ".join(
+            f'transparent {i * colw:.2f}%, #191d21 {i * colw:.2f}%, '
+            f'#191d21 calc({i * colw:.2f}% + 1px), transparent calc({i * colw:.2f}% + 1px)'
+            for i in range(1, ncols)) or "transparent 0%"
+        rows_html = []
+        for f in chart:
+            state = ex_state.get(f["id"], "scoped")
+            size = _tshirt_label(f["points"])
+            width = max(6.0, (f["points"] / maxp) * (colw - 3))
+            left = f["layer"] * colw + 1
+            dep = f' · after {", ".join(esc(d) for d in f["after"])}' if f["after"] else ""
+            rows_html.append(
                 f'<div style="display:grid;grid-template-columns:186px 1fr;align-items:center;'
                 f'border-bottom:1px solid #14181b;">'
                 f'<div style="padding-right:14px;"><div style="font-size:12px;color:{_C["soft"]};'
-                f'line-height:1.3;">{label[:52]}</div>'
+                f'line-height:1.3;">{esc(f["text"])[:52]}</div>'
                 f'<div style="font-size:9.5px;color:{_C["dim"]};margin-top:3px;">{esc(f["id"])}'
-                f' · {f["stories_closed"]}/{f["stories_total"]}</div></div>'
-                f'<div style="position:relative;height:40px;background-image:linear-gradient(90deg, {grid});">'
-                f'<div style="position:absolute;top:9px;left:{left:.2f}%;width:{w:.2f}%;height:22px;'
-                f'border-radius:3px;display:flex;align-items:center;padding:0 8px;font-size:9.5px;'
-                f'letter-spacing:.02em;overflow:hidden;white-space:nowrap;{fills[state]}">{state}</div></div></div>')
-        today_line = (f'<div style="position:absolute;left:{_pct(today.isoformat(), w0, span):.2f}%;'
-                      f'top:0;bottom:0;width:1px;background:rgba(255,178,36,.45);"></div>')
-        review_marks = "".join(
-            f'<div style="position:absolute;left:{_pct(o["review_by"], w0, span):.2f}%;top:50%;'
-            f'width:10px;height:10px;background:{_C["amber"]};transform:translate(-50%,-50%) rotate(45deg);'
-            f'border:2px solid {_C["bg"]};"></div>'
-            for o in model.get("operations", []) if len(o.get("review_by", "")) == 10)
+                f' · {f["stories"]} st · {f["acs"]} ac{dep}</div></div>'
+                f'<div style="position:relative;height:40px;background-image:linear-gradient(90deg, {gridlines});">'
+                f'<div style="position:absolute;top:9px;left:{left:.2f}%;width:{width:.2f}%;height:22px;'
+                f'border-radius:3px;display:flex;align-items:center;gap:6px;padding:0 8px;font-size:9.5px;'
+                f'letter-spacing:.02em;overflow:hidden;white-space:nowrap;{fills[state]}">'
+                f'<b>{size}</b> {f["points"]}pt · {state}</div></div></div>')
         lanes_html = (
             f'<div style="margin:0 0 60px;">'
             f'<div style="display:grid;grid-template-columns:186px 1fr;"><span></span>'
-            f'<div style="position:relative;height:20px;">{month_html}</div></div>'
-            f'<div style="position:relative;border-top:1px solid {_C["line"]};">'
-            f'<div style="position:absolute;left:186px;right:0;top:0;bottom:0;pointer-events:none;">'
-            f'{today_line}{review_marks}</div>{"".join(lane_rows)}</div>'
+            f'<div style="position:relative;height:20px;">{headers}</div></div>'
+            f'<div style="position:relative;border-top:1px solid {_C["line"]};">{"".join(rows_html)}</div>'
             f'<div style="display:flex;gap:18px;margin-top:18px;font-size:10.5px;color:{_C["muted"]};flex-wrap:wrap;align-items:center;">'
-            f'<span style="display:flex;align-items:center;gap:7px;"><span style="width:11px;height:11px;background:rgba(255,178,36,.85);border-radius:2px;display:inline-block;"></span>open · real created→now span</span>'
-            f'<span style="display:flex;align-items:center;gap:7px;"><span style="width:11px;height:11px;background:rgba(63,185,80,.78);border-radius:2px;display:inline-block;"></span>done · created→closed</span>'
-            f'<span style="display:flex;align-items:center;gap:7px;"><span style="width:11px;height:11px;background:rgba(240,78,78,.82);border-radius:2px;display:inline-block;"></span>blocked label</span>'
-            f'<span style="margin-left:auto;display:flex;align-items:center;gap:8px;">'
-            f'<span style="width:9px;height:9px;background:{_C["amber"]};transform:rotate(45deg);display:inline-block;"></span>operations review</span></div></div>')
+            f'<span>position = dependency sequence (`after` layers)</span>'
+            f'<span>width = <b>scope points</b> = stories + acceptance criteria (no estimation, no time axis)</span>'
+            f'<span>XS=1 · S=2 · M=3–4 · L=5–7 · XL=8+</span>'
+            f'<span style="margin-left:auto;display:flex;gap:14px;">'
+            f'<span style="display:flex;align-items:center;gap:6px;"><span style="width:11px;height:11px;background:rgba(63,185,80,.78);border-radius:2px;display:inline-block;"></span>done</span>'
+            f'<span style="display:flex;align-items:center;gap:6px;"><span style="width:11px;height:11px;background:rgba(255,178,36,.85);border-radius:2px;display:inline-block;"></span>open</span>'
+            f'<span style="display:flex;align-items:center;gap:6px;"><span style="width:11px;height:11px;background:rgba(240,78,78,.82);border-radius:2px;display:inline-block;"></span>blocked</span>'
+            f'<span style="display:flex;align-items:center;gap:6px;"><span style="width:11px;height:11px;background:rgba(255,255,255,.05);border:1px dashed #3a4046;border-radius:2px;display:inline-block;"></span>scoped</span></span></div></div>')
 
     roadmap_html = ""
     if timeline_html or lanes_html:
@@ -591,6 +576,13 @@ def render_html(model) -> str:
 """
 
 
+def _tshirt_label(points: int) -> str:
+    for cap, label in ((1, "XS"), (2, "S"), (4, "M"), (7, "L")):
+        if points <= cap:
+            return label
+    return "XL"
+
+
 def _section(num, name, aside) -> str:
     return (f'<div class="sect"><span class="num">{num}</span>'
             f'<span class="name">{name}</span><span class="rule"></span>'

{docassert-0.18.0 → docassert-0.20.0/docassert.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docassert
-Version: 0.18.0
+Version: 0.20.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.18.0 → docassert-0.20.0}/tests/test_status.py

@@ -53,7 +53,9 @@ def test_rag_red_on_failing_approved_doc():
 
 
 def test_rag_amber_on_open_risk():
-    assert S.derive_rag(_model(risks=[{"id": "RISK-1", "score": 4}])) == "amber"
+    # at or above the appetite (default 6) ambers; below stays green
+    assert S.derive_rag(_model(risks=[{"id": "RISK-1", "score": 6}])) == "amber"
+    assert S.derive_rag(_model(risks=[{"id": "RISK-1", "score": 4}])) == "green"
 
 
 def test_rag_amber_on_coverage_gap():
@@ -189,8 +191,8 @@ def test_disposition_parsed_and_defaulted():
 def test_rag_green_when_all_risks_dispositioned():
     base = {"documents": [], "coverage": [], "broken_references": [],
             "latest_report": None, "completeness": None}
-    open_r = dict(base, risks=[{"id": "R", "score": 2, "disposition": "open"}])
-    done_r = dict(base, risks=[{"id": "R", "score": 2, "disposition": "accepted"}])
+    open_r = dict(base, risks=[{"id": "R", "score": 6, "disposition": "open"}])
+    done_r = dict(base, risks=[{"id": "R", "score": 6, "disposition": "accepted"}])
     assert S.derive_rag(open_r) == "amber"
     assert S.derive_rag(done_r) == "green"
 
@@ -275,3 +277,93 @@ def test_svc_and_freshness_checks(tmp_path):
     assert ok
     fresh_ok, detail = check_ops_review_fresh(doc, ctx)
     assert not fresh_ok and "overdue" in detail
+
+
+# ── risk appetite (spec 0.7.0) ───────────────────────────────────────────────
+def test_low_grade_open_risks_do_not_amber():
+    base = {"documents": [], "coverage": [], "broken_references": [],
+            "latest_report": None, "completeness": None, "operations": [],
+            "risk_amber_score": 6}
+    low = dict(base, risks=[{"id": "R", "score": 4, "disposition": "open"}])
+    hi = dict(base, risks=[{"id": "R", "score": 6, "disposition": "open"}])
+    strict = dict(low, risk_amber_score=0)
+    assert S.derive_rag(low) == "green"
+    assert S.derive_rag(hi) == "amber"
+    assert S.derive_rag(strict) == "amber"
+
+
+def test_charter_target_becomes_implicit_milestone():
+    _cd_root()
+    m = S.build_status(ROOT / "documents", project="PRJ-002-ATL")
+    dates = [x["label"] for x in m["milestones"]]
+    assert any("Charter target" in lbl or lbl for lbl in dates) or m["milestones"] == []
+    # Aurora has explicit dated milestones AND a target; no duplicates by date
+    m2 = S.build_status(ROOT / "documents", project="PRJ-001-AUR")
+    seen = [x["date"] for x in m2["milestones"]]
+    assert len(seen) == len(set(seen))
+
+
+# ── sequence-and-size charts (sponsor direction, spec 0.8.0) ─────────────────
+def _seq_tree(tmp_path, cyclic=False):
+    d = tmp_path / "documents" / "PRJ-001-SQ"
+    d.mkdir(parents=True)
+    (d / "project.md").write_text(
+        "---\nkind: project\nid: PRJ-001-SQ\ncode: SQ\nname: Seq Fixture\n"
+        "sponsor: sp.owner\nstatus: active\n---\n\n## Overview\nx\n\n## Scope\nx\n",
+        encoding="utf-8")
+    first_after = "; after: SQ-PR-003" if cyclic else ""
+    (d / "prd.md").write_text(
+        "---\nkind: prd\nid: SQ-prd\nproject: PRJ-001-SQ\ntitle: T\n"
+        "owner: ow.ner\nstatus: approved\n---\n\n## Overview\nx\n\n"
+        "## Product Requirements\n\n"
+        f"- **SQ-PR-001** (traces: SQ-BR-001{first_after}): First thing.\n"
+        "- **SQ-PR-002** (traces: SQ-BR-001; after: SQ-PR-001): Second thing.\n"
+        "- **SQ-PR-003** (traces: SQ-BR-001; after: SQ-PR-002): Third thing.\n\n"
+        "## Acceptance Criteria\n\n"
+        "- **SQ-AC-001** (verifies: SQ-PR-001): Given a, when b, then c.\n"
+        "- **SQ-AC-002** (verifies: SQ-PR-001): Given d, when e, then f.\n"
+        "- **SQ-AC-003** (verifies: SQ-PR-002): Given g, when h, then i.\n",
+        encoding="utf-8")
+    (d / "brd.md").write_text(
+        "---\nkind: brd\nid: SQ-brd\nproject: PRJ-001-SQ\ntitle: T\n"
+        "owner: ow.ner\nstatus: approved\n---\n\n## Purpose\nx\n\n"
+        "## Business Requirements\n\n"
+        "- **SQ-BR-001**: The business shall reach 100% of the metric by 2026-12-31.\n\n"
+        "## Out of Scope\nx\n", encoding="utf-8")
+    (d / "user-story.md").write_text(
+        "---\nkind: user-story\nid: SQ-user-story\nproject: PRJ-001-SQ\ntitle: T\n"
+        "owner: ow.ner\nstatus: approved\n---\n\n## Overview\nx\n\n"
+        "## User Stories\n\n"
+        "- **SQ-US-001** (traces: SQ-PR-001): As a user, I want one so that value.\n"
+        "- **SQ-US-002** (traces: SQ-PR-003): As a user, I want three so that value.\n",
+        encoding="utf-8")
+    return tmp_path / "documents"
+
+
+def test_features_points_layers_and_tshirt(tmp_path):
+    _cd_root()
+    m = S.build_status(_seq_tree(tmp_path), project="PRJ-001-SQ")
+    by = {f["id"]: f for f in m["features"]}
+    assert by["SQ-PR-001"]["points"] == 3 and by["SQ-PR-001"]["layer"] == 0
+    assert by["SQ-PR-002"]["points"] == 1 and by["SQ-PR-002"]["layer"] == 1
+    assert by["SQ-PR-003"]["points"] == 1 and by["SQ-PR-003"]["layer"] == 2
+    from docassert.status.derive import _tshirt
+    assert [_tshirt(n) for n in (1, 2, 3, 5, 9)] == ["XS", "S", "M", "L", "XL"]
+
+
+def test_sequence_chart_renders_without_time_axis(tmp_path):
+    _cd_root()
+    m = S.build_status(_seq_tree(tmp_path), project="PRJ-001-SQ")
+    out = S.render_html(m)
+    assert "SEQ 1" in out and "scope points" in out
+    assert "XS=1" in out and "scoped" in out
+    assert "created→closed" not in out and "JUL" not in out
+
+
+def test_after_cycle_blocks(tmp_path):
+    from docassert.consistency import check_sequence_acyclic
+    from docassert.graph import build_graph
+    _cd_root()
+    g = build_graph(_seq_tree(tmp_path, cyclic=True))
+    r = check_sequence_acyclic(g)
+    assert not r.passed and r.blocking and "after-cycle" in r.detail