Fix evaluation harness and normalize rubrics

Normalize rubric encodings for wildtrace-0195, wildtrace-0371, and wildtrace-0419; support HF JSONL ground-truth fields; create output directories; enforce complete judge panels; report Scored and All481 aggregation; refresh documentation and checksums.

CHECKSUMS.sha256

@@ -1,5 +1,5 @@
 0bd74a4ae3fd93117c71de4eff9514e14c8d9c7c936f17ed62298b8a2bff4c3c  LICENSE
-caa35af7fe9087012bb7e9548cf51ff2434168a982456ac725957d381c8fa1bc  README.md
+187e3481d181a7eb8ecbed5b90408022a3e627ab212c0ad1b9632113a006fb60  README.md
 69077a8632a9b760d542f51fd979ac8f48c7f4785a8da28028b554eee78c26fa  corpus/source-0001.txt
 89053a97930794a97cf842bc72042475d20c776dae82d734ffe97cb5e11ef967  corpus/source-0002.txt
 1ca60b578d990db5324489e767603f5d71021480c24cb91750125f2ea6a2a49c  corpus/source-0003.txt
@@ -217,16 +217,16 @@ d6acba7c1463a690bd850eeeb04359469d29e7e965f2a9f2f7b918ff9d11f4fe  corpus/source-
 5cd62c628bbaae5365a28c584d1fc0626c8288e6d7b3fc02e0e724106ee57f89  croissant.json
 89f19eabc8dd8e84f87454974d953b6f0e45fe16b4d89b52f7901994a28a8a2a  data/wildtrace_strict481.questions_only.json
 2218cff5b98c62bf97c9d6facc16a0d715c6c9d231095b3da69d1bfbe63ee9f3  data/wildtrace_strict481.questions_only.jsonl
-d9794618dd1762b37d6873a28bfe45ba230d8c3749141c6e086c3bfe515a222f  data/wildtrace_strict481.with_answers.json
-bb84003a2e0144f6f2e9d29533f2370347a698cc9c7877dcc46e4a3e57ab5f24  data/wildtrace_strict481.with_answers.jsonl
-0f37435e7724723cfa15e8735ffc1ea9dddedbf30d3ab3034c043cfaf09fa9bf  eval/config.json
-fb0b7ba21a0990f1f4c23e2cc7fa09d89e6dc3f52b0be9a166ccdbabe6e30ba1  eval/run_eval.py
-ac138baa999b926d632a9d05b53770b3c0fb6faad232e774a9a30ff24f770a9d  eval/run_judge.py
+e50e58e89ec79c88e7dde387a633b78a6dff6a6abfef0c5f94110eec939c527d  data/wildtrace_strict481.with_answers.json
+42feb334cd9b463e1bdf8e7d39c79aa40e13ae73797b580d6e6156aa09fb985b  data/wildtrace_strict481.with_answers.jsonl
+7f87bca51db65b08e5f45441977ef721dae68017ee44f543477cf8d4299abf7b  eval/config.json
+614f15526babfb8fbf027ad805b763a87101fea310627c093bb1afbffd12a810  eval/run_eval.py
+83b08805933a66d9a7ea1927eaddeb813cff6beedc957806811eabbe10cac0cd  eval/run_judge.py
 2a4dbda88b6436e80c2e324196edb4e662306ad2898ea42deb90f1673422bb85  metadata/corpora_manifest.csv
 0c1c65118131cc01a7c41c300e8792293074f8b914a8e23a4cec2bd0d00756e4  metadata/corpora_manifest.json
 3a5df0f909776ea657bc9bd9951d633fde8a37ee8ee33bb38a7d14af40240909  metadata/dataset_stats.json
 426dd91bf6e37246af75b071b3ae0b498e81632c1edb62a831ff322889484c0e  metadata/release_manifest.json
 b1f38eb3ffbfa4d37d921f1a2f65ac26dd4dad6b81a14c0b7d19bf9a4a3fde03  metadata/schema.json
-c942d195d66190a88da6ccefdd4aa355dca230de3c84b06c9d98d182edd34b65  methodology/EVAL_PROTOCOL.md
+711b8d03de08a763159686ad4da9e393f92d4e87f6dd4f7f2fb87a282bcf387e  methodology/EVAL_PROTOCOL.md
 9216f159b8475a29f5ef7f797e97c511cc6185ee80985ad863df42e1cb80c214  upload_to_hf.py
 bbc809f06ee9dab93d9b98e83919a3456b7e3619a991ae75e4f5fefddeabbc6d  upload_to_hf.sh

