@r1z4x/tezgah 1.9.2 → 1.13.0

package/hooks/tezgah_research.py

@@ -83,6 +83,7 @@ the offset just past its last newline (`tezgah_integrity.committed_size`) - so a
 fragment a killed writer left behind is neither read as a record by the readers
 here nor appended beside as one.
 """
+import decimal
 import fnmatch
 import json
 import math
@@ -150,7 +151,14 @@ PROTOCOL_RULES = 4
 SCOPE_RULES = 5
 HOLDOUT_RULES = 6
 EXPLORE_RULES = 7
-RULES = EXPLORE_RULES
+# Rules 8 (plan 127): evidence captured by the tool and claims narrowed rather
+# than lines refused.
+EVIDENCE_RULES = 8
+# Rules 9 (plan 136): a decision.md writes the line's own pick as `recommended:`;
+# `chosen:` is the owner's, recorded by `choose` with an `owner:` line carrying
+# the owner's words. `init` writes 9.
+OWNER_CHOICE_RULES = 9
+RULES = OWNER_CHOICE_RULES
 # How a rules-5 line answers its question. `qualitative` is a source or
 # reference review and owes no metric; `measured` runs experiments and locks
 # one. The question picks it, not the tooling: a qualitative ask answered with a
@@ -357,6 +365,27 @@ def slugs(repo):
     return sorted(seen)
 
 
+def stray_dirs(repo):
+    """[(path, error)] for the hidden dirs under research/, its open/ or its done/:
+    `slugs` skips them, so a line written into one (a `.staging` beside a refusal)
+    is invisible to every check. `status` and the no-slug `check` report each."""
+    out = []
+    for folder in layout_roots(repo):
+        try:
+            names = sorted(os.listdir(folder))
+        except OSError:
+            continue
+        for name in names:
+            path = os.path.join(folder, name)
+            if name.startswith(".") and os.path.isdir(path):
+                rel = os.path.relpath(path, repo)
+                out.append((rel, "%s is not a research line: a line lives under "
+                                 "research/open or research/done; import it with "
+                                 "`tezgah-research init` then move its files, or "
+                                 "delete it" % rel))
+    return out
+
+
 def line_dir(repo, slug):
     """The one resolver: the first layout root that holds the line, else the
     `open/` path a new line is created at."""
@@ -485,6 +514,20 @@ def _ws_rel(repo, path):
     return rel if os.path.exists(os.path.join(ws, ".git")) else None
 
 
+def folded(repo):
+    """True when `<repo>/.tezgah` is a folded workspace: a directory the project
+    itself tracks and that holds no repository of its own, so the project's
+    history is the one that carries it (`ensure_workspace` answers None for it by
+    design). A symlinked `.tezgah` and a tree with no `.git` are not folded: the
+    first is refused as repository-provided, the second has no history at all.
+    `workspace_tracked` wants positive evidence, so an index that cannot be read
+    is not folded either."""
+    ws = tp.workspace(repo)
+    return (os.path.isdir(ws) and not os.path.islink(ws)
+            and not os.path.lexists(os.path.join(ws, ".git"))
+            and tp.workspace_tracked(repo))
+
+
 def _ws_log(repo, path, *args):
     """(shas, error) of the private repository's `git log <args>` over `path`'s
     own layout names (`_own_names`) along its HEAD, ([], None) when `path` is
@@ -952,6 +995,13 @@ def _check_state(base, errors, warnings, strict):
     _check_derived_phase(base, state.get("phase"), state.get("direction"), warnings)
 
 
+def _verdict_error(sid, verdict):
+    """The error a verdict outside `VERDICTS` gets; `broken_open_lines` builds the
+    same text for a `pending` one, so an in-flight line is told from a broken one."""
+    return "success criterion %s: verdict %r is not one of %s" % (
+        sid, verdict, ", ".join(VERDICTS))
+
+
 def _check_success(state, errors, warnings, strict):
     """The ask contract, on a line that states an ask (rules 3 onward).
 
@@ -983,8 +1033,7 @@ def _check_success(state, errors, warnings, strict):
         if not sid or not criterion:
             errors.append("a success criterion carries no id or no text")
         if verdict and verdict not in VERDICTS:
-            errors.append("success criterion %s: verdict %r is not one of %s"
-                          % (sid, verdict, ", ".join(VERDICTS)))
+            errors.append(_verdict_error(sid, verdict))
         if verdict in VERDICTS and not evidence:
             errors.append("success criterion %s: a verdict with no evidence "
                           "pointer is an opinion" % sid)
@@ -992,7 +1041,7 @@ def _check_success(state, errors, warnings, strict):
         unjudged = [sid for sid, _c, verdict, _e in rows if verdict not in VERDICTS]
         if unjudged:
             errors.append("concluded with no verdict for %s: judge each criterion "
-                          "(`tezgah-research verdict`) before concluding"
+                          "(`~/.config/tezgah/bin/tezgah-research verdict`) before concluding"
                           % ", ".join(unjudged))
         if unanswered(state) and not (state.get("closed") or {}).get("ack") \
                 and not _user_event(state):
@@ -1237,7 +1286,7 @@ def _check_findings(base, errors, warnings, strict):
     missing = [s for s in FINDINGS_SECTIONS if ("## " + s) not in text]
     if missing:
         errors.append("findings.md does not answer: %s" % ", ".join(missing))
-    _check_patterns(text, errors, warnings, strict)
+    _check_patterns(text, errors, warnings, strict, _evidence(_state(base)))
 
 
 PATTERNS_BULLET = re.compile(r"^\s*(?:[-*+]|\d+[.)])\s+(.*)$")
@@ -1256,7 +1305,7 @@ def _section(text, name):
     return out
 
 
-def _check_patterns(text, errors, warnings, strict):
+def _check_patterns(text, errors, warnings, strict, wrapped):
     """Every bullet under `## Patterns` names the source it came from.
 
     A pattern is the one finding a reader is meant to carry into other work, so
@@ -1265,9 +1314,17 @@ def _check_patterns(text, errors, warnings, strict):
     none is a guess wearing the clothes of a finding, which is exactly the
     failure the review exists to catch, and it is reported once per line with the
     count so a line with seventeen of them says so in one row rather than
