Upload score_chrono.py with huggingface_hub

score_chrono.py

@@ -0,0 +1,763 @@
+"""ChronoCalc released scorer. Recomputes every gold answer, then exact-matches.
+
+    python score_chrono.py --selftest
+    python score_chrono.py ROWS.jsonl GENS.jsonl [--report R.json] [--verdicts V.jsonl]
+    python score_chrono.py --recompute ROWS.jsonl        # gold integrity only, no model
+
+WHAT MAKES THIS DIFFERENT FROM A KEY FILE. It does not trust the stored answers. For
+every row it re-derives the gold answer from the scenario parameters in the row itself,
+and if a stored answer and its recomputation disagree the run ABORTS rather than
+scoring against either. A reviewer therefore does not have to take our labels on faith:
+running this script is running the label generator.
+
+DEPENDENCIES. Standard library plus `zoneinfo`, and two files that ship beside it:
+solver_a.py and fedcal.py, which are also stdlib only. Reporting helpers come from
+part2/scripts/common/scoring.py, shared with the other entries in this repo, also
+stdlib only. Supported Python: 3.11 to 3.13. There is no pip install, and in
+particular the `holidays` package is NOT used anywhere in this path; it appears only in
+crosscheck_fedcal.py, a build-time tool.
+
+TZDATA. Timezone answers depend on the IANA database, and IANA changes. Two guards,
+because a silently different tzdata would silently change gold answers:
+  1. Every F3 endpoint carries the UTC offset it was generated under. Before scoring,
+     the live zoneinfo is asked for the same offset, and a mismatch aborts the run
+     naming the endpoint. This is per-row and exact, not a sampled fingerprint.
+  2. `--pin-tzdata` forces zoneinfo to read the pip `tzdata` package instead of the
+     system database, for reproducing a number byte for byte on a different machine.
+     It is optional; the guard above is what makes the run trustworthy either way.
+
+=============================================================================
+THE SCORING RULES, PRE-DECLARED. No tolerance, no partial credit, no judgment.
+=============================================================================
+
+ANSWER FORMATS. Exactly one form per family, and nothing else is accepted:
+    date      <answer>YYYY-MM-DD</answer>      F1, F2, F4
+    duration  <answer>H:MM</answer>            F3
+    isoweek   <answer>YYYY-Www</answer>        F5
+
+H:MM semantics, pinned so there is nothing to argue about:
+    total hours, which MAY exceed 24              30:45 is valid
+    no days component                             "1 day 6:45" is not an answer
+    minutes always two digits                     9:0 is malformed
+    hours never zero-padded                       09:00 is malformed, 9:00 is right
+    zero hours are written as 0                   0:45
+Worked: 540 minutes is "9:00". 1845 minutes is "30:45". 45 minutes is "0:45".
+
+ISO week semantics: YYYY is the ISO week-numbering year, which is not always the
+calendar year of the date, and Www is zero-padded two digits, 01 to 53. 2022-01-01
+falls in ISO week 2021-W52.
+
+STRICT. The output must contain EXACTLY ONE <answer>...</answer> tag whose content
+matches the required format for that row. Zero tags scores 0. Two or more tags scores
+0, even when they agree, because "the model emitted one answer" is part of what is
+being measured. A well-formed single tag scores 1 only on an exact string match against
+the recomputed gold.
+
+LENIENT. Defined to favour the base model, so that no part of a reported lift rests on
+format compliance. Scan the whole output for literals shaped like the row's answer
+type, ignoring tags entirely, and compare the LAST one to the gold. The shapes:
+    date      a YYYY-MM-DD literal not adjacent to another digit
+    isoweek   a YYYY-Www literal
+    duration  an H:MM literal with an unpadded hour, not adjacent to another digit or
+              colon, not immediately preceded by "T" or by "YYYY-MM-DD "
+The two duration exclusions exist because prompts state instants as 2026-10-31T22:00,
+and a scan that treated a quoted input timestamp as an answer would score the model on
+its ability to copy the question.
+
+LENIENT_ANY. A second, strictly more generous diagnostic: does the gold literal appear
+ANYWHERE in the output as an answer-shaped literal. Published alongside, never gated
+on. Its purpose is to bound how much the LAST-literal rule could be under-crediting a
+model that computed correctly and then kept talking. If LENIENT and LENIENT_ANY are
+far apart, the extraction rule is doing more work than it should, and that is a fact
+about the harness that a reader is entitled to see rather than something to discover
+after the fact.
+
+CONFIDENT_WRONG. Among outputs with exactly one well-formed tag, the fraction whose
+answer is wrong. Rows without a well-formed single tag are excluded from the
+denominator, not counted as correct. Entirely mechanical: no hedge lexicon, no reading
+of tone.
+
+HAS_WORKING. Whether anything resembling a computation precedes the tag: at least two
+non-empty lines and at least twenty characters before the first tag. A release gate,
+not an accuracy metric. This project has twice shipped a tuned model that got terser
+than its base and lost on tasks it had not been trained on, so a collapse to
+bare answers has to be visible.
+
+F1 SUBPOPULATION SPLIT, first-class since the pre-registered adjudication of
+2026-07-28 (part2/docs/eval/gcp/chrono_gate_adjudication.md). Every F1 row is
+classified from its stored scenario parameters alone:
+
+    holiday-affected   recomputing the gold and recomputing the SAME walk with
+                       holidays ignored (weekends still skipped) give different
+                       dates, i.e. at least one observed federal holiday changes
+                       the answer
+    no-holiday         the two walks agree, so the row is plain day-walking
+
+Every metric above is then reported separately for each side, in the printed output
+and in the report JSON under "f1_split", alongside the blended F1 numbers, which
+continue to be published unchanged. The blend measures the pilot mix; the split
+measures the capability, and the adjudication reads
+f1_split -> holiday_affected -> <column> -> lenient_exact from the report file. The
+classification is recomputed by this scorer at scoring time, never read from a stored
+flag, for the same reason gold answers are recomputed: the released instrument, not a
+notebook, is what produces every adjudicated number.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from collections import Counter
+from datetime import date, datetime, timedelta
+from pathlib import Path
+from zoneinfo import ZoneInfo
+
+_HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(_HERE))
+sys.path.insert(0, str(_HERE.parent))
+
+import solver_a  # noqa: E402
+from common import scoring  # noqa: E402
+
+SUPPORTED_PYTHON = (3, 11), (3, 13)
+
+TAG_RE = re.compile(r"<answer>(.*?)</answer>", re.DOTALL | re.IGNORECASE)
+
+STRICT_FORMS = {
+    "date": re.compile(r"^\d{4}-\d{2}-\d{2}$"),
+    "duration": re.compile(r"^(?:0|[1-9]\d*):[0-5]\d$"),
+    "isoweek": re.compile(r"^\d{4}-W\d{2}$"),
+}
+
+LITERAL_FORMS = {
+    "date": re.compile(r"(?<!\d)\d{4}-\d{2}-\d{2}(?!\d)"),
+    "isoweek": re.compile(r"(?<![A-Za-z0-9])\d{4}-W\d{2}(?!\d)"),
+    "duration": re.compile(
+        r"(?<![\d:])(?<!T)(?<!\d{4}-\d{2}-\d{2} )(?:0|[1-9]\d{0,2}):[0-5]\d(?![\d:])"),
+}
+
+FAMILIES = ("F1", "F2", "F3", "F4", "F5")
+
+
+class ScoringError(SystemExit):
+    pass
+
+
+# ------------------------------------------------------------------ validation
+
+def well_formed(answer_type: str, text: str) -> bool:
+    """Does `text` satisfy the declared answer format, including semantic validity."""
+    form = STRICT_FORMS.get(answer_type)
+    if form is None or not form.match(text):
+        return False
+    if answer_type == "date":
+        try:
+            date.fromisoformat(text)
+        except ValueError:
+            return False
+    elif answer_type == "isoweek":
+        week = int(text[6:])
+        if not 1 <= week <= 53:
+            return False
+        # Week 53 exists only in long ISO years; reject 53 where it does not.
+        if week == 53:
+            year = int(text[:4])
+            try:
+                date.fromisocalendar(year, 53, 1)
+            except ValueError:
+                return False
+    return True
+
+
+def tags_in(output: str) -> list[str]:
+    return [m.group(1).strip() for m in TAG_RE.finditer(output or "")]
+
+
+def single_well_formed_tag(answer_type: str, output: str) -> str | None:
+    """The one tag, or None when there are zero, several, or a malformed one."""
+    found = tags_in(output)
+    if len(found) != 1:
+        return None
+    return found[0] if well_formed(answer_type, found[0]) else None
+
+
+def last_literal(answer_type: str, output: str) -> str | None:
+    hits = LITERAL_FORMS[answer_type].findall(output or "")
+    return hits[-1] if hits else None
+
+
+def literals(answer_type: str, output: str) -> list[str]:
+    return LITERAL_FORMS[answer_type].findall(output or "")
+
+
+def working_before_tag(output: str) -> bool:
+    m = TAG_RE.search(output or "")
+    head = (output or "")[: m.start()] if m else (output or "")
+    lines = [l for l in head.splitlines() if l.strip()]
+    return len(lines) >= 2 and len(head.strip()) >= 20
+
+
+# ------------------------------------------------------------------ F1 split
+
+def weekday_only_offset(anchor: date, n: int, forward: bool) -> date:
+    """The nth Mon-Fri day strictly after (or before) anchor, holidays IGNORED.
+
+    The counterfactual behind the F1 split. It deliberately lives here, in the
+    released scorer, rather than in the solvers: it computes a WRONG answer under the
+    task's rules (the answer a holiday-blind clerk would reach), and the solvers must
+    never contain a code path that produces wrong answers.
+    """
+    step = timedelta(days=1 if forward else -1)
+    cur, k = anchor, 0
+    while k < n:
+        cur += step
+        if cur.weekday() < 5:
+            k += 1
+    return cur
+
+
+def holiday_affected(params: dict, gold: str) -> bool:
+    """Does an observed federal holiday change this F1 row's answer?
+
+    True exactly when the holiday-blind walk lands somewhere other than the recomputed
+    gold. Pure function of the scenario parameters, so the subpopulation a row belongs
+    to is decided by the released instrument at scoring time, not by a stored label.
+    """
+    if params.get("family") != "F1":
+        raise ScoringError(f"holiday_affected is defined for F1 only, got "
+                           f"{params.get('family')!r}")
+    naive = weekday_only_offset(date.fromisoformat(params["anchor"]), params["n"],
+                                params["direction"] == "after")
+    return naive.isoformat() != gold
+
+
+def split_f1(gens: list[dict], by_id: dict[str, dict],
+             gold_by_id: dict[str, tuple[str, str]], metrics: dict) -> dict | None:
+    """Score the two F1 subpopulations separately. None when the file has no F1."""
+    hol: list[dict] = []
+    nohol: list[dict] = []
+    for g in gens:
+        params = (by_id[g["id"]].get("params") or {})
+        if params.get("family") != "F1":
+            continue
+        _, gold = gold_by_id[g["id"]]
+        (hol if holiday_affected(params, gold) else nohol).append(g)
+    if not hol and not nohol:
+        return None
+
+    out: dict = {
+        "definition": "holiday-affected means the recomputed gold differs from the "
+                      "same walk with holidays ignored (weekends still skipped)",
+        "n_holiday_affected": len(hol),
+        "n_no_holiday": len(nohol),
+    }
+    for name, sub in (("holiday_affected", hol), ("no_holiday", nohol)):
+        if sub:
+            res = scoring.score_file(sub, metrics)
+            scoring.report(res, f"F1 {name.replace('_', ' ')} subpopulation  "
+                                f"({len(sub)} rows)", headline="strict_exact")
+            out[name] = res
+        else:
+            out[name] = None
+            print(f"\nF1 {name.replace('_', ' ')} subpopulation: 0 rows in this file, "
+                  f"nothing to score on that side.")
+    return out
+
+
+# ------------------------------------------------------------------ gold
+
+def recompute(row: dict) -> tuple[str, str]:
+    """(answer_type, gold) recomputed from the row's scenario parameters."""
+    params = row.get("params")
+    if not isinstance(params, dict):
+        raise ScoringError(
+            f"row {row.get('id')!r} carries no `params` object, so its gold answer "
+            f"cannot be recomputed. This scorer refuses to grade against a stored key.")
+    out = solver_a.solve(params)
+    return out["answer_type"], out["answer"]
+
+
+def check_tz_drift(rows: list[dict]) -> list[str]:
+    """Every recorded F3 UTC offset must still be what the live tzdata says."""
+    problems: list[str] = []
+    for r in rows:
+        p = r.get("params") or {}
+        if p.get("family") != "F3":
+            continue
+        for side in ("start", "end"):
+            spec = p.get(side) or {}
+            want = spec.get("utc_offset_min")
+            if want is None:
+                problems.append(f"{r.get('id')}: F3 {side} has no recorded utc_offset_min")
+                continue
+            naive = datetime.fromisoformat(spec["dt"])
+            got = ZoneInfo(spec["zone"]).utcoffset(naive)
+            got = int(got.total_seconds()) // 60
+            if got != want:
+                problems.append(
+                    f"{r.get('id')}: {spec['zone']} {spec['dt']} was generated at "
+                    f"{want} minutes from UTC, this machine says {got}. The IANA "
+                    f"database has changed; re-run with --pin-tzdata or rebuild.")
+    return problems
+
+
+def verify_golds(rows: list[dict]) -> list[str]:
+    """Stored answers must equal their recomputation, and be well formed."""
+    problems: list[str] = []
+    for r in rows:
+        try:
+            atype, gold = recompute(r)
+        except (solver_a.SolverError, ValueError) as exc:
+            problems.append(f"{r.get('id')}: {exc}")
+            continue
+        if not well_formed(atype, gold):
+            problems.append(f"{r.get('id')}: recomputed gold {gold!r} is not a "
+                            f"well-formed {atype}")
+        stored = r.get("answer", r.get("reference"))
+        if stored is not None and str(stored).strip() != gold:
+            problems.append(f"{r.get('id')}: stored answer {stored!r} but recomputation "
+                            f"says {gold!r}")
+        declared = r.get("answer_type")
+        if declared is not None and declared != atype:
+            problems.append(f"{r.get('id')}: declared answer_type {declared!r}, "
+                            f"recomputation says {atype!r}")
+    return problems
+
+
+# ------------------------------------------------------------------ metrics
+
+def build_metrics(gold_by_id: dict[str, tuple[str, str]]):
+    def _g(row: dict) -> tuple[str, str]:
+        return gold_by_id[row["id"]]
+
+    def strict(pred: str, row: dict):
+        atype, gold = _g(row)
+        tag = single_well_formed_tag(atype, pred)
+        return tag == gold
+
+    def tag_compliance(pred: str, row: dict):
+        atype, _ = _g(row)
+        return single_well_formed_tag(atype, pred) is not None
+
+    def lenient(pred: str, row: dict):
+        atype, gold = _g(row)
+        return last_literal(atype, pred) == gold
+
+    def lenient_any(pred: str, row: dict):
+        atype, gold = _g(row)
+        return gold in literals(atype, pred)
+
+    def confident_wrong(pred: str, row: dict):
+        atype, gold = _g(row)
+        tag = single_well_formed_tag(atype, pred)
+        if tag is None:
+            return None                      # excluded from the denominator
+        return tag != gold
+
+    def has_working(pred: str, row: dict):
+        return working_before_tag(pred)
+
+    return {
+        "strict_exact": strict,
+        "lenient_exact": lenient,
+        "lenient_any": lenient_any,
+        "tag_compliance": tag_compliance,
+        "confident_wrong": confident_wrong,
+        "has_working": has_working,
+    }
+
+
+def verdict_rows(gens: list[dict], gold_by_id: dict[str, tuple[str, str]]) -> list[dict]:
+    out = []
+    for r in gens:
+        atype, gold = gold_by_id[r["id"]]
+        rec = {"id": r["id"], "family": r.get("family", r.get("category", "")),
+               "answer_type": atype, "gold": gold}
+        for col in scoring.columns(gens):
+            pred = r.get(col) or ""
+            tag = single_well_formed_tag(atype, pred)
+            rec[col] = {
+                "tag": tag,
+                "n_tags": len(tags_in(pred)),
+                "strict": tag == gold,
+                "lenient": last_literal(atype, pred) == gold,
+                "lenient_any": gold in literals(atype, pred),
+                "has_working": working_before_tag(pred),
+                "chars": len(pred),
+            }
+        out.append(rec)
+    return out
+
+
+# ------------------------------------------------------------------ driver
+
+def load_rows(path: str | Path) -> list[dict]:
+    rows = scoring.load(path)
+    seen: set[str] = set()
+    for r in rows:
+        rid = r.get("id")
+        if not rid:
+            raise ScoringError(f"{path}: a row has no id")
+        if rid in seen:
+            raise ScoringError(f"{path}: duplicate id {rid!r}")
+        seen.add(rid)
+    return rows
+
+
+def score(rows_path: str, gens_path: str, report_path: str = "",
+          verdicts_path: str = "") -> dict:
+    rows = load_rows(rows_path)
+    gens = scoring.load(gens_path)
+
+    by_id = {r["id"]: r for r in rows}
+    missing = [g.get("id") for g in gens if g.get("id") not in by_id]
+    if missing:
+        raise ScoringError(
+            f"{len(missing)} generation id(s) are absent from {rows_path}, first: "
+            f"{missing[:3]}. Scoring a generation file against the wrong slice is how "
+            f"a harness failure gets published as a model result.")
+
+    drift = check_tz_drift([by_id[g["id"]] for g in gens])
+    if drift:
+        raise ScoringError("timezone database drift:\n  " + "\n  ".join(drift[:10]))
+
+    problems = verify_golds([by_id[g["id"]] for g in gens])
+    if problems:
+        raise ScoringError(
+            f"{len(problems)} gold answer(s) failed recomputation; refusing to score.\n  "
+            + "\n  ".join(problems[:10]))
+
+    gold_by_id = {g["id"]: recompute(by_id[g["id"]]) for g in gens}
+    for g in gens:
+        g.setdefault("family", by_id[g["id"]].get("family", g.get("category", "")))
+
+    metrics = build_metrics(gold_by_id)
+    overall = scoring.score_file(gens, metrics)
+    scoring.report(overall, f"ChronoCalc: {Path(gens_path).name}  ({len(gens)} rows)",
+                   headline="strict_exact")
+
+    per_family: dict[str, dict] = {}
+    for fam in FAMILIES:
+        sub = [g for g in gens if g.get("family") == fam]
+        if not sub:
+            continue
+        per_family[fam] = scoring.score_file(sub, metrics)
+        scoring.report(per_family[fam], f"{fam}  ({len(sub)} rows)",
+                       headline="strict_exact")
+
+    f1_split = split_f1(gens, by_id, gold_by_id, metrics)
+
+    lengths = scoring.length_report(gens)
+    print("\nOutput length (characters):", json.dumps(lengths))
+    if lengths.get("terseness_flag"):
+        print("TERSENESS FLAG: the tuned median is under 0.6x the base median. This has "
+              "twice preceded a win-rate collapse in this project. Do not release on it.")
+
+    for col in scoring.columns(gens):
+        miss = sum(1 for g in gens if not working_before_tag(g.get(col) or ""))
+        pct = 100.0 * miss / len(gens)
+        note = "  RELEASE BLOCKER" if (col == "tuned" and pct > 1.0) else ""
+        print(f"working section missing on column {col!r}: {miss}/{len(gens)} "
+              f"= {pct:.1f}%{note}")
+
+    result = {
+        "rows_file": str(rows_path),
+        "generations_file": str(gens_path),
+        "n_rows": len(gens),
+        "python": f"{sys.version_info.major}.{sys.version_info.minor}",
+        "overall": overall,
+        "per_family": per_family,
+        "f1_split": f1_split,
+        "lengths": lengths,
+        "family_mix": dict(Counter(g.get("family", "") for g in gens)),
+    }
+    if report_path:
+        Path(report_path).write_text(json.dumps(result, indent=2) + "\n")
+        print(f"wrote {report_path}")
+    if verdicts_path:
+        with Path(verdicts_path).open("w") as fh:
+            for v in verdict_rows(gens, gold_by_id):
+                fh.write(json.dumps(v, ensure_ascii=False) + "\n")
+        print(f"wrote {verdicts_path}")
+    return result
+
+
+# ------------------------------------------------------------------ selftest
+
+def _selftest() -> None:
+    """Every gate is fed something that must make it fail. See HANDOFF 5.13."""
+    ok = 0
+    lo, hi = SUPPORTED_PYTHON
+    assert lo <= sys.version_info[:2] <= hi, (
+        f"Python {sys.version_info[:2]} is outside the declared support range "
+        f"{lo} to {hi}")
+    ok += 1
+
+    # --- answer format validation, both directions -------------------------
+    good = {"date": ["2026-12-07", "2020-02-29"],
+            "duration": ["0:00", "0:45", "9:00", "30:45", "100:05"],
+            "isoweek": ["2026-W47", "2020-W53", "2021-W01"]}
+    bad = {"date": ["2026-12-7", "12/07/2026", "2026-13-01", "2026-02-30",
+                    "December 7, 2026", "2026-12-07.", ""],
+           "duration": ["09:00", "9:0", "9:60", "1 day 6:45", "9h00", "9:00 hours",
+                        "-1:00", ""],
+           "isoweek": ["2026-W5", "2026W47", "2026-w47", "2026-W54", "2025-W53", ""]}
+    for atype, xs in good.items():
+        for x in xs:
+            assert well_formed(atype, x), f"{atype} {x!r} should be well formed"
+    for atype, xs in bad.items():
+        for x in xs:
+            assert not well_formed(atype, x), f"{atype} {x!r} should be rejected"
+    # 2025 is a 52-week ISO year, so W53 must be rejected there. 2020 and 2026 are
+    # 53-week years (January 1 lands on a Thursday, or on a Wednesday in a leap year),
+    # so W53 is legitimate for those and must be accepted.
+    assert not well_formed("isoweek", "2025-W53")
+    assert well_formed("isoweek", "2020-W53") and well_formed("isoweek", "2026-W53")
+    ok += 1
+
+    # --- tag extraction -----------------------------------------------------
+    assert single_well_formed_tag("date", "x <answer>2026-12-07</answer>") == "2026-12-07"
+    assert single_well_formed_tag("date", "no tag here") is None
+    assert single_well_formed_tag(
+        "date", "<answer>2026-12-07</answer> and <answer>2026-12-07</answer>") is None, \
+        "two tags must score zero even when they agree"
+    assert single_well_formed_tag("date", "<answer>Dec 7 2026</answer>") is None
+    assert single_well_formed_tag("duration", "<answer>09:00</answer>") is None
+    assert single_well_formed_tag("duration", "<answer> 9:00 </answer>") == "9:00"
+    ok += 1
+
+    # --- lenient literal extraction ----------------------------------------
+    assert last_literal("date", "walk 2026-12-04 then 2026-12-07 done") == "2026-12-07"
+    assert last_literal("date", "nothing") is None
+    assert last_literal("isoweek", "week 2026-W47 it is") == "2026-W47"
+    # A quoted input timestamp must NOT be read as a duration answer.
+    txt = ("Start 2026-10-31T22:00 America/New_York, end 2026-11-01T06:00. "
+           "Elapsed is 9:00.")
+    assert last_literal("duration", txt) == "9:00", last_literal("duration", txt)
+    assert literals("duration", "at 2026-10-31 22:00 the clock") == [], \
+        "a date-space-time literal is not an answer shape"
+    assert literals("duration", "T06:00 alone") == []
+    assert last_literal("duration", "8:00 then 9:00") == "9:00"
+    assert last_literal("duration", "06:00 padded is ignored") is None
+    ok += 1
+
+    # --- working-section detection -----------------------------------------
+    assert working_before_tag("line one here\nline two here\n<answer>x</answer>")
+    assert not working_before_tag("<answer>2026-12-07</answer>")
+    assert not working_before_tag("short\n<answer>x</answer>")
+    ok += 1
+
+    # --- end to end, with a deliberately wrong row of every kind -----------
+    import tempfile
+
+    p_f1 = {"family": "F1", "anchor": "2026-11-20", "n": 10, "direction": "after"}
+    p_f3 = {"family": "F3",
+            "start": {"dt": "2026-10-31T22:00", "zone": "America/New_York",
+                      "utc_offset_min": -240},
+            "end": {"dt": "2026-11-01T06:00", "zone": "America/New_York",
+                    "utc_offset_min": -300}}
+    p_f5 = {"family": "F5", "kind": "of_date", "date": "2026-11-20"}
+    rows = [
+        {"id": "t-correct", "family": "F1", "params": p_f1, "answer": "2026-12-07"},
+        {"id": "t-wrong", "family": "F1", "params": p_f1, "answer": "2026-12-07"},
+        {"id": "t-notag", "family": "F1", "params": p_f1, "answer": "2026-12-07"},
+        {"id": "t-twotags", "family": "F1", "params": p_f1, "answer": "2026-12-07"},
+        {"id": "t-malformed", "family": "F1", "params": p_f1, "answer": "2026-12-07"},
+        {"id": "t-prose", "family": "F1", "params": p_f1, "answer": "2026-12-07"},
+        {"id": "t-terse", "family": "F1", "params": p_f1, "answer": "2026-12-07"},
+        {"id": "t-dst", "family": "F3", "params": p_f3, "answer": "9:00"},
+        {"id": "t-week", "family": "F5", "params": p_f5, "answer": "2026-W47"},
+    ]
+    body = "computing the walk\nskipping Thanksgiving 2026-11-26\n"
+    gens = [
+        {"id": "t-correct", "output": body + "<answer>2026-12-07</answer>"},
+        {"id": "t-wrong", "output": body + "<answer>2026-12-04</answer>"},
+        {"id": "t-notag", "output": body + "the answer is probably early December"},
+        {"id": "t-twotags",
+         "output": body + "<answer>2026-12-07</answer> or <answer>2026-12-07</answer>"},
+        {"id": "t-malformed", "output": body + "<answer>December 7 2026</answer>"},
+        {"id": "t-prose", "output": body + "so the due date is 2026-12-07 in the end"},
+        {"id": "t-terse", "output": "<answer>2026-12-07</answer>"},
+        {"id": "t-dst",
+         "output": "Start 2026-10-31T22:00, end 2026-11-01T06:00, so 8:00 elapsed.\n"
+                   "Second thought, via UTC it is 9:00.\n<answer>9:00</answer>"},
+        {"id": "t-week", "output": body + "<answer>2026-W47</answer>"},
+    ]
+    with tempfile.TemporaryDirectory() as td:
+        rp, gp = Path(td) / "rows.jsonl", Path(td) / "gens.jsonl"
+        rp.write_text("".join(json.dumps(r) + "\n" for r in rows))
+        gp.write_text("".join(json.dumps(g) + "\n" for g in gens))
+        res = score(str(rp), str(gp))
+
+        m = res["overall"]["output"]
+        # All 7 F1 rows here share the Thanksgiving scenario, so the split must put
+        # 7 on the holiday-affected side, 0 on the other, and survive the empty side.
+        assert res["f1_split"]["n_holiday_affected"] == 7, res["f1_split"]
+        assert res["f1_split"]["n_no_holiday"] == 0
+        assert res["f1_split"]["no_holiday"] is None
+        assert res["f1_split"]["holiday_affected"]["output"]["strict_exact"]["n_scored"] == 7
+        # 4 of 9 strictly correct: correct, terse, dst, week.
+        assert m["strict_exact"]["n_true"] == 4, m["strict_exact"]
+        # tag compliance excludes notag, prose, twotags and malformed: 5 of 9.
+        assert m["tag_compliance"]["n_true"] == 5, m["tag_compliance"]
+        # lenient credits the prose row and the two-tag row on top of the 4 strict
+        # passes, which is exactly the point of it. It does NOT credit the malformed
+        # row, whose last date literal is the intermediate 2026-11-26.
+        assert m["lenient_exact"]["n_true"] == 6, m["lenient_exact"]
+        assert m["lenient_exact"]["n_true"] > m["strict_exact"]["n_true"], \
+            "lenient must be more generous than strict, or it is not doing its job"
+        # confident_wrong: 5 well-formed tags, 1 of them wrong.
+        assert m["confident_wrong"]["n_scored"] == 5, m["confident_wrong"]
+        assert m["confident_wrong"]["n_true"] == 1, m["confident_wrong"]
+        # the terse row is the only one with no working section.
+        assert m["has_working"]["n_true"] == 8, m["has_working"]
+        # F3's distractor: the last duration literal is the corrected 9:00.
+        assert res["per_family"]["F3"]["output"]["lenient_exact"]["n_true"] == 1
+        ok += 1
+
+        # --- the gold-integrity gate must fire ---------------------------
+        broken = [dict(r) for r in rows]
+        broken[0]["answer"] = "2026-12-04"
+        rp2 = Path(td) / "broken.jsonl"
+        rp2.write_text("".join(json.dumps(r) + "\n" for r in broken))
+        try:
+            score(str(rp2), str(gp))
+            raise AssertionError("a wrong stored answer was accepted")
+        except ScoringError as exc:
+            assert "recomputation" in str(exc)
+        ok += 1
+
+        # --- a row with no params must be refused, not guessed ------------
+        noparams = [dict(r) for r in rows]
+        noparams[0].pop("params")
+        rp3 = Path(td) / "noparams.jsonl"
+        rp3.write_text("".join(json.dumps(r) + "\n" for r in noparams))
+        try:
+            score(str(rp3), str(gp))
+            raise AssertionError("a row without params was scored")
+        except ScoringError as exc:
+            assert "params" in str(exc)
+        ok += 1
+
+        # --- tz drift gate ------------------------------------------------
+        drifted = [dict(r) for r in rows]
+        bad_p = json.loads(json.dumps(p_f3))
+        bad_p["start"]["utc_offset_min"] = -239
+        drifted[7] = dict(drifted[7], params=bad_p)
+        rp4 = Path(td) / "drift.jsonl"
+        rp4.write_text("".join(json.dumps(r) + "\n" for r in drifted))
+        try:
+            score(str(rp4), str(gp))
+            raise AssertionError("timezone drift was not detected")
+        except ScoringError as exc:
+            assert "IANA" in str(exc)
+        ok += 1
+
+        # --- a generation file from the wrong slice must be refused -------
+        gp2 = Path(td) / "wrong.jsonl"
+        gp2.write_text(json.dumps({"id": "not-a-chrono-id", "output": "x"}) + "\n")
+        try:
+            score(str(rp), str(gp2))
+            raise AssertionError("a mismatched generation file was scored")
+        except ScoringError as exc:
+            assert "absent" in str(exc)
+        ok += 1
+
+        # --- the F1 split: one synthetic case per side, and the sides move
+        #     INDEPENDENTLY. The adjudication of 2026-07-28 reads the
+        #     holiday-affected lenient number, so this proves that number can fail
+        #     while the other side passes, and the reverse. All four answers below
+        #     were verified against the solvers before being hardcoded.
+        p_hol = {"family": "F1", "anchor": "2026-11-20", "n": 10,
+                 "direction": "after"}                       # gold 2026-12-07,
+        #                                weekend-only walk 2026-12-04 -> affected
+        p_clean = {"family": "F1", "anchor": "2026-08-03", "n": 4,
+                   "direction": "after"}                     # gold 2026-08-07,
+        #                                weekend-only walk identical -> not affected
+        assert holiday_affected(p_hol, "2026-12-07") is True
+        assert holiday_affected(p_clean, "2026-08-07") is False
+        try:
+            holiday_affected({"family": "F3"}, "9:00")
+            raise AssertionError("non-F1 must be refused, not classified")
+        except ScoringError:
+            pass
+
+        split_rows = [
+            {"id": "s-hol", "family": "F1", "params": p_hol, "answer": "2026-12-07"},
+            {"id": "s-clean", "family": "F1", "params": p_clean,
+             "answer": "2026-08-07"},
+        ]
+        rp5 = Path(td) / "split_rows.jsonl"
+        rp5.write_text("".join(json.dumps(r) + "\n" for r in split_rows))
+
+        def split_of(hol_out: str, clean_out: str) -> dict:
+            gp5 = Path(td) / "split_gens.jsonl"
+            gp5.write_text(json.dumps({"id": "s-hol", "output": body + hol_out}) + "\n"
+                           + json.dumps({"id": "s-clean",
+                                         "output": body + clean_out}) + "\n")
+            return score(str(rp5), str(gp5))["f1_split"]
+
+        # Holiday side passes while the no-holiday side fails...
+        s = split_of("<answer>2026-12-07</answer>", "<answer>2026-08-06</answer>")
+        assert s["n_holiday_affected"] == 1 and s["n_no_holiday"] == 1
+        assert s["holiday_affected"]["output"]["lenient_exact"]["pct"] == 100.0, s
+        assert s["no_holiday"]["output"]["lenient_exact"]["pct"] == 0.0, s
+        # ...and the reverse: the holiday side fails on the exact wrong answer the
+        # subpopulation exists to catch (the holiday-blind 2026-12-04) while the
+        # no-holiday side passes. The two sides are independent, so neither can mask
+        # the other in the adjudication.
+        s = split_of("<answer>2026-12-04</answer>", "<answer>2026-08-07</answer>")
+        assert s["holiday_affected"]["output"]["lenient_exact"]["pct"] == 0.0, s
+        assert s["holiday_affected"]["output"]["strict_exact"]["pct"] == 0.0, s
+        assert s["no_holiday"]["output"]["lenient_exact"]["pct"] == 100.0, s
+        ok += 1
+
+    print(f"\nscore_chrono selftest: {ok}/11 OK  "
+          f"(every gate above was shown failing on purpose-built bad input, and the "
+          f"F1 split's two sides were shown moving independently)")
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
+    ap.add_argument("rows", nargs="?", help="row file carrying `params` per row")
+    ap.add_argument("gens", nargs="?", help="generation file from gcp_eval.py")
+    ap.add_argument("--report", default="")
+    ap.add_argument("--verdicts", default="")
+    ap.add_argument("--recompute", default="", help="verify a row file's golds and exit")
+    ap.add_argument("--selftest", action="store_true")
+    ap.add_argument("--pin-tzdata", action="store_true",
+                    help="read timezone rules from the pip `tzdata` package only")
+    args = ap.parse_args()
+
+    if args.pin_tzdata:
+        import zoneinfo
+        zoneinfo.reset_tzpath([])
+        try:
+            import tzdata
+            print(f"tzdata pinned to the pip package, IANA {tzdata.IANA_VERSION}")
+        except ImportError:
+            raise SystemExit("--pin-tzdata needs `pip install tzdata`")
+
+    if args.selftest:
+        _selftest()
+        return
+    if args.recompute:
+        rows = load_rows(args.recompute)
+        drift = check_tz_drift(rows)
+        problems = verify_golds(rows) + drift
+        if problems:
+            print(f"FAIL: {len(problems)} problem(s)")
+            for p in problems[:40]:
+                print(f"  {p}")
+            raise SystemExit(1)
+        mix = Counter(r.get("family", "") for r in rows)
+        print(f"recomputed {len(rows)} gold answers, all agree. mix={dict(mix)}")
+        return
+    if not (args.rows and args.gens):
+        ap.error("give ROWS.jsonl and GENS.jsonl, or --selftest, or --recompute FILE")
+    score(args.rows, args.gens, args.report, args.verdicts)
+
+
+if __name__ == "__main__":
+    main()