Datasets:

Shangy
/

DR-256-backup

#!/usr/bin/env python3
"""Build a deterministic, evidence-conditioned DeepResearch medium benchmark.
Selection never uses model outputs.  Every selected question has at least one
successfully fetched, non-QA-dump teacher-provenance document containing the
normalized gold answer.  Questions are stratified by dataset difficulty,
teacher outcome, and how much work an independent original-query search needs
to surface the answer after QA-dump documents are blocked.  The independently
retrieved evidence URL need not be the exact URL used by the teacher: exact-
content deduplication deliberately retains only one representative URL in FTS.
"""

from __future__ import annotations

import argparse
import hashlib
import json
import random
import re
import unicodedata
from collections import Counter, defaultdict
from functools import lru_cache
from pathlib import Path
from typing import Any
from urllib.parse import urlsplit

try:
    from .common import read_jsonl, write_jsonl
    from .corpus_db import connect, open_document, search
except ImportError:  # direct script execution
    from common import read_jsonl, write_jsonl
    from corpus_db import connect, open_document, search


BENCHMARK_NAME = "deepresearch9k-medium-v1"
DEFAULT_SEED = 20260809
AGENT_VISIBLE_K = 12

# Exact quotas keyed by (difficulty, teacher_correct, retrieval bucket).  The
# source has only five D2/teacher-failure questions whose answer is absent from
# the original-query top 20 before stricter filtering, so forcing every cell
# to be 50/50 is impossible.  These quotas retain exact global 128/128 teacher
# balance and the desired difficulty/bucket marginals without oversampling a
# nonexistent cell.
CELL_QUOTAS = {
    (1, False, "visible"): 24,
    (1, True, "visible"): 8,
    (1, False, "open"): 22,
    (1, True, "open"): 6,
    (1, False, "reformulate"): 2,
    (1, True, "reformulate"): 2,
    (2, False, "visible"): 20,
    (2, True, "visible"): 36,
    (2, False, "open"): 18,
    (2, True, "open"): 46,
    (2, False, "reformulate"): 2,
    (2, True, "reformulate"): 6,
    (3, False, "visible"): 4,
    (3, True, "visible"): 4,
    (3, False, "open"): 12,
    (3, True, "open"): 8,
    (3, False, "reformulate"): 24,
    (3, True, "reformulate"): 12,
}

SUSPICIOUS_URL_MARKERS = (
    "huggingface.co/datasets",
    "honestybench",
    "halueval",
    "qapairs",
    "musique",
    "hotpotqa",
    "hotpot_qa",
    "triviaqa",
    "natural_questions",
    "strategyqa",
    "2wikimultihopqa",
)
SHORT_COMMON_ANSWERS = {
    "earth",
    "false",
    "home",
    "magazine",
    "no",
    "plants",
    "rock",
    "true",
    "yes",
}


def normalize(text: str) -> str:
    decomposed = unicodedata.normalize("NFKD", text or "")
    without_marks = "".join(
        character for character in decomposed if not unicodedata.combining(character)
    )
    return re.sub(r"[^\w]+", " ", without_marks.casefold(), flags=re.UNICODE).strip()


def contains_answer(text: str, normalized_answer: str) -> bool:
    return f" {normalized_answer} " in f" {normalize(text)} "


def answer_is_usable(answer: str) -> bool:
    normalized = normalize(answer)
    compact = normalized.replace(" ", "")
    if not normalized or normalized in SHORT_COMMON_ANSWERS or "<q1>" in answer:
        return False
    if len(compact) < 4 or len(answer) > 120:
        return False
    # Very short single alphabetic tokens are especially prone to incidental
    # matches in long pages.  Four-digit years remain useful.
    if " " not in normalized and normalized.isalpha() and len(normalized) < 6:
        return False
    return True