README.md

@@ -119,7 +119,7 @@ from datasets import load_dataset
 
 ds = load_dataset(
     "json",
-    data_files="hf_release_wildtrace_strict481_20260621/data/wildtrace_strict481.with_answers.jsonl",
+    data_files="data/wildtrace_strict481.with_answers.jsonl",
     split="train",
 )
 print(ds[0]["question_id"])
@@ -134,16 +134,37 @@ from datasets import load_dataset
 ds = load_dataset("CinderD/wildtrace", "with_answers", split="test")
 ```
 
-To evaluate a model, use `eval/run_eval.py` with `--corpus ../corpus`; the
-script constructs the evidence-withheld prompt from `question_text` and the full
-source document. Use `eval/run_judge.py` to score answers against the hidden
-rubric. See `methodology/EVAL_PROTOCOL.md` before reporting new results.
+To evaluate a model, clone the complete dataset repository, configure the model
+and judge endpoints in `eval/config.json`, and run:
+
+```bash
+cd eval
+python run_eval.py --config config.json \
+  --data ../data/wildtrace_strict481.with_answers.json \
+  --corpus ../corpus --out ../results/mymodel.responses.json
+python run_judge.py --config config.json \
+  --data ../data/wildtrace_strict481.with_answers.json \
+  --responses ../results/mymodel.responses.json \
+  --out ../results/mymodel.scores.json
+```
+
+The scripts create the output directory automatically. Both the nested `.json`
+and Hugging Face `.jsonl` representations are accepted. See
+`methodology/EVAL_PROTOCOL.md` before reporting new results.
 
 ## Scoring Denominators
 
-When reporting model results, distinguish valid-response quality from
-coverage-sensitive all-task quality. The protocol document defines both views
-and the treatment of out-of-context or failed rows.
+The score file reports both `scored_overall` (valid-response quality) and
+`all_tasks_overall`/`overall` (coverage-sensitive All481 quality). Missing,
+failed, and out-of-context model responses receive zero in All481. A judge API
+or parse failure leaves `overall` null and exits nonzero instead of silently
+averaging a partial judge panel; rerun the same command to resume.
+
+## Maintenance Notes
+
+- 2026-08-13: normalized three legacy rubric encodings, added HF JSONL support,
+  automatic output-directory creation, complete-panel judging, and explicit
+  Scored/All481 aggregation. Refreshed release checksums.
 
 ## Quality Assurance
 
@@ -179,12 +200,11 @@ terms before redistributing or adapting source texts.
 ## Citation
 
 ```bibtex
