build_extrinsic.py

#!/usr/bin/env python3
"""
Build Mergeability-2/extrinsic-evaluations: one tidy long-format table of every
EXTRINSIC (downstream / task-level) evaluation produced across the 2026-08-26 workstreams.

Re-runnable and idempotent. Sources that are not yet published on the Hub are skipped
with a recorded status, so re-running once the in-progress agents publish will pick
them up without any code change.

Usage:
    source /root/.ms_hf_env
    python3 build_extrinsic.py            # build only
    python3 build_extrinsic.py --push     # build and push to the Hub
"""
import argparse, csv, json, math, os, sys, datetime
from pathlib import Path

ROOT = Path("/root/extrinsic-eval")
CACHE = ROOT / "cache"
OUT = ROOT / "out"
TARGET_REPO = "Mergeability-2/extrinsic-evaluations"

# ---------------------------------------------------------------- source registry
SOURCES = {
    "merge-accuracy":   dict(repo="Mergeability-2/merge-accuracy",                 status="complete"),
    "compose-audit":    dict(repo="Mergeability-2/compose-audit",                  status="complete"),
    "crossarch-1b":     dict(repo="Mergeability-2/crossarch-1b-diagnostics",       status="complete"),
    "mergebench":       dict(repo="Mergeability-2/mergebench-property-sweep",      status="complete"),
    "aim":              dict(repo="Mergeability-2/aim-activation-informed-merging",status="complete"),
    "goldfish":         dict(repo="suchirsalhan/goldfish-crosslingual-cka",        status="complete"),
    "beetle":           dict(repo="Mergeability-2/beetle-merge-eval",              status="in_progress"),
    "crossarch-acc":    dict(repo="Mergeability-2/crossarch-accuracy",             status="in_progress"),
}

# ---------------------------------------------------------------- metric dictionary
# metric -> (metric_kind, unit).  metric_kind is the coarse grouping that must never be
# mixed:  accuracy | benchmark_score | likelihood | likelihood_delta | other
METRICS = {
    "accuracy":                    ("accuracy",         "proportion_0_1"),
    "accuracy_pct":                ("accuracy",         "percent_0_100"),
    "delta_accuracy":              ("accuracy_delta",   "proportion_0_1"),
    "benchmark_score_pct":         ("benchmark_score",  "percent_0_100"),
    "benchmark_score_norm_pct":    ("benchmark_score",  "percent_0_100_normalised"),
    "benchmark_mean_accuracy":     ("benchmark_score",  "proportion_0_1"),
    "nats_per_token":              ("likelihood",       "nats/token"),
    "nats_per_utf8_byte":          ("likelihood",       "nats/utf8_byte"),
    "delta_floor_nats_per_token":  ("likelihood_delta", "nats/token"),
    "delta_floor_nats_per_byte":   ("likelihood_delta", "nats/utf8_byte"),
    "lmc_barrier_nats_per_token":  ("likelihood_delta", "nats/token"),
    "harmfulness_score":           ("other",            "score_0_1"),
    "bliss_score":                 ("other",            "BLiSS sub-score"),
}

# chance levels for single-benchmark accuracy rows
CHANCE = {
    "belebele": 0.25, "arc_easy": 0.25, "sciq": 0.25, "piqa": 0.5,
    "lambada": 0.0, "ifeval": 0.0, "blimp": 0.5, "multiblimp": 0.5,
    "mmlu": 25.0, "humaneval": 0.0, "mbpp": 0.0, "math": 0.0, "gsm8k": 0.0,
}

rows = []
NCOLS = ["model_id","model_role","provenance_family","parents","rung","operator","experiment",
         "benchmark","metric","value","chance","n","source_dataset","notes","metric_kind","unit"]

def emit(model_id, model_role, provenance_family, parents, rung, operator, experiment,
         benchmark, metric, value, chance=None, n=None, source_dataset=None, notes=""):
    if value is None: return
    try:
        v = float(value)
    except (TypeError, ValueError):
        return
    if math.isnan(v) or math.isinf(v): return
    kind, unit = METRICS[metric]
    if kind == "accuracy" and chance is None:
        raise AssertionError(f"accuracy row without chance: {model_id} {benchmark} {metric}")
    rows.append(dict(model_id=model_id, model_role=model_role, provenance_family=provenance_family,
        parents=parents or "", rung=rung or "", operator=operator or "", experiment=experiment,
        benchmark=benchmark, metric=metric, value=v,
        chance=("" if chance is None else float(chance)), n=("" if n is None else int(n)),
        source_dataset=source_dataset, notes=notes, metric_kind=kind, unit=unit))

def rd(p):
    return list(csv.DictReader(open(p)))

def jl(p):
    return [json.loads(l) for l in open(p) if l.strip()]

def f(x):
    if x in (None, "", "NA", "nan", "NaN"): return None
    try:
        v = float(x)
        return None if math.isnan(v) else v
    except (TypeError, ValueError):
        return None

