OpenDecisions 1.0: 2,352 decisions (long logs removed), dataset card, scorer and letter readout

README.md

@@ -0,0 +1,191 @@
+---
+license: cc-by-sa-4.0
+pretty_name: OpenDecisions
+language:
+- en
+- pl
+- pt
+- es
+- de
+- ja
+- da
+- it
+- fr
+- hi
+- ar
+- zh
+- ko
+- uk
+- el
+- tr
+- nl
+- cs
+- fi
+- 'no'
+- sv
+- id
+task_categories:
+- multiple-choice
+- text-classification
+tags:
+- decision-model
+- jev
+- jevbench
+- calibration
+- evaluation
+size_categories:
+- 1K<n<10K
+configs:
+- config_name: default
+  data_files: opendecisions.jsonl
+---
+
+# OpenDecisions
+
+OpenDecisions (version 1.0) is a validation set of 2,352 Jev-style decisions: a state, a typed question and its options. A decision
+model returns one probability per option. The set is built to compare decision models such as Jev and its open
+alternatives. Its composition follows JevBench v1.6 (question types, difficulty tiers, item families and languages),
+but it contains no JevBench items.
+
+Use it for evaluation only. Do not train on it, fit temperatures on it, or use its items as examples.
+
+## At a glance
+
+| | |
+|---|---|
+| Decisions | 2,352 |
+| Question types | choice 1,178, yes/no 586, score (ordered levels) 588 |
+| Difficulty tiers | easy 443, standard 407, judge 581, hard 921 |
+| Languages | English 1,842; 510 items in 21 other languages or mixed-language inputs |
+| Labels | computed by code 599; written by an LLM author and confirmed by a labeler panel 1,443; real user requests labeled by the panel 310 |
+
+## Files
+
+| File | Content |
+|---|---|
+| `opendecisions.jsonl` | the 2,352 items |
+| `score.py` | the scorer: Intelligence, Calibration and Capability (Python standard library only) |
+| `predict_letters.py` | predictions from any Hugging Face chat model with a letter readout (one forward pass per item) |
+
+## How to evaluate
+
+Write one prediction per item to a JSONL file, `{"id": "<item id>", "probs": {...}}`:
+
+- choice: one probability per option id in `labels`
+- yes/no: `{"yes": p, "no": 1 - p}`
+- score: one probability per level `"0"`, `"1"`, ...
+
+The probabilities of an item must sum to 1. Items without a prediction count as wrong. Then run:
+
+```
+python score.py predictions.jsonl
+```
+
+To get predictions from a Hugging Face chat model:
+
+```
+pip install torch transformers accelerate
+python predict_letters.py --model google/gemma-4-31B-it --out predictions.jsonl
+python score.py predictions.jsonl
+```
+
+`predict_letters.py` shows each item as a multiple-choice prompt with lettered options, runs the model once and reads
+the probabilities of the option letters. `--temperatures` divides the letter logits by one temperature per question
+type (choice, yes/no, score). Fit temperatures on your own data, never on OpenDecisions.
+
+As a check of your setup: google/gemma-4-31B-it scores 72.3 without temperatures and 79.3 with
+`--temperatures 5.96,7.2444,7.2444` (the temperatures we fitted on separate data). Our paper reports 79.6 for the same
+model; there we ran many items per batch, which changes the top answer on 0.6% of items.
+
+## Format
+
+One JSON object per line, in JevBench's task format. A short example:
+
+```json
+{"id": "jb16-usecase-842d6d23b1", "family": "usecase", "tier": "easy", "language": "en",
+ "state": "CRM note, 2025-03-04, account Hillcrest Bakeries\nCall with Dana (purchasing). They open two new shops in May and asked us to double their weekly flour order from the first week of May onward.",
+ "question": {"type": "choice",
+              "instructions": "What does this note say about Hillcrest's flour orders from May?",
+              "criteria": {"lower_volume": "Hillcrest will order less flour than now.",
+                           "same_volume": "Hillcrest will keep ordering about the same amount.",
+                           "higher_volume": "Hillcrest will order more flour than now.",
+                           "not_mentioned": "The note says nothing about future order volume."}},
+ "labels": ["lower_volume", "same_volume", "higher_volume", "not_mentioned"],
+ "expected": "higher_volume"}
+```
+
+| Field | Content |
+|---|---|
+| `state` | the input: text or a JSON object |
+| `question` | `type` (`choice`, `noul` = yes/no, `score`), `instructions`, and `criteria`: one description per option (choice), the meaning of `true` and `false` (yes/no), or the ordered levels (score) |
+| `labels`, `expected` | the option ids and the correct one; yes/no items use `no` / `yes`; score items give the correct level as an index from 0 |
+| `family`, `tier`, `language`, `use_case`, `topic` | what kind of item it is |
+| `group` | items that belong together (pairs that differ in one detail, the same item with reordered options); empty otherwise |
+| `label_source` | `programmatic`, `author+panel` or `panel` (see below) |
+| `panel` | the answers of the three labeler models and their mean probability per option |
+| `provenance` | origin and licence of the item, and the reason for its label |
+| `jb16` | build details (generator, batch, prompt source) |
+
+Item IDs (`jb16-...`) and the `jb16` field keep the set's working name from when it was built.
+
+## Item families
+
+| Family | Items | What it tests |
+|---|---:|---|
+| llm_router | 694 | routing requests: task type, needed capability, model choice, difficulty |
+| multilingual | 422 | decisions on inputs in 21 languages other than English, or mixed |
+| fairness | 236 | variants that change only a protected attribute; the answer must stay the same |
+| usecase | 213 | everyday business decisions (support, compliance, extraction, and similar) |
+| jaggedness | 162 | easy-looking questions where models fail unevenly: counting, decimals vs. version numbers, dates, small sums |
+| negation_pair_gen | 160 | pairs whose answer flips because one fact or the question is negated |
+| option_order | 120 | the same item with its options reordered |
+| perturb_pair | 110 | pairs that change only an irrelevant detail; the answer must stay the same |
+| composite_gen | 106 | policies with 2 to 5 rules that need small computations |
+| calibration_gen, calibration | 129 | the state fixes the answer distribution exactly (rates among past cases, dice, cards, draws) |
+
+## How the labels were made
+
+- **Computed (599 items).** Written by seeded generators; the label is computed, so it is exact.
+- **Authored (1,443 items).** Written by LLM agents (Claude Opus) from fixed briefs, with a label and a rationale.
+  Kept only if a panel of three open models (Qwen3.8-27B, gpt-oss-120b, GLM-4.7-Flash) agreed with the label: all
+  three, or two of three with a mean probability of at least 0.5 on the label.
+- **Real requests (310 items).** User prompts from public datasets (Chatbot Arena 55k 288, Dolly 17, GSM8K 4,
+  MATH-500 1), each paired with a routing question. The label is the panel's answer, kept only when all three agree.
+- Items that belong together are kept only if every member passes.
+- Every candidate was compared with our model training data and with the 231 public JevBench items; 43 of 3,297
+  candidates were dropped for overlap. About 60 items were also read by hand.
+
+## Scoring
+
+`score.py` computes Capability, the mean of Intelligence and Calibration, as JevBench v1.6 defines them, with one
+change for yes/no questions.
+
+- Intelligence: accuracy corrected for chance, per question type and difficulty tier (tier weights: easy 0.1,
+  standard 0.2, judge 0.3, hard 0.4; the three question types weigh equally).
+- Calibration: an expected-calibration-error score per question type.
+- Yes/no answers: "yes" if P(yes) is at least 0.5, otherwise "no".
+
+Note: JevBench v1.6 counts a yes/no answer with P(yes) between 0.2 and 0.8 as an abstention, which is scored as
+wrong. OpenDecisions drops this rule. The exact definitions are in the docstring of `score.py`.
+
+We ran 17 public systems the way their authors serve them and scored them with JevBench v1.6's own rule. For the 14
+with an official Capability of 55 or more, OpenDecisions ranks them close to the official JevBench v1.6.1 board
+(Spearman correlation 0.90). For systems not used while the set was built, the official score is predicted to within
+3.0 points (root mean squared error).
+
+## Limitations
+
+- Authored items may differ in style from real requests, and some labels may be wrong. 71 items are answered wrongly by every strong public system we ran; some of them may have wrong labels, others are simply hard.
+- Compared with JevBench v1.6, our easy and standard tiers are easier and our hard tier is harder.
+- Non-English items were written natively by the agents but not checked by native speakers.
+- 78% of the items are English.
+- All inputs are short (at most about 10,000 characters), so the set does not test long inputs. We removed 37 very
+  long items (about 80,000 tokens each) before release, because most decision models, ours included, refuse inputs above
+  8,192 tokens.
+
+## Licence
+
+CC BY-SA 4.0. Items built from real requests keep the terms of their source (Chatbot Arena 55k: Apache-2.0; Dolly:
+CC BY-SA 3.0; GSM8K and MATH-500: MIT); each item names its source and licence in `provenance`. The code (`score.py`,
+`predict_letters.py`) is under the MIT License. This dataset is not
+affiliated with TypeSafe or Benchmark Heaven.

