Add RepoPeftBench corpus merge

Joins Code2LoRA's benchmark (~500K assertion-completion items over 512 repos)
to aligned6 (~27K prose QA over 2066 repos). The two are complementary: the
benchmark showed the head learns a repo's stack and conventions but not what the
project does, and exact-recall data is what addresses that.

Carries RepoPeftBench's own by-repo partition through unchanged, and lets an
eval assignment always win over a train one, so no repo can leak between train
and cross-repo eval. Caps QA per repo (evo alone has ~1000/repo) so the exact
recall task cannot swamp the prose QA.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

app/scripts/benchmark_repo.py

@@ -0,0 +1,321 @@
+#!/usr/bin/env python3
+"""Benchmark a generated adapter against the frozen base model on ONE repo.
+
+Builds the question set from the repo's ACTUAL contents (deps, test framework,
+packaging, layout, license, entry points) rather than hand-written guesses, so
+the gold answers are ground truth rather than opinion. Then scores base vs
+adapted on the same model instance, adapter toggled with `disable_adapter()`.
+
+Three task families, because an adapter can help one and hurt another -- which
+is exactly what happened here (QA improved hugely while raw-text modelling
+regressed), and a single number would have hidden it:
+
+  FACT   - "Q: <question>\\nA:" -> short factual answer. The trained format.
+  CODE   - completion of real lines taken from the repo's own source.
+  TEXT   - plain continuation of repo prose (README/docstrings).
+
+Metrics per family:
+  loss      teacher-forced cross-entropy on the gold answer (lower better)
+  win rate  fraction of items where adapted loss < base loss
+  keyword   fraction of greedy generations containing the gold keyword
+
+Usage:
+    python benchmark_repo.py --job <jobId> --checkpoint ../../runs/h200_run/head.best.pt
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+import numpy as np
+import torch
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE.parent / "engine"))
+import config  # noqa: E402
+from generate_and_merge import (TARGET_MODULES, load_head,  # noqa: E402
+                                _lora_modules_by_spec_name)
+from memory_lora.core import DEFAULT_ROOT_PREFIX, get_module_specs  # noqa: E402
+
+SKIP = {".git", "__pycache__", ".venv", "node_modules", "build", "dist", ".tox"}
+
+
+# --------------------------------------------------------------------------
+# Build the benchmark from repo ground truth
+# --------------------------------------------------------------------------
+
+def _read(p: Path, n: int = 20000) -> str:
+    try:
+        return p.read_text(errors="ignore")[:n]
+    except OSError:
+        return ""
+
+
+def build_fact_items(repo: Path) -> list[dict]:
+    """Derive Q/A pairs whose answers are verifiable from the repo itself."""
+    items: list[dict] = []
+    pyproject = _read(repo / "pyproject.toml")
+    setup_py = _read(repo / "setup.py")
+    setup_cfg = _read(repo / "setup.cfg")
+    build = pyproject + setup_py + setup_cfg
+
+    # packaging backend
+    if "setuptools" in build:
+        items.append(dict(q="What packaging tool does this project use?",
+                          a=" setuptools", kw="setuptools"))
+    elif "poetry" in build.lower():
+        items.append(dict(q="What packaging tool does this project use?",
+                          a=" poetry", kw="poetry"))
+    if "hatchling" in build:
+        items.append(dict(q="What build backend does this project declare?",
+                          a=" hatchling", kw="hatchling"))
+
+    # test framework
+    test_files = [p for p in repo.rglob("*.py")
+                  if not any(s in p.parts for s in SKIP)
+                  and ("test" in p.name.lower() or "tests" in p.parts)]
+    joined = " ".join(_read(p, 4000) for p in test_files[:12])
+    if "pytest" in joined or "pytest" in build:
+        items.append(dict(q="What testing framework does this repository use?",
+                          a=" pytest", kw="pytest"))
+    elif "unittest" in joined:
+        items.append(dict(q="What testing framework does this repository use?",
+                          a=" unittest", kw="unittest"))
+
+    # license
+    lic = _read(repo / "LICENSE") + _read(repo / "LICENSE.txt")
+    for name, key in (("Apache", "Apache"), ("MIT", "MIT"),
+                      ("BSD", "BSD"), ("GNU", "GPL")):
+        if name.lower() in lic.lower()[:400]:
+            items.append(dict(q="What license does this project use?",
+                              a=f" {key}", kw=key))
+            break
+
+    # top-level package
+    EXCL = {"tests", "test", "docs", "doc", "examples", "example", "scripts",
+            "benchmarks", "ext"}
+    pkgs = [d.name for d in repo.iterdir()
+            if d.is_dir() and (d / "__init__.py").exists()
+            and d.name not in SKIP and d.name.lower() not in EXCL]
+    if pkgs:
+        # Prefer the package named after the repo (src/<name> layouts included).
+        best = next((k for k in pkgs if k.lower() == repo.name.lower()), pkgs[0])
+        items.append(dict(q="What is the name of the main Python package in this repository?",
+                          a=f" {best}", kw=best))
+
+    # dependencies
+    # Parse only INSIDE a dependency list, otherwise setup.py keywords such as
+    # `install_requires=` / `python_requires=` get matched as package names.
+    dep_block = ""
+    for pat in (r"install_requires\s*=\s*\[(.*?)\]",
+                r"dependencies\s*=\s*\[(.*?)\]",
+                r"\[project\.dependencies\](.*?)(?:\n\[|\Z)"):
+        m = re.search(pat, build, re.S)
+        if m:
+            dep_block = m.group(1)
+            break
+    NOT_PKG = {"python", "name", "version", "requires", "install", "extras",
+               "setup", "packages", "classifiers"}
+    deps = re.findall(r"['\"]([A-Za-z][A-Za-z0-9_.-]{2,})\s*[><=~!\[]", dep_block)
+    deps = [d for d in deps if d.lower() not in NOT_PKG]
+    if deps:
+        items.append(dict(q="Name a runtime dependency of this project.",
+                          a=f" {deps[0]}", kw=deps[0]))
+
+    # CI
+    ci = list((repo / ".github" / "workflows").glob("*.y*ml")) if (repo / ".github" / "workflows").exists() else []
+    if ci:
+        items.append(dict(q="What CI system does this repository use?",
+                          a=" GitHub Actions", kw="GitHub Actions"))
+
+    # docs
+    if (repo / "docs").is_dir():
+        conf = _read(repo / "docs" / "conf.py")
+        if "sphinx" in conf.lower() or (repo / "docs" / "conf.py").exists():
+            items.append(dict(q="What documentation tool does this project use?",
+                              a=" Sphinx", kw="Sphinx"))
+    return items
+
+
+def build_code_items(repo: Path, n: int = 12) -> list[dict]:
+    """Split real source lines: prefix -> the rest of the line."""
+    items: list[dict] = []
+    srcs = [p for p in repo.rglob("*.py")
+            if not any(s in p.parts for s in SKIP)
+            and "test" not in p.name.lower()]
+    for p in srcs[:40]:
+        text = _read(p, 12000)
+        lines = [l for l in text.splitlines()
+                 if 30 < len(l) < 110 and not l.strip().startswith("#")
+                 and ("(" in l or "=" in l or "import" in l)]
+        for l in lines[:2]:
+            cut = max(len(l) // 2, l.find("(") + 1 if "(" in l else len(l) // 2)
+            prefix, target = l[:cut], l[cut:]
+            if len(target.strip()) < 4:
+                continue
+            items.append(dict(prefix=f"# file: {p.name}\n{prefix}", target=target))
+            if len(items) >= n:
+                return items
+    return items
+
+
+def build_text_items(repo: Path, n: int = 6) -> list[dict]:
+    items: list[dict] = []
+    for name in ("README.md", "README.rst", "HISTORY.md", "CHANGELOG.md"):
+        t = _read(repo / name, 6000)
+        if len(t) < 600:
+            continue
+        chunks = [c for c in t.split("\n\n") if len(c) > 200][:3]
+        for c in chunks:
+            half = len(c) // 2
+            items.append(dict(prefix=c[:half], target=c[half:half + 300]))
+            if len(items) >= n:
+                return items
+    return items
+
+
+# --------------------------------------------------------------------------
+# Scoring
+# --------------------------------------------------------------------------
+
+@torch.no_grad()
+def item_loss(model, tok, prefix: str, target: str, device: str) -> float:
+    pid = tok(prefix, add_special_tokens=False)["input_ids"]
+    tid = tok(target, add_special_tokens=False)["input_ids"]
+    if not tid or not pid:
+        return float("nan")
+    ids = torch.tensor([pid + tid], device=device)
+    labels = torch.tensor([[-100] * len(pid) + tid], device=device)
+    return float(model(input_ids=ids, labels=labels).loss)
+
+
+@torch.no_grad()
+def generate(model, tok, prompt: str, device: str, max_new: int = 24) -> str:
+    enc = tok(prompt, return_tensors="pt").to(device)
+    out = model.generate(**enc, max_new_tokens=max_new, do_sample=False,
+                         pad_token_id=tok.pad_token_id or tok.eos_token_id)
+    return tok.decode(out[0][enc["input_ids"].shape[1]:],
+                      skip_special_tokens=True).split("\n")[0]
+
+
+def run_family(model, tok, items, device, name, generate_kw=False):
+    rows = []
+    for it in items:
+        prefix = it.get("prefix") or f"Q: {it['q']}\nA:"
+        target = it.get("target") or it["a"]
+        with model.disable_adapter():
+            lb = item_loss(model, tok, prefix, target, device)
+            gb = generate(model, tok, prefix, device) if generate_kw else ""
+        la = item_loss(model, tok, prefix, target, device)
+        ga = generate(model, tok, prefix, device) if generate_kw else ""
+        rows.append(dict(prefix=prefix, target=target, kw=it.get("kw", ""),
+                         base=lb, adapted=la, gen_base=gb, gen_adapted=ga))
+    valid = [r for r in rows if not (np.isnan(r["base"]) or np.isnan(r["adapted"]))]
+    if not valid:
+        return None
+    mb = float(np.mean([r["base"] for r in valid]))
+    ma = float(np.mean([r["adapted"] for r in valid]))
+    wins = sum(1 for r in valid if r["adapted"] < r["base"])
+    out = dict(family=name, n=len(valid), base=mb, adapted=ma,
+               delta=ma - mb, win_rate=wins / len(valid))
+    if generate_kw:
+        kb = sum(1 for r in valid if r["kw"] and r["kw"].lower() in r["gen_base"].lower())
+        ka = sum(1 for r in valid if r["kw"] and r["kw"].lower() in r["gen_adapted"].lower())
+        nk = sum(1 for r in valid if r["kw"])
+        out["kw_base"] = kb / max(nk, 1)
+        out["kw_adapted"] = ka / max(nk, 1)
+        out["nk"] = nk
+    return out, rows
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--job", required=True)
+    ap.add_argument("--checkpoint", default=str(config.DEFAULT_CHECKPOINT))
+    ap.add_argument("--device", default="cpu")
+    ap.add_argument("--show-generations", action="store_true")
+    args = ap.parse_args()
+
+    from peft import LoraConfig, get_peft_model
+    from transformers import AutoModelForImageTextToText, AutoTokenizer
+
+    ws = config.workspace(args.job)
+    repo = ws / "repo"
+    if not repo.exists():
+        print(f"repo clone missing at {repo}", file=sys.stderr)
+        sys.exit(1)
+    repo_url = json.loads((ws / "status.json").read_text()).get("repo_url", "?")
+    emb = np.load(ws / "embedding.npy").astype("float32")
+    device = config.resolve_device(args.device)
+
+    facts = build_fact_items(repo)
+    codes = build_code_items(repo)
+    texts = build_text_items(repo)
+    print(f"repo:       {repo_url}")
+    print(f"checkpoint: {args.checkpoint}")
+    print(f"benchmark:  {len(facts)} FACT, {len(codes)} CODE, {len(texts)} TEXT items\n",
+          flush=True)
+
+    head, cfg, alpha = load_head(Path(args.checkpoint))
+    with torch.no_grad():
+        head_out = head(torch.from_numpy(emb).unsqueeze(0))
+
+    tok = AutoTokenizer.from_pretrained(config.BASE_MODEL)
+    if tok.pad_token is None:
+        tok.pad_token = tok.eos_token
+    base = AutoModelForImageTextToText.from_pretrained(
+        config.BASE_MODEL, torch_dtype=torch.float32, low_cpu_mem_usage=True)
+    specs = get_module_specs(base, TARGET_MODULES, root_prefix=DEFAULT_ROOT_PREFIX)
+    type_of = {s.full_name: s.type for s in specs}
+    model = get_peft_model(base, LoraConfig(
+        r=cfg["rank"], lora_alpha=alpha,
+        target_modules=[s.full_name for s in specs], lora_dropout=0.0, bias="none"))
+    mods = _lora_modules_by_spec_name(model)
+    with torch.no_grad():
+        for sp in specs:
+            m = mods.get(sp.full_name)
+            if m is None:
+                continue
+            t = type_of[sp.full_name]
+            m.lora_A["default"].weight.copy_(head_out["A"][t][0].float())
+            m.lora_B["default"].weight.copy_(head_out["B"][t][0].float())
+    model.to(device)
+    model.eval()
+
+    results = []
+    all_rows = {}
+    for items, name, gk in ((facts, "FACT", True), (codes, "CODE", False),
+                            (texts, "TEXT", False)):
+        if not items:
+            continue
+        r = run_family(model, tok, items, device, name, generate_kw=gk)
+        if r:
+            res, rows = r
+            results.append(res)
+            all_rows[name] = rows
+
+    print(f"{'family':<7} {'n':>3} {'base':>8} {'adapted':>8} {'delta':>9} {'win%':>6}")
+    print("-" * 46)
+    for r in results:
+        print(f"{r['family']:<7} {r['n']:>3} {r['base']:>8.4f} {r['adapted']:>8.4f} "
+              f"{r['delta']:>+9.4f} {100*r['win_rate']:>5.0f}%")
+    for r in results:
+        if "kw_base" in r:
+            print(f"\nFACT keyword accuracy over {r['nk']} verifiable answers:")
+            print(f"  base    {100*r['kw_base']:.0f}%")
+            print(f"  adapted {100*r['kw_adapted']:.0f}%")
+
+    if args.show_generations and "FACT" in all_rows:
+        print("\n--- FACT generations ---")
+        for row in all_rows["FACT"]:
+            q = row["prefix"].replace("Q: ", "").replace("\nA:", "")
+            print(f"Q: {q}\n  gold:    {row['target'].strip()}")
+            print(f"  base:    {row['gen_base'].strip()[:110]}")
+            print(f"  adapted: {row['gen_adapted'].strip()[:110]}\n")
+
+
+if __name__ == "__main__":
+    main()

app/scripts/test_repo_qa.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+"""Test a generated adapter the way it was TRAINED: repo Q&A.
+
+`diagnose_head.py` scores raw repo text, which is the wrong distribution for a
+head trained on "Q: <question>\\nA:" -> answer. It is the right tool for
+detecting an adapter that is inert or collapsed (bad at everything), but a
+working head specializes on the QA format and can look worse on plain text
+while being dramatically better at the task it was trained for.
+
+This scores the trained format, on the same model instance, adapter on vs off:
+  * loss on held-out QA pairs for the repo (if the repo is in the corpus)
+  * greedy generations for hand-written questions, base vs adapted
+
+Usage:
+    python test_repo_qa.py --job <jobId> --checkpoint ../../runs/h200_run/head.best.pt
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import torch
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE.parent / "engine"))
+import config  # noqa: E402
+from generate_and_merge import (TARGET_MODULES, load_head,  # noqa: E402
+                                _lora_modules_by_spec_name)
+from memory_lora.core import DEFAULT_ROOT_PREFIX, get_module_specs  # noqa: E402
+
+QUESTIONS = [
+    "What is the core purpose of this repository?",
+    "What is the main entry point or primary public API of this project?",
+    "How is this project's source code organized?",
+    "What testing framework and conventions does this repository use?",
+    "How is this project built, packaged, or deployed?",
+]
+
+
+@torch.no_grad()
+def gen(model, tok, prompt: str, device: str, max_new: int = 40) -> str:
+    enc = tok(prompt, return_tensors="pt").to(device)
+    out = model.generate(**enc, max_new_tokens=max_new, do_sample=False,
+                         pad_token_id=tok.pad_token_id or tok.eos_token_id)
+    txt = tok.decode(out[0][enc["input_ids"].shape[1]:], skip_special_tokens=True)
+    return txt.split("\nQ:")[0].strip()
+
+
+@torch.no_grad()
+def qa_loss(model, tok, pairs, device: str) -> float:
+    tot, ntok = 0.0, 0
+    for p in pairs:
+        prefix, target = p["prefix"], p["target"]
+        pid = tok(prefix, add_special_tokens=False)["input_ids"]
+        tid = tok(target, add_special_tokens=False)["input_ids"]
+        if not tid:
+            continue
+        ids = torch.tensor([pid + tid], device=device)
+        labels = torch.tensor([[-100] * len(pid) + tid], device=device)
+        out = model(input_ids=ids, labels=labels)
+        n = len(tid)
+        tot += float(out.loss) * n
+        ntok += n
+    return tot / max(ntok, 1)
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--job", required=True)
+    ap.add_argument("--checkpoint", default=str(config.DEFAULT_CHECKPOINT))
+    ap.add_argument("--qna-path", default="data/qna/aligned6_qna.jsonl")
+    ap.add_argument("--device", default="cpu")
+    ap.add_argument("--max-qa", type=int, default=20)
+    args = ap.parse_args()
+
+    from peft import LoraConfig, get_peft_model
+    from transformers import AutoModelForImageTextToText, AutoTokenizer
+
+    ws = config.workspace(args.job)
+    emb = np.load(ws / "embedding.npy").astype("float32")
+    repo_url = json.loads((ws / "status.json").read_text()).get("repo_url", "?")
+    device = config.resolve_device(args.device)
+
+    head, cfg, alpha = load_head(Path(args.checkpoint))
+    with torch.no_grad():
+        head_out = head(torch.from_numpy(emb).unsqueeze(0))
+
+    print(f"repo: {repo_url}\ncheckpoint: {args.checkpoint}\n", flush=True)
+    tok = AutoTokenizer.from_pretrained(config.BASE_MODEL)
+    if tok.pad_token is None:
+        tok.pad_token = tok.eos_token
+    base = AutoModelForImageTextToText.from_pretrained(
+        config.BASE_MODEL, torch_dtype=torch.float32, low_cpu_mem_usage=True)
+    specs = get_module_specs(base, TARGET_MODULES, root_prefix=DEFAULT_ROOT_PREFIX)
+    type_of = {s.full_name: s.type for s in specs}
+    model = get_peft_model(base, LoraConfig(
+        r=cfg["rank"], lora_alpha=alpha,
+        target_modules=[s.full_name for s in specs],
+        lora_dropout=0.0, bias="none"))
+    mods = _lora_modules_by_spec_name(model)
+    with torch.no_grad():
+        for sp in specs:
+            m = mods.get(sp.full_name)
+            if m is None:
+                continue
+            t = type_of[sp.full_name]
+            m.lora_A["default"].weight.copy_(head_out["A"][t][0].float())
+            m.lora_B["default"].weight.copy_(head_out["B"][t][0].float())
+    model.to(device)
+    model.eval()
+
+    # 1. Held-out QA loss in the trained format, if this repo is in the corpus.
+    doc_id = repo_url.replace("https://github.com/", "").rstrip("/")
+    pairs = []
+    qp = Path(args.qna_path)
+    if qp.exists():
+        with open(qp) as f:
+            for line in f:
+                d = json.loads(line)
+                if d.get("doc_id") == doc_id:
+                    pairs.append(d)
+                    if len(pairs) >= args.max_qa:
+                        break
+    if pairs:
+        with model.disable_adapter():
+            lb = qa_loss(model, tok, pairs, device)
+        la = qa_loss(model, tok, pairs, device)
+        print(f"QA loss on {len(pairs)} pairs (the TRAINED format):")
+        print(f"  base    {lb:.4f}")
+        print(f"  adapted {la:.4f}   delta {la-lb:+.4f}  "
+              f"{'HELPS' if la < lb else 'HURTS'}\n", flush=True)
+    else:
+        print(f"(no QA rows for doc_id '{doc_id}' — generation comparison only)\n",
+              flush=True)
+
+    # 2. Generation comparison.
+    for q in QUESTIONS:
+        prompt = f"Q: {q}\nA:"
+        with model.disable_adapter():
+            b = gen(model, tok, prompt, device)
+        a = gen(model, tok, prompt, device)
+        print(f"Q: {q}")
+        print(f"  base:    {b[:200]}")
+        print(f"  adapted: {a[:200]}\n", flush=True)
+
+
+if __name__ == "__main__":
+    main()