# =================================================================== 1. merge-accuracy
def build_merge_accuracy(d, ds):
    """Chat-vector / Llama-3.1-8B fork accuracies + the pythia x Zh-Pythia cross-group pair."""
    BENCH_CHANCE = {"arc_easy": 0.25, "belebele_eng_Latn": 0.25, "belebele_ind_Latn": 0.25,
                    "belebele_jpn_Jpan": 0.25, "belebele_tha_Thai": 0.25,
                    "ifeval_inst": 0.0, "ifeval_prompt": 0.0}
    ROLE = {"reference": "reference", "control": "control", "fork": "parent", "merge": "merged"}

    for r in jl(d / "results/chatvec.jsonl"):
        acc = r.get("acc")
        if not acc:  # 'diag' records carry no evaluation
            continue
        kind, fork, arm = r["kind"], r.get("fork"), r.get("arm")
        lam = r.get("lam")
        role = ROLE.get(kind, "merged")
        model = r.get("model")
        if kind in ("reference", "fork"):
            # each real fork has its own repo, so the repo id is a unique model id
            mid = model
        elif kind == "control":
            # every PERM control shares the underlying fork's repo but is a DIFFERENT model
            # (that fork acted on by a random element of its own symmetry group), so the
            # permutation fraction and arm must be part of the identity.
            mid = f"chatvec-control:{fork}|{arm}" + (f"|lam{lam}" if lam is not None else "")
        else:
            mid = f"chatvec-merge:{fork}|{arm}|lam{lam}"
        parents = ""
        operator = ""
        if kind == "merge" or (kind == "control" and arm in ("naive", "aligned")):
            base_fork = (fork or "").split("_PERM")[0]
            parents = "|".join(filter(None, [
                "meta-llama/Llama-3.1-8B-Instruct", "meta-llama/Llama-3.1-8B",
                {"swallow_ja": "tokyotech-llm/Llama-3.1-Swallow-8B-v0.1",
                 "swallow_ja_v02": "tokyotech-llm/Llama-3.1-Swallow-8B-v0.2",
                 "sealion_id": "aisingapore/llama3.1-8b-cpt-sea-lionv3-base",
                 "typhoon2_th": "scb10x/llama3.1-typhoon2-8b"}.get(base_fork, f"fork:{fork}")]))
            operator = f"chat_vector_{arm}"
        note = r.get("note", "")
        if kind == "control":
            note = (note + f" | ground-truth control: {fork} = the fork acted on by a random element "
                    f"of its own symmetry group (functionally identical, differently parameterised); "
                    f"frac_layers_permuted={r.get('frac_layers_permuted')}; "
                    f"underlying repo {model or 'n/a (constructed merge)'}").strip(" |")
        for b, v in acc.items():
            if b == "mean":
                emit(mid, role, "Llama-3.1-8B", parents, (f"lambda={lam}" if lam is not None else ""),
                     operator, "chat_vector_llama31", "mean_of_benchmarks", "benchmark_mean_accuracy",
                     v, None, None, ds, (note + " | unweighted mean over the row's benchmarks; "
                     "not a single-benchmark accuracy, so no chance level").strip(" |"))
                continue
            ch = BENCH_CHANCE.get(b)
            if ch is None:
                ch = 0.25 if b.startswith("belebele") else 0.0
            emit(mid, role, "Llama-3.1-8B", parents, (f"lambda={lam}" if lam is not None else ""),
                 operator, "chat_vector_llama31", b, "accuracy", v, ch, None, ds, note)

    # cross-group direct merge: pythia-1.4b x Zh-Pythia-1.4B
    LED_CHANCE = {"sciq": 0.25, "sciq_norm": 0.25, "piqa": 0.5, "piqa_norm": 0.5,
                  "arc_easy": 0.25, "arc_easy_norm": 0.25, "lambada": 0.0, "lambada_norm": 0.0}
    for r in jl(d / "results/ledger.jsonl"):
        acc = r.get("acc")
        if not acc: continue
        arm = r["arm"]
        role = "parent" if arm in ("parentA", "parentB") else "merged"
        model = r.get("model")
        alpha = r.get("alpha")
        mid = model if role == "parent" else f"crossgroup-merge:{r['pair']}|{arm}|alpha{alpha}"
        parents = "" if role == "parent" else "EleutherAI/pythia-1.4b|SJTU-CL/Zh-Pythia-1.4B"
        for b, v in acc.items():
            if b == "mean":
                emit(mid, role, "pythia-1.4b x Zh-Pythia-1.4B", parents,
                     (f"alpha={alpha}" if alpha is not None else ""), arm if role=="merged" else "",
                     "crossgroup_direct_merge", "mean_of_benchmarks", "benchmark_mean_accuracy", v,
                     None, None, ds, "R4_cross_group; unweighted mean over sciq/piqa/arc_easy/lambada "
                     "(acc and acc_norm), not a single-benchmark accuracy")
                continue
            emit(mid, role, "pythia-1.4b x Zh-Pythia-1.4B", parents,
                 (f"alpha={alpha}" if alpha is not None else ""), arm if role=="merged" else "",
                 "crossgroup_direct_merge", b, "accuracy", v, LED_CHANCE.get(b, 0.25), None, ds,
                 "R4_cross_group; two independently pretrained 1.4B models, different vocabularies")

