steps456: add code/exp/pipeline (chance.py + scoring.py + stage_d_blind.py) needed by pool_steps.eligible (MCQ yes/no rule); fixes ModuleNotFoundError 'chance'

steps456_20260910/code/exp/pipeline/chance.py

@@ -0,0 +1,425 @@
+"""One chance definition for every table (user plan item 3, 2026-09-06).
+
+item_chance(row, bench_meta, k_inferred=None, digit_index=False) -> (c, source)
+  Per-item chance c and its source, in this precedence:
+    list      1/k, k = length of the sample row's option list
+              (scoring.coerce_options; lists with k >= 2)
+    question  1/k, k = number of lettered option lines embedded in the question
+              text (stage_d_blind.embedded_options: >= 2 lines A, B, ... in order)
+    declared  1/num_options of exp/video_benchmarks.csv, only for benchmarks with
+              question_format == MCQ; has_chance_level is NOT consulted (that flag
+              produced the NA cells of the earlier tables); several integers
+              ("4 or 6") give the mean of 1/n
+    inferred  1/k_inferred, k inferred from the letter-form golds of the
+              benchmark's items without an option list (infer_k: the smallest
+              number of leading positions that holds >= 95 % of those golds, at
+              least 2); passed in by the caller (bench_chance computes it)
+    yesno     0.5 for golds yes / no / true / false
+    open      0 (everything else: free text, numbers, intervals)
+  Multi-select golds use 1/k of their option count like single-select items.
+
+bench_chance(samples, bench_meta) -> dict
+  c          benchmark chance = mean of the item chances over the MULTIPLE-CHOICE
+             items only (is_mcq_item; user decision 2026-09-10: every statistic uses
+             multiple-choice items, yes/no and open items excluded); c_all keeps the
+             earlier all-item mean; n_mcq / n_excluded / mcq_qids report the split
+  cvec       {qid: c_item}
+  csrc       Counter of sources
+  c_source   "declared:8;list:292" (sorted source:count pairs)
+  k_inf      inferred k (0 when no item needed it)
+  n_items, n_open, digit_index, pos ({qid: gold letter}, see gold_position)
+
+item_chances(samples, bench_meta) -> (cvec, pos, csrc, k_inf)
+  Compatibility wrapper for exp/analysis/apex/breaking_levels.py.
+
+gold_position(row, opts, fmt, digit_index) -> letter | None
+  Letter of the gold option (fixed-position attacker of breaking_levels).
+
+Consumers: stage_e1_stats.py (e1_table chance), e1_n1_stats.py (N1 e1_table),
+stage_p2_profiles.py (chance / lang_prior), exp/t3/export_t2_tables.py (T2
+threshold), exp/analysis/apex/breaking_levels.py, exp/report/build_tex.py.
+
+CLI (writes exp/results/chance_by_benchmark.csv and chance_notes.md):
+  python chance.py [--samples-dir D --samples-n1-dir D --bench-csv F --out-dir D]
+  The notes compare c against the *.pre_chance_v2.csv snapshots of the earlier
+  tables (e1_table, n1/e1_table, t2 s300 export, apex/breaking_levels) when
+  those files exist, and list every benchmark whose c moved by more than 0.01.
+"""
+import argparse
+import csv
+import glob
+import json
+import math
+import os
+import re
+import sys
+from collections import Counter
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+EXP = os.path.abspath(os.path.join(HERE, ".."))
+sys.path.insert(0, HERE)
+from scoring import _MULTI, _pre, coerce_options, mcq_letter  # noqa: E402
+from stage_d_blind import item_options  # noqa: E402
+
+BENCH_CSV = os.path.join(EXP, "video_benchmarks.csv")
+SOURCES = ["list", "question", "declared", "inferred", "yesno", "open"]
+# gold in letter form: "C", "(C)", "C.", "C. text", "[C] text"
+_LETTER_GOLD = re.compile(r"^\s*[\(\[]?([A-P])(?:[\)\]\.:]\s*(?:\S.*)?|\s*)$")
+_YESNO = {"yes", "no", "true", "false"}
+INFER_SHARE = 0.95
+
+
+# ------------------------------------------------------------------ meta
+def load_bench_meta(path=BENCH_CSV):
+    """{name: row} of exp/video_benchmarks.csv."""
+    return {r["name"]: r for r in csv.DictReader(open(path))}
+
+
+def bench_meta(meta, bench):
+    """Row for a sample-file stem ('/' in the CSV name is '_' in file names)."""
+    return meta.get(bench) or meta.get(bench.replace("_", "/")) or {}
+
+
+def declared_chance(m):
+    """1/num_options (mean over the integers found) for an MCQ-format
+    benchmark; None otherwise. has_chance_level is not consulted."""
+    if (m.get("question_format") or "").strip().upper() != "MCQ":
+        return None
+    ns = [int(x) for x in re.findall(r"\d+", str(m.get("num_options") or "")) if int(x) > 1]
+    if not ns:
+        return None
+    return sum(1.0 / n for n in ns) / len(ns)
+
+
+def declared_counts(m):
+    """Sorted integers of num_options (any format), for option-count checks."""
+    return sorted({int(x) for x in re.findall(r"\d+", str(m.get("num_options") or "")) if int(x) > 1})
+
+
+# ------------------------------------------------------------------ items
+def is_yesno(ans):
+    return str(ans if ans is not None else "").strip().lower() in _YESNO
+
+
+def gold_position(row, opts, fmt, digit_index=False):
+    """Letter of the gold option, or None (multi-select, open, unresolvable).
+    digit_index: the benchmark stores gold as a bare option index (NExT-QA style)."""
+    ans = row.get("answer")
+    if ans is None:
+        return None
+    if _MULTI.match(_pre(ans)):
+        return None
+    if opts:
+        return mcq_letter(ans, opts)
+    fmt = (fmt or "").strip().upper()
+    if fmt not in ("MCQ", "MIXED"):
+        return None
+    m = _LETTER_GOLD.match(_pre(ans))
+    if m:
+        return m.group(1).upper()
+    if fmt == "MCQ":
+        L = mcq_letter(ans)
+        if L:
+            return L
+        s = str(ans).strip()
+        if digit_index and re.fullmatch(r"\d", s):
+            return chr(65 + int(s))
+    return None
+
+
+def item_chance(row, m, k_inferred=None, digit_index=False):
+    """(c, source) for one sample row; m = video_benchmarks.csv row (or {})."""
+    opts, src = item_options(row)
+    if opts:
+        return 1.0 / len(opts), src
+    dec = declared_chance(m)
+    if dec:
+        return dec, "declared"
+    if k_inferred and gold_position(row, None, m.get("question_format", ""), digit_index):
+        return 1.0 / k_inferred, "inferred"
+    if is_yesno(row.get("answer")):
+        return 0.5, "yesno"
+    return 0.0, "open"
+
+
+def infer_k(samples, m, opts_of=None):
+    """(k_inferred, pos, digit_index) for a benchmark: k = smallest count of
+    leading positions holding >= 95 % of the letter-form golds of the items
+    without an option list (at least 2); 0 when no such gold exists. pos maps
+    every item (with or without options) to its gold letter when resolvable."""
+    fmt = m.get("question_format", "")
+    is_mcq = (fmt or "").strip().upper() == "MCQ"
+    if opts_of is None:
+        opts_of = {qid: item_options(r)[0] for qid, r in samples.items()}
+    unc_golds = [str(r.get("answer", "")).strip() for qid, r in samples.items() if not opts_of[qid]]
+    digit_index = bool(is_mcq and unc_golds and all(re.fullmatch(r"\d", g) for g in unc_golds if g))
+    pos = {}
+    for qid, r in samples.items():
+        L = gold_position(r, opts_of[qid], fmt, digit_index)
+        if L:
+            pos[qid] = L
+    unc_pos = sorted(ord(L) - 64 for q, L in pos.items() if not opts_of[q])
+    k_inf = 0
+    if unc_pos:
+        k_inf = max(2, unc_pos[min(len(unc_pos) - 1, int(math.ceil(INFER_SHARE * len(unc_pos))) - 1)])
+    return k_inf, pos, digit_index
+
+
+MCQ_SOURCES = ("list", "question", "declared", "inferred")
+_YN_SET = {"yes", "no", "true", "false"}
+
+
+def _yes_no_options(opts):
+    """True when the option texts are only yes/no (or true/false), e.g. ['A. Yes', 'B. No']."""
+    texts = set()
+    for o in opts or []:
+        t = re.sub(r"^\s*[\(\[]?[A-Za-z][\)\]\.:]\s*", "", str(o)).strip().lower().rstrip(".")
+        texts.add(t)
+    return bool(texts) and texts <= _YN_SET
+
+
+def is_mcq_item(row, m, k_inferred=None, digit_index=False):
+    """Statistics rule (user decision 2026-09-10): every statistic uses multiple-choice items only.
+    An item counts when its chance source is list / question / declared / inferred (an option list,
+    options embedded in the question text, a declared MCQ benchmark with a letter gold, or an inferred
+    option count) AND its options are not a bare yes/no (true/false) pair. Yes/no items and open items
+    (free text, numbers, intervals) are excluded."""
+    c, src = item_chance(row, m, k_inferred, digit_index)
+    if src not in MCQ_SOURCES or c <= 0:
+        return False
+    opts, _ = item_options(row)
+    if opts and _yes_no_options(opts):
+        return False
+    if not opts and is_yesno(row.get("answer")):
+        return False
+    return True
+
+
+def mcq_items(samples, m):
+    """{qid: row} of the multiple-choice items of a sample (see is_mcq_item)."""
+    m = m or {}
+    opts_of = {qid: item_options(r)[0] for qid, r in samples.items()}
+    k_inf, _, digit_index = infer_k(samples, m, opts_of)
+    return {qid: r for qid, r in samples.items() if is_mcq_item(r, m, k_inf, digit_index)}
+
+
+def bench_chance(samples, m):
+    """See module docstring. samples = {qid: row}; m = CSV row or {}.
+    2026-09-10: c is the mean item chance over the MULTIPLE-CHOICE items only (is_mcq_item); open and
+    yes/no items are reported in n_open / n_yesno / n_excluded and carry no weight. cvec keeps every
+    item's chance (excluded items keep 0 or 0.5) so callers can still look items up; mcq_qids lists the
+    items that statistics should use."""
+    m = m or {}
+    opts_of = {qid: item_options(r)[0] for qid, r in samples.items()}
+    k_inf, pos, digit_index = infer_k(samples, m, opts_of)
+    cvec, csrc, mcq = {}, Counter(), []
+    for qid, r in samples.items():
+        c, src = item_chance(r, m, k_inf, digit_index)
+        cvec[qid], csrc[src] = c, csrc[src] + 1
+        if is_mcq_item(r, m, k_inf, digit_index):
+            mcq.append(qid)
+    n = len(cvec)
+    c_mcq = (sum(cvec[q] for q in mcq) / len(mcq)) if mcq else None
+    return dict(c=c_mcq, cvec=cvec, csrc=csrc, c_source=source_string(csrc), k_inf=k_inf, n_items=n,
+                n_mcq=len(mcq), n_excluded=n - len(mcq), mcq_qids=mcq,
+                n_open=csrc.get("open", 0), n_yesno=csrc.get("yesno", 0), digit_index=digit_index, pos=pos,
+                c_all=(sum(cvec.values()) / n) if n else None)
+
+
+def item_chances(samples, m):
+    """breaking_levels.py compatibility: (cvec, pos, csrc, k_inf)."""
+    d = bench_chance(samples, m)
+    return d["cvec"], d["pos"], d["csrc"], d["k_inf"]
+
+
+def source_string(csrc):
+    return ";".join(f"{k}:{v}" for k, v in sorted(csrc.items()))
+
+
+def load_samples(path):
+    out = {}
+    if not path or not os.path.exists(path):
+        return out
+    for l in open(path):
+        if l.strip():
+            r = json.loads(l)
+            out[r["qid"]] = r
+    return out
+
+
+# ------------------------------------------------------------------ CLI
+def _f(v):
+    try:
+        return float(v)
+    except (TypeError, ValueError):
+        return None
+
+
+def _prev_table(path, bench_col, val_col, pick_first=True):
+    """{bench: value or None} from a snapshot; first non-NA per bench."""
+    out = {}
+    if not os.path.exists(path):
+        return None
+    for r in csv.DictReader(l for l in open(path) if not l.startswith("#")):
+        b = r.get(bench_col)
+        if b is None:
+            continue
+        v = _f(r.get(val_col))
+        if b not in out or (out[b] is None and v is not None):
+            out[b] = v
+    return out
+
+
+def reason_for(row):
+    """Short reason text derived from the source counts of a benchmark."""
+    src = dict(kv.split(":") for kv in row["c_source_counts"].split(";") if kv)
+    src = {k: int(v) for k, v in src.items()}
+    n = int(row["n_items"])
+    parts = []
+    if src.get("declared"):
+        parts.append(f"declared num_options={row['num_options_csv']} applied to {src['declared']} items "
+                     f"without an option list (has_chance_level={row['has_chance_level_csv']} no longer gates c)")
+    if src.get("question"):
+        parts.append(f"{src['question']} items carry lettered options inside the question text (1/k each)")
+    if src.get("inferred"):
+        parts.append(f"k={row['k_inferred']} inferred from letter-form golds for {src['inferred']} items")
+    if src.get("yesno"):
+        parts.append(f"{src['yesno']} yes/no golds count 0.5")
+    if src.get("open"):
+        parts.append(f"{src['open']}/{n} open items count 0 (item average, not MCQ-only mean)")
+    if src.get("list"):
+        parts.append(f"1/k over the option lists of {src['list']} items (k: {row['k_dist']})")
+    return "; ".join(parts) or "item-average over the sampled option lists"
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--samples-dir", default=os.path.join(EXP, "data", "samples"))
+    ap.add_argument("--samples-n1-dir", default=os.path.join(EXP, "data", "samples_n1"))
+    ap.add_argument("--bench-csv", default=BENCH_CSV)
+    ap.add_argument("--out-dir", default=os.path.join(EXP, "results"))
+    a = ap.parse_args()
+    meta = load_bench_meta(a.bench_csv)
+    rows = []
+    for set_name, d in (("main", a.samples_dir), ("n1", a.samples_n1_dir)):
+        for p in sorted(glob.glob(os.path.join(d, "*.jsonl"))):
+            bench = os.path.basename(p)[:-6]
+            m = bench_meta(meta, bench)
+            samples = load_samples(p)
+            r = bench_chance(samples, m)
+            kd = Counter(len(item_options(x)[0]) for x in samples.values() if item_options(x)[0])
+            rows.append(dict(bench=bench, set=set_name, c=f"{r['c']:.4f}" if r["c"] is not None else "NA",
+                             c_source_counts=r["c_source"], n_items=r["n_items"], n_open=r["n_open"],
+                             k_inferred=r["k_inf"], k_dist=";".join(f"{k}:{v}" for k, v in sorted(kd.items())),
+                             question_format=m.get("question_format", ""),
+                             num_options_csv=m.get("num_options", ""),
+                             has_chance_level_csv=m.get("has_chance_level", ""),
+                             n_mcq=r["n_mcq"], n_excluded=r["n_excluded"], n_yesno=r["n_yesno"],
+                             c_all=f"{r['c_all']:.4f}" if r["c_all"] is not None else "NA"))
+    # 2026-09-10: n_mcq / n_excluded / n_yesno / c_all appended (n_mcq = multiple-choice items = the n of every
+    # statistic; benchmarks with n_mcq = 0 leave the main-set tables; c_all = the earlier all-item mean)
+    cols = ["bench", "set", "c", "c_source_counts", "n_items", "n_open", "k_inferred", "k_dist",
+            "question_format", "num_options_csv", "has_chance_level_csv", "n_mcq", "n_excluded", "n_yesno", "c_all"]
+    out_csv = os.path.join(a.out_dir, "chance_by_benchmark.csv")
+    with open(out_csv, "w", newline="") as f:
+        w = csv.DictWriter(f, fieldnames=cols)
+        w.writeheader()
+        w.writerows(rows)
+    print(f"[chance] wrote {out_csv} ({len(rows)} rows)")
+    for set_name in ("main", "n1"):
+        z = [r["bench"] for r in rows if r["set"] == set_name and r["n_mcq"] == 0]
+        lo = [f"{r['bench']} ({r['n_mcq']})" for r in rows if r["set"] == set_name and 0 < r["n_mcq"] < 30]
+        print(f"[chance] {set_name}: {len(z)} benchmark(s) with n_mcq = 0 (excluded from every statistic): {z}")
+        print(f"[chance] {set_name}: {len(lo)} benchmark(s) with 0 < n_mcq < 30: {lo}")
+
+    # ---- notes: compare with the earlier tables (snapshots *.pre_chance_v2.csv)
+    R = a.out_dir
+    prev = {
+        "e1_table.csv (stage_e1_stats; has_chance_level-gated 1/num_options)":
+            _prev_table(os.path.join(R, "e1_table.pre_chance_v2.csv"), "bench", "chance"),
+        "n1/e1_table.csv (e1_n1_stats; csv else mean 1/k over option lists when >= half the items)":
+            _prev_table(os.path.join(R, "n1", "e1_table.pre_chance_v2.csv"), "bench", "chance"),
+        "t2/t2_eps_by_benchmark_s300.csv (export chance = 1/len(options), 0 without a list)":
+            _prev_table(os.path.join(R, "t2", "t2_eps_by_benchmark_s300.pre_chance_v2.csv"), "benchmark", "chance"),
+        "apex/breaking_levels.csv (item average over the reference model's validly scored items; "
+        "declared only when has_chance_level)":
+            _prev_table(os.path.join(R, "apex", "breaking_levels.pre_chance_v2.csv"), "bench", "c"),
+    }
+    extra_note = {
+        "apex": ("The apex value averages over the items the reference model scored validly (free-text golds "
+                 "are NA there), the new benchmark c averages over all sampled items with open items at 0; "
+                 "differences on benchmarks with open items come from that denominator. Inside "
+                 "breaking_levels.py the profile c is still computed on the reference items (same chance.py "
+                 "item values)."),
+        "e1_table": ("Previously NA = has_chance_level False in exp/video_benchmarks.csv (the old gate); the "
+                     "value now comes from the sampled items."),
+        "n1/e1": ("Previously NA = fewer than half the items carried an option list and the CSV had no "
+                  "has_chance_level; the value now comes from the sampled items."),
+        "t2": ("The export's chance is 1/len(options) of the sample list and 0 when the sample has no list "
+               "(question-embedded, declared, inferred and yes/no items); those benchmarks move from 0."),
+    }
+    by_bench = {r["bench"]: r for r in rows}
+    L = ["# Chance correction: changes against the earlier tables", "",
+         "Definition (exp/pipeline/chance.py): per item 1/k from the option list, else 1/k from lettered "
+         "option lines embedded in the question, else 1/declared num_options for MCQ-format benchmarks "
+         "(has_chance_level not consulted), else 1/k inferred from letter-form golds (k = smallest number of "
+         "leading positions holding >= 95 % of such golds), else 0.5 for yes/no golds, else 0 (open). "
+         "Benchmark c = mean over the multiple-choice items only (user decision 2026-09-10: yes/no and open items "
+         "are excluded from every statistic; n_mcq / n_excluded in exp/results/chance_by_benchmark.csv). "
+         "Source counts per benchmark: exp/results/chance_by_benchmark.csv.",
+         "", f"Benchmarks: {len(rows)} ({sum(r['set'] == 'main' for r in rows)} main, "
+         f"{sum(r['set'] == 'n1' for r in rows)} N1).", ""]
+    src_kinds = Counter()
+    for r in rows:
+        for k in {kv.split(":")[0] for kv in r["c_source_counts"].split(";") if kv}:
+            src_kinds[k] += 1
+    L.append("Benchmarks with at least one item per source: " + ", ".join(
+        f"{k} {src_kinds.get(k, 0)}" for k in SOURCES) + ".")
+    L.append("")
+    for name, tab in prev.items():
+        L.append(f"## Versus {name}")
+        L.append("")
+        for key, txt in extra_note.items():
+            if name.startswith(key):
+                L.append(txt)
+                L.append("")
+        if tab is None:
+            L.append("Snapshot not found; no comparison.")
+            L.append("")
+            continue
+        changed, from_na, unchanged, absent = [], [], 0, 0
+        for b, old in sorted(tab.items()):
+            r = by_bench.get(b)
+            if r is None or r["c"] == "NA":
+                absent += 1
+                continue
+            new = float(r["c"])
+            if old is None:
+                from_na.append((b, new, r))
+            elif abs(new - old) > 0.01:
+                changed.append((b, old, new, r))
+            else:
+                unchanged += 1
+        L.append(f"Benchmarks in the snapshot: {len(tab)}; unchanged (|delta| <= 0.01): {unchanged}; "
+                 f"changed by more than 0.01: {len(changed)}; previously NA / undefined: {len(from_na)}; "
+                 f"not among the current samples: {absent}.")
+        L.append("")
+        if changed:
+            L.append("| benchmark | before | after | reason |")
+            L.append("|---|---|---|---|")
+            for b, old, new, r in sorted(changed, key=lambda x: -abs(x[2] - x[1])):
+                L.append(f"| {b} | {old:.4f} | {new:.4f} | {reason_for(r)} |")
+            L.append("")
+        if from_na:
+            L.append("| benchmark | before | after | reason |")
+            L.append("|---|---|---|---|")
+            for b, new, r in sorted(from_na, key=lambda x: -x[1]):
+                L.append(f"| {b} | NA | {new:.4f} | {reason_for(r)} |")
+            L.append("")
+    out_md = os.path.join(a.out_dir, "chance_notes.md")
+    open(out_md, "w").write("\n".join(L) + "\n")
+    print(f"[chance] wrote {out_md}")
+
+
+if __name__ == "__main__":
+    main()