predict_letters.py

@@ -0,0 +1,110 @@
+"""Zero-shot letter readout of a Hugging Face chat model on OpenDecisions; writes predictions for score.py.
+
+    pip install torch transformers accelerate
+    python predict_letters.py --model google/gemma-4-31B-it --out predictions.jsonl
+    python predict_letters.py --model google/gemma-4-31B-it --out predictions.jsonl --temperatures 5.96,7.24,7.24
+    python score.py predictions.jsonl
+
+Each item becomes a multiple-choice prompt with lettered options (the prompt of SemIf, github.com/TheoLeeCJ/SemIf):
+a fixed system message and a JSON user message {"evidence": state, "criterion": question, "options": [{"letter",
+"description"}]}, rendered with the model's chat template with thinking disabled. One forward pass gives the
+next-token logits of the option letters A, B, C, ...; a softmax over the item's K letters gives the probabilities.
+Option descriptions are "<id>: <text>"; yes/no questions have the options "true" (listed first) and "false"; score
+levels are listed from lowest to highest. This is how JevBench's semif_direct adapter maps a question
+(github.com/fstandhartinger/jevbench, MIT).
+
+--temperatures choice,yesno,score divides the letter logits by one temperature per question type (default 1, 1, 1).
+Our paper fits them by NLL on separate data, never below 1 (for example 5.96, 7.24, 7.24 for Gemma 4 31B).
+Items above --max-tokens prompt tokens (default 8192) are skipped and count as wrong in score.py. MIT License.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+SYSTEM = ("Apply the supplied criterion to the supplied evidence. Choose exactly one listed option. "
+          "Respond with only its uppercase letter, with no explanation or reasoning.")
+LETTERS = "ABCDEFGHIJKLMNOP"
+
+
+def options(question: dict) -> list[dict]:
+    """Option ids and descriptions of one question, in prompt order."""
+    qtype, criteria = question["type"], question["criteria"]
+    if qtype == "noul":
+        opts = [(key, criteria.get(key, f"The proposition is {key}.")) for key in ("true", "false")]
+    elif qtype == "choice" and isinstance(criteria, dict):
+        opts = [(key, text or key) for key, text in criteria.items()]
+    elif qtype == "choice":                           # a bare list of option ids
+        opts = [(str(key), str(key)) for key in criteria]
+    else:
+        opts = [(str(i), text) for i, text in enumerate(criteria)]
+    return [{"id": key, "description": f"{key}: {text}"} for key, text in opts]
+
+
+def messages(item: dict) -> tuple[list[dict], list[str]]:
+    opts = options(item["question"])
+    if len(opts) > len(LETTERS):
+        raise ValueError(f"{item['id']}: more than {len(LETTERS)} options")
+    payload = {"evidence": item["state"], "criterion": item["question"]["instructions"],
+               "options": [{"letter": LETTERS[i], "description": o["description"]} for i, o in enumerate(opts)]}
+    return ([{"role": "system", "content": SYSTEM}, {"role": "user", "content": json.dumps(payload, ensure_ascii=False)}],
+            [o["id"] for o in opts])
+
+
+def letter_ids(tokenizer) -> list[int]:
+    ids = []
+    for letter in LETTERS:
+        encoded = tokenizer.encode(letter, add_special_tokens=False)
+        if len(encoded) != 1 or tokenizer.decode(encoded) != letter:
+            raise ValueError(f"the letter {letter!r} is not a single token for this tokenizer")
+        ids.append(encoded[0])
+    return ids
+
+
+def main() -> None:
+    import torch
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--model", required=True)
+    parser.add_argument("--revision", default=None)
+    parser.add_argument("--out", required=True)
+    parser.add_argument("--data", default=str(Path(__file__).resolve().parent / "opendecisions.jsonl"))
+    parser.add_argument("--temperatures", default="1,1,1", help="choice,yesno,score")
+    parser.add_argument("--max-tokens", type=int, default=8192)
+    parser.add_argument("--limit", type=int, default=None, help="only the first N items (for a quick test)")
+    args = parser.parse_args()
+    temps = dict(zip(("choice", "noul", "score"), (float(x) for x in args.temperatures.split(","))))
+
+    torch.backends.cuda.enable_cudnn_sdp(False)      # as in all our evaluations
+    tokenizer = AutoTokenizer.from_pretrained(args.model, revision=args.revision)
+    model = AutoModelForCausalLM.from_pretrained(args.model, revision=args.revision, dtype=torch.bfloat16,
+                                                 device_map="auto").eval()
+    letters = letter_ids(tokenizer)
+    with open(args.data, encoding="utf-8") as f:
+        items = [json.loads(line) for line in f if line.strip()][:args.limit]
+    written = skipped = 0
+    with open(args.out, "w", encoding="utf-8") as out:
+        for item in items:
+            msgs, ids = messages(item)
+            prompt = tokenizer.apply_chat_template(msgs, tokenize=False, add_generation_prompt=True, enable_thinking=False)
+            tokens = tokenizer.encode(prompt, add_special_tokens=False)
+            if len(tokens) > args.max_tokens:
+                skipped += 1
+                continue
+            with torch.inference_mode():
+                logits = model(input_ids=torch.tensor([tokens], device=model.device), use_cache=False,
+                               logits_to_keep=1).logits[0, -1].float()
+            qtype = item["question"]["type"]
+            probs = torch.softmax(logits[letters[:len(ids)]] / temps[qtype], dim=-1).tolist()
+            by_id = dict(zip(ids, probs))
+            if qtype == "noul":
+                by_id = {"yes": by_id["true"], "no": by_id["false"]}
+            out.write(json.dumps({"id": item["id"], "probs": by_id}) + "\n")
+            written += 1
+    print(f"wrote {written} predictions to {args.out}; skipped {skipped} items above {args.max_tokens} tokens")
+
+
+if __name__ == "__main__":
+    main()

score.py

@@ -0,0 +1,218 @@
+"""Score a model's predictions on OpenDecisions: Intelligence, Calibration and Capability.
+
+    python score.py predictions.jsonl                  # data file: opendecisions.jsonl next to this script
+    python score.py predictions.jsonl --data path/to/opendecisions.jsonl --json
+
+predictions.jsonl has one line per item: {"id": "<item id>", "probs": {"<label>": probability, ...}}
+  choice  one probability per id in the item's "labels"
+  yes/no  {"yes": p, "no": 1 - p}  (or only {"yes": p})
+  score   one probability per level "0", "1", ... (the item's "labels")
+Probabilities are used as given and must sum to 1 over the item's labels (within 0.01, so rounded outputs are fine).
+An item without a prediction counts as wrong (this is how we count inputs that are too long for a model).
+
+The metric is JevBench v1.6's Capability, with one change: a yes/no answer counts as "yes" when P(yes) >= 0.5 and
+as "no" otherwise. JevBench v1.6 instead counts an answer with 0.2 < P(yes) < 0.8 as an abstention (wrong).
+
+  Capability   = (Intelligence + Calibration) / 2
+  Intelligence = mean over the three question types of a tier-weighted, chance-corrected competence
+                 (tier weights easy 0.1, standard 0.2, judge 0.3, hard 0.4; each type's value clipped at 0),
+                 clipped to [0, 100]
+                 choice: 100 (acc - c) / (1 - c), c = mean of 1 / (number of options)
+                 yes/no: 100 (acc - 0.5) / 0.5
+                 score:  100 (1 - mean nMAE / mean nMAE of the mid-scale guess), nMAE = |E[level] - gold| / (K - 1)
+  Calibration  = mean over the three types of
+                 choice: 100 (1 - ECE / 0.5), top-label ECE on hard-tier items
+                 yes/no: 100 (1 - ECE / 0.5), ECE of P(yes)
+                 score:  mean of 100 (1 - top-level ECE / 0.5) and 100 (1 - mean nRPS)
+                 (ECE: 10 equal-width bins; each ECE term clipped at 0; only items with a prediction)
+
+This file reimplements the JevBench v1.6 scorer from its published method and reproduces the published v1.6.1
+results; JevBench's own v1.6 scorer is not public. MIT License.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import math
+from collections import defaultdict
+from pathlib import Path
+
+TIER_WEIGHTS = {"easy": 0.1, "standard": 0.2, "judge": 0.3, "hard": 0.4}
+TYPES = ("choice", "noul", "score")
+
+
+# ------------------------------------------------------------------ per item
+
+def ece(pairs: list[tuple[float, float]], bins: int = 10) -> float | None:
+    """Expected calibration error of (forecast, outcome) pairs; equal-width bins, empty bins absent."""
+    if not pairs:
+        return None
+    sums = defaultdict(lambda: [0, 0.0, 0.0])
+    for p, y in pairs:
+        p = min(max(float(p), 0.0), 1.0)
+        b = sums[min(int(p * bins), bins - 1)]
+        b[0] += 1
+        b[1] += p
+        b[2] += float(y)
+    return sum(n / len(pairs) * abs(o / n - f / n) for n, f, o in sums.values())
+
+
+def nrps(probs: list[float], gold: int) -> float:
+    """Normalized ranked probability score (0 is perfect)."""
+    k, cum, total = len(probs), 0.0, 0.0
+    for level in range(k - 1):
+        cum += probs[level]
+        total += (cum - (1.0 if gold <= level else 0.0)) ** 2
+    return total / (k - 1)
+
+
+def item_outcome(task: dict, probs: dict | None) -> dict:
+    """Outcome of one item; probs is None for a missing prediction (wrong, no forecast)."""
+    qtype, labels = task["question"]["type"], task["labels"]
+    out = {"id": task["id"], "type": qtype, "tier": task["tier"], "k": len(labels), "valid": probs is not None}
+    if qtype == "choice":
+        out["chance"] = 1.0 / len(labels)
+        if probs is None:
+            out.update(correct=False, conf=None)
+        else:
+            best = max(sorted(labels), key=lambda lab: probs[lab])        # ties: the smallest label
+            out.update(correct=best == task["expected"], conf=probs[best])
+    elif qtype == "noul":
+        y = 1.0 if task["expected"] == "yes" else 0.0
+        if probs is None:
+            out.update(correct=False, p_yes=None, y=y)
+        else:
+            p = probs["yes"]
+            out.update(correct=(p >= 0.5) == (y == 1.0), p_yes=p, y=y)   # the more likely side; no abstention
+    else:
+        k, gold = len(labels), int(task["expected"])
+        out["nmae_chance"] = sum(abs(level - gold) for level in range(k)) / k / (k - 1)   # random level
+        out["nmae_chance_mid"] = abs((k - 1) / 2 - gold) / (k - 1)                         # mid-scale guess
+        if probs is None:
+            out.update(nmae=max(gold, k - 1 - gold) / (k - 1), conf=None, correct=False)   # the worst level
+        else:
+            vector = [probs[str(level)] for level in range(k)]
+            ev = sum(level * p for level, p in enumerate(vector))
+            best = max(range(k), key=lambda level: (vector[level], -level))
+            out.update(nmae=abs(ev - gold) / (k - 1), conf=vector[best], correct=best == gold, nrps=nrps(vector, gold))
+    return out
+
+
+# ------------------------------------------------------------------ aggregation
+
+def _weighted(values: dict, weights: dict) -> float | None:
+    present = {k: v for k, v in values.items() if v is not None}
+    total = sum(weights[k] for k in present)
+    return sum(weights[k] * v for k, v in present.items()) / total if total else None
+
+
+def _mean(values: list[float]) -> float:
+    return sum(values) / len(values)
+
+
+def competence(outs: list[dict]) -> float | None:
+    """Chance-corrected competence of items of one type and tier (0 = chance, 100 = perfect)."""
+    if not outs:
+        return None
+    qtype = outs[0]["type"]
+    if qtype == "choice":
+        acc, chance = _mean([o["correct"] for o in outs]), _mean([o["chance"] for o in outs])
+        return 100 * (acc - chance) / (1 - chance)
+    if qtype == "noul":
+        return 100 * (_mean([o["correct"] for o in outs]) - 0.5) / 0.5
+    chance = _mean([o["nmae_chance_mid"] for o in outs])
+    if chance <= 0:                                       # every gold at mid-scale: the random-level baseline
+        chance = _mean([o["nmae_chance"] for o in outs])
+    return 100 * (1 - _mean([o["nmae"] for o in outs]) / chance)
+
+
+def intelligence(outs: list[dict]) -> tuple[float | None, dict]:
+    per_type = {}
+    for qtype in TYPES:
+        tiers = {t: competence([o for o in outs if o["type"] == qtype and o["tier"] == t]) for t in TIER_WEIGHTS}
+        cc = _weighted(tiers, TIER_WEIGHTS)
+        per_type[qtype] = None if cc is None else max(0.0, cc)
+    total = _weighted(per_type, {t: 1 / 3 for t in TYPES})
+    return (None if total is None else min(100.0, max(0.0, total))), per_type
+
+
+def _ece_score(e: float | None) -> float | None:
+    return None if e is None else max(0.0, 100 * (1 - e / 0.5))
+
+
+def calibration(outs: list[dict]) -> tuple[float | None, dict]:
+    parts = {}
+    choice = [o for o in outs if o["type"] == "choice" and o["valid"]]
+    if choice:
+        parts["choice"] = _ece_score(ece([(o["conf"], float(o["correct"])) for o in choice if o["tier"] == "hard"]))
+    noul = [o for o in outs if o["type"] == "noul" and o["valid"]]
+    if noul:
+        parts["noul"] = _ece_score(ece([(o["p_yes"], o["y"]) for o in noul]))
+    score = [o for o in outs if o["type"] == "score" and o["valid"]]
+    if score:
+        top = _ece_score(ece([(o["conf"], float(o["correct"])) for o in score]))
+        parts["score"] = (top + 100 * (1 - _mean([o["nrps"] for o in score]))) / 2
+    return _weighted(parts, {t: 1 / 3 for t in TYPES}), parts
+
+
+def summary(outs: list[dict]) -> dict:
+    i, cc = intelligence(outs)
+    c, cal = calibration(outs)
+    accuracy = {t: _mean([o["correct"] for o in outs if o["type"] == t]) * 100 for t in TYPES
+                if any(o["type"] == t for o in outs)}
+    return {"capability": None if i is None or c is None else (i + c) / 2, "intelligence": i, "calibration": c,
+            "competence_per_type": cc, "calibration_per_type": cal, "accuracy_per_type": accuracy,
+            "items": len(outs), "predicted": sum(o["valid"] for o in outs)}
+
+
+# ------------------------------------------------------------------ input
+
+def normalized(task: dict, probs: dict) -> dict:
+    labels = task["labels"]
+    if task["question"]["type"] == "noul" and "no" not in probs:
+        probs = {"yes": probs["yes"], "no": 1.0 - probs["yes"]}
+    values = {lab: float(probs.get(lab, 0.0)) for lab in labels}
+    if any(not math.isfinite(v) or v < 0 for v in values.values()):
+        raise ValueError(f"{task['id']}: probabilities must be finite and non-negative")
+    if abs(sum(values.values()) - 1.0) > 0.01:
+        raise ValueError(f"{task['id']}: probabilities over the labels {labels} sum to {sum(values.values()):.4f}, not 1")
+    return values
+
+
+def score(tasks: list[dict], predictions: list[dict]) -> dict:
+    by_id = {t["id"]: t for t in tasks}
+    probs = {}
+    for p in predictions:
+        if p["id"] not in by_id:
+            raise ValueError(f"unknown item id {p['id']!r}")
+        if p["id"] in probs:
+            raise ValueError(f"item {p['id']!r} predicted twice")
+        probs[p["id"]] = normalized(by_id[p["id"]], p["probs"])
+    return summary([item_outcome(t, probs.get(t["id"])) for t in tasks])
+
+
+def read_jsonl(path) -> list[dict]:
+    with open(path, encoding="utf-8") as f:
+        return [json.loads(line) for line in f if line.strip()]
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("predictions")
+    parser.add_argument("--data", default=str(Path(__file__).resolve().parent / "opendecisions.jsonl"))
+    parser.add_argument("--json", action="store_true", help="print the full result as JSON")
+    args = parser.parse_args()
+    result = score(read_jsonl(args.data), read_jsonl(args.predictions))
+    if args.json:
+        print(json.dumps(result, indent=1))
+        return
+    print(f"Capability {result['capability']:.1f}  (Intelligence {result['intelligence']:.1f}, "
+          f"Calibration {result['calibration']:.1f});  {result['predicted']} of {result['items']} items predicted")
+    for t in TYPES:
+        if t in result["accuracy_per_type"]:
+            print(f"  {t:7s} accuracy {result['accuracy_per_type'][t]:5.1f}%  competence "
+                  f"{result['competence_per_type'][t]:5.1f}  calibration {result['calibration_per_type'][t]:5.1f}")
+
+
+if __name__ == "__main__":
+    main()