# =================================================================== 2. compose-audit
def build_compose_audit(d, ds):
    R = d / "results"
    # ---- SET 1: BLiMP accuracy on PolyPythia seed merges
    for p in sorted(R.glob("blimp*.jsonl")):
        size_tag = p.stem.replace("blimpB_", "").replace("blimp_", "")
        for r in jl(p):
            size = r.get("size", size_tag)
            pair = r["pair"]; pid = f"pythia-{size}-seed{pair[0]}|pythia-{size}-seed{pair[1]}"
            npar = r.get("n_per_paradigm"); npara = r.get("n_paradigms")
            n = (npar * npara) if (npar and npara) else None
            fam = f"PolyPythia-{size}"
            for side, k in (("a", 0), ("b", 1)):
                emit(f"EleutherAI/pythia-{size}-seed{pair[k]}", "parent", fam, "", "parent", "",
                     "polypythia_seed_merge", "BLiMP", "accuracy", r["parent_acc"][side], 0.5, n, ds,
                     "SET 1 parent; seed-only difference")
            for rung, vals in r["rungs"].items():
                mid = f"compose-audit:polypythia_seed_merge|{size}|seed{pair[0]}x{pair[1]}|{rung}"
                emit(mid, "merged", fam, pid,
                     rung, rung.split("_", 1)[1], "polypythia_seed_merge", "BLiMP", "accuracy",
                     vals.get("blimp_acc"), 0.5, n, ds,
                     "SET 1 merged; BLiMP is ACCURACY -- do not read as the likelihood rescue")
                emit(mid, "merged", fam, pid,
                     rung, rung.split("_", 1)[1], "polypythia_seed_merge", "BLiMP", "delta_accuracy",
                     vals.get("delta_vs_best_parent"), None, n, ds, "vs. the better parent")

    # ---- SET 1: nats/token (Delta-floor) on the same merges
    # NOTE: set1 / set1x / slerp / repair are four resumable ledgers over the SAME merges.
    # They re-report identical M0_naive_avg / M1_perm_avg baselines, and set1x re-measures
    # three 410m pairs already in set1. A canonical merge id + the global dedupe below
    # collapses those repeats so no merge is counted more than once.
    for pat, exp in (("set1_*.jsonl", "polypythia_seed_merge"), ("set1x_*.jsonl", "polypythia_seed_merge"),
                     ("slerp_*.jsonl", "polypythia_seed_merge"),
                     ("repair_*.jsonl", "polypythia_seed_merge"),
                     ("abl_*.jsonl", "polypythia_ablation")):
        for p in sorted(R.glob(pat)):
            if p.name.endswith("_pairs.csv"): continue
            for r in jl(p):
                size = r.get("size", p.stem.split("_", 1)[1])
                pair = r["pair"]; pid = f"pythia-{size}-seed{pair[0]}|pythia-{size}-seed{pair[1]}"
                fam = f"PolyPythia-{size}"
                corpus = r.get("corpus", "flores200_devtest_eng_Latn")
                pn = r.get("parent_nll") or {}
                for side, k in (("a", 0), ("b", 1)):
                    if side in pn:
                        emit(f"EleutherAI/pythia-{size}-seed{pair[k]}", "parent", fam, "", "parent", "",
                             exp, corpus, "nats_per_token", pn[side], None, None, ds, "SET 1 parent floor")
                for rung, vals in r["rungs"].items():
                    mid = f"compose-audit:{exp}|{size}|seed{pair[0]}x{pair[1]}|{rung}"
                    op = rung.split("_", 1)[1]
                    emit(mid, "merged", fam, pid, rung, op, exp, corpus, "nats_per_token",
                         vals.get("nll"), None, None, ds, "LIKELIHOOD, not accuracy")
                    emit(mid, "merged", fam, pid, rung, op, exp, corpus,
                         "delta_floor_nats_per_token", vals.get("delta_floor"), None, None, ds,
                         "Delta vs. the better parent's floor; LIKELIHOOD, not accuracy")
                    if "blimp_acc" in vals:
                        emit(mid, "merged", fam, pid, rung, op, exp, "BLiMP", "accuracy",
                             vals["blimp_acc"], 0.5, None, ds,
                             "same merge as the nats/token rows -- the two rescues are uncorrelated")
                for key, lbl in (("barrier_naive", "naive"), ("barrier_perm", "perm_avg")):
                    if key in r:
                        emit(f"compose-audit:{exp}|{size}|seed{pair[0]}x{pair[1]}|{lbl}", "merged", fam, pid,
                             lbl, lbl, exp, corpus, "lmc_barrier_nats_per_token",
                             r[key].get("barrier"), None, None, ds, "linear-mode-connectivity barrier")

    # ---- SET 1: corpus robustness -- the same merges scored on three held-out corpora
    for p in sorted(R.glob("corpus_*.jsonl")):
        for r in jl(p):
            size = r["size"]; pair = r["pair"]
            pid = f"pythia-{size}-seed{pair[0]}|pythia-{size}-seed{pair[1]}"
            fam = f"PolyPythia-{size}"
            for side, k in (("a", 0), ("b", 1)):
                for corpus, v in (r.get("parent_nll") or {}).get(side, {}).items():
                    emit(f"EleutherAI/pythia-{size}-seed{pair[k]}", "parent", fam, "", "parent", "",
                         "polypythia_corpus_robustness", corpus, "nats_per_token", v, None, None, ds,
                         "SET 1 parent floor on an alternative held-out corpus")
            for rung, per_corpus in r["rungs"].items():
                mid = f"compose-audit:corpus|{size}|seed{pair[0]}x{pair[1]}|{rung}"
                op = rung.split("_", 1)[1]
                for corpus, vals in per_corpus.items():
                    emit(mid, "merged", fam, pid, rung, op, "polypythia_corpus_robustness",
                         corpus, "nats_per_token", vals.get("nll"), None, None, ds,
                         "robustness check: same merge, different held-out corpus; LIKELIHOOD")
                    emit(mid, "merged", fam, pid, rung, op, "polypythia_corpus_robustness",
                         corpus, "delta_floor_nats_per_token", vals.get("delta_floor"), None, None,
                         ds, "Delta vs. the better parent's floor on that corpus; LIKELIHOOD")

    # ---- SET 4: Goldfish bilingual composition (nats / UTF-8 byte)
    for name, exp in (("set4_goldfish.jsonl", "goldfish_bilingual_merge"),
                      ("set4_reverse.jsonl", "goldfish_bilingual_merge_reverse")):
        p = R / name
        if not p.exists(): continue
        for r in jl(p):
            lang = r["lang"]; ra, rb = r.get("repo_a"), r.get("repo_b")
            pid = "|".join(x for x in (ra, rb) if x); fam = f"Goldfish eng x {lang}"
            for pk, pv in (r.get("parents") or {}).items():
                if isinstance(pv, dict) and "nats_per_byte" in pv:
                    emit(f"goldfish-parent:{pid}|{pk}", "parent", fam, "", "parent", "", exp,
                         f"flores200_devtest[{pk}]", "nats_per_utf8_byte", pv["nats_per_byte"],
                         None, r.get("n_sent"), ds, "SET 4 parent floor; LIKELIHOOD")
            for rung, vals in r["rungs"].items():
                mid = f"compose-audit:{r['set']}|{lang}|{rung}"; op = rung.split("_", 1)[1]
                for sub in ("eng", "x"):
                    if isinstance(vals.get(sub), dict):
                        emit(mid, "merged", fam, pid, rung, op, exp, f"flores200_devtest[{sub}]",
                             "nats_per_utf8_byte", vals[sub].get("nats_per_byte"), None,
                             r.get("n_sent"), ds, "LIKELIHOOD, not accuracy")
                for k, sub in (("delta_floor_eng", "eng"), ("delta_floor_x", "x"),
                               ("delta_floor_mean", "mean")):
                    emit(mid, "merged", fam, pid, rung, op, exp, f"flores200_devtest[{sub}]",
                         "delta_floor_nats_per_byte", vals.get(k), None, r.get("n_sent"), ds,
                         "Delta vs. parent floor; LIKELIHOOD, not accuracy")

    # ---- SET 4: MultiBLiMP accuracy on the same Goldfish merges
    p = R / "set4_multiblimp.jsonl"
    if p.exists():
        for r in jl(p):
            lang = r["lang"]; rb = r.get("repo_b"); fam = f"Goldfish eng x {lang}"
            pid = f"goldfish-models/eng_latn_1000mb|{rb}"
            ne, nx = r.get("n_items_eng"), r.get("n_items_x")
            for pk, pv in (r.get("parents") or {}).items():
                emit(f"goldfish-parent:{pid}|{pk}", "parent", fam, "", "parent", "",
                     "goldfish_bilingual_merge", f"MultiBLiMP1.0[{pk}]", "accuracy", pv, 0.5,
                     ne if "eng" in pk else nx, ds, "SET 4 parent")
            for rung, vals in r["rungs"].items():
                mid = f"compose-audit:set4_goldfish|{lang}|{rung}"; op = rung.split("_", 1)[1]
                for k, sub, n in (("mb_eng", "eng", ne), ("mb_x", "x", nx)):
                    emit(mid, "merged", fam, pid, rung, op, "goldfish_bilingual_merge",
                         f"MultiBLiMP1.0[{sub}]", "accuracy", vals.get(k), 0.5, n, ds,
                         "ACCURACY on the same merge whose Delta-floor says it is destroyed")
                for k, sub, n in (("delta_eng_vs_eng_parent", "eng", ne),
                                  ("delta_x_vs_x_parent", "x", nx)):
                    emit(mid, "merged", fam, pid, rung, op, "goldfish_bilingual_merge",
                         f"MultiBLiMP1.0[{sub}]", "delta_accuracy", vals.get(k), None, n, ds,
                         "vs. that language's parent")

    # ---- B-GPT: bilingual x bilingual merge (shared vocabulary) + joint-training ceiling
    p = R / "bgpt_merge.jsonl"
    if p.exists():
        for r in jl(p):
            lang = r["lang"]; ra, rb = r.get("repo_a"), r.get("repo_b")
            pid = f"{ra}|{rb}"; fam = f"B-GPT en-{lang} ({r.get('variant')})"
            for pk, pv in (r.get("parents") or {}).items():
                mid = {"A": ra, "B": rb}.get(pk, f"bgpt-parent:{pk}")
                for k, sub in (("nats_per_byte_eng", "eng"), ("nats_per_byte_x", "x")):
                    emit(mid, "parent", fam, "", "parent", "", "bgpt_bilingual_merge",
                         f"flores200_devtest[{sub}]", "nats_per_utf8_byte", pv.get(k), None, None, ds,
                         "B-GPT parent; LIKELIHOOD")
                for k, sub in (("multiblimp_eng", "eng"), ("multiblimp_x", "x")):
                    emit(mid, "parent", fam, "", "parent", "", "bgpt_bilingual_merge",
                         f"MultiBLiMP1.0[{sub}]", "accuracy", pv.get(k), 0.5, None, ds, "B-GPT parent")
            for rung, vals in r["rungs"].items():
                mid = f"compose-audit:bgpt_merge|{lang}|{rung}"; op = rung.split("_", 1)[1]
                for k, sub in (("nats_per_byte_eng", "eng"), ("nats_per_byte_x", "x")):
                    emit(mid, "merged", fam, pid, rung, op, "bgpt_bilingual_merge",
                         f"flores200_devtest[{sub}]", "nats_per_utf8_byte", vals.get(k), None, None, ds,
                         "LIKELIHOOD, not accuracy")
                for k, sub in (("delta_floor_eng", "eng"), ("delta_floor_x", "x"),
                               ("delta_floor_mean", "mean")):
                    emit(mid, "merged", fam, pid, rung, op, "bgpt_bilingual_merge",
                         f"flores200_devtest[{sub}]", "delta_floor_nats_per_byte", vals.get(k),
                         None, None, ds, "LIKELIHOOD, not accuracy")
                for k, sub in (("multiblimp_eng", "eng"), ("multiblimp_x", "x")):
                    emit(mid, "merged", fam, pid, rung, op, "bgpt_bilingual_merge",
                         f"MultiBLiMP1.0[{sub}]", "accuracy", vals.get(k), 0.5, None, ds,
                         "ACCURACY on the same merge")

    p = R / "bgpt_ceiling.jsonl"
    if p.exists():
        for r in jl(p):
            lang = r["lang"]; fam = f"B-GPT en-{lang} ({r.get('variant')})"
            ne, nx = r.get("n_items_eng"), r.get("n_items_x")
            ROLE = {"bgpt_joint_bilingual": "jointly_trained", "goldfish_eng_parent": "parent",
                    "goldfish_partner_parent": "parent", "merge_M0_naive": "merged",
                    "merge_M1a_vocab": "merged"}
            for arm, vals in r["arms"].items():
                role = ROLE.get(arm, "reference")
                mid = r.get("repo") if arm == "bgpt_joint_bilingual" else f"compose-audit:bgpt_ceiling|{lang}|{arm}"
                note = ("jointly trained bilingual model -- the ceiling any merge is compared against"
                        if role == "jointly_trained" else "")
                for k, sub, n in (("nats_per_byte_eng", "eng", ne), ("nats_per_byte_x", "x", nx)):
                    emit(mid, role, fam, "", arm, "", "bgpt_joint_vs_merge",
                         f"flores200_devtest[{sub}]", "nats_per_utf8_byte", vals.get(k), None, n, ds,
                         (note + " | LIKELIHOOD").strip(" |"))
                for k, sub, n in (("multiblimp_eng", "eng", ne), ("multiblimp_x", "x", nx)):
                    emit(mid, role, fam, "", arm, "", "bgpt_joint_vs_merge",
                         f"MultiBLiMP1.0[{sub}]", "accuracy", vals.get(k), 0.5, n, ds, note)