steps456_20260910/code/exp/pipeline/scoring.py

@@ -0,0 +1,399 @@
+"""Scoring rules shared by stages D/E/F.
+
+score(pred, answer, options, question_format) -> bool | None
+  * MCQ (question_format == "MCQ", or options is a list with >= 2 entries):
+    extract the leading option letter from pred (regex ^\\s*\\(?([A-J])[).\\s:]
+    plus bare-letter / "Answer: X" fallbacks); normalize the gold answer the
+    same way (it may be "A", "(A)", "A. text", or the full option text -> the
+    letter comes from its index in options). Compare letters; if either side
+    yields no letter, fall back to normalized-text comparison against the
+    resolved option text. A bare numeric answer ("0") resolves as an index
+    into options (text match has priority). A comma-separated multi-select
+    gold ("A,B,C") is scored as letter-set equality with the prediction.
+    str-typed options are coerced to a list when the format is recognizable
+    (JSON dict/list, python list repr, "A. ..." lines).
+  * temporal grounding (gold parses as EXACTLY two floats, e.g. "[ 0.  12.6]"
+    or "21 39"): extract the first two non-negative floats from pred and score
+    by interval IoU >= 0.5 (industry-standard R@0.5). Pred without two floats
+    falls back to normalized exact match.
+  * counting / numeric (gold parses as ONE number): if pred is not itself a
+    pure number sequence, extract the number from pred ("is/are/answer: N"
+    pattern preferred, else the last standalone number) and compare.
+  * free text (non-MCQ gold with >= FREETEXT_MIN_WORDS words): NOT rule-
+    scorable -> returns None. Callers must treat None as NA (exclude from
+    accuracy), never as wrong.
+  * other non-MCQ: normalized exact match (lowercase, punctuation stripped,
+    whitespace collapsed). If BOTH sides parse entirely as number sequences,
+    compare numerically ("5" == "5.0").
+
+chance_level(num_options, has_chance_level) -> float | None
+  None unless has_chance_level is truthy ("True"/"true"/True/1). num_options
+  may be junk from the CSV ('', 'NA', '4', '4 or 6'); every integer found
+  contributes 1/n and the mean is returned ("4 or 6" -> (1/4+1/6)/2).
+
+Run `python scoring.py` for the self-test.
+"""
+import ast
+import json
+import re
+
+# leading option letter: "B", "(B)", "B.", "B) text", "[b]", "b: text"
+_LEAD = re.compile(r"^\s*[\(\[]?([A-Ja-j])[\)\]\.,:]?(?:\s|$)")
+# comma-separated multi-select gold: "A,B,C" / "a, c"
+_MULTI = re.compile(r"^\s*[A-Ja-j](\s*,\s*[A-Ja-j])+\s*$")
+# "answer is (B)" / "Answer: B." / "option B"  (the LAST occurrence wins:
+# predictions often discuss wrong options before stating the answer)
+_STATED = re.compile(
+    r"(?:answer|option|choice)\s*(?:is|would\s+be)?\s*[:\-]?\s*[\(\[]?([A-Ja-j])[\)\]\.,:]?(?:\s|$)",
+    re.IGNORECASE)
+_STATED_CN = re.compile(r"答案\s*(?:是|为)?\s*[:：]?\s*[\(\[]?([A-Ja-j])(?![A-Za-z])")
+# extended alphabet K-P for benches with MORE than 10 options (N1 intake:
+# UCF101-AD 11, iSafetyBench 16). Selected only when len(options) > 10, so
+# every bench with <=10 options keeps the exact A-J behaviour above.
+_LEAD_X = re.compile(r"^\s*[\(\[]?([A-Pa-p])[\)\]\.,:]?(?:\s|$)")
+_MULTI_X = re.compile(r"^\s*[A-Pa-p](\s*,\s*[A-Pa-p])+\s*$")
+_STATED_X = re.compile(
+    r"(?:answer|option|choice)\s*(?:is|would\s+be)?\s*[:\-]?\s*[\(\[]?([A-Pa-p])[\)\]\.,:]?(?:\s|$)",
+    re.IGNORECASE)
+
+
+def _wide(options):
+    return isinstance(options, (list, tuple)) and len(options) > 10
+# non-negative decimal number (timestamps/counts); '-' is treated as a
+# separator ("10-20"), not a sign
+_NUM = re.compile(r"\d+(?:\.\d+)?")
+# "is/are/answer(ed)/total/count ... N" — preferred counting extraction
+_NUM_STATED = re.compile(
+    r"(?:\bis\b|\bare\b|\banswer\b|\banswered\b|\btotal\b|\bcount\b)"
+    r"[^0-9\n]{0,20}?(\d+(?:\.\d+)?)", re.IGNORECASE)
+# standalone number (not part of a word/identifier like "f16" or "1st")
+_NUM_ALONE = re.compile(r"(?<![\w.])(\d+(?:\.\d+)?)(?![\w])")
+
+FREETEXT_MIN_WORDS = 10  # gold this long cannot be scored by exact match
+IOU_THRESHOLD = 0.5      # temporal grounding R@0.5
+
+
+def _pre(s):
+    """Light normalization before letter extraction: full-width punctuation
+    and markdown emphasis defeat the regexes ('（C）', '**C**', 'C。')."""
+    s = str(s)
+    s = s.replace("（", "(").replace("）", ")").replace("：", ":")
+    s = s.replace("。", ".").replace("，", ",")
+    return s.replace("*", "").replace("#", "")
+
+
+def norm_text(s):
+    s = str(s).strip().lower()
+    s = re.sub(r"[‘’“”`]", "'", s)
+    s = re.sub(r"[^\w\s.\-]", " ", s)     # keep word chars, '.', '-' (numbers)
+    s = re.sub(r"\s+", " ", s).strip()
+    return s.strip(".").strip()
+
+
+def num_seq(s):
+    """Parse s as a pure sequence of numbers, else None."""
+    toks = re.sub(r"[\[\](){},;:]", " ", str(s)).split()
+    if not toks:
+        return None
+    out = []
+    for t in toks:
+        try:
+            out.append(float(t))
+        except ValueError:
+            return None
+    return out
+
+
+def coerce_options(options):
+    """Normalize an options field to a list (or None). The data contract
+    allows list|str|null; live str shapes: JSON dict '{"A": "Yes", ...}',
+    python-list repr, and newline 'A. ...' blocks."""
+    if options is None:
+        return None
+    if isinstance(options, (list, tuple)):
+        return list(options)
+    s = str(options).strip()
+    if not s:
+        return None
+    for parser in (json.loads, ast.literal_eval):
+        try:
+            v = parser(s)
+        except Exception:
+            continue
+        if isinstance(v, dict) and v:
+            # {'A': 'Yes', 'B': 'No'} -> values ordered by (letter) key
+            return [f"{k}. {v[k]}" for k in sorted(v, key=lambda x: str(x))]
+        if isinstance(v, (list, tuple)) and v:
+            return [str(x) for x in v]
+    lines = [l.strip() for l in s.splitlines() if l.strip()]
+    if len(lines) >= 2 and sum(
+            bool(re.match(r"^\(?[A-J][).:\.]\s*", l)) for l in lines) >= 2:
+        return lines
+    return None
+
+
+def _strip_letter_prefix(opt):
+    return re.sub(r"^\s*[\(\[]?[A-Ja-j][\)\]\.,:]\s+", "", str(opt)).strip()
+
+
+def mcq_letter(s, options=None):
+    """Extract an option letter from a prediction / gold answer."""
+    if s is None:
+        return None
+    s = _pre(s).strip()
+    options = coerce_options(options)
+    wide = _wide(options)
+    m = (_LEAD_X if wide else _LEAD).match(s)
+    if m:
+        letter = m.group(1).upper()
+        # bare 'A '/'I ' followed by more words is usually the article/pronoun
+        # ('A man walks...', 'I think...'), not the option letter: only accept
+        # it with an explicit delimiter or when the pred is the letter alone.
+        has_delim = any(ch in m.group(0) for ch in "()[].,:")
+        if has_delim or letter not in ("A", "I") or len(s.split()) == 1:
+            return letter
+    ms = (list((_STATED_X if wide else _STATED).finditer(s))
+          or list(_STATED_CN.finditer(s)))
+    if ms:
+        return ms[-1].group(1).upper()
+    if options:
+        ns = norm_text(s)
+        for i, opt in enumerate(options):
+            if ns and ns in (norm_text(opt), norm_text(_strip_letter_prefix(opt))):
+                return chr(65 + i)
+        # option text stated followed by explanation: containment, but only
+        # when EXACTLY ONE option matches (ambiguous containment stays None)
+        flat = lambda t: re.sub(r"\s+", " ", re.sub(r"[.\-]", " ", t)).strip()
+        nsf = flat(ns)
+        hits = []
+        for i, opt in enumerate(options):
+            ot = flat(norm_text(_strip_letter_prefix(opt)))
+            if ot and len(ot) >= 3 and f" {ot} " in f" {nsf} ":
+                hits.append(i)
+        if len(hits) == 1:
+            return chr(65 + hits[0])
+        # bare numeric index into options ("0" -> A); text match takes priority
+        if re.fullmatch(r"\d{1,2}", s) and int(s) < len(options):
+            return chr(65 + int(s))
+    return None
+
+
+def _letter_set(s, wide=False):
+    """Letters of a multi-select answer. Strict comma form first; otherwise
+    uppercase standalone letters ("The artifacts are A and C" -> {A, C}).
+    In the loose fallback 'I' is excluded (almost always the pronoun).
+    wide=True widens the alphabet to A-P (benches with >10 options)."""
+    s = _pre(s)
+    if (_MULTI_X if wide else _MULTI).match(s):
+        return {c.upper() for c in re.findall(r"[A-Pa-p]" if wide else r"[A-Ja-j]", s)}
+    toks = [t for t in re.findall(r"\b([A-P])\b" if wide else r"\b([A-J])\b", s)
+            if t != "I"]
+    return set(toks) if toks else None
+
+
+def parse_interval(s):
+    """(start, end) when s parses as exactly two numbers, else None."""
+    ns = num_seq(s)
+    if ns is not None and len(ns) == 2:
+        return (ns[0], ns[1])
+    return None
+
+
+def extract_pred_interval(pred):
+    """First two non-negative floats in pred ('from 10.5 to 20s' -> (10.5, 20))."""
+    nums = _NUM.findall(str(pred))
+    if len(nums) < 2:
+        return None
+    return (float(nums[0]), float(nums[1]))
+
+
+def interval_iou(a, b):
+    """Temporal IoU of two (start, end) intervals (order-normalized)."""
+    a = (min(a), max(a))
+    b = (min(b), max(b))
+    inter = max(0.0, min(a[1], b[1]) - max(a[0], b[0]))
+    union = max(a[1], b[1]) - min(a[0], b[0])
+    if union <= 0:  # both degenerate points
+        return 1.0 if abs(a[0] - b[0]) <= 1e-6 else 0.0
+    return inter / union
+
+
+def extract_pred_number(pred):
+    """Number stated in a verbose prediction; 'is/are/answer: N' pattern
+    preferred (last such match), else the last standalone number."""
+    s = str(pred).replace(",", "")   # '1,234' -> '1234'
+    ms = _NUM_STATED.findall(s)
+    if ms:
+        return float(ms[-1])
+    ms = _NUM_ALONE.findall(s)
+    if ms:
+        return float(ms[-1])
+    return None
+
+
+def score(pred, answer, options=None, question_format=None):
+    """True/False = rule-scored; None = NOT rule-scorable (free-text gold).
+    Callers must treat None as NA — excluded from accuracy, never 'wrong'."""
+    if pred is None or answer is None:
+        return False
+    options = coerce_options(options)
+    wide = _wide(options)
+    if (_MULTI_X if wide else _MULTI).match(_pre(answer)):  # multi-select gold "A,B,C"
+        return _letter_set(pred, wide) == _letter_set(answer, wide)
+    is_mcq = ((question_format or "").strip().upper() == "MCQ"
+              or (isinstance(options, (list, tuple)) and len(options) >= 2))
+    if is_mcq and isinstance(options, (list, tuple)) and options:
+        pl = mcq_letter(pred, options)
+        al = mcq_letter(answer, options)
+        if pl and al:
+            return pl == al
+        # one side unresolvable -> compare texts (resolve letters to option text)
+        ptxt = (norm_text(_strip_letter_prefix(options[ord(pl) - 65]))
+                if pl and ord(pl) - 65 < len(options) else norm_text(pred))
+        atxt = (norm_text(_strip_letter_prefix(options[ord(al) - 65]))
+                if al and ord(al) - 65 < len(options) else norm_text(answer))
+        return bool(ptxt) and ptxt == atxt
+    if is_mcq:  # MCQ without an options list: letter-vs-letter if possible
+        pl, al = mcq_letter(pred), mcq_letter(answer)
+        if pl and al:
+            return pl == al
+    # ---- temporal grounding: gold is exactly two floats -> IoU >= 0.5
+    gold_iv = parse_interval(answer)
+    if gold_iv is not None:
+        pred_iv = (parse_interval(pred) if num_seq(pred) is not None
+                   else extract_pred_interval(pred))
+        if pred_iv is not None:
+            return interval_iou(pred_iv, gold_iv) >= IOU_THRESHOLD
+        return bool(norm_text(pred)) and norm_text(pred) == norm_text(answer)
+    pn, an = num_seq(pred), num_seq(answer)
+    if pn is not None and an is not None:
+        return len(pn) == len(an) and all(abs(a - b) <= 1e-6 for a, b in zip(pn, an))
+    # ---- counting/numeric gold with a verbose prediction: extract the number
+    if an is not None and len(an) == 1:
+        pv = extract_pred_number(pred)
+        if pv is not None:
+            return abs(pv - an[0]) <= 1e-6
+        return bool(norm_text(pred)) and norm_text(pred) == norm_text(answer)
+    # ---- long free-text gold: not rule-scorable -> NA
+    if len(norm_text(answer).split()) >= FREETEXT_MIN_WORDS:
+        return None
+    return bool(norm_text(pred)) and norm_text(pred) == norm_text(answer)
+
+
+def chance_level(num_options, has_chance_level):
+    flag = str(has_chance_level).strip().lower()
+    if flag not in ("true", "1", "yes"):
+        return None
+    ns = [int(x) for x in re.findall(r"\d+", str(num_options or "")) if int(x) > 0]
+    if not ns:
+        return None
+    return sum(1.0 / n for n in ns) / len(ns)
+
+
+# ---------------------------------------------------------------- self-test
+def _selftest():
+    OPTS = ["Holding something", "Releasing something", "Not sure"]
+    LOPTS = ["A. Turn right and walk.", "B. Turn left and walk.", "C. Stay put."]
+    cases = [
+        # (pred, answer, options, fmt, expected)
+        ("B", "B", LOPTS, "MCQ", True),                       # bare letter
+        ("(B)", "B", LOPTS, "MCQ", True),                     # parenthesized
+        ("b) Turn left and walk.", "B", LOPTS, "MCQ", True),  # lowercase + text
+        ("B.", "C", LOPTS, "MCQ", False),                     # wrong letter
+        ("The answer is (C)", "C", LOPTS, "MCQ", True),       # stated answer
+        ("Answer: A", "A. Turn right and walk.", LOPTS, "MCQ", True),  # gold has text
+        ("Turn left and walk.", "B", LOPTS, "MCQ", True),     # pred is option text
+        ("Releasing something", "Releasing something", OPTS, "mixed", True),  # unlabeled opts
+        ("A", "Holding something", OPTS, "MCQ", True),        # letter vs option text
+        ("B", "Holding something", OPTS, "MCQ", False),
+        ("As shown, people run.", "C", LOPTS, "MCQ", False),  # 'As' is not letter A
+        ("Not sure.", "Not sure", OPTS, "MCQ", True),         # trailing period
+        # numeric index answers ("0" -> options[0]); text match has priority
+        ("A", "0", OPTS, "MCQ", True),                        # gold is index
+        ("Holding something", "0", OPTS, "MCQ", True),        # pred text vs gold index
+        ("B", "0", OPTS, "MCQ", False),
+        ("1", "B", ["cat", "dog", "fox"], "MCQ", True),       # pred is index
+        ("3", "5", ["5", "3", "1"], "MCQ", False),            # "3" is option text (B), not index
+        # multi-select "A,B,C": normalized letter-set equality
+        ("A,C", "C, A", LOPTS, "MCQ", True),
+        ("B, A and C", "A,B,C", None, "MCQ", True),
+        ("The artifacts are A and C.", "A,C", None, "MCQ", True),
+        ("A", "A,B", None, "MCQ", False),
+        ("A,B,C", "A,B", None, "MCQ", False),
+        # non-MCQ text
+        ("  Yes. ", "yes", None, "open", True),
+        ("A dog", "a  dog!", None, "open", True),
+        ("dog", "cat", None, "open", False),
+        ("", "cat", None, "open", False),                     # empty pred never correct
+        # numeric equivalence
+        ("5", "5.0", None, "numeric", True),
+        ("5", "6", None, "numeric", False),
+        # ---- letter-extraction robustness (review fixes) -----------------
+        ("I think the answer is B", "B", LOPTS, "MCQ", True),   # 'I' not letter I
+        ("A man walks by; the answer is C", "C", LOPTS, "MCQ", True),
+        ("A man walks in the park.", "A", LOPTS, "MCQ", False),  # article, no signal
+        ("**C**", "C", LOPTS, "MCQ", True),                   # markdown bold
+        ("（C）", "C", LOPTS, "MCQ", True),                    # full-width parens
+        ("C。", "C", LOPTS, "MCQ", True),                      # full-width period
+        ("答案是C", "C", LOPTS, "MCQ", True),                  # Chinese stated
+        ("Option A is wrong. The answer is B.", "B", LOPTS, "MCQ", True),  # last stated wins
+        ("Turn left and walk. That matches what happens.", "B", LOPTS, "MCQ", True),  # opt text + explanation
+        ("The artifacts I see are A and C.", "A,C", None, "MCQ", True),   # 'I' in multi-select prose
+        # str-typed options are coerced
+        ("A", "A", '{"A": "Yes", "B": "No"}', "MCQ", True),
+        ("Yes", "A", '{"A": "Yes", "B": "No"}', "MCQ", True),
+        ("B", "A", "['Yes', 'No']", None, False),
+        # ---- temporal grounding: IoU >= 0.5 (R@0.5) ----------------------
+        ("0, 12.6", "[ 0.  12.6]", None, "grounding", True),   # exact interval
+        ("0.0 12.0", "[ 0.  12.6]", None, "grounding", True),  # IoU 0.95
+        ("From 10.2 to 20.5 seconds.", "[10, 21]", None, "grounding", True),
+        ("5 - 8", "[20, 30]", None, "grounding", False),       # IoU 0
+        ("10-20", "[12, 22]", None, "grounding", True),        # '-' as separator, IoU 0.67
+        ("around 14", "[10, 20]", None, "grounding", False),   # one float -> exact fallback
+        ("2702 2715", "[2702. 2715.]", None, "grounding", True),  # numpy repr gold
+        ("[21, 39]", "[21, 39]", None, "open", True),
+        ("22 38", "[21, 39]", None, "open", True),             # IoU 16/18
+        # ---- counting: extract the number from a sentence ----------------
+        ("There are 13 repetitions.", "13", None, "numeric", True),
+        ("The person does 12 push-ups in total, so the answer is 12.", "12", None, "numeric", True),
+        ("I counted 5 pull-ups and then 7 squats.", "7", None, "numeric", True),  # last standalone
+        ("The count is 27.", "27", None, "open", True),
+        ("approximately 14.1 meters", "14.10", None, "open", True),
+        ("There are 5 people.", "6", None, "numeric", False),
+        ("many repetitions", "13", None, "numeric", False),    # no number -> exact fallback
+        ("13", "13", None, "numeric", True),
+        # ---- long free-text gold -> None (NA, not rule-scorable) ---------
+        ("some answer", "A woman wearing a white coat and black pants attacks "
+         "a public trash can with her feet on the street", None, "open", None),
+        ("the man opens the door", "the man opens the door", None, "open", True),
+    ]
+    for i, (p, a, o, f, want) in enumerate(cases):
+        got = score(p, a, o, f)
+        assert got is want if want is None else got == want, \
+            f"case {i}: score({p!r}, {a!r}) = {got}, want {want}"
+    assert chance_level("4", "True") == 0.25
+    assert chance_level("4 or 6", "True") == (0.25 + 1 / 6) / 2
+    assert chance_level("NA", "True") is None
+    assert chance_level("4", "False") is None
+    assert chance_level("", True) is None
+    assert abs(chance_level(5, True) - 0.2) < 1e-9
+    # coerce_options shapes
+    assert coerce_options('{"A": "Yes", "B": "No"}') == ["A. Yes", "B. No"]
+    assert coerce_options("['x', 'y']") == ["x", "y"]
+    assert coerce_options("A. foo\nB. bar\nC. baz") == ["A. foo", "B. bar", "C. baz"]
+    assert coerce_options("free text blob") is None
+    assert coerce_options(None) is None
+    assert coerce_options(["a", "b"]) == ["a", "b"]
+    # interval helpers
+    assert parse_interval("[ 0.  12.6]") == (0.0, 12.6)
+    assert parse_interval("12") is None
+    assert extract_pred_interval("from 3.5s to 9s") == (3.5, 9.0)
+    assert abs(interval_iou((0, 10), (5, 15)) - 1 / 3) < 1e-9
+    assert extract_pred_number("the answer is 42.") == 42.0
+    assert extract_pred_number("no digits here") is None
+    print(f"scoring selftest: {len(cases)} score cases + option/interval/"
+          f"number helper cases OK")
+
+
+if __name__ == "__main__":
+    _selftest()

