Remove bad duplicated upload directories

VERIFICATION-DOSSIER-PUBLIC.md/VERIFICATION-DOSSIER-PUBLIC.md

@@ -1,62 +0,0 @@
-# Verification dossier — public summary
-
-This is the public part of RE-Lab's verification dossier for `binary-reasoning-v1`. The full buyer-ready version adds procurement, provenance tables, calibration plans, and delivery details. Contact: samueljanttila@gmail.com.
-
-**Dataset:** https://huggingface.co/datasets/S3RL4/binary-reasoning-v1  
-**Self-serve sample kit:** `verification_kit/README.md` in this dataset repo  
-**Canary for contamination checks:** `RE-Lab-brv-2026-10-29-8c1e4f7a`
-
-## What is verified now
-
-### 1. Pack counts and grader split
-The full pack contains `10,251` items:
-- `10,172` deterministic-graded items.
-- `79` rubric-judged open-ended items, disclosed rather than sold as deterministic.
-
-The public sample includes 9 free items and a 100-item open sample in the Prime environment package. The sample kit skips rubric-judged items instead of pretending they are deterministic.
-
-### 2. Grader sanity checks
-On the 100-item open sample, the public sample kit reports:
-- `gold.py`: deterministic gold replies pass `84/84`; `16` judge items skipped.
-- `do_nothing.py`: empty answers score `0` on all `84` deterministic items.
-- `random_wrong.py`: deterministic mutated wrong answers score `0` on all `84` deterministic items.
-- `grader_tamper.py`: mutating the answer key makes the original gold reply fail on all `84` deterministic items.
-- `leak_check.py`: `items=100 unique_ids=100 checked_rows=73 leaks=0`.
-
-On the 9-item free sample:
-- deterministic sanity checks pass `4/4`; `5` judge items skipped.
-- `leak_check.py`: `items=9 unique_ids=9 checked_rows=3 leaks=0`.
-
-### 3. Answer-leak audit
-The existing full-pack answer-token audit reports `0/10,251` exact-token leaks. The public sample script is a smaller reproduction tool and reports checked-row coverage (`73/100` checkable rows on the open sample; `3/9` on the free sample). It does not replace the full-pack audit.
-
-### 4. Agentic environments
-The public agentic tier has `29` Harbor-format flag-hunt environments. The Docker reward chain was tested with gold answers and wrong-answer tests, and each binary was checked with 24 single-character mutations that scored zero. In the JSONL/verifiers path, the deterministic grader checks whether the stored flag appears in the reply as a substring; that is weaker than the Harbor oracle.
-
-### 5. Hard-trial reproduction evidence
-The 99-item hard trial pack has 19 family-level reproduction scripts in RE-Lab's pinned Ubuntu 24.04/WSL2 and Windows test environment. They reproduce `99/99` gold answers without reading the `answer` field. About `77` rows are command/binary re-execution (reproducibility, not an independent solve); about `22` rows use static ELF/PE/argv-derived reasoning. No human solved these tasks.
-
-### 6. Calibration evidence so far
-The public agentic tier is intentionally warm-up level for a frontier agent: Claude Opus 5.5 solved `29/29` environments and `145/145` attempts in a non-isolated host run with Bash/Read tools, graded by the binary oracle.
-
-A separate local open-weight calibration run on the 99-item hard trial pack scored `14/99` at pass@8:
-- model: `qwen3.8-flash-next-iq3_s`, 3-bit quantized;
-- single-turn, no tools;
-- temperature `0.7`, `max_tokens=600`, with a `reasoning_content` fallback;
-- whole-reply normalized matching rather than each item's verifier rule.
-
-That is headroom evidence, not a published band table or proof that each task sits in the RL mid-band. Per-buyer model calibration is part of the paid pilot path.
-
-## Known limitations and caveats
-- Current deterministic graders can accept some "shotgun" replies that contain the correct token among many distractors. A dedicated `shotgun.py` probe is a planned kit addition.
-- Some hard-trial reproduction scripts are environment-bound: they depend on local paths, WSL/Windows tools, pinned package digests, or host-specific loader behavior. They are evidence, not yet a portable buyer-runnable solver suite.
-- Some shipped artifact sets include grader-side metadata or unstripped twins that could reveal an answer if mounted to the model. A model-visible vs grader-only manifest is needed before selling sealed evaluation as fully isolated.
-- The full-pack public exposure window was 2026-10-28 22:02 → 2026-10-29 17:08 UTC, then older public versions were deleted. Deletion reduces future access but does not prove no copies exist.
-- The full pack uses production distro binaries with per-item provenance (`binary` path + `sha256_16`, plus address/size/architecture where applicable). A source-offer manifest lists `649` distinct third-party file names; upstream package/source mapping is a procurement follow-up for any redistribution-heavy order.
-
-## What this does not claim
-- It does not claim human or expert hand-checking of every task.
-- It does not claim every task is model-solvable without tools.
-- It does not claim the deterministic graders reject all low-effort answers.
-- It does not claim the hard trial pack has a published pass-rate band for every task yet.
-Add public verification summary