# =================================================================== 3. crossarch 1B
CODE2REPO = {"EN_pythia": "EleutherAI/pythia-1.4b", "ZH_pythia": "SJTU-CL/Zh-Pythia-1.4B",
             "PT_tucano": "TucanoBR/Tucano-1b1", "PL_bielik": "speakleash/Bielik-1.5B-v3",
             "IT_minerva": "sapienzanlp/Minerva-1B-base-v1.0",
             "pythia": "EleutherAI/pythia-1.4b", "zhpythia": "SJTU-CL/Zh-Pythia-1.4B",
             "EN": "EleutherAI/pythia-1.4b", "ZH": "SJTU-CL/Zh-Pythia-1.4B",
             "PT": "TucanoBR/Tucano-1b1", "PL": "speakleash/Bielik-1.5B-v3",
             "IT": "sapienzanlp/Minerva-1B-base-v1.0"}

def build_crossarch(d, ds):
    R = d / "results"
    # per-model reference quality (nats/token)
    mq = R / "model_quality.json"
    if mq.exists():
        roster = {}
        tr = R / "table_model_roster.csv"
        if tr.exists():
            for x in rd(tr):
                roster[x["model"].replace("-", "_").replace(".", "")] = x.get("HF repo id", "")
        for k, v in json.load(open(mq)).items():
            emit(CODE2REPO.get(k, k), "reference", "crossarch-1B", "", "endpoint", "",
                 "crossarch_1b_native", "held_out_corpus", "nats_per_token", v.get("tok_nll"),
                 None, None, ds, f"single-model reference quality (source code '{k}'); LIKELIHOOD")

    # checkpoint merges within one training run
    for p in sorted(R.glob("ckpt_*_shard*.jsonl")):
        for r in jl(p):
            fam = r["family"]; repo = CODE2REPO.get(fam, fam)
            pid = f"{repo}@step{r['step_a']}|{repo}@step{r['step_b']}"
            base = f"crossarch:{fam}|{r['step_a']}x{r['step_b']}"
            for side, st in (("a", r["step_a"]), ("b", r["step_b"])):
                emit(f"{repo}@step{st}", "parent", fam, "", "checkpoint", "",
                     "crossarch_checkpoint_merge", "held_out_corpus", "nats_per_token",
                     r.get(f"nll_{side}"), None, None, ds, "checkpoint endpoint; LIKELIHOOD")
            for k, op in (("nll_avg", "weight_avg"), ("nll_lerp_0.25", "lerp_a0.25"),
                          ("nll_lerp_0.75", "lerp_a0.75"), ("nll_ties", "ties"),
                          ("nll_task_arith", "task_arithmetic"), ("nll_dare", "dare")):
                emit(f"{base}|{op}", "merged", fam, pid, op, op, "crossarch_checkpoint_merge",
                     "held_out_corpus", "nats_per_token", r.get(k), None, None, ds,
                     "LIKELIHOOD, not accuracy")
            emit(f"{base}|lmc", "merged", fam, pid, "lmc", "weight_avg",
                 "crossarch_checkpoint_merge", "held_out_corpus", "lmc_barrier_nats_per_token",
                 r.get("barrier"), None, None, ds,
                 "linear-mode-connectivity barrier; negative = merge beats the endpoint average")

    # cross-architecture optimal-transport transport merges
    p = R / "transport_merge.csv"
    if p.exists():
        for r in rd(p):
            tgt, don, a = r["target"], r["donor"], r["alpha"]
            pid = f"{CODE2REPO.get(tgt, tgt)}|{CODE2REPO.get(don, don)}"
            mid = f"crossarch-transport:{tgt}<-{don}|alpha{a}"
            n = int(f(r.get("n_probe")) or 0) or None
            for k, lbl, op in (("nll", f"held_out[{r['target_lang']}]", "transport_ot"),
                               ("nll_donor_lang", f"held_out[{r['donor_lang']}]", "transport_ot"),
                               ("nll_randplan", f"held_out[{r['target_lang']}]", "transport_random_plan"),
                               ("nll_donor_lang_randplan", f"held_out[{r['donor_lang']}]", "transport_random_plan")):
                emit(f"{mid}|{op}", "merged" if "random" not in op else "control", "crossarch-1B",
                     pid, f"alpha={a}", op, "crossarch_transport_merge", lbl, "nats_per_token",
                     r.get(k), None, n, ds,
                     "random-plan arm is the control for the OT plan" if "random" in op
                     else "cross-architecture transport merge; LIKELIHOOD")

    # native cross-model merges (no transport)
    p = R / "crossmodel_native_merge_summary.csv"
    if p.exists():
        for r in rd(p):
            host, op = r["host"], r["operator"]
            emit(CODE2REPO.get(host, host), "parent", "crossarch-1B", "", "host_only",
                 "", "crossarch_native_merge", f"held_out[{host}]", "nats_per_token",
                 r.get("nll_host_only"), None, None, ds, "host model alone; LIKELIHOOD")
            for k, rung in (("nll_donor_blocks", "donor_blocks"), ("nll_half", "half")):
                emit(f"crossarch-native:{host}|{op}|{rung}", "merged", "crossarch-1B", "", rung, op,
                     "crossarch_native_merge", f"held_out[{host}]", "nats_per_token", r.get(k),
                     None, None, ds, "LIKELIHOOD, not accuracy")
            emit(f"crossarch-native:{host}|{op}|half", "merged", "crossarch-1B", "", "half", op,
                 "crossarch_native_merge", f"held_out[{host}]", "lmc_barrier_nats_per_token",
                 r.get("barrier"), None, None, ds, "LMC barrier")