-    seventeen."""
-    bullets = [m.group(1).strip() for line in _section(text, "Patterns")
-               for m in [PATTERNS_BULLET.match(line)] if m]
+    seventeen. With `wrapped` (a rules-8 line, `_evidence`) a bullet is its first
+    line plus every following indented, non-blank line before the next bullet
+    (spec 4.7): a source wrapped onto a continuation line is still the bullet's
+    source. An older line reads each bullet's first line, as it was opened under."""
+    bullets = []
+    for line in _section(text, "Patterns"):
+        found = PATTERNS_BULLET.match(line)
+        if found:
+            bullets.append(found.group(1).strip())
+        elif wrapped and bullets and line[:1].isspace() and line.strip():
+            bullets[-1] += " " + line.strip()
     unsourced = [b for b in bullets if not PATTERNS_SOURCE.search(b)]
     if unsourced:
         _soft(errors, warnings, strict,
@@ -1707,14 +1764,17 @@ def _check_claims(base, errors, warnings, roots=(), strict=False):
         # held to their proof here. Warning on the historical statement too would
         # make a correction that rewords a figure impossible to land (it already
         # cannot edit the row), for a sentence no reader is meant to keep.
-        if cid not in superseded:
+        # rules 8 replaces this rule by `untraced-number`, a step that never refuses
+        if cid not in superseded and not _evidence(line_state):
             _check_claim_numbers(cid, claim, base, repo, errors, warnings, strict)
         _check_claim_raters(cid, claim, base, errors, warnings, strict)
         if sections and cid not in superseded:
             problem = _token_claim_problem(cid, claim, base)
             if problem:
                 errors.append(problem)
-    _check_supersedes(parsed, errors, warnings, strict)
+    _check_supersedes(parsed, errors, warnings, strict,
+                      _note_text(os.path.join(base, "to_human", "report.md"))
+                      if _evidence(line_state) else None)
     if not count:
         warnings.append("no claims recorded yet")
     return count
@@ -1738,7 +1798,7 @@ def _token_claim_problem(cid, claim, base):
     return None
 
 
-def _check_supersedes(parsed, errors, warnings, strict):
+def _check_supersedes(parsed, errors, warnings, strict, report=None):
     """A claim that supersedes another names one this line holds, and says so.
 
     The record is append-only: a claim whose number went stale is corrected by a
@@ -1760,6 +1820,10 @@ def _check_supersedes(parsed, errors, warnings, strict):
                 errors.append("claim %s supersedes %s, and no claim in this line "
                               "carries that id" % (cid, ref))
                 continue
+            # rules 8 (spec 4.6): a report line naming both ids tells the reader
+            if report is not None and any(_mentions(cid, line) and _mentions(ref, line)
+                                          for line in report.splitlines()):
+                continue
             _soft(errors, warnings, strict,
                   "claim %s supersedes %s: a reader who opens %s alone reads the "
                   "statement this line has since replaced" % (cid, ref, ref))
@@ -1787,6 +1851,11 @@ def _supersedes(claim):
     return ids, None
 
 
+def _superseded(rows):
+    """The claim ids some row supersedes (`_supersedes`): the historical rows."""
+    return {ref for row in rows for ref in _supersedes(row)[0]}
+
+
 def _claim_ids(base, handle=None):
     """The ids `claims.jsonl` already carries, for the rule that a claim may only
     supersede one this line holds. A row that does not parse is skipped here: the
@@ -2027,6 +2096,12 @@ def claim_problems(claim, base, repo, held=None):
         if scopes and all(s == "fixture" for s in scopes):
             problems.append("claim %s declares scope real and every row it rests on "
                             "records fixture" % cid)
+    # rules 8: the claim refusals `_core_rules8` applies, from the same functions, and
+    # like it never to a claim a row supersedes (the correction is that row)
+    if _evidence(_state(base)) and cid not in _superseded(
+            _row_objects(os.path.join(base, "claims.jsonl"))):
+        problems.extend(derived_problems(cid, claim, base))
+        problems.extend(fired_problems(cid, claim, base))
     return problems
 
 
@@ -2329,10 +2404,17 @@ def _check_tracking(repo, base, errors, warnings, strict):
             if not pattern:
                 continue
             rel = _ws_rel(repo, path)
-            fix = ("`git -C .tezgah add -f %s`" % rel if rel is not None else
-                   "`.tezgah` has no git repository of its own - `tezgah-research "
-                   "commit %s \"<message>\"` creates it and commits the line there"
-                   % os.path.basename(base))
+            if rel is not None:
+                fix = "`git -C .tezgah add -f %s`" % rel
+            elif folded(repo):
+                # a forced add of a `.tezgah/` path is the control rule's to refuse
+                fix = ("`.tezgah` is tracked by the project - drop that ignore line, "
+                       "then `~/.config/tezgah/bin/tezgah-research commit %s \"<message>\"` commits the "
+                       "line in the project's history" % os.path.basename(base))
+            else:
+                fix = ("`.tezgah` has no git repository of its own - `~/.config/tezgah/bin/tezgah-research "
+                       "commit %s \"<message>\"` creates it and commits the line there"
+                       % os.path.basename(base))
             _soft(errors, warnings, strict,
                   "experiment %s: %s is ignored by %s, so no commit can show the "
                   "protocol predates the results; %s"
@@ -2532,7 +2614,7 @@ def _check_literature(base, errors, warnings, strict):
             _soft(errors, warnings, note in legacy or newer,
                   "literature/%s is not in INDEX.jsonl: a note the index does not "
                   "name is a source no reader can weigh" % note)
-    _index_fields(rows, errors, warnings, strict)
+    _index_fields(rows, errors, warnings, strict, _evidence(_state(base)))
 
 
 def _read_index(index, literature, errors, warnings, strict):
@@ -2572,9 +2654,10 @@ def _read_index(index, literature, errors, warnings, strict):
     return rows, named
 
 
-def _index_fields(rows, errors, warnings, strict):
+def _index_fields(rows, errors, warnings, strict, evidence=False):
     """The index entries the rules read: a grey source's quality, a verification
-    against two records, and the three fields a note has to carry."""
+    against two records (rules 8 reads its receipts instead), and the three fields a
+    note has to carry."""
     total = len(rows)
     if not total:
         return
@@ -2585,8 +2668,8 @@ def _index_fields(rows, errors, warnings, strict):
               "literature/INDEX.jsonl: %d of %d rows are a grey source with no "
               "quality note, so nothing says how good the practice evidence is"
               % (len(grey), total))
-    verified = [r for r in rows
-                if not isinstance(r.get("verified"), list) or len(r["verified"]) < 2]
+    verified = [] if evidence else [
+        r for r in rows if not isinstance(r.get("verified"), list) or len(r["verified"]) < 2]
     if verified:
         _soft(errors, warnings, strict,
               "literature/INDEX.jsonl: %d of %d rows are verified by fewer than "
@@ -2761,6 +2844,11 @@ def _rules(state):
     return value if isinstance(value, int) and not isinstance(value, bool) else 1
 
 
+def _evidence(state):
+    """True for a line opened under the evidence rules (`EVIDENCE_RULES`)."""
+    return _rules(state) >= EVIDENCE_RULES
+
+
 def _state(base):
     """state.json as an object, or {} when it is missing or unreadable."""
     state, exc = _read_json(os.path.join(base, "state.json"))
@@ -2770,10 +2858,10 @@ def _state(base):
 def newer_rules(state):
     """The refusal for a line a later tezgah wrote, or None.
 
-    A `rules` above `RULES` names rules this code does not implement. Reading the
-    line by the rules it does know would pass what the later set refuses, and a
-    writer would append rows judged by the older set. So the line is refused by
-    name, before any rule reads it."""
+    A `rules` above `RULES` names rules this code does not implement.
+    Reading the line by the rules it does know would pass what the later set
+    refuses, and a writer would append rows judged by the older set. So the line
+    is refused by name, before any rule reads it."""
     found = _rules(state)
     if found <= RULES:
         return None
@@ -2791,20 +2879,22 @@ def _concluding(base, state):
             or os.path.isfile(os.path.join(base, "to_human", "report.md")))
 
 
-def file_versions(repo, path):
+def file_versions(repo, path, every_ref=True):
     """[(sha, text)] of every committed version of `path`, oldest first; [] when git
     cannot say. The append-only rule compares versions, which the added/last-touched
     pair cannot. The project's history is read first and the private `.tezgah`
     repository's after it, like `added_commits`: a line committed in the project
     before the move has its older versions there.
 
-    The order rules read HEAD's lineage; this reads every ref of the private
-    repository (`--all`), because it looks for a rewrite and not an order: a row
-    amended away while a tag keeps the old commit is a result rewritten after the
-    run, which HEAD alone no longer shows (an internal research decision). A side
-    ref can only add a version, so it can refuse a line and never pass one."""
+    By default this reads every ref of the private repository (`--all`), because
+    the results rule looks for a rewrite: a row amended away while a tag keeps the
+    old commit is a result rewritten after the run, which HEAD alone no longer
+    shows (an internal research decision); the append-only capture ledgers read it
+    the same way. `every_ref=False` reads HEAD's lineage only, for the order rule of
+    the captures: a backdated side branch read through `--all` supplied the oldest
+    version and satisfied the stopping-rule order."""
     return [v for top, rel in _histories(repo, path)
-            for v in _versions(top, rel, ("--all",) if top != repo else ())]
+            for v in _versions(top, rel, ("--all",) if every_ref and top != repo else ())]
 
 
 def _versions(top, rel, extra=()):
@@ -2890,19 +2980,22 @@ def _evaluation_commit(repo, path):
     return {top: _first_lock(top, rel) for top, rel in _histories(repo, path)}
 
 
+def _orders_lock(state):
+    """True when a line's results are ordered against its evaluation lock: the
+    arena is an exploratory line's lock, and `_check_arena_order` orders every
+    results.jsonl against it instead; a state with no evaluation has none."""
+    return not _exploratory(state) and isinstance(state.get("evaluation"), dict)
+
+
 def _check_evaluation_order(repo, base, state, errors, warnings, strict):
     """The evaluation is locked before the first result, and `locked_at` names a
     commit the history holds. `_check_evaluation` reads that the fields are filled;
     this reads when: a metric and a baseline committed after the results are the
     criterion the results were measured against after the fact."""
-    if _exploratory(state):
-        # the arena is an exploratory line's lock, and `_check_arena_order` orders
-        # every results.jsonl against it the way this orders them against a metric
+    if not _orders_lock(state):
         return
     hard = strict or _rules(state) >= STANDARDS_RULES
-    evaluation = state.get("evaluation")
-    if not isinstance(evaluation, dict):
-        return
+    evaluation = state["evaluation"]
     for token in SHA_TOKEN.findall(str(evaluation.get("locked_at", ""))):
         if is_ancestor(repo, token, "HEAD") is not True:
             _soft(errors, warnings, hard,
@@ -3181,6 +3274,34 @@ def _mentions(token, text):
     return re.search(r"(?<![\w.-])%s(?![\w.-])" % re.escape(token), text) is not None
 
 
+# A decision.md's pick: `chosen:` is the owner's, `recommended:` the line's own
+# (rules 9); every reader takes `chosen:` when present, else `recommended:`.
+PICK = r"(?im)^\W*%s\W*:\s*`?([\w.-]+)"
+# The `owner:` line `choose` writes: a date and the owner's words, quoted.
+OWNER_WORDS = re.compile(r'(?im)^\W*owner\W*:[^\n]*"[^"\n]*\S[^"\n]*"')
+
+
+def decision_pick(body):
+    """(variant, "chosen" or "recommended") for a decision.md body, else (None, None)."""
+    for field in ("chosen", "recommended"):
+        found = re.search(PICK % field, body)
+        if found:
+            return found.group(1), field
+    return None, None
+
+
+def line_pick(body):
+    """The line's own pick, which the line's rules judge (rejected variants,
+    dominance, post-hoc): `recommended:`, else a `chosen:` with no owner's words.
+    An owner's `chosen:` is the owner's call, so a dominated or post-hoc owner
+    choice is never the line's error."""
+    found = re.search(PICK % "recommended", body)
+    if found:
+        return found.group(1)
+    found = re.search(PICK % "chosen", body)
+    return found.group(1) if found and not OWNER_WORDS.search(body) else None
+
+
 def _check_decision(repo, base, name, ddir, need, errors, warnings, strict, git,
                     concluding):
     label = "decisions/%s" % name
@@ -3264,13 +3385,19 @@ def _check_decision(repo, base, name, ddir, need, errors, warnings, strict, git,
               "says what ruled it out" % label)
         return
     body = _note_text(os.path.join(ddir, "decision.md"))
-    found = re.search(r"(?im)^\W*chosen\W*:\s*`?([\w.-]+)", body)
-    chosen = found.group(1) if found else None
+    chosen, field = decision_pick(body)
     if chosen not in produced:
         errors.append("%s: decision.md chosen %r is not a produced variant"
                       % (label, chosen))
+    if field == "chosen" and _rules(_state(base)) >= OWNER_CHOICE_RULES \
+            and not OWNER_WORDS.search(body):
+        errors.append("%s: decision.md chosen %s names no owner choice: the line "
+                      "writes recommended:, and the owner's pick is recorded with "
+                      "tezgah-research choose" % (label, chosen))
+    pick = line_pick(body)
+    owned = chosen if field == "chosen" and OWNER_WORDS.search(body) else None
     for vid in produced:
-        if vid == chosen:
+        if vid in (pick, owned):
             continue
         lines = [line for line in body.splitlines() if _mentions(vid, line)]
         if not any(_mentions(cid, line) for line in lines for cid in criteria):
@@ -3279,12 +3406,12 @@ def _check_decision(repo, base, name, ddir, need, errors, warnings, strict, git,
     if not re.search(r"(?im)^\W*flip\W*:", body):
         errors.append("%s: decision.md names no `flip:` condition - the result that "
                       "would reverse the choice" % label)
-    if chosen in produced:
-        better = dominated_by(chosen, produced, criteria, cells)
+    if pick in produced:
+        better = dominated_by(pick, produced, criteria, cells)
         if better:
             errors.append("%s: the chosen variant %s is dominated by %s, which is at "
                           "least as good on every criterion and better on one"
-                          % (label, chosen, better))
+                          % (label, pick, better))
 
 
 def _deliverable_path(state):
@@ -3533,7 +3660,8 @@ def _check_review_integrity(base, errors, warnings, strict):
               "to_human/review.json names no %s: a review says who produced the line "
               "and who judged it, and those are two readers"
               % ("reviewer" if not reviewer else "producer"))
-    elif reviewer == producer:
+    elif reviewer == producer or (_evidence(state) and re.sub(r"\s+", "", reviewer).casefold()
+                                  == re.sub(r"\s+", "", producer).casefold()):
         errors.append("to_human/review.json reviewer %r is the producer: a line graded "
                       "by the session that wrote it is not reviewed" % reviewer)
     if review.get("findings") == []:
@@ -3551,14 +3679,977 @@ def _check_review_integrity(base, errors, warnings, strict):
                       % (" and ".join(high), len(order), order[0][:80]))
 
 