environment/src/binary_reasoning_v1/grading.py/environment/src/binary_reasoning_v1/grading.py

@@ -1,115 +0,0 @@
-"""Deterministic grading for binary-reasoning-v1 items. Pure functions, no framework deps."""
-import json
-import re
-
-JUDGE_FAMILIES = {"func_summary", "arch_semantics_qa", "isa_semantics_qa", "pe_import_reasoning", "pe_structure_qa"}
-
-
-def norm_symbol(s: str) -> str:
-    s = s.strip().lower()
-    s = re.sub(r"^[*&]+", "", s)
-    s = re.sub(r"\(.*\)$", "", s).strip()
-    s = re.sub(r"\.+$", "", s)  # sentence-final dot captured by token regex
-    return s
-
-
-def _answer_symbol(answer) -> str:
-    if isinstance(answer, dict):
-        return answer.get("symbol", "")
-    return str(answer)
-
-
-def grade_func_id_exact(reply: str, answer) -> float:
-    sym = norm_symbol(_answer_symbol(answer))
-    if not sym:
-        return 0.0
-    accepted = {sym}
-    if isinstance(answer, dict):
-        accepted |= {norm_symbol(a) for a in answer.get("aliases", []) if a}
-    toks = [norm_symbol(t) for t in re.findall(r"[A-Za-z_][A-Za-z0-9_.]+", reply)]
-    return 1.0 if accepted & set(toks) else 0.0
-
-
-def grade_func_id_mc(reply: str, answer: dict) -> float:
-    correct = answer.get("correct", "")
-    opts = answer.get("options", [])
-    r = reply.strip()
-    m = re.search(r"\b([A-D])\b", r[:80], re.IGNORECASE)
-    if m:
-        idx = ord(m.group(1).upper()) - 65
-        if 0 <= idx < len(opts):
-            return float(norm_symbol(opts[idx]) == norm_symbol(correct))
-    names = [norm_symbol(o) for o in re.findall(r"[A-Za-z_][A-Za-z0-9_.]{3,}", r.lower())]
-    return 1.0 if norm_symbol(correct) in names else 0.0
-
-
-def grade_tcfp(reply: str, answer: dict) -> float:
-    strs = answer.get("toolchain_strings", [])
-    if not strs:
-        return 0.0
-    hits = sum(1 for s in strs if s.lower() in reply.lower())
-    return hits / len(strs)
-
-
-def needs_judge(family: str, answer) -> bool:
-    if family in JUDGE_FAMILIES:
-        return True
-    if family == "func_id_exact":
-        sym = _answer_symbol(answer)
-        # descriptive/inferred answers (contain prose) cannot be string-matched
-        return (" " in sym.strip()) or ("inferred" in sym.lower())
-    return False
-
-
-def grade_agentic(reply: str, answer) -> float:
-    flag = _answer_symbol(answer)
-    return 1.0 if flag and flag in reply else 0.0
-
-
-def grade_crossarch(reply: str, answer) -> float:
-    if isinstance(answer, str):
-        try:
-            answer = json.loads(answer)
-        except Exception:
-            answer = {"same": "true" in answer.lower(),
-                      "symbol": re.sub(r'.*?"symbol"\s*:\s*"([^"]+)".*', r"\1", answer) if '"symbol"' in answer else ""}
-    want = bool(answer.get("same"))
-    r = reply.lower()
-    neg = bool(re.search(r"\bnot\s+(the\s+)?same\b|\bdifferent\b|\bno\b", r))
-    pos = not neg and bool(re.search(r"\bsame\b|\byes\b|\btrue\b|match", r))
-    if not (neg or pos):
-        return 0.0  # abstention / no clear stance
-    if pos != want:
-        return 0.0
-    if want:
-        sym = norm_symbol(answer.get("symbol", ""))
-        toks = [norm_symbol(t) for t in re.findall(r"[A-Za-z_][A-Za-z0-9_.]+", reply)]
-        if sym not in toks:
-            return 0.0
-    return 1.0
-
-
-def grade_library_ident(reply: str, answer) -> float:
-    ans = _answer_symbol(answer)
-    toks = [t for t in re.split(r"\s+", ans) if len(t) >= 2]
-    r = reply.lower()
-    return 1.0 if all(t.lower() in r for t in toks) else 0.0
-
-
-def grade_item(family: str, reply: str, answer) -> float:
-    if needs_judge(family, answer):
-        return 0.0  # handled by rubric judge in taskset.py
-    if family == "library_ident":
-        return grade_library_ident(reply, answer)
-    if family == "crossarch_equivalence":
-        return grade_crossarch(reply, answer)
-    if family == "agentic_flag_hunt":
-        return grade_agentic(reply, answer)
-    if family == "func_id_exact":
-        return grade_func_id_exact(reply, answer)
-    if family == "func_id_mc":
-        return grade_func_id_mc(reply, answer)
-    if family == "toolchain_fp":
-        return grade_tcfp(reply, answer)
-    return 0.0
-Add grader module used by verification kit