# =================================================================== 4. MergeBench
def build_mergebench(d, ds):
    p = d / "mergebench_published_scores.csv"
    if not p.exists(): return
    NORM = {"Avg. Norm", "Avg. Norm (Table 8)"}
    for r in rd(p):
        fam = r["family"]
        fam_c = {"Gemma-2-2b": "gemma-2-2b", "Gemma-2-2b-it": "gemma-2-2b-it",
                 "Gemma-2-9b": "gemma-2-9b", "Gemma-2-9b-it": "gemma-2-9b-it"}.get(fam, fam)
        task = r["task"]
        metric = "benchmark_score_norm_pct" if task in NORM else "benchmark_score_pct"
        arity = int(f(r.get("merge_arity")) or 5)
        emit(f"mergebench:{fam_c}|{r['method']}", "merged", fam_c,
             f"{fam_c}: all {arity} domain experts", f"{arity}-expert merge", r["method"],
             "mergebench_published_outcomes", task, metric, r.get("score"), None, None, ds,
             f"published by MergeBench ({r.get('source','')}); every released score is a "
             f"{arity}-expert merge, so no pair-level outcome exists. Suite aggregate over "
             "heterogeneous tasks -- NOT a single-benchmark accuracy, so no chance level is defined.")

# =================================================================== 5. AIM
def build_aim(d, ds):
    p = d / "results/published_scores.csv"
    if not p.exists(): return
    B = {"HumanEval": ("accuracy_pct", 0.0), "MBPP": ("accuracy_pct", 0.0),
         "MMLU": ("accuracy_pct", 25.0), "MATH": ("accuracy_pct", 0.0),
         "GSM8K": ("accuracy_pct", 0.0), "IFEval": ("accuracy_pct", 0.0),
         "HV": ("harmfulness_score", None)}
    for r in rd(p):
        op, combo, aim = r["operator"], r["combo"], r["aim"]
        is_base = op == "_base"
        role = "reference" if is_base else "merged"
        mid = r.get("repo_id") or f"aim:{op}|{combo}|aim{aim}"
        note = ("base / single-expert reference checkpoint" if is_base else
                ("with AIM (activation-informed merging applied post hoc)" if aim == "1"
                 else "without AIM (baseline merge)"))
        parents = "" if is_base else f"Llama-2 experts: {combo.replace('-', ' + ')}"
        for b, (metric, ch) in B.items():
            emit(mid, role, "Llama-2-7B (AIM release)", parents, f"aim={aim}",
                 "" if is_base else op, "aim_published_outcomes", b, metric, r.get(b), ch, None, ds,
                 note + (" | HV is a harmfulness score, not an accuracy" if b == "HV" else ""))

