| |
| """Build and validate the frozen DeepResearch-9K frontier-v1 release. |
| |
| The internal builder creates a thin release whose multi-gigabyte SQLite corpus |
| is a relative symlink. The validator also accepts the standalone Hub layout, |
| where that same database is an embedded regular file excluded from the small |
| artifact checksum list and pinned separately in ``manifest.json``. Keeping the |
| complete corpus preserves FTS/BM25 ranks; extracting only answer-bearing pages |
| would make the benchmark a different (and much easier) retrieval task. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import os |
| import shutil |
| import sqlite3 |
| import tempfile |
| from collections import Counter, defaultdict |
| from datetime import datetime, timezone |
| from pathlib import Path |
| from typing import Any, Iterable |
|
|
| try: |
| from .common import read_jsonl |
| from .corpus_db import fts_counts, search_docids, status_counts |
| except ImportError: |
| from common import read_jsonl |
| from corpus_db import fts_counts, search_docids, status_counts |
|
|
|
|
| RELEASE_NAME = "deepresearch9k-frontier-v1" |
| DATABASE_RELEASE_PATH = Path("search/corpus.sqlite3") |
| CHECKSUMS_PATH = Path("checksums.sha256") |
| MANIFEST_PATH = Path("manifest.json") |
|
|
| PROBE_QUERIES = ( |
| "research history university film", |
| "Eye Of The Eagle Italian beach comedy filmmaker", |
| ) |
|
|
|
|
| def sha256_file(path: Path) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as handle: |
| for chunk in iter(lambda: handle.read(8 * 1024 * 1024), b""): |
| digest.update(chunk) |
| return digest.hexdigest() |
|
|
|
|
| def load_json(path: Path) -> dict[str, Any]: |
| value = json.loads(path.read_text(encoding="utf-8")) |
| if not isinstance(value, dict): |
| raise ValueError(f"expected a JSON object: {path}") |
| return value |
|
|
|
|
| def write_json(path: Path, value: Any) -> None: |
| path.write_text( |
| json.dumps(value, ensure_ascii=False, indent=2, sort_keys=True) + "\n", |
| encoding="utf-8", |
| ) |
|
|
|
|
| def require(condition: bool, message: str) -> None: |
| if not condition: |
| raise ValueError(message) |
|
|
|
|
| def relative_artifact(path: str | Path) -> Path: |
| result = Path(path) |
| require(not result.is_absolute(), f"release artifact path must be relative: {result}") |
| require(".." not in result.parts, f"release artifact path escapes release: {result}") |
| return result |
|
|
|
|
| def benchmark_inventory(rows: Iterable[dict[str, Any]]) -> dict[str, Any]: |
| rows = list(rows) |
| require(bool(rows), "benchmark has no questions") |
| qids: list[str] = [] |
| indexes: list[int] = [] |
| composition: dict[str, Counter[str]] = defaultdict(Counter) |
| difficulties: Counter[str] = Counter() |
| teacher_correct: Counter[str] = Counter() |
| provenance_docids: set[str] = set() |
|
|
| for position, row in enumerate(rows): |
| metadata = row.get("metadata") or {} |
| benchmark = metadata.get("benchmark") or {} |
| qid = str(metadata.get("qid") or "") |
| index = benchmark.get("index") |
| require(qid != "", f"question {position} has no qid") |
| require(metadata.get("manifest_qid") == qid, f"question {position} manifest_qid mismatch") |
| require(index == position, f"question {position} has benchmark index {index!r}") |
| require(benchmark.get("name") == RELEASE_NAME, f"question {position} benchmark name mismatch") |
| require(str(row.get("label") or "").strip() != "", f"question {position} has an empty label") |
| require(isinstance(row.get("prompt"), list) and row["prompt"], f"question {position} has no prompt") |
|
|
| tier = str(benchmark.get("calibration_tier") or "") |
| bucket = str(benchmark.get("selection_bucket") or "") |
| require(tier in {"frontier", "challenge"}, f"question {position} has invalid tier {tier!r}") |
| require(bucket in {"hard_open", "reformulate"}, f"question {position} has invalid bucket {bucket!r}") |
| docids = benchmark.get("clean_provenance_answer_docids") or [] |
| require(bool(docids), f"question {position} has no clean provenance answer document") |
| require(all(isinstance(docid, str) and docid for docid in docids), f"question {position} has invalid docids") |
|
|
| qids.append(qid) |
| indexes.append(int(index)) |
| composition[tier][bucket] += 1 |
| difficulties[str(metadata.get("difficulty"))] += 1 |
| teacher_correct[str(bool(metadata.get("teacher_correct"))).lower()] += 1 |
| provenance_docids.update(docids) |
|
|
| require(len(set(qids)) == len(qids), "benchmark contains duplicate qids") |
| require(indexes == list(range(len(rows))), "benchmark indexes are not contiguous") |
| return { |
| "questions": len(rows), |
| "unique_qids": len(set(qids)), |
| "index_range": [0, len(rows) - 1], |
| "composition": { |
| tier: dict(sorted(buckets.items())) |
| for tier, buckets in sorted(composition.items()) |
| }, |
| "difficulty": dict(sorted(difficulties.items())), |
| "teacher_correct": dict(sorted(teacher_correct.items())), |
| "clean_provenance_answer_documents": len(provenance_docids), |
| } |
|
|
|
|
| def result_inventory( |
| rows: Iterable[dict[str, Any]], |
| questions: list[dict[str, Any]], |
| *, |
| seed_base: int, |
| ) -> dict[str, Any]: |
| rows = list(rows) |
| require(len(rows) == len(questions), f"result has {len(rows)} rows, expected {len(questions)}") |
| expected = { |
| int(question["metadata"]["benchmark"]["index"]): question["metadata"]["qid"] |
| for question in questions |
| } |
| seen: set[int] = set() |
| judge_correct = 0.0 |
| local_em_correct = 0.0 |
| turns = 0 |
| searches = 0 |
| opens = 0 |
| empty_answers = 0 |
| stop_reasons: Counter[str] = Counter() |
| by_stratum: dict[str, Counter[str]] = defaultdict(Counter) |
|
|
| for row in rows: |
| index = int(row["index"]) |
| require(index not in seen, f"duplicate result index {index}") |
| require(expected.get(index) == row.get("qid"), f"result qid mismatch at index {index}") |
| require(row.get("sampling_seed") == seed_base + index, f"sampling seed mismatch at index {index}") |
| seen.add(index) |
|
|
| judge_score = float(row.get("judge_score", 0) or 0) |
| local_em = float(row.get("local_em", 0) or 0) |
| require(judge_score in {0.0, 1.0}, f"invalid judge score at index {index}") |
| require(local_em in {0.0, 1.0}, f"invalid local EM at index {index}") |
| judge_correct += judge_score |
| local_em_correct += local_em |
| turns += int(row.get("num_turns", 0) or 0) |
| tool_stats = row.get("tool_stats") or {} |
| searches += int(tool_stats.get("search", 0) or 0) |
| opens += int(tool_stats.get("open_page", 0) or 0) |
| empty_answers += int(not str(row.get("predicted") or "").strip()) |
| stop_reasons[str(row.get("stop_reason") or "unknown")] += 1 |
| benchmark = row.get("benchmark") or {} |
| stratum = f"{benchmark.get('calibration_tier')}/{benchmark.get('selection_bucket')}" |
| by_stratum[stratum]["questions"] += 1 |
| by_stratum[stratum]["judge_correct"] += int(judge_score) |
| by_stratum[stratum]["local_em_correct"] += int(local_em) |
|
|
| require(seen == set(expected), "result indexes do not exactly cover the benchmark") |
| count = len(rows) |
| return { |
| "questions": count, |
| "sampling_seed_base": seed_base, |
| "sampling_seed_range": [seed_base, seed_base + count - 1], |
| "judge_correct": int(judge_correct), |
| "judge_accuracy": judge_correct / count, |
| "local_em_correct": int(local_em_correct), |
| "local_em_accuracy": local_em_correct / count, |
| "mean_turns": turns / count, |
| "search_calls": searches, |
| "open_page_calls": opens, |
| "empty_answers": empty_answers, |
| "stop_reasons": dict(sorted(stop_reasons.items())), |
| "by_stratum": { |
| stratum: dict(sorted(values.items())) |
| for stratum, values in sorted(by_stratum.items()) |
| }, |
| } |
|
|
|
|
| def connect_immutable(path: Path) -> sqlite3.Connection: |
| connection = sqlite3.connect( |
| f"file:{path.resolve()}?mode=ro&immutable=1", |
| uri=True, |
| check_same_thread=False, |
| ) |
| connection.row_factory = sqlite3.Row |
| return connection |
|
|
|
|
| def database_inventory(path: Path) -> dict[str, Any]: |
| connection = connect_immutable(path) |
| try: |
| statuses = status_counts(connection) |
| indexed = fts_counts(connection) |
| return { |
| "sqlite_version": sqlite3.sqlite_version, |
| "page_size": int(connection.execute("PRAGMA page_size").fetchone()[0]), |
| "page_count": int(connection.execute("PRAGMA page_count").fetchone()[0]), |
| "freelist_count": int(connection.execute("PRAGMA freelist_count").fetchone()[0]), |
| "documents": int(connection.execute("SELECT count(*) FROM documents").fetchone()[0]), |
| "fetch_status": dict(sorted(statuses.items())), |
| "url_aliases": int(connection.execute("SELECT count(*) FROM url_aliases").fetchone()[0]), |
| "qid_links": int(connection.execute("SELECT count(*) FROM document_qids").fetchone()[0]), |
| "distinct_qids": int( |
| connection.execute("SELECT count(DISTINCT qid) FROM document_qids").fetchone()[0] |
| ), |
| "domains": int(connection.execute("SELECT count(DISTINCT domain) FROM documents").fetchone()[0]), |
| "fts_documents": indexed["documents"], |
| "fts_chunks": indexed["chunks"], |
| } |
| finally: |
| connection.close() |
|
|
|
|
| def search_probe_inventory(path: Path, blocked: frozenset[str]) -> list[dict[str, Any]]: |
| connection = connect_immutable(path) |
| try: |
| return [ |
| { |
| "query": query, |
| "k": 5, |
| "docids": search_docids(connection, query, 5, excluded_docids=blocked), |
| } |
| for query in PROBE_QUERIES |
| ] |
| finally: |
| connection.close() |
|
|
|
|
| def copied_source_layout(data_root: Path, base_results_dir: Path, rl_results_dir: Path) -> dict[Path, Path]: |
| frontier = data_root / "benchmarks/frontier_v1" |
| candidates = data_root / "benchmarks/frontier_candidates_v1" |
| pilot_results = data_root / "eval/frontier_base_pilot_v1_20260810_2202_merged" |
| return { |
| Path("benchmark/questions.jsonl"): frontier / "questions.jsonl", |
| Path("benchmark/blocked_docids.txt"): frontier / "blocked_docids.txt", |
| Path("benchmark/summary.json"): frontier / "summary.json", |
| Path("selection/pilot_audit.jsonl"): frontier / "pilot_audit.jsonl", |
| Path("selection/pilot_supply.json"): frontier / "pilot_supply.json", |
| Path("selection/candidates.jsonl"): candidates / "candidates.jsonl", |
| Path("selection/pilot_data.jsonl"): candidates / "base_pilot.jsonl", |
| Path("selection/candidate_summary.json"): candidates / "summary.json", |
| Path("selection/blocked_documents.jsonl"): candidates / "blocked_documents.jsonl", |
| Path("selection/pilot_results.jsonl"): pilot_results / "final_results.jsonl", |
| Path("baselines/qwen3-8b/final_results.jsonl"): base_results_dir / "final_results.jsonl", |
| Path("baselines/qwen3-8b/summary.json"): base_results_dir / "final_results.summary.json", |
| Path("baselines/browsecomp-rl-iter199/final_results.jsonl"): rl_results_dir / "final_results.jsonl", |
| Path("baselines/browsecomp-rl-iter199/summary.json"): rl_results_dir / "final_results.summary.json", |
| Path("search/coverage_summary.json"): data_root / "coverage_full_hq/summary.json", |
| Path("search/source_manifest_summary.json"): data_root / "train_manifest_final/summary.json", |
| } |
|
|
|
|
| def regular_release_files(release_dir: Path) -> list[Path]: |
| return sorted( |
| path.relative_to(release_dir) |
| for path in release_dir.rglob("*") |
| if path.is_file() |
| and not path.is_symlink() |
| and path.relative_to(release_dir) not in { |
| CHECKSUMS_PATH, |
| DATABASE_RELEASE_PATH, |
| } |
| and not ( |
| {".cache", "__pycache__"} |
| & set(path.relative_to(release_dir).parts) |
| ) |
| ) |
|
|
|
|
| def write_checksums(release_dir: Path) -> None: |
| lines = [ |
| "# Regular release artifacts. The 3.5 GB database is pinned in manifest.json", |
| "# and is hashed by: frontier_release.py validate --deep", |
| ] |
| for relative in regular_release_files(release_dir): |
| lines.append(f"{sha256_file(release_dir / relative)} {relative.as_posix()}") |
| (release_dir / CHECKSUMS_PATH).write_text("\n".join(lines) + "\n", encoding="utf-8") |
|
|
|
|
| def checksums_from_file(path: Path) -> dict[Path, str]: |
| result: dict[Path, str] = {} |
| for line_number, line in enumerate(path.read_text(encoding="utf-8").splitlines(), start=1): |
| if not line or line.startswith("#"): |
| continue |
| parts = line.split(None, 1) |
| require(len(parts) == 2, f"invalid checksum line {line_number}") |
| digest, filename = parts |
| relative = relative_artifact(filename.strip()) |
| require(len(digest) == 64, f"invalid SHA-256 on checksum line {line_number}") |
| require(relative not in result, f"duplicate checksum entry: {relative}") |
| result[relative] = digest |
| return result |
|
|
|
|
| def release_readme(manifest: dict[str, Any]) -> str: |
| database = manifest["database"] |
| base = manifest["baselines"]["qwen3-8b"]["metrics"] |
| rl = manifest["baselines"]["browsecomp-rl-iter199"]["metrics"] |
| return f"""# DeepResearch-9K frontier-v1 frozen diagnostic release |
| |
| This directory binds one evaluation set to the exact offline-search snapshot, |
| selection audit, and paired reference runs used with it. It is an **internal, |
| train-provenance diagnostic**, not a clean held-out DeepResearch-9K score. |
| |
| Do not replace `search/corpus.sqlite3` with a database containing only the |
| answer pages. The release uses the complete {database['inventory']['documents']:,}-URL |
| snapshot because removing distractors changes FTS/BM25 ranks and task difficulty. |
| The database file is a relative symlink to the canonical {database['size_bytes'] / 2**30:.2f} GiB |
| snapshot and is pinned by SHA-256 in `manifest.json`. |
| |
| ## Contents |
| |
| - `benchmark/`: 256 frozen questions, 28 blocked dataset/dump documents, and |
| the final selection summary. |
| - `selection/`: complete 672-question candidate/pilot audit needed to explain |
| why each final question was admitted. |
| - `search/`: the corpus link plus crawl/coverage summaries. |
| - `baselines/`: fresh, paired Qwen3-8B and BrowseComp-RL iter199 results. |
| - `manifest.json`: machine-readable composition, hashes, corpus statistics, |
| retrieval probes, sampling protocol, and baseline metrics. |
| |
| The paired semantic scores are {base['judge_correct']}/256 |
| ({base['judge_accuracy']:.1%}) for Qwen3-8B and {rl['judge_correct']}/256 |
| ({rl['judge_accuracy']:.1%}) for BrowseComp-RL iter199. These are reference |
| runs, not outputs used to select the final 256 questions. |
| |
| ## Validate |
| |
| From the Miles repository root: |
| |
| ```bash |
| python examples/deepresearch9k/frontier_release.py validate \ |
| --release-dir {manifest['release']['canonical_path']} |
| ``` |
| |
| The default validates all small-file hashes, benchmark/result alignment, |
| blocked and answer-bearing document membership, SQLite metadata, and frozen |
| search probes. Use `--deep` before publishing or moving the package; it also |
| hashes the 3.5 GB database and runs SQLite `PRAGMA quick_check`. |
| |
| ## Serve local search |
| |
| ```bash |
| release={manifest['release']['canonical_path']} |
| export DEEPRESEARCH9K_BLOCKED_DOCIDS_FILE="$release/benchmark/blocked_docids.txt" |
| python examples/deepresearch9k/search_server.py \ |
| --database "$release/search/corpus.sqlite3" --host 127.0.0.1 --port 8011 |
| ``` |
| |
| ## Launch a matched evaluation |
| |
| ```bash |
| release={manifest['release']['canonical_path']} |
| DR9K_DATABASE="$release/search/corpus.sqlite3" \ |
| DR9K_EVAL_DATA="$release/benchmark/questions.jsonl" \ |
| DR9K_BLOCKED_DOCIDS_FILE="$release/benchmark/blocked_docids.txt" \ |
| DR9K_MODEL=/path/to/checkpoint \ |
| DR9K_RUN_PREFIX=frontier_v1_my_checkpoint \ |
| EVAL_SEED_BASE=20260811 \ |
| SHARD_SIZE=64 \ |
| sbatch --array=0-3%4 examples/deepresearch9k/run_local_eval_gb300.sbatch |
| ``` |
| |
| Keep temperature `0.6`, top-p `0.95`, top-k `20`, maximum 20 turns, and the |
| same per-index seed when making a paired comparison. New random seeds should |
| be stored as new result runs; do not mutate this release in place. |
| """ |
|
|
|
|
| def build_release(args: argparse.Namespace) -> Path: |
| data_root = args.data_root.resolve() |
| database = (args.database or data_root / "train_corpus_full_hq.sqlite3").resolve() |
| base_results_dir = ( |
| args.base_results_dir |
| or data_root / "eval/frontier_v1_base_qwen3_8b_seed20260811_2215_merged" |
| ).resolve() |
| rl_results_dir = ( |
| args.rl_results_dir |
| or data_root / "eval/frontier_v1_iter199_seed20260811_2219_merged" |
| ).resolve() |
| output = (args.output_dir or data_root / "releases/frontier_v1").resolve() |
| require(not output.exists(), f"refusing to overwrite existing release: {output}") |
| require(database.is_file(), f"database does not exist: {database}") |
| wal_path = Path(str(database) + "-wal") |
| require(not wal_path.exists() or wal_path.stat().st_size == 0, f"database WAL is not empty: {wal_path}") |
|
|
| sources = copied_source_layout(data_root, base_results_dir, rl_results_dir) |
| missing = [str(source) for source in sources.values() if not source.is_file()] |
| require(not missing, "missing source artifacts:\n" + "\n".join(missing)) |
|
|
| output.parent.mkdir(parents=True, exist_ok=True) |
| staging = Path(tempfile.mkdtemp(prefix=f".{output.name}.", dir=output.parent)) |
| try: |
| artifact_manifest: dict[str, dict[str, Any]] = {} |
| for relative, source in sources.items(): |
| destination = staging / relative |
| destination.parent.mkdir(parents=True, exist_ok=True) |
| shutil.copy2(source, destination) |
| artifact_manifest[relative.as_posix()] = { |
| "sha256": sha256_file(destination), |
| "size_bytes": destination.stat().st_size, |
| } |
|
|
| link_path = staging / DATABASE_RELEASE_PATH |
| link_path.parent.mkdir(parents=True, exist_ok=True) |
| link_target = os.path.relpath(database, start=link_path.parent) |
| link_path.symlink_to(link_target) |
|
|
| questions = list(read_jsonl(staging / "benchmark/questions.jsonl")) |
| blocked = frozenset( |
| line.strip() |
| for line in (staging / "benchmark/blocked_docids.txt").read_text(encoding="utf-8").splitlines() |
| if line.strip() |
| ) |
| benchmark = benchmark_inventory(questions) |
| require(len(blocked) == 28, f"expected 28 blocked documents, found {len(blocked)}") |
|
|
| candidate_summary = load_json(staging / "selection/candidate_summary.json") |
| database_sha256 = sha256_file(database) |
| require( |
| candidate_summary.get("database_sha256") == database_sha256, |
| "database no longer matches the snapshot used to build frontier candidates", |
| ) |
| inventory = database_inventory(database) |
| probes = search_probe_inventory(database, blocked) |
|
|
| baseline_specs = { |
| "qwen3-8b": ("baselines/qwen3-8b/final_results.jsonl", "baselines/qwen3-8b/summary.json"), |
| "browsecomp-rl-iter199": ( |
| "baselines/browsecomp-rl-iter199/final_results.jsonl", |
| "baselines/browsecomp-rl-iter199/summary.json", |
| ), |
| } |
| baselines: dict[str, dict[str, Any]] = {} |
| for name, (results_path, summary_path) in baseline_specs.items(): |
| summary = load_json(staging / summary_path) |
| results = list(read_jsonl(staging / results_path)) |
| metrics = result_inventory(results, questions, seed_base=args.seed_base) |
| require(summary.get("questions") == len(questions), f"{name} summary question count mismatch") |
| require( |
| summary.get("output_sha256") == artifact_manifest[results_path]["sha256"], |
| f"{name} summary result hash mismatch", |
| ) |
| require( |
| int(summary["judge_score"]["correct"]) == metrics["judge_correct"], |
| f"{name} summary judge score mismatch", |
| ) |
| baselines[name] = { |
| "model_label": summary.get("model_label"), |
| "results": results_path, |
| "summary": summary_path, |
| "metrics": metrics, |
| } |
|
|
| manifest = { |
| "schema_version": 1, |
| "release": { |
| "name": RELEASE_NAME, |
| "canonical_path": str(output), |
| "created_at_utc": datetime.now(timezone.utc).isoformat(), |
| "classification": "internal_train_provenance_model_calibrated_diagnostic", |
| "held_out_claim_allowed": False, |
| }, |
| "benchmark": { |
| "questions": "benchmark/questions.jsonl", |
| "blocked_docids": "benchmark/blocked_docids.txt", |
| "inventory": benchmark, |
| "blocked_documents": len(blocked), |
| }, |
| "selection": { |
| "candidate_questions": 672, |
| "pilot_episodes": 2016, |
| "pilot_replicas_per_qid": 3, |
| "selection_seed": 20260810, |
| "warning": "Base pilot outputs selected the final qids; only fresh baseline results are scores.", |
| }, |
| "sampling_protocol": { |
| "temperature": 0.6, |
| "top_p": 0.95, |
| "top_k": 20, |
| "maximum_agent_turns": 20, |
| "seed_base": args.seed_base, |
| "per_question_seed": "seed_base + benchmark index", |
| }, |
| "database": { |
| "path": DATABASE_RELEASE_PATH.as_posix(), |
| "storage": "relative_symlink_to_canonical_snapshot", |
| "link_target": link_target, |
| "sha256": database_sha256, |
| "size_bytes": database.stat().st_size, |
| "hash_scope": "main SQLite file; build requires an absent or empty WAL", |
| "retrieval": "SQLite FTS5 unicode61, 800-word chunks, 100-word overlap, BM25", |
| "inventory": inventory, |
| "search_probes": probes, |
| }, |
| "baselines": baselines, |
| "artifacts": artifact_manifest, |
| } |
| write_json(staging / MANIFEST_PATH, manifest) |
| (staging / "README.md").write_text(release_readme(manifest), encoding="utf-8") |
| write_checksums(staging) |
| validate_release(staging, deep=False) |
| staging.rename(output) |
| except Exception: |
| shutil.rmtree(staging, ignore_errors=True) |
| raise |
| return output |
|
|
|
|
| def validate_database_membership( |
| database: Path, |
| questions: list[dict[str, Any]], |
| blocked: frozenset[str], |
| ) -> dict[str, int]: |
| provenance = { |
| docid |
| for question in questions |
| for docid in question["metadata"]["benchmark"]["clean_provenance_answer_docids"] |
| } |
| requested = sorted(provenance | set(blocked)) |
| connection = connect_immutable(database) |
| try: |
| found: dict[str, sqlite3.Row] = {} |
| for start in range(0, len(requested), 500): |
| chunk = requested[start : start + 500] |
| placeholders = ",".join("?" for _ in chunk) |
| for row in connection.execute( |
| f"SELECT url_id,status,length(trim(text)) AS text_length FROM documents WHERE url_id IN ({placeholders})", |
| chunk, |
| ): |
| found[str(row["url_id"])] = row |
| missing_provenance = provenance - set(found) |
| require(not missing_provenance, f"missing provenance documents: {sorted(missing_provenance)[:5]}") |
| bad_provenance = [ |
| docid |
| for docid in provenance |
| if found[docid]["status"] != "success" or int(found[docid]["text_length"] or 0) == 0 |
| ] |
| require(not bad_provenance, f"unusable provenance documents: {sorted(bad_provenance)[:5]}") |
| require(not (provenance & blocked), "answer-bearing provenance overlaps blocked documents") |
| missing_blocked = blocked - set(found) |
| require(not missing_blocked, f"blocked docids absent from database: {sorted(missing_blocked)[:5]}") |
| indexed = fts_counts(connection) |
| return { |
| "provenance_documents": len(provenance), |
| "blocked_documents": len(blocked), |
| "fts_documents": indexed["documents"], |
| "fts_chunks": indexed["chunks"], |
| } |
| finally: |
| connection.close() |
|
|
|
|
| def validate_release(release_dir: Path, *, deep: bool) -> dict[str, Any]: |
| release_dir = release_dir.resolve() |
| require((release_dir / MANIFEST_PATH).is_file(), f"missing {MANIFEST_PATH}") |
| require((release_dir / CHECKSUMS_PATH).is_file(), f"missing {CHECKSUMS_PATH}") |
| manifest = load_json(release_dir / MANIFEST_PATH) |
| require(manifest.get("schema_version") == 1, "unsupported release schema") |
| require(manifest.get("release", {}).get("name") == RELEASE_NAME, "release name mismatch") |
|
|
| checksums = checksums_from_file(release_dir / CHECKSUMS_PATH) |
| expected_regular = set(regular_release_files(release_dir)) |
| require(set(checksums) == expected_regular, "checksums.sha256 does not exactly cover regular release files") |
| for relative, expected_digest in checksums.items(): |
| path = release_dir / relative |
| require(path.is_file() and not path.is_symlink(), f"missing regular artifact: {relative}") |
| require(sha256_file(path) == expected_digest, f"checksum mismatch: {relative}") |
|
|
| for filename, metadata in manifest.get("artifacts", {}).items(): |
| relative = relative_artifact(filename) |
| path = release_dir / relative |
| require(path.is_file(), f"missing manifest artifact: {relative}") |
| require(path.stat().st_size == metadata["size_bytes"], f"size mismatch: {relative}") |
| require(checksums.get(relative) == metadata["sha256"], f"manifest hash mismatch: {relative}") |
|
|
| questions_path = release_dir / manifest["benchmark"]["questions"] |
| blocked_path = release_dir / manifest["benchmark"]["blocked_docids"] |
| questions = list(read_jsonl(questions_path)) |
| blocked = frozenset( |
| line.strip() for line in blocked_path.read_text(encoding="utf-8").splitlines() if line.strip() |
| ) |
| benchmark = benchmark_inventory(questions) |
| require(benchmark == manifest["benchmark"]["inventory"], "benchmark inventory mismatch") |
| require(len(blocked) == manifest["benchmark"]["blocked_documents"], "blocked count mismatch") |
|
|
| database_metadata = manifest["database"] |
| database = release_dir / relative_artifact(database_metadata["path"]) |
| require(database.is_file(), f"missing database target: {database}") |
| require(database.stat().st_size == database_metadata["size_bytes"], "database size mismatch") |
| membership = validate_database_membership(database, questions, blocked) |
| require( |
| membership["fts_documents"] == database_metadata["inventory"]["fts_documents"], |
| "FTS document count mismatch", |
| ) |
| require( |
| membership["fts_chunks"] == database_metadata["inventory"]["fts_chunks"], |
| "FTS chunk count mismatch", |
| ) |
| probes = search_probe_inventory(database, blocked) |
| require(probes == database_metadata["search_probes"], "frozen search probe results changed") |
|
|
| seed_base = int(manifest["sampling_protocol"]["seed_base"]) |
| baseline_metrics: dict[str, dict[str, Any]] = {} |
| for name, baseline in manifest["baselines"].items(): |
| rows = list(read_jsonl(release_dir / relative_artifact(baseline["results"]))) |
| metrics = result_inventory(rows, questions, seed_base=seed_base) |
| require(metrics == baseline["metrics"], f"baseline metrics mismatch: {name}") |
| baseline_metrics[name] = metrics |
|
|
| deep_checks: dict[str, Any] | None = None |
| if deep: |
| database_sha256 = sha256_file(database) |
| require(database_sha256 == database_metadata["sha256"], "database SHA-256 mismatch") |
| connection = connect_immutable(database) |
| try: |
| quick_check = [str(row[0]) for row in connection.execute("PRAGMA quick_check")] |
| finally: |
| connection.close() |
| require(quick_check == ["ok"], f"SQLite quick_check failed: {quick_check[:5]}") |
| deep_checks = {"database_sha256": database_sha256, "sqlite_quick_check": "ok"} |
|
|
| return { |
| "release": RELEASE_NAME, |
| "release_dir": str(release_dir), |
| "questions": len(questions), |
| "blocked_documents": len(blocked), |
| "database_membership": membership, |
| "search_probes": len(probes), |
| "baselines": { |
| name: { |
| "judge_correct": metrics["judge_correct"], |
| "judge_accuracy": metrics["judge_accuracy"], |
| } |
| for name, metrics in baseline_metrics.items() |
| }, |
| "deep_checks": deep_checks, |
| "status": "ok", |
| } |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser(description=__doc__) |
| subparsers = parser.add_subparsers(dest="command", required=True) |
|
|
| build = subparsers.add_parser("build", help="create a new frozen thin release") |
| build.add_argument("--data-root", type=Path, required=True) |
| build.add_argument("--database", type=Path) |
| build.add_argument("--base-results-dir", type=Path) |
| build.add_argument("--rl-results-dir", type=Path) |
| build.add_argument("--output-dir", type=Path) |
| build.add_argument("--seed-base", type=int, default=20260811) |
|
|
| validate = subparsers.add_parser("validate", help="validate an existing release") |
| validate.add_argument("--release-dir", type=Path, required=True) |
| validate.add_argument( |
| "--deep", |
| action="store_true", |
| help="also hash the multi-gigabyte database and run SQLite quick_check", |
| ) |
| return parser.parse_args() |
|
|
|
|
| def main() -> None: |
| args = parse_args() |
| if args.command == "build": |
| output = build_release(args) |
| result = validate_release(output, deep=False) |
| result["created"] = str(output) |
| else: |
| result = validate_release(args.release_dir, deep=args.deep) |
| print(json.dumps(result, ensure_ascii=False, indent=2, sort_keys=True)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