verification_kit/README.md/verification_kit/README.md

@@ -1,53 +0,0 @@
-# Verification kit — sample-level checks
-
-This small kit lets a buyer's researcher sanity-check the grader and answer hygiene without trusting RE-Lab. It runs on the public sample JSONL files; it does not require the paid full pack. The grader scripts import `binary_reasoning_v1.grading` from `environment/src/binary_reasoning_v1/grading.py` (`leak_check.py` does not), so include that file (or the Prime environment package) when downloading just the free sample.
-
-## Run it
-
-From the dataset root:
-
-```bash
-python verification_kit/gold.py sample_free.jsonl
-python verification_kit/do_nothing.py sample_free.jsonl
-python verification_kit/random_wrong.py sample_free.jsonl
-python verification_kit/leak_check.py sample_free.jsonl
-python verification_kit/grader_tamper.py sample_free.jsonl
-```
-
-If the 100-item open sample is present locally, point the same scripts at it:
-
-```bash
-python verification_kit/gold.py environment/src/binary_reasoning_v1/items.jsonl
-python verification_kit/do_nothing.py environment/src/binary_reasoning_v1/items.jsonl
-python verification_kit/random_wrong.py environment/src/binary_reasoning_v1/items.jsonl
-python verification_kit/leak_check.py environment/src/binary_reasoning_v1/items.jsonl
-python verification_kit/grader_tamper.py environment/src/binary_reasoning_v1/items.jsonl
-```
-
-## What each script checks
-
-| Script | What it does | Expected result |
-|---|---|---|
-| `gold.py` | Builds a reply from the stored answer and grades it. | Deterministic items score `1.0`; rubric-judged items are skipped, not silently graded. |
-| `do_nothing.py` | Grades an empty reply. | Deterministic items score `0`. |
-| `random_wrong.py` | Builds a deterministic mutated wrong reply and grades it. | Deterministic items score `0`. It is not stochastic random guessing. |
-| `leak_check.py` | Extracts exact hidden answer tokens where possible and searches the model-facing `input` field. | Reports checked-row coverage; no exact-token leaks on the public samples. |
-| `grader_tamper.py` | Mutates the stored answer key and grades the original gold reply against it. | The original gold reply no longer scores, showing that grading depends on the answer key. |
-
-## Measured results on this workspace (2026-10-30)
-
-On `sample_free.jsonl`:
-- `gold.py`, `do_nothing.py`, `random_wrong.py`, and `grader_tamper.py`: `4/4` deterministic items pass; `5` rubric-judged items are skipped.
-- `leak_check.py`: `items=9 unique_ids=9 checked_rows=3 leaks=0`.
-
-On the 100-item open sample at `environment/src/binary_reasoning_v1/items.jsonl`:
-- `gold.py`, `do_nothing.py`, `random_wrong.py`, and `grader_tamper.py`: `84/84` deterministic items pass; `16` rubric-judged items are skipped.
-- `leak_check.py`: `items=100 unique_ids=100 checked_rows=73 leaks=0`.
-
-## Known limitations
-
-- The current deterministic graders can accept some "shotgun" replies that contain the correct token among many distractors. This kit does not yet include a dedicated `shotgun.py` probe.
-- `leak_check.py` scans the raw JSONL `input` field, not every rendered prompt variant. Rows with no extractable exact answer token are reported as unchecked.
-- The full-pack answer-leak figure (`0/10,251`) comes from the existing full-pack audit, not from this public sample script.
-- The `solvers/` directory contains RE-Lab-run reproduction scripts for internal hard-trial families. Several depend on local paths, WSL/Windows tools, pinned package digests, or host-specific loader behavior, so they are evidence rather than a portable buyer-runnable kit yet.
-Add verification kit README