# =================================================================== 6. Goldfish CKA/NLL
def build_goldfish(d, ds):
    """Only the NLL columns are extrinsic evaluations; CKA is an intrinsic
    representation-similarity diagnostic and is deliberately excluded."""
    p = d / "results/cka_lastlayer.csv"
    if not p.exists(): return
    seen = set()
    for r in rd(p):
        mid = r["model"]
        if mid in seen: continue  # one row per model; the file repeats it per pooling
        seen.add(mid)
        arm = r.get("arm") or "reference"
        role = {"merged": "merged", "trained": "jointly_trained"}.get(arm, "reference")
        pair = r["pair"]; cfg = r["config"]
        parents = "" if role != "merged" else f"goldfish[{pair.split('_')[0]}]|goldfish[{pair.split('_')[1]}]"
        n = int(f(r.get("n")) or 0) or None
        note = (f"config={cfg}; arm={arm}. NLL only -- the CKA columns in the source are an "
                "intrinsic representation-similarity diagnostic and are not extrinsic evaluations.")
        if role == "jointly_trained":
            note += " 'trained' = a model trained directly on the mixture, the merge's comparator."
        for k, lbl in (("nll_a", f"held_out[{pair.split('_')[0]}]"),
                       ("nll_b", f"held_out[{pair.split('_')[1]}]"),
                       ("nll_mean", f"held_out[{pair}] mean")):
            emit(mid, role, f"Goldfish {pair}", parents,
                 f"alpha={r.get('alpha')},topk={r.get('topk')}", arm if role == "merged" else "",
                 "goldfish_crosslingual", lbl, "nats_per_token", r.get(k), None, n, ds,
                 note + " | LIKELIHOOD, not accuracy")