steps456_20260910/code/exp/pipeline/stage_d_blind.py

@@ -0,0 +1,322 @@
+"""Stage D — blind condition: question+options only, NO video. Runs locally
+(API keys in env). Results: exp/results/blind/<bench>__<model>.jsonl, resumable.
+Usage: python stage_d_blind.py --model goldmane [--bench NAME] [--limit N]
+
+--options-only (N0.2, option-level attacker of the paper): the prompt carries
+ONLY the option list of the item — no question, no video — and asks for the
+letter of the most likely correct option. Items without an option list are
+skipped (counted per bench). The option list is taken from the sample's
+`options` field (scoring.coerce_options); when that field is absent the
+lettered option lines embedded in the question text are used (>= 2 lines
+"(A) ..." / "A. ..." / "A: ..." / "A) ..." with consecutive letters from A) and
+the row records opts_source="question". Options without a letter prefix are
+rendered as "A. ...", "B. ...". Same client/routing/retry as the blind mode.
+Results: <E1_RESULTS_DIR or exp/results>/options_only/<bench>__<model>.jsonl,
+same row schema (qid, pred, answer) plus opts_source and n_options.
+
+Routing: "claude" in model -> Anthropic Messages API, else Gemini
+generateContent (covers gemini-* and internal model names like goldmane).
+Gemini thinking models: skip parts flagged "thought", join the rest; on
+MAX_TOKENS with no visible text retry once with a larger budget.
+429/5xx/network errors back off exponentially (honoring retry-after).
+"""
+import argparse
+import glob
+import json
+import os
+import random
+import re
+import sys
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+import requests
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from scoring import coerce_options  # noqa: E402
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+SAMPLES = os.environ.get("E1_SAMPLES_DIR") or os.path.join(HERE, "..", "data", "samples")  # override: N1 new-benchmark E1 runs
+RESULTS = os.environ.get("E1_RESULTS_DIR") or os.path.join(HERE, "..", "results")
+OUT = os.path.join(RESULTS, "blind")               # replaced by main() for --options-only
+
+PROMPT = ("You will answer a question about a video WITHOUT seeing the video. "
+          "Guess the most likely answer from the question and options alone.\n\n"
+          "Question: {q}\n{opts}\n"
+          "Reply with ONLY the option letter (or the exact short answer if no options).")
+
+PROMPT_OPTIONS_ONLY = (
+    "You will see ONLY the answer options of a multiple-choice question about a video. "
+    "The question and the video are not shown. Choose the option that is most likely "
+    "to be the correct answer.\n\nOptions:\n{opts}\n\n"
+    "Reply with ONLY the option letter.")
+
+MAX_ATTEMPTS = 5
+
+# lettered option line: "(A) text" / "A. text" / "A: text" / "A) text" / "[A] text"
+_OPT_LINE = re.compile(r"^\s*[\(\[]?([A-P])[\)\]\.:]\s*(\S.*)?$")
+
+
+def embedded_options(question):
+    """Option lines embedded in the question text, in order, or None.
+    Requires >= 2 lines whose letters run consecutively from A."""
+    out = []
+    for line in str(question or "").splitlines():
+        m = _OPT_LINE.match(line)
+        if m and m.group(1) == chr(65 + len(out)):
+            out.append(line.strip())
+        elif m and out:
+            break
+    return out if len(out) >= 2 else None
+
+
+def item_options(row):
+    """(option list, source) for an item; source in {"list", "question"}; (None, None)
+    when the item carries no option list anywhere."""
+    opts = coerce_options(row.get("options"))
+    if opts and len(opts) >= 2:
+        return opts, "list"
+    emb = embedded_options(row.get("question"))
+    if emb:
+        return emb, "question"
+    return None, None
+
+
+def lettered(opts):
+    """Render options one per line with a letter prefix; keep existing prefixes."""
+    if all(_OPT_LINE.match(str(o)) for o in opts):
+        return "\n".join(str(o).strip() for o in opts)
+    return "\n".join(f"{chr(65 + i)}. {str(o).strip()}" for i, o in enumerate(opts))
+
+
+def log(msg):
+    print(f"[D-blind] {msg}", file=sys.stderr, flush=True)
+
+
+class Retryable(Exception):
+    """429 / 5xx / network — worth backing off and retrying."""
+
+    def __init__(self, msg, wait=None):
+        super().__init__(msg)
+        self.wait = wait
+
+
+def fmt_opts(o):
+    if not o:
+        return ""
+    if isinstance(o, str):
+        return o
+    return "\n".join(str(x) for x in o)
+
+
+def _check_http(r):
+    if r.status_code == 429 or r.status_code >= 500:
+        wait = None
+        ra = r.headers.get("retry-after")
+        if ra:
+            try:
+                wait = min(120.0, float(ra))
+            except ValueError:
+                pass
+        raise Retryable(f"HTTP {r.status_code}: {r.text[:150]}", wait=wait)
+
+
+def _gemini_call(model, prompt, budget):
+    try:
+        r = requests.post(
+            f"https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent",
+            headers={"x-goog-api-key": os.environ["GEMINI_API_KEY"]},
+            json={"contents": [{"parts": [{"text": prompt}]}],
+                  "generationConfig": {"maxOutputTokens": budget}},
+            timeout=120)
+    except requests.RequestException as e:
+        raise Retryable(f"net: {type(e).__name__}")
+    _check_http(r)
+    d = r.json()
+    if "candidates" not in d:
+        raise RuntimeError(f"no candidates: {str(d.get('error', d))[:250]}")
+    c = d["candidates"][0]
+    parts = (c.get("content") or {}).get("parts") or []
+    # thinking models: parts may open with {"thought": true} segments — skip
+    # them and join the visible remainder.
+    text = "".join(p.get("text", "") for p in parts if not p.get("thought")).strip()
+    return text, c.get("finishReason", "")
+
+
+def ask_gemini(model, prompt):
+    text, fin = _gemini_call(model, prompt, 4096)
+    if not text and fin == "MAX_TOKENS":
+        # thinking ate the whole budget -> no visible parts; give it headroom
+        text, fin = _gemini_call(model, prompt, 8192)
+    if not text:
+        raise RuntimeError(f"empty answer (finishReason={fin})")
+    return text
+
+
+def _claude_call(model, prompt, max_tokens):
+    try:
+        r = requests.post(
+            "https://api.anthropic.com/v1/messages",
+            headers={"x-api-key": os.environ["ANTHROPIC_API_KEY"],
+                     "anthropic-version": "2023-06-01"},
+            json={"model": model, "max_tokens": max_tokens,
+                  "output_config": {"effort": "low"},
+                  "messages": [{"role": "user", "content": prompt}]},
+            timeout=180)
+    except requests.RequestException as e:
+        raise Retryable(f"net: {type(e).__name__}")
+    _check_http(r)
+    d = r.json()
+    if "content" not in d:
+        raise RuntimeError(str(d.get("error", d))[:250])
+    # content blocks: skip "thinking" blocks, take the text block
+    text = next((b.get("text", "") for b in d["content"]
+                 if b.get("type") == "text"), "").strip()
+    return text, d.get("stop_reason", "")
+
+
+def ask_claude(model, prompt):
+    text, stop = _claude_call(model, prompt, 1024)
+    if not text and stop == "max_tokens":
+        # thinking + answer exceeded the cap -> no text block; raise the cap
+        text, stop = _claude_call(model, prompt, 4096)
+    if not text:
+        raise RuntimeError(f"empty answer (stop_reason={stop})")
+    return text
+
+
+def make_prompt(row, options_only=False):
+    """Prompt for one item; None when --options-only and the item has no option list."""
+    if not options_only:
+        return PROMPT.format(q=row["question"], opts=fmt_opts(row.get("options")))
+    opts, _ = item_options(row)
+    if not opts:
+        return None
+    return PROMPT_OPTIONS_ONLY.format(opts=lettered(opts))
+
+
+def ask_with_retry(ask, model, row, bench, errlog, options_only=False):
+    """Returns pred text or None (after logging) — never raises."""
+    prompt = make_prompt(row, options_only)
+    if prompt is None:
+        return None
+    for attempt in range(MAX_ATTEMPTS):
+        try:
+            return ask(model, prompt)
+        except Retryable as e:
+            if attempt == MAX_ATTEMPTS - 1:
+                errlog(f"{bench}/{row['qid']}: gave up after {MAX_ATTEMPTS} tries: {e}")
+                return None
+            wait = e.wait if e.wait else min(60.0, 2.0 ** attempt + random.uniform(0, 2))
+            if attempt >= 1:
+                log(f"{bench}/{row['qid']}: retry {attempt + 1} in {wait:.0f}s ({str(e)[:80]})")
+            time.sleep(wait)
+        except Exception as e:
+            if attempt >= 1:  # parse/4xx: one flake allowance, then surface
+                errlog(f"{bench}/{row['qid']}: {type(e).__name__}: {str(e)[:200]}")
+                return None
+            time.sleep(2)
+    return None
+
+
+def run_bench(path, model, limit, options_only=False):
+    bench = os.path.basename(path)[:-6]
+    os.makedirs(OUT, exist_ok=True)
+    outp = os.path.join(OUT, f"{bench}__{model.replace('/', '_')}.jsonl")
+    done = set()
+    if os.path.exists(outp):
+        for l in open(outp):
+            try:
+                done.add(json.loads(l)["qid"])
+            except Exception:
+                pass
+    rows = [json.loads(l) for l in open(path) if l.strip()]
+    if limit:
+        rows = rows[:limit]
+    todo = [r for r in rows if r["qid"] not in done]
+    n_skip = 0
+    if options_only:  # items without any option list cannot be probed
+        n_skip = sum(1 for r in todo if item_options(r)[0] is None)
+        todo = [r for r in todo if item_options(r)[0] is not None]
+        if n_skip:
+            log(f"{bench}: {n_skip} item(s) without an option list skipped")
+    if not todo:
+        return bench, 0, 0, len(rows)
+    ask = ask_claude if "claude" in model else ask_gemini
+
+    n_logged = [0]
+
+    def errlog(msg):
+        n_logged[0] += 1
+        if n_logged[0] <= 8:
+            log(msg)
+        elif n_logged[0] == 9:
+            log(f"{bench}: more errors — suppressing further per-row logs")
+
+    n_new = n_err = 0
+    with open(outp, "a") as f:
+        for i, r in enumerate(todo):
+            pred = ask_with_retry(ask, model, r, bench, errlog, options_only)
+            if pred is None:
+                n_err += 1
+            else:
+                out = dict(qid=r["qid"], pred=pred[:300], answer=r.get("answer", ""))
+                if options_only:
+                    opts, src = item_options(r)
+                    out.update(opts_source=src, n_options=len(opts))
+                f.write(json.dumps(out, ensure_ascii=False) + "\n")
+                f.flush()
+                n_new += 1
+            if (i + 1) % 50 == 0:
+                log(f"{bench}: {i + 1}/{len(todo)} (ok={n_new} err={n_err})")
+    return bench, n_new, n_err, len(rows)
+
+
+def select_files(files, spec):
+    """--bench selector: "|"-separated names; exact sample basenames win, and only when
+    no token matches exactly does the historical substring rule apply."""
+    if not spec:
+        return files
+    toks = [t.strip() for t in spec.split("|") if t.strip()]
+    exact = [f for f in files if os.path.basename(f)[:-6] in toks]
+    return exact or [f for f in files if any(t in f for t in toks)]
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--model", required=True)
+    ap.add_argument("--bench", default=None)
+    ap.add_argument("--limit", type=int, default=None)
+    ap.add_argument("--workers", type=int, default=6)
+    ap.add_argument("--options-only", action="store_true",
+                    help="N0.2 option-level attacker: options list only, no question "
+                         "(-> <results>/options_only/)")
+    a = ap.parse_args()
+    global OUT
+    if a.options_only:
+        OUT = os.path.join(RESULTS, "options_only")
+    key = "ANTHROPIC_API_KEY" if "claude" in a.model else "GEMINI_API_KEY"
+    if not os.environ.get(key):
+        sys.exit(f"[D-blind] {key} not set")
+    files = select_files(sorted(glob.glob(f"{SAMPLES}/*.jsonl")), a.bench)
+    print(f"[D-blind] {len(files)} benchmarks, model={a.model}, "
+          f"mode={'options_only' if a.options_only else 'blind'}, out={OUT}", flush=True)
+    n_done = 0
+    with ThreadPoolExecutor(max_workers=a.workers) as ex:
+        futs = {ex.submit(run_bench, p, a.model, a.limit, a.options_only): p for p in files}
+        for fut in as_completed(futs):
+            try:
+                bench, n_new, n_err, n_all = fut.result()
+            except Exception as e:
+                log(f"{os.path.basename(futs[fut])}: bench-level failure "
+                    f"{type(e).__name__}: {str(e)[:200]}")
+                n_done += 1
+                continue
+            n_done += 1
+            print(f"[D-blind] [{n_done}/{len(files)}] {bench}: +{n_new} "
+                  f"err={n_err} (total {n_all})", flush=True)
+    print("[D-blind] all benchmarks finished", flush=True)
+
+
+if __name__ == "__main__":
+    main()