verification_kit/do_nothing.py/verification_kit/do_nothing.py

@@ -1,55 +0,0 @@
-#!/usr/bin/env python3
-"""Do-nothing sanity check: an empty answer should score 0 on deterministic tasks."""
-import json
-import sys
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parents[1]
-sys.path.insert(0, str(ROOT / "environment" / "src"))
-from binary_reasoning_v1.grading import grade_item, needs_judge  # noqa: E402
-
-
-def resolve_path():
-    if len(sys.argv) > 1:
-        return Path(sys.argv[1])
-    for p in (ROOT / "sample_free.jsonl", ROOT / "environment/src/binary_reasoning_v1/items.jsonl"):
-        if p.exists():
-            return p
-    raise SystemExit("no sample JSONL found; pass one as argv[1]")
-
-
-def load_rows(path):
-    rows = []
-    for line in path.read_text(encoding="utf-8").splitlines():
-        if line.strip():
-            rows.append(json.loads(line))
-    return rows
-
-
-def main():
-    path = resolve_path()
-    rows = load_rows(path)
-    passed = failed = skipped = 0
-    fails = []
-    for row in rows:
-        fam = row.get("family", "")
-        ans = row.get("answer")
-        if needs_judge(fam, ans):
-            skipped += 1
-            continue
-        score = grade_item(fam, "", ans)
-        if score == 0.0:
-            passed += 1
-        else:
-            failed += 1
-            fails.append((row.get("id"), fam, score))
-    print(f"file={path}")
-    print(f"summary: do_nothing pass={passed}/{passed + failed} fail={failed} skipped_judge={skipped}")
-    for f in fails[:10]:
-        print("FAIL", *f)
-    return 0 if failed == 0 else 1
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
-Add do-nothing sanity check

verification_kit/grader_tamper.py/verification_kit/grader_tamper.py