runs/h200_best/head.best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:48804c71508e1d96381b33acf0a331237a9ba2c5f2a2e1dd6759ae5212ac4f31
+size 3001716868

scripts/merge_repopeft_corpus.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""Merge RepoPeftBench (Code2LoRA's own benchmark) into the aligned6 corpus.
+
+RepoPeftBench contributes ~500K *assertion-completion* items over 512 repos --
+short, exact code targets. aligned6 contributes ~27K *prose* QA over 2066 repos
+-- conventions and architecture. They are complementary: the benchmark run
+showed the head learns a repo's stack and conventions but not what it actually
+does, and exact-recall data is what addresses that.
+
+Split integrity is the thing to get right. A repo must never appear in both a
+training split and an eval split, or cross-repo evaluation becomes meaningless.
+RepoPeftBench already partitions BY REPO (cr_val / cr_test hold out whole
+repositories), so we carry its partition through unchanged and only ever add
+repos to `train` when the benchmark itself calls them training repos.
+
+    doc split   : which repos the hypernetwork trains on (train/cr_val/cr_test)
+    qna_split   : within a train repo, held-out QA for in-repo eval (ir_*)
+
+Usage:
+    python scripts/merge_repopeft_corpus.py \
+        --repopeft-emb data/embeddings/repopeft_6view.parquet \
+        --out-emb data/embeddings/all_lora_embeddings.parquet \
+        --out-qna data/qna/all_lora_qna.jsonl
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections import Counter, defaultdict
+from pathlib import Path
+
+import pyarrow.parquet as pq
+
+HERE = Path(__file__).resolve().parent
+REPO_ROOT = HERE.parent
+sys.path.insert(0, str(REPO_ROOT))
+
+# file stem -> (doc split contributed, qna_split)
+# cr_* hold out whole repos; ir_* are held-out QA of repos that stay in train.
+SPLIT_MAP = {
+    "train": ("train", "train"),
+    "cr_val": ("cr_val", "train"),
+    "cr_test": ("cr_test", "train"),
+    "ir_val": ("train", "held_out"),
+    "ir_test": ("train", "held_out"),
+}
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--repopeft-emb", default="data/embeddings/repopeft_6view.parquet")
+    ap.add_argument("--aligned-emb", default="data/embeddings/aligned6_embeddings.parquet")
+    ap.add_argument("--aligned-qna", default="data/qna/aligned6_qna.jsonl")
+    ap.add_argument("--repopeft-glob", default="data/real_code2lora/*/qna/*.parquet")
+    ap.add_argument("--out-emb", default="data/embeddings/all_lora_embeddings.parquet")
+    ap.add_argument("--out-qna", default="data/qna/all_lora_qna.jsonl")
+    ap.add_argument("--max-qna-per-repo", type=int, default=400,
+                    help="cap per repo: evo alone has ~1000/repo, which would "
+                         "swamp the prose QA and bias the head toward one task")
+    ap.add_argument("--max-target-chars", type=int, default=400)
+    args = ap.parse_args()
+
+    import glob as _glob
+    import pyarrow as pa
+
+    # ---------------- embeddings ----------------
+    ali = pq.read_table(args.aligned_emb)
+    ali_dim = len(ali.column("doc_embedding")[0].as_py())
+    print(f"aligned6:  {ali.num_rows} repos, dim {ali_dim}")
+
+    rp_path = Path(args.repopeft_emb)
+    if not rp_path.exists():
+        print(f"!! missing {rp_path} -- run build_repo_multiview.py first",
+              file=sys.stderr)
+        sys.exit(1)
+    rp = pq.read_table(rp_path)
+    rp_dim = len(rp.column("doc_embedding")[0].as_py())
+    print(f"repopeft:  {rp.num_rows} repos, dim {rp_dim}")
+    if rp_dim != ali_dim:
+        print(f"!! dim mismatch {rp_dim} != {ali_dim}; the head cannot consume both",
+              file=sys.stderr)
+        sys.exit(1)
+
+    # Which split does each RepoPeftBench repo belong to? Derived from the QA
+    # files it appears in, so we inherit the benchmark's own repo partition.
+    repo_split: dict[str, str] = {}
+    for f in sorted(_glob.glob(args.repopeft_glob)):
+        stem = Path(f).stem
+        if stem not in SPLIT_MAP:
+            continue
+        doc_split, _ = SPLIT_MAP[stem]
+        ids = set(pq.read_table(f, columns=["repo_id"]).column("repo_id").to_pylist())
+        for r in ids:
+            # An eval assignment always wins: if a repo is used to hold out
+            # cross-repo performance anywhere, it must never be trained on.
+            if repo_split.get(r) in ("cr_val", "cr_test"):
+                continue
+            repo_split[r] = doc_split
+
+    rp_ids = rp.column("doc_id").to_pylist()
+    rp_embs = rp.column("doc_embedding").to_pylist()
+    ali_ids = set(ali.column("doc_id").to_pylist())
+
+    out_ids, out_ver, out_split, out_cat, out_emb = [], [], [], [], []
+    for c, col in (("doc_id", out_ids), ("doc_version", out_ver),
+                   ("split", out_split), ("category", out_cat)):
+        if c in ali.column_names:
+            col.extend(ali.column(c).to_pylist())
+        else:
+            col.extend(["v1"] * ali.num_rows if c == "doc_version"
+                       else ["aligned6"] * ali.num_rows)
+    out_emb.extend(ali.column("doc_embedding").to_pylist())
+
+    added = 0
+    for rid, emb in zip(rp_ids, rp_embs):
+        if rid in ali_ids:            # already covered by aligned6
+            continue
+        sp = repo_split.get(rid)
+        if sp is None:                # embedded but no QA -> useless
+            continue
+        out_ids.append(rid)
+        out_ver.append("head")
+        out_split.append(sp)
+        out_cat.append("repopeftbench")
+        out_emb.append(emb)
+        added += 1
+    print(f"merged embeddings: {len(out_ids)} repos (+{added} from RepoPeftBench)")
+    print("  split counts:", dict(Counter(out_split)))
+
+    pq.write_table(pa.table({
+        "doc_id": out_ids, "doc_version": out_ver, "split": out_split,
+        "category": out_cat, "doc_embedding": out_emb,
+    }), args.out_emb)
+
+    # ---------------- QA ----------------
+    have_emb = set(out_ids)
+    split_of = dict(zip(out_ids, out_split))
+    per_repo: dict[str, int] = defaultdict(int)
+    n_written = 0
+    src_counts: Counter = Counter()
+
+    with open(args.out_qna, "w") as out:
+        # aligned6 first, verbatim
+        with open(args.aligned_qna) as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                out.write(line + "\n")
+                n_written += 1
+                src_counts["aligned6"] += 1
+
+        for f in sorted(_glob.glob(args.repopeft_glob)):
+            stem = Path(f).stem
+            if stem not in SPLIT_MAP:
+                continue
+            _, qna_split = SPLIT_MAP[stem]
+            t = pq.read_table(f, columns=["repo_id", "prefix", "target"])
+            rid_c = t.column("repo_id").to_pylist()
+            pre_c = t.column("prefix").to_pylist()
+            tgt_c = t.column("target").to_pylist()
+            kept = 0
+            for rid, pre, tgt in zip(rid_c, pre_c, tgt_c):
+                if rid not in have_emb:
+                    continue
+                if not pre or not tgt:
+                    continue
+                if len(tgt) > args.max_target_chars:
+                    continue
+                if per_repo[rid] >= args.max_qna_per_repo:
+                    continue
+                per_repo[rid] += 1
+                out.write(json.dumps({
+                    "doc_id": rid,
+                    "doc_version": "head",
+                    "split": split_of[rid],
+                    "qna_split": qna_split,
+                    "question": "",
+                    "prefix": pre,
+                    "target": tgt,
+                }) + "\n")
+                kept += 1
+                n_written += 1
+            src_counts[Path(f).parent.parent.name + "/" + stem] += kept
+
+    print(f"\nmerged QA: {n_written} rows -> {args.out_qna}")
+    for k, v in src_counts.most_common():
+        print(f"  {k:<34} {v}")
+    print(f"\nrepos with QA: {len(per_repo)}")
+
+
+if __name__ == "__main__":
+    main()