-@misc{wildtrace2026,
-  title={WILDTRACE: Benchmarking Multi-Hop Reasoning over Natural Evidence Trails in Long Contexts},
-  author={WildTrace authors},
+@article{chen2026wildtrace,
+  title={WildTrace: Benchmarking Natural Evidence Trails in Long-Context Reasoning},
+  author={Chen, Zixin and Liu, Peng and Li, Haobo and Sheng, Rui and Tu, Jianhong and Deng, Xiaodong and Huang, Fei and Shum, Kashun and Liu, Dayiheng and Qu, Huamin},
   year={2026},
-  howpublished={Hugging Face dataset},
-  url={https://huggingface.co/datasets/CinderD/wildtrace},
-  note={strict481 public release, freeze wildtrace_strict481_public_20260710}
+  journal={arXiv preprint arXiv:2607.09328},
+  url={https://arxiv.org/abs/2607.09328}
 }
 ```

data/wildtrace_strict481.with_answers.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d9794618dd1762b37d6873a28bfe45ba230d8c3749141c6e086c3bfe515a222f
-size 6420902
+oid sha256:e50e58e89ec79c88e7dde387a633b78a6dff6a6abfef0c5f94110eec939c527d
+size 6421202

data/wildtrace_strict481.with_answers.jsonl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:bb84003a2e0144f6f2e9d29533f2370347a698cc9c7877dcc46e4a3e57ab5f24
-size 6254460
+oid sha256:42feb334cd9b463e1bdf8e7d39c79aa40e13ae73797b580d6e6156aa09fb985b
+size 6254535

eval/run_eval.py

@@ -52,6 +52,27 @@ def is_cjk(text):
     return sum(1 for ch in text[:4000] if "一" <= ch <= "鿿") > 20
 
 
+def parse_ground_truth(value):
+    """Accept both nested JSON objects and HF JSONL's serialized JSON field."""
+    if isinstance(value, dict):
+        return value
+    if isinstance(value, str):
+        try:
+            parsed = json.loads(value)
+            return parsed if isinstance(parsed, dict) else {}
+        except json.JSONDecodeError:
+            return {}
+    return {}
+
+
+def write_json(path, value):
+    """Write resumable manifests atomically so interruptions do not corrupt them."""
+    tmp = f"{path}.tmp"
+    with open(tmp, "w", encoding="utf-8") as f:
+        json.dump(value, f, ensure_ascii=False, indent=2)
+    os.replace(tmp, path)
+
+
 def post(url, key, payload, timeout):
     last = None
     for attempt in range(5):
@@ -104,19 +125,25 @@ def main():
     ap.add_argument("--out", required=True, help="output responses json")
     ap.add_argument("--workers", type=int, default=4)
     args = ap.parse_args()
-    cfg = json.load(open(args.config))
+    os.makedirs(os.path.dirname(os.path.abspath(args.out)), exist_ok=True)
+    with open(args.config, encoding="utf-8") as f:
+        cfg = json.load(f)
     caps = load_caps(cfg)
     cap_key = cfg["model"] if cfg["model"] in caps else cfg.get("cap_key", "default")
 
-    rows = ([json.loads(l) for l in open(args.data) if l.strip()]
-            if args.data.endswith(".jsonl") else json.load(open(args.data)))
+    with open(args.data, encoding="utf-8") as f:
+        rows = ([json.loads(l) for l in f if l.strip()]
+                if args.data.endswith(".jsonl") else json.load(f))
     rows = {r["question_id"]: r for r in rows}
 
     done = {}
     if os.path.exists(args.out):
-        for r in json.load(open(args.out)):
+        with open(args.out, encoding="utf-8") as f:
+            previous = json.load(f)
+        for r in previous:
             resp = r["model_response"]
-            if resp and (not resp.startswith("[ERROR") or resp.startswith("[ERROR out_of_context_scope")):
+            if (r.get("question_id") in rows and resp and
+                    (not resp.startswith("[ERROR") or resp.startswith("[ERROR out_of_context_scope"))):
                 done[r["question_id"]] = r  # terminal: keep; transient errors retry
     work = [qid for qid in rows if qid not in done]
     _docs, lock = {}, Lock()
@@ -130,7 +157,7 @@ def main():
     print(f"model={cfg['model']} cap_key={cap_key} | to do={len(work)} (done={len(done)})", flush=True)
 
     def run(qid):
-        r = rows[qid]; gt = r.get("ground_truth", {})
+        r = rows[qid]; gt = parse_ground_truth(r.get("ground_truth", {}))
         q = r.get("question_text") or gt.get("question_text")
         text = doc(r["corpus_file"])
         cap = caps[cap_key]["cjk" if is_cjk(text) else "en"]
@@ -140,7 +167,9 @@ def main():
                          "doc_chars": len(text), "cap_chars": cap}, "oos"
         resp, err = call_model(EVAL_PROMPT.format(q=q, ctx=text[:cap]), cfg)
         if resp is None:
-            return qid, None, f"FAIL {str(err)[:60]}"  # transient -> not persisted, retries on resume
+            return qid, {"question_id": qid, "paradigm": r.get("paradigm"),
+                         "model_response": f"[ERROR inference_failed: {str(err)[:240]}]",
+                         "doc_chars": len(text), "cap_chars": cap}, f"FAIL {str(err)[:60]}"
         return qid, {"question_id": qid, "paradigm": r.get("paradigm"),
                      "model_response": resp, "doc_chars": len(text), "cap_chars": cap}, "ok"
 
@@ -151,7 +180,7 @@ def main():
             if row:
                 with lock:
                     done[qid] = row
-                    json.dump(list(done.values()), open(args.out, "w"), ensure_ascii=False, indent=2)
+                    write_json(args.out, list(done.values()))
             if n % 20 == 0 or tag.startswith("FAIL"):
                 print(f"[{n}/{len(work)}] {qid[:40]} -> {tag}", flush=True)
     print(f"DONE: {len(done)}/{len(rows)} -> {args.out}", flush=True)

eval/run_judge.py

@@ -1,39 +1,100 @@
 #!/usr/bin/env python3
-"""WildTrace — rubric judge harness (3-judge non-contestant panel, averaged).
+"""WildTrace rubric-judge harness.
 
-Scores a model's answers (from run_eval.py) against each task's rubric. Each answer is graded
-by THREE non-contestant judges and the three scores are AVERAGED (simple mean, no same-family
-exclusion). out_of_context_scope answers stay 0 (the model could not ingest the evidence).
-
-Panel used in the paper (deliberately models NOT on the leaderboard):
-  Claude-Sonnet-4.6 · Qwen3.5 · Gemini-2.5-Flash
-Supply your own judge endpoints in config.json -> "judges". OpenAI-compatible chat endpoints are
-the default; gateways that expose Gemini through native `contents`/`candidates` payloads can set
-`"api_type": "gemini_native"` on that judge. Using a single judge is supported (list one) but the
-paper headline is the 3-judge average.
-
-Output: results/<model>.scores.json
-  { "per_judge": {judge: {qid: score_0_1}}, "average": {qid: mean_score}, "overall": pct }
+Score answers produced by run_eval.py with one or more non-contestant judges.
+The paper protocol uses three judges and averages their normalized rubric scores.
+Out-of-context, failed, and missing model responses receive zero in the AllN view.
+Judge API/parse failures never get silently averaged away: rerun the command to
+resume them before an AllN score is emitted.
 
 Usage:
   export API_KEY=sk-...
-  python run_judge.py --config config.json --data ../data/wildtrace_strict481.with_answers.json \
-                      --responses ../results/mymodel.responses.json --out ../results/mymodel.scores.json
+  python run_judge.py --config config.json \
+      --data ../data/wildtrace_strict481.with_answers.json \
+      --responses ../results/mymodel.responses.json \
+      --out ../results/mymodel.scores.json
 """
-import argparse, ast, json, os, re, time, urllib.request, urllib.error
+
+import argparse
+import ast
+import json
+import os
+import re
+import time
+import urllib.request
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from threading import Lock
 
 
+def parse_jsonish(value):
+    """Decode fields serialized by the Hugging Face JSONL representation."""
+    if not isinstance(value, str):
+        return value
+    try:
+        return json.loads(value)
+    except json.JSONDecodeError:
+        try:
+            return ast.literal_eval(value)
+        except (SyntaxError, ValueError):
+            return None
+
+
+def parse_ground_truth(value):
+    value = parse_jsonish(value)
+    return value if isinstance(value, dict) else {}
+
+
+def normalize_rubric(value):
+    """Return (points, criterion) pairs for canonical and legacy schemas."""
+    value = parse_jsonish(value)
+    if not isinstance(value, list) or not value:
+        raise ValueError("rubric must be a non-empty list")
+
+    normalized = []
+    for item in value:
+        if not isinstance(item, dict):
+            raise ValueError("every rubric criterion must be an object")
+        try:
+            points = float(item.get("points", 0))
+        except (TypeError, ValueError) as exc:
+            raise ValueError("rubric points must be numeric") from exc
+        if points <= 0:
+            raise ValueError("rubric points must be positive")
+
+        criterion = item.get("correct_criterion")
+        if not criterion:
+            label = str(item.get("criterion") or "").strip()
+            evidence = str(item.get("evidence") or "").strip()
+            criterion = ": ".join(part for part in (label, evidence) if part)
+        if not str(criterion).strip():
+            raise ValueError("rubric criterion text is empty")
+        normalized.append((points, str(criterion).strip()))
+    return normalized
+
+
+def write_json(path, value):
+    """Atomically save resumable score state."""
+    tmp = f"{path}.tmp"
+    with open(tmp, "w", encoding="utf-8") as f:
+        json.dump(value, f, ensure_ascii=False, indent=2)
+    os.replace(tmp, path)
+
+
 def post(url, key, payload, timeout=180):
     for attempt in range(4):
         if attempt:
             time.sleep(3 * attempt)
         try:
-            req = urllib.request.Request(url, data=json.dumps(payload).encode(),
-                                         headers={"Authorization": f"Bearer {key}", "Content-Type": "application/json"})
-            with urllib.request.urlopen(req, timeout=timeout) as r:
-                return json.loads(r.read())
+            request = urllib.request.Request(
+                url,
+                data=json.dumps(payload).encode(),
+                headers={
+                    "Authorization": f"Bearer {key}",
+                    "Content-Type": "application/json",
+                },
+            )
+            with urllib.request.urlopen(request, timeout=timeout) as response:
+                return json.loads(response.read())
         except Exception:
             pass
     return None
@@ -62,12 +123,16 @@ def build_payload(judge_cfg, prompt):
 
 def response_content(data):
     content = (data.get("choices", [{}])[0].get("message", {}) or {}).get("content", "")
-    if not content and isinstance(data.get("content"), list):  # Anthropic-native content blocks
-        content = "".join(b.get("text", "") for b in data["content"] if b.get("type") == "text")
-    if not content and isinstance(data.get("candidates"), list):  # Gemini-native candidates
+    if not content and isinstance(data.get("content"), list):
+        content = "".join(
+            block.get("text", "")
+            for block in data["content"]
+            if block.get("type") == "text"
+        )
+    if not content and isinstance(data.get("candidates"), list):
         parts = []
-        for cand in data["candidates"]:
-            for part in ((cand.get("content") or {}).get("parts") or []):
+        for candidate in data["candidates"]:
+            for part in ((candidate.get("content") or {}).get("parts") or []):
                 if part.get("text"):
                     parts.append(part["text"])
         content = "".join(parts)
@@ -75,103 +140,220 @@ def response_content(data):
 
 
 def build_judge_prompt(question, rubric, response):
-    if isinstance(rubric, str):
-        try: rubric = ast.literal_eval(rubric)
-        except Exception: rubric = []
-    if not isinstance(rubric, list): rubric = []
-    rt = "".join(f'P{i+1} ({p.get("points", 0)}pts): {p.get("correct_criterion", "")[:260]}\n'
-                 for i, p in enumerate(rubric) if isinstance(p, dict))
-    return ("STRICT grader. Only award points for SPECIFIC details present.\n"
-            f"QUESTION: {question[:600]}\nRUBRIC:\n{rt}\nRESPONSE:\n{response[:5000]}\n"
-            'Reply JSON: {"points_awarded":[<pts>],"total":<sum>}')
+    normalized = normalize_rubric(rubric)
+    rubric_text = "".join(
+        f"P{i + 1} ({points:g}pts): {criterion[:260]}\n"
+        for i, (points, criterion) in enumerate(normalized)
+    )
+    prompt = (
+        "STRICT grader. Only award points for SPECIFIC details present.\n"
+        f"QUESTION: {question[:600]}\nRUBRIC:\n{rubric_text}\n"
+        f"RESPONSE:\n{response[:5000]}\n"
+        'Reply JSON: {"points_awarded":[<pts>],"total":<sum>}'
+    )
+    return prompt, sum(points for points, _ in normalized)
 
 
 def parse_total(content):
     if not content:
         return None
-    t = re.sub(r"^```(?:json)?\s*", "", content.strip()); t = re.sub(r"\s*```$", "", t)
-    m = re.search(r'\{.*"total".*\}', t, re.DOTALL)
-    if not m:
+    text = re.sub(r"^```(?:json)?\s*", "", content.strip())
+    text = re.sub(r"\s*```$", "", text)
+    match = re.search(r'\{.*"total".*\}', text, re.DOTALL)
+    if not match:
         return None
     try:
-        return float(json.loads(m.group())["total"])
-    except Exception:
+        return float(json.loads(match.group())["total"])
+    except (KeyError, TypeError, ValueError, json.JSONDecodeError):
         return None
 
 
 def judge_one(judge_cfg, key, question, rubric, response):
-    """One judge's score in [0,1], or None on failure. total is a 0-100 sum -> /100, capped at 1."""
-    prompt = build_judge_prompt(question, rubric, response)
+    """Return one normalized score in [0,1], or None on API/parse failure."""
+    prompt, max_points = build_judge_prompt(question, rubric, response)
     data = post(judge_cfg["base_url"], key, build_payload(judge_cfg, prompt))
     if not data:
         return None
-    content = response_content(data)
-    tot = parse_total(content)
-    return None if tot is None else min(tot / 100.0, 1.0)
+    total = parse_total(response_content(data))
+    return None if total is None else max(0.0, min(total / max_points, 1.0))
 
 
 def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--config", default="config.json")
-    ap.add_argument("--data", required=True)
-    ap.add_argument("--responses", required=True)
-    ap.add_argument("--out", required=True)
-    ap.add_argument("--workers", type=int, default=8)
-    args = ap.parse_args()
-    cfg = json.load(open(args.config))
-    judges = cfg["judges"]                       # list of {name, base_url, model, api_key_env?, max_tokens?}
-    rows = ([json.loads(l) for l in open(args.data) if l.strip()]
-            if args.data.endswith(".jsonl") else json.load(open(args.data)))
-    rows = {r["question_id"]: r for r in rows}
-    responses = {r["question_id"]: r for r in json.load(open(args.responses))}
-
-    out = json.load(open(args.out)) if os.path.exists(args.out) else {"per_judge": {}, "average": {}, "overall": None}
-    per = out["per_judge"]
-    for j in judges:
-        per.setdefault(j["name"], {})
-
-    # work: (judge, qid) for non-oos answers not yet judged; oos -> score 0 directly
-    oos = {qid for qid, r in responses.items() if str(r["model_response"]).startswith("[ERROR out_of_context_scope")}
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--config", default="config.json")
+    parser.add_argument("--data", required=True)
+    parser.add_argument("--responses", required=True)
+    parser.add_argument("--out", required=True)
+    parser.add_argument("--workers", type=int, default=8)
+    args = parser.parse_args()
+
+    os.makedirs(os.path.dirname(os.path.abspath(args.out)), exist_ok=True)
+    with open(args.config, encoding="utf-8") as f:
+        cfg = json.load(f)
+    judges = cfg["judges"]
+    if not judges or len({judge["name"] for judge in judges}) != len(judges):
+        raise ValueError("config must contain at least one judge with a unique name")
+
+    with open(args.data, encoding="utf-8") as f:
+        data_rows = (
+            [json.loads(line) for line in f if line.strip()]
+            if args.data.endswith(".jsonl")
+            else json.load(f)
+        )
+    rows = {row["question_id"]: row for row in data_rows}
+    if len(rows) != len(data_rows):
+        raise ValueError("dataset contains duplicate question_id values")
+
+    with open(args.responses, encoding="utf-8") as f:
+        response_rows = json.load(f)
+    responses = {row["question_id"]: row for row in response_rows}
+    if len(responses) != len(response_rows):
+        raise ValueError("response manifest contains duplicate question_id values")
+
+    if os.path.exists(args.out):
+        with open(args.out, encoding="utf-8") as f:
+            out = json.load(f)
+    else:
+        out = {"per_judge": {}, "average": {}, "overall": None}
+    per_judge = out.setdefault("per_judge", {})
+    for judge in judges:
+        per_judge.setdefault(judge["name"], {})
+
+    missing = {qid for qid in rows if qid not in responses}
+    oos = {
+        qid
+        for qid, row in responses.items()
+        if qid in rows
+        and str(row.get("model_response", "")).startswith("[ERROR out_of_context_scope")
+    }
+    failed = {
+        qid
+        for qid, row in responses.items()
+        if qid in rows
+        and (
+            not str(row.get("model_response", "")).strip()
+            or str(row.get("model_response", "")).startswith("[ERROR")
+        )
+        and qid not in oos
+    }
+    valid = set(rows) - missing - oos - failed
+
+    # Validate every judge input before spending API calls.
+    ground_truth = {}
+    for qid in sorted(valid):
+        gt = parse_ground_truth(rows[qid].get("ground_truth", {}))
+        if not (rows[qid].get("question_text") or gt.get("question_text")):
+            raise ValueError(f"{qid}: missing question text")
+        try:
+            normalize_rubric(gt.get("scoring_rubric"))
+        except ValueError as exc:
+            raise ValueError(f"{qid}: {exc}") from exc
+        ground_truth[qid] = gt
+
     work = []
-    for j in judges:
-        for qid, r in responses.items():
-            if qid in oos or qid not in rows:
-                continue
-            if str(r["model_response"]).startswith("[ERROR"):  # transient eval failure: skip, not judged
-                continue
-            if per[j["name"]].get(qid) is None:
-                work.append((j, qid))
-    print(f"judges={[j['name'] for j in judges]} | oos(score0)={len(oos)} | to judge={len(work)}", flush=True)
-    lock = Lock(); n = [0]
+    for judge in judges:
+        for qid in sorted(valid):
+            if per_judge[judge["name"]].get(qid) is None:
+                work.append((judge, qid))
+    print(
+        f"judges={[judge['name'] for judge in judges]} | valid={len(valid)} | "
+        f"zero_fill={len(missing | oos | failed)} | to_judge={len(work)}",
+        flush=True,
+    )
+
+    lock = Lock()
+    completed = [0]
 
     def run(item):
-        j, qid = item
-        r = rows[qid]; gt = r.get("ground_truth", {})
-        q = r.get("question_text") or gt.get("question_text")
-        key = os.environ[j.get("api_key_env", cfg.get("api_key_env", "API_KEY"))]
-        sc = judge_one(j, key, q, gt.get("scoring_rubric") or [], responses[qid]["model_response"])
+        judge, qid = item
+        row = rows[qid]
+        gt = ground_truth[qid]
+        question = row.get("question_text") or gt.get("question_text")
+        env_name = judge.get("api_key_env", cfg.get("api_key_env", "API_KEY"))
+        score = judge_one(
+            judge,
+            os.environ[env_name],
+            question,
+            gt["scoring_rubric"],
+            responses[qid]["model_response"],
+        )
         with lock:
-            per[j["name"]][qid] = sc; n[0] += 1
-            if n[0] % 100 == 0:
-                json.dump(out, open(args.out, "w"), ensure_ascii=False, indent=2)
-                print(f"{n[0]}/{len(work)}", flush=True)
-
-    with ThreadPoolExecutor(max_workers=args.workers) as ex:
-        list(as_completed([ex.submit(run, it) for it in work]))
-
-    # aggregate: per task, average the available judge scores; oos -> 0
-    avg = {}
-    all_qids = set(oos) | {qid for jn in per for qid in per[jn]}
-    for qid in all_qids:
-        if qid in oos:
-            avg[qid] = 0.0; continue
-        vals = [per[jn][qid] for jn in per if per[jn].get(qid) is not None]
-        if vals:
-            avg[qid] = sum(vals) / len(vals)
-    out["average"] = avg
-    out["overall"] = round(100 * sum(avg.values()) / len(avg), 2) if avg else None
-    json.dump(out, open(args.out, "w"), ensure_ascii=False, indent=2)
-    print(f"DONE: overall={out['overall']} over n={len(avg)} -> {args.out}", flush=True)
+            per_judge[judge["name"]][qid] = score
+            completed[0] += 1
+            if completed[0] % 100 == 0:
+                write_json(args.out, out)
+                print(f"{completed[0]}/{len(work)}", flush=True)
+
+    with ThreadPoolExecutor(max_workers=args.workers) as executor:
+        futures = [executor.submit(run, item) for item in work]
+        try:
+            for future in as_completed(futures):
+                future.result()
+        finally:
+            with lock:
+                write_json(args.out, out)
+
+    # Require the full configured panel for every valid response. A judge failure is not a
+    # contestant failure and must not be converted into zero or a smaller-panel average.
+    judge_names = [judge["name"] for judge in judges]
+    scored = {}
+    incomplete = {}
+    for qid in sorted(valid):
+        absent = [name for name in judge_names if per_judge[name].get(qid) is None]
+        if absent:
+            incomplete[qid] = absent
+        else:
+            scored[qid] = sum(float(per_judge[name][qid]) for name in judge_names) / len(judge_names)
+
+    zero_filled = missing | oos | failed
+    average = {qid: 0.0 for qid in sorted(zero_filled)}
+    average.update(scored)
+    scored_overall = round(100 * sum(scored.values()) / len(scored), 2) if scored else None
+    all_tasks_overall = (
+        round(100 * sum(average.values()) / len(rows), 2)
+        if rows and not incomplete
+        else None
+    )
+    out.update(
+        {
+            "average": average,
+            "scored_overall": scored_overall,
+            "scored_n": len(scored),
+            "valid_n": len(scored),
+            "all_tasks_overall": all_tasks_overall,
+            "all_tasks_n": len(rows),
+            "overall": all_tasks_overall,
+            "overall_definition": (
+                f"All{len(rows)}: missing, failed, and out-of-context responses are zero"
+            ),
+            "scoring_complete": not incomplete,
+            "response_manifest_complete": not missing,
+            "coverage": {
+                "responses_present": len(set(rows) & set(responses)),
+                "valid_responses": len(valid),
+                "out_of_context": len(oos),
+                "failed_responses": len(failed),
+                "missing_responses": len(missing),
+                "fully_judged": len(scored),
+                "incomplete_judging": len(incomplete),
+            },
+            "incomplete_judging": incomplete,
+        }
+    )
+    write_json(args.out, out)
+
+    if incomplete:
+        print(
+            f"INCOMPLETE: {len(incomplete)} valid responses lack one or more judge scores; "
+            f"resume the command -> {args.out}",
+            flush=True,
+        )
+        raise SystemExit(2)
+    print(
+        f"DONE: Scored={scored_overall} (n={len(scored)}), "
+        f"All{len(rows)}={all_tasks_overall} -> {args.out}",
+        flush=True,
+    )
 
 
 if __name__ == "__main__":

methodology/EVAL_PROTOCOL.md

@@ -32,9 +32,7 @@ few-shot examples, no chain-of-thought instruction.
 ## 3. Context caps and out-of-context scoring
 Each model is evaluated **at its native context window**. The document is measured in
 **characters**; if `len(document) > cap` the task is **out_of_context_scope** and scored
-**0** — the document is NOT sent (a system that cannot ingest the evidence fails the task).
-This is the single most important convention: bottom-of-leaderboard models score low mainly
-because 40–50% of documents exceed their window.
+**0** — the document is NOT sent. Treat this as route metadata, not as an item edit.
 
 CJK detection: if the first 4000 chars contain >20 CJK ideographs (`一`–`鿿`), use the **cjk**
 cap, else the **en** cap (CJK packs more tokens per character).
@@ -67,8 +65,8 @@ judges show no measurable bias on this set). Panel used in the paper:
 | judge 2 | Qwen3.5 | `qwen3.5-plus` |
 | judge 3 | Gemini-2.5-Flash | `gemini-2.5-flash` |
 
-(Qwen3.5 is a *judge* here, hence it is not a graded contestant.) out_of_context_scope
-answers stay 0 and are not sent to judges.
+(Qwen3.5 is a *judge* here, hence it is not a graded contestant.) Out-of-context
+records stay at zero and are not sent to judges.
 
 Exact judge prompt (per answer):
 
@@ -83,20 +81,23 @@ RESPONSE:
 Reply JSON: {"points_awarded":[<pts>],"total":<sum>}
 ```
 
-The rubric is the task's `ground_truth.scoring_rubric` (a list of `{points, correct_criterion}`).
-Judge settings: `temperature = 0.1`, `max_tokens = 16384`. Parse the `total` field
-(a 0–100 sum), score = `min(total / 100, 1.0)`. A task's final score = mean of the available
-judges' scores.
+The rubric is the task's `ground_truth.scoring_rubric` (a list of
+`{points, correct_criterion}`). Released rubric points sum to 100. Judge settings:
+`temperature = 0.1`, `max_tokens = 16384`. Parse the `total` field and normalize by the
+sum of rubric points. A task's final score is emitted only after all configured judges
+succeed, then equals their simple mean.
 
 ## 5. Aggregation
-- Per task, per model: mean of the 3 judges for valid scored responses; out-of-context rows
-  are assigned 0 and are not sent to judges.
-- The paper reports two denominator views. `Scored` is valid-response quality: the mean over
-  valid scored responses for that route, with `n` reporting the number of valid scored rows.
-  `All481` is coverage-sensitive quality: all 481 attempted tasks are the denominator, and
-  missing, failed, and out-of-context rows are zero-filled.
-- A matched-panel variant (tasks scored by all models) is reported only as a robustness check.
-  It is not the headline denominator because it removes many long-context access failures.
+- `Scored` (`scored_overall`, with `scored_n`) is valid-response quality: the mean
+  over valid responses successfully scored by the full configured judge panel.
+- `All481` (`all_tasks_overall`, also exposed as `overall`) is coverage-sensitive:
+  all 481 tasks are the denominator, and missing, failed, and out-of-context model
+  responses are zero-filled.
+- Judge API or parse failures are resumable infrastructure failures, not model
+  failures. The script writes partial state, leaves `overall` null, and exits with
+  status 2 until the complete configured panel succeeds.
+- Do not mix scores produced under different route caps, prompts, retry policies,
+  judge panels, or aggregation policies.
 
 ## 6. Reproducing with the provided scripts
 ```bash
@@ -108,8 +109,13 @@ python run_eval.py  --config config.json --data ../data/wildtrace_strict481.with
 # 2) edit config.json "judges" to your three judge endpoints
 python run_judge.py --config config.json --data ../data/wildtrace_strict481.with_answers.json \
                     --responses ../results/mymodel.responses.json --out ../results/mymodel.scores.json
-# overall % is printed and stored at results/mymodel.scores.json -> "overall"
+# Scored and All481 are printed; All481 is stored in "all_tasks_overall" and "overall"
 ```
+Both released data representations are supported: the nested `.json` file and the
+Hugging Face `.jsonl` file whose `ground_truth` field is serialized JSON. Output
+directories are created automatically. Re-run either command to resume transient
+model or judge failures.
+
 LLM judges are non-deterministic, so a fresh run should be reported with the
 model route, endpoint date, context policy, decoding settings, and judge panel
 used for that run.