@@ -1,128 +0,0 @@
-#!/usr/bin/env python3
-"""Grader tamper check: gold replies must fail when the answer key is deliberately mutated."""
-import copy
-import json
-import sys
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parents[1]
-sys.path.insert(0, str(ROOT / "environment" / "src"))
-from binary_reasoning_v1.grading import _answer_symbol, grade_item, needs_judge, norm_symbol  # noqa: E402
-
-
-def resolve_path():
-    if len(sys.argv) > 1:
-        return Path(sys.argv[1])
-    for p in (ROOT / "sample_free.jsonl", ROOT / "environment/src/binary_reasoning_v1/items.jsonl"):
-        if p.exists():
-            return p
-    raise SystemExit("no sample JSONL found; pass one as argv[1]")
-
-
-def load_rows(path):
-    rows = []
-    for line in path.read_text(encoding="utf-8").splitlines():
-        if line.strip():
-            rows.append(json.loads(line))
-    return rows
-
-
-def parse_json_answer(ans):
-    if isinstance(ans, dict):
-        return ans
-    if isinstance(ans, str):
-        try:
-            obj = json.loads(ans)
-            if isinstance(obj, dict):
-                return obj
-        except Exception:
-            pass
-    return {}
-
-
-def mutate_token(s):
-    s = str(s)
-    if not s:
-        return "RELAB_TAMPER"
-    mid = len(s) // 2
-    return f"{s[:mid]}_RELAB_TAMPER_{s[mid:]}"
-
-
-def gold_reply(row):
-    fam = row.get("family", "")
-    ans = row.get("answer")
-    if fam == "func_id_mc" and isinstance(ans, dict):
-        opts = ans.get("options", [])
-        correct = norm_symbol(ans.get("correct", ""))
-        for i, opt in enumerate(opts[:4]):
-            if norm_symbol(opt) == correct:
-                return "ABCD"[i]
-        return str(ans.get("correct", ""))
-    if fam == "toolchain_fp" and isinstance(ans, dict):
-        return "\n".join(str(s) for s in ans.get("toolchain_strings", []))
-    if fam == "crossarch_equivalence":
-        obj = parse_json_answer(ans)
-        if bool(obj.get("same")):
-            return f"Same function: {obj.get('symbol', '')}"
-        return "Not the same."
-    sym = _answer_symbol(ans)
-    return str(sym or ans or "")
-
-
-def tamper_answer(row):
-    fam = row.get("family", "")
-    ans = copy.deepcopy(row.get("answer"))
-    if fam == "func_id_mc" and isinstance(ans, dict):
-        opts = ans.get("options", [])
-        correct = norm_symbol(ans.get("correct", ""))
-        for opt in opts:
-            if norm_symbol(opt) != correct:
-                ans["correct"] = opt
-                return ans
-        ans["correct"] = f"{ans.get('correct', '')}_RELAB_TAMPER"
-        return ans
-    if fam == "toolchain_fp" and isinstance(ans, dict):
-        ans["toolchain_strings"] = [mutate_token(s) for s in ans.get("toolchain_strings", [])]
-        return ans
-    if fam == "library_ident":
-        return f"{ans}_RELAB_TAMPER"
-    if fam == "crossarch_equivalence":
-        obj = parse_json_answer(ans)
-        obj["same"] = not bool(obj.get("same"))
-        if isinstance(ans, str):
-            return json.dumps(obj)
-        return obj
-    if isinstance(ans, dict):
-        ans["symbol"] = f"{ans.get('symbol', '')}_RELAB_TAMPER"
-        ans["aliases"] = [f"{a}_RELAB_TAMPER" for a in ans.get("aliases", [])]
-        return ans
-    return f"{ans}_RELAB_TAMPER"
-
-
-def main():
-    path = resolve_path()
-    rows = load_rows(path)
-    passed = failed = skipped = 0
-    fails = []
-    for row in rows:
-        fam = row.get("family", "")
-        ans = row.get("answer")
-        if needs_judge(fam, ans):
-            skipped += 1
-            continue
-        score = grade_item(fam, gold_reply(row), tamper_answer(row))
-        if score < 1.0:
-            passed += 1
-        else:
-            failed += 1
-            fails.append((row.get("id"), fam, score))
-    print(f"file={path}")
-    print(f"summary: grader_tamper pass={passed}/{passed + failed} fail={failed} skipped_judge={skipped}")
-    for f in fails[:10]:
-        print("FAIL", *f)
-    return 0 if failed == 0 else 1
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
-Add answer-key sensitivity check

verification_kit/leak_check.py/verification_kit/leak_check.py

@@ -1,72 +0,0 @@
-#!/usr/bin/env python3
-"""Answer-leak audit: hidden answer labels/tokens should not appear in the model-facing input."""
-import json
-import re
-import sys
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parents[1]
-
-
-def resolve_path():
-    if len(sys.argv) > 1:
-        return Path(sys.argv[1])
-    for p in (ROOT / "sample_free.jsonl", ROOT / "environment/src/binary_reasoning_v1/items.jsonl"):
-        if p.exists():
-            return p
-    raise SystemExit("no sample JSONL found; pass one as argv[1]")
-
-
-def load_rows(path):
-    rows = []
-    for line in path.read_text(encoding="utf-8").splitlines():
-        if line.strip():
-            rows.append(json.loads(line))
-    return rows
-
-
-def candidate_names(row):
-    ans = row.get("answer")
-    names = []
-    if isinstance(ans, dict):
-        if isinstance(ans.get("symbol"), str):
-            names.append(ans["symbol"])
-        if isinstance(ans.get("correct"), str):
-            names.append(ans["correct"])
-        for alias in ans.get("aliases", []):
-            if isinstance(alias, str):
-                names.append(alias)
-        for s in ans.get("toolchain_strings", []):
-            if isinstance(s, str):
-                names.append(s)
-    elif isinstance(ans, str) and re.fullmatch(r"[A-Za-z_][A-Za-z0-9_.]{4,}", ans):
-        # Exact-symbol / flag-style answers. Prose and JSON answers are handled by rubric/judge paths.
-        names.append(ans)
-    return [n for n in names if len(n) >= 4]
-
-
-def main():
-    path = resolve_path()
-    rows = load_rows(path)
-    leaks = []
-    checked_rows = 0
-    ids = [row.get("id") for row in rows]
-    for row in rows:
-        candidates = candidate_names(row)
-        if candidates:
-            checked_rows += 1
-        surface = row.get("input", "")
-        for name in candidates:
-            if re.search(r"(?<![A-Za-z0-9_.])" + re.escape(name) + r"(?![A-Za-z0-9_])", surface):
-                leaks.append((row.get("id"), row.get("family"), name))
-                break
-    print(f"file={path}")
-    print(f"summary: leak_check items={len(rows)} unique_ids={len(set(ids))} checked_rows={checked_rows} leaks={len(leaks)}")
-    for l in leaks[:10]:
-        print("LEAK", *l)
-    return 0 if not leaks else 1
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
-Add sample answer-leak check