def sha256(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as handle:
        for block in iter(lambda: handle.read(1024 * 1024), b""):
            digest.update(block)
    return digest.hexdigest()


def url_is_suspicious(url: str) -> bool:
    lowered = url.casefold()
    if any(marker in lowered for marker in SUSPICIOUS_URL_MARKERS):
        return True
    path = urlsplit(lowered).path
    return path.endswith((".jsonl", ".parquet"))


def find_blocked_documents(connection) -> tuple[set[str], list[dict[str, str]]]:
    blocked: set[str] = set()
    details = []
    for row in connection.execute(
        "SELECT url_id, canonical_url, title, text FROM documents WHERE status='success'"
    ):
        reason = None
        if url_is_suspicious(row["canonical_url"]):
            reason = "url_marker"
        else:
            lowered = row["text"].casefold()
            question_fields = lowered.count('"question"') + lowered.count('"question":')
            answer_fields = lowered.count('"answer"') + lowered.count('"answer":')
            if question_fields >= 5 and answer_fields >= 5:
                reason = "repeated_structured_qa"
        if reason:
            blocked.add(row["url_id"])
            details.append(
                {
                    "docid": row["url_id"],
                    "url": row["canonical_url"],
                    "title": row["title"],
                    "reason": reason,
                }
            )
    return blocked, details


def load_provenance(connection) -> dict[str, list[str]]:
    result: defaultdict[str, list[str]] = defaultdict(list)
    for row in connection.execute(
        """
        SELECT q.qid, d.url_id
        FROM document_qids AS q JOIN documents AS d USING(url_id)
        WHERE d.status='success'
        """
    ):
        result[row["qid"]].append(row["url_id"])
    return dict(result)


def target_cells() -> dict[tuple[int, bool, str], int]:
    return dict(CELL_QUOTAS)


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--database", type=Path, required=True)
    parser.add_argument(
        "--database-label",
        type=Path,
        help="persistent source path recorded when --database is a staged copy",
    )
    parser.add_argument("--data", type=Path, required=True)
    parser.add_argument("--coverage", type=Path, required=True)
    parser.add_argument("--output-dir", type=Path, required=True)
    parser.add_argument("--seed", type=int, default=DEFAULT_SEED)
    args = parser.parse_args()

    records = read_jsonl(args.data)
    coverage = {row["qid"]: row for row in read_jsonl(args.coverage)}
    connection = connect(args.database, readonly=True)
    blocked_docids, blocked_details = find_blocked_documents(connection)
    provenance = load_provenance(connection)

    @lru_cache(maxsize=32768)
    def document(docid: str) -> dict[str, Any] | None:
        return open_document(connection, docid=docid)

    candidates = []
    rejected = Counter()
    for record in records:
        metadata = record.get("metadata") or {}
        qid = metadata.get("manifest_qid") or metadata.get("qid")
        audit = coverage.get(qid)
        answer = metadata.get("answer") or record.get("label", "")
        if audit is None or not audit.get("answer_in_fetched_provenance"):
            rejected["audit_no_provenance_answer"] += 1
            continue
        if not answer_is_usable(answer):
            rejected["unusable_answer"] += 1
            continue
        candidates.append(record)

    rng = random.Random(args.seed)
    rng.shuffle(candidates)
    coarse_base_counts = Counter(
        (int(record["metadata"]["difficulty"]), bool(record["metadata"]["teacher_correct"]))
        for record in candidates
    )
    # Stable sort after shuffling: prioritize rare strata while preserving a
    # seeded random order within each stratum.  This changes no eligibility or
    # quota; it avoids thousands of unnecessary FTS queries while waiting for
    # a rare D2/teacher-failure row to appear in a global random stream.
    candidates.sort(
        key=lambda record: coarse_base_counts[
            (
                int(record["metadata"]["difficulty"]),
                bool(record["metadata"]["teacher_correct"]),
            )
        ]
    )
    quotas = target_cells()
    selected_by_cell: defaultdict[tuple[int, bool, str], list[dict[str, Any]]] = defaultdict(list)
    scanned = 0

    for record in candidates:
        if all(len(selected_by_cell[cell]) >= quota for cell, quota in quotas.items()):
            break
        scanned += 1
        metadata = record["metadata"]
        qid = metadata.get("manifest_qid") or metadata["qid"]
        audit = coverage[qid]
        difficulty = int(metadata["difficulty"])
        teacher_correct = bool(metadata["teacher_correct"])
        base_cells = [
            (difficulty, teacher_correct, bucket)
            for bucket in ("visible", "open", "reformulate")
        ]
        if all(len(selected_by_cell[cell]) >= quotas[cell] for cell in base_cells):
            rejected[f"base_quota_full:{difficulty}/{teacher_correct}"] += 1
            continue
        # The earlier audit used a superset of this benchmark's visible
        # results (top 20, before blocking QA dumps).  A miss there is
        # guaranteed to remain a reformulation case here and need not repeat
        # an expensive FTS query.
        audit_retrieval_miss = not bool(audit["answer_in_question_search_top_20"])
        reformulate_cell = (difficulty, teacher_correct, "reformulate")
        if (
            audit_retrieval_miss
            and len(selected_by_cell[reformulate_cell]) >= quotas[reformulate_cell]
        ):
            rejected[f"reformulate_quota_full:{difficulty}/{teacher_correct}"] += 1
            continue
        answer = metadata.get("answer") or record.get("label", "")
        normalized_answer = normalize(answer)
        clean_provenance_hits = []
        for docid in provenance.get(qid, []):
            if docid in blocked_docids:
                continue
            page = document(docid)
            if page and contains_answer(page["text"], normalized_answer):
                clean_provenance_hits.append(docid)
        if not clean_provenance_hits:
            rejected["no_clean_provenance_answer"] += 1
            continue

        if audit_retrieval_miss:
            bucket = "reformulate"
            evidence_rank, evidence_row = None, None
        else:
            try:
                visible = search(
                    connection,
                    metadata["question"],
                    AGENT_VISIBLE_K,
                    excluded_docids=blocked_docids,
                )
            except ValueError:
                rejected["unsearchable_question"] += 1
                continue
            snippet_matches = [
                (rank, row)
                for rank, row in enumerate(visible, 1)
                if contains_answer(row["text"], normalized_answer)
            ]
            full_matches = []
            if not snippet_matches:
                for rank, row in enumerate(visible, 1):
                    page = document(row["docid"])
                    if page and contains_answer(page["text"], normalized_answer):
                        full_matches.append((rank, row))

            if snippet_matches:
                bucket = "visible"
                evidence_rank, evidence_row = snippet_matches[0]
            elif full_matches:
                bucket = "open"
                evidence_rank, evidence_row = full_matches[0]
            else:
                bucket = "reformulate"
                evidence_rank, evidence_row = None, None

        cell = (int(metadata["difficulty"]), bool(metadata["teacher_correct"]), bucket)
        if cell not in quotas or len(selected_by_cell[cell]) >= quotas[cell]:
            rejected[f"quota_full:{cell}"] += 1
            continue

        enriched = json.loads(json.dumps(record, ensure_ascii=False))
        enriched["metadata"]["benchmark"] = {
            "name": BENCHMARK_NAME,
            "selection_bucket": bucket,
            "clean_provenance_answer_docids": sorted(clean_provenance_hits),
            "original_query_evidence_rank": evidence_rank,
            "original_query_evidence_docid": evidence_row["docid"] if evidence_row else None,
        }
        selected_by_cell[cell].append(enriched)
        if len(selected_by_cell[cell]) == quotas[cell] or scanned % 100 == 0:
            print(
                f"scanned={scanned} selected={sum(map(len, selected_by_cell.values()))} "
                f"filled={sum(len(selected_by_cell[c]) >= q for c, q in quotas.items())}/{len(quotas)}",
                flush=True,
            )

    missing = {
        str(cell): quota - len(selected_by_cell[cell])
        for cell, quota in quotas.items()
        if len(selected_by_cell[cell]) < quota
    }
    if missing:
        raise RuntimeError(f"could not fill benchmark quotas after scanning {scanned}: {missing}")

    selected = [row for cell in sorted(selected_by_cell, key=str) for row in selected_by_cell[cell]]
    rng.shuffle(selected)
    for index, row in enumerate(selected):
        row["metadata"]["benchmark"]["index"] = index

    args.output_dir.mkdir(parents=True, exist_ok=True)
    questions_path = args.output_dir / "questions.jsonl"
    blocked_docids_path = args.output_dir / "blocked_docids.txt"
    write_jsonl(questions_path, selected)
    write_jsonl(args.output_dir / "blocked_documents.jsonl", blocked_details)
    blocked_docids_path.write_text(
        "".join(f"{docid}\n" for docid in sorted(blocked_docids))
    )

    by_difficulty = Counter(row["metadata"]["difficulty"] for row in selected)
    by_teacher = Counter(str(row["metadata"]["teacher_correct"]).lower() for row in selected)
    by_bucket = Counter(
        row["metadata"]["benchmark"]["selection_bucket"] for row in selected
    )
    summary = {
        "benchmark": BENCHMARK_NAME,
        "seed": args.seed,
        "questions": len(selected),
        "source_data": str(args.data),
        "source_coverage": str(args.coverage),
        "database": str(args.database_label or args.database),
        "database_sha256": sha256(args.database),
        "questions_sha256": sha256(questions_path),
        "blocked_docids_sha256": sha256(blocked_docids_path),
        "search_k": AGENT_VISIBLE_K,
        "agent_visible_k": AGENT_VISIBLE_K,
        "blocked_documents": len(blocked_docids),
        "candidates_after_coarse_filter": len(candidates),
        "coarse_candidates_by_difficulty_teacher": {
            f"D{difficulty}/teacher_{str(teacher).lower()}": count
            for (difficulty, teacher), count in sorted(coarse_base_counts.items())
        },
        "candidates_scanned": scanned,
        "by_difficulty": dict(sorted(by_difficulty.items())),
        "by_teacher_correct": dict(sorted(by_teacher.items())),
        "by_selection_bucket": dict(sorted(by_bucket.items())),
        "rejected": dict(rejected.most_common()),
        "selection_note": (
            "Evidence-conditioned diagnostic; model outputs were not used for selection. "
            "Not a clean held-out estimate because train questions and train-trajectory provenance are allowed."
        ),
    }
    (args.output_dir / "summary.json").write_text(
        json.dumps(summary, ensure_ascii=False, indent=2, sort_keys=True) + "\n"
    )
    connection.close()
    print(json.dumps(summary, ensure_ascii=False, sort_keys=True))


if __name__ == "__main__":
    main()

	#!/usr/bin/env python3
	"""Build a deterministic, evidence-conditioned DeepResearch medium benchmark.

	Selection never uses model outputs. Every selected question has at least one
	successfully fetched, non-QA-dump teacher-provenance document containing the
	normalized gold answer. Questions are stratified by dataset difficulty,
	teacher outcome, and how much work an independent original-query search needs
	to surface the answer after QA-dump documents are blocked. The independently
	retrieved evidence URL need not be the exact URL used by the teacher: exact-
	content deduplication deliberately retains only one representative URL in FTS.
	"""

	from __future__ import annotations

	import argparse
	import hashlib
	import json
	import random
	import re
	import unicodedata
	from collections import Counter, defaultdict
	from functools import lru_cache
	from pathlib import Path
	from typing import Any
	from urllib.parse import urlsplit

	try:
	from .common import read_jsonl, write_jsonl
	from .corpus_db import connect, open_document, search
	except ImportError: # direct script execution
	from common import read_jsonl, write_jsonl
	from corpus_db import connect, open_document, search


	BENCHMARK_NAME = "deepresearch9k-medium-v1"
	DEFAULT_SEED = 20260809
	AGENT_VISIBLE_K = 12

	# Exact quotas keyed by (difficulty, teacher_correct, retrieval bucket). The
	# source has only five D2/teacher-failure questions whose answer is absent from
	# the original-query top 20 before stricter filtering, so forcing every cell
	# to be 50/50 is impossible. These quotas retain exact global 128/128 teacher
	# balance and the desired difficulty/bucket marginals without oversampling a
	# nonexistent cell.
	CELL_QUOTAS = {
	(1, False, "visible"): 24,
	(1, True, "visible"): 8,
	(1, False, "open"): 22,
	(1, True, "open"): 6,
	(1, False, "reformulate"): 2,
	(1, True, "reformulate"): 2,
	(2, False, "visible"): 20,
	(2, True, "visible"): 36,
	(2, False, "open"): 18,
	(2, True, "open"): 46,
	(2, False, "reformulate"): 2,
	(2, True, "reformulate"): 6,
	(3, False, "visible"): 4,
	(3, True, "visible"): 4,
	(3, False, "open"): 12,
	(3, True, "open"): 8,
	(3, False, "reformulate"): 24,
	(3, True, "reformulate"): 12,
	}

	SUSPICIOUS_URL_MARKERS = (
	"huggingface.co/datasets",
	"honestybench",
	"halueval",
	"qapairs",
	"musique",
	"hotpotqa",
	"hotpot_qa",
	"triviaqa",
	"natural_questions",
	"strategyqa",
	"2wikimultihopqa",
	)
	SHORT_COMMON_ANSWERS = {
	"earth",
	"false",
	"home",
	"magazine",
	"no",
	"plants",
	"rock",
	"true",
	"yes",
	}


	def normalize(text: str) -> str:
	decomposed = unicodedata.normalize("NFKD", text or "")
	without_marks = "".join(
	character for character in decomposed if not unicodedata.combining(character)
	)
	return re.sub(r"[^\w]+", " ", without_marks.casefold(), flags=re.UNICODE).strip()


	def contains_answer(text: str, normalized_answer: str) -> bool:
	return f" {normalized_answer} " in f" {normalize(text)} "


	def answer_is_usable(answer: str) -> bool:
	normalized = normalize(answer)
	compact = normalized.replace(" ", "")
	if not normalized or normalized in SHORT_COMMON_ANSWERS or "<q1>" in answer:
	return False
	if len(compact) < 4 or len(answer) > 120:
	return False
	# Very short single alphabetic tokens are especially prone to incidental
	# matches in long pages. Four-digit years remain useful.
	if " " not in normalized and normalized.isalpha() and len(normalized) < 6:
	return False
	return True


	def sha256(path: Path) -> str:
	digest = hashlib.sha256()
	with path.open("rb") as handle:
	for block in iter(lambda: handle.read(1024 * 1024), b""):
	digest.update(block)
	return digest.hexdigest()


	def url_is_suspicious(url: str) -> bool:
	lowered = url.casefold()
	if any(marker in lowered for marker in SUSPICIOUS_URL_MARKERS):
	return True
	path = urlsplit(lowered).path
	return path.endswith((".jsonl", ".parquet"))


	def find_blocked_documents(connection) -> tuple[set[str], list[dict[str, str]]]:
	blocked: set[str] = set()
	details = []
	for row in connection.execute(
	"SELECT url_id, canonical_url, title, text FROM documents WHERE status='success'"
	):
	reason = None
	if url_is_suspicious(row["canonical_url"]):
	reason = "url_marker"
	else:
	lowered = row["text"].casefold()
	question_fields = lowered.count('"question"') + lowered.count('"question":')
	answer_fields = lowered.count('"answer"') + lowered.count('"answer":')
	if question_fields >= 5 and answer_fields >= 5:
	reason = "repeated_structured_qa"
	if reason:
	blocked.add(row["url_id"])
	details.append(
	{
	"docid": row["url_id"],
	"url": row["canonical_url"],
	"title": row["title"],
	"reason": reason,
	}
	)
	return blocked, details


	def load_provenance(connection) -> dict[str, list[str]]:
	result: defaultdict[str, list[str]] = defaultdict(list)
	for row in connection.execute(
	"""
	SELECT q.qid, d.url_id
	FROM document_qids AS q JOIN documents AS d USING(url_id)
	WHERE d.status='success'
	"""
	):
	result[row["qid"]].append(row["url_id"])
	return dict(result)


	def target_cells() -> dict[tuple[int, bool, str], int]:
	return dict(CELL_QUOTAS)


	def main() -> None:
	parser = argparse.ArgumentParser(description=__doc__)
	parser.add_argument("--database", type=Path, required=True)
	parser.add_argument(
	"--database-label",
	type=Path,
	help="persistent source path recorded when --database is a staged copy",
	)
	parser.add_argument("--data", type=Path, required=True)
	parser.add_argument("--coverage", type=Path, required=True)
	parser.add_argument("--output-dir", type=Path, required=True)
	parser.add_argument("--seed", type=int, default=DEFAULT_SEED)
	args = parser.parse_args()

	records = read_jsonl(args.data)
	coverage = {row["qid"]: row for row in read_jsonl(args.coverage)}
	connection = connect(args.database, readonly=True)
	blocked_docids, blocked_details = find_blocked_documents(connection)
	provenance = load_provenance(connection)

	@lru_cache(maxsize=32768)
	def document(docid: str) -> dict[str, Any] \| None:
	return open_document(connection, docid=docid)

	candidates = []
	rejected = Counter()
	for record in records:
	metadata = record.get("metadata") or {}
	qid = metadata.get("manifest_qid") or metadata.get("qid")
	audit = coverage.get(qid)
	answer = metadata.get("answer") or record.get("label", "")
	if audit is None or not audit.get("answer_in_fetched_provenance"):
	rejected["audit_no_provenance_answer"] += 1
	continue
	if not answer_is_usable(answer):
	rejected["unusable_answer"] += 1
	continue
	candidates.append(record)

	rng = random.Random(args.seed)
	rng.shuffle(candidates)
	coarse_base_counts = Counter(
	(int(record["metadata"]["difficulty"]), bool(record["metadata"]["teacher_correct"]))
	for record in candidates
	)
	# Stable sort after shuffling: prioritize rare strata while preserving a
	# seeded random order within each stratum. This changes no eligibility or
	# quota; it avoids thousands of unnecessary FTS queries while waiting for
	# a rare D2/teacher-failure row to appear in a global random stream.
	candidates.sort(
	key=lambda record: coarse_base_counts[
	(
	int(record["metadata"]["difficulty"]),
	bool(record["metadata"]["teacher_correct"]),
	)
	]
	)
	quotas = target_cells()
	selected_by_cell: defaultdict[tuple[int, bool, str], list[dict[str, Any]]] = defaultdict(list)
	scanned = 0

	for record in candidates:
	if all(len(selected_by_cell[cell]) >= quota for cell, quota in quotas.items()):
	break
	scanned += 1
	metadata = record["metadata"]
	qid = metadata.get("manifest_qid") or metadata["qid"]
	audit = coverage[qid]
	difficulty = int(metadata["difficulty"])
	teacher_correct = bool(metadata["teacher_correct"])
	base_cells = [
	(difficulty, teacher_correct, bucket)
	for bucket in ("visible", "open", "reformulate")
	]
	if all(len(selected_by_cell[cell]) >= quotas[cell] for cell in base_cells):
	rejected[f"base_quota_full:{difficulty}/{teacher_correct}"] += 1
	continue
	# The earlier audit used a superset of this benchmark's visible
	# results (top 20, before blocking QA dumps). A miss there is
	# guaranteed to remain a reformulation case here and need not repeat
	# an expensive FTS query.
	audit_retrieval_miss = not bool(audit["answer_in_question_search_top_20"])
	reformulate_cell = (difficulty, teacher_correct, "reformulate")
	if (
	audit_retrieval_miss
	and len(selected_by_cell[reformulate_cell]) >= quotas[reformulate_cell]
	):
	rejected[f"reformulate_quota_full:{difficulty}/{teacher_correct}"] += 1
	continue
	answer = metadata.get("answer") or record.get("label", "")
	normalized_answer = normalize(answer)
	clean_provenance_hits = []
	for docid in provenance.get(qid, []):
	if docid in blocked_docids:
	continue
	page = document(docid)
	if page and contains_answer(page["text"], normalized_answer):
	clean_provenance_hits.append(docid)
	if not clean_provenance_hits:
	rejected["no_clean_provenance_answer"] += 1
	continue

	if audit_retrieval_miss:
	bucket = "reformulate"
	evidence_rank, evidence_row = None, None
	else:
	try:
	visible = search(
	connection,
	metadata["question"],
	AGENT_VISIBLE_K,
	excluded_docids=blocked_docids,
	)
	except ValueError:
	rejected["unsearchable_question"] += 1
	continue
	snippet_matches = [
	(rank, row)
	for rank, row in enumerate(visible, 1)
	if contains_answer(row["text"], normalized_answer)
	]
	full_matches = []
	if not snippet_matches:
	for rank, row in enumerate(visible, 1):
	page = document(row["docid"])
	if page and contains_answer(page["text"], normalized_answer):
	full_matches.append((rank, row))

	if snippet_matches:
	bucket = "visible"
	evidence_rank, evidence_row = snippet_matches[0]
	elif full_matches:
	bucket = "open"
	evidence_rank, evidence_row = full_matches[0]
	else:
	bucket = "reformulate"
	evidence_rank, evidence_row = None, None

	cell = (int(metadata["difficulty"]), bool(metadata["teacher_correct"]), bucket)
	if cell not in quotas or len(selected_by_cell[cell]) >= quotas[cell]:
	rejected[f"quota_full:{cell}"] += 1
	continue

	enriched = json.loads(json.dumps(record, ensure_ascii=False))
	enriched["metadata"]["benchmark"] = {
	"name": BENCHMARK_NAME,
	"selection_bucket": bucket,
	"clean_provenance_answer_docids": sorted(clean_provenance_hits),
	"original_query_evidence_rank": evidence_rank,
	"original_query_evidence_docid": evidence_row["docid"] if evidence_row else None,
	}
	selected_by_cell[cell].append(enriched)
	if len(selected_by_cell[cell]) == quotas[cell] or scanned % 100 == 0:
	print(
	f"scanned={scanned} selected={sum(map(len, selected_by_cell.values()))} "
	f"filled={sum(len(selected_by_cell[c]) >= q for c, q in quotas.items())}/{len(quotas)}",
	flush=True,
	)

	missing = {
	str(cell): quota - len(selected_by_cell[cell])
	for cell, quota in quotas.items()
	if len(selected_by_cell[cell]) < quota
	}
	if missing:
	raise RuntimeError(f"could not fill benchmark quotas after scanning {scanned}: {missing}")

	selected = [row for cell in sorted(selected_by_cell, key=str) for row in selected_by_cell[cell]]
	rng.shuffle(selected)
	for index, row in enumerate(selected):
	row["metadata"]["benchmark"]["index"] = index

	args.output_dir.mkdir(parents=True, exist_ok=True)
	questions_path = args.output_dir / "questions.jsonl"
	blocked_docids_path = args.output_dir / "blocked_docids.txt"
	write_jsonl(questions_path, selected)
	write_jsonl(args.output_dir / "blocked_documents.jsonl", blocked_details)
	blocked_docids_path.write_text(
	"".join(f"{docid}\n" for docid in sorted(blocked_docids))
	)

	by_difficulty = Counter(row["metadata"]["difficulty"] for row in selected)
	by_teacher = Counter(str(row["metadata"]["teacher_correct"]).lower() for row in selected)
	by_bucket = Counter(
	row["metadata"]["benchmark"]["selection_bucket"] for row in selected
	)
	summary = {
	"benchmark": BENCHMARK_NAME,
	"seed": args.seed,
	"questions": len(selected),
	"source_data": str(args.data),
	"source_coverage": str(args.coverage),
	"database": str(args.database_label or args.database),
	"database_sha256": sha256(args.database),
	"questions_sha256": sha256(questions_path),
	"blocked_docids_sha256": sha256(blocked_docids_path),
	"search_k": AGENT_VISIBLE_K,
	"agent_visible_k": AGENT_VISIBLE_K,
	"blocked_documents": len(blocked_docids),
	"candidates_after_coarse_filter": len(candidates),
	"coarse_candidates_by_difficulty_teacher": {
	f"D{difficulty}/teacher_{str(teacher).lower()}": count
	for (difficulty, teacher), count in sorted(coarse_base_counts.items())
	},
	"candidates_scanned": scanned,
	"by_difficulty": dict(sorted(by_difficulty.items())),
	"by_teacher_correct": dict(sorted(by_teacher.items())),
	"by_selection_bucket": dict(sorted(by_bucket.items())),
	"rejected": dict(rejected.most_common()),
	"selection_note": (
	"Evidence-conditioned diagnostic; model outputs were not used for selection. "
	"Not a clean held-out estimate because train questions and train-trajectory provenance are allowed."
	),
	}
	(args.output_dir / "summary.json").write_text(
	json.dumps(summary, ensure_ascii=False, indent=2, sort_keys=True) + "\n"
	)
	connection.close()
	print(json.dumps(summary, ensure_ascii=False, sort_keys=True))


	if __name__ == "__main__":
	main()