masterwork 0.0.1__py3-none-any.whl

masterwork/cells.py

@@ -0,0 +1,140 @@
+"""The completeness gate: a run that lost cells is not a smaller run.
+
+A battery is a grid — cases crossed with seeds. When some of those cells
+come back empty, the tempting move is to average whatever arrived. That is
+not a smaller sample of the same thing: cells fail for reasons that
+correlate with what is being measured, so dropping them quietly moves the
+number in a direction nobody chose.
+
+Two failures this gate exists for, both observed:
+
+  * Eight cells vanished from a battery and the loss was noticed only by
+    counting by hand, after the verdict had been written.
+  * Cells that hit the harness round limit came back with a full transcript
+    and no closing text. Read as "empty" they looked like sloppy work; rerun
+    with a higher limit, every one of them closed correctly. They were the
+    longest, most careful runs in the battery — exactly the ones whose
+    removal flatters the score.
+
+So the gate does not drop anything on its own. It reports what is missing
+and stops. Proceeding without a full grid requires saying so out loud
+(--allow-missing N), and the allowance is echoed into the report so it
+survives into the record.
+"""
+from __future__ import annotations
+
+import argparse
+import glob
+import json
+import os
+import sys
+from dataclasses import dataclass
+
+
+@dataclass
+class Cell:
+    name: str
+    path: str
+    steps: int
+    closing: int
+    unreadable: str | None = None
+
+    def problem(self, min_steps: int, need_closing: bool) -> str | None:
+        # Unconditional: a file that would not parse is not a cell, whatever
+        # the thresholds are. With min_steps 0 and closing optional — a
+        # legitimate configuration — a truncated file used to count as complete.
+        if self.unreadable:
+            return f"could not be read ({self.unreadable})"
+        if self.steps < min_steps:
+            return f"transcript too short ({self.steps} < {min_steps})"
+        if need_closing and self.closing == 0:
+            return "no closing text — the run stopped before answering"
+        return None
+
+
+def read_cell(path: str, transcript_key: str, closing_key: str) -> Cell:
+    name = os.path.splitext(os.path.basename(path))[0]
+    try:
+        d = json.load(open(path, encoding="utf-8"))
+    except Exception as e:
+        # Named the same way as a readable cell: the stem. Naming it with the
+        # extension made one corrupt file report as INCOMPLETE and ABSENT at
+        # once, which tells an operator two different stories about it.
+        return Cell(name, path, 0, 0, unreadable=f"{type(e).__name__}: {e}")
+    steps = len(d.get(transcript_key) or [])
+    closing = len((d.get(closing_key) or "").strip())
+    return Cell(name, path, steps, closing)
+
+
+def inspect(pattern: str, expected: list[str] | None, min_steps: int,
+            need_closing: bool, transcript_key: str, closing_key: str):
+    """Cells found, the broken ones with why, and the expected ones absent.
+
+    A pattern that matches nothing is the caller's problem, not an empty grid:
+    with no expected list there is nothing to be short of, so zero cells used
+    to read as a complete grid and the gate passed. A mistyped pattern in a
+    spec is the ordinary way to arrive there.
+    """
+    cells = [read_cell(p, transcript_key, closing_key)
+             for p in sorted(glob.glob(pattern))]
+    by_name = {c.name: c for c in cells}
+    broken = [(c, c.problem(min_steps, need_closing)) for c in cells]
+    broken = [(c, why) for c, why in broken if why]
+    absent = [n for n in (expected or []) if n not in by_name]
+    return cells, broken, absent
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(prog="masterwork cells", description="completeness gate for a battery")
+    ap.add_argument("pattern", help="glob of per-cell record files")
+    ap.add_argument("--expect", help="file listing expected cell names, one per line")
+    ap.add_argument("--min-steps", type=int, default=2,
+                    help="a transcript shorter than this did not run")
+    ap.add_argument("--no-closing-required", action="store_true",
+                    help="accept cells with no closing text (say why in the record)")
+    ap.add_argument("--allow-missing", type=int, default=0,
+                    help="proceed with this many cells short — an explicit, "
+                         "recorded choice, never a default")
+    ap.add_argument("--transcript-key", default="messages")
+    ap.add_argument("--closing-key", default="final_text")
+    a = ap.parse_args(argv)
+
+    expected = None
+    if a.expect:
+        expected = [l.strip() for l in open(a.expect, encoding="utf-8")
+                    if l.strip() and not l.startswith("#")]
+
+    cells, broken, absent = inspect(
+        a.pattern, expected, a.min_steps, not a.no_closing_required,
+        a.transcript_key, a.closing_key)
+
+    good = len(cells) - len(broken)
+    want = len(expected) if expected else len(cells)
+    print(f"cells found {len(cells)} · complete {good} · expected {want}")
+    for c, why in broken:
+        print(f"  INCOMPLETE {c.name}: {why}")
+    for n in absent:
+        print(f"  ABSENT     {n}")
+
+    if not cells:
+        print(f"\nHELD: no cells matched {a.pattern!r}. An empty grid is not a "
+              f"complete one — check the pattern, and quote it so the shell "
+              f"does not expand it.")
+        return 1
+
+    short = want - good
+    if short <= 0:
+        print("grid complete")
+        return 0
+    if short <= a.allow_missing:
+        print(f"proceeding {short} cell(s) short — allowed explicitly "
+              f"(--allow-missing {a.allow_missing}); record this alongside the result, "
+              f"missing cells are not a random sample")
+        return 0
+    print(f"\nHELD: {short} cell(s) short of the grid. Fix the run, or state the "
+          f"allowance with --allow-missing and say why in the record.")
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