verification_kit/random_wrong.py/verification_kit/random_wrong.py

@@ -1,104 +0,0 @@
-#!/usr/bin/env python3
-"""Random-wrong sanity check: a deliberately wrong deterministic reply should score 0."""
-import json
-import sys
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parents[1]
-sys.path.insert(0, str(ROOT / "environment" / "src"))
-from binary_reasoning_v1.grading import _answer_symbol, grade_item, needs_judge, norm_symbol  # noqa: E402
-
-
-def resolve_path():
-    if len(sys.argv) > 1:
-        return Path(sys.argv[1])
-    for p in (ROOT / "sample_free.jsonl", ROOT / "environment/src/binary_reasoning_v1/items.jsonl"):
-        if p.exists():
-            return p
-    raise SystemExit("no sample JSONL found; pass one as argv[1]")
-
-
-def load_rows(path):
-    rows = []
-    for line in path.read_text(encoding="utf-8").splitlines():
-        if line.strip():
-            rows.append(json.loads(line))
-    return rows
-
-
-def parse_json_answer(ans):
-    if isinstance(ans, dict):
-        return ans
-    if isinstance(ans, str):
-        try:
-            obj = json.loads(ans)
-            if isinstance(obj, dict):
-                return obj
-        except Exception:
-            pass
-    return {}
-
-
-def mutate_token(s):
-    s = str(s)
-    if not s:
-        return "RELAB_WRONG"
-    mid = len(s) // 2
-    return f"{s[:mid]}_RELAB_WRONG_{s[mid:]}"
-
-
-def wrong_reply(row):
-    fam = row.get("family", "")
-    ans = row.get("answer")
-    if fam == "func_id_mc" and isinstance(ans, dict):
-        opts = ans.get("options", [])
-        correct = norm_symbol(ans.get("correct", ""))
-        for i, opt in enumerate(opts[:4]):
-            if norm_symbol(opt) != correct:
-                return "ABCD"[i]
-        return "RELAB_WRONG"
-    if fam == "toolchain_fp" and isinstance(ans, dict):
-        parts = [mutate_token(s) for s in ans.get("toolchain_strings", []) if str(s)]
-        return "\n".join(parts) if parts else "RELAB_WRONG"
-    if fam == "library_ident":
-        ans_str = str(_answer_symbol(ans) or ans or "")
-        toks = [t for t in ans_str.split() if len(t) >= 2]
-        return " ".join(mutate_token(t) for t in toks) if toks else "RELAB_WRONG"
-    if fam == "crossarch_equivalence":
-        obj = parse_json_answer(ans)
-        if bool(obj.get("same")):
-            return "Not the same."
-        return "Same function: RELAB_WRONG"
-    sym = _answer_symbol(ans) or ans or ""
-    if row.get("family") == "agentic_flag_hunt":
-        return mutate_token(sym)
-    return f"{sym}_RELAB_WRONG"
-
-
-def main():
-    path = resolve_path()
-    rows = load_rows(path)
-    passed = failed = skipped = 0
-    fails = []
-    for row in rows:
-        fam = row.get("family", "")
-        ans = row.get("answer")
-        if needs_judge(fam, ans):
-            skipped += 1
-            continue
-        score = grade_item(fam, wrong_reply(row), ans)
-        if score == 0.0:
-            passed += 1
-        else:
-            failed += 1
-            fails.append((row.get("id"), fam, score))
-    print(f"file={path}")
-    print(f"summary: random_wrong pass={passed}/{passed + failed} fail={failed} skipped_judge={skipped}")
-    for f in fails[:10]:
-        print("FAIL", *f)
-    return 0 if failed == 0 else 1
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
-Add deterministic wrong-answer sanity check