# =================================================================== 7. Beetle merges
def build_beetle(d, ds):
    """Beetle merge evaluations. The source already ships a long-format table whose
    columns line up almost exactly with this schema, so this is mostly a relabelling."""
    p = d / "beetle_merge_eval_long.csv"
    if not p.exists(): return
    src = rd(p)
    # a released model that some merge names as its ceiling is a jointly-trained comparator;
    # one named as a parent is a parent. Everything else is a plain reference.
    ceilings = {r["ceiling"] for r in src if r.get("ceiling")}
    parents_set = {r[k] for r in src for k in ("parent_a", "parent_b") if r.get(k)}
    for r in src:
        kind = r.get("kind")
        mid_base = r["merge_id"]
        rung, op, arm = r.get("rung", ""), r.get("operator", ""), r.get("arm", "")
        if kind == "merge":
            role = "merged"
            mid = f"{mid_base}#{rung}" if rung else mid_base
            parents = "|".join(x for x in (r.get("parent_a"), r.get("parent_b")) if x)
            note = (f"Beetle merge; arm={arm}; jointly-trained ceiling for this pair is "
                    f"{r.get('ceiling') or 'n/a'}; eval langs {r.get('eval_langs') or 'n/a'}")
        else:
            mid, parents = mid_base, ""
            if mid_base in ceilings:
                role, note = "jointly_trained", ("released bilingual model trained directly on the "
                                                "pair -- the ceiling a Beetle merge is judged against")
            elif mid_base in parents_set:
                role, note = "parent", "Beetle merge parent, evaluated alone"
            else:
                role, note = "reference", "Beetle reference model"
        bench, metric_in = r["benchmark"], r.get("metric")
        ch = f(r.get("chance"))
        if metric_in == "accuracy":
            # BLiSS accuracy is reported on 0-100, everything else on 0-1
            metric = "accuracy_pct" if (ch is not None and ch > 1) else "accuracy"
        else:
            bench, metric = f"{bench}:{metric_in}", "bliss_score"
            note += f" | BLiSS sub-score '{metric_in}', not an accuracy"
        emit(mid, role, r.get("provenance_family") or "beetle", parents, rung, op,
             "beetle_merge_eval", bench, metric, r.get("value"),
             ch if metric.startswith("accuracy") else ch, f(r.get("n")), ds, note)


