"""Build a leakage-separated Common-264 experiment bundle.""" from __future__ import annotations import json import shutil from collections import defaultdict from pathlib import Path from typing import Any from .schema import validate_planner_input def read_jsonl(path: Path) -> list[dict[str, Any]]: return [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line.strip()] def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None: path.parent.mkdir(parents=True, exist_ok=True) with path.open("w", encoding="utf-8") as handle: for row in rows: handle.write(json.dumps(row, ensure_ascii=False) + "\n") def load(path: Path) -> dict[str, Any]: return json.loads(path.read_text(encoding="utf-8")) def _dependency_index(path: Path) -> dict[str, dict[str, Any]]: grouped: dict[str, list[dict[str, Any]]] = defaultdict(list) for row in read_jsonl(path): grouped[str(row["case_id"])].append(row) return {case_id: rows[0] for case_id, rows in grouped.items() if len(rows) == 1} def _balanced_sample(rows: list[dict[str, Any]], per_level: int) -> list[dict[str, Any]]: result: list[dict[str, Any]] = [] for level in ("L1", "L2", "L3"): families: dict[str, list[dict[str, Any]]] = defaultdict(list) for row in rows: if row.get("dependency_prelabel") == level: families[str(row["case_family"])].append(row) for values in families.values(): values.sort(key=lambda item: (int(item["position"]), str(item["uid"]))) names = sorted(families) selected: list[dict[str, Any]] = [] cursor = 0 while len(selected) < per_level and names: name = names[cursor % len(names)] if families[name]: selected.append(families[name].pop(0)) names = [item for item in names if families[item]] cursor += 1 if len(selected) != per_level: raise ValueError(f"insufficient {level} cases: wanted {per_level}, found {len(selected)}") result.extend(selected) return sorted(result, key=lambda item: int(item["position"])) def build_bundle( *, common_cases_path: Path, portable_dir: Path, dependency_path: Path, output_dir: Path, ) -> dict[str, Any]: common = read_jsonl(common_cases_path) source_generation = read_jsonl(portable_dir / "generation_manifest.jsonl") generation_by_uid = {str(row["uid"]): row for row in source_generation} source_batch = load(portable_dir / "batch_manifest.json") batch_by_uid = {str(row["uid"]): row for row in source_batch["cases"]} source_contract_manifest = load(portable_dir / "contract_manifest.json") contract_by_uid = {str(row["uid"]): row for row in source_contract_manifest["cases"]} dependency = _dependency_index(dependency_path) frozen = output_dir / "frozen" assets = frozen / "assets" contracts = frozen / "contracts" assets.mkdir(parents=True, exist_ok=True) contracts.mkdir(parents=True, exist_ok=True) generation_rows: list[dict[str, Any]] = [] batch_rows: list[dict[str, Any]] = [] contract_rows: list[dict[str, Any]] = [] planner_rows: list[dict[str, Any]] = [] selection_rows: list[dict[str, Any]] = [] for index, common_row in enumerate(common, 1): uid = str(common_row["uid"]) source_gen = generation_by_uid[uid] source_asset = (portable_dir / source_gen["input_image"]).resolve() suffix = source_asset.suffix.lower() or ".jpg" asset_name = f"{index:03d}{suffix}" destination = assets / asset_name shutil.copy2(source_asset, destination) contract_item = contract_by_uid[uid] source_contract = (portable_dir / contract_item["contract_path"]).resolve() contract_name = f"{index:03d}.json" shutil.copy2(source_contract, contracts / contract_name) relative_image = f"assets/{asset_name}" instruction = str(source_gen["instruction"]) base_meta = { key: source_gen.get(key) for key in ( "position", "uid", "source_uid", "case_id", "case_family", "source", "top_level", "approval_batch", "reasoning_depth", "primary_operator", "analysis_weight", ) } generation_rows.append({**base_meta, "input_image": relative_image, "instruction": instruction}) source_batch_item = batch_by_uid[uid] batch_rows.append({**source_batch_item, "input_image": relative_image, "gt_image": None}) contract_rows.append({**contract_item, "contract_path": f"contracts/{contract_name}"}) planner_row = { **base_meta, "input_image": f"frozen/assets/{asset_name}", "instruction": instruction, } issues = validate_planner_input(planner_row) if issues: raise ValueError(f"planner input leakage/schema failure for {uid}: {issues}") planner_rows.append(planner_row) prelabel = dependency.get(str(source_gen["case_id"])) selection_rows.append( { **base_meta, "dependency_prelabel": prelabel.get("level") if prelabel else None, "dependency_prelabel_confidence": prelabel.get("confidence") if prelabel else None, "dependency_prelabel_status": "single_model_sampling_only" if prelabel else "unavailable", } ) if len(generation_rows) != 264 or len({row["uid"] for row in generation_rows}) != 264: raise ValueError("Common bundle must contain exactly 264 unique UIDs") write_jsonl(frozen / "generation_manifest.jsonl", generation_rows) write_jsonl(output_dir / "planner_inputs.jsonl", planner_rows) write_jsonl(output_dir / "selection_manifest.jsonl", selection_rows) (frozen / "batch_manifest.json").write_text( json.dumps({"schema_version": "solveedit.common264_batch.v1", "case_count": 264, "cases": batch_rows}, ensure_ascii=False, indent=2) + "\n" ) (frozen / "contract_manifest.json").write_text( json.dumps({"schema_version": "solveedit.common264_contracts.v1", "case_count": 264, "cases": contract_rows}, ensure_ascii=False, indent=2) + "\n" ) eligible = [row for row in selection_rows if row.get("dependency_prelabel") in {"L1", "L2", "L3"}] pilot = _balanced_sample(eligible, 16) pilot_uids = {row["uid"] for row in pilot} pilot_planner = [row for row in planner_rows if row["uid"] in pilot_uids] by_level: dict[str, list[dict[str, Any]]] = defaultdict(list) for row in pilot: by_level[str(row["dependency_prelabel"])].append(row) smoke_selection = [] for level in ("L1", "L2", "L3"): smoke_selection.extend(by_level[level][:4]) smoke_uids = {row["uid"] for row in smoke_selection} smoke_planner = [row for row in planner_rows if row["uid"] in smoke_uids] write_jsonl(output_dir / "pilot48_selection.jsonl", pilot) write_jsonl(output_dir / "pilot48_planner_inputs.jsonl", pilot_planner) write_jsonl(output_dir / "smoke12_selection.jsonl", smoke_selection) write_jsonl(output_dir / "smoke12_planner_inputs.jsonl", smoke_planner) def write_subset(prefix: str, wanted: set[str]) -> None: subset_generation = [row for row in generation_rows if row["uid"] in wanted] subset_batch = [row for row in batch_rows if row["uid"] in wanted] subset_contracts = [row for row in contract_rows if row["uid"] in wanted] if not (len(subset_generation) == len(subset_batch) == len(subset_contracts) == len(wanted)): raise ValueError(f"incomplete {prefix} frozen subset") write_jsonl(frozen / f"{prefix}_direct_manifest.jsonl", subset_generation) (frozen / f"{prefix}_batch_manifest.json").write_text( json.dumps( {"schema_version": f"solveedit.{prefix}_batch.v1", "case_count": len(wanted), "cases": subset_batch}, ensure_ascii=False, indent=2, ) + "\n" ) (frozen / f"{prefix}_contract_manifest.json").write_text( json.dumps( { "schema_version": f"solveedit.{prefix}_contracts.v1", "case_count": len(wanted), "cases": subset_contracts, }, ensure_ascii=False, indent=2, ) + "\n" ) write_subset("smoke12", smoke_uids) write_subset("pilot48", pilot_uids) summary = { "schema_version": "solveedit.harness_common264_bundle.v1", "common_cases": 264, "prelabel_matched": len(eligible), "prelabel_note": "single-model metadata used only for stratified sampling; not human gold", "pilot48": len(pilot), "smoke12": len(smoke_selection), "output_dir": str(output_dir.resolve()), } (output_dir / "bundle_summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2) + "\n") return summary