Publish verification pack files (cookie commit)

README.md

@@ -53,60 +53,3 @@ request access; access is reviewed on request. Commercial licensing and custom t
 
 ## License
 All rights reserved pending commercial license; research evaluation use granted for the free sample.
-
-<!-- hf-api-probe -->
----
-license: "other"
-tags:
-- reinforcement-learning
-- evaluation
-- reverse-engineering
-- binaries
-- elf
-- pe
-- cross-architecture
-- taskset
-- harbor-framework
-- rl-environments
-size_categories:
-- 10K<n<100K
-pretty_name: binary-reasoning-v1
----
-
-# binary-reasoning-v1
-
-**Verified reverse-engineering tasks over real production binaries** — an RL / eval environment
-pack where every answer is derived from the artifact itself and machine-checked.
-
-- **10,251 items · 10 families · 7 ISAs** (x86-64, i686, AArch64, ARM32, RISC-V, MIPS o32/n64, PPC64LE)
-- Sources: 649 distinct third-party file names referenced in shipped provenance (system libs incl.
-  libcrypto/zstd/sqlite3/libxml2, Mesa DRI drivers, QEMU device models, systemd internals), Debian production
-  cross-toolchain glibc, Android/Termux production aarch64 libs, curated Windows PEs, labeled cross-compiles
-- Provenance per item: binary name and sha256_16 on every item; function address/size and architecture where applicable
-- **Verification:** automated REA re-verification (answers re-verified against the binaries); 10,172
-  deterministic items score 1.0 on gold / 0.0 on abstention; automated answer-leak scan found 0/10,251 hits; all tasks load
-  against the real `verifiers` v1 framework; 29 agentic challenges ship Harbor-format task packages,
-  built + scored in real Docker containers with reward-chain gold and wrong-answer tests passing; each binary was also checked with 24 single-character mutations that scored zero
-- **Baseline:** a small local open-weight model mini-eval scored `5/23` (22%) on selected static deterministic items; see `EVAL_RESULTS.md` for conditions. Headroom is the feature — per-buyer calibration is part of the paid pilot path.
-
-## Contents of this repo (free sample)
-| file | what |
-|---|---|
-| `DATASHEET.md` | full composition table, guarantees, known limits, positioning vs existing work |
-| `sample_free.jsonl` | 9 items — one per family |
-| `EVAL_RESULTS.md` | baseline eval methodology + results (incl. measured frontier reference: Opus 5.5 single-shot ~58% on ID items; agentic flag-hunts pass@1 3/3 with tools — reward reachable, not free) |
-| `VERIFICATION-DOSSIER-PUBLIC.md` | public proof summary with measured checks and known caveats |
-| `verification_kit/` | sample-level grader, wrong-answer, key-sensitivity, and leak-check scripts; see `verification_kit/README.md` for limitations |
-| `environment/src/binary_reasoning_v1/grading.py` | minimal grader module used by the verification kit (full runnable environment is on the Prime Hub package) |
-| `harbor_pilot_29.zip` | all 29 agentic Harbor task packages (task.toml + instruction + Dockerfile + verifier), ready for `harbor run` or a free HUD import ([direct download](https://huggingface.co/datasets/S3RL4/binary-reasoning-v1/resolve/main/harbor_pilot_29.zip)) |
-
-Also live on the Prime Intellect Environments Hub: `s3rl4/binary-reasoning-v1`
-(`prime env install s3rl4/binary-reasoning-v1`).
-
-The **full pack** (10,251 items + runnable verifiers v1 environment + Harbor packages + agentic
-binaries & sources) lives in the gated companion repo:
-[S3RL4/binary-reasoning-v1-full](https://huggingface.co/datasets/S3RL4/binary-reasoning-v1-full) —
-request access; access is reviewed on request. Commercial licensing and custom taskset builds: samueljanttila@gmail.com.
-
-## License
-All rights reserved pending commercial license; research evaluation use granted for the free sample.

VERIFICATION-DOSSIER-PUBLIC.md

@@ -0,0 +1,61 @@
+# 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.

environment/src/binary_reasoning_v1/grading.py

@@ -0,0 +1,114 @@
+"""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

verification_kit/README.md

@@ -0,0 +1,52 @@
+# 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.

verification_kit/do_nothing.py

@@ -0,0 +1,54 @@
+#!/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())

verification_kit/gold.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""Gold-answer sanity check: built-in gold replies should score 1 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 _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 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 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), ans)
+        if score == 1.0:
+            passed += 1
+        else:
+            failed += 1
+            fails.append((row.get("id"), fam, score))
+    print(f"file={path}")
+    print(f"summary: gold 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())

verification_kit/grader_tamper.py

@@ -0,0 +1,127 @@
+#!/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())

verification_kit/leak_check.py

@@ -0,0 +1,71 @@
+#!/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())

verification_kit/random_wrong.py

@@ -0,0 +1,103 @@
+#!/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())