# =================================================================== driver
BUILDERS = {"merge-accuracy": build_merge_accuracy, "compose-audit": build_compose_audit,
            "crossarch-1b": build_crossarch, "mergebench": build_mergebench,
            "aim": build_aim, "goldfish": build_goldfish, "beetle": build_beetle}

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--push", action="store_true")
    ap.add_argument("--no-fetch", action="store_true")
    a = ap.parse_args()

    from huggingface_hub import snapshot_download
    from huggingface_hub.errors import RepositoryNotFoundError
    tok = os.environ.get("HF_TOKEN")
    OUT.mkdir(parents=True, exist_ok=True)

    manifest = {"built_utc": datetime.datetime.now(datetime.timezone.utc)
                    .strftime("%Y-%m-%dT%H:%M:%SZ"), "sources": {}}

    for key, meta in SOURCES.items():
        repo = meta["repo"]; local = CACHE / key
        entry = {"repo": repo, "declared_status": meta["status"]}
        if not a.no_fetch:
            try:
                snapshot_download(repo, repo_type="dataset", local_dir=str(local), token=tok,
                                  allow_patterns=["*.csv", "*.json", "*.jsonl", "*.md"])
                entry["fetch"] = "ok"
            except RepositoryNotFoundError:
                entry["fetch"] = "not_published_yet"
                print(f"[skip] {repo} is not published yet", file=sys.stderr)
            except Exception as e:
                entry["fetch"] = f"error: {type(e).__name__}"
                print(f"[warn] {repo}: {e}", file=sys.stderr)
        else:
            entry["fetch"] = "ok" if local.exists() else "not_present"

        before = len(rows)
        fn = BUILDERS.get(key)
        if fn and entry["fetch"] == "ok" and local.exists():
            fn(local, repo)
        elif entry["fetch"] == "ok" and local.exists():
            data = [q for q in local.rglob("*")
                    if q.is_file() and q.suffix in (".csv", ".json", ".jsonl")
                    and ".cache" not in q.parts]
            if not data:
                print(f"[note] {repo} exists but ships no result files yet", file=sys.stderr)
                entry["note"] = "repo created but empty; re-run once it has results"
            else:
                print(f"[note] {repo} has {len(data)} result file(s) but no extractor -- "
                      f"add one and re-run", file=sys.stderr)
                entry["note"] = f"published with {len(data)} result file(s) but no extractor yet"
        entry["rows"] = len(rows) - before
        manifest["sources"][key] = entry

    # in-progress provenance flag in notes
    inprog = {SOURCES[k]["repo"] for k in SOURCES if SOURCES[k]["status"] == "in_progress"}
    for r in rows:
        if r["source_dataset"] in inprog:
            r["notes"] = ("IN PROGRESS -- this source dataset was still being written when this "
                          "file was built; treat as provisional. | " + r["notes"]).strip(" |")

    # ---- global dedupe: the same measurement on the same model must appear exactly once.
    # Several sources are resumable ledgers that re-report shared baseline rungs.
    seen, deduped, conflicts = {}, [], []
    KEY = ("source_dataset", "experiment", "model_id", "model_role", "rung", "operator",
           "benchmark", "metric")
    for r in rows:
        k = tuple(r[c] for c in KEY)
        if k in seen:
            # tolerate re-measurement jitter (different ledgers re-run the same eval and can
            # differ in the ~8th significant figure); flag only genuine disagreements
            if not math.isclose(seen[k]["value"], r["value"], rel_tol=1e-6, abs_tol=1e-9):
                conflicts.append({"key": list(k), "kept": seen[k]["value"], "dropped": r["value"]})
            continue
        seen[k] = r
        deduped.append(r)
    n_dropped = len(rows) - len(deduped)
    rows[:] = deduped
    print(f"dedupe: dropped {n_dropped} repeated measurements, {len(conflicts)} value conflicts")

    rows.sort(key=lambda r: (r["source_dataset"], r["experiment"], r["metric_kind"],
                             r["benchmark"], r["model_id"], r["metric"]))

    csv_p = OUT / "extrinsic_evaluations.csv"
    with open(csv_p, "w", newline="") as fh:
        w = csv.DictWriter(fh, fieldnames=NCOLS); w.writeheader(); w.writerows(rows)
    print(f"wrote {csv_p}  rows={len(rows)}")

    try:
        import pandas as pd
        df = pd.DataFrame(rows, columns=NCOLS)
        df["chance"] = pd.to_numeric(df["chance"], errors="coerce")
        df["n"] = pd.to_numeric(df["n"], errors="coerce").astype("Int64")
        df.to_parquet(OUT / "extrinsic_evaluations.parquet", index=False)
        print("wrote parquet")
    except Exception as e:
        print(f"[warn] parquet skipped: {e}", file=sys.stderr)

    from collections import Counter
    manifest["n_rows"] = len(rows)
    manifest["n_duplicate_measurements_dropped"] = n_dropped
    manifest["n_value_conflicts"] = len(conflicts)
    manifest["value_conflicts"] = conflicts[:200]
    manifest["by_experiment"] = dict(Counter(r["experiment"] for r in rows).most_common())
    manifest["by_metric_kind"] = dict(Counter(r["metric_kind"] for r in rows).most_common())
    manifest["by_metric"] = dict(Counter(r["metric"] for r in rows).most_common())
    manifest["by_source"] = dict(Counter(r["source_dataset"] for r in rows).most_common())
    manifest["by_role"] = dict(Counter(r["model_role"] for r in rows).most_common())
    manifest["accuracy_rows_missing_chance"] = sum(
        1 for r in rows if r["metric_kind"] == "accuracy" and r["chance"] == "")
    json.dump(manifest, open(OUT / "build_manifest.json", "w"), indent=2)
    print(json.dumps({k: manifest[k] for k in
        ("n_rows", "by_metric_kind", "accuracy_rows_missing_chance")}, indent=2))

    if a.push:
        from huggingface_hub import HfApi
        api = HfApi(token=tok)
        api.create_repo(TARGET_REPO, repo_type="dataset", exist_ok=True)
        for fn_ in ("extrinsic_evaluations.csv", "extrinsic_evaluations.parquet",
                    "build_manifest.json", "README.md"):
            fp = OUT / fn_
            if fp.exists():
                api.upload_file(path_or_fileobj=str(fp), path_in_repo=fn_,
                                repo_id=TARGET_REPO, repo_type="dataset")
                print("uploaded", fn_)
        api.upload_file(path_or_fileobj=__file__, path_in_repo="build_extrinsic.py",
                        repo_id=TARGET_REPO, repo_type="dataset")
        print("uploaded build_extrinsic.py")

if __name__ == "__main__":
    main()