-def check_line(repo, slug, git=True, strict=False, code=None):
+# --- rules 8 (plan 127): steps, routing and the execution trail ----------------
+# A line opened under `EVIDENCE_RULES` is read for the steps that narrow each
+# claim's certainty (spec section 2) beside its refusals. `_check_rules8` threads
+# one `steps` dict - claim id -> step names in the order found - through the
+# capture module, the checks below and the evidence module, which turns the steps
+# into levels. Keys starting with `#` are the channel, never claim ids: `#flags`
+# (what `check` was asked), `#report` (the report lines `check` prints and never
+# counts), `#certainty` (each claim's level, for `check --json`) and `#stats`
+# ("experiment <h>" -> the statistics error `_check_rules8` refuses).
+
+QUESTION_CLASSES = tuple("R%d" % n for n in range(13))
+CLASS_METHODS = dict(
+    [(c, ("qualitative",)) for c in ("R1", "R2", "R7", "R8", "R9", "R10")]
+    + [(c, ("qualitative", "measured")) for c in ("R3", "R12")]
+    + [(c, ("measured",)) for c in ("R4", "R5", "R6")] + [("R11", ("exploratory",))])
+SEARCH_CLASSES = ("R1", "R2", "R7", "R8", "R9", "R10")
+# sources / searches / runs per tier: starting values, to re-measure (spec 3.3)
+BUDGETS = {"quick": (10, 10, 10), "study": (30, 40, 40), "program": (100, 150, 200)}
+LITERATURE_STEPS = ("header-mismatch", "unindexed-source", "online-drift",
+                    "abstract-only", "source-not-captured", "one-provider")
+SEARCH_STEPS = ("one-connector", "no-counter-search", "no-stopping-rule",
+                "stopping-not-met", "known-item-missed", "screened-outside-search")
+EXPERIMENT_STEPS = ("no-replication", "no-power-plan", "below-planned-n", "no-interval",
+                    "interval-includes-zero", "below-achieved-mde",
+                    "no-multiplicity-correction", "fails-multiplicity", "no-sesoi",
+                    "tost-not-passed", "instrument-unvalidated", "instrument-rejected",
+                    "judged-row-incomplete", "falsifier-not-evaluable")
+CLASS_STEPS = {"R2": ("no-grey-quality",), "R3": ("no-population",),
+               "R4": ("no-confounders",),
+               "R5": ("fewer-than-two-rivals", "no-positive-control"),
+               "R6": ("fewer-than-two-rivals",),
+               "R7": ("no-dual-screening", "no-recall-stopping"),
+               "R8": ("no-dual-screening",), "R9": ("no-amstar",), "R10": ("no-codebook",),
+               "R12": ("fewer-than-two-approaches",)}
+TERMINAL_STATUSES = ("supported", "refuted", "weakened", "revised", "untested",
+                     "inconclusive")
+DEAD_ROWS = ("aborted", "failed")
+# The comparator words match ASCII-case-insensitively (`(?a:...)`): a Unicode
+# IGNORECASE lets U+017F match `s`, a spelling FALSIFIER_OPS holds no key for
+# (review round two R2-2).
+FALSIFIER_COMPARATOR = re.compile(
+    r"(?i)(?:<=|>=|≤|≥|<|>|=|\b(?a:at most|at least|above|below|less than|more than"
+    r"|fewer than|greater than|exceeds?|under|over))\s*-?\d")
+FALSIFIER_TEST = re.compile(
+    r"(?i)\b(?:t-test|welch|wilcoxon|mann-whitney|chi-square|fisher|binomial|tost)\b")
+FALSIFIER_ALPHA = re.compile(r"(?i)\balpha\s*=?\s*0?\.\d+")
+# The structured form (spec 2.2) takes every comparator the grammar above names; each
+# maps to the operator it means. Anything else stays unevaluated (review D3-2).
+FALSIFIER_OPS = {"<=": "<=", ">=": ">=", "≤": "<=", "≥": ">=", "<": "<", ">": ">", "=": "=",
+                 "at most": "<=", "at least": ">=", "above": ">", "below": "<",
+                 "less than": "<", "more than": ">", "fewer than": "<", "greater than": ">",
+                 "exceeds": ">", "exceed": ">", "under": "<", "over": ">"}
+FALSIFIER_FORM = re.compile(
+    r"(?i)^([\w.-]+)(?:\s*(<=|>=|≤|≥|<|>|=)|\s+(?a:(at\s+most|at\s+least|above|below"
+    r"|less\s+than|more\s+than|fewer\s+than|greater\s+than|exceeds?|under|over)))"
+    r"\s*(-?\d+(?:\.\d+)?)(?:\s+on\s+(\S+))?\s*$")
+# A protocol number (spec 2.3): `0.05`, `.05`, `5%` (0.05), `1e-1`.
+PROTOCOL_NUMBER = re.compile(r"([-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?)(\s*%)?")
+# Each checked protocol number's open range (lower, upper; None = unbounded).
+PROTOCOL_RANGES = {"alpha": (0.0, 1.0), "power": (0.0, 1.0), "sesoi": (0.0, None),
+                   "mde": (0.0, None)}
+COMPARE_FORM = re.compile(
+    r"(?i)^(\S+)\s+vs\s+(\S+)\s+on\s+([\w.-]+)\s*,\s*(lower|higher)\s+is\s+better")
+CLAIM_NUMBER = re.compile(r"(?<![\w.])-?\d+(?:\.\d+)?(?![\w.])")
+DERIVED_REF = re.compile(r"^([\w.-]+)/(#\d+|[\w.-]+):([\w.-]+)$")
+UNIVERSAL_WORDS = re.compile(r"(?i)\b(every|all|always|never|any)\b")
+CAUSAL_WORDS = re.compile(r"(?i)\b(causes|caused|cause|leads to|due to|because of)\b")
+CODE_SUFFIXES = (".py", ".sh", ".js", ".ts", ".rs", ".go")
+
+
+def obligations(cls, method=""):
+    """The step names of spec section 2 a line of class `cls` can trigger."""
+    out = ["no-question-class", "class-unreviewed", "method-not-allowed",
+           "untraced-number", "uncalibrated-verifier"] + list(LITERATURE_STEPS)
+    if cls in SEARCH_CLASSES or method == "qualitative":
+        out += SEARCH_STEPS
+    if method == "measured" or "measured" in CLASS_METHODS.get(cls, ()):
+        out += EXPERIMENT_STEPS
+    return out + list(CLASS_STEPS.get(cls, ()))
+
+
+def _step(steps, cid, name):
+    """Name `name` once for claim `cid`, in the order found."""
+    found = steps.setdefault(cid, [])
+    if name not in found:
+        found.append(name)
+
+
+def _fields(text):
+    """{key: [values]} of every column-0 `key: value` line of a protocol."""
+    out = {}
+    for line in text.lstrip("\ufeff").splitlines():
+        found = PROTOCOL_LABEL.match(line)
+        if found:
+            out.setdefault(found.group(1).lower(), []).append(found.group(2).strip())
+    return out
+
+
+def _first(fields, key):
+    return (fields.get(key) or [""])[0]
+
+
+def _number(value):
+    """The first number of a protocol value (`PROTOCOL_NUMBER`), a percent read as its
+    fraction; None without one."""
+    found = PROTOCOL_NUMBER.search(value or "")
+    if not found:
+        return None
+    number = float(found.group(1))
+    return number / 100 if found.group(2) else number
+
+
+def protocol_number(key, value):
+    """(number, problem) of the protocol line `key: value`, `key` one of PROTOCOL_RANGES:
+    the one reader `check`, `claim`, the session context and the instruments share.
+    (None, None) when the line is absent or empty; a value with no number, or one
+    outside its range (alpha, power in (0, 1); sesoi, mde above 0), is an invalid
+    record: (None, the refusal naming the key and the value). So is an alpha so close
+    to 0 that alpha/2 or 1 - alpha/2, the quantiles the intervals read, is 0 or 1 as a
+    float (`1e-20`, review round two R2-1)."""
+    value = (value or "").strip()
+    if not value:
+        return None, None
+    number = _number(value)
+    lo, hi = PROTOCOL_RANGES[key]
+    if number is not None and math.isfinite(number) and number > lo \
+            and (hi is None or number < hi):
+        if key == "alpha" and not (number / 2 > 0 and 1 - number / 2 < 1):
+            return None, "protocol.md alpha: %s leaves a quantile at 0 or 1" % value
+        return number, None
+    return None, "protocol.md %s: %s is not a number %s" % (
+        key, value, "above 0" if hi is None else "in (0, 1)")
+
+
+def _numeric(value):
+    return isinstance(value, (int, float)) and not isinstance(value, bool)
+
+
+def _live(rows):
+    """Rows that count. A refile is a correction: the latest row filed for the same
+    `run`, `arm`, `item` and `instrument` stands for it, so one run measured over
+    several arms or items keeps a row for each; a row with no `run` counts on its
+    own. An `aborted` or `failed` run stays a row and counts nowhere."""
+    key = lambda r: tuple(str(r.get(k)) for k in ("run", "arm", "item", "instrument"))  # noqa: E731
+    last = {key(r): n for n, r in enumerate(rows) if r.get("run") is not None}
+    return [r for n, r in enumerate(rows)
+            if (r.get("run") is None or last[key(r)] == n)
+            and r.get("status") not in DEAD_ROWS]
+
+
+def _groups(rows):
+    """{group: rows}: by `arm`, else `phase`, else one group `all`."""
+    live = _live(rows)
+    key = next((k for k in ("arm", "phase") if any(k in r for r in live)), None)
+    out = {}
+    for row in live:
+        out.setdefault(str(row[key]) if key in row else "all", []).append(row)
+    return out
+
+
+def _paired(rows_a, rows_b):
+    """The two groups aligned by `item` when both carry the same item set, else None."""
+    items_a, items_b = [r.get("item") for r in rows_a], [r.get("item") for r in rows_b]
+    if None in items_a or None in items_b or len(set(map(str, items_a))) != len(items_a):
+        return None
+    if sorted(map(str, items_a)) != sorted(map(str, items_b)):
+        return None
+    order = {str(i): n for n, i in enumerate(items_a)}
+    return rows_a, sorted(rows_b, key=lambda r: order[str(r.get("item"))])
+
+
+def _effect(fields, groups, alpha, power):
+    """The `compare:` line's effect (spec 2.3), or None without one."""
+    import tezgah_research_stats as stats
+    found = COMPARE_FORM.match(_first(fields, "compare"))
+    if not found:
+        return None
+    t, c, field, better = found.groups()
+    rows_t, rows_c = groups.get(t, []), groups.get(c, [])
+    out = {"t": t, "c": c, "field": field, "n": (len(rows_t), len(rows_c)),
+           "effect": None, "ci": None, "mde": None, "p": None, "a": [], "b": [],
+           "paired": False}
+    rows_t = [r for r in rows_t if _numeric(r.get(field))]
+    rows_c = [r for r in rows_c if _numeric(r.get(field))]
+    if better.lower() == "lower":
+        rows_t, rows_c = rows_c, rows_t
+    aligned = _paired(rows_t, rows_c) if len(rows_t) >= 2 else None
+    if aligned:
+        rows_t, rows_c = aligned
+    a, b = [float(r[field]) for r in rows_t], [float(r[field]) for r in rows_c]
+    out.update(a=a, b=b, paired=bool(aligned))
+    if a and b:
+        out["effect"] = sum(a) / len(a) - sum(b) / len(b)
+    if len(a) >= 2 and len(b) >= 2:
+        diff = stats.mean_diff(a, b, alpha, paired=bool(aligned))
+        out.update(effect=diff["effect"], ci=(diff["lo"], diff["hi"]), p=diff["p"],
+                   mde=stats.achieved_mde(diff["se"], alpha, power))
+    return out
+
+
+def _stats_failed(exp, exc):
+    """Keep an experiment's first statistics error (ValueError, ArithmeticError);
+    `_check_rules8` turns it into the experiment's one refusal (review round two R2-1)."""
+    if not exp.get("stats_error"):
+        exp["stats_error"] = str(exc) or type(exc).__name__
+
+
+def experiment_record(base, h):
+    """One experiment as the rules-8 checks read it: protocol fields, rows, groups,
+    the plan's numbers and the `compare:` effect. `invalid` holds the refusal of each
+    protocol number outside its range; an invalid alpha or power is None and leaves
+    the effect uncomputed, so no statistic runs on it. A statistics error leaves the
+    effect None and lands in `stats_error`."""
+    d = os.path.join(base, "experiments", h)
+    fields = _fields(_note_text(os.path.join(d, "protocol.md")))
+    rows = _row_objects(os.path.join(d, "results.jsonl"))
+    groups = _groups(rows)
+    plan = {k: protocol_number(k, _first(fields, k)) for k in PROTOCOL_RANGES}
+    alpha, power = (None if plan[k][1] else plan[k][0] or default
+                    for k, default in (("alpha", 0.05), ("power", 0.80)))
+    exp = {"h": h, "dir": d, "fields": fields, "rows": rows, "groups": groups,
+           "alpha": alpha, "power": power, "sesoi": plan["sesoi"][0],
+           "invalid": [problem for _, problem in plan.values() if problem],
+           "effect": None, "stats_error": None}
+    if alpha is not None and power is not None:
+        try:
+            exp["effect"] = _effect(fields, groups, alpha, power)
+        except (ValueError, ArithmeticError) as exc:
+            _stats_failed(exp, exc)
+    return exp
+
+
+def falsifier_unscoped(text, groups):
+    """True when a structured falsifier names no `on <group>` while the rows hold
+    more than one group: its mean would pool the control with the arm it judges."""
+    found = FALSIFIER_FORM.match(text)
+    return bool(found and not found.group(5) and len(groups) > 1)
+
+
+def falsifier_fired(exp):
+    """(falsifier, mean) when the structured `falsifier:` holds over its rows, else
+    None - also when the group holds no row carrying the field, and when it names no
+    group over several (`falsifier_unscoped`)."""
+    text = _first(exp["fields"], "falsifier")
+    found = FALSIFIER_FORM.match(text)
+    if not found or falsifier_unscoped(text, exp["groups"]):
+        return None
+    field, symbol, words, number, group = found.groups()
+    op = FALSIFIER_OPS.get(" ".join((symbol or words).casefold().split()))
+    if op is None:
+        return None
+    rows = exp["groups"].get(group, []) if group else _live(exp["rows"])
+    values = [float(r[field]) for r in rows if _numeric(r.get(field))]
+    if not values:
+        return None
+    mean, x = sum(values) / len(values), float(number)
+    holds = {"<": mean < x, "<=": mean <= x, ">": mean > x, ">=": mean >= x,
+             "=": mean == x}[op]
+    return (text, mean) if holds else None
+
+
+def _claim_experiments(claim, base):
+    return [h for h in _experiments_named(_cited(claim.get("proof")))
+            if os.path.isdir(os.path.join(base, "experiments", h))]
+
+
+def fired_problems(cid, claim, base):
+    """The refusal for a `supported` claim whose cited experiment's falsifier fired."""
+    if claim.get("status") != "supported":
+        return []
+    out = []
+    for h in _claim_experiments(claim, base):
+        fired = falsifier_fired(experiment_record(base, h))
+        if fired:
+            out.append("claim %s is supported while its falsifier fired: experiments/%s "
+                       "`falsifier: %s` holds at a mean of %s" % (cid, h, fired[0],
+                                                                 "%g" % fired[1]))
+    return out
+
+
+def _ref_value(base, ref):
+    """The number `<h>/<run>:<field>` or `<h>/#<row>:<field>` names, as the Decimal of
+    the value written in the row (`repr` gives back a JSON float's shortest digits), or
+    None."""
+    found = DERIVED_REF.match(str(ref).strip())
+    if not found:
+        return None
+    h, which, field = found.groups()
+    rows = _row_objects(os.path.join(base, "experiments", h, "results.jsonl"))
+    if which.startswith("#"):
+        k = int(which[1:])
+        row = rows[k - 1] if 1 <= k <= len(rows) else None
+    else:
+        row = next((r for r in reversed(rows) if str(r.get("run")) == which), None)
+    value = row.get(field) if row else None
+    if not _numeric(value) or (isinstance(value, float) and not math.isfinite(value)):
+        return None
+    return decimal.Decimal(repr(value))
+
+
+def _recompute(spec, base):
+    if not isinstance(spec, dict) or not isinstance(spec.get("of"), list):
+        return None
+    op, refs = spec.get("op"), spec["of"]
+    if op == "count":
+        return decimal.Decimal(len(refs))
+    values = [_ref_value(base, ref) for ref in refs]
+    if not values or None in values:
+        return None
+    if op in ("diff", "ratio"):
+        if len(values) != 2 or (op == "ratio" and values[1] == 0):
+            return None
+        return values[0] - values[1] if op == "diff" else values[0] / values[1]
+    return {"mean": lambda v: sum(v) / len(v), "sum": sum, "min": min,
+            "max": max}.get(op, lambda v: None)(values)
+
+
+def _rounds_to(value, written):
+    """True when `value` (a Decimal) rounded half-up or half-even at the precision of the
+    number as written equals it."""
+    try:
+        target = decimal.Decimal(written)
+        return any(value.quantize(target, rounding=mode) == target
+                   for mode in (decimal.ROUND_HALF_UP, decimal.ROUND_HALF_EVEN))
+    except decimal.DecimalException:
+        return False
+
+
+def derived_problems(cid, claim, base):
+    """The refusals for `derived_from` entries whose recomputed value differs from
+    the number as written (spec 2.4); writer and checker read this one rule. The
+    arithmetic is decimal over the rows' written values, so 2.675 is 2.675, not the
+    binary float below it."""
+    derived = claim.get("derived_from")
+    if derived is None:
+        return []
+    if not isinstance(derived, dict):
+        return ["claim %s derived_from is not an object of number -> {op, of}" % cid]
+    out = []
+    with decimal.localcontext() as ctx:
+        ctx.prec = 50
+        for written, spec in derived.items():
+            value = _recompute(spec, base)
+            if value is None or not _rounds_to(value, written):
+                out.append("claim %s derived_from %s does not recompute: %s gives %s"
+                           % (cid, written, json.dumps(spec),
+                              "nothing" if value is None else "%g" % value))
+    return out
+
+
+def _log_tokens(exp, row, cache):
+    rel = row.get("log")
+    if not isinstance(rel, str) or not rel:
+        return set()
+    for root in (exp["dir"], os.path.dirname(os.path.dirname(exp["dir"]))):
+        path = os.path.join(root, rel)
+        if os.path.isfile(path):
+            if path not in cache:
+                cache[path] = set(CLAIM_NUMBER.findall(_note_text(path)))
+            return cache[path]
+    return set()
+
+
+def _untraced(claim, cited):
+    """The numbers of an evidence claim no cited row holds with its log, and no
+    `derived_from` entry names (spec 2.4)."""
+    derived = claim.get("derived_from")
+    derived = derived if isinstance(derived, dict) else {}
+    cache, out = {}, []
+    for token in CLAIM_NUMBER.findall(str(claim.get("statement", ""))):
+        if token in derived:
+            continue
+        value = float(token)
+        if not any(token in _log_tokens(exp, row, cache)
+                   and any(_numeric(v) and float(v) == value for v in row.values())
+                   for exp in cited for row in _live(exp["rows"])):
+            out.append(token)
+    return out
+
+
+def _rivals(fields):
+    return [v for v in fields.get("rival", [])
+            if re.match(r"\S.*\sexcludes:\s*\S", v)]
+
+
+def _observational(fields):
+    design = _first(fields, "design").lower()
+    return design == "observational" or (not design and not _first(fields, "change"))
+
+
+def _experiment_steps(claim, cited, cls, measured, rejected):
+    """The section-2 steps an experiment claim takes from the experiments it cites."""
+    import tezgah_research_stats as stats
+    out = []
+    no_difference = claim.get("effect") == "no-difference"
+    for exp in cited:
+        fields, groups, eff = exp["fields"], exp["groups"], exp["effect"]
+        if cls in ("R5", "R6") and len(_rivals(fields)) < 2:
+            out.append("fewer-than-two-rivals")
+        if not groups or any(len(rows) < 2 for rows in groups.values()):
+            out.append("no-replication")
+        if measured and not all(_first(fields, k) for k in ("alpha", "power", "mde", "n")):
+            out.append("no-power-plan")
+        falsifier = _first(fields, "falsifier")
+        if measured and falsifier and (not falsifier_testable(falsifier)
+                                       or falsifier_unscoped(falsifier, groups)):
+            out.append("falsifier-not-evaluable")
+        if eff:
+            planned = _number(_first(fields, "n"))
+            if planned is not None and min(eff["n"]) < planned:
+                out.append("below-planned-n")
+            if eff["ci"] is None:
+                out.append("no-interval")
+            elif not no_difference:
+                if eff["ci"][0] <= 0:
+                    out.append("interval-includes-zero")
+                if eff["effect"] < eff["mde"]:
+                    out.append("below-achieved-mde")
+        correction = _first(fields, "correction")
+        if len(groups) > 2 and not correction:
+            out.append("no-multiplicity-correction")
+        if correction and exp["h"] not in rejected:
+            out.append("fails-multiplicity")
+        if no_difference:
+            sesoi = exp["sesoi"]
+            if sesoi is None:
+                out.append("no-sesoi")
+            else:
+                try:
+                    passed = bool(eff and eff["ci"] and stats.tost(
+                        eff["a"], eff["b"], sesoi, exp["alpha"], eff["paired"]))
+                except (ValueError, ArithmeticError) as exc:
+                    _stats_failed(exp, exc)
+                    passed = False
+                if not passed:
+                    out.append("tost-not-passed")
+    return out
+
+
+def _multiplicity(base, exps):
+    """The experiments their declared `correction:` rejects, corrected together."""
+    import tezgah_research_stats as stats
+    tests = {"bh": stats.bh, "holm": stats.holm, "bonferroni": stats.bonferroni}
+    by = {}
+    for h, exp in sorted(exps.items()):
+        method = _first(exp["fields"], "correction").strip().lower()
+        if method and exp["effect"]:
+            by.setdefault(method, []).append(h)
+    rejected = set()
+    for method, hs in by.items():
+        alpha = min(exps[h]["alpha"] for h in hs)
+        try:
+            if method == "e-bh":
+                values = [_number(_first(_fields(_note_text(os.path.join(
+                    exps[h]["dir"], "analysis.md"))), "e-value")) or 0.0 for h in hs]
+                flags = stats.ebh(values, alpha)
+            elif method in tests:
+                p = [exps[h]["effect"]["p"] for h in hs]
+                flags = tests[method]([1.0 if v is None else v for v in p], alpha)
+            else:
+                continue
+        except (ValueError, ArithmeticError) as exc:
+            for h in hs:
+                _stats_failed(exps[h], exc)
+            continue
+        rejected.update(h for h, flag in zip(hs, flags) if flag)
+    return rejected
+
+
+def _format_ci(lo, hi):
+    return "[%.4f, %.4f]" % (lo, hi)
+
+
+def falsifier_testable(text):
+    """True when a falsifier holds a comparator and a number, or a named test with its
+    alpha (spec 2.2)."""
+    return bool(FALSIFIER_COMPARATOR.search(text)
+                or (FALSIFIER_TEST.search(text) and FALSIFIER_ALPHA.search(text)))
+
+
+# A `metric:` list splits at the commas that separate names: never inside parentheses
+# (`(ms, median of 5 runs)`), never between digit groups (`10,000-piece`), and never
+# inside the locked name, which is one name (plan 128 K1, K3).
+METRIC_COMMA = re.compile(r",(?![^()]*\))(?!(?<=\d,)\d)")
+# A word of a metric name, for the reworded comparison: hyphen and underscore split,
+# digits kept (`p95`), and the joining words a reworded name may drop or add
+# (`of`, `the`, `per`) ignored.
+METRIC_WORD = re.compile(r"[0-9a-z]+")
+METRIC_JOIN = {"a", "an", "the", "of", "for", "in", "on", "to", "per", "by", "with"}
+
+
+def _metric_key(name):
+    """A metric name as the rules compare it: casefolded, whitespace collapsed, a
+    trailing parenthetical (`(ms)`) dropped."""
+    return " ".join(re.sub(r"\s*\([^)]*\)\s*$", "", str(name or "")).casefold().split())
+
+
+def _metric_words(key):
+    return {w for w in METRIC_WORD.findall(key) if w not in METRIC_JOIN}
+
+
+def _same_metric(a, b):
+    """True when one metric key is the other or a word-boundary prefix of it, either
+    way (plan 128 K2), or a rewording of it: every word of `b` sits in `a`, in any
+    order and with the joining words ignored (`read-path p95 latency` is
+    `p95 latency of the read path`, K6 raters X6 and Y6)."""
+    if a == b or a.startswith(b + " ") or b.startswith(a + " "):
+        return True
+    words = _metric_words(b)
+    return bool(words) and words <= _metric_words(a)
+
+
+def _registered(state, fields):
+    """(names, keys, locked key): the metrics a protocol's `metric:` lines register,
+    split at METRIC_COMMA with the locked name kept whole, and the line's lock."""
+    evaluation = state.get("evaluation") if isinstance(state.get("evaluation"), dict) else {}
+    locked = _metric_key(evaluation.get("metric"))
+    whole = re.compile(r"\s*,\s*".join(r"\s+".join(map(re.escape, part.split()))
+                                       for part in locked.split(",")), re.I) \
+        if "," in locked else None
+    names = []
+    for value in fields.get("metric", []):
+        if whole:
+            value = whole.sub(lambda m: m.group(0).replace(",", "\0"), value)
+        names += [m.strip().replace("\0", ",") for m in METRIC_COMMA.split(value)
+                  if m.strip()]
+    return names, [_metric_key(m) for m in names], locked
+
+
+def metric_problem(state, fields):
+    """The locked-metric refusal of a protocol's `metric:` lines, or None (spec 2.2):
+    one of them has to be the locked metric (`_same_metric`). `source` asks it
+    before a rules-8 capture freezes the protocol (plan 128 K4)."""
+    names, keys, locked = _registered(state, fields)
+    if locked and keys and not any(_same_metric(k, locked) for k in keys):
+        return ("protocol.md registers a metric other than the locked one (%s, locked: %s)"
+                % (", ".join(names), locked))
+    return None
+
+
+def _check_experiment8(repo, slug, base, state, exp, report, errors, warnings, strict,
+                       git, lines, code=None):
+    """One experiment's rules-8 refusals (2.2, 2.4) and report lines (2.3)."""
+    import tezgah_research_stats as stats
+    h, fields = exp["h"], exp["fields"]
+    label = "experiment %s" % h
+    errors.extend("%s: %s" % (label, problem) for problem in exp["invalid"])
+    problem = metric_problem(state, fields)
+    if problem:
+        errors.append("%s: %s" % (label, problem))
+    if report is not None:
+        metrics, norm, locked = _registered(state, fields)
+        excused = {_metric_key(v.split(":", 1)[0])
+                   for v in fields.get("not_reported", []) if ":" in v}
+        text = " ".join(report.casefold().split())
+        # protocol.md is frozen once the run is filed (`changed after the run`), so
+        # `not_reported:` is an exit only before it (plan 128 K5)
+        exit_ = ("the run is filed, so protocol.md is frozen: name it in to_human/report.md"
+                 if exp["rows"] else
+                 "name it in to_human/report.md, or before the run mark it "
+                 "`not_reported: <metric>: <reason>` in protocol.md")
+        for metric, key in zip(metrics, norm):
+            # a registered metric that is the locked one (the rule above's
+            # equivalence) is reported where the report names the locked metric
+            refines = locked and _same_metric(key, locked)
+            if (key not in text and not (refines and locked in text)
+                    and key not in excused):
+                errors.append("%s: registered metric %r is neither reported nor marked "
+                              "not_reported - %s" % (label, metric, exit_))
+    evaluator = _first(fields, "evaluator")
+    if evaluator:
+        _check_evaluator(repo, base, state, exp, evaluator, label, errors, git, code)
+    select = re.match(r"(?i)^(min|max)\s+([\w.-]+)", _first(fields, "select"))
+    if select:
+        field = select.group(2)
+        values = {g: [float(r[field]) for r in rows if _numeric(r.get(field))]
+                  for g, rows in exp["groups"].items()}
+        means = {g: sum(v) / len(v) for g, v in values.items() if v}
+        if means:
+            pick = (min if select.group(1).lower() == "min" else max)(
+                sorted(means), key=means.get)
+            found = re.search(r"(?im)^\W*selected\W*:\s*`?([\w.-]+)",
+                              _note_text(os.path.join(exp["dir"], "analysis.md")))
+            if not found:
+                _soft(errors, warnings, strict,
+                      "%s: analysis states no selected group, and `select:` picks %s"
+                      % (label, pick))
+            elif found.group(1) != pick:
+                errors.append("%s: select rule picks %s, and analysis.md selected: %s"
+                              % (label, pick, found.group(1)))
+    for group, rows in exp["groups"].items():
+        # binary: every outcome 0 or 1, a JSON boolean counting as 1/0 (True == 1)
+        if rows and exp["alpha"] is not None and all(r.get("outcome") in (0, 1)
+                                                     for r in rows):
+            k, n = sum(int(r["outcome"]) for r in rows), len(rows)
+            try:
+                wilson = _format_ci(*stats.wilson(k, n, exp["alpha"]))
+                cp = _format_ci(*stats.clopper_pearson(k, n, exp["alpha"]))
+            except (ValueError, ArithmeticError) as exc:
+                _stats_failed(exp, exc)
+                continue
+            lines.append("stats %s: %s %s n=%d k=%d wilson=%s cp=%s"
+                         % (slug, h, group, n, k, wilson, cp))
+    eff = exp["effect"]
+    if eff:
+        lines.append("effect %s: %s %s vs %s on %s effect=%s ci=%s mde=%s"
+                     % (slug, h, eff["t"], eff["c"], eff["field"],
+                        "none" if eff["effect"] is None else "%.4f" % eff["effect"],
+                        _format_ci(*eff["ci"]) if eff["ci"] else "none",
+                        "none" if eff["mde"] is None else "%.4f" % eff["mde"]))
+
+
+def evaluator_file(repo, base, code, rel):
+    """(path, root): an `evaluator:` path looked up in the line, the repository and
+    the checkout `check` runs from (`code`, plan 128 K9), with the repository whose
+    history holds it; (None, None) when none holds the file."""
+    for root, at in ((repo, base), (repo, repo), (code, code)):
+        if at and os.path.isfile(os.path.join(at, rel)):
+            return os.path.join(at, rel), root
+    return None, None
+
+
+def _commit_time(repo, path, sha):
+    """The commit time of `sha` in the first history of `path` that holds it, or ""."""
+    stamp = ""
+    for top, _rel in _histories(repo, path):
+        out, err = _git_out(top, "show", "-s", "--format=%cI", sha)
+        stamp = stamp or ("" if err else out.strip())
+    return stamp
+
+
+def _text_at(root, path, sha, stamp):
+    """`path`'s committed text at commit `sha` - in a history that does not hold that
+    commit (a project file read against a line in `.tezgah`'s repository), its latest
+    version not after `stamp` - or None."""
+    found = None
+    for top, rel in _histories(root, path):
+        rev = sha if _holds(top, sha) else None
+        if rev is None and stamp:
+            out, err = _git_out(top, "log", "-1", "--format=%H", "--until=" + stamp,
+                                "--", rel)
+            rev = None if err else out.strip()
+        if rev:
+            out, err = _git_out(top, "show", "%s:%s" % (rev, rel))
+            found = found if err else out
+    return found
+
+
+def _sealed_evaluator(repo, base, state, h, root, path, git):
+    """The evaluator's sha256 at the line's conclusion, or None for a line not
+    concluded (plan 128 K8): the hash `conclude` sealed, and for a seal older than
+    that field the evaluator at the first committed state.json holding the seal."""
+    import hashlib
+    seal = state.get(SEAL)
+    if not isinstance(seal, dict):
+        return None
+    rows = seal.get("experiments") if isinstance(seal.get("experiments"), dict) else {}
+    row = rows.get(h) if isinstance(rows.get(h), dict) else {}
+    if SHA256_HEX.fullmatch(str(row.get("evaluator") or "")):
+        return row["evaluator"]
+    if not git:
+        return None
+    state_path = os.path.join(base, "state.json")
+    for top, rel in _histories(repo, state_path):
+        for sha, text in _versions(top, rel):
+            try:
+                held = SEAL in json.loads(text)
+            except (ValueError, TypeError):
+                held = False
+            if held:
+                at = _text_at(root, path, sha, _commit_time(repo, state_path, sha))
+                return None if at is None else hashlib.sha256(at.encode("utf-8")).hexdigest()
+    return None
+
+
+def _check_evaluator(repo, base, state, exp, evaluator, label, errors, git, code=None):
+    """An `evaluator:` file holds the bytes it held at the protocol's first commit -
+    in a history that does not hold that commit (a project evaluator of a line in
+    `.tezgah`'s repository), its latest version not after that commit's time - and
+    its declared `sha256:` (spec 2.4). A concluded line reads the evaluator as it was
+    at the conclusion (`_sealed_evaluator`), so a later project edit is not its own."""
+    import hashlib
+    parts = evaluator.split()
+    path, root = evaluator_file(repo, base, code, parts[0])
+    declared = next((p.split(":", 1)[1] for p in parts[1:] if p.startswith("sha256:")), "")
+    if path is None:
+        errors.append("%s: evaluator %s is not a file in the line, the repository or the "
+                      "checkout" % (label, parts[0]))
+        return
+    now = _sealed_evaluator(repo, base, state, exp["h"], root, path, git) or _digest(path)
+    if declared and now != declared.lower():
+        errors.append("%s: evaluator file changed after lock: %s no longer hashes to its "
+                      "declared sha256" % (label, parts[0]))
+        return
+    if not git:
+        return
+    proto_path = os.path.join(exp["dir"], "protocol.md")
+    proto = file_versions(repo, proto_path)
+    if not proto:
+        return
+    sha = proto[0][0]
+    locked = _text_at(root, path, sha, _commit_time(repo, proto_path, sha))
+    if locked is None:
+        # committed only after the lock: its first version is the nearest to it
+        versions = file_versions(root, path)
+        locked = versions[0][1] if versions else None
+    if locked is not None and hashlib.sha256(locked.encode("utf-8")).hexdigest() != now:
+        errors.append("%s: evaluator file changed after lock: %s differs from its state "
+                      "at the protocol's first commit" % (label, parts[0]))
+
+
+def _overclaim(cid, claim, cited, warnings):
+    """Universal words over fixture evidence, causal words over an observational or
+    single-group experiment (spec 4.4). Warns in both modes."""
+    text = str(claim.get("statement", ""))
+    rows = [r for exp in cited for r in exp["rows"]]
+    words = []
+    if claim.get("scope") == "fixture" or (rows and all(r.get("scope") == "fixture"
+                                                        for r in rows)):
+        words += UNIVERSAL_WORDS.findall(text)
+    if any(_observational(exp["fields"]) or len(exp["groups"]) < 2 for exp in cited):
+        words += CAUSAL_WORDS.findall(text)
+    if words:
+        warnings.append("claim %s overclaims: %s - the evidence it cites does not reach "
+                        "that far; narrow the claim to what was measured"
+                        % (cid, ", ".join('"%s"' % w for w in dict.fromkeys(words))))
+
+
+def _routing_steps(base, state, exps, review):
+    """The 3.3 steps that touch every claim of the line."""
+    cls = state.get("question_class")
+    out = []
+    if not cls:
+        out.append("no-question-class")
+    if review is not None and review.get("question_class") != cls:
+        out.append("class-unreviewed")
+    if cls in CLASS_METHODS and state.get("method") not in CLASS_METHODS[cls]:
+        out.append("method-not-allowed")
+    index = _row_objects(os.path.join(base, "literature", "INDEX.jsonl"))
+    protocols = [exp["fields"] for exp in exps.values()]
+    if cls in ("R7", "R8"):
+        screeners, dropped = {}, set()
+        for row in _row_objects(os.path.join(base, "searches", "screening.jsonl")):
+            rid = str(row.get("id"))
+            if rid not in screeners and row.get("decision") == "dropped":
+                dropped.add(rid)
+            screeners.setdefault(rid, set()).add(
+                re.sub(r"\s+", "", str(row.get("screener") or "")).casefold())
+        dual = {rid for rid, who in screeners.items() if len(who - {""}) >= 2}
+        if cls == "R7":
+            thin = not screeners or len(dual) < len(screeners)
+        else:
+            thin = (not screeners or 5 * len(dual) < len(screeners)
+                    or bool(dropped - dual))
+        if thin:
+            out.append("no-dual-screening")
+    stopping = state.get("stopping")
+    if cls == "R7" and not (isinstance(stopping, dict)
+                            and stopping.get("rule") == "hypergeometric"):
+        out.append("no-recall-stopping")
+    if cls == "R5" and state.get("method") == "measured" and any(
+            not _first(f, "control") for f in protocols):
+        out.append("no-positive-control")
+    if cls == "R4" and any(not _first(f, "confounders") for f in protocols):
+        out.append("no-confounders")
+    if cls == "R3" and not (state.get("population") and state.get("n")):
+        out.append("no-population")
+    if cls == "R2" and any(r.get("class") == "grey" and not str(r.get("quality", "")).strip()
+                           for r in index):
+        out.append("no-grey-quality")
+    if cls == "R9" and any(not str(r.get("amstar", "")).strip() for r in index):
+        out.append("no-amstar")
+    if cls == "R10" and not os.path.isfile(os.path.join(base, "codebook.md")):
+        out.append("no-codebook")
+    approaches = state.get("approaches")
+    if cls == "R12" and sum(1 for a in approaches or [] if isinstance(a, dict)
+                            and a.get("biases")) < 2:
+        out.append("fewer-than-two-approaches")
+    return out
+
+
+def budget(slug, base, state):
+    """(report line, [what is over]) of the tier's budget (spec 3.3)."""
+    caps = BUDGETS.get(state.get("tier"), BUDGETS[DEFAULT_TIER])
+    used = (len(_row_objects(os.path.join(base, "literature", "INDEX.jsonl"))),
+            len(_row_objects(os.path.join(base, "searches", "SEARCHES.jsonl"))),
+            sum(1 for h in _experiment_names(base)
+                for r in _row_objects(os.path.join(base, "experiments", h, "results.jsonl"))
+                if str(r.get("source", "")).startswith("orx:")))
+    names = ("sources", "searches", "runs")
+    line = "budget %s: %s" % (slug, " ".join("%s %d/%d" % (n, u, c)
+                                             for n, u, c in zip(names, used, caps)))
+    return line, ["%s %d/%d" % (n, u, c) for n, u, c in zip(names, used, caps) if u > c]
+
+
+def hypothesis_problems(state):
+    """A concluded line ends every hypothesis in a terminal status (spec 2.2)."""
+    out = []
+    for n, entry in enumerate(state.get("hypotheses") or [], 1):
+        status = entry.get("status") if isinstance(entry, dict) else None
+        if status not in TERMINAL_STATUSES:
+            hid = entry.get("id") if isinstance(entry, dict) and entry.get("id") else n
+            out.append("state.json hypothesis %s has no terminal status (%r): a concluded "
+                       "line ends each one %s" % (hid, status, ", ".join(TERMINAL_STATUSES)))
+    return out
+
+
+def overlaps(repo, question, slug=None):
+    """[(line, claim, status, similarity)] of the done lines' claims whose
+    `similarity_matrix` value against `question` is >= 0.5, over the corpus of the
+    question plus every done line's claim statements (spec 4.2)."""
+    done = [(name, row) for name in slugs(repo) if name != slug and sealed(repo, name)
+            for row in _row_objects(os.path.join(line_dir(repo, name), "claims.jsonl"))
+            if str(row.get("statement", "")).strip()]
+    if not done or not str(question or "").strip():
+        return []
+    _backend, matrix = similarity_matrix([question] + [str(r["statement"]) for _, r in done])
+    return [(name, row.get("id"), row.get("status"), matrix[0][n])
+            for n, (name, row) in enumerate(done, 1) if matrix[0][n] >= 0.5]
+
+
+def _post_hoc(repo, ddir):
+    """The variant ids whose variants.jsonl row was first committed after the first
+    comparison.jsonl cell (spec 4.5)."""
+    paths = [os.path.join(ddir, f) for f in ("variants.jsonl", "comparison.jsonl")]
+    top, _rel = _histories(repo, paths[0])[-1]
+    order, err = _git_out(top, "rev-list", "--reverse", "HEAD")
+    if err:
+        return set()
+    index = {sha: n for n, sha in enumerate(order.split())}
+    firsts = []
+    for path in paths:
+        seen = {}
+        for sha, text in _versions(top, _histories(repo, path)[-1][1]):
+            for line in text.splitlines():
+                if line.strip() and sha in index:
+                    seen.setdefault(line.strip(), index[sha])
+        firsts.append(seen)
+    if not firsts[1]:
+        return set()
+    first_cell = min(firsts[1].values())
+    out = set()
+    for line, n in firsts[0].items():
+        if n > first_cell:
+            try:
+                row = json.loads(line)
+            except ValueError:
+                continue
+            if isinstance(row, dict) and row.get("id"):
+                out.add(str(row["id"]))
+    return out
+
+
+def _check_review8(base, claims, review, errors, warnings, strict):
+    """4.1: families compared normalised, and a review of evidence claims that reads
+    a raw log or code."""
+    if review is None:
+        return
+    family = [re.sub(r"\s+", "", str(review.get(k) or "")).casefold()
+              for k in ("producer_family", "reviewer_family")]
+    if family[0] and family[0] == family[1]:
+        warnings.append("to_human/review.json: same-family review (%s): producer and "
+                        "reviewer share a model family, so they share its blind spots"
+                        % family[0])
+    if any(c.get("kind") == "evidence" for c in claims):
+        targets = [str(f.get("target", "")).strip() for f in review.get("findings") or []
+                   if isinstance(f, dict)]
+        if not any(re.match(r"experiments/[^/]+/raw/", t) or t.endswith(CODE_SUFFIXES)
+                   for t in targets):
+            _soft(errors, warnings, strict,
+                  "to_human/review.json: review quotes no raw log or code, so no finding "
+                  "reads the bytes an evidence claim rests on")
+
+
+def _core_rules8(repo, slug, base, state, errors, warnings, strict, git, steps, code=None):
+    rows = _row_objects(os.path.join(base, "claims.jsonl"))
+    claims = [c for c in rows if isinstance(c.get("id"), str) and c["id"]]
+    superseded = _superseded(rows)
+    exps = {h: experiment_record(base, h) for h in _experiment_names(base)}
+    report_path = os.path.join(base, "to_human", "report.md")
+    report = _note_text(report_path) if os.path.isfile(report_path) else None
+    review_path = os.path.join(base, "to_human", "review.json")
+    review, exc = _read_json(review_path) if os.path.isfile(review_path) else (None, None)
+    review = review if isinstance(review, dict) and not exc else None
+    lines = steps.setdefault("#report", [])
+    for h in sorted(exps):
+        _check_experiment8(repo, slug, base, state, exps[h], report, errors, warnings,
+                           strict, git, lines, code)
+    rejected = _multiplicity(base, exps)
+    every = _routing_steps(base, state, exps, review)
+    cls, measured = state.get("question_class"), state.get("method") == "measured"
+    for claim in claims:
+        cid = claim["id"]
+        cited = [exps[h] for h in _experiments_named(_cited(claim.get("proof")))
+                 if h in exps]
+        if cid not in superseded:
+            errors.extend(derived_problems(cid, claim, base))
+            errors.extend(fired_problems(cid, claim, base))
+        found = _experiment_steps(claim, cited, cls, measured, rejected) if cited else []
+        if claim.get("kind") == "evidence" and _untraced(claim, cited):
+            found.append("untraced-number")
+        for name in found + every:
+            _step(steps, cid, name)
+        _overclaim(cid, claim, cited, warnings)
+    failed = steps.setdefault("#stats", {})
+    for h in sorted(exps):
+        if exps[h]["stats_error"]:
+            failed.setdefault("experiment %s" % h, exps[h]["stats_error"])
+    _check_review8(base, claims, review, errors, warnings, strict)
+    if state.get("phase") == "concluded":
+        errors.extend(hypothesis_problems(state))
+    line, over = budget(slug, base, state)
+    lines.append(line)
+    if over:
+        warnings.append("over budget: %s (tier %s)" % (", ".join(over),
+                                                      state.get("tier") or DEFAULT_TIER))
+    if git:
+        for name, ddir in _decision_dirs(base):
+            body = _note_text(os.path.join(ddir, "decision.md"))
+            picked = line_pick(body)
+            if picked and picked in _post_hoc(repo, ddir) \
+                    and "post-hoc" not in body and "post_hoc" not in body:
+                errors.append("decisions/%s: decision.md chooses %s, a variant first "
+                              "committed after the first comparison cell, without saying "
+                              "post-hoc" % (name, picked))
+        related = {(str(r.get("line")), str(r.get("claim")))
+                   for r in _row_objects(os.path.join(base, "related.jsonl"))
+                   if r.get("relation") in ("builds-on", "dismissed")}
+        for line_name, cid, status, _sim in overlaps(repo, state.get("question"), slug):
+            if status == "refuted" and (line_name, str(cid)) not in related:
+                warnings.append("overlaps refuted claim %s/%s: record in related.jsonl "
+                                "whether this line builds on it or dismisses it, and why"
+                                % (line_name, cid))
+
+
+def _check_rules8(repo, slug, base, state, errors, warnings, strict, git, flags=None,
+                  code=None):
+    """steps of a rules-8 line: the capture checks, the core ones, then the evidence
+    module, which reads every step found and holds the certainty engine. A module
+    that cannot be imported is an error on a rules-8 line, never a silent pass. A
+    statistics computation's ValueError or ArithmeticError, kept in `#stats` by
+    the module it ran in, is one refusal per experiment (review round two R2-1)."""
+    steps = {"#flags": {"online": bool((flags or {}).get("online")),
+                        "orx": bool((flags or {}).get("orx"))}, "#stats": {}}
+    import importlib
+    for name in ("tezgah_research_capture", None, "tezgah_research_evidence"):
+        if name is None:
+            _core_rules8(repo, slug, base, state, errors, warnings, strict, git, steps, code)
+            continue
+        try:
+            module = importlib.import_module(name)
+        except ImportError as exc:
+            errors.append("rules 8: %s cannot be imported (%s), so its checks did not run"
+                          % (name, exc))
+            continue
+        module.check(repo, slug, base, state, errors, warnings, strict, git, steps)
+    errors.extend("%s: statistics could not be computed: %s" % (label, error)
+                  for label, error in sorted(steps["#stats"].items()))
+    return steps
+
+
+def check_line(repo, slug, git=True, strict=False, code=None, flags=None, extra=None):
     """(errors, warnings) for one research line. `git=False` skips the checks that
     need git history, for callers that must stay cheap (the session context).
     `strict=True` turns every guarantee the checker cannot decide into an error.
     `code` is the checkout the check runs in when it is not `repo`: the line
     lives in the main checkout's workspace (plan 097) and its citations and
     proofs resolve against the checkout whose branch holds the code; unnamed, a
-    bare repository's worktree holding the cwd (`tp.work_tree`, plan 098)."""
+    bare repository's worktree holding the cwd (`tp.work_tree`, plan 098).
+    A rules-8 line (`_evidence`) also runs `_check_rules8` with `flags` (`online`,
+    `orx`); a dict `extra` receives its `report` lines and per-claim `certainty`."""
     code = code or tp.work_tree(repo)
     base = line_dir(repo, slug)
     errors, warnings = [], []
@@ -3586,6 +4677,13 @@ def check_line(repo, slug, git=True, strict=False, code=None):
     if git:
         _check_tracking(repo, base, errors, warnings, strict)
     _check_review_integrity(base, errors, warnings, strict)
+    state = _state(base)
+    if _evidence(state):
+        steps = _check_rules8(repo, slug, base, state, errors, warnings, strict, git, flags,
+                              code)
+        if extra is not None:
+            extra["report"] = list(steps.get("#report", []))
+            extra["certainty"] = dict(steps.get("#certainty", {}))
     return errors, warnings
 
 
@@ -3692,22 +4790,29 @@ def _check_derived_phase(base, phase, direction, warnings):
                         "stopped describing the line" % (direction, derived, want))
 
 
-def check(repo, slug=None, git=True, strict=False, all_lines=True, code=None):
-    """{slug: {"errors": [...], "warnings": [...]}} for one line or every line.
+def check(repo, slug=None, git=True, strict=False, all_lines=True, code=None, flags=None):
+    """{slug: {"errors": [...], "warnings": [...]}} for one line or every line; a
+    rules-8 line adds "report" (the lines `check` prints, never counted) and
+    "certainty" ({claim id: {level, start, steps}}).
 
     With `all_lines=False` and no slug, a line under `done/` is read by its order
     seal alone (`done_seal`), not re-checked, and appears only when that read
     fails: the default no-slug `check` and the session note report the open
-    lines, and `check --all-lines` re-runs the closed ones (ADR 015)."""
-    out = {}
+    lines, and `check --all-lines` re-runs the closed ones (ADR 015). With no
+    slug, each hidden dir under research/ (`stray_dirs`) is a row of its own,
+    keyed by its path."""
+    out = {} if slug else {path: {"errors": [error], "warnings": []}
+                           for path, error in stray_dirs(repo)}
     for name in ([slug] if slug else slugs(repo)):
         if not slug and not all_lines and sealed(repo, name):
             errors = done_seal(repo, name)[0]
             if errors:
                 out[name] = {"errors": errors, "warnings": []}
             continue
-        errors, warnings = check_line(repo, name, git=git, strict=strict, code=code)
-        out[name] = {"errors": errors, "warnings": warnings}
+        extra = {}
+        errors, warnings = check_line(repo, name, git=git, strict=strict, code=code,
+                                      flags=flags, extra=extra)
+        out[name] = dict({"errors": errors, "warnings": warnings}, **extra)
     return out
 
 
@@ -3789,7 +4894,9 @@ def _last_add(repo, path):
 
 def _seal_rows(repo, base):
     """{experiment: seal row}: the blob hashes of every experiment holding a
-    protocol.md, and the add commits of a run one, informational only."""
+    protocol.md, and the add commits of a run one, informational only. A protocol
+    naming an `evaluator:` also seals the evaluator's hash, the version `check`
+    reads for the concluded line (`_sealed_evaluator`, plan 128 K8)."""
     out = {}
     for h, (proto, results) in _seal_files(base).items():
         row = {"protocol": _digest(proto),
@@ -3797,6 +4904,11 @@ def _seal_rows(repo, base):
         if results:
             row["commits"] = {"protocol": _last_add(repo, proto),
                               "results": _last_add(repo, results)}
+        words = _first(_fields(_note_text(proto)), "evaluator").split()
+        evaluator = evaluator_file(repo, base, tp.work_tree(repo), words[0])[0] \
+            if words else None
+        if evaluator:
+            row["evaluator"] = _digest(evaluator)
         out[h] = row
     return out
 
@@ -3982,7 +5094,7 @@ def import_line(repo, source, slug=None, allow_open=None, date=""):
     lines, here = _committed_lines(ws, rev), slugs(repo)
     if slug is not None and slug not in lines:
         return [], ("%s is not committed in %s, so it has no history to import; "
-                    "commit it there (`tezgah-research commit`) - a plain copy is "
+                    "commit it there (`~/.config/tezgah/bin/tezgah-research commit`) - a plain copy is "
                     "refused because it loses the order proof" % (slug, src))
     wanted = [slug] if slug is not None else sorted(s for s in lines if s not in here)
     clash = [s for s in wanted if s in here]
@@ -3999,14 +5111,14 @@ def import_line(repo, source, slug=None, allow_open=None, date=""):
     unfinished = open_lines(repo) if arriving else []
     if (unfinished or len(arriving) > 1) and allow_open is None:
         return [], ("%s would open beside unfinished line(s) %s; say why with "
-                    "--allow-open \"<reason>\"" % (
+                    "--allow-open \"<reason>\"; %s" % (
                         ", ".join(arriving),
                         "; ".join("%s (%s)" % (n, "; ".join(r)) for n, r in unfinished)
-                        or ", ".join(arriving)))
+                        or ", ".join(arriving), OWNER_ASK))
     broken = broken_open_lines(repo) if unfinished else []
     if broken:
         return [], ("--allow-open does not open a line beside an open line check "
-                    "refuses: %s" % ", ".join(n for n, _e in broken))
+                    "refuses: %s; %s" % (", ".join(n for n, _e in broken), OWNER_ASK))
     if fresh:
         done = tp.ws_git(repo, "commit", "-q", "--allow-empty", "-m",
                          "research: workspace root")
@@ -4134,10 +5246,16 @@ def _variants_owed(base, state):
 def broken_open_lines(repo):
     """[(slug, errors)] for the open lines `check` refuses: what `init
     --allow-open` will not open a new line beside, because a hatch past broken
-    lines is how they stayed broken."""
+    lines is how they stayed broken. A criterion whose verdict is still
+    `pending` is a line in flight, not a broken one, so that error alone does
+    not block: another session may be running the line."""
     out = []
     for slug, _reasons in open_lines(repo):
         errors, _ = check_line(repo, slug)
+        pending = {_verdict_error(sid, verdict) for sid, _c, verdict, _e
+                   in success_rows(line_state(repo, slug).get("success"))
+                   if verdict == "pending"}
+        errors = [e for e in errors if e not in pending]
         if errors:
             out.append((slug, errors))
     return out
@@ -4220,8 +5338,20 @@ def conclude_line(repo, slug, date=""):
                         "(state.json `success`) before concluding")
     if unjudged:
         problems.append("no verdict for %s: record it with "
-                        "`tezgah-research verdict <slug> <id> met|not-met|unanswerable "
+                        "`~/.config/tezgah/bin/tezgah-research verdict <slug> <id> met|not-met|unanswerable "
                         "--evidence <ref>`" % ", ".join(unjudged))
+    if _evidence(state):
+        # the rules `check` refuses a concluded rules-8 line for, asked before the
+        # line is concluded: every hypothesis terminal, every rejected instrument
+        # switched or narrowed (the evidence module's rule)
+        problems.extend(hypothesis_problems(state))
+        try:
+            import tezgah_research_evidence as evidence
+        except ImportError as exc:
+            problems.append("rules 8: tezgah_research_evidence cannot be imported (%s)"
+                            % exc)
+        else:
+            problems.extend(evidence.conclude_problems(repo, slug, base, state))
     if problems:
         return problems, None
     state.update(phase="concluded", direction="conclude")
@@ -4238,6 +5368,75 @@ def conclude_line(repo, slug, date=""):
     return ([problem] if problem else []), state
 
 
+# The line every refusal over open lines carries (`init`, `import`): deciding
+# about another session's work (its line, plan or branch) is the owner's.
+OWNER_ASK = ("a line another session is running is not this session's to fix or "
+             "close: stop and ask the owner (a decision only the owner makes), never "
+             "a way around a tezgah refusal (another folder, a hidden dir)")
+
+
+def choose_line(repo, slug, decision, variant, ack, date=""):
+    """The problem that stopped the owner's choice being written, or None.
+
+    A line recommends; the owner chooses (rules 9). `chosen: <variant>` and
+    `owner: <date> "<words>"` replace any earlier pair in the decision's
+    decision.md; the line's own pick stays as written, and a pick a rules-8 line
+    wrote as `chosen:` is renamed `recommended:`. log.md gets one line. A done
+    line takes it too: its order seal hashes the experiments alone, so the
+    decision note stays writable."""
+    words = " ".join(str(ack or "").replace('"', "'").split())
+    if not words:
+        return ("choose needs --ack \"<the owner's words>\": choosing a variant or "
+                "option a research, analysis or review recommends is the owner's call")
+    base = line_dir(repo, slug)
+    newer = newer_rules(_state(base))
+    if newer:
+        return newer
+    ddir = dict(_decision_dirs(base)).get(decision)
+    path = os.path.join(ddir or "", "decision.md")
+    if not ddir or not os.path.isfile(path):
+        return "decisions/%s has no decision.md in %s" % (decision, slug)
+    _criteria, variants, _problems = load_decision(ddir)
+    produced = sorted(v for v, row in variants.items() if row.get("status") == "produced")
+    if variant not in produced:
+        return "variant %s is not produced in decisions/%s (produced: %s)" % (
+            variant, decision, ", ".join(produced) or "none")
+    body = _note_text(path)
+    replace = OWNER_WORDS.search(body) or re.search(PICK % "recommended", body)
+    kept = []
+    for line in body.splitlines():
+        if re.match(r"(?i)\W*owner\W*:", line):
+            continue
+        if re.match(r"(?i)\W*chosen\W*:", line):
+            if replace:
+                continue
+            # the line wrote its own pick as `chosen:` (rules 8): it stays the
+            # line's pick, for the line's rules to judge
+            line = re.sub(r"(?i)chosen", "recommended", line, count=1)
+        kept.append(line)
+    try:
+        with open(path, "w", encoding="utf-8") as fh:
+            fh.write("\n".join(kept + ["chosen: %s" % variant,
+                                       'owner: %s "%s"' % (date, words)]) + "\n")
+        with open(os.path.join(base, "log.md"), "a", encoding="utf-8") as fh:
+            fh.write('- %s owner chose %s in decisions/%s: "%s"\n'
+                     % (date, variant, decision, words))
+    except OSError as exc:
+        return str(exc)
+    return None
+
+
+def owner_waits(repo, slug):
+    """[(decision, variant)] for each decision.md that recommends a variant and
+    records no owner choice: what `conclude` tells the session to report."""
+    out = []
+    for name, ddir in _decision_dirs(line_dir(repo, slug)):
+        picked, field = decision_pick(_note_text(os.path.join(ddir, "decision.md")))
+        if field == "recommended":
+            out.append((name, picked))
+    return out
+
+
 def open_lines(repo):
     """[(slug, [reason, ...])] for every line that is not finished, for `init`.
 
@@ -4296,6 +5495,7 @@ def summary(repo):
         if fixtures:
             note += ", %d fixture-scoped claim(s): %s" % (len(fixtures), ", ".join(fixtures))
         out.append("%s: %s" % (slug, note))
+    out.extend("FAIL %s" % error for _path, error in stray_dirs(repo))
     unfinished = open_note(repo)
     if unfinished:
         out.append(unfinished)
@@ -4678,7 +5878,51 @@ def urlsplit_host(source):
     return host[4:] if host.startswith("www.") else host
 
 
-def source_run(repo, slug, hypothesis, run, orx, command="", scope="", fixture=""):
+# A run log above 16 MiB is refused rather than committed as a receipt unseen; the
+# refusal names `--ack`, which files it whole when the owner says so (K6 rater X6).
+RUN_LOG_BOUND = 16 * 1024 * 1024
+# What orx 0.2.20's `orx logs` prints instead of the log: the path, the size, a tail.
+ORX_LOG_SUMMARY = re.compile(r"\s*This is the path to the full log file: (.+?)[ \t]*\n"
+                             r"\s*It is ([\d,]+) bytes\.")
+
+
+def _bound_problem(verb, run, size, bound):
+    return ("orx logs %s %s %d bytes, above the %d-byte bound a receipt is committed "
+            "under - file it with --ack \"<the user's words>\" to keep it whole"
+            % (run, verb, size, bound))
+
+
+def _full_log(repo, run, out, bound=RUN_LOG_BOUND):
+    """(bytes, problem): the run log `orx logs` printed - its output, or, when that is
+    orx's summary, the file the summary names, held to the size it printed (K6 rater
+    Y2: the summary's 500-character tail is not the log). Either is held to `bound`
+    (`RUN_LOG_BOUND`; None when the owner acknowledged the size, which reads it whole)."""
+    found = ORX_LOG_SUMMARY.match(out)
+    if not found:
+        if out.lstrip().startswith("This is the path to the full log file:"):
+            return None, ("orx logs %s printed the log's path without its size, so the "
+                          "file cannot be held to what orx saw" % run)
+        data = out.encode("utf-8")
+        if bound is not None and len(data) > bound:
+            return None, _bound_problem("printed", run, len(data), bound)
+        return data, None
+    path, size = os.path.join(repo, found.group(1)), int(found.group(2).replace(",", ""))
+    if bound is not None and size > bound:
+        return None, _bound_problem("said", run, size, bound)
+    try:
+        with open(path, "rb") as fh:
+            data = fh.read(-1 if bound is None else bound + 1)
+    except OSError as exc:
+        return None, "cannot read the log orx logs %s names: %s" % (run, exc)
+    if len(data) != size:
+        return None, ("orx logs %s said %d bytes and %s holds %d: the run is still "
+                      "writing it or it changed since, so it is not the log orx saw - "
+                      "file the run once its log is complete" % (run, size, path, len(data)))
+    return data, None
+
+
+def source_run(repo, slug, hypothesis, run, orx, command="", scope="", fixture="",
+               arm="", item="", values=(), instrument="", ack=""):
     """(path, problems): file one orx run as this experiment's receipt.
 
     `orx logs` is read here rather than by the session, so the log lands in the
@@ -4700,37 +5944,129 @@ def source_run(repo, slug, hypothesis, run, orx, command="", scope="", fixture="
     without it files the row and says which field is still missing rather than
     refusing a row a session may have a reason to file; a value that is not a
     string, or one that is empty, is the mistake the field exists to catch and is
-    refused."""
+    refused.
+
+    `values` are (field, number as written) pairs: each lands in the row as a
+    number, and one equal to no number of the stored log is refused - equal as a
+    number, so `1.5` matches a logged `1.50` (review round two K-6). `instrument`,
+    `arm` and `item` land as strings, so the instrument ledger (`gold`, `label`)
+    reads the row (K-7). A run already filed keeps its log; the new one is
+    `raw/<run>.<n>.log` (a capture is written once). A rules-8 line's row also
+    names its `run`, the engine's
+    `status` when the line names an orx project, and the log and row are committed
+    as `capture: source <slug>` (plan 127, spec 1.4).
+
+    `ack` is the owner's words for a log above `RUN_LOG_BOUND`: the log is stored
+    whole and the row records the words (K6 rater X6)."""
     if scope and scope not in SCOPES:
         return None, ["scope %r is not one of %s" % (scope, ", ".join(SCOPES))]
     if fixture and (not isinstance(fixture, str) or not fixture.strip()):
         return None, ["fixture %r does not name what was generated" % (fixture,)]
-    newer = newer_rules(_state(line_dir(repo, slug)))
+    base = line_dir(repo, slug)
+    state = _state(base)
+    newer = newer_rules(state)
     if newer:
         return None, [newer]
     experiment = os.path.join(line_dir(repo, slug), "experiments", hypothesis)
     if not os.path.isfile(os.path.join(experiment, "protocol.md")):
         return None, ["experiments/%s holds no protocol.md: write and commit the "
                       "plan before filing the run it predicts" % hypothesis]
-    log, err = _run([orx, "logs", run], cwd=repo)
+    if _evidence(state) and (_orders_lock(state) or _exploratory(state)):
+        # the capture is committed at once, after HEAD of the history carrying the
+        # line, so an uncommitted lock would follow its results for good: the order
+        # `_check_evaluation_order` reads - an exploratory line's lock is its arena,
+        # ordered by `_check_arena_order` (plan 128 K12) - asked of that HEAD before
+        # anything is written
+        lock_path = os.path.join(base, "state.json")
+        top = _histories(repo, lock_path)[-1][0]
+        arena = _exploratory(state)
+        firsts = _arena_lock(repo, base)[0] if arena else _evaluation_commit(repo, lock_path)
+        if _answers(repo, firsts, {top: "HEAD"}).get(top) is not True:
+            return None, ["%s is not committed: no committed state.json holding %s "
+                          "precedes this capture, so its results would come before the "
+                          "lock for good - commit the line first (`tezgah-research commit "
+                          "%s \"<message>\"`); nothing was written"
+                          % ((("the arena", "the arena") if arena else
+                              ("the evaluation lock", "the metric and the baseline"))
+                             + (slug,))]
+    if _evidence(state):
+        # the same reason as the lock: what the capture commits next would leave the
+        # protocol refused for good - entered after its results, or frozen invalid
+        # (left, refused; fixed, `changed after the run`) - K6 rater X2
+        commit = 'commit the line first (`tezgah-research commit %s "<message>"`); ' \
+                 'nothing was written' % slug
+        record = experiment_record(base, hypothesis)
+        if record["invalid"]:
+            return None, ["experiments/%s/protocol.md carries an invalid record (%s): the "
+                          "capture commits its results at once, after which the protocol "
+                          "cannot be fixed - fix it, then %s"
+                          % (hypothesis, "; ".join(record["invalid"]), commit)]
+        metric = metric_problem(state, record["fields"])
+        if metric:
+            return None, ["experiments/%s/%s: the capture commits its results at once, "
+                          "after which the protocol cannot be fixed - name the locked "
+                          "metric in its `metric:` line, then %s" % (hypothesis, metric,
+                                                                     commit)]
+        if not _git_out(repo, "rev-parse", "--is-inside-work-tree")[1] and not any(
+                _oldest_adds(repo, os.path.join(experiment, "protocol.md"))[0].values()):
+            return None, ["experiments/%s/protocol.md is not committed: the capture commits "
+                          "its results at once, so the protocol would enter the history "
+                          "after them for good - %s" % (hypothesis, commit)]
+    out, err = _run([orx, "logs", run], cwd=repo)
     if err:
         return None, ["orx logs %s failed: %s" % (run, err)]
-    if not log.strip():
+    data, problem = _full_log(repo, run, out, None if ack else RUN_LOG_BOUND)
+    if problem:
+        return None, [problem]
+    if not data.strip():
         return None, ["orx logs %s returned nothing, so there is no receipt to "
                       "file" % run]
+    import tezgah_research_capture as cap  # deferred: it imports this module
+    logged = cap.log_numbers(data.decode("utf-8", "replace"))
+    for field, written in values:
+        if decimal.Decimal(written) not in logged:
+            return None, ["%s=%s: value not in the run log (orx logs %s holds no number "
+                          "equal to %s)" % (field, written, run, written)]
     raw = os.path.join(experiment, "raw")
     os.makedirs(raw, exist_ok=True)
-    path = os.path.join(raw, run + ".log")
-    with open(path, "w", encoding="utf-8") as fh:
-        fh.write(log)
-    row = {"source": "orx:%s" % run, "log": "raw/%s.log" % run}
+    name, n = run + ".log", 0
+    while os.path.lexists(os.path.join(raw, name)):
+        n += 1
+        name = "%s.%d.log" % (run, n)
+    path = os.path.join(raw, name)
+    with open(path, "wb") as fh:
+        fh.write(data)
+    row = {"source": "orx:%s" % run, "log": "raw/%s" % name}
+    if _evidence(state):
+        row["run"] = run
+    if instrument:
+        row["instrument"] = instrument
+    if arm:
+        row["arm"] = arm
+    if item:
+        row["item"] = item
+    for field, written in values:
+        row[field] = int(written) if re.fullmatch(r"-?\d+", written) else float(written)
     if command:
         row["command"] = command
+    if ack:
+        row["ack"] = ack
     if scope:
         row["scope"] = scope
     if fixture:
         row["fixture"] = fixture
-    problems = _append_row(os.path.join(experiment, "results.jsonl"), row)
+    if _evidence(state):
+        runs, _err = cap.engine_runs(state)
+        status = next((r.get("status") for r in runs or () if cap.run_id(r) == run), None)
+        if isinstance(status, str) and status:
+            row["status"] = status
+    results = os.path.join(experiment, "results.jsonl")
+    problems = _append_row(results, row)
+    if not problems and _evidence(state):
+        err = cap.commit_capture(repo, base, [os.path.relpath(path, base),
+                                              os.path.relpath(results, base)],
+                                 "source", slug)
+        problems = [err] if err else []
     return path, problems
 
 
@@ -4899,7 +6235,7 @@ def verdict_problems(state, rows):
 
 
 def init(repo, slug, question="", created="", supersedes=None, ask="", tier=DEFAULT_TIER,
-         method="", scope_in=(), scope_out=(), arena=None):
+         method="", scope_in=(), scope_out=(), arena=None, question_class=""):
     """Scaffold a research line. Returns the paths created (never overwrites).
 
     Refuses a slug `slugs()` cannot list - see `valid_slug` - so no caller can
@@ -4914,6 +6250,8 @@ def init(repo, slug, question="", created="", supersedes=None, ask="", tier=DEFA
         os.makedirs(path, exist_ok=True)
     state = dict(STATE_TEMPLATE)
     state["method"] = method
+    if question_class:
+        state["question_class"] = question_class
     state["scope"] = {"in": list(scope_in), "out": list(scope_out)}
     state["question"] = question
     state["created"] = created
@@ -6239,9 +7577,9 @@ def bradley_terry(ids, matches):
 
 def _next_action(slug, iid, stage, history, record, arena):
     """The one action an idea is owed next, as the command that does it."""
-    cmd = "tezgah-research stage %s %s" % (slug, iid)
+    cmd = "~/.config/tezgah/bin/tezgah-research stage %s %s" % (slug, iid)
     if stage == "proposed":
-        return ("dedup (`tezgah-research dedup %s`), then `%s prior-art --evidence "
+        return ("dedup (`~/.config/tezgah/bin/tezgah-research dedup %s`), then `%s prior-art --evidence "
                 "'{\"verdict\": \"novel|incremental|known\", \"nearest\": [3 indexed "
                 "notes], \"delta\": \"<one sentence>\"}'`" % (slug, cmd))
     if stage == "duplicate":
@@ -6254,7 +7592,7 @@ def _next_action(slug, iid, stage, history, record, arena):
     if stage == "prior-art":
         if record["judges"] >= 2 and record["orders"] >= 2:
             return "`%s screened --evidence tournament.jsonl`" % cmd
-        return ("judge it: `tezgah-research match %s` (2+ judges of a family that "
+        return ("judge it: `~/.config/tezgah/bin/tezgah-research match %s` (2+ judges of a family that "
                 "generated neither idea, both orders)" % slug)
     if stage == "screened":
         return ("pilot: commit experiments/<h>/protocol.md naming %s and its kill "
@@ -6318,7 +7656,7 @@ def board(repo, slug):
     live = [e for e in entries if e["stage"] not in ("confirmed", "killed")]
     live.sort(key=lambda e: (-STAGES.index(e["stage"]), -e["score"], _idea_number(e["id"])))
     nxt = ("%s - %s" % (live[0]["id"], live[0]["next"]) if live else
-           ("record ideas: `tezgah-research idea %s`" % slug) if not ideas else
+           ("record ideas: `~/.config/tezgah/bin/tezgah-research idea %s`" % slug) if not ideas else
            "nothing left: every idea is confirmed or killed - write the report")
     evaluator = ("none (review only)" if not _text(arena.get("evaluator")) else
                  "%s %s" % (arena["evaluator"], "changed" if evaluator_problem(repo, state)
@@ -6444,7 +7782,7 @@ def dedup_text(report, slug):
         rep = c["members"][0]
         out.append("cluster %s: %s" % (rep, ", ".join(
             "%s (%.2f)" % (m, c["similarity"][m]) for m in c["members"][1:])))
-        out.extend("  tezgah-research stage %s %s duplicate --evidence '%s'"
+        out.extend("  ~/.config/tezgah/bin/tezgah-research stage %s %s duplicate --evidence '%s'"
                    % (slug, m, json.dumps({"of": rep, "similarity": c["similarity"][m],
                                            "backend": report["backend"]}))
                    for m in c["members"][1:])