@andresmassello/uscha 1.86.1 → 1.88.0

package/README.md

@@ -40,7 +40,7 @@ Requires **Python 3.8+** on the machine (the engine is Python stdlib — no pip
 runtime dependencies). The npm package is a thin router; the canonical installer is
 `uscha-kit/install-uscha.py`.
 
-**Kit v1.86.1** <!-- uscha:version --> · [uscha.dev](https://uscha.dev) ·
+**Kit v1.88.0** <!-- uscha:version --> · [uscha.dev](https://uscha.dev) ·
 [changelog](https://github.com/andresmassello/uscha/blob/main/uscha-kit/CHANGELOG.md)
 (the per-release changelogs live in the repo, not in the npm tarball)
 
@@ -85,7 +85,7 @@ automatic tool can perform: a human verdict.
    from the compiled code: 0.062 measured (12 archetypes) — names, not yet semantics
 ```
 
-**What each arrow is, in the engine (kit 1.86.1, 52 subcommands, all measured):**
+**What each arrow is, in the engine (kit 1.88.0, 52 subcommands, all measured):**
 
 | Leg | Subcommands | What it establishes |
 |---|---|---|

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andresmassello/uscha",
-  "version": "1.86.1",
+  "version": "1.88.0",
   "description": "Spec-driven development for LLM coding agents: 9 skills + a stdlib evidence engine. Facts block, guesses advise; the human approves.",
   "author": {
     "name": "Andres Massello",

package/uscha-kit/.claude/skills/uscha-devloop/SKILL.md

@@ -535,7 +535,10 @@ once logged it caps readiness ≤65 and blocks convergence until resolved with
 criterion carries a stable ID: `- [ ] AC-01 — when X then Y`. A criterion counts as
 CLOSED only when ≥1 GREEN testcase whose name carries the tag (`test_ac1_x`,
 `testAC01X`, `"AC-01: ..."` — IDs normalize by number, `AC-01 == AC_1 == ac1`) exists
-in the ingested JUnit reports AND no tagged testcase is red. The checkbox is the
+in the ingested JUnit reports AND no tagged testcase is red. Since kit 1.87.0 (ADR-036)
+a FAMILY prefix is read the same way: `- [ ] AC-BC-07 — ...` closes on `AC-BC-07_x`,
+`test_ac_bc_7_y` or `AC_BC_7` (normalized to `AC-BC-7`; the family needs a separator on
+both sides — camelCase `testACBC07` is NOT a tag, and `AC-7-x` is still the bare `AC-7`). The checkbox is the
 NARRATIVE; the testcase is the FACT — a checked box without a green tagged test shows
 up as `narrated_only` and does NOT close (measured beats narrated, per criterion).
 A JUnit report older than the repo's source code is treated as STALE (the code changed

package/uscha-kit/.claude/skills/uscha-devloop/qa_ledger.py

@@ -764,11 +764,43 @@ def _test_evidence_provenance(repo_path, repo_type):
 _AC_TAG = re.compile(
     r"(?:(?<![A-Za-z0-9])[Aa][Cc]|(?<=[a-z])AC)[-_]?0*(\d+)(?!\d)")
 
+# kit 1.87.0 (ADR-036): the FAMILY grammar 'AC-<FAMILY>-<n>' (AC-BC-07, AC-T-24,
+# ac_dd_3). Same explicit boundaries as the bare form, plus a MANDATORY separator
+# on BOTH sides of the family — 'AC-BC-07', 'ac_bc_7', 'AC_T_1'. camelCase families
+# are deliberately NOT supported: 'testACBC07' has no honest split into family +
+# number and stays unmatched.
+# Kept as its OWN pattern so the bare pattern above (and every tag it already
+# produced) stays byte-identical. The two are disjoint by construction: a family
+# must start with a LETTER, so 'AC-01' can never match this one, and the digits of
+# 'AC-BC-07' do not follow 'AC', so it can never match the bare one.
+_AC_TAG_FAM = re.compile(
+    r"(?:(?<![A-Za-z0-9])[Aa][Cc]|(?<=[a-z])AC)"
+    r"[-_]([A-Za-z][A-Za-z0-9]*)[-_]0*(\d+)(?!\d)")
+
+
+def _ac_canon(family, num):
+    """Canonical criterion id for both grammars (ADR-036): 'AC-<int>' for the bare
+    form (AC-01 == AC_1 == ac1) and 'AC-<FAMILY>-<int>' for the family form
+    (AC-T-01 == AC-T-1 == ac_t_1) — python/go test names cannot carry '-', so the
+    separator and the zero padding are never part of the identity."""
+    if family:
+        return "AC-%s-%d" % (family.upper(), int(num))
+    return "AC-%d" % int(num)
+
+
+def _ac_tag_ids(name):
+    """Every criterion id a testcase NAME tags, normalized. Family form first, then
+    bare; the two patterns are disjoint, so the order fixes only the output order."""
+    ids = [_ac_canon(fam, num) for fam, num in _AC_TAG_FAM.findall(name)]
+    ids.extend(_ac_canon(None, num) for num in _AC_TAG.findall(name))
+    return ids
+
 
 def _ac_tags(repo_path, repo_type):
     """Tags AC-n leidos de los NOMBRES de testcase en los reportes JUnit que el
     engine ya ingiere. Devuelve (tags, stale) donde tags = {'AC-n': {'green': x,
-    'red': y}} y stale = [rutas de reportes descartados por viejos]. Un criterio
+    'red': y}} (o 'AC-FAM-n' para la forma con familia, ADR-036 / kit 1.87.0)
+    y stale = [rutas de reportes descartados por viejos]. Un criterio
     cierra MEDIDO solo con >=1 testcase verde y 0 rojos (evidencia roja veta:
     fail-closed). Testcases skipped no cuentan para ningun lado.
 
@@ -812,9 +844,8 @@ def _ac_tags(repo_path, repo_type):
             # cuyo nombre matchea 'ACn' por coincidencia (test_ac3_flow.py) no
             # debe taggear los OTROS tests del mismo archivo/clase.
             blob = tc.get("name") or ""
-            for num in _AC_TAG.findall(blob):
-                d = tags.setdefault(f"AC-{int(num)}",
-                                    {"green": 0, "red": 0, "cases": []})
+            for cid in _ac_tag_ids(blob):
+                d = tags.setdefault(cid, {"green": 0, "red": 0, "cases": []})
                 d[status] += 1
                 # RECEIPT (kit 1.50.0): keep WHICH testcase in WHICH report backed the
                 # verdict -- the name and path were always in scope here and were being
@@ -4213,15 +4244,20 @@ def _canonical_ids(repo_path, acceptance_file):
     except Exception:
         return {}
     for it in items or []:
-        if it.get("id"):                          # normalized "AC-<n>" (numeric ids only)
-            ids[int(it["id"].split("-")[1])] = it["id"]
+        if it.get("id"):
+            # normalized id of EITHER grammar (ADR-036): "AC-<n>" or "AC-<FAMILY>-<n>". Keyed by
+            # the canonical id itself; a bare and a family id can never collide.
+            ids[it["id"]] = it["id"]
     return ids
 
 
 def _match_canonical(statement, canon_ids):
-    m = re.search(r"(?i)\bAC[-_]?0*(\d+)\b", statement)
-    if m and int(m.group(1)) in canon_ids:
-        return canon_ids[int(m.group(1))]
+    """The canonical id an observation's statement names, if any -- read with the same
+    grammar as ACCEPTANCE.md and the JUnit tags (ADR-036), so a statement that mentions
+    'AC-DD-07' anchors the criterion AC-DD-7 exactly as one that mentions 'AC-7' anchors AC-7."""
+    for cid in _ac_tag_ids(statement or ""):
+        if cid in canon_ids:
+            return canon_ids[cid]
     return None
 
 
@@ -7175,12 +7211,34 @@ def _band(score):
 
 _AC_ID = re.compile(r"(?i)^[*_`]*\s*AC[-_]?0*(\d+)\b[*_`]*[\s.:—–·-]*")
 
+# kit 1.87.0 (ADR-036): the family grammar, same tolerated wrappers/separators.
+# A family starts with a LETTER, so a numeric "family" is not one: '- [ ] AC-7-x'
+# falls through to the bare pattern and reads as AC-7 followed by the text 'x' (the
+# trailing-separator class eats the hyphen, exactly as before ADR-036).
+_AC_ID_FAM = re.compile(
+    r"(?i)^[*_`]*\s*AC[-_]([A-Za-z][A-Za-z0-9]*)[-_]0*(\d+)\b[*_`]*[\s.:—–·-]*")
+
+
+def _ac_id_of(body):
+    """(canonical id, end offset) of the leading AC id of a checkbox body, or
+    (None, 0). The FAMILY form is tried first; the bare form is the fallback, so
+    every id the engine read before ADR-036 still reads exactly the same."""
+    m = _AC_ID_FAM.match(body)
+    if m:
+        return _ac_canon(m.group(1), m.group(2)), m.end()
+    m = _AC_ID.match(body)
+    if m:
+        return _ac_canon(None, m.group(1)), m.end()
+    return None, 0
+
 
 def _parse_acceptance_items(path, section=None):
     """Checkboxes markdown de ACCEPTANCE, con ID trazable opcional por criterio
     ('- [ ] AC-01 — cuando X entonces Y'). Los IDs se normalizan por numero
-    (AC-01 == AC_1 == ac1 — los nombres de test de python/go no admiten '-').
-    Devuelve (items, found); item = {'id': 'AC-n'|None, 'checked', 'text'}."""
+    (AC-01 == AC_1 == ac1 — los nombres de test de python/go no admiten '-') y,
+    desde kit 1.87.0 (ADR-036), tambien por FAMILIA ('- [ ] AC-BC-07 — ...',
+    AC-T-01 == AC-T-1 == ac_t_1). Devuelve (items, found);
+    item = {'id': 'AC-n'|'AC-FAM-n'|None, 'checked', 'text'}."""
     if not path or not os.path.exists(path):
         return [], False
     items = []
@@ -7203,10 +7261,10 @@ def _parse_acceptance_items(path, section=None):
                 else:
                     continue
                 body = s[5:].strip()
-                m = _AC_ID.match(body)
-                items.append({"id": f"AC-{int(m.group(1))}" if m else None,
+                cid, end = _ac_id_of(body)
+                items.append({"id": cid,
                               "checked": checked,
-                              "text": body[m.end():].strip() if m else body})
+                              "text": body[end:].strip()})
     except OSError:
         return [], False
     return items, True
@@ -8157,12 +8215,183 @@ def _top_pct(done, total):
     return 99 if (done < total and pct >= 100) else pct
 
 
-def _top_ac_num(cid):
-    """Stable numeric order for the normalized 'AC-<n>' ids _parse_acceptance_items emits."""
+def _top_ac_key(cid):
+    """Stable order for the normalized ids _parse_acceptance_items emits: the BARE
+    'AC-<n>' criteria first by number, then each letter FAMILY alphabetically and by
+    number inside it (ADR-036). An id in neither shape sorts last instead of raising —
+    the board must still render when the acceptance file carries something unexpected."""
+    parts = str(cid).split("-")
+    if len(parts) >= 3:
+        try:
+            return (1, parts[1].upper(), int(parts[2]))
+        except ValueError:
+            return (2, str(cid), 0)
     try:
-        return int(str(cid).split("-")[1])
+        return (0, "", int(parts[1]))
     except (IndexError, ValueError):
-        return 0
+        return (2, str(cid), 0)
+
+
+TOP_EVENTS_TAIL = 8          # how many steps the feed carries; the TUI shows what fits
+TOP_EVENT_WIDTH = 72         # one feed line, short enough to survive the 80-column floor
+
+# kind -> level, the FIXED map ADR-032 (amended 1.88.0, M2) requires. `level` and `text` do
+# not exist in `ledger["steps"]`; they are derived here, once, so the TUI renders a feed it
+# did not author (ADR-034). A kind absent from this map reads `info`: an unclassified step
+# is never a green one. Four kinds get their level REFINED below from the record the step
+# announces (the iteration/escalation with the same `n`, the k-th clean-room record of the
+# repo) -- and when that correlation misses, the level stays at its neutral value instead of
+# guessing a verdict.
+TOP_EVENT_LEVELS = {
+    "snapshot": "info",                      # -> fail when the snapshot recorded red tests
+    "qa-step": "info",                       # -> pass when nothing was reported, or all fixed
+    "static-gate": "info",                   # -> pass/fail by the gated finding count
+    "cleanroom": "info",                     # -> pass/fail by the record's `ok`
+    "fastpath-eval": "info",
+    "gate-not-run": "unmeasured",            # a gate nobody ran is UNMEASURED, not a pass
+    "escalation": "human",
+    "escalation-resolved": "human",
+    "production-finding": "human",
+    "production-finding:resolve": "human",
+    "spec-doubt": "human",
+    "spec-doubt:resolve": "human",
+    "spec-change-request": "human",
+    "spec-change-request:resolve": "human",
+}
+
+
+def _top_ts(iso):
+    """HH:MM:SS in UTC, or None. A stamp carrying an offset is normalized to UTC (machine-
+    independent); it is never converted to the LOCAL zone, which would make the same ledger
+    read differently on two boxes and break the golden frames."""
+    dt = _top_dt(iso)
+    if dt is None:
+        return None
+    if dt.tzinfo is not None:
+        dt = dt.astimezone(timezone.utc)
+    return dt.strftime("%H:%M:%S")
+
+
+def _top_key(value):
+    """A dict key that cannot raise. The writers always put a scalar in `n`, `at` and `repo`,
+    but the ledger is JSON on disk and a hand edit can leave a list or a dict there --
+    `unhashable type` is not how a read-only readout gets to report that."""
+    if isinstance(value, (str, int, float, bool)) or value is None:
+        return value
+    return repr(value)
+
+
+def _top_event_text(*parts):
+    """One feed line: the only free text of the whole contract that reaches a terminal.
+
+    Its ingredients are ledger prose (an escalation reason, a tool name) -- human and CLI
+    input -- so an ESC or a C0 byte inside one would be a control sequence the board prints
+    verbatim. Every control character is dropped HERE, in the engine, and the renderer drops
+    them again on the way out: two cheap guards over one attack surface."""
+    txt = " · ".join(str(p) for p in parts if p not in (None, "", "?"))
+    txt = "".join(" " if c in ("\t", "\n", "\r") else c for c in txt)
+    txt = "".join(c for c in txt if ord(c) >= 32 and ord(c) != 127)
+    txt = " ".join(txt.split())
+    if len(txt) > TOP_EVENT_WIDTH:
+        txt = txt[:TOP_EVENT_WIDTH - 1] + "…"
+    return txt
+
+
+def _top_events(ledger, limit=TOP_EVENTS_TAIL):
+    """events_tail[]: the last `limit` steps as {ts, level, text}, NEWEST FIRST.
+
+    Deterministic given the ledger and read-only, like the rest of `cmd_top`. The step
+    records carry `n, at, kind, repo` plus a few per-kind fields; everything else the feed
+    shows comes from the record that step announces, correlated the way the ledger really
+    supports it: by `n` for iterations, escalations and fast-path entries (the writer copies
+    the counter into both), in ORDER for clean-room records (step and record are appended in
+    the same call), and by `(repo, at)` for snapshots. A miss degrades that one line to
+    `info` -- under-claiming a verdict, never inventing one."""
+    nodes = dict(ledger.get("repos") or {})
+    nodes["integration"] = ledger.get("integration") or {}
+    iters, snaps = {}, {}
+    for rname, node in nodes.items():
+        for it in (node or {}).get("iterations") or []:
+            if isinstance(it, dict) and it.get("n") is not None:
+                iters[(rname, _top_key(it.get("n")))] = it
+        for sn in (node or {}).get("snapshots") or []:
+            if isinstance(sn, dict):
+                snaps.setdefault((rname, _top_key(sn.get("at"))), sn)
+    esc = {_top_key(e.get("n")): e for e in ledger.get("escalations") or []
+           if isinstance(e, dict) and e.get("n") is not None}
+    fastp = {_top_key(e.get("n")): e for e in ledger.get("fast_path") or []
+             if isinstance(e, dict) and e.get("n") is not None}
+    crs = {}
+    for rec in ledger.get(CLEAN_ROOM_KEY) or []:
+        if isinstance(rec, dict):
+            crs.setdefault(str(rec.get("repo") or ""), []).append(rec)
+    cr_seen = {}
+
+    events = []
+    for st in ledger.get("steps") or []:
+        if not isinstance(st, dict):
+            continue
+        kind = str(st.get("kind") or "")
+        level = TOP_EVENT_LEVELS.get(kind, "info")
+        try:
+            repo = str(st.get("repo") or "")
+            n = _top_key(st.get("n"))
+            head, tail = kind or "step", None
+
+            if kind == "snapshot":
+                head = "snapshot " + repo if repo else "snapshot"
+                tail = "phase %s" % st.get("phase") if st.get("phase") else None
+                tests = (snaps.get((repo, _top_key(st.get("at")))) or {}).get("tests") or {}
+                red = (tests.get("failures") or 0) + (tests.get("errors") or 0)
+                if tests.get("report_found") and red:
+                    level, tail = "fail", "%d red test(s)" % red
+            elif kind in ("qa-step", "static-gate", "gate-not-run"):
+                head = "%s %s" % (kind, "/".join(str(p) for p in (repo, st.get("tool")) if p))
+                it = iters.get((repo, n)) or {}
+                rep, fixed = it.get("reported"), it.get("fixed")
+                gated = it.get("gated_reported")
+                if kind == "gate-not-run":
+                    tail = "not run — nobody measured it"
+                elif kind == "static-gate" and isinstance(gated, int):
+                    level = "fail" if gated >= 1 else "pass"
+                    tail = "%d gated finding(s)" % gated if gated else "clean"
+                elif kind == "qa-step" and isinstance(rep, int):
+                    if rep == 0 or (isinstance(fixed, int) and fixed >= rep):
+                        level = "pass"
+                    tail = "%d reported, %s fixed" % (rep,
+                                                      fixed if fixed is not None else "?")
+            elif kind == "cleanroom":
+                head = "cleanroom " + repo if repo else "cleanroom"
+                queue = crs.get(repo) or []
+                idx = cr_seen.get(repo, 0)
+                cr_seen[repo] = idx + 1
+                rec = queue[idx] if idx < len(queue) else {}
+                if rec.get("status") and rec.get("ok") is not None:
+                    level = "pass" if rec.get("ok") else "fail"
+                    tail = str(rec.get("status"))
+            elif kind == "fastpath-eval":
+                head = "fastpath-eval " + repo if repo else "fastpath-eval"
+                tail = (fastp.get(n) or {}).get("verdict")
+            elif kind in ("escalation", "escalation-resolved"):
+                head = "%s %s" % (kind, repo) if repo else kind
+                # `escalation-resolved` gets a FRESH counter of its own, so there is no
+                # record to look up: it says what happened and nothing more.
+                tail = (esc.get(n) or {}).get("reason") if kind == "escalation" else None
+            else:
+                head = "%s %s" % (kind, repo) if repo else (kind or "step")
+                tail = st.get("id")
+            text = _top_event_text(head, tail)
+        except Exception:
+            # a ledger is JSON on disk: any field can arrive as a list, a dict or a number
+            # from a hand edit. ONE unreadable step degrades to a neutral line naming its
+            # kind -- the readout never raises and never loses the JSON the board needs
+            # (the same fail-soft rule _top_dt already applies to timestamps).
+            level, text = "info", _top_event_text(kind or "step")
+
+        events.append({"ts": _top_ts(st.get("at")), "level": level, "text": text})
+
+    events.reverse()                          # newest first, as the board reads top-down
+    return events[:max(0, int(limit))]
 
 
 def cmd_top(args):
@@ -8234,7 +8463,7 @@ def cmd_top(args):
             seen.add(it["id"])
             ids.append(it["id"])
     obligations = []
-    for cid in sorted(ids, key=_top_ac_num):
+    for cid in sorted(ids, key=_top_ac_key):
         tag, obs = ac_tags.get(cid), quarantine.get(cid)
         # red evidence VETOES (fail-closed, the same rule _ac_closed applies). Measured
         # evidence outranks the lateral QUARANTINE rung so the four buckets partition the
@@ -8281,7 +8510,9 @@ def cmd_top(args):
         "generated_at": _now(),
         "obligations": obligations,
         "observations": observations,
-        "events_tail": [],                # the live feed is M2; the key ships empty, not absent
+        # the live feed (M2): the last steps, newest first, with `level`/`text` derived by the
+        # fixed per-kind map above -- in the engine, so the TUI authors no verdict of its own.
+        "events_tail": _top_events(ledger),
         "counts": {"measured_pass": done, "measured_fail": fail, "quarantine": quar,
                    "unmeasured": _n("UNMEASURED"), "traced": 0, "tagged": 0, "total": total},
         "terminado": {"done": done, "total": total, "pct": pct, "unmeasured": unmeasured},
@@ -8346,13 +8577,13 @@ def cmd_readiness(args):
     # IDs duplicados (ACCEPTANCE mal numerado) cuentan UNA sola vez — si no,
     # un solo test verde cierra "medido" tantos criterios como copias del ID.
     id_list = [i["id"] for i in ac_ids]
-    dupe_ids = sorted({cid for cid in id_list if id_list.count(cid) > 1})
-    unique_ids = sorted(set(id_list))
+    dupe_ids = sorted({cid for cid in id_list if id_list.count(cid) > 1}, key=_top_ac_key)
+    unique_ids = sorted(set(id_list), key=_top_ac_key)
     measured_closed = [cid for cid in unique_ids if _ac_closed(cid)]
     narrated_only = sorted({i["id"] for i in ac_ids
-                            if i["checked"] and not _ac_closed(i["id"])})
+                            if i["checked"] and not _ac_closed(i["id"])}, key=_top_ac_key)
     measured_unchecked = sorted({i["id"] for i in ac_ids
-                                 if not i["checked"] and _ac_closed(i["id"])})
+                                 if not i["checked"] and _ac_closed(i["id"])}, key=_top_ac_key)
     ac_untagged = total - len(ac_ids)
     acc_traceable = bool(ac_ids)
     if acc_traceable:
@@ -8627,8 +8858,9 @@ def cmd_readiness(args):
               f"(--section {args.section!r} matched nothing in the file?) — "
               f"adr/acceptance dimensions at 0")
     if acc_found and total and not acc_traceable:
-        print("  ! acceptance has no traceable IDs ('- [ ] AC-01 — ...') — the "
-              "acceptance dimension falls back to the checkbox ratio (NARRATED, not measured)")
+        print("  ! acceptance has no traceable IDs ('- [ ] AC-01 — ...' or "
+              "'- [ ] AC-BC-01 — ...') — the acceptance dimension falls back to the "
+              "checkbox ratio (NARRATED, not measured)")
     if dupe_ids:
         print(f"  ! duplicate IDs in acceptance (normalized): {', '.join(dupe_ids)} "
               f"— each ID counts ONCE in the acceptance dimension")
@@ -10102,8 +10334,9 @@ def _spec_check_text(text):
 def _acceptance_traceability(path):
     """Trazabilidad del ACCEPTANCE (kit 1.10.0): estructura = FACT.
     Bloquea: archivo ausente, cero criterios, CERO criterios con AC-ID, IDs
-    duplicados (tras normalizar: AC-01 == AC-1). Aconseja: criterios sueltos
-    sin ID (no podran cerrar MEDIDO)."""
+    duplicados (tras normalizar: AC-01 == AC-1, y desde kit 1.87.0 / ADR-036
+    AC-BC-07 == AC-BC-7). Aconseja: criterios sueltos sin ID (no podran cerrar
+    MEDIDO)."""
     blockers, advisory = [], []
     items, found = _parse_acceptance_items(path)
     if not found:
@@ -10115,7 +10348,8 @@ def _acceptance_traceability(path):
     ids = [i["id"] for i in items if i["id"]]
     if not ids:
         blockers.append("cero criterios trazables — cada criterio lleva ID "
-                        "estable: '- [ ] AC-01 — cuando X entonces Y'")
+                        "estable: '- [ ] AC-01 — cuando X entonces Y' "
+                        "(o con familia: '- [ ] AC-BC-01 — ...')")
         return blockers, advisory
     dupes = sorted({x for x in ids if ids.count(x) > 1})
     if dupes:
@@ -10835,7 +11069,8 @@ def cmd_doctor(args):
                 elif items:
                     warn(f"ACCEPTANCE without traceable AC-IDs ({len(items)} criterion(s))",
                          "generate it with /uscha-discovery or /uscha-adr-refine "
-                         "(format '- [ ] AC-01 - ...') - without IDs the dominant readiness "
+                         "(format '- [ ] AC-01 - ...', or with a family "
+                         "'- [ ] AC-BC-01 - ...') - without IDs the dominant readiness "
                          "dimension falls back to the checkbox ratio")
                 else:
                     warn(f"ACCEPTANCE {acc} has no criteria (zero checkboxes)")