masterwork/ceremony.py

@@ -0,0 +1,205 @@
+"""The sitting where the piece is made.
+
+The model reads the teachings and is asked, one axis at a time, what it will
+hold to. Its answers are its own; nothing is asserted at it and no earlier
+commitment is in view. At the end it distils its own answers into one
+standing text, and that text — not anything written for it — becomes the
+identity it reads on every later request.
+
+Four properties are the recipe rather than implementation detail, and each
+was paid for:
+
+  * **Anchorless.** No previous commitment or name is anywhere in the
+    context. With one present the model copies it, and a copy is a role
+    being worn rather than a pattern re-derived. It also destroys the
+    measurement: you can no longer tell whether the teachings carried.
+  * **One session.** Every answer is an assistant turn in the same dialogue,
+    so the model is distilling something it actually said a moment ago, not
+    a text handed to it as if it were its own.
+  * **Order is shuffled by a seed.** Answers otherwise echo their
+    neighbours in the order they were asked.
+  * **The distillation is not a rewrite.** The closing turn says: these are
+    your words, remove repetition, join where they meet, drop nothing.
+    Asked to "write an identity" the model produces a description of one.
+
+Everything that varies between workshops — the teachings, the questions,
+the closing instruction, the sampling profile — is data. What lives here is
+the shape of the sitting.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import random
+import sys
+import time
+import urllib.request
+
+# The sampling used for the sitting must match the sampling the piece will
+# later be read under; a candidate made at one temperature and run at
+# another is not the candidate that was measured.
+DEFAULT_PARAMS = {"temperature": 0.15, "top_p": 0.9, "min_p": 0.05,
+                  "presence_penalty": 0.1, "repeat_penalty": 1.05}
+
+
+def ask(endpoint: str, messages: list[dict], model: str | None = None,
+        params: dict | None = None, max_tokens: int = 8000,
+        sampling_seed: int | None = None, thinking: bool = True,
+        timeout: int = 600, _attempt: int = 0) -> tuple[str, str]:
+    """One turn. Returns (text, reasoning).
+
+    An empty answer from a reasoning model usually means the thinking ate
+    the budget, not that it refused. Retrying with a larger budget is the
+    documented behaviour rather than a silent zero — a zero here would sail
+    through every later stage looking like an answer.
+    """
+    body = {"model": model or "default", "messages": messages,
+            "max_tokens": max_tokens,
+            "chat_template_kwargs": {"enable_thinking": thinking},
+            **(params if params is not None else DEFAULT_PARAMS)}
+    if sampling_seed is not None:
+        body["seed"] = sampling_seed
+    req = urllib.request.Request(
+        endpoint.rstrip("/") + "/v1/chat/completions",
+        json.dumps(body).encode(), {"Content-Type": "application/json"})
+    with urllib.request.urlopen(req, timeout=timeout) as r:
+        d = json.load(r)
+    msg = d["choices"][0]["message"]
+    text = (msg.get("content") or "").strip()
+    thought = msg.get("reasoning_content") or ""
+    if not text and _attempt < 3:
+        return ask(endpoint, messages, model, params, int(max_tokens * 1.6),
+                   sampling_seed, thinking, timeout, _attempt + 1)
+    return text, thought
+
+
+def _md5(text: str) -> str:
+    return hashlib.md5(text.encode()).hexdigest()
+
+
+def hold(corpus: str, script: dict, endpoint: str, model: str | None = None,
+         params: dict | None = None, order_seed: int = 0,
+         sampling_seed: int | None = None, max_tokens: int = 8000,
+         report=lambda *_: None) -> dict:
+    """Run the sitting. Returns the transcript, the name and the standing text.
+
+    `script` carries the workshop's words: questions (label + text), the
+    closing appended to each, the name question and the distillation
+    question. Nothing here is embedded, so a house can change what it asks
+    without touching the shape of the asking.
+    """
+    questions = list(script["questions"])
+    random.Random(order_seed).shuffle(questions)
+    closing = script.get("closing", "")
+
+    messages: list[dict] = []
+    rounds = []
+    for i, q in enumerate(questions):
+        text = q["text"] + closing
+        if i == 0:
+            messages.append({"role": "user", "content": corpus + "\n\n" + text})
+        else:
+            messages.append({"role": "user", "content": text})
+        answer, thought = ask(endpoint, messages, model, params, max_tokens,
+                              sampling_seed)
+        if not answer:
+            raise RuntimeError(f"empty answer at {q['label']} — the sitting is "
+                               f"incomplete and must not be sealed")
+        messages.append({"role": "assistant", "content": answer})
+        rounds.append({"label": q["label"], "answer": answer, "thought": thought})
+        report(f"  {q['label']} ({len(answer)} chars)")
+
+    messages.append({"role": "user", "content": script["name"]})
+    name_answer, _ = ask(endpoint, messages, model, params, max_tokens, sampling_seed)
+    messages.append({"role": "assistant", "content": name_answer})
+    name = ""
+    for line in name_answer.splitlines():
+        if line.strip().lower().startswith("name:"):
+            name = line.split(":", 1)[1].strip()
+    report(f"  name: {name or '(not given in the asked shape)'}")
+
+    messages.append({"role": "user", "content": script["distil"]})
+    standing, _ = ask(endpoint, messages, model, params,
+                      max(max_tokens, 12000), sampling_seed)
+    if not standing:
+        raise RuntimeError("empty standing text — nothing to seal")
+    report(f"  standing text: {len(standing)} chars")
+
+    return {
+        "name": name,
+        "name_answer": name_answer,
+        "text": standing,
+        "rounds": rounds,
+        "order_seed": order_seed,
+        "sampling_seed": sampling_seed,
+        "corpus_hash": _md5(corpus),
+        "script_hash": _md5(json.dumps(script, sort_keys=True, ensure_ascii=False)),
+        "questions_asked": [q["label"] for q in questions],
+        "date": time.strftime("%Y-%m-%d"),
+    }
+
+
+def seal_text(transcript: dict, script_hash: str | None = None) -> str:
+    """The piece plus its maker's mark, in the shape the seal reader expects.
+
+    Refuses to stamp a mark it cannot make again. Formatting an absent seed
+    into the header writes the word "None", which looks like a value.
+    """
+    for field in ("corpus_hash", "order_seed", "sampling_seed", "date"):
+        if transcript.get(field) in (None, ""):
+            raise ValueError(
+                f"cannot seal: {field} is unset. Two candidates from one corpus "
+                f"that differ only by sampling seed are different candidates, "
+                f"so a piece made without one cannot be made again.")
+    return (
+        "# masterwork seal\n"
+        f"# name: {transcript.get('name') or '(unnamed)'}\n"
+        f"# corpus hash: {transcript['corpus_hash']}\n"
+        f"# script hash: {script_hash or transcript['script_hash']}\n"
+        f"# question seed: {transcript['order_seed']} "
+        f"· sampling seed: {transcript.get('sampling_seed')}\n"
+        f"# date: {transcript['date']}\n\n"
+        + transcript["text"].strip() + "\n")
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(prog="masterwork ceremony", description="hold a sitting and seal the piece")
+    ap.add_argument("corpus", help="the teachings, as text")
+    ap.add_argument("script", help="JSON: questions, closing, name, distil")
+    ap.add_argument("--endpoint", required=True)
+    ap.add_argument("--model")
+    ap.add_argument("--params-file", help="JSON sampling profile; must match "
+                                          "the profile the piece is later read under")
+    ap.add_argument("--order-seed", type=int, default=0)
+    ap.add_argument("--sampling-seed", type=int,
+                    help="two candidates from one corpus differing only by this "
+                         "seed are different candidates, so it is recorded")
+    ap.add_argument("--max-tokens", type=int, default=8000)
+    ap.add_argument("--out", required=True, help="where to write the sealed piece")
+    ap.add_argument("--transcript", help="where to write the sitting itself")
+    a = ap.parse_args(argv)
+
+    corpus = open(a.corpus, encoding="utf-8").read()
+    script = json.load(open(a.script, encoding="utf-8"))
+    params = json.load(open(a.params_file, encoding="utf-8")) if a.params_file else None
+
+    print(f"sitting: {len(script['questions'])} questions, order seed "
+          f"{a.order_seed}, sampling seed {a.sampling_seed}", file=sys.stderr)
+    transcript = hold(corpus, script, a.endpoint, a.model, params,
+                      a.order_seed, a.sampling_seed, a.max_tokens,
+                      report=lambda m: print(m, file=sys.stderr, flush=True))
+
+    os.makedirs(os.path.dirname(os.path.abspath(a.out)), exist_ok=True)
+    with open(a.out, "w", encoding="utf-8") as f:
+        f.write(seal_text(transcript))
+    if a.transcript:
+        json.dump(transcript, open(a.transcript, "w", encoding="utf-8"),
+                  ensure_ascii=False, indent=1)
+    print(f"sealed -> {a.out}", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

masterwork/gate.py

@@ -0,0 +1,258 @@
+"""The frozen gate: a threshold is only a threshold if it clears the noise.
+
+Before a run decides anything, the decision rule is written down and frozen.
+Looking at results afterwards is fine; moving the rule is not. But a frozen
+rule is still worthless if the threshold sits inside the arm's own run-to-run
+spread — then the gate is not reading the effect, it is reading the sampling.
+
+So a gate section must carry three lines, and this checker enforces all
+three by executing the first one:
+
+    band-command: <a command that COMPUTES the spread>
+    band-value:   <the spread it produces, with n>
+    threshold:    <the decision threshold — must be above the band>
+
+The reason it is three lines rather than a principle: written as a
+principle, it gets read, agreed with, and skipped. A skip then costs
+nothing and shows up nowhere. With three required lines, skipping means
+actively leaving them blank, which is visible.
+
+Two verdicts other than pass, both deliberate:
+
+  * A band-command that merely prints a number already written in its own
+    text is not a measurement, it is a quotation. That returns UNVERIFIABLE
+    (exit 2) — a human has to sign for it — rather than passing quietly.
+  * A section that produces a decision but carries none of the three lines
+    fails outright. A section that is deliberately not a gate says so with
+    `gate-skip: <reason>`, and the reason is printed, so exemptions cannot
+    hide as silence.
+"""
+from __future__ import annotations
+
+import argparse
+import glob
+import os
+import re
+import subprocess
+import sys
+
+FIELDS = ("band-command", "band-value", "threshold")
+# A section that names an axis is applied to the measured report as well as
+# checked for validity. Without `measure`, a gate is only a written rule and
+# a human still has to bind it to numbers — which is where a verdict quietly
+# becomes an opinion.
+APPLY = ("measure", "compare")
+# Field names are data, like seal headers: a workshop writing its gates in
+# another language passes --profile {canonical: [aliases]} rather than
+# translating frozen documents, which would edit the record after the fact.
+DEFAULT_FIELD_ALIASES: dict[str, list[str]] = {f: [f] for f in FIELDS}
+SKIP = re.compile(r"^\s*gate-skip\s*:\s*(.+)$", re.M | re.I)
+# A section that decides something: an explicit verdict word or a comparison.
+DECIDES = re.compile(r"^.*(?:\b(?:accept|reject|veto|pass|fail)\b\s*:|>=|<=|≥|≤).*$",
+                     re.M | re.I)
+NUMBER = re.compile(r"-?\d+(?:[.,]\d+)?")
+ABOVE = re.compile(r"\babove\b", re.I)
+# "above" is a word, and words are dialect like field names. A workshop that
+# writes its frozen gates in another language should configure the reader
+# rather than translate documents that were frozen before a run.
+ABOVE_WORDS = ("above",)
+
+
+def numbers(text: str) -> list[float]:
+    return [float(m.group(0).replace(",", ".")) for m in NUMBER.finditer(text)]
+
+
+def first_number(text: str):
+    n = numbers(text)
+    return n[0] if n else None
+
+
+def field(body: str, name: str, aliases: dict | None = None):
+    for alias in (aliases or DEFAULT_FIELD_ALIASES).get(name, [name]):
+        m = re.search(rf"^\s*{re.escape(alias)}\s*:\s*(.+)$", body, re.M | re.I)
+        if m:
+            return m.group(1).strip()
+    return None
+
+
+def sections(text: str):
+    for part in re.split(r"^##\s+", text, flags=re.M)[1:]:
+        title, _, body = part.partition("\n")
+        yield title.strip(), body
+
+
+def _above(text: str, aliases: dict | None) -> bool:
+    words = (aliases or {}).get("above") or ABOVE_WORDS
+    return any(re.search(rf"\b{re.escape(w)}\b", text, re.I) for w in words)
+
+
+def check_section(body: str, timeout: int = 60, aliases: dict | None = None):
+    """Return (verdict, notes). verdict: PASS | FAIL | UNVERIFIABLE | SKIP."""
+    skip = SKIP.search(body)
+    if skip:
+        return "SKIP", [f"declared not a gate: {skip.group(1).strip()}"]
+
+    missing = [f for f in FIELDS if field(body, f, aliases) is None]
+    if len(missing) == len(FIELDS):
+        line = DECIDES.search(body)
+        return "FAIL", ["decides something but no band was measured",
+                        f"matched decision line: {line.group(0).strip()[:100]!r}"
+                        if line else "",
+                        "if this is not a gate, add `gate-skip: <reason>`"]
+    if missing:
+        return "FAIL", [f"missing: {', '.join(missing)} — the gate is void"]
+
+    command = field(body, "band-command", aliases)
+    written = first_number(field(body, "band-value", aliases) or "")
+    placement = field(body, "threshold", aliases) or ""
+
+    try:
+        p = subprocess.run(["bash", "-lc", command], capture_output=True,
+                           text=True, timeout=timeout)
+    except subprocess.TimeoutExpired:
+        return "FAIL", [f"band-command did not finish in {timeout}s"]
+    if p.returncode != 0:
+        return "FAIL", [f"band-command failed (rc={p.returncode}): "
+                        f"{(p.stderr or p.stdout).strip()[:200]}"]
+
+    produced = numbers(p.stdout)
+    if not produced or written is None:
+        return "UNVERIFIABLE", [f"band is not numeric; output was "
+                                f"{p.stdout.strip()[:120]!r} — sign for it by hand"]
+
+    close = [x for x in produced if abs(x - written) <= max(0.02, 0.05 * abs(x))]
+    if not close:
+        return "FAIL", [f"band-value says {written} but the command produces "
+                        f"{produced[:6]} — the band was written from memory"]
+
+    if any(abs(x - written) <= 1e-9 for x in numbers(command)):
+        return "UNVERIFIABLE", [f"band-command does not compute {written}, it "
+                                f"restates it — a quotation, not a measurement"]
+
+    band = close[0]
+    if not _above(placement, aliases):
+        return "FAIL", [f"threshold does not claim to be above the band: {placement!r}"]
+    threshold = first_number(placement)
+    if threshold is None:
+        return "UNVERIFIABLE", [f"threshold is not numeric: {placement!r}"]
+    if threshold <= band:
+        return "FAIL", [f"threshold {threshold} <= band {band:.4f} — this gate "
+                        f"reads sampling noise, not effect"]
+    sound = (f"band {band:.4f} (computed) · threshold {threshold} "
+             f"· margin {threshold - band:+.4f}")
+    # Sound rule, nothing to apply it to. Said here, at freeze time, because
+    # the alternative is learning it after the run — when a human binds the
+    # rule by hand and the verdict quietly becomes an opinion.
+    if not field(body, "measure", aliases):
+        return "UNBOUND", [sound, "no `measure:` field — this rule can never "
+                                  "touch a report; name the axis now, not later"]
+    return "PASS", [sound]
+
+
+def evaluate_section(body: str, measured: dict, incumbent: dict | None = None,
+                     aliases: dict | None = None):
+    """Apply a checked gate to measured axes. (verdict, notes).
+
+    verdict: ACCEPT | REJECT | UNRESOLVED | NOT_APPLIED
+
+    UNRESOLVED is a real answer and is kept distinct from "no difference".
+    A difference smaller than the threshold has not been shown to be absent;
+    it has been shown to be unresolvable at this size, and the note says how
+    many cells per arm it would take — otherwise the next reader turns a
+    silence into a finding.
+    """
+    axis = field(body, "measure", aliases)
+    if not axis:
+        return "NOT_APPLIED", ["no `measure:` field — the rule is written but "
+                               "never bound to a number"]
+    if axis not in measured:
+        return "NOT_APPLIED", [f"axis {axis!r} is not in the report "
+                               f"(has: {', '.join(sorted(measured)) or 'nothing'})"]
+
+    threshold = first_number(field(body, "threshold", aliases) or "")
+    band = first_number(field(body, "band-value", aliases) or "")
+    compare = (field(body, "compare", aliases) or "candidate").lower()
+    value = measured[axis]
+
+    if "incumbent" in compare:
+        if not incumbent or axis not in incumbent:
+            return "NOT_APPLIED", [f"comparison needs the incumbent's {axis}, "
+                                   f"which was not supplied"]
+        difference = value - incumbent[axis]
+        shown = (f"{axis}: candidate {value:.4f} − incumbent "
+                 f"{incumbent[axis]:.4f} = {difference:+.4f}")
+    else:
+        difference = value
+        shown = f"{axis}: {value:.4f} (absolute)"
+
+    if threshold is None:
+        return "NOT_APPLIED", [shown, "threshold is not numeric"]
+    if difference >= threshold:
+        return "ACCEPT", [shown, f"clears +{threshold}"]
+    if difference <= -threshold:
+        return "REJECT", [shown, f"falls short by {threshold}"]
+
+    note = [shown, f"inside ±{threshold} — NOT resolvable at this size, "
+                   f"which is not the same as no difference"]
+    if band and abs(difference) > 0:
+        # Band shrinks as 1/sqrt(n); say what size would settle this.
+        note.append(f"a difference of {abs(difference):.4f} needs a band below "
+                    f"it: roughly {(band / abs(difference)) ** 2:.1f}x the cells "
+                    f"used for this band")
+    return "UNRESOLVED", note
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(prog="masterwork gate", description="check frozen gate files")
+    ap.add_argument("paths", nargs="+", help="gate files, or a directory to walk")
+    ap.add_argument("--timeout", type=int, default=60)
+    ap.add_argument("--profile", help="JSON map {canonical field: [aliases]}")
+    a = ap.parse_args(argv)
+
+    aliases = dict(DEFAULT_FIELD_ALIASES)
+    if a.profile:
+        import json as _json
+        for k, v in _json.load(open(a.profile, encoding="utf-8")).items():
+            aliases[k] = list(v) + aliases.get(k, [])
+    files = []
+    for p in a.paths:
+        if os.path.isdir(p):
+            files.extend(sorted(glob.glob(os.path.join(p, "**", "*.md"),
+                                          recursive=True)))
+        elif os.path.exists(p):
+            files.append(p)
+        else:
+            print(f"HELD: no gate file or directory at {p}")
+            return 1
+    if not files:
+        print(f"HELD: no gate files under {', '.join(a.paths)} — a gate is a "
+              f"markdown file; gates/example.md is the smallest one")
+        return 1
+
+    tally: dict[str, int] = {}
+    for path in files:
+        text = open(path, encoding="utf-8").read()
+        printed = False
+        for title, body in sections(text):
+            if not (DECIDES.search(body) or field(body, "band-command", aliases)):
+                continue
+            verdict, notes = check_section(body, a.timeout, aliases)
+            if not printed:
+                print(f"--- {path}")
+                printed = True
+            print(f"    [{verdict:<12}] {title}")
+            for n in notes:
+                if n:
+                    print(f"        {n}")
+            tally[verdict] = tally.get(verdict, 0) + 1
+
+    print("\n" + " · ".join(f"{v} {k}" for k, v in sorted(tally.items())) or "nothing to check")
+    if tally.get("FAIL"):
+        return 1
+    if tally.get("UNVERIFIABLE") or tally.get("UNBOUND"):
+        return 2
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())