docking_pipeline/benchmark_adaptive.py

from __future__ import annotations

import argparse
import csv
import json
import math
import os
import random
import shutil
import time
import traceback
from dataclasses import dataclass
from pathlib import Path
from typing import Any

from .audit_benchmark import audit_benchmark_run
from .dataset import read_ligand_metadata, repair_dataset_dir, validate_dataset_dir
from .provenance import RDockPipelineError, probe_version, require_executable, require_file, sha256_file
from .rdock import RDockEngine, RDockRunConfig, TargetConfig, load_target_config
from .reports.plots import plot_multifidelity_outputs, plot_score_outputs
from .sdf import ligand_id_from_block, parse_tags, split_sdf_file, write_rows_csv, write_sdf_blocks

try:
    from libs.adaptive.surrogate_model import SurrogateConfig, SurrogateModel
except Exception:  # pragma: no cover
    SurrogateConfig = None  # type: ignore[assignment]
    SurrogateModel = None  # type: ignore[assignment]

try:  # pragma: no cover
    from sklearn.ensemble import ExtraTreesClassifier, ExtraTreesRegressor, RandomForestRegressor
    from sklearn.ensemble import HistGradientBoostingRegressor
    from sklearn.linear_model import LogisticRegression, Ridge
    SKLEARN_AVAILABLE = True
except Exception:  # pragma: no cover
    ExtraTreesClassifier = None  # type: ignore[assignment]
    ExtraTreesRegressor = None  # type: ignore[assignment]
    RandomForestRegressor = None  # type: ignore[assignment]
    HistGradientBoostingRegressor = None  # type: ignore[assignment]
    LogisticRegression = None  # type: ignore[assignment]
    Ridge = None  # type: ignore[assignment]
    SKLEARN_AVAILABLE = False

try:  # pragma: no cover
    from rdkit import Chem, DataStructs, RDLogger
    from rdkit.Chem import AllChem, Descriptors, MACCSkeys, rdMolDescriptors
    from rdkit.Chem.Scaffolds import MurckoScaffold
    try:
        from rdkit.Chem.EnumerateStereoisomers import EnumerateStereoisomers, StereoEnumerationOptions
    except Exception:  # pragma: no cover
        EnumerateStereoisomers = None  # type: ignore[assignment]
        StereoEnumerationOptions = None  # type: ignore[assignment]
    try:
        from rdkit.Chem.MolStandardize import rdMolStandardize  # type: ignore
    except Exception:  # pragma: no cover
        rdMolStandardize = None  # type: ignore[assignment]
    RDKit_AVAILABLE = True
    RDLogger.DisableLog("rdApp.warning")
except Exception:  # pragma: no cover
    Chem = None  # type: ignore[assignment]
    DataStructs = None  # type: ignore[assignment]
    AllChem = None  # type: ignore[assignment]
    Descriptors = None  # type: ignore[assignment]
    MACCSkeys = None  # type: ignore[assignment]
    rdMolDescriptors = None  # type: ignore[assignment]
    MurckoScaffold = None  # type: ignore[assignment]
    EnumerateStereoisomers = None  # type: ignore[assignment]
    StereoEnumerationOptions = None  # type: ignore[assignment]
    rdMolStandardize = None  # type: ignore[assignment]
    RDKit_AVAILABLE = False


def _read_rows(path: str | Path) -> list[dict[str, str]]:
    with Path(path).open("r", encoding="utf-8", newline="") as handle:
        return list(csv.DictReader(handle))


def _write_json(path: str | Path, payload: dict[str, Any]) -> Path:
    target = Path(path)
    target.parent.mkdir(parents=True, exist_ok=True)
    target.write_text(json.dumps(payload, indent=2), encoding="utf-8")
    return target


def _load_json(path: str | Path) -> dict[str, Any]:
    source = require_file(path, "JSON artifact")
    payload = json.loads(source.read_text(encoding="utf-8"))
    if not isinstance(payload, dict):
        raise RDockPipelineError(f"Expected JSON object in {source}")
    return payload


def _float(value: object, default: float = 0.0) -> float:
    try:
        text = str(value).strip()
        if not text:
            return default
        return float(text)
    except Exception:
        return default


def _bool_text(value: bool) -> str:
    return "true" if value else "false"


def _parse_levels(text: str) -> list[int]:
    try:
        levels = [int(part.strip()) for part in text.split(",") if part.strip()]
    except Exception as exc:
        raise RDockPipelineError(f"Invalid --fidelity-levels value {text!r}: {exc}") from exc
    if not levels or sorted(levels) != levels or min(levels) <= 0:
        raise RDockPipelineError(f"Invalid fidelity levels: {levels}")
    return levels


def _write_yaml_like(path: Path, payload: dict[str, Any]) -> None:
    try:
        import yaml

        text = yaml.safe_dump(payload, sort_keys=False)
    except Exception:
        text = json.dumps(payload, indent=2)
    path.write_text(text, encoding="utf-8")


def _bool_arg(value: object, default: bool = False) -> bool:
    text = str(value).strip().lower()
    if not text:
        return default
    return text in {"1", "true", "yes", "y", "on"}


def _count_sdf(path: Path) -> int:
    return len(split_sdf_file(path))


def _load_input_block_map(sdf_path: Path) -> dict[str, str]:
    block_map: dict[str, str] = {}
    for idx, block in enumerate(split_sdf_file(sdf_path)):
        tags = parse_tags(block)
        ligand_id = ligand_id_from_block(block, tags, idx)
        block_map[ligand_id] = block
    return block_map


def _write_selected_sdf(block_map: dict[str, str], ligand_ids: list[str], out_path: Path) -> Path:
    missing = [ligand_id for ligand_id in ligand_ids if ligand_id not in block_map]
    if missing:
        raise RDockPipelineError(f"Missing {len(missing)} ligand IDs in prepared SDF: {missing[:10]}")
    write_sdf_blocks([block_map[ligand_id] for ligand_id in ligand_ids], out_path)
    return out_path


def _mean(values: list[float]) -> float:
    return sum(values) / len(values) if values else 0.0


def _stdev(values: list[float], center: float) -> float:
    if not values:
        return 1.0
    var = sum((value - center) ** 2 for value in values) / max(1, len(values))
    return math.sqrt(var) or 1.0


def _component_sane_score(row: dict[str, Any]) -> float | None:
    for key in ("ranking_score", "final_score", "SCORE", "best_score"):
        value = _float(row.get(key), float("inf"))
        if math.isfinite(value):
            return value
    return None


def _score_target_value(row: dict[str, Any], target: str) -> float | None:
    target_name = str(target or "component_sane_affinity_like").strip().lower()
    raw_score = _float(row.get("SCORE"), float("inf"))
    filtered_score = _component_sane_score(row)
    score_inter = _float(row.get("SCORE.INTER"), float("inf"))
    if target_name == "raw_score":
        return raw_score if math.isfinite(raw_score) else None
    if target_name in {"filtered_score", "downranked_score", "component_sane_score"}:
        return filtered_score
    if target_name == "score_inter":
        return score_inter if math.isfinite(score_inter) else None
    if target_name in {"affinity_like", "component_sane_affinity_like"}:
        return (-filtered_score) if filtered_score is not None else None
    return (-filtered_score) if filtered_score is not None else None


def _state_overrides_from_rows(rows: list[dict[str, Any]]) -> dict[str, dict[str, Any]]:
    overrides: dict[str, dict[str, Any]] = {}
    for row in rows:
        ligand_id = str(row.get("ligand_id", ""))
        if not ligand_id:
            continue
        score = _component_sane_score(row)
        inter_val = _float(row.get("SCORE.INTER"), 0.0)
        intra_val = _float(row.get("SCORE.INTRA"), 0.0)
        intra_fraction = _float(row.get("intra_fraction"), 0.0)
        selected_level = int(_float(row.get("selected_fidelity_runs"), 0.0) or 0)
        overrides[ligand_id] = {
            "selected_fidelity_runs": selected_level,
            "current_best_score": score if score is not None else 0.0,
            "score_mean_observed": score if score is not None else 0.0,
            "score_std_observed": 0.0,
            "best_inter_seen": inter_val,
            "best_intra_seen": intra_val,
            "best_intra_fraction_seen": intra_fraction,
            "failed_observation_fraction": 0.0 if str(row.get("rdock_success", "true")).lower() in {"true", "1"} else 1.0,
            "pose_count_seen": int(_float(row.get("n_poses"), 1.0) or 1),
        }
    return overrides


def _split_rows_for_validation(
    rows: list[dict[str, Any]],
    holdout_fraction: float,
    seed: int,
    mode: str,
) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
    if len(rows) < 2:
        return list(rows), []
    holdout_size = max(1, min(len(rows) - 1, int(math.ceil(len(rows) * holdout_fraction))))
    shuffled = list(rows)
    rng = random.Random(seed)
    mode_name = str(mode or "random").strip().lower()
    if mode_name == "cluster":
        clusters: dict[str, list[dict[str, Any]]] = {}
        for row in shuffled:
            clusters.setdefault(str(row.get("cluster_id", "")), []).append(row)
        cluster_ids = list(clusters)
        rng.shuffle(cluster_ids)
        holdout_rows: list[dict[str, Any]] = []
        for cluster_id in cluster_ids:
            if len(holdout_rows) >= holdout_size:
                break
            holdout_rows.extend(clusters[cluster_id])
        holdout_ids = {str(row["ligand_id"]) for row in holdout_rows[:holdout_size]}
        holdout = [row for row in shuffled if str(row["ligand_id"]) in holdout_ids]
        train = [row for row in shuffled if str(row["ligand_id"]) not in holdout_ids]
        if not train or not holdout:
            rng.shuffle(shuffled)
            holdout = shuffled[:holdout_size]
            train = shuffled[holdout_size:] or shuffled[:-1]
        return train, holdout
    rng.shuffle(shuffled)
    holdout = shuffled[:holdout_size]
    train = shuffled[holdout_size:] or shuffled[:-1]
    return train, holdout


def _effective_uncertainty_weight(configured_weight: float, correlation: float | None) -> tuple[float, bool, str]:
    corr = _float(correlation, None)
    if corr is None:
        return 0.0, False, "uncertainty_validation_unavailable"
    if corr < 0.1:
        return 0.0, False, "uncertainty_vs_error_correlation_too_low"
    return min(float(configured_weight), 0.2), True, ""


def _clamp_unit_interval(value: Any) -> float | None:
    numeric = _float(value, None)
    if numeric is None:
        return None
    return max(0.0, min(1.0, float(numeric)))


def _regressor_status_from_metrics(metrics: dict[str, Any]) -> tuple[bool, str]:
    spearman = _float(metrics.get("surrogate_affinity_like_spearman", metrics.get("surrogate_spearman")), None)
    mae = _float(metrics.get("surrogate_mae"), None)
    cluster_spearman = _float(metrics.get("cluster_validation_spearman"), None)
    sign_ok = bool(metrics.get("regressor_sign_check_passed", False))
    if not sign_ok:
        return False, "regressor_sign_check_failed"
    if spearman is None or spearman < 0.3:
        return False, "surrogate_spearman_below_threshold"
    if cluster_spearman is not None and cluster_spearman < 0.2:
        return False, "cluster_aware_spearman_below_threshold"
    if mae is not None and mae > 25.0:
        return False, "surrogate_mae_above_threshold"
    return True, ""


def _augment_full_rows(rows: list[dict[str, str]]) -> list[dict[str, Any]]:
    ordered = sorted(rows, key=lambda row: (_float(row.get("SCORE"), float("inf")), str(row.get("ligand_id", ""))))
    total = max(1, len(ordered))
    enriched: list[dict[str, Any]] = []
    for idx, row in enumerate(ordered, start=1):
        item: dict[str, Any] = dict(row)
        item["full_rank"] = idx
        item["full_percentile"] = 100.0 if total == 1 else 100.0 * (1.0 - ((idx - 1) / (total - 1)))
        enriched.append(item)
    return enriched


def _percentile_from_rank(rank: int, total: int) -> float:
    if total <= 1:
        return 100.0
    return 100.0 * (1.0 - ((rank - 1) / (total - 1)))


def _append_rank_metrics(rows: list[dict[str, Any]], full_rank_map: dict[str, int], total: int) -> list[dict[str, Any]]:
    enriched: list[dict[str, Any]] = []
    for row in rows:
        item = dict(row)
        ligand_id = str(item["ligand_id"])
        rank = full_rank_map.get(ligand_id)
        item["full_rank"] = rank if rank is not None else ""
        item["full_percentile"] = _percentile_from_rank(rank, total) if rank is not None else ""
        enriched.append(item)
    return enriched


def _make_regressor_model(model_type: str) -> Any:
    model_name = str(model_type or "extra_trees").strip().lower()
    if model_name == "random_forest" and RandomForestRegressor is not None:
        return RandomForestRegressor(
            n_estimators=256,
            random_state=42,
            min_samples_leaf=2,
            n_jobs=1,
        )
    if model_name == "hist_gradient_boosting" and HistGradientBoostingRegressor is not None:
        return HistGradientBoostingRegressor(
            random_state=42,
            max_depth=8,
            learning_rate=0.05,
        )
    if model_name == "ridge" and Ridge is not None:
        return Ridge(alpha=1.0, random_state=42)
    if ExtraTreesRegressor is not None:
        return ExtraTreesRegressor(
            n_estimators=256,
            random_state=42,
            min_samples_leaf=2,
            n_jobs=1,
        )
    return None


def _sort_by_score(rows: list[dict[str, Any]], *keys: str) -> list[dict[str, Any]]:
    def _row_score(row: dict[str, Any]) -> float:
        for key in keys:
            value = _float(row.get(key), None)
            if value is not None and math.isfinite(value):
                return value
        return float("inf")

    return sorted(rows, key=lambda row: (_row_score(row), str(row.get("ligand_id", ""))))


def _top_overlap(full_rows: list[dict[str, Any]], sample_rows: list[dict[str, Any]], n: int) -> int:
    full_top = {str(row["ligand_id"]) for row in full_rows[:n]}
    ranked = sorted(sample_rows, key=lambda row: _float(row.get("final_score", row.get("SCORE")), float("inf")))
    sample_top = {str(row["ligand_id"]) for row in ranked[:n] if str(row.get("is_final_fidelity", "")).lower() in {"true", "1"}}
    return len(full_top & sample_top)


def _infer_cluster_id(row: dict[str, str], index: int) -> str:
    for key in ("cluster_id", "scaffold_id", "series_id"):
        value = str(row.get(key, "")).strip()
        if value:
            return value
    smiles = str(row.get("smiles", "")).strip()
    if smiles:
        return smiles[:12]
    return f"cluster_{index:05d}"


def _rdkit_mol(smiles: str):
    if not RDKit_AVAILABLE or not smiles:
        return None
    try:
        return Chem.MolFromSmiles(smiles)
    except Exception:
        return None


def _rdkit_scaffold_id(mol) -> str:
    if not RDKit_AVAILABLE or mol is None:
        return ""
    try:
        scaffold = MurckoScaffold.MurckoScaffoldSmiles(mol=mol)
        return str(scaffold or "")
    except Exception:
        return ""


def _rdkit_fingerprint_bits(mol, n_bits: int = 128) -> list[float]:
    if not RDKit_AVAILABLE or mol is None:
        return [0.0 for _ in range(n_bits)]
    try:
        fp = rdMolDescriptors.GetMorganFingerprintAsBitVect(mol, 2, nBits=n_bits)
        bits = [1.0 if int(fp.GetBit(i)) else 0.0 for i in range(n_bits)]
        if any(bits):
            return bits
    except Exception:
        pass
    try:
        counts = rdMolDescriptors.GetHashedMorganFingerprint(mol, 2, nBits=n_bits)
        bits = [0.0 for _ in range(n_bits)]
        for bit_id, count in counts.GetNonzeroElements().items():
            if int(count) > 0:
                bits[int(bit_id) % n_bits] = 1.0
        return bits
    except Exception:
        return [0.0 for _ in range(n_bits)]


def _rdkit_morgan_count_sum(mol, n_bits: int = 128) -> float:
    if not RDKit_AVAILABLE or mol is None:
        return 0.0
    try:
        counts = rdMolDescriptors.GetHashedMorganFingerprint(mol, 2, nBits=n_bits)
        return float(sum(max(0, int(count)) for count in counts.GetNonzeroElements().values()))
    except Exception:
        return 0.0


def _rdkit_maccs_bits(mol) -> list[float]:
    if not RDKit_AVAILABLE or mol is None or MACCSkeys is None:
        return [0.0 for _ in range(167)]
    try:
        fp = MACCSkeys.GenMACCSKeys(mol)
        return [1.0 if int(fp.GetBit(i)) else 0.0 for i in range(fp.GetNumBits())]
    except Exception:
        return [0.0 for _ in range(167)]


def _rdkit_chiral_center_count(mol) -> float:
    if not RDKit_AVAILABLE or mol is None:
        return 0.0
    try:
        return float(len(Chem.FindMolChiralCenters(mol, includeUnassigned=True)))
    except Exception:
        return 0.0


def _activity_class(p_good: float, uncertainty: float, confidence: float) -> str:
    if p_good >= 0.65 and confidence >= 0.35:
        return "active"
    if p_good <= 0.25 and uncertainty <= 0.75:
        return "inactive"
    return "uncertain"


def _build_model_rows(rows: list[dict[str, str]]) -> list[dict[str, Any]]:
    numeric_keys = [
        "molecular_weight",
        "xlogp",
        "tpsa",
        "hbd",
        "hba",
        "rotatable_bonds",
        "heavy_atom_count",
        "formal_charge",
        "ring_count",
        "aromatic_ring_count",
        "fraction_csp3",
        "heteroatom_count",
        "chiral_center_count",
        "smiles_length",
        "digit_count",
        "branch_count",
        "double_bond_count",
        "triple_bond_count",
        "halogen_count",
        "hetero_fraction",
        "rotor_heavy_ratio",
    ]
    features: dict[str, list[float]] = {key: [] for key in numeric_keys}
    parsed: list[dict[str, Any]] = []
    for idx, row in enumerate(rows):
        item: dict[str, Any] = dict(row)
        smiles = str(row.get("smiles", "")).strip()
        item["smiles"] = smiles
        mol = _rdkit_mol(smiles)
        rdkit_cluster = _rdkit_scaffold_id(mol)
        analog_group_id = str(row.get("analog_group_id", "")).strip()
        analog_group_size = max(1.0, _float(row.get("analog_group_size"), 1.0))
        analog_group_weight = _float(row.get("analog_group_weight"), 1.0 / analog_group_size)
        analog_group_weight = max(0.01, min(1.0, analog_group_weight))
        item["analog_group_id"] = analog_group_id
        item["analog_parent_id"] = str(row.get("analog_parent_id", row.get("ligand_id", "")))
        item["analog_group_size"] = float(analog_group_size)
        item["analog_group_weight"] = float(analog_group_weight)
        item["analog_variant_index"] = _float(row.get("analog_variant_index"), 1.0)
        item["analog_group_rule"] = str(row.get("analog_group_rule", "singleton"))
        item["cluster_id"] = analog_group_id or rdkit_cluster or _infer_cluster_id(row, idx)
        item["scaffold_id"] = rdkit_cluster or str(row.get("scaffold_id", ""))
        scaffold_match = _bool_arg(row.get("scaffold_match"), False)
        is_reference = _bool_arg(row.get("is_reference"), False)
        item["scaffold_match_num"] = 1.0 if scaffold_match else 0.0
        item["is_reference_num"] = 1.0 if is_reference else 0.0
        if RDKit_AVAILABLE and mol is not None:
            item["molecular_weight"] = _float(row.get("molecular_weight"), float(Descriptors.MolWt(mol)))
            item["xlogp"] = _float(row.get("xlogp"), float(Descriptors.MolLogP(mol)))
            item["tpsa"] = _float(row.get("tpsa"), float(rdMolDescriptors.CalcTPSA(mol)))
            item["hbd"] = _float(row.get("hbd"), float(rdMolDescriptors.CalcNumHBD(mol)))
            item["hba"] = _float(row.get("hba"), float(rdMolDescriptors.CalcNumHBA(mol)))
            item["rotatable_bonds"] = _float(row.get("rotatable_bonds"), float(rdMolDescriptors.CalcNumRotatableBonds(mol)))
            item["heavy_atom_count"] = _float(row.get("heavy_atom_count"), float(mol.GetNumHeavyAtoms()))
            item["formal_charge"] = _float(row.get("formal_charge"), float(sum(atom.GetFormalCharge() for atom in mol.GetAtoms())))
            item["ring_count"] = _float(row.get("ring_count"), float(rdMolDescriptors.CalcNumRings(mol)))
            item["aromatic_ring_count"] = _float(row.get("aromatic_ring_count"), float(rdMolDescriptors.CalcNumAromaticRings(mol)))
            item["fraction_csp3"] = _float(row.get("fraction_csp3"), float(rdMolDescriptors.CalcFractionCSP3(mol)))
            item["heteroatom_count"] = _float(row.get("heteroatom_count"), float(sum(1 for atom in mol.GetAtoms() if atom.GetAtomicNum() not in {1, 6})))
            item["chiral_center_count"] = _float(row.get("chiral_center_count"), _rdkit_chiral_center_count(mol))
            fp_bits = _rdkit_fingerprint_bits(mol, 128)
            morgan_count_sum = _rdkit_morgan_count_sum(mol, 128)
            maccs_bits = _rdkit_maccs_bits(mol)
        else:
            item["molecular_weight"] = _float(row.get("molecular_weight"), 0.0)
            item["xlogp"] = _float(row.get("xlogp"), 0.0)
            item["tpsa"] = _float(row.get("tpsa"), 0.0)
            item["hbd"] = _float(row.get("hbd"), 0.0)
            item["hba"] = _float(row.get("hba"), 0.0)
            item["rotatable_bonds"] = _float(row.get("rotatable_bonds"), 0.0)
            item["heavy_atom_count"] = _float(row.get("heavy_atom_count"), 0.0)
            item["formal_charge"] = _float(row.get("formal_charge"), 0.0)
            item["ring_count"] = _float(row.get("ring_count"), smiles.count("1") + smiles.count("2") + smiles.count("3"))
            item["aromatic_ring_count"] = _float(row.get("aromatic_ring_count"), max(0.0, smiles.count("c") / 6.0))
            item["fraction_csp3"] = _float(row.get("fraction_csp3"), min(1.0, max(0.0, smiles.count("C") / max(1.0, float(smiles.count("C") + smiles.count("c"))))))
            hetero_count = sum(smiles.count(token) for token in ("N", "O", "S", "P", "F", "Cl", "Br", "I", "n", "o", "s", "p"))
            item["heteroatom_count"] = _float(row.get("heteroatom_count"), float(hetero_count))
            item["chiral_center_count"] = _float(row.get("chiral_center_count"), 0.0)
            fp_bits = [0.0 for _ in range(128)]
            morgan_count_sum = 0.0
            maccs_bits = [0.0 for _ in range(167)]
        fp_bits = list(fp_bits or [])
        maccs_bits = list(maccs_bits or [])
        if len(fp_bits) != 128:
            fp_bits = (fp_bits + [0.0 for _ in range(128)])[:128]
        if len(maccs_bits) != 167:
            maccs_bits = (maccs_bits + [0.0 for _ in range(167)])[:167]
        item["smiles_length"] = float(len(smiles))
        item["digit_count"] = float(sum(1 for ch in smiles if ch.isdigit()))
        item["branch_count"] = float(smiles.count("("))
        item["double_bond_count"] = float(smiles.count("="))
        item["triple_bond_count"] = float(smiles.count("#"))
        item["halogen_count"] = float(smiles.count("F") + smiles.count("Cl") + smiles.count("Br") + smiles.count("I"))
        item["hetero_fraction"] = float(item["heteroatom_count"]) / max(1.0, float(item["heavy_atom_count"]))
        item["rotor_heavy_ratio"] = float(item["rotatable_bonds"]) / max(1.0, float(item["heavy_atom_count"]))
        item["morgan_nonzero_count"] = float(sum(1 for value in fp_bits if float(value) > 0.0))
        item["morgan_density"] = item["morgan_nonzero_count"] / 128.0
        item["morgan_count_sum"] = float(morgan_count_sum)
        item["maccs_nonzero_count"] = float(sum(1 for value in maccs_bits if float(value) > 0.0))
        sim = _float(row.get("reference_similarity"), 0.0)
        item["reference_similarity"] = sim
        item["reference_core_focus_score"] = float((0.65 * sim) + (0.25 * item["scaffold_match_num"]) + (0.10 * item["is_reference_num"]))
        model_score = _float(
            row.get("model_score"),
            (
                0.10 * sim
                + 0.08 * item["scaffold_match_num"]
                + 0.04 * item["is_reference_num"]
                - 0.002 * float(item["molecular_weight"])
                - 0.03 * float(item["rotatable_bonds"])
            ),
        )
        item["model_score"] = model_score
        for key in numeric_keys:
            value = _float(item.get(key), 0.0)
            item[key] = value
            features[key].append(value)
        item["fingerprint_bits"] = fp_bits
        item["maccs_bits"] = maccs_bits
        parsed.append(item)
    cluster_sizes: dict[str, int] = {}
    for item in parsed:
        cluster_id = str(item["cluster_id"])
        cluster_sizes[cluster_id] = cluster_sizes.get(cluster_id, 0) + 1
    means = {key: _mean(values) for key, values in features.items()}
    stdevs = {key: _stdev(values, means[key]) for key, values in features.items()}
    for item in parsed:
        item["cluster_size"] = cluster_sizes.get(str(item["cluster_id"]), 1)
        item["feature_vector"] = [
            (_float(item[key]) - means[key]) / stdevs[key]
            for key in numeric_keys
        ] + [
            float(item["scaffold_match_num"]),
            float(item["is_reference_num"]),
            float(item["reference_similarity"]),
            float(item["reference_core_focus_score"]),
            float(item["morgan_nonzero_count"]),
            float(item["morgan_density"]),
            float(item["morgan_count_sum"]),
            float(item["maccs_nonzero_count"]),
            float(item["analog_group_size"]),
            float(item["analog_group_weight"]),
            float(item["analog_variant_index"]),
        ] + list(item.get("fingerprint_bits") or []) + list(item.get("maccs_bits") or [])
    return parsed


MODEL_STRATEGIES = {
    "reference_free_triage_bandit_v1",
    "reference_free_active_learning_v2",
    "reference_free_active_learning_v3_diverse_ranker",
    "reference_free_active_learning_v3_lean",
}

TRIAGE_ROW_FIELDS = [
    "ligand_id",
    "smiles",
    "cluster_id",
    "scaffold_id",
    "analog_group_id",
    "analog_parent_id",
    "analog_group_size",
    "analog_group_weight",
    "analog_variant_index",
    "analog_group_rule",
    "survived_triage",
    "triage_score",
    "keep_probability",
    "p_good",
    "regressor_activity_class",
    "predicted_adjusted_score",
    "predicted_affinity_like",
    "predicted_uncertainty",
    "regressor_confidence",
    "outlier_risk",
    "cluster_quality",
    "diversity_bonus",
    "interaction_quality",
    "post_docking_confidence_score",
    "biological_interaction_proxy_score",
    "reference_similarity",
    "reference_core_focus_score",
    "scaffold_match_num",
    "is_reference_num",
    "morgan_nonzero_count",
    "morgan_density",
    "morgan_count_sum",
    "maccs_nonzero_count",
    "adaptive_policy",
    "acquisition_mode",
    "acquisition_classifier_component",
    "acquisition_score_component",
    "acquisition_uncertainty_component",
    "acquisition_diversity_component",
    "acquisition_cluster_component",
    "acquisition_outlier_component",
    "acquisition_interaction_component",
    "effective_regressor_weight",
    "effective_uncertainty_weight",
]


def _strategy_requires_rdkit(strategy: str) -> bool:
    return strategy in MODEL_STRATEGIES or strategy in {"cluster_only_triage"}


def _variants_require_rdkit(enabled: bool, stage: str) -> bool:
    return enabled and str(stage) in {"final_survivors", "posthoc_top_hits"}


def _feature_matrix(rows: list[dict[str, Any]]) -> list[list[float]]:
    matrix: list[list[float]] = []
    for row in rows:
        vector = row.get("augmented_feature_vector", row.get("feature_vector", []))
        matrix.append(_sanitize_model_features(vector))
    return matrix


def _analog_sample_weights(rows: list[dict[str, Any]]) -> list[float]:
    return [max(0.01, min(1.0, _float(row.get("analog_group_weight"), 1.0))) for row in rows]


def _fit_model(model: Any, x: list[list[float]], y: list[Any], sample_weight: list[float] | None = None) -> Any:
    if sample_weight is not None:
        try:
            return model.fit(x, y, sample_weight=sample_weight)
        except TypeError:
            pass
    return model.fit(x, y)


def _sanitize_model_feature(value: Any, default: float = 0.0, limit: float = 1.0e6) -> float:
    try:
        numeric = float(value)
    except Exception:
        return default
    if not math.isfinite(numeric):
        return default
    return max(-limit, min(limit, numeric))


def _sanitize_model_features(values: Any) -> list[float]:
    try:
        iterator = list(values)
    except Exception:
        return []
    return [_sanitize_model_feature(value) for value in iterator]


def _median(values: list[float]) -> float:
    if not values:
        return 0.0
    ordered = sorted(values)
    mid = len(ordered) // 2
    if len(ordered) % 2:
        return float(ordered[mid])
    return float(0.5 * (ordered[mid - 1] + ordered[mid]))


def _ensemble_uncertainty(model: Any, matrix: list[list[float]], fallback: float = 1.0) -> list[float]:
    if not matrix:
        return []
    estimators = list(getattr(model, "estimators_", []) or [])
    if not estimators:
        return [fallback for _ in matrix]
    per_row: list[list[float]] = [[] for _ in matrix]
    for estimator in estimators:
        try:
            preds = estimator.predict(matrix)
        except Exception:
            continue
        for idx, pred in enumerate(preds):
            per_row[idx].append(float(pred))
    uncertainties: list[float] = []
    for preds in per_row:
        if not preds:
            uncertainties.append(fallback)
            continue
        center = _mean(preds)
        uncertainties.append(_stdev(preds, center))
    return uncertainties


def _binary_positive_proba(model: Any, matrix: list[list[float]], default_positive: float = 0.0) -> list[float]:
    if not matrix:
        return []
    classes_attr = getattr(model, "classes_", None)
    classes = list(classes_attr) if classes_attr is not None else []
    if len(classes) <= 1:
        if classes and int(classes[0]) == 1:
            return [1.0 for _ in matrix]
        return [default_positive for _ in matrix]
    probs = model.predict_proba(matrix)
    positive_index = classes.index(1) if 1 in classes else len(classes) - 1
    return [float(row[positive_index]) for row in probs]


def _spearman(xs: list[float], ys: list[float]) -> float | None:
    if len(xs) < 2 or len(xs) != len(ys):
        return None

    def _ranks(values: list[float]) -> list[float]:
        order = sorted(range(len(values)), key=lambda idx: values[idx])
        ranks = [0.0] * len(values)
        for rank, idx in enumerate(order, start=1):
            ranks[idx] = float(rank)
        return ranks

    rx = _ranks(xs)
    ry = _ranks(ys)
    mx = _mean(rx)
    my = _mean(ry)
    num = sum((a - mx) * (b - my) for a, b in zip(rx, ry))
    denx = math.sqrt(sum((a - mx) ** 2 for a in rx))
    deny = math.sqrt(sum((b - my) ** 2 for b in ry))
    if denx == 0.0 or deny == 0.0:
        return None
    return num / (denx * deny)


def _distance(a: list[float], b: list[float]) -> float:
    left = _sanitize_model_features(a)
    right = _sanitize_model_features(b)
    return math.sqrt(sum((x - y) ** 2 for x, y in zip(left, right)))


def _plan_level_counts(library_size: int, levels: list[int], budget_runs: int, promotion_fraction: float) -> list[int]:
    if not 0.0 < promotion_fraction <= 1.0:
        raise RDockPipelineError(f"promotion_fraction must be in (0, 1], got {promotion_fraction}")
    if library_size <= 0:
        return [0 for _ in levels]
    best_counts = [0 for _ in levels]
    for final_count in range(1, library_size + 1):
        counts = [0 for _ in levels]
        counts[-1] = final_count
        for idx in range(len(levels) - 2, -1, -1):
            counts[idx] = min(library_size, max(counts[idx + 1], int(math.ceil(counts[idx + 1] / promotion_fraction))))
        cost = sum(count * level for count, level in zip(counts, levels))
        if cost <= budget_runs:
            best_counts = counts
        else:
            break
    if not any(best_counts):
        base = min(library_size, max(1, budget_runs // levels[0]))
        best_counts[0] = base
        for idx in range(1, len(levels)):
            best_counts[idx] = 0
    return best_counts


def _select_diverse(rows: list[dict[str, Any]], target_count: int, min_per_cluster: int, max_per_cluster: int) -> list[dict[str, Any]]:
    if target_count <= 0 or not rows:
        return []
    def _cluster_key(row: dict[str, Any]) -> str:
        for key in ("cluster_id", "scaffold_id", "canonical_smiles", "smiles", "ligand_id"):
            value = row.get(key)
            if value not in (None, ""):
                return str(value)
        return "__missing_cluster__"
    cluster_counts: dict[str, int] = {}
    selected: list[dict[str, Any]] = []
    cluster_buckets: dict[str, list[dict[str, Any]]] = {}
    for row in rows:
        cluster_buckets.setdefault(_cluster_key(row), []).append(row)
    for cluster_id in sorted(cluster_buckets):
        bucket = cluster_buckets[cluster_id]
        take = min(len(bucket), min_per_cluster, max_per_cluster, target_count - len(selected))
        selected.extend(bucket[:take])
        cluster_counts[cluster_id] = take
        if len(selected) >= target_count:
            return selected[:target_count]
    for row in rows:
        cluster_id = _cluster_key(row)
        current = cluster_counts.get(cluster_id, 0)
        if current >= max_per_cluster:
            continue
        if any(str(existing["ligand_id"]) == str(row["ligand_id"]) for existing in selected):
            continue
        selected.append(row)
        cluster_counts[cluster_id] = current + 1
        if len(selected) >= target_count:
            break
    return selected[:target_count]


def _sample_reference_rows(
    rows: list[dict[str, Any]],
    sample_size: int,
    seed: int,
    min_per_cluster: int,
    max_per_cluster: int,
) -> list[dict[str, Any]]:
    if sample_size <= 0 or sample_size >= len(rows):
        return list(rows)
    shuffled = list(rows)
    random.Random(seed).shuffle(shuffled)
    shuffled.sort(key=lambda row: (str(row.get("cluster_id", "")), str(row.get("ligand_id", ""))))
    return _select_diverse(shuffled, sample_size, min_per_cluster, max_per_cluster)


def _top_ids_by_score(rows: list[dict[str, Any]], top_fraction: float, *keys: str) -> set[str]:
    ranked = _sort_by_score(rows, *keys)
    n_top = max(1, int(math.ceil(len(ranked) * top_fraction)))
    return {str(row["ligand_id"]) for row in ranked[:n_top]}


def _evaluate_selection_against_reference(
    reference_rows: list[dict[str, Any]],
    selected_ids: set[str],
    *,
    top_fraction: float,
) -> dict[str, Any]:
    total = len(reference_rows)
    if total == 0:
        return {
            "survivor_count": len(selected_ids),
            "reduction_fraction": 0.0,
            "top1_recall": None,
            "top5_recall": None,
            "top10_recall": None,
            "top1pct_recall": None,
            "top5pct_recall": None,
            "top10pct_recall": None,
            "false_negative_rate": None,
            "best_survivor_score": None,
            "top10_survivor_mean_score": None,
        }
    full_top1 = {str(row["ligand_id"]) for row in reference_rows[:1]}
    full_top5 = {str(row["ligand_id"]) for row in reference_rows[: min(5, total)]}
    full_top10 = {str(row["ligand_id"]) for row in reference_rows[: min(10, total)]}
    full_top1pct = _top_ids_by_score(reference_rows, 0.01, "SCORE", "best_score", "final_score")
    full_top5pct = _top_ids_by_score(reference_rows, 0.05, "SCORE", "best_score", "final_score")
    full_top10pct = _top_ids_by_score(reference_rows, 0.10, "SCORE", "best_score", "final_score")
    survivor_rows = [row for row in reference_rows if str(row["ligand_id"]) in selected_ids]
    top10_survivors = survivor_rows[: min(10, len(survivor_rows))]
    top10_scores = [_float(row.get("SCORE", row.get("best_score", row.get("final_score"))), None) for row in top10_survivors]
    top10_scores = [value for value in top10_scores if value is not None]
    return {
        "survivor_count": len(selected_ids),
        "reduction_fraction": 1.0 - (len(selected_ids) / max(1, total)),
        "top1_recall": len(full_top1 & selected_ids) / max(1, len(full_top1)),
        "top5_recall": len(full_top5 & selected_ids) / max(1, len(full_top5)),
        "top10_recall": len(full_top10 & selected_ids) / max(1, len(full_top10)),
        "top1pct_recall": len(full_top1pct & selected_ids) / max(1, len(full_top1pct)),
        "top5pct_recall": len(full_top5pct & selected_ids) / max(1, len(full_top5pct)),
        "top10pct_recall": len(full_top10pct & selected_ids) / max(1, len(full_top10pct)),
        "false_negative_rate": 1.0 - (len(full_top5pct & selected_ids) / max(1, len(full_top5pct))),
        "best_survivor_score": _float(survivor_rows[0].get("SCORE", survivor_rows[0].get("best_score", survivor_rows[0].get("final_score"))), None) if survivor_rows else None,
        "top10_survivor_mean_score": _mean(top10_scores) if top10_scores else None,
        "best_full_ligand_survived": str(reference_rows[0]["ligand_id"]) in selected_ids,
    }


def _requested_survivor_count(
    total_rows: int,
    retain_fraction: float,
    min_survivors: int,
    max_survivors: int,
) -> int:
    requested = max(min_survivors, int(math.ceil(total_rows * retain_fraction)))
    if max_survivors > 0:
        requested = min(requested, max_survivors)
    return min(total_rows, max(1, requested))


def _stable_json_hash(payload: dict[str, Any]) -> str:
    import hashlib

    return hashlib.sha256(json.dumps(payload, sort_keys=True, separators=(",", ":")).encode("utf-8")).hexdigest()


@dataclass
class MultiFidelityConfig:
    strategy: str
    fidelity_levels: list[int]
    cost_budget_runs: int
    adaptive_budget_ligands: int | None
    promotion_fraction: float
    min_per_cluster: int
    max_per_cluster: int
    outlier_intra_z_threshold: float
    score_component_filter: str
    final_fidelity_only_hits: bool
    checkpoint_every: int
    jobs: int | str
    cpu_fraction: float
    resume: bool
    reference_mode: str
    evaluation_pool_mode: str
    balanced_baselines: bool
    reference_sample_size: int
    reference_sample_seed: int
    posthoc_score_selected_hits: bool
    posthoc_final_runs: int
    force_resume_stale: bool
    outlier_policy: str
    intra_z_threshold: float
    score_z_threshold: float
    max_intra_fraction: float
    max_intra_fraction_soft: float
    max_intra_fraction_hard: float
    exploration_fraction: float
    diversity_weight: float
    uncertainty_weight: float
    outlier_risk_weight: float
    cluster_min_coverage: int
    use_reference_features: bool
    production_reference_free_mode: bool
    calibration_size: int
    calibration_fraction: float
    min_clusters_covered: int
    calibration_random_fraction: float
    calibration_diversity_weight: float
    fidelity_validation_size: int
    fidelity_validation_policy: str
    promotion_policy: str
    min_final_ligands: int
    min_promotion_per_level: int
    promotion_fraction_by_level: str
    triage_retain_fraction: float
    triage_target_recall: float
    triage_min_survivors: int
    triage_max_survivors: int
    cluster_min_survivors: int
    cluster_max_survivors: int
    rescue_fraction: float
    rare_cluster_rescue: int
    uncertainty_rescue: int
    allow_low_confidence_triage: bool
    top_good_fraction: float
    minimum_training_ligands: int
    triage_controller: str
    max_retain_fraction_before_not_useful: float
    classifier_top_percentile: float
    triage_model: str = "classifier"
    classifier_threshold_mode: str = "recall_target"
    classifier_min_positives: int = 10
    classifier_holdout_fraction: float = 0.25
    classifier_fallback: str = "cluster_only"
    model_fallback_if_worse: str = "none"
    survivor_combination_policy: str = "model_only"
    adaptive_policy: str = "hybrid_rank"
    regressor_contribution_mode: str = "linear"
    classifier_weight: float = 1.0
    regressor_weight: float = 0.35
    cluster_quality_weight: float = 0.5
    fixed_score_regressor_name: str = "fixed_score_regressor_v1"
    fixed_score_regressor_target: str = "component_sane_affinity_like"
    regressor_model_type: str = "extra_trees"
    model_validation_split: str = "cluster"
    cluster_quota: int = 0
    promotion_temperature: float = 1.0
    final_survivor_enumerate_variants: bool = False
    variant_stage: str = "none"
    enumerate_stereoisomers: str = "none"
    max_stereoisomers_per_parent: int = 2
    enumerate_tautomers: str = "none"
    max_tautomers_per_parent: int = 1
    enumerate_protonation: str = "none"
    ph: float = 7.4
    max_protomer_states_per_parent: int = 1
    max_conformers_per_variant: int = 1
    max_total_variants_per_parent: int = 1
    posthoc_top_parents: int = 100
    posthoc_max_total_variants_per_parent: int = 20
    variant_fairness_policy: str = "cap"
    allow_no_rdkit_parent_only: bool = False
    diagnostics_level: str = "standard"
    classifier_gate_fraction: float = 0.15
    classifier_max_gate_fraction: float = 0.2


class MultiFidelityAdaptiveRunner:
    def __init__(
        self,
        dataset_dir: str | Path,
        out_dir: str | Path,
        engine: RDockEngine,
        config: MultiFidelityConfig,
    ) -> None:
        self.dataset_dir = Path(dataset_dir)
        self.out_dir = Path(out_dir)
        self.engine = engine
        self.config = config
        self._prepare_runtime_dirs()
        self._emit_progress("repair_dataset:start", {"dataset_dir": str(self.dataset_dir)})
        self.dataset_repair = repair_dataset_dir(self.dataset_dir)
        self._emit_progress("repair_dataset:done", self.dataset_repair)
        self.dataset_validation = validate_dataset_dir(self.dataset_dir, check_rdock_tools=False)
        self.manifest = self.dataset_validation["manifest"]
        self.manifest.setdefault("pocket_definition_mode", "dataset_manifest")
        self.manifest.setdefault("has_reference_ligand", bool(self.dataset_validation.get("reference_records", 0)))
        self.manifest.setdefault("reference_features_enabled", bool(self.config.use_reference_features))
        self.manifest.setdefault("production_reference_free_mode", bool(self.config.production_reference_free_mode))
        self.synthetic_dataset = bool(self.manifest.get("synthetic_expansion") or self.manifest.get("synthetic_stress_test_only"))
        self.target_config = load_target_config(self.dataset_dir / "target" / "rdock_prm" / "target_config.yaml")
        self.ligands_sdf = require_file(self.dataset_dir / "ligands" / "all_ligands.sdf", "dataset ligand library")
        metadata_path = self.dataset_dir / "ligands" / "ligand_metadata.csv"
        if metadata_path.exists():
            metadata_rows = read_ligand_metadata(metadata_path)
        else:
            metadata_rows = [{"ligand_id": ligand_id, "smiles": ""} for ligand_id in self._load_block_map()]
        self.block_map = self._load_block_map()
        raw_model_rows = _build_model_rows(metadata_rows)
        self.model_rows, self.missing_prepared_model_rows = self._filter_prepared_model_rows(raw_model_rows)
        self.model_by_id = {str(row["ligand_id"]): row for row in self.model_rows}
        self.dataset_ligand_ids = [str(row["ligand_id"]) for row in self.model_rows]
        self.reference_rows = self._build_reference_rows()
        self.reference_ids = [str(row["ligand_id"]) for row in self.reference_rows]
        self.reference_id_set = set(self.reference_ids)
        self.candidate_rows = self._build_candidate_rows()
        self.candidate_ids = [str(row["ligand_id"]) for row in self.candidate_rows]
        self.candidate_id_set = set(self.candidate_ids)
        self.final_level = self.config.fidelity_levels[-1]
        self.trace_rows: list[dict[str, Any]] = []
        self.promotion_rows: list[dict[str, Any]] = []
        self.failed_chunk_rows: list[dict[str, Any]] = []
        self.failed_ligand_rows: list[dict[str, Any]] = []
        self.rdock_records_without_score_dropped = 0
        self.state_by_id: dict[str, dict[str, Any]] = {}
        self.training_time_total = 0.0
        self.docking_time_total = 0.0
        self.overhead_time_total = 0.0
        self.parsing_time_total = 0.0
        self.sdf_split_merge_time_total = 0.0
        self.scheduler_time_total = 0.0
        self.io_time_total = 0.0
        self.reference_completion_fraction = 0.0
        self.benchmark_status = "BENCHMARK COMPLETE"
        self.reference_label = "full"
        self.reference_free_mode = self.config.strategy in MODEL_STRATEGIES or self.config.production_reference_free_mode
        self.trace_step_counter = 0
        self.pre_docking_prediction_rows: list[dict[str, Any]] = []
        self.acquisition_component_rows: list[dict[str, Any]] = []
        self.cluster_quota_rows: list[dict[str, Any]] = []
        self.exploration_split_rows: list[dict[str, Any]] = []
        self.current_effective_uncertainty_weight = float(self.config.uncertainty_weight)
        self.current_uncertainty_used_for_acquisition = True
        self.current_uncertainty_disabled_reason = ""
        self.current_regressor_used_for_ranking = self.config.regressor_contribution_mode != "none"
        self.current_regressor_disabled_reason = ""
        self.current_effective_regressor_weight = float(self.config.regressor_weight)
        self.current_classifier_gate_warning = ""
        self.run_started_at = time.time()
        self._validate_runtime_dependencies()
        self.signature = self._build_run_signature()
        self._check_resume_signature()
        self._write_json_artifact(self.out_dir / "checkpoints" / "run_signature.json", self.signature)
        self._write_reference_artifacts()
        self._init_state()

    def _prepare_runtime_dirs(self) -> None:
        for name in ("checkpoints", "metrics", "tables", "plots", "rdock", "poses", "target", "ligands"):
            (self.out_dir / name).mkdir(parents=True, exist_ok=True)

    def _diagnostics_rows(
        self,
        rows: list[dict[str, Any]],
        *,
        survivors: list[dict[str, Any]] | None = None,
        final_hits: list[dict[str, Any]] | None = None,
    ) -> list[dict[str, Any]]:
        level = str(getattr(self.config, "diagnostics_level", "standard") or "standard").lower()
        if level == "full":
            return list(rows)
        survivor_ids = {str(row.get("ligand_id", "")) for row in (survivors or []) if str(row.get("ligand_id", ""))}
        final_ids = {str(row.get("ligand_id", "")) for row in (final_hits or []) if str(row.get("ligand_id", ""))}
        keep_ids = survivor_ids | final_ids
        if level == "minimal":
            if keep_ids:
                return [row for row in rows if str(row.get("ligand_id", "")) in keep_ids]
            return rows[: min(10, len(rows))]
        if keep_ids:
            return [row for row in rows if str(row.get("ligand_id", "")) in keep_ids]
        return rows[: min(250, len(rows))]

    def _validate_runtime_dependencies(self) -> None:
        if _strategy_requires_rdkit(self.config.strategy) and not RDKit_AVAILABLE:
            raise RDockPipelineError("RDKit_REQUIRED_FOR_REFERENCE_FREE_MODEL")
        if _variants_require_rdkit(self.config.final_survivor_enumerate_variants, self.config.variant_stage):
            if not RDKit_AVAILABLE and not self.config.allow_no_rdkit_parent_only:
                raise RDockPipelineError("RDKit_REQUIRED_FOR_VARIANT_ENUMERATION")
            if not RDKit_AVAILABLE and self.config.allow_no_rdkit_parent_only:
                warning = {
                    "warning": "RDKit unavailable; variant expansion downgraded to parent-only passthrough because --allow-no-rdkit-parent-only was set.",
                    "variant_stage": self.config.variant_stage,
                }
                _write_json(self.out_dir / "metrics" / "variant_rdkit_warning.json", warning)

    def _write_json_artifact(self, path: Path, payload: dict[str, Any]) -> None:
        path.parent.mkdir(parents=True, exist_ok=True)
        path.write_text(json.dumps(payload, indent=2), encoding="utf-8")

    def _build_reference_rows(self) -> list[dict[str, Any]]:
        mode = str(self.config.reference_mode).lower()
        if mode == "none":
            self.reference_label = "none"
            return []
        if mode == "sampled":
            self.reference_label = "sampled_reference"
            return _sample_reference_rows(
                self.model_rows,
                self.config.reference_sample_size,
                self.config.reference_sample_seed,
                self.config.min_per_cluster,
                self.config.max_per_cluster,
            )
        self.reference_label = "full"
        return list(self.model_rows)

    def _build_candidate_rows(self) -> list[dict[str, Any]]:
        if str(self.config.evaluation_pool_mode).lower() == "same_pool" and self.reference_rows:
            return list(self.reference_rows)
        return list(self.model_rows)

    def _write_reference_artifacts(self) -> None:
        if not self.reference_ids:
            return
        if self.reference_label == "sampled_reference":
            sample_path = self.out_dir / "tables" / "reference_sample_ligand_ids.txt"
            sample_path.write_text("\n".join(self.reference_ids) + "\n", encoding="utf-8")

    def _build_run_signature(self) -> dict[str, Any]:
        manifest_path = require_file(self.dataset_dir / "dataset_manifest.json", "dataset manifest")
        target_config_path = require_file(self.dataset_dir / "target" / "rdock_prm" / "target_config.yaml", "dataset target_config")
        return {
            "run_id": self.out_dir.name,
            "dataset_manifest_hash": sha256_file(manifest_path),
            "ligand_file_hash": sha256_file(self.ligands_sdf),
            "target_config_hash": sha256_file(target_config_path),
            "strategy": self.config.strategy,
            "reference_mode": self.config.reference_mode,
            "evaluation_pool_mode": self.config.evaluation_pool_mode,
            "reference_sample_seed": self.config.reference_sample_seed,
            "reference_sample_size": self.config.reference_sample_size,
            "fidelity_levels": self.config.fidelity_levels,
            "cost_budget_runs": self.config.cost_budget_runs,
            "final_fidelity_runs": self.final_level,
            "rdock_version": probe_version(require_executable("rbdock")),
            "command_args": {
                "balanced_baselines": self.config.balanced_baselines,
                "outlier_policy": self.config.outlier_policy,
                "intra_z_threshold": self.config.intra_z_threshold,
                "score_z_threshold": self.config.score_z_threshold,
                "max_intra_fraction": self.config.max_intra_fraction,
                "exploration_fraction": self.config.exploration_fraction,
                "diversity_weight": self.config.diversity_weight,
                "uncertainty_weight": self.config.uncertainty_weight,
                "outlier_risk_weight": self.config.outlier_risk_weight,
                "cluster_min_coverage": self.config.cluster_min_coverage,
                "triage_retain_fraction": self.config.triage_retain_fraction,
                "triage_target_recall": self.config.triage_target_recall,
                "calibration_size": self.config.calibration_size,
                "fidelity_validation_size": self.config.fidelity_validation_size,
                "promotion_policy": self.config.promotion_policy,
                "min_final_ligands": self.config.min_final_ligands,
                "use_reference_features": self.config.use_reference_features,
                "production_reference_free_mode": self.config.production_reference_free_mode,
            },
        }

    def _check_resume_signature(self) -> None:
        signature_path = self.out_dir / "checkpoints" / "run_signature.json"
        if not self.config.resume or not signature_path.exists():
            return
        existing = _load_json(signature_path)
        if existing == self.signature:
            return
        mismatch = {
            "existing": existing,
            "current": self.signature,
        }
        self._write_json_artifact(self.out_dir / "checkpoints" / "stale_signature.json", mismatch)
        if not self.config.force_resume_stale:
            raise RDockPipelineError(
                f"Resume checkpoint signature mismatch for {self.out_dir}. "
                f"Refusing to reuse stale cache without --force-resume-stale."
            )

    def _emit_progress(self, message: str, payload: dict[str, Any] | None = None) -> None:
        line = f"[benchmark-adaptive] {message}"
        print(line, flush=True)
        progress_log = self.out_dir / "checkpoints" / "progress.log"
        progress_log.parent.mkdir(parents=True, exist_ok=True)
        with progress_log.open("a", encoding="utf-8") as handle:
            handle.write(line + "\n")
        if payload is not None:
            _write_json(self.out_dir / "checkpoints" / "status.json", {"message": message, **payload})

    def _load_block_map(self) -> dict[str, str]:
        return _load_input_block_map(Path(self.ligands_sdf))

    def _filter_prepared_model_rows(self, rows: list[dict[str, Any]]) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
        prepared_ids = set(self.block_map)
        kept: list[dict[str, Any]] = []
        missing: list[dict[str, Any]] = []
        for row in rows:
            ligand_id = str(row["ligand_id"])
            if ligand_id in prepared_ids:
                kept.append(row)
            else:
                missing.append(
                    {
                        "ligand_id": ligand_id,
                        "cluster_id": str(row.get("cluster_id", "")),
                        "scaffold_id": str(row.get("scaffold_id", "")),
                        "smiles": str(row.get("smiles", "")),
                        "reason": "missing_from_prepared_sdf",
                    }
                )
        write_rows_csv(missing, self.out_dir / "tables" / "missing_prepared_ligands.csv")
        _write_json(
            self.out_dir / "metrics" / "prepared_sdf_consistency.json",
            {
                "metadata_rows": len(rows),
                "prepared_sdf_rows": len(prepared_ids),
                "usable_model_rows": len(kept),
                "missing_prepared_ligands": len(missing),
            },
        )
        if not kept:
            raise RDockPipelineError("Prepared SDF contains no usable ligand IDs after metadata alignment")
        return kept, missing

    def _init_state(self) -> None:
        for row in self.candidate_rows:
            ligand_id = str(row["ligand_id"])
            self.state_by_id[ligand_id] = {
                "ligand_id": ligand_id,
                "cluster_id": str(row["cluster_id"]),
                "model_score": float(row["model_score"]),
                "surrogate_score": float(row["model_score"]),
                "selected_fidelity_runs": 0,
                "current_best_score": "",
                "current_best_score_level": "",
                "final_score": "",
                "is_final_fidelity": False,
                "n_rdock_runs_total_spent": 0,
                "promoted_from_level": "",
                "promoted_to_level": "",
                "promotion_reason": "",
                "batch_id": "",
                "rdock_success": False,
                "failed_reason": "",
                "timing_docking_seconds": 0.0,
                "timing_training_seconds": 0.0,
                "intra_outlier": False,
                "score_outlier": False,
                "component_warning": "",
                "pre_docking_predicted_score": "",
                "pre_docking_predicted_uncertainty": "",
                "predicted_filtered_score": 0.0,
                "predicted_uncertainty": 0.0,
                "outlier_risk": 0.0,
                "diversity_bonus": 0.0,
                "p_good": 0.0,
                "cluster_quality": 0.0,
                "triage_score": 0.0,
                "acquisition_classifier_component": 0.0,
                "acquisition_score_component": 0.0,
                "acquisition_uncertainty_component": 0.0,
                "acquisition_diversity_component": 0.0,
                "acquisition_cluster_component": 0.0,
                "acquisition_outlier_component": 0.0,
                "score_observation_count": 0,
                "score_sum": 0.0,
                "score_sq_sum": 0.0,
                "score_mean_observed": 0.0,
                "score_std_observed": 0.0,
                "best_inter_seen": 0.0,
                "best_intra_seen": 0.0,
                "best_intra_fraction_seen": 0.0,
                "failed_observation_count": 0,
                "failed_observation_fraction": 0.0,
                "pose_count_seen": 0,
            }

    def _write_checkpoint(self, name: str, payload: dict[str, Any]) -> None:
        checkpoint_dir = self.out_dir / "checkpoints"
        checkpoint_dir.mkdir(parents=True, exist_ok=True)
        _write_json(checkpoint_dir / f"{name}.json", payload)

    def _prepare_output_layout(self) -> None:
        self._prepare_runtime_dirs()
        target_dir = self.out_dir / "target"
        shutil.copy2(require_file(self.dataset_dir / "target" / "target.mol2", "dataset target.mol2"), target_dir / "target.mol2")
        reference_ligand = self.dataset_dir / "target" / "reference_ligand.sdf"
        if reference_ligand.exists():
            shutil.copy2(reference_ligand, target_dir / "reference_ligand.sdf")
        prm_dir = target_dir / "rdock_prm"
        prm_dir.mkdir(parents=True, exist_ok=True)
        for path in (self.dataset_dir / "target" / "rdock_prm").iterdir():
            if path.is_file():
                shutil.copy2(path, prm_dir / path.name)
        shutil.copy2(self.ligands_sdf, self.out_dir / "ligands" / "all_ligands.sdf")

    def _materialize_reference_sdf(self, ligand_ids: list[str], out_path: Path) -> Path:
        if not ligand_ids:
            raise RDockPipelineError("Reference/evaluation pool is empty")
        return _write_selected_sdf(self.block_map, ligand_ids, out_path)

    def _complete_docking_rows(
        self,
        selected_ids: list[str],
        observed_rows: list[dict[str, Any]],
        n_runs_requested: int,
        source_label: str,
    ) -> list[dict[str, Any]]:
        observed_map = {str(row["ligand_id"]): dict(row) for row in observed_rows}
        completed: list[dict[str, Any]] = []
        for ligand_id in selected_ids:
            row = observed_map.get(ligand_id)
            if row is None:
                row = {
                    "ligand_id": ligand_id,
                    "attempted": True,
                    "rdock_success": False,
                    "failed_reason": "missing_best_pose",
                    "best_score": "",
                    "SCORE": "",
                    "n_poses": 0,
                    "n_runs_requested": n_runs_requested,
                    "n_runs_completed": 0,
                    "source_chunk": source_label,
                    "score_outlier": False,
                    "intra_outlier": False,
                }
            else:
                score = row.get("final_score", row.get("SCORE", ""))
                row["attempted"] = True
                row["rdock_success"] = _bool_text(str(row.get("rdock_success", True)).lower() in {"true", "1"})
                row["failed_reason"] = row.get("failed_reason", "")
                row["best_score"] = score
                row["n_runs_requested"] = n_runs_requested
                row["n_runs_completed"] = n_runs_requested if str(row.get("rdock_success", "")).lower() in {"true", "1"} else 0
                row["source_chunk"] = row.get("source_chunk", source_label)
                row.setdefault("n_poses", 1 if str(row.get("rdock_success", "")).lower() in {"true", "1"} else 0)
            completed.append(row)
        return completed

    def _run_full_docking(self) -> tuple[list[dict[str, Any]], dict[str, Any]]:
        if not self.reference_ids:
            return [], {
                "reference_mode": self.config.reference_mode,
                "reference_completion_fraction": 0.0,
                "reference_ligand_count": 0,
                "full_docking_seconds": 0.0,
                "n_runs": self.final_level,
                "benchmark_status": "BENCHMARK PARTIAL / NOT COMPARABLE",
            }
        full_dir = self.out_dir / "full_docking"
        full_dir.mkdir(parents=True, exist_ok=True)
        self._emit_progress("full_docking:start", {"run_dir": str(full_dir), "n_runs": self.final_level, "jobs": self.config.jobs})
        reference_sdf = self.out_dir / "ligands" / f"{self.reference_label}.sdf"
        self._materialize_reference_sdf(self.reference_ids, reference_sdf)
        start = time.time()
        artifacts = self.engine.dock_sdf(
            self.target_config,
            reference_sdf,
            full_dir,
            n_runs=self.final_level,
            jobs=self.config.jobs,
            run_id=f"{self.out_dir.name}_full",
            resume=self.config.resume,
        )
        elapsed = time.time() - start
        observed_rows = [dict(row) for row in _read_rows(artifacts.best_per_ligand_csv)]
        complete_rows = self._complete_docking_rows(self.reference_ids, observed_rows, self.final_level, "reference")
        success_rows = [row for row in complete_rows if str(row.get("rdock_success", "")).lower() in {"true", "1"} and _float(row.get("best_score"), None) is not None]
        for row in success_rows:
            row["SCORE"] = row.get("best_score", row.get("SCORE", ""))
        rows = _augment_full_rows(success_rows)
        full_rank_map = {str(row["ligand_id"]): row for row in rows}
        full_table_rows: list[dict[str, Any]] = []
        for row in complete_rows:
            item = dict(row)
            item.update({k: v for k, v in full_rank_map.get(str(row["ligand_id"]), {}).items() if k not in item or item[k] in {"", None}})
            full_table_rows.append(item)
        self.reference_completion_fraction = len(full_table_rows) / max(1, len(self.reference_ids))
        if self.config.reference_mode == "full" and self.reference_completion_fraction < 0.99:
            self.benchmark_status = "BENCHMARK PARTIAL / NOT COMPARABLE"
        elif self.config.reference_mode == "sampled":
            self.benchmark_status = "BENCHMARK SAMPLED REFERENCE"
        write_rows_csv(full_table_rows, self.out_dir / "tables" / "full_docking_scores.csv")
        write_rows_csv(full_table_rows, self.out_dir / "tables" / "reference_scores.csv")
        metrics = {
            "library_size": len(self.reference_ids),
            "successful_ligands": len(rows),
            "failed_ligands": max(0, len(self.reference_ids) - len(rows)),
            "pose_count": _count_sdf(Path(artifacts.all_poses_sdf)),
            "best_SCORE": _float(rows[0]["SCORE"]) if rows else None,
            "full_docking_seconds": elapsed,
            "n_runs": self.final_level,
            "best_ligand_id": rows[0]["ligand_id"] if rows else None,
            "reference_mode": self.config.reference_mode,
            "reference_completion_fraction": self.reference_completion_fraction,
            "reference_ligand_count": len(self.reference_ids),
            "benchmark_status": self.benchmark_status,
        }
        _write_json(self.out_dir / "metrics" / "rdock_metrics.json", metrics)
        self._write_checkpoint("full_docking", metrics)
        self._emit_progress("full_docking:done", metrics)
        return rows, metrics

    def _run_single_fidelity_adaptive(self, count: int) -> tuple[list[dict[str, Any]], float]:
        if count <= 0:
            return [], 0.0
        ordered = sorted(
            self.candidate_rows,
            key=lambda row: (-float(row["model_score"]), str(row["cluster_id"]), str(row["ligand_id"])),
        )
        selected = _select_diverse(ordered, count, self.config.min_per_cluster, self.config.max_per_cluster)
        selected_ids = [str(row["ligand_id"]) for row in selected]
        run_dir = self.out_dir / "single_fidelity_adaptive"
        run_dir.mkdir(parents=True, exist_ok=True)
        sdf_path = self.out_dir / "ligands" / "single_fidelity_adaptive.sdf"
        _write_selected_sdf(self.block_map, selected_ids, sdf_path)
        self._emit_progress("single_fidelity:start", {"count": len(selected_ids), "run_dir": str(run_dir)})
        start = time.time()
        self.engine.dock_sdf(
            self.target_config,
            sdf_path,
            run_dir,
            n_runs=self.final_level,
            jobs=self.config.jobs,
            run_id=f"{self.out_dir.name}_single",
            resume=self.config.resume,
        )
        elapsed = time.time() - start
        observed = [dict(row) for row in _read_rows(run_dir / "tables" / "best_per_ligand.csv")]
        rows = self._complete_docking_rows(selected_ids, observed, self.final_level, "single_fidelity")
        for row in rows:
            row["is_final_fidelity"] = str(row.get("rdock_success", "")).lower() in {"true", "1"}
            row["final_score"] = row.get("best_score", row.get("SCORE", ""))
        write_rows_csv(rows, self.out_dir / "tables" / "single_fidelity_adaptive_scores.csv")
        self._write_checkpoint("single_fidelity", {"count": len(rows), "seconds": elapsed})
        self._emit_progress("single_fidelity:done", {"count": len(rows), "seconds": elapsed})
        return rows, elapsed

    def _run_random_baseline(self, cost_budget_runs: int, diverse: bool = False) -> tuple[list[dict[str, Any]], float]:
        count = max(1, cost_budget_runs // self.final_level)
        population_rows = list(self.candidate_rows)
        rng = random.Random(42 if not diverse else 43)
        if diverse:
            rng.shuffle(population_rows)
            selected_rows = _select_diverse(population_rows, min(len(population_rows), count), self.config.min_per_cluster, self.config.max_per_cluster)
            selected_ids = [str(row["ligand_id"]) for row in selected_rows]
        else:
            population = [str(row["ligand_id"]) for row in population_rows]
            selected_ids = rng.sample(population, min(len(population), count))
        run_dir = self.out_dir / "random_baseline"
        if diverse:
            run_dir = self.out_dir / "diverse_random_baseline"
        run_dir.mkdir(parents=True, exist_ok=True)
        sdf_path = self.out_dir / "ligands" / ("diverse_random_baseline.sdf" if diverse else "random_baseline.sdf")
        _write_selected_sdf(self.block_map, selected_ids, sdf_path)
        phase = "diverse_random_baseline" if diverse else "random_baseline"
        self._emit_progress(f"{phase}:start", {"count": len(selected_ids), "run_dir": str(run_dir)})
        start = time.time()
        self.engine.dock_sdf(
            self.target_config,
            sdf_path,
            run_dir,
            n_runs=self.final_level,
            jobs=self.config.jobs,
            run_id=f"{self.out_dir.name}_{'diverse_random' if diverse else 'random'}",
            resume=self.config.resume,
        )
        elapsed = time.time() - start
        observed = [dict(row) for row in _read_rows(run_dir / "tables" / "best_per_ligand.csv")]
        rows = self._complete_docking_rows(selected_ids, observed, self.final_level, phase)
        for row in rows:
            row["is_final_fidelity"] = str(row.get("rdock_success", "")).lower() in {"true", "1"}
            row["final_score"] = row.get("best_score", row.get("SCORE", ""))
            row["n_rdock_runs_total_spent"] = self.final_level
        write_rows_csv(rows, self.out_dir / "tables" / ("diverse_random_baseline_scores.csv" if diverse else "random_baseline_scores.csv"))
        self._write_checkpoint(phase, {"count": len(rows), "seconds": elapsed})
        self._emit_progress(f"{phase}:done", {"count": len(rows), "seconds": elapsed})
        return rows, elapsed

    def _penalize_rows(self, rows: list[dict[str, Any]], level: int) -> list[dict[str, Any]]:
        score_values = [_float(row.get("SCORE"), float("nan")) for row in rows if str(row.get("rdock_success", "")).lower() in {"true", "1"}]
        intra_values = [_float(row.get("SCORE.INTRA"), float("nan")) for row in rows if str(row.get("rdock_success", "")).lower() in {"true", "1"}]
        score_mean = _mean(score_values)
        intra_mean = _mean(intra_values)
        score_sd = _stdev(score_values, score_mean)
        intra_sd = _stdev(intra_values, intra_mean)
        output: list[dict[str, Any]] = []
        for row in rows:
            item = dict(row)
            score = _float(item.get("SCORE"), float("inf"))
            intra = _float(item.get("SCORE.INTRA"), 0.0)
            score_z = (score - score_mean) / score_sd if math.isfinite(score) else 0.0
            intra_z = (intra - intra_mean) / intra_sd if math.isfinite(intra) else 0.0
            intra_fraction = abs(intra) / max(abs(score), 1e-6) if math.isfinite(intra) and math.isfinite(score) else 0.0
            dominant_intra_soft = intra_fraction >= self.config.max_intra_fraction_soft
            dominant_intra_hard = intra_fraction >= self.config.max_intra_fraction_hard
            intra_outlier = intra_z < (-abs(self.config.intra_z_threshold)) or dominant_intra_soft
            score_outlier = score_z < -abs(self.config.score_z_threshold)
            penalty = 0.0
            warnings: list[str] = []
            severe_pattern = (score_outlier and intra_outlier) or dominant_intra_hard
            if intra_outlier:
                penalty += min(12.0, abs(intra_z) * 1.25 if math.isfinite(intra_z) else 6.0)
                warnings.append("intra_outlier")
            if score_outlier:
                penalty += 3.0
                warnings.append("score_outlier")
            if dominant_intra_soft:
                warnings.append("intra_dominance")
                penalty += 2.0 if not dominant_intra_hard else 6.0
            item["intra_outlier"] = intra_outlier
            item["score_outlier"] = score_outlier
            item["score_z"] = score_z
            item["intra_z"] = intra_z
            item["intra_fraction"] = intra_fraction
            item["component_warning"] = ",".join(warnings)
            if severe_pattern and len(warnings) >= 2:
                penalty += 6.0
            if self.config.outlier_policy == "exclude" and severe_pattern and len(warnings) >= 2:
                item["ranking_score"] = float("inf")
            elif self.config.outlier_policy == "flag":
                item["ranking_score"] = score
            else:
                item["ranking_score"] = score + penalty
            item["selected_fidelity_runs"] = level
            output.append(item)
        return output

    def _promotion_priority(self, row: dict[str, Any]) -> float:
        classifier_probability = _float(row.get("p_good"), 0.0)
        predicted_score = _float(row.get("predicted_filtered_score"), _float(row.get("ranking_score"), float("inf")))
        uncertainty = _float(row.get("predicted_uncertainty"), 0.0)
        outlier_risk = _float(row.get("outlier_risk"), 0.0)
        diversity_bonus = _float(row.get("diversity_bonus"), 0.0)
        cluster_quality = _float(row.get("cluster_quality"), 0.0)
        acquisition = -(self.config.classifier_weight * classifier_probability)
        if self.current_regressor_used_for_ranking:
            acquisition += self.config.regressor_weight * predicted_score
        acquisition -= self.current_effective_uncertainty_weight * uncertainty
        acquisition -= self.config.diversity_weight * diversity_bonus
        acquisition -= self.config.cluster_quality_weight * cluster_quality
        acquisition += self.config.outlier_risk_weight * outlier_risk
        return acquisition

    def _update_surrogate(self, observed_rows: list[dict[str, Any]]) -> float:
        start = time.time()
        observed = []
        for row in observed_rows:
            ligand_id = str(row["ligand_id"])
            target_score = _float(row.get("ranking_score"), float("inf"))
            outlier_flag = 1.0 if str(row.get("component_warning", "")).strip() else 0.0
            observed.append((ligand_id, target_score, outlier_flag))
        if not observed:
            return 0.0
        observed_ids = [ligand_id for ligand_id, _, _ in observed]
        if SurrogateModel is not None and SurrogateConfig is not None and len(observed) >= 8:
            feature_names = [f"f{i}" for i in range(len(self.model_rows[0]["feature_vector"]))]
            train_features = []
            train_masks = []
            train_targets = []
            for ligand_id, target_score, _ in observed:
                feat = [float(x) for x in self.model_by_id[ligand_id]["feature_vector"]]
                train_features.append(feat)
                train_masks.append([1.0 for _ in feat])
                train_targets.append(float(target_score))
            surrogate = SurrogateModel(SurrogateConfig(prefer_xgboost=False, random_state=42, n_estimators=120))
            surrogate.fit(
                features=__import__("numpy").asarray(train_features, dtype=float),
                masks=__import__("numpy").asarray(train_masks, dtype=float),
                y=__import__("numpy").asarray(train_targets, dtype=float),
                feature_names=feature_names,
                mask_names=[f"m{i}" for i in range(len(feature_names))],
            )
            all_features = []
            all_masks = []
            for row in self.candidate_rows:
                feat = [float(x) for x in row["feature_vector"]]
                all_features.append(feat)
                all_masks.append([1.0 for _ in feat])
            bundle = surrogate.predict_bundle(
                features=__import__("numpy").asarray(all_features, dtype=float),
                masks=__import__("numpy").asarray(all_masks, dtype=float),
            )
            for row, pred, unc in zip(self.candidate_rows, bundle["expected_score"], bundle["uncertainty"]):
                row["predicted_filtered_score"] = float(pred)
                row["predicted_uncertainty"] = float(unc)
                if str(row["ligand_id"]) in observed_ids:
                    matching = next(item for item in observed if item[0] == str(row["ligand_id"]))
                    row["predicted_filtered_score"] = float(matching[1])
                    row["predicted_uncertainty"] = 0.0
            observed_outlier_rate = sum(outlier for _, _, outlier in observed) / max(1, len(observed))
            for row in self.candidate_rows:
                row["outlier_risk"] = observed_outlier_rate if str(row["ligand_id"]) not in observed_ids else next(item[2] for item in observed if item[0] == str(row["ligand_id"]))
        else:
            for row in self.candidate_rows:
                ligand_id = str(row["ligand_id"])
                if ligand_id in observed_ids:
                    target = next(item[1] for item in observed if item[0] == ligand_id)
                    row["predicted_filtered_score"] = float(target)
                    row["predicted_uncertainty"] = 0.0
                    row["outlier_risk"] = next(item[2] for item in observed if item[0] == ligand_id)
                    continue
                neighbors: list[tuple[float, float, float]] = []
                for observed_id, ranking_score, outlier_flag in observed:
                    ref = self.model_by_id[observed_id]
                    dist = _distance(row["feature_vector"], ref["feature_vector"])
                    neighbors.append((dist, ranking_score, outlier_flag))
                neighbors.sort(key=lambda item: item[0])
                top = neighbors[: min(16, len(neighbors))]
                weights = [1.0 / (1.0 + dist) for dist, _, _ in top]
                total_weight = sum(weights) or 1.0
                predicted = sum(weight * score for weight, (_, score, _) in zip(weights, top)) / total_weight
                row["predicted_filtered_score"] = float(predicted)
                row["predicted_uncertainty"] = float(_stdev([score for _, score, _ in top], predicted))
                row["outlier_risk"] = float(sum(weight * outlier for weight, (_, _, outlier) in zip(weights, top)) / total_weight)

        cluster_counts: dict[str, int] = {}
        for row in observed_rows:
            cluster_counts[str(row.get("cluster_id", ""))] = cluster_counts.get(str(row.get("cluster_id", "")), 0) + 1
        for row in self.candidate_rows:
            cluster_id = str(row.get("cluster_id", ""))
            coverage = cluster_counts.get(cluster_id, 0)
            row["diversity_bonus"] = 1.0 / (1.0 + coverage)
            state = self.state_by_id.get(str(row["ligand_id"]))
            if state is not None:
                state["surrogate_score"] = float(-_float(row.get("predicted_filtered_score"), 0.0))
                state["predicted_uncertainty"] = float(_float(row.get("predicted_uncertainty"), 0.0))
                state["outlier_risk"] = float(_float(row.get("outlier_risk"), 0.0))
        for row in self.model_rows:
            ligand_id = str(row["ligand_id"])
            source = self.model_by_id.get(ligand_id, row)
            row["surrogate_score"] = source.get("surrogate_score", row.get("surrogate_score", 0.0))
            row["predicted_filtered_score"] = source.get("predicted_filtered_score", row.get("predicted_filtered_score", 0.0))
            row["predicted_uncertainty"] = source.get("predicted_uncertainty", row.get("predicted_uncertainty", 0.0))
            row["outlier_risk"] = source.get("outlier_risk", row.get("outlier_risk", 0.0))
            row["diversity_bonus"] = source.get("diversity_bonus", row.get("diversity_bonus", 0.0))
        return time.time() - start

    def _record_level_rows(self, level: int, batch_id: int, rows: list[dict[str, Any]], level_seconds: float, training_seconds: float) -> None:
        level_rows: list[dict[str, Any]] = []
        for row in rows:
            ligand_id = str(row["ligand_id"])
            state = self.state_by_id[ligand_id]
            raw_score = row.get("SCORE", "")
            score_value = _float(raw_score, None)
            current_best = state["current_best_score"]
            if current_best == "" or _float(raw_score, float("inf")) < _float(current_best, float("inf")):
                state["current_best_score"] = raw_score
                state["current_best_score_level"] = level
            state["selected_fidelity_runs"] = level
            state["surrogate_score"] = self.model_by_id[ligand_id].get("surrogate_score", state["surrogate_score"])
            state["predicted_filtered_score"] = self.model_by_id[ligand_id].get("predicted_filtered_score", state.get("predicted_filtered_score", 0.0))
            state["n_rdock_runs_total_spent"] = int(state["n_rdock_runs_total_spent"]) + level
            state["batch_id"] = batch_id
            state["rdock_success"] = str(row.get("rdock_success", True)).lower() in {"true", "1"}
            state["failed_reason"] = row.get("failed_reason", "")
            state["timing_docking_seconds"] = _float(state["timing_docking_seconds"]) + level_seconds / max(1, len(rows))
            state["timing_training_seconds"] = _float(state["timing_training_seconds"]) + training_seconds / max(1, len(rows))
            state["intra_outlier"] = row.get("intra_outlier", False)
            state["score_outlier"] = row.get("score_outlier", False)
            state["component_warning"] = row.get("component_warning", "")
            state["predicted_uncertainty"] = self.model_by_id[ligand_id].get("predicted_uncertainty", state.get("predicted_uncertainty", 0.0))
            state["outlier_risk"] = self.model_by_id[ligand_id].get("outlier_risk", state.get("outlier_risk", 0.0))
            state["diversity_bonus"] = self.model_by_id[ligand_id].get("diversity_bonus", state.get("diversity_bonus", 0.0))
            state["p_good"] = self.model_by_id[ligand_id].get("p_good", state.get("p_good", 0.0))
            state["cluster_quality"] = self.model_by_id[ligand_id].get("cluster_quality", state.get("cluster_quality", 0.0))
            state["triage_score"] = self.model_by_id[ligand_id].get("triage_score", state.get("triage_score", 0.0))
            state["acquisition_classifier_component"] = self.model_by_id[ligand_id].get("acquisition_classifier_component", state.get("acquisition_classifier_component", 0.0))
            state["acquisition_score_component"] = self.model_by_id[ligand_id].get("acquisition_score_component", state.get("acquisition_score_component", 0.0))
            state["acquisition_uncertainty_component"] = self.model_by_id[ligand_id].get("acquisition_uncertainty_component", state.get("acquisition_uncertainty_component", 0.0))
            state["acquisition_diversity_component"] = self.model_by_id[ligand_id].get("acquisition_diversity_component", state.get("acquisition_diversity_component", 0.0))
            state["acquisition_cluster_component"] = self.model_by_id[ligand_id].get("acquisition_cluster_component", state.get("acquisition_cluster_component", 0.0))
            state["acquisition_outlier_component"] = self.model_by_id[ligand_id].get("acquisition_outlier_component", state.get("acquisition_outlier_component", 0.0))
            if score_value is not None and math.isfinite(score_value):
                state["score_observation_count"] = int(_float(state.get("score_observation_count"), 0.0) or 0) + 1
                state["score_sum"] = _float(state.get("score_sum"), 0.0) + score_value
                state["score_sq_sum"] = _float(state.get("score_sq_sum"), 0.0) + (score_value * score_value)
                count = max(1, int(_float(state.get("score_observation_count"), 1.0) or 1))
                mean_score = _float(state.get("score_sum"), 0.0) / count
                variance = max(0.0, (_float(state.get("score_sq_sum"), 0.0) / count) - (mean_score * mean_score))
                state["score_mean_observed"] = mean_score
                state["score_std_observed"] = math.sqrt(variance)
                inter_val = _float(row.get("SCORE.INTER"), 0.0)
                intra_val = _float(row.get("SCORE.INTRA"), 0.0)
                state["best_inter_seen"] = inter_val if count == 1 or inter_val < _float(state.get("best_inter_seen"), float("inf")) else state.get("best_inter_seen", 0.0)
                state["best_intra_seen"] = intra_val if count == 1 or intra_val < _float(state.get("best_intra_seen"), float("inf")) else state.get("best_intra_seen", 0.0)
                state["best_intra_fraction_seen"] = _float(row.get("intra_fraction"), state.get("best_intra_fraction_seen", 0.0))
            if str(row.get("rdock_success", "")).lower() not in {"true", "1"}:
                state["failed_observation_count"] = int(_float(state.get("failed_observation_count"), 0.0) or 0) + 1
            total_obs = max(1, int(_float(state.get("score_observation_count"), 0.0) or 0) + int(_float(state.get("failed_observation_count"), 0.0) or 0))
            state["failed_observation_fraction"] = int(_float(state.get("failed_observation_count"), 0.0) or 0) / total_obs
            state["pose_count_seen"] = int(_float(state.get("pose_count_seen"), 0.0) or 0) + int(_float(row.get("n_poses"), 1.0) or 0)
            if level == self.final_level and state["rdock_success"]:
                state["final_score"] = raw_score
                state["is_final_fidelity"] = True
            merged = dict(state)
            merged.update(row)
            self.trace_step_counter += 1
            merged["trace_step"] = self.trace_step_counter
            merged["trace_walltime_seconds"] = time.time() - self.run_started_at
            merged["strategy"] = self.config.strategy
            merged["adaptive_policy"] = getattr(self.config, "adaptive_policy", "")
            self.trace_rows.append(merged)
            level_rows.append(merged)
        write_rows_csv(level_rows, self.out_dir / "tables" / f"fidelity_level_{level}_scores.csv")

    def _run_level(self, level: int, level_index: int, selected_ids: list[str]) -> list[dict[str, Any]]:
        level_dir = self.out_dir / "rdock" / f"fidelity_{level:03d}"
        selection_path = level_dir / "selection.json"
        level_dir.mkdir(parents=True, exist_ok=True)
        if not (self.config.resume and selection_path.exists()):
            _write_json(
                selection_path,
                {
                    "level": level,
                    "level_index": level_index,
                    "ligand_ids": selected_ids,
                },
            )
        sdf_path = self.out_dir / "ligands" / f"fidelity_{level:03d}.sdf"
        if not (self.config.resume and sdf_path.exists() and _count_sdf(sdf_path) == len(selected_ids)):
            _write_selected_sdf(self.block_map, selected_ids, sdf_path)
        self._emit_progress("fidelity:start", {"level": level, "selected_ligands": len(selected_ids), "run_dir": str(level_dir)})
        pre_docking_predictions = {
            ligand_id: {
                "pre_docking_predicted_score": self.model_by_id[ligand_id].get("predicted_filtered_score", self.model_by_id[ligand_id].get("model_score", 0.0)),
                "pre_docking_predicted_uncertainty": self.model_by_id[ligand_id].get("predicted_uncertainty", 0.0),
            }
            for ligand_id in selected_ids
        }
        for ligand_id in selected_ids:
            self.pre_docking_prediction_rows.append(
                {
                    "ligand_id": ligand_id,
                    "cluster_id": str(self.model_by_id.get(ligand_id, {}).get("cluster_id", "")),
                    "fidelity_level": level,
                    "prediction_stage": f"before_fidelity_{level:03d}",
                    "predicted_score": pre_docking_predictions[ligand_id]["pre_docking_predicted_score"],
                    "predicted_uncertainty": pre_docking_predictions[ligand_id]["pre_docking_predicted_uncertainty"],
                    "observed_score_available_before_prediction": "false",
                    "leakage_flag": "false",
                }
            )
        start = time.time()
        artifacts = self.engine.dock_sdf(
            self.target_config,
            sdf_path,
            level_dir,
            n_runs=level,
            jobs=self.config.jobs,
            run_id=f"{self.out_dir.name}_fidelity_{level:03d}",
            resume=self.config.resume,
        )
        level_seconds = time.time() - start
        self.docking_time_total += level_seconds
        failed_chunks_path = level_dir / "tables" / "failed_chunks.csv"
        failed_ligands_path = level_dir / "tables" / "failed_ligands.csv"
        failure_summary_path = level_dir / "metrics" / "rdock_failure_summary.json"
        if failed_chunks_path.exists():
            for row in _read_rows(failed_chunks_path):
                item = dict(row)
                item["fidelity_level"] = level
                self.failed_chunk_rows.append(item)
        if failed_ligands_path.exists():
            for row in _read_rows(failed_ligands_path):
                item = dict(row)
                item["fidelity_level"] = level
                self.failed_ligand_rows.append(item)
        if failure_summary_path.exists():
            failure_payload = _load_json(failure_summary_path)
            self.rdock_records_without_score_dropped += int(failure_payload.get("records_without_score_dropped", 0) or 0)
        best_rows = []
        success_rows = {str(row["ligand_id"]): dict(row) for row in _read_rows(level_dir / "tables" / "best_per_ligand.csv")}
        for ligand_id in selected_ids:
            row = success_rows.get(ligand_id, {"ligand_id": ligand_id, "rdock_success": False, "failed_reason": "missing_best_pose"})
            row.setdefault("model_score", self.model_by_id[ligand_id]["model_score"])
            row.setdefault("cluster_id", self.model_by_id[ligand_id]["cluster_id"])
            row.setdefault("surrogate_score", self.model_by_id[ligand_id].get("surrogate_score", self.model_by_id[ligand_id]["model_score"]))
            row.update(pre_docking_predictions.get(ligand_id, {}))
            row["rdock_success"] = bool(success_rows.get(ligand_id))
            best_rows.append(row)
        penalized = self._penalize_rows(best_rows, level)
        training_seconds = self._update_surrogate(penalized)
        self.training_time_total += training_seconds
        self._record_level_rows(level, level_index, penalized, level_seconds, training_seconds)
        self._emit_progress(
            "fidelity:done",
            {
                "level": level,
                "selected_ligands": len(selected_ids),
                "successful_ligands": sum(1 for row in penalized if str(row.get("rdock_success", "")).lower() in {"true", "1"}),
                "seconds_docking": level_seconds,
                "seconds_training": training_seconds,
            },
        )
        return penalized

    def _promotion_reason(self, row: dict[str, Any]) -> str:
        reasons = [f"ranking_score={row.get('ranking_score')}", f"cluster={row.get('cluster_id')}"]
        if row.get("component_warning"):
            reasons.append(str(row["component_warning"]))
        return ";".join(reasons)

    def _promote(
        self,
        rows: list[dict[str, Any]],
        current_level: int,
        next_level: int,
        target_count: int,
    ) -> list[str]:
        successful = [row for row in rows if str(row.get("rdock_success", "")).lower() in {"true", "1"}]
        promotion_policy = str(self.config.promotion_policy).lower()
        def _policy_priority(item: dict[str, Any]) -> tuple[float, float, float, str, str]:
            base = self._promotion_priority(item) / max(0.1, float(getattr(self.config, "promotion_temperature", 1.0) or 1.0))
            uncertainty = _float(item.get("predicted_uncertainty"), 0.0)
            cluster_quality = _float(item.get("cluster_quality"), 0.0)
            classifier_probability = _float(item.get("p_good"), 0.0)
            diversity_bonus = _float(item.get("diversity_bonus"), 0.0)
            if promotion_policy == "quota_ladder":
                return (
                    base,
                    -classifier_probability,
                    -cluster_quality,
                    -diversity_bonus,
                    str(item.get("cluster_id", "")),
                )
            if promotion_policy == "exploit_heavy":
                return (base, -cluster_quality, -_float(item.get("p_good"), 0.0), str(item.get("cluster_id", "")), str(item.get("ligand_id", "")))
            if promotion_policy == "explore_heavy":
                return (base - (0.75 * uncertainty), -uncertainty, -cluster_quality, str(item.get("cluster_id", "")), str(item.get("ligand_id", "")))
            return (base - (0.25 * uncertainty), -cluster_quality, -_float(item.get("p_good"), 0.0), str(item.get("cluster_id", "")), str(item.get("ligand_id", "")))
        ordered = sorted(successful, key=_policy_priority)
        chosen_rows = _select_diverse(ordered, target_count, self.config.min_per_cluster, self.config.max_per_cluster)
        promoted_ids = [str(row["ligand_id"]) for row in chosen_rows]
        for row in ordered:
            ligand_id = str(row["ligand_id"])
            decision = {
                "ligand_id": ligand_id,
                "cluster_id": row.get("cluster_id", ""),
                "from_level": current_level,
                "to_level": next_level if ligand_id in promoted_ids else "",
                "promoted": ligand_id in promoted_ids,
                "promotion_reason": self._promotion_reason(row) if ligand_id in promoted_ids else "not selected",
                "ranking_score": row.get("ranking_score", ""),
                "SCORE": row.get("SCORE", ""),
                "SCORE.INTER": row.get("SCORE.INTER", ""),
                "SCORE.INTRA": row.get("SCORE.INTRA", ""),
                "component_warning": row.get("component_warning", ""),
            }
            self.promotion_rows.append(decision)
            state = self.state_by_id[ligand_id]
            if ligand_id in promoted_ids:
                state["promoted_from_level"] = current_level
                state["promoted_to_level"] = next_level
                state["promotion_reason"] = decision["promotion_reason"]
        return promoted_ids

    def _initial_selection(self, target_count: int) -> list[str]:
        if target_count <= 0:
            return []
        ordered = sorted(
            self.candidate_rows,
            key=lambda row: (-float(row["model_score"]), str(row["cluster_id"]), str(row["ligand_id"])),
        )
        explore_count = max(self.config.cluster_min_coverage, int(math.ceil(target_count * self.config.exploration_fraction)))
        explore_seed_rows = _select_diverse(ordered, min(target_count, explore_count), max(self.config.min_per_cluster, self.config.cluster_min_coverage), self.config.max_per_cluster)
        selected_ids = [str(row["ligand_id"]) for row in explore_seed_rows]
        if len(selected_ids) >= target_count:
            return selected_ids[:target_count]
        for row in ordered:
            ligand_id = str(row["ligand_id"])
            if ligand_id in selected_ids:
                continue
            selected_ids.append(ligand_id)
            if len(selected_ids) >= target_count:
                break
        return selected_ids[:target_count]

    def _prefilter_candidate_rows(self) -> list[dict[str, Any]]:
        decisions: list[dict[str, Any]] = []
        screenable: list[dict[str, Any]] = []
        for row in self.candidate_rows:
            item = dict(row)
            reasons: list[str] = []
            low_priority = False
            smiles = str(item.get("smiles", "")).strip()
            mw = _float(item.get("molecular_weight"), 0.0)
            charge = abs(_float(item.get("formal_charge"), 0.0))
            rotors = _float(item.get("rotatable_bonds"), 0.0)
            heavy = _float(item.get("heavy_atom_count"), 0.0)
            if not smiles:
                reasons.append("missing_smiles")
            if mw <= 0.0 and heavy <= 0.0:
                reasons.append("missing_descriptor_support")
            if charge > 3.0:
                reasons.append("high_formal_charge")
                low_priority = True
            if rotors > 18:
                reasons.append("high_rotatable_bonds")
                low_priority = True
            if mw > 900:
                reasons.append("large_molecule")
                low_priority = True
            if heavy < 8 and mw < 120:
                reasons.append("very_small_molecule")
                low_priority = True
            keep = "missing_smiles" not in reasons
            decision = {
                "ligand_id": str(item["ligand_id"]),
                "cluster_id": str(item["cluster_id"]),
                "keep_for_screening": _bool_text(keep),
                "low_priority": _bool_text(low_priority),
                "reason": ",".join(reasons),
                "molecular_weight": item.get("molecular_weight", ""),
                "rotatable_bonds": item.get("rotatable_bonds", ""),
                "formal_charge": item.get("formal_charge", ""),
                "heavy_atom_count": item.get("heavy_atom_count", ""),
                "smiles_length": item.get("smiles_length", ""),
            }
            decisions.append(decision)
            if keep:
                item["prefilter_low_priority"] = low_priority
                item["prefilter_reason"] = decision["reason"]
                screenable.append(item)
        write_rows_csv(decisions, self.out_dir / "tables" / "initial_prefilter_decisions.csv")
        return screenable

    def _policy_level_counts(self, library_size: int, levels: list[int], budget_runs: int) -> list[int]:
        if library_size <= 0:
            return [0 for _ in levels]
        if not self.reference_free_mode:
            counts = _plan_level_counts(
                library_size=library_size,
                levels=levels,
                budget_runs=budget_runs,
                promotion_fraction=self.config.promotion_fraction,
            )
            if self.config.adaptive_budget_ligands is not None and counts:
                counts[0] = min(counts[0], int(self.config.adaptive_budget_ligands))
            return counts
        policy = str(self.config.promotion_policy).lower()
        step_expansion_caps = {
            "aggressive": 1.30,
            "adaptive": 1.45,
            "conservative": 1.55,
            "exploit_heavy": 1.35,
            "balanced": 1.55,
            "explore_heavy": 1.80,
        }
        max_step_expansion = step_expansion_caps.get(policy, step_expansion_caps["conservative"])
        explicit_multipliers: list[float] = []
        if str(self.config.promotion_fraction_by_level).strip():
            try:
                parsed = [float(part.strip()) for part in str(self.config.promotion_fraction_by_level).split(",") if part.strip()]
                if len(parsed) == len(levels):
                    explicit_multipliers = [max(1.0, float(value)) for value in parsed]
            except Exception:
                explicit_multipliers = []

        def _counts_from_final(final_count: int) -> list[int]:
            counts = [0 for _ in levels]
            counts[-1] = min(library_size, max(0, final_count))
            for idx in range(len(levels) - 2, -1, -1):
                if explicit_multipliers:
                    proposed = int(math.ceil(counts[-1] * explicit_multipliers[idx]))
                else:
                    proposed = int(math.ceil(counts[idx + 1] * max_step_expansion))
                counts[idx] = min(
                    library_size,
                    max(counts[idx + 1], self.config.min_promotion_per_level, proposed),
                )
            return counts

        def _cost(counts: list[int]) -> int:
            return sum(level * count for level, count in zip(levels, counts))

        max_final_by_budget = max(0, budget_runs // max(1, sum(levels)))
        if max_final_by_budget <= 0:
            base = min(library_size, max(1, budget_runs // max(1, levels[0])))
            counts = [0 for _ in levels]
            counts[0] = base
            return counts

        high = min(library_size, max_final_by_budget)
        low = 1
        best_counts = _counts_from_final(1)
        if _cost(best_counts) > budget_runs:
            counts = [0 for _ in levels]
            counts[0] = min(library_size, max(1, budget_runs // max(1, levels[0])))
            return counts
        while low <= high:
            mid = (low + high) // 2
            counts = _counts_from_final(mid)
            total_cost = _cost(counts)
            if total_cost <= budget_runs:
                best_counts = counts
                low = mid + 1
            else:
                high = mid - 1
        counts = best_counts
        if self.config.adaptive_budget_ligands is not None and counts:
            counts[0] = min(counts[0], int(self.config.adaptive_budget_ligands))
        for idx in range(1, len(counts)):
            counts[idx] = min(counts[idx], counts[idx - 1])
        return counts

    def _select_calibration_rows(self, rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
        if not rows:
            return []
        requested = self.config.calibration_size
        if requested <= 0:
            requested = int(math.ceil(len(rows) * self.config.calibration_fraction))
        requested = max(self.config.min_clusters_covered, min(len(rows), requested))
        ordered = sorted(
            rows,
            key=lambda row: (
                _bool_arg(row.get("prefilter_low_priority"), False),
                -float(row.get("diversity_bonus", 0.0)),
                str(row.get("cluster_id", "")),
                str(row.get("ligand_id", "")),
            ),
        )
        selected = _select_diverse(ordered, requested, max(self.config.min_clusters_covered, 1), max(self.config.max_per_cluster, 1))
        if self.config.calibration_random_fraction > 0.0 and len(selected) < requested:
            rng = random.Random(self.config.reference_sample_seed)
            remaining = [row for row in rows if str(row["ligand_id"]) not in {str(item["ligand_id"]) for item in selected}]
            rng.shuffle(remaining)
            random_take = max(1, int(math.ceil(requested * self.config.calibration_random_fraction)))
            selected.extend(remaining[: max(0, min(random_take, requested - len(selected)))])
        return selected[:requested]

    def _cluster_only_selection(self, rows: list[dict[str, Any]]) -> tuple[list[dict[str, Any]], dict[str, Any]]:
        requested = _requested_survivor_count(
            len(rows),
            self.config.triage_retain_fraction,
            self.config.triage_min_survivors,
            self.config.triage_max_survivors,
        )
        ordered = sorted(
            rows,
            key=lambda row: (
                _bool_arg(row.get("prefilter_low_priority"), False),
                float(row.get("cluster_size", 1)),
                -float(row.get("diversity_bonus", 0.0)),
                str(row.get("cluster_id", "")),
                str(row.get("ligand_id", "")),
            ),
        )
        selected = _select_diverse(ordered, requested, max(1, self.config.cluster_min_survivors), self.config.cluster_max_survivors or max(1, self.config.max_per_cluster))
        selected_ids = {str(row["ligand_id"]) for row in selected}
        if self.config.rare_cluster_rescue > 0:
            rare_candidates = [
                row for row in ordered
                if str(row["ligand_id"]) not in selected_ids and int(_float(row.get("cluster_size"), 1.0) or 1) <= 2
            ]
            for row in rare_candidates[: self.config.rare_cluster_rescue]:
                selected.append(row)
                selected_ids.add(str(row["ligand_id"]))
        selected.sort(key=lambda row: (float(row.get("cluster_size", 1)), str(row.get("cluster_id", "")), str(row.get("ligand_id", ""))))
        return selected, {
            "requested_survivor_count": requested,
            "final_survivor_count": len(selected),
        }

    def _descriptor_filter_selection(self, rows: list[dict[str, Any]]) -> tuple[list[dict[str, Any]], dict[str, Any]]:
        decisions: list[dict[str, Any]] = []
        retained: list[dict[str, Any]] = []
        for row in rows:
            reasons: list[str] = []
            keep = True
            mw = _float(row.get("molecular_weight"), 0.0)
            charge = abs(_float(row.get("formal_charge"), 0.0))
            rotors = _float(row.get("rotatable_bonds"), 0.0)
            heavy = _float(row.get("heavy_atom_count"), 0.0)
            if str(row.get("smiles", "")).strip() == "":
                keep = False
                reasons.append("missing_smiles")
            if charge > 4.0:
                keep = False
                reasons.append("extreme_charge")
            if rotors > 20:
                keep = False
                reasons.append("too_many_rotors")
            if mw > 1000:
                keep = False
                reasons.append("too_large")
            if heavy < 6 and mw < 100:
                keep = False
                reasons.append("too_small")
            decisions.append(
                {
                    "ligand_id": str(row["ligand_id"]),
                    "cluster_id": str(row.get("cluster_id", "")),
                    "keep_for_screening": _bool_text(keep),
                    "reason": ",".join(reasons),
                    "molecular_weight": row.get("molecular_weight", ""),
                    "formal_charge": row.get("formal_charge", ""),
                    "rotatable_bonds": row.get("rotatable_bonds", ""),
                    "heavy_atom_count": row.get("heavy_atom_count", ""),
                }
            )
            if keep:
                retained.append(dict(row))
        write_rows_csv(decisions, self.out_dir / "tables" / "descriptor_filter_decisions.csv")
        requested = _requested_survivor_count(
            len(retained),
            self.config.triage_retain_fraction,
            min(self.config.triage_min_survivors, max(1, len(retained))),
            self.config.triage_max_survivors,
        ) if retained else 0
        ordered = sorted(
            retained,
            key=lambda row: (
                float(row.get("rotatable_bonds", 0.0)),
                abs(float(row.get("formal_charge", 0.0))),
                float(row.get("cluster_size", 1)),
                str(row.get("ligand_id", "")),
            ),
        )
        selected = _select_diverse(ordered, requested, max(1, self.config.cluster_min_survivors), self.config.cluster_max_survivors or max(1, self.config.max_per_cluster)) if requested > 0 else []
        selected.sort(key=lambda row: (float(row.get("rotatable_bonds", 0.0)), abs(float(row.get("formal_charge", 0.0))), str(row.get("ligand_id", ""))))
        return selected, {
            "prefilter_retained_count": len(retained),
            "requested_survivor_count": requested,
            "final_survivor_count": len(selected),
        }

    def _classifier_metrics(self, labeled_rows: list[dict[str, Any]], top_fraction: float) -> dict[str, Any]:
        if len(labeled_rows) < 3:
            return {
                "classifier_precision": None,
                "classifier_recall": None,
                "classifier_f1": None,
                "classifier_auc_pr": None,
                "top_k_recall": None,
                "selected_threshold": None,
                "calibration_sample_size": len(labeled_rows),
                "positive_count": 0,
                "positives_in_train": 0,
                "positives_in_holdout": 0,
                "threshold_confidence": "low",
                "insufficient_positive_examples_for_classifier": True,
            }
        ranked = _sort_by_score(labeled_rows, "final_score", "ranking_score", "SCORE")
        positive_ids = {str(row["ligand_id"]) for row in ranked[: max(1, int(math.ceil(len(ranked) * top_fraction)))]}
        if len(positive_ids) < self.config.classifier_min_positives:
            return {
                "classifier_precision": None,
                "classifier_recall": None,
                "classifier_f1": None,
                "classifier_auc_pr": None,
                "top_k_recall": None,
                "selected_threshold": None,
                "calibration_sample_size": len(labeled_rows),
                "positive_count": len(positive_ids),
                "positives_in_train": 0,
                "positives_in_holdout": len(positive_ids),
                "threshold_confidence": "low",
                "insufficient_positive_examples_for_classifier": True,
            }

        def _run_split(split_name: str) -> tuple[dict[str, Any], list[dict[str, Any]], list[dict[str, Any]], list[dict[str, Any]]]:
            train_rows, holdout_rows = _split_rows_for_validation(
                labeled_rows,
                self.config.classifier_holdout_fraction,
                self.config.reference_sample_seed,
                split_name,
            )
            holdout_positive_ids = {str(row["ligand_id"]) for row in holdout_rows if str(row["ligand_id"]) in positive_ids}
            predicted_rows = self._build_knn_predictions(
                train_rows,
                holdout_rows,
                top_fraction=top_fraction,
                state_overrides=_state_overrides_from_rows(train_rows),
            )
            scored = [(str(row["ligand_id"]), float(row["p_good"])) for row in predicted_rows]
            ordered = sorted(scored, key=lambda item: item[1], reverse=True)
            unique_thresholds = sorted({score for _, score in ordered}, reverse=True)
            curve_rows: list[dict[str, Any]] = []
            best_metrics = None
            precision_points: list[tuple[float, float]] = []
            for candidate_threshold in unique_thresholds:
                selected_ids = {ligand_id for ligand_id, score in ordered if score >= candidate_threshold}
                tp = len(selected_ids & holdout_positive_ids)
                recall = tp / max(1, len(holdout_positive_ids))
                precision = tp / max(1, len(selected_ids))
                f1 = 0.0 if (precision + recall) == 0.0 else (2.0 * precision * recall) / (precision + recall)
                curve_rows.append(
                    {
                        "validation_split": split_name,
                        "threshold": candidate_threshold,
                        "selected_count": len(selected_ids),
                        "recall": recall,
                        "precision": precision,
                        "f1": f1,
                    }
                )
                precision_points.append((recall, precision))
                if recall >= self.config.triage_target_recall:
                    if best_metrics is None or len(selected_ids) < int(best_metrics["selected_count"]):
                        best_metrics = {
                            "classifier_precision": precision,
                            "classifier_recall": recall,
                            "classifier_f1": f1,
                            "top_k_recall": recall,
                            "selected_threshold": candidate_threshold,
                            "calibration_sample_size": len(labeled_rows),
                            "positive_count": len(positive_ids),
                            "positives_in_train": len({str(row['ligand_id']) for row in train_rows if str(row['ligand_id']) in positive_ids}),
                            "positives_in_holdout": len(holdout_positive_ids),
                            "threshold_confidence": "high",
                            "selected_count": len(selected_ids),
                            "insufficient_positive_examples_for_classifier": False,
                            "validation_split": split_name,
                        }
            auc_pr = None
            if precision_points:
                ordered_curve = sorted(precision_points, key=lambda item: item[0])
                auc = 0.0
                prev_recall, prev_precision = ordered_curve[0]
                for recall, precision in ordered_curve[1:]:
                    auc += max(0.0, recall - prev_recall) * ((precision + prev_precision) * 0.5)
                    prev_recall, prev_precision = recall, precision
                auc_pr = auc
            if best_metrics is None:
                fallback_threshold = unique_thresholds[-1] if unique_thresholds else 0.0
                selected_ids = {ligand_id for ligand_id, score in ordered if score >= fallback_threshold}
                tp = len(selected_ids & holdout_positive_ids)
                recall = tp / max(1, len(holdout_positive_ids))
                precision = tp / max(1, len(selected_ids))
                f1 = 0.0 if (precision + recall) == 0.0 else (2.0 * precision * recall) / (precision + recall)
                best_metrics = {
                    "classifier_precision": precision,
                    "classifier_recall": recall,
                    "classifier_f1": f1,
                    "top_k_recall": recall,
                    "selected_threshold": fallback_threshold,
                    "calibration_sample_size": len(labeled_rows),
                    "positive_count": len(positive_ids),
                    "positives_in_train": len({str(row['ligand_id']) for row in train_rows if str(row['ligand_id']) in positive_ids}),
                    "positives_in_holdout": len(holdout_positive_ids),
                    "threshold_confidence": "low",
                    "selected_count": len(selected_ids),
                    "insufficient_positive_examples_for_classifier": False,
                    "validation_split": split_name,
                }
            best_metrics["classifier_auc_pr"] = auc_pr
            return best_metrics, curve_rows, train_rows, holdout_rows

        random_metrics, random_curve_rows, random_train, random_holdout = _run_split("random")
        cluster_metrics, cluster_curve_rows, cluster_train, cluster_holdout = _run_split("cluster")
        active_split = str(getattr(self.config, "model_validation_split", "cluster") or "cluster").lower()
        active = cluster_metrics if active_split == "cluster" else random_metrics
        active_train = cluster_train if active_split == "cluster" else random_train
        active_holdout = cluster_holdout if active_split == "cluster" else random_holdout
        write_rows_csv(random_curve_rows + cluster_curve_rows, self.out_dir / "tables" / "threshold_calibration_curve.csv")
        write_rows_csv(
            [
                {
                    "split": active_split,
                    "role": "train",
                    "ligand_id": str(row.get("ligand_id", "")),
                    "cluster_id": str(row.get("cluster_id", "")),
                    "canonical_smiles": str(row.get("smiles", "")),
                    "is_positive": _bool_text(str(row.get("ligand_id", "")) in positive_ids),
                }
                for row in active_train
            ],
            self.out_dir / "tables" / "model_training_rows.csv",
        )
        write_rows_csv(
            [
                {
                    "split": active_split,
                    "role": "holdout",
                    "ligand_id": str(row.get("ligand_id", "")),
                    "cluster_id": str(row.get("cluster_id", "")),
                    "canonical_smiles": str(row.get("smiles", "")),
                    "is_positive": _bool_text(str(row.get("ligand_id", "")) in positive_ids),
                }
                for row in active_holdout
            ],
            self.out_dir / "tables" / "model_holdout_rows.csv",
        )
        active.update(
            {
                "classifier_precision_random": random_metrics.get("classifier_precision"),
                "classifier_recall_random": random_metrics.get("classifier_recall"),
                "classifier_auc_pr_random": random_metrics.get("classifier_auc_pr"),
                "classifier_precision_cluster": cluster_metrics.get("classifier_precision"),
                "classifier_recall_cluster": cluster_metrics.get("classifier_recall"),
                "classifier_auc_pr_cluster": cluster_metrics.get("classifier_auc_pr"),
                "model_validation_split": active_split,
            }
        )
        random_auc = _float(random_metrics.get("classifier_auc_pr"), None)
        cluster_auc = _float(cluster_metrics.get("classifier_auc_pr"), None)
        active["MODEL_GENERALIZATION_WEAK_ACROSS_CLUSTERS"] = bool(
            random_auc is not None and cluster_auc is not None and random_auc > 0.15 and cluster_auc < (0.7 * random_auc)
        )
        _write_json(self.out_dir / "metrics" / "classifier_threshold_metrics.json", active)
        return active

    def _regressor_audit_metrics(self, labeled_rows: list[dict[str, Any]], top_fraction: float) -> dict[str, Any]:
        if len(labeled_rows) < max(12, self.config.classifier_min_positives * 2):
            payload = {
                "fixed_score_regressor_name": self.config.fixed_score_regressor_name,
                "fixed_score_regressor_target": self.config.fixed_score_regressor_target,
                "regressor_model_type": self.config.regressor_model_type,
                "surrogate_mae": None,
                "surrogate_spearman": None,
                "surrogate_spearman_neg_pred_vs_obs": None,
                "surrogate_spearman_pred_vs_neg_obs": None,
                "surrogate_affinity_like_spearman": None,
                "n_regressor_points": 0,
                "regressor_prediction_direction": "higher_is_better",
                "uncertainty_vs_error_spearman": None,
                "regressor_sign_check_passed": False,
                "cluster_validation_spearman": None,
                "REGRESSOR_NOT_PROVEN_USEFUL": True,
                "predicted_score_sd": None,
                "observed_score_sd": None,
                "predicted_observed_sd_ratio": None,
                "REGRESSOR_MEDIAN_COLLAPSE_RISK": True,
            }
            _write_json(self.out_dir / "metrics" / "regressor_audit_metrics.json", payload)
            write_rows_csv([], self.out_dir / "tables" / "regressor_validation_predictions.csv")
            write_rows_csv([], self.out_dir / "tables" / "regressor_sign_check.csv")
            write_rows_csv([], self.out_dir / "tables" / "regressor_target_comparison.csv")
            write_rows_csv([], self.out_dir / "tables" / "regressor_distribution_audit.csv")
            write_rows_csv([], self.out_dir / "tables" / "leakage_audit.csv")
            return payload
        validation_rows: list[dict[str, Any]] = []
        target_rows: list[dict[str, Any]] = []
        leakage_rows: list[dict[str, Any]] = []
        split_payloads: dict[str, dict[str, Any]] = {}

        for split_name in ("random", "cluster"):
            train_rows, holdout_rows = _split_rows_for_validation(
                labeled_rows,
                self.config.classifier_holdout_fraction,
                self.config.reference_sample_seed,
                split_name,
            )
            predicted_rows = self._build_knn_predictions(
                train_rows,
                holdout_rows,
                top_fraction=top_fraction,
                state_overrides=_state_overrides_from_rows(train_rows),
            )
            pred_rows_by_id = {str(row.get("ligand_id", "")): row for row in predicted_rows}
            pred_score: list[float] = []
            obs_score: list[float] = []
            pred_affinity: list[float] = []
            obs_affinity: list[float] = []
            unc_values: list[float] = []
            unc_errors: list[float] = []
            split_validation_rows: list[dict[str, Any]] = []
            for row in holdout_rows:
                ligand_id = str(row.get("ligand_id", ""))
                pred_row = pred_rows_by_id.get(ligand_id)
                if pred_row is None:
                    continue
                predicted_adjusted_score = _float(pred_row.get("predicted_adjusted_score"), None)
                predicted_affinity_like = _float(pred_row.get("predicted_affinity_like"), None)
                observed_component_sane = _component_sane_score(row)
                observed_raw = _float(row.get("SCORE"), None)
                observed_inter = _float(row.get("SCORE.INTER"), None)
                if predicted_adjusted_score is None or predicted_affinity_like is None or observed_component_sane is None:
                    continue
                pred_score.append(predicted_adjusted_score)
                obs_score.append(observed_component_sane)
                pred_affinity.append(predicted_affinity_like)
                obs_affinity.append(-observed_component_sane)
                unc_val = _float(pred_row.get("predicted_uncertainty"), None)
                if unc_val is not None:
                    unc_values.append(unc_val)
                    unc_errors.append(abs(predicted_adjusted_score - observed_component_sane))
                split_validation_rows.append(
                    {
                        "validation_split": split_name,
                        "ligand_id": ligand_id,
                        "cluster_id": str(row.get("cluster_id", "")),
                        "predicted_activity_class": str(pred_row.get("regressor_activity_class", "uncertain")),
                        "predicted_score": predicted_adjusted_score,
                        "predicted_affinity_like": predicted_affinity_like,
                        "prediction_uncertainty": unc_val,
                        "observed_component_sane_score": observed_component_sane,
                        "observed_raw_score": observed_raw,
                        "observed_score_inter": observed_inter,
                        "observed_affinity_like": -observed_component_sane,
                        "regressor_rank_score": _float(pred_row.get("regressor_rank_score"), None),
                        "regressor_confidence": _float(pred_row.get("regressor_confidence"), None),
                    }
                )
                leakage_rows.append(
                    {
                        "ligand_id": ligand_id,
                        "split": split_name,
                        "cluster_id": str(row.get("cluster_id", "")),
                        "fidelity_level": str(row.get("selected_fidelity_runs", "")),
                        "prediction_timestamp_stage": f"{split_name}_holdout_validation",
                        "observed_score_available_before_prediction": "false",
                        "leakage_flag": "false",
                    }
                )
                for target_name in ("raw_score", "component_sane_score", "score_inter", "affinity_like"):
                    observed_target = _score_target_value(row, target_name)
                    target_rows.append(
                        {
                            "validation_split": split_name,
                            "ligand_id": ligand_id,
                            "target_name": target_name,
                            "predicted_score": predicted_adjusted_score,
                            "predicted_affinity_like": predicted_affinity_like,
                            "observed_target": observed_target,
                        }
                    )
            split_payloads[split_name] = {
                "surrogate_mae": _mean([abs(a - b) for a, b in zip(pred_score, obs_score)]) if pred_score else None,
                "surrogate_spearman": _spearman(pred_score, obs_score),
                "surrogate_affinity_like_spearman": _spearman(pred_affinity, obs_affinity),
                "uncertainty_vs_error_spearman": _spearman(unc_values, unc_errors) if unc_values else None,
                "validation_rows": split_validation_rows,
                "sign_rows": [
                    {"comparison": "spearman(predicted_score, observed_score)", "value": _spearman(pred_score, obs_score), "validation_split": split_name},
                    {"comparison": "spearman(-predicted_score, observed_score)", "value": _spearman([-value for value in pred_score], obs_score), "validation_split": split_name},
                    {"comparison": "spearman(predicted_score, -observed_score)", "value": _spearman(pred_score, [-value for value in obs_score]), "validation_split": split_name},
                    {"comparison": "spearman(predicted_affinity_like, observed_affinity_like)", "value": _spearman(pred_affinity, obs_affinity), "validation_split": split_name},
                ],
                "n_points": len(split_validation_rows),
            }
            validation_rows.extend(split_validation_rows)

        grouped_targets: dict[tuple[str, str], list[tuple[float, float]]] = {}
        for row in target_rows:
            predicted_affinity_like = _float(row.get("predicted_affinity_like"), None)
            observed_target = _float(row.get("observed_target"), None)
            if predicted_affinity_like is None or observed_target is None:
                continue
            grouped_targets.setdefault((str(row["validation_split"]), str(row["target_name"])), []).append((predicted_affinity_like, observed_target))
        target_comparison_rows: list[dict[str, Any]] = []
        for (split_name, target_name), pairs in grouped_targets.items():
            target_comparison_rows.append(
                {
                    "validation_split": split_name,
                    "target_name": target_name,
                    "spearman_predicted_affinity_vs_target": _spearman([x for x, _ in pairs], [y for _, y in pairs]),
                    "n_points": len(pairs),
                }
            )

        active_split = str(getattr(self.config, "model_validation_split", "cluster") or "cluster").lower()
        active = split_payloads.get(active_split, split_payloads["cluster"])
        sign_lookup = {str(row["comparison"]): row.get("value") for row in active["sign_rows"]}
        active_validation = list(active.get("validation_rows", []))
        active_pred_scores_raw = [_float(row.get("predicted_score"), None) for row in active_validation]
        active_obs_scores_raw = [_float(row.get("observed_component_sane_score"), None) for row in active_validation]
        active_pred_scores = [float(value) for value in active_pred_scores_raw if value is not None]
        active_obs_scores = [float(value) for value in active_obs_scores_raw if value is not None]
        pred_sd = _stdev(active_pred_scores, _mean(active_pred_scores)) if active_pred_scores else None
        obs_sd = _stdev(active_obs_scores, _mean(active_obs_scores)) if active_obs_scores else None
        sd_ratio = (float(pred_sd) / float(obs_sd)) if pred_sd is not None and obs_sd not in {None, 0.0} else None
        median_collapse = bool(sd_ratio is not None and sd_ratio < 0.25 and int(active.get("n_points", 0) or 0) >= 8)
        distribution_rows = [
            {
                "validation_split": active_split,
                "n_points": active.get("n_points", 0),
                "predicted_score_mean": _mean(active_pred_scores) if active_pred_scores else None,
                "predicted_score_median": _median(active_pred_scores) if active_pred_scores else None,
                "predicted_score_sd": pred_sd,
                "observed_score_mean": _mean(active_obs_scores) if active_obs_scores else None,
                "observed_score_median": _median(active_obs_scores) if active_obs_scores else None,
                "observed_score_sd": obs_sd,
                "predicted_observed_sd_ratio": sd_ratio,
                "median_collapse_risk": median_collapse,
            }
        ]
        raw_target_spearman = next(
            (
                _float(row.get("spearman_predicted_affinity_vs_target"), None)
                for row in target_comparison_rows
                if str(row.get("validation_split")) == active_split and str(row.get("target_name")) == "raw_score"
            ),
            None,
        )
        component_sane_spearman = next(
            (
                _float(row.get("spearman_predicted_affinity_vs_target"), None)
                for row in target_comparison_rows
                if str(row.get("validation_split")) == active_split and str(row.get("target_name")) == "component_sane_score"
            ),
            None,
        )
        inter_component_spearman = next(
            (
                _float(row.get("spearman_predicted_affinity_vs_target"), None)
                for row in target_comparison_rows
                if str(row.get("validation_split")) == active_split and str(row.get("target_name")) == "score_inter"
            ),
            None,
        )
        sign_passed = (_float(sign_lookup.get("spearman(predicted_affinity_like, observed_affinity_like)"), -1.0) or -1.0) > 0.0
        payload = {
            "fixed_score_regressor_name": self.config.fixed_score_regressor_name,
            "fixed_score_regressor_target": self.config.fixed_score_regressor_target,
            "regressor_model_type": self.config.regressor_model_type,
            "surrogate_mae": active.get("surrogate_mae"),
            "surrogate_spearman": active.get("surrogate_spearman"),
            "surrogate_spearman_neg_pred_vs_obs": sign_lookup.get("spearman(-predicted_score, observed_score)"),
            "surrogate_spearman_pred_vs_neg_obs": sign_lookup.get("spearman(predicted_score, -observed_score)"),
            "surrogate_affinity_like_spearman": active.get("surrogate_affinity_like_spearman"),
            "uncertainty_vs_error_spearman": active.get("uncertainty_vs_error_spearman"),
            "n_regressor_points": active.get("n_points"),
            "regressor_prediction_direction": "higher_is_better",
            "model_validation_split": active_split,
            "random_validation_spearman": split_payloads["random"].get("surrogate_affinity_like_spearman"),
            "cluster_validation_spearman": split_payloads["cluster"].get("surrogate_affinity_like_spearman"),
            "random_validation_mae": split_payloads["random"].get("surrogate_mae"),
            "cluster_validation_mae": split_payloads["cluster"].get("surrogate_mae"),
            "raw_score_spearman": raw_target_spearman,
            "component_sane_spearman": component_sane_spearman,
            "inter_component_spearman": inter_component_spearman,
            "regressor_sign_check_passed": sign_passed,
            "MODEL_GENERALIZATION_WEAK_ACROSS_CLUSTERS": bool(
                _float(split_payloads["random"].get("surrogate_affinity_like_spearman"), None) is not None
                and _float(split_payloads["cluster"].get("surrogate_affinity_like_spearman"), None) is not None
                and float(split_payloads["random"]["surrogate_affinity_like_spearman"]) > 0.3
                and float(split_payloads["cluster"]["surrogate_affinity_like_spearman"]) < 0.2
            ),
            "intra_fraction_outlier_rate": _mean(
                [
                    1.0 if _float(row.get("intra_fraction"), 0.0) >= self.config.max_intra_fraction_soft else 0.0
                    for row in labeled_rows
                ]
            ),
            "target_outlier_rate": _mean(
                [
                    1.0 if str(row.get("component_warning", "")).strip() else 0.0
                    for row in labeled_rows
                ]
            ),
            "predicted_score_sd": pred_sd,
            "observed_score_sd": obs_sd,
            "predicted_observed_sd_ratio": sd_ratio,
            "REGRESSOR_MEDIAN_COLLAPSE_RISK": median_collapse,
        }
        regressor_ok, disabled_reason = _regressor_status_from_metrics(payload)
        payload["REGRESSOR_NOT_PROVEN_USEFUL"] = not regressor_ok
        payload["regressor_disabled_reason"] = disabled_reason
        _write_json(self.out_dir / "metrics" / "regressor_audit_metrics.json", payload)
        write_rows_csv(validation_rows, self.out_dir / "tables" / "regressor_validation_predictions.csv")
        write_rows_csv(split_payloads["random"]["sign_rows"] + split_payloads["cluster"]["sign_rows"], self.out_dir / "tables" / "regressor_sign_check.csv")
        write_rows_csv(target_comparison_rows, self.out_dir / "tables" / "regressor_target_comparison.csv")
        write_rows_csv(distribution_rows, self.out_dir / "tables" / "regressor_distribution_audit.csv")
        write_rows_csv(leakage_rows, self.out_dir / "tables" / "leakage_audit.csv")
        return payload

    def _build_knn_predictions(
        self,
        labeled_rows: list[dict[str, Any]],
        universe_rows: list[dict[str, Any]],
        *,
        top_fraction: float,
        state_overrides: dict[str, dict[str, Any]] | None = None,
    ) -> list[dict[str, Any]]:
        usable_labeled_rows = [
            dict(row)
            for row in labeled_rows
            if _score_target_value(row, self.config.fixed_score_regressor_target) is not None
        ]
        if not usable_labeled_rows:
            return [
                dict(
                    row,
                    p_good=0.5,
                    predicted_adjusted_score=_float(row.get("model_score"), 0.0),
                    predicted_affinity_like=-_float(row.get("model_score"), 0.0),
                    predicted_uncertainty=1.0,
                    outlier_risk=0.0,
                    regressor_confidence=0.5,
                    regressor_activity_class="uncertain",
                    regressor_prediction_direction="higher_is_better",
                )
                for row in universe_rows
            ]
        ranked = _sort_by_score(usable_labeled_rows, "final_score", "ranking_score", "SCORE")
        n_good = max(1, int(math.ceil(len(ranked) * top_fraction)))
        good_ids = {str(row["ligand_id"]) for row in ranked[:n_good]}
        cluster_scores: dict[str, list[float]] = {}
        cluster_hits: dict[str, list[float]] = {}
        for row in usable_labeled_rows:
            cluster_id = str(row.get("cluster_id", ""))
            cluster_scores.setdefault(cluster_id, []).append(_float(row.get("final_score", row.get("ranking_score", row.get("SCORE"))), 0.0))
            cluster_hits.setdefault(cluster_id, []).append(1.0 if str(row.get("ligand_id")) in good_ids else 0.0)

        def _augment_row(row: dict[str, Any]) -> dict[str, Any]:
            item = dict(row)
            ligand_id = str(item.get("ligand_id", ""))
            cluster_id = str(item.get("cluster_id", ""))
            if state_overrides is None:
                state = self.state_by_id.get(ligand_id, {})
            else:
                state = state_overrides.get(ligand_id, {})
            scores = cluster_scores.get(cluster_id, [])
            hits = cluster_hits.get(cluster_id, [])
            item["best_cluster_score_seen_so_far"] = min(scores) if scores else 0.0
            item["median_cluster_score_seen_so_far"] = _median(scores) if scores else 0.0
            item["n_cluster_labeled"] = len(scores)
            item["cluster_uncertainty"] = _stdev(scores, _mean(scores)) if scores else 1.0
            item["cluster_hit_rate"] = _mean(hits) if hits else 0.0
            item["interaction_quality"] = max(
                _float(state.get("biological_interaction_proxy_score"), 0.0),
                _float(item.get("biological_interaction_proxy_score"), 0.0),
            )
            item["post_docking_confidence_score"] = max(
                _float(state.get("post_docking_confidence_score"), 0.0),
                _float(item.get("post_docking_confidence_score"), 0.0),
            )
            dynamic = [
                _float(state.get("selected_fidelity_runs"), 0.0),
                _float(state.get("current_best_score"), 0.0),
                _float(state.get("score_mean_observed"), 0.0),
                _float(state.get("score_std_observed"), 0.0),
                _float(state.get("best_inter_seen"), 0.0),
                _float(state.get("best_intra_seen"), 0.0),
                _float(state.get("best_intra_fraction_seen"), 0.0),
                _float(state.get("failed_observation_fraction"), 0.0),
                _float(state.get("pose_count_seen"), 0.0),
                _float(item.get("best_cluster_score_seen_so_far"), 0.0),
                _float(item.get("median_cluster_score_seen_so_far"), 0.0),
                _float(item.get("n_cluster_labeled"), 0.0),
                _float(item.get("cluster_uncertainty"), 0.0),
                _float(item.get("cluster_hit_rate"), 0.0),
                _float(item.get("interaction_quality"), 0.0),
                _float(item.get("post_docking_confidence_score"), 0.0),
            ]
            item["augmented_feature_vector"] = [float(value) for value in item.get("feature_vector", [])] + dynamic
            return item

        usable_labeled_rows = [_augment_row(row) for row in usable_labeled_rows]
        prepared_universe_rows = [_augment_row(row) for row in universe_rows]
        if SKLEARN_AVAILABLE and len(usable_labeled_rows) >= max(12, self.config.classifier_min_positives * 2):
            train_x = _feature_matrix(usable_labeled_rows)
            pred_x = _feature_matrix(prepared_universe_rows)
            y_good = [1 if str(row["ligand_id"]) in good_ids else 0 for row in usable_labeled_rows]
            y_score = [_score_target_value(row, self.config.fixed_score_regressor_target) or 0.0 for row in usable_labeled_rows]
            y_outlier = [1 if str(row.get("component_warning", "")).strip() else 0 for row in usable_labeled_rows]
            sample_weight = _analog_sample_weights(usable_labeled_rows)
            classifier_name = str(self.config.triage_model).lower()
            if classifier_name == "logistic_regression" and LogisticRegression is not None:
                classifier = LogisticRegression(max_iter=500, class_weight="balanced", random_state=42)
            else:
                classifier = ExtraTreesClassifier(
                    n_estimators=256,
                    random_state=42,
                    class_weight="balanced",
                    min_samples_leaf=2,
                    n_jobs=1,
                )
            _fit_model(classifier, train_x, y_good, sample_weight)
            regressor = _make_regressor_model(self.config.regressor_model_type)
            if regressor is None:
                raise RDockPipelineError("No regressor backend available")
            _fit_model(regressor, train_x, y_score, sample_weight)
            outlier_model = ExtraTreesClassifier(
                n_estimators=128,
                random_state=17,
                class_weight="balanced",
                min_samples_leaf=2,
                n_jobs=1,
            )
            _fit_model(outlier_model, train_x, y_outlier, sample_weight)
            predicted_good = _binary_positive_proba(classifier, pred_x, default_positive=0.0)
            predicted_affinity = regressor.predict(pred_x)
            uncertainties = _ensemble_uncertainty(regressor, pred_x, fallback=1.0)
            outlier_probs = _binary_positive_proba(outlier_model, pred_x, default_positive=0.0)
            cluster_positive_rate: dict[str, float] = {}
            cluster_totals: dict[str, int] = {}
            for row, label in zip(usable_labeled_rows, y_good):
                cluster_id = str(row["cluster_id"])
                cluster_positive_rate[cluster_id] = cluster_positive_rate.get(cluster_id, 0.0) + float(label)
                cluster_totals[cluster_id] = cluster_totals.get(cluster_id, 0) + 1
            for cluster_id, total in cluster_totals.items():
                cluster_positive_rate[cluster_id] = cluster_positive_rate[cluster_id] / max(1, total)
            out: list[dict[str, Any]] = []
            for row, p_good, pred_affinity, unc, outlier_prob in zip(prepared_universe_rows, predicted_good, predicted_affinity, uncertainties, outlier_probs):
                item = dict(row)
                item["p_good"] = float(p_good)
                item["predicted_affinity_like"] = float(pred_affinity)
                item["predicted_adjusted_score"] = float(-pred_affinity)
                item["predicted_uncertainty"] = float(unc)
                item["outlier_risk"] = float(outlier_prob)
                item["cluster_quality"] = float(cluster_positive_rate.get(str(row["cluster_id"]), _mean(list(cluster_positive_rate.values())) if cluster_positive_rate else 0.5))
                item["regressor_rank_score"] = float(pred_affinity)
                item["regressor_confidence"] = 1.0 / (1.0 + max(0.0, float(unc)))
                item["regressor_activity_class"] = _activity_class(float(p_good), float(unc), float(item["regressor_confidence"]))
                item["regressor_prediction_direction"] = "higher_is_better"
                out.append(item)
            return out
        out: list[dict[str, Any]] = []
        for row in prepared_universe_rows:
            item = dict(row)
            neighbors: list[tuple[float, dict[str, Any]]] = []
            for ref in usable_labeled_rows:
                dist = _distance(item["augmented_feature_vector"], ref["augmented_feature_vector"])
                neighbors.append((dist, ref))
            neighbors.sort(key=lambda pair: pair[0])
            top_neighbors = neighbors[: min(16, len(neighbors))]
            weights = [(1.0 / (1.0 + dist)) * max(0.01, min(1.0, _float(ref.get("analog_group_weight"), 1.0))) for dist, ref in top_neighbors]
            total_weight = sum(weights) or 1.0
            predicted_affinity = sum(weight * ((_score_target_value(ref, self.config.fixed_score_regressor_target) or 0.0)) for weight, (_, ref) in zip(weights, top_neighbors)) / total_weight
            p_good = sum(weight * (1.0 if str(ref["ligand_id"]) in good_ids else 0.0) for weight, (_, ref) in zip(weights, top_neighbors)) / total_weight
            outlier_risk = sum(weight * (1.0 if str(ref.get("component_warning", "")).strip() else 0.0) for weight, (_, ref) in zip(weights, top_neighbors)) / total_weight
            uncertainty = _stdev([(_score_target_value(ref, self.config.fixed_score_regressor_target) or 0.0) for _, ref in top_neighbors], predicted_affinity)
            item["p_good"] = p_good
            item["predicted_affinity_like"] = predicted_affinity
            item["predicted_adjusted_score"] = -predicted_affinity
            item["predicted_uncertainty"] = uncertainty
            item["outlier_risk"] = outlier_risk
            item["cluster_quality"] = p_good
            item["regressor_rank_score"] = predicted_affinity
            item["regressor_confidence"] = 1.0 / (1.0 + max(0.0, uncertainty))
            item["regressor_activity_class"] = _activity_class(float(p_good), float(uncertainty), float(item["regressor_confidence"]))
            item["regressor_prediction_direction"] = "higher_is_better"
            out.append(item)
        return out

    def _triage_survivors(
        self,
        universe_rows: list[dict[str, Any]],
        labeled_rows: list[dict[str, Any]],
    ) -> tuple[list[dict[str, Any]], dict[str, Any]]:
        predictions = self._build_knn_predictions(labeled_rows, universe_rows, top_fraction=self.config.classifier_top_percentile)
        classifier_metrics = self._classifier_metrics(labeled_rows, self.config.classifier_top_percentile)
        regressor_metrics = self._regressor_audit_metrics(labeled_rows, self.config.classifier_top_percentile)
        effective_uncertainty_weight, uncertainty_used_for_acquisition, uncertainty_disabled_reason = _effective_uncertainty_weight(
            self.config.uncertainty_weight,
            regressor_metrics.get("uncertainty_vs_error_spearman"),
        )
        regressor_allowed = (
            str(getattr(self.config, "regressor_contribution_mode", "linear") or "linear").lower() != "none"
            and not bool(regressor_metrics.get("REGRESSOR_NOT_PROVEN_USEFUL"))
        )
        effective_regressor_weight = float(self.config.regressor_weight) if regressor_allowed else 0.0
        self.current_effective_uncertainty_weight = effective_uncertainty_weight
        self.current_uncertainty_used_for_acquisition = uncertainty_used_for_acquisition
        self.current_uncertainty_disabled_reason = uncertainty_disabled_reason
        self.current_regressor_used_for_ranking = regressor_allowed
        self.current_regressor_disabled_reason = "" if regressor_allowed else str(regressor_metrics.get("regressor_disabled_reason", "regressor_disabled"))
        self.current_effective_regressor_weight = effective_regressor_weight
        self.current_classifier_gate_warning = ""
        cluster_good_counts: dict[str, float] = {}
        for row in predictions:
            cluster_good_counts[str(row["cluster_id"])] = cluster_good_counts.get(str(row["cluster_id"]), 0.0) + float(row["p_good"])
        policy = str(getattr(self.config, "adaptive_policy", "hybrid_rank") or "hybrid_rank").lower()
        regressor_mode = str(getattr(self.config, "regressor_contribution_mode", "linear") or "linear").lower()
        scored_rows: list[dict[str, Any]] = []
        v3_strategies = {"reference_free_active_learning_v3_diverse_ranker", "reference_free_active_learning_v3_lean"}
        if self.config.strategy in {"reference_free_active_learning_v2", *v3_strategies}:
            score_order = sorted(predictions, key=lambda row: (_float(row.get("predicted_adjusted_score"), float("inf")), str(row["ligand_id"])))
            pgood_order = sorted(predictions, key=lambda row: (-_float(row.get("p_good"), 0.0), str(row["ligand_id"])))
            uncertainty_order = sorted(predictions, key=lambda row: (-_float(row.get("predicted_uncertainty"), 0.0), str(row["ligand_id"])))
            cluster_order = sorted(predictions, key=lambda row: (-_float(row.get("cluster_quality"), 0.0), str(row["ligand_id"])))
            diversity_order = sorted(predictions, key=lambda row: (_float(cluster_good_counts.get(str(row["cluster_id"]), 0.0), 0.0), str(row["ligand_id"])))
            score_rank = {str(row["ligand_id"]): idx for idx, row in enumerate(score_order, start=1)}
            pgood_rank = {str(row["ligand_id"]): idx for idx, row in enumerate(pgood_order, start=1)}
            uncertainty_rank = {str(row["ligand_id"]): idx for idx, row in enumerate(uncertainty_order, start=1)}
            cluster_rank = {str(row["ligand_id"]): idx for idx, row in enumerate(cluster_order, start=1)}
            diversity_rank = {str(row["ligand_id"]): idx for idx, row in enumerate(diversity_order, start=1)}
        else:
            score_rank = {}
            pgood_rank = {}
            uncertainty_rank = {}
            cluster_rank = {}
            diversity_rank = {}
        for row in predictions:
            cluster_id = str(row["cluster_id"])
            diversity_bonus = 1.0 / max(1.0, cluster_good_counts.get(cluster_id, 1.0))
            ligand_id = str(row["ligand_id"])
            interaction_component = -0.35 * float(row.get("interaction_quality", row.get("biological_interaction_proxy_score", 0.0)))
            if self.config.strategy in {"reference_free_active_learning_v2", *v3_strategies}:
                classifier_component = -float(row.get("p_good", 0.0))
                score_component = float(row.get("predicted_adjusted_score", float("inf")))
                uncertainty_component = -effective_uncertainty_weight * float(row.get("predicted_uncertainty", 0.0))
                diversity_component = -self.config.diversity_weight * diversity_bonus
                cluster_component = -self.config.cluster_quality_weight * float(row.get("cluster_quality", 0.0))
                outlier_component = self.config.outlier_risk_weight * float(row.get("outlier_risk", 0.0))
                use_regressor = regressor_allowed
                if self.config.strategy in v3_strategies:
                    classifier_rank_weight = 0.35 if self.config.strategy == "reference_free_active_learning_v3_diverse_ranker" else 0.25
                    gate_bonus = -classifier_rank_weight * self.config.classifier_weight * float(row.get("p_good", 0.0))
                    novelty_component = -(max(0.4, self.config.exploration_fraction) * diversity_bonus)
                    cluster_quota_component = -(0.5 * float(row.get("cluster_quality", 0.0)))
                    triage_score = (
                        gate_bonus
                        + diversity_component
                        + cluster_quota_component
                        + cluster_component
                        + novelty_component
                        + outlier_component
                    )
                    if use_regressor:
                        triage_score += max(0.0, min(0.15, effective_regressor_weight)) * score_component
                elif policy == "classifier_only":
                    triage_score = self.config.classifier_weight * classifier_component
                    if regressor_mode in {"linear", "gate"}:
                        triage_score += effective_regressor_weight * score_component
                elif policy == "classifier_uncertainty":
                    triage_score = self.config.classifier_weight * classifier_component + uncertainty_component
                    if regressor_mode in {"linear", "gate"}:
                        triage_score += effective_regressor_weight * score_component
                elif policy == "classifier_uncertainty_diversity":
                    triage_score = self.config.classifier_weight * classifier_component + uncertainty_component + diversity_component
                    if regressor_mode in {"linear", "gate"}:
                        triage_score += effective_regressor_weight * score_component
                elif policy == "ucb_like":
                    triage_score = (
                        (effective_regressor_weight * score_component if use_regressor else 0.0)
                        - (8.0 * self.config.classifier_weight * float(row.get("p_good", 0.0)))
                        + uncertainty_component
                        + outlier_component
                    )
                elif policy == "cluster_bandit":
                    triage_score = (
                        -3.0 * float(row.get("cluster_quality", 0.0))
                        - (2.5 * self.config.classifier_weight * float(row.get("p_good", 0.0)))
                        + ((0.5 * effective_regressor_weight * score_component) if use_regressor else 0.0)
                        + diversity_component
                        + outlier_component
                    )
                elif policy == "classifier_plus_regressor_plus_cluster_quality":
                    triage_score = (self.config.classifier_weight * classifier_component) + (effective_regressor_weight * score_component if use_regressor else 0.0) + cluster_component + outlier_component
                else:
                    triage_score = (
                        (float(score_rank.get(ligand_id, len(predictions))) if use_regressor else 0.0)
                        + (0.8 * self.config.classifier_weight * float(pgood_rank.get(ligand_id, len(predictions))))
                        - effective_uncertainty_weight * float(len(predictions) - uncertainty_rank.get(ligand_id, len(predictions)))
                        - self.config.diversity_weight * float(len(predictions) - diversity_rank.get(ligand_id, len(predictions)))
                        - self.config.cluster_quality_weight * float(len(predictions) - cluster_rank.get(ligand_id, len(predictions)))
                        + self.config.outlier_risk_weight * float(row.get("outlier_risk", 0.0)) * len(predictions)
                    )
            else:
                classifier_component = -12.0 * float(row.get("p_good", 0.0))
                score_component = float(row["predicted_adjusted_score"])
                uncertainty_component = -effective_uncertainty_weight * float(row["predicted_uncertainty"])
                diversity_component = -self.config.diversity_weight * diversity_bonus
                cluster_component = -0.5 * float(row.get("cluster_quality", 0.0))
                outlier_component = self.config.outlier_risk_weight * float(row["outlier_risk"])
                triage_score = (
                    score_component
                    + classifier_component
                    + uncertainty_component
                    + diversity_component
                    + outlier_component
                )
            triage_score += interaction_component
            row["diversity_bonus"] = diversity_bonus
            row["triage_score"] = triage_score
            row["keep_probability"] = row["p_good"]
            row["adaptive_policy"] = policy
            row["acquisition_mode"] = (
                "diverse_ranker_v1"
                if self.config.strategy == "reference_free_active_learning_v3_diverse_ranker"
                else "lean_production_v1"
                if self.config.strategy == "reference_free_active_learning_v3_lean"
                else policy
            )
            row["acquisition_classifier_component"] = classifier_component
            row["acquisition_score_component"] = score_component
            row["acquisition_uncertainty_component"] = uncertainty_component
            row["acquisition_diversity_component"] = diversity_component
            row["acquisition_cluster_component"] = cluster_component
            row["acquisition_outlier_component"] = outlier_component
            row["acquisition_interaction_component"] = interaction_component
            row["effective_regressor_weight"] = effective_regressor_weight
            row["effective_uncertainty_weight"] = effective_uncertainty_weight
            scored_rows.append(row)
            state = self.state_by_id.get(ligand_id)
            model_row = self.model_by_id.get(ligand_id)
            if state is not None:
                state["p_good"] = float(row.get("p_good", 0.0))
                state["cluster_quality"] = float(row.get("cluster_quality", 0.0))
                state["triage_score"] = float(triage_score)
                state["predicted_filtered_score"] = float(row.get("predicted_adjusted_score", 0.0))
                state["predicted_affinity_like"] = float(row.get("predicted_affinity_like", 0.0))
                state["predicted_uncertainty"] = float(row.get("predicted_uncertainty", 0.0))
                state["outlier_risk"] = float(row.get("outlier_risk", 0.0))
                state["diversity_bonus"] = float(diversity_bonus)
                state["acquisition_classifier_component"] = float(classifier_component)
                state["acquisition_score_component"] = float(score_component)
                state["acquisition_uncertainty_component"] = float(uncertainty_component)
                state["acquisition_diversity_component"] = float(diversity_component)
                state["acquisition_cluster_component"] = float(cluster_component)
                state["acquisition_outlier_component"] = float(outlier_component)
                state["acquisition_interaction_component"] = float(interaction_component)
                state["interaction_quality"] = float(row.get("interaction_quality", 0.0))
            if model_row is not None:
                model_row["p_good"] = float(row.get("p_good", 0.0))
                model_row["cluster_quality"] = float(row.get("cluster_quality", 0.0))
                model_row["triage_score"] = float(triage_score)
                model_row["predicted_filtered_score"] = float(row.get("predicted_adjusted_score", 0.0))
                model_row["predicted_affinity_like"] = float(row.get("predicted_affinity_like", 0.0))
                model_row["predicted_uncertainty"] = float(row.get("predicted_uncertainty", 0.0))
                model_row["outlier_risk"] = float(row.get("outlier_risk", 0.0))
                model_row["diversity_bonus"] = float(diversity_bonus)
                model_row["acquisition_classifier_component"] = float(classifier_component)
                model_row["acquisition_score_component"] = float(score_component)
                model_row["acquisition_uncertainty_component"] = float(uncertainty_component)
                model_row["acquisition_diversity_component"] = float(diversity_component)
                model_row["acquisition_cluster_component"] = float(cluster_component)
                model_row["acquisition_outlier_component"] = float(outlier_component)
                model_row["acquisition_interaction_component"] = float(interaction_component)
                model_row["interaction_quality"] = float(row.get("interaction_quality", 0.0))
        scored_rows.sort(key=lambda row: (float(row["triage_score"]), str(row["cluster_id"]), str(row["ligand_id"])))
        labeled_good_ids = {
            str(row["ligand_id"])
            for row in _sort_by_score(labeled_rows, "final_score", "ranking_score", "SCORE")[: max(1, int(math.ceil(len(labeled_rows) * self.config.classifier_top_percentile)))]
        }
        controller_rows: list[dict[str, Any]] = []
        threshold_rows: list[dict[str, Any]] = []
        requested_fraction = self.config.triage_retain_fraction
        requested = _requested_survivor_count(
            len(scored_rows),
            requested_fraction,
            self.config.triage_min_survivors,
            self.config.triage_max_survivors,
        )
        step_fraction = max(0.01, requested_fraction * 0.5)
        final_selected: list[dict[str, Any]] = []
        final_selected_ids: set[str] = set()
        final_recall_estimate = 0.0 if labeled_good_ids else 1.0
        iterations = 0
        selected_threshold = classifier_metrics.get("selected_threshold")
        gate_retained_count = 0

        def _select_for_requested(requested_count: int) -> tuple[list[dict[str, Any]], set[str]]:
            nonlocal gate_retained_count
            cluster_selected: dict[str, int] = {}
            selected: list[dict[str, Any]] = []
            selected_ids: set[str] = set()
            hard_cap = requested_count
            if self.config.triage_max_survivors > 0:
                hard_cap = min(hard_cap, self.config.triage_max_survivors)
            hard_cap = max(1, hard_cap)
            candidate_rows = scored_rows
            if self.config.triage_model == "classifier" and selected_threshold is not None:
                classifier_rows = [row for row in scored_rows if float(row.get("keep_probability", 0.0)) >= float(selected_threshold)]
                if classifier_rows:
                    candidate_rows = classifier_rows
            if self.config.strategy in v3_strategies:
                gate_fraction = max(0.10, min(float(getattr(self.config, "classifier_gate_fraction", 0.15)), 0.20))
                max_gate_fraction = max(gate_fraction, min(0.30, float(getattr(self.config, "classifier_max_gate_fraction", 0.20))))
                requested_gate_pool = max(hard_cap, int(math.ceil(len(scored_rows) * gate_fraction)))
                max_gate_pool = max(hard_cap, int(math.ceil(len(scored_rows) * max_gate_fraction)))
                if len(candidate_rows) > max_gate_pool:
                    candidate_rows = sorted(
                        candidate_rows,
                        key=lambda row: (-float(row.get("keep_probability", 0.0)), float(row.get("triage_score", float("inf")))),
                    )[:max_gate_pool]
                    self.current_classifier_gate_warning = "classifier_gate_capped_to_max_gate_fraction"
                min_candidate_pool = max(
                    hard_cap,
                    min(len(candidate_rows), max(self.config.min_final_ligands, requested_gate_pool)),
                )
                candidate_rows = sorted(
                    candidate_rows,
                    key=lambda row: (-float(row.get("keep_probability", 0.0)), float(row.get("triage_score", float("inf")))),
                )[:min_candidate_pool]
                gate_retained_count = len(candidate_rows)
                if self.config.strategy == "reference_free_active_learning_v3_lean":
                    exploit_fraction = 0.60
                    explore_fraction = 0.40
                else:
                    exploit_fraction = max(0.6, 1.0 - self.config.exploration_fraction)
                    explore_fraction = self.config.exploration_fraction
                exploit_target = min(hard_cap, max(1, int(math.ceil(hard_cap * exploit_fraction))))
                explore_target = max(0, hard_cap - exploit_target)
                self.exploration_split_rows.append(
                    {
                        "requested_count": requested_count,
                        "candidate_pool": len(candidate_rows),
                        "exploit_target": exploit_target,
                        "explore_target": explore_target,
                        "exploration_fraction": explore_fraction,
                        "strategy": self.config.strategy,
                    }
                )
                exploit_rows = sorted(candidate_rows, key=lambda row: (float(row.get("triage_score", float("inf"))), str(row.get("cluster_id", "")), str(row.get("ligand_id", ""))))
                explore_rows = sorted(
                    [row for row in candidate_rows if str(row.get("ligand_id", "")) not in {str(item.get("ligand_id", "")) for item in exploit_rows[:exploit_target]}],
                    key=lambda row: (
                        -float(row.get("diversity_bonus", 0.0)),
                        -float(row.get("cluster_quality", 0.0)),
                        float(row.get("triage_score", float("inf"))),
                    ),
                )
                selected = _select_diverse(exploit_rows, exploit_target, max(1, self.config.min_per_cluster), max(1, self.config.max_per_cluster))
                selected_ids = {str(row["ligand_id"]) for row in selected}
                for row in explore_rows:
                    if len(selected) >= hard_cap or explore_target <= 0:
                        break
                    ligand_id = str(row["ligand_id"])
                    cluster_id = str(row["cluster_id"])
                    if ligand_id in selected_ids:
                        continue
                    if cluster_selected.get(cluster_id, 0) >= self.config.max_per_cluster > 0:
                        self.cluster_quota_rows.append({"ligand_id": ligand_id, "cluster_id": cluster_id, "decision": "rejected_cluster_cap", "phase": "explore"})
                        continue
                    selected.append(row)
                    selected_ids.add(ligand_id)
                    explore_target -= 1
                    self.cluster_quota_rows.append({"ligand_id": ligand_id, "cluster_id": cluster_id, "decision": "selected_explore", "phase": "explore"})
                cluster_selected = {}
                for row in selected:
                    cluster_id = str(row["cluster_id"])
                    cluster_selected[cluster_id] = cluster_selected.get(cluster_id, 0) + 1
                for row in selected:
                    self.cluster_quota_rows.append(
                        {
                            "ligand_id": str(row["ligand_id"]),
                            "cluster_id": str(row["cluster_id"]),
                            "decision": "selected",
                            "phase": "exploit" if row in exploit_rows[:exploit_target] else "explore",
                        }
                    )
                selected = _sort_by_score(selected, "triage_score", "predicted_adjusted_score")[:hard_cap]
                selected_ids = {str(row["ligand_id"]) for row in selected}
                return selected, selected_ids
            for row in candidate_rows:
                cluster_id = str(row["cluster_id"])
                if cluster_selected.get(cluster_id, 0) >= self.config.cluster_max_survivors > 0:
                    continue
                selected.append(row)
                selected_ids.add(str(row["ligand_id"]))
                cluster_selected[cluster_id] = cluster_selected.get(cluster_id, 0) + 1
                if len(selected) >= hard_cap:
                    break
            if self.config.cluster_min_survivors > 0:
                for cluster_id in sorted({str(row["cluster_id"]) for row in scored_rows}):
                    if len(selected) >= hard_cap:
                        break
                    current = cluster_selected.get(cluster_id, 0)
                    if current >= self.config.cluster_min_survivors:
                        continue
                    for row in scored_rows:
                        if len(selected) >= hard_cap:
                            break
                        if str(row["cluster_id"]) != cluster_id or str(row["ligand_id"]) in selected_ids:
                            continue
                        selected.append(row)
                        selected_ids.add(str(row["ligand_id"]))
                        cluster_selected[cluster_id] = cluster_selected.get(cluster_id, 0) + 1
                        current += 1
                        if current >= self.config.cluster_min_survivors:
                            break
            if self.config.rare_cluster_rescue > 0:
                rare_rows = [row for row in scored_rows if cluster_good_counts.get(str(row["cluster_id"]), 0.0) <= 1.0 and str(row["ligand_id"]) not in selected_ids]
                for row in rare_rows[: self.config.rare_cluster_rescue]:
                    if len(selected) >= hard_cap:
                        break
                    selected.append(row)
                    selected_ids.add(str(row["ligand_id"]))
            if self.config.uncertainty_rescue > 0:
                uncertain_rows = sorted(
                    [row for row in scored_rows if str(row["ligand_id"]) not in selected_ids],
                    key=lambda row: (-float(row["predicted_uncertainty"]), float(row["triage_score"])),
                )
                for row in uncertain_rows[: self.config.uncertainty_rescue]:
                    if len(selected) >= hard_cap:
                        break
                    selected.append(row)
                    selected_ids.add(str(row["ligand_id"]))
            if regressor_mode == "rescue":
                rescue_cap = max(1, int(math.ceil(requested_count * max(0.01, self.config.rescue_fraction))))
                regressor_rows = sorted(
                    [row for row in scored_rows if str(row["ligand_id"]) not in selected_ids],
                    key=lambda row: (
                        -float(row.get("predicted_affinity_like", 0.0)),
                        float(row.get("triage_score", float("inf"))),
                    ),
                )
                for row in regressor_rows[:rescue_cap]:
                    if len(selected) >= hard_cap:
                        break
                    selected.append(row)
                    selected_ids.add(str(row["ligand_id"]))
            selected = _sort_by_score(selected, "triage_score", "predicted_adjusted_score")[:hard_cap]
            selected_ids = {str(row["ligand_id"]) for row in selected}
            return selected, selected_ids

        def _cluster_only_ids() -> set[str]:
            cluster_rows, _ = self._cluster_only_selection(universe_rows)
            return {str(row["ligand_id"]) for row in cluster_rows}

        max_fraction = max(requested_fraction, self.config.max_retain_fraction_before_not_useful)
        while True:
            iterations += 1
            selected, selected_ids = _select_for_requested(requested)
            recall_estimate = len(labeled_good_ids & selected_ids) / max(1, len(labeled_good_ids)) if labeled_good_ids else 1.0
            threshold_rows.append(
                {
                    "retain_fraction": requested_fraction,
                    "requested_survivors": requested,
                    "estimated_recall": recall_estimate,
                    "estimated_cost_saved_fraction": max(0.0, 1.0 - (len(selected_ids) / max(1, len(scored_rows)))),
                }
            )
            controller_rows.append(
                {
                    "iteration": iterations,
                    "requested_retain_fraction": requested_fraction,
                    "requested_survivors": requested,
                    "achieved_recall_estimate": recall_estimate,
                    "survivor_count": len(selected_ids),
                }
            )
            final_selected, final_selected_ids, final_recall_estimate = selected, selected_ids, recall_estimate
            if self.config.triage_controller != "auto_recall":
                break
            if recall_estimate >= self.config.triage_target_recall:
                break
            if requested_fraction >= max_fraction:
                break
            requested_fraction = min(max_fraction, requested_fraction + step_fraction)
            requested = _requested_survivor_count(
                len(scored_rows),
                requested_fraction,
                self.config.triage_min_survivors,
                self.config.triage_max_survivors,
            )
            self.config.uncertainty_rescue = max(self.config.uncertainty_rescue, int(math.ceil(requested * 0.02)))
            self.config.rare_cluster_rescue = max(self.config.rare_cluster_rescue, int(math.ceil(requested * 0.01)))

        selected = final_selected
        selected_ids = final_selected_ids
        recall_estimate = final_recall_estimate
        final_requested_survivors = _requested_survivor_count(
            len(scored_rows),
            requested_fraction,
            self.config.triage_min_survivors,
            self.config.triage_max_survivors,
        )
        fallback_used = ""
        if classifier_metrics.get("insufficient_positive_examples_for_classifier") and self.config.classifier_fallback == "cluster_only":
            selected_ids = _cluster_only_ids()
            selected = [row for row in scored_rows if str(row["ligand_id"]) in selected_ids]
            recall_estimate = len(labeled_good_ids & selected_ids) / max(1, len(labeled_good_ids)) if labeled_good_ids else 1.0
            fallback_used = "cluster_only_insufficient_positives"
        if self.config.model_fallback_if_worse in {"cluster_only", "union_with_cluster_only"}:
            cluster_ids = _cluster_only_ids()
            cluster_recall = len(labeled_good_ids & cluster_ids) / max(1, len(labeled_good_ids)) if labeled_good_ids else 1.0
            if self.config.model_fallback_if_worse == "union_with_cluster_only" or cluster_recall > recall_estimate:
                fallback_used = self.config.model_fallback_if_worse
                if self.config.survivor_combination_policy == "cluster_only" and self.config.model_fallback_if_worse == "cluster_only":
                    selected_ids = cluster_ids
                elif self.config.survivor_combination_policy == "intersection":
                    selected_ids = selected_ids & cluster_ids
                else:
                    selected_ids = selected_ids | cluster_ids
                selected = [row for row in scored_rows if str(row["ligand_id"]) in selected_ids]
                recall_estimate = len(labeled_good_ids & selected_ids) / max(1, len(labeled_good_ids)) if labeled_good_ids else 1.0
        capped_survivor_limit = max(1, final_requested_survivors)
        if len(selected_ids) > capped_survivor_limit:
            selected = _sort_by_score(selected, "triage_score", "predicted_adjusted_score")[:capped_survivor_limit]
            selected_ids = {str(row["ligand_id"]) for row in selected}
            recall_estimate = len(labeled_good_ids & selected_ids) / max(1, len(labeled_good_ids)) if labeled_good_ids else 1.0
        survivors = _sort_by_score(selected, "triage_score", "predicted_adjusted_score")
        rejected = [row for row in scored_rows if str(row["ligand_id"]) not in selected_ids]
        for row in survivors:
            row["survived_triage"] = True
        for row in rejected:
            row["survived_triage"] = False
        write_rows_csv(scored_rows, self.out_dir / "tables" / "triage_scores.csv", fieldnames=TRIAGE_ROW_FIELDS)
        write_rows_csv(survivors, self.out_dir / "tables" / "triage_survivors.csv", fieldnames=TRIAGE_ROW_FIELDS)
        write_rows_csv(rejected, self.out_dir / "tables" / "triage_rejected.csv", fieldnames=TRIAGE_ROW_FIELDS)
        write_rows_csv(controller_rows, self.out_dir / "tables" / "triage_controller_iterations.csv")
        write_rows_csv(threshold_rows, self.out_dir / "tables" / "threshold_calibration_curve.csv")
        acquisition_component_rows = [
            {
                "ligand_id": str(row.get("ligand_id", "")),
                "cluster_id": str(row.get("cluster_id", "")),
                "classifier_probability": row.get("p_good", ""),
                "regressor_score": row.get("predicted_adjusted_score", ""),
                "predicted_affinity_like": row.get("predicted_affinity_like", ""),
                "diversity_bonus": row.get("diversity_bonus", ""),
                "cluster_quality": row.get("cluster_quality", ""),
                "uncertainty": row.get("predicted_uncertainty", ""),
                "outlier_risk": row.get("outlier_risk", ""),
                "interaction_quality": row.get("interaction_quality", ""),
                "effective_regressor_weight": effective_regressor_weight,
                "effective_uncertainty_weight": effective_uncertainty_weight,
                "regressor_used_for_ranking": self.current_regressor_used_for_ranking,
                "uncertainty_used_for_acquisition": uncertainty_used_for_acquisition,
                "final_acquisition_score": row.get("triage_score", ""),
                "adaptive_policy": row.get("adaptive_policy", ""),
                "acquisition_mode": row.get("acquisition_mode", ""),
            }
            for row in scored_rows
        ]
        write_rows_csv(
            self._diagnostics_rows(acquisition_component_rows, survivors=survivors),
            self.out_dir / "tables" / "acquisition_components.csv",
        )
        write_rows_csv(self._diagnostics_rows(self.cluster_quota_rows, survivors=survivors), self.out_dir / "tables" / "cluster_quota_decisions.csv")
        write_rows_csv(self._diagnostics_rows(self.exploration_split_rows, survivors=survivors), self.out_dir / "tables" / "exploration_exploitation_split.csv")
        reduction_fraction = 1.0 - (len(survivors) / max(1, len(scored_rows)))
        triage_metrics = {
            "adaptive_policy": policy,
            "initial_ligands": len(scored_rows),
            "triage_survivor_count": len(survivors),
            "triage_reduction_fraction": reduction_fraction,
            "triage_recall_estimate": recall_estimate,
            "triage_false_negative_estimate": max(0.0, 1.0 - recall_estimate),
            "triage_target_recall": self.config.triage_target_recall,
            "safe_to_reduce_95_percent": recall_estimate >= self.config.triage_target_recall and reduction_fraction >= 0.95,
            "safe_to_reduce_99_percent": recall_estimate >= self.config.triage_target_recall and reduction_fraction >= 0.99,
            "confidence_level": "high" if recall_estimate >= self.config.triage_target_recall and len(labeled_rows) >= self.config.minimum_training_ligands else "medium" if recall_estimate >= max(0.9, self.config.triage_target_recall - 0.05) else "low",
            "requested_retain_fraction": self.config.triage_retain_fraction,
            "final_requested_survivors": final_requested_survivors,
            "final_retain_fraction": len(survivors) / max(1, len(scored_rows)),
            "iterations": iterations,
            "model_useful_for_target_recall": recall_estimate >= self.config.triage_target_recall and reduction_fraction >= 0.5,
            "safe_to_reduce_any_meaningfully": recall_estimate >= self.config.triage_target_recall and reduction_fraction >= 0.25,
            "fallback_used": fallback_used,
        }
        triage_metrics.update(classifier_metrics)
        triage_metrics.update(
            {
                "surrogate_mae": regressor_metrics.get("surrogate_mae"),
                "surrogate_spearman": regressor_metrics.get("surrogate_spearman"),
                "surrogate_affinity_like_spearman": regressor_metrics.get("surrogate_affinity_like_spearman"),
                "cluster_validation_spearman": regressor_metrics.get("cluster_validation_spearman"),
                "raw_score_spearman": regressor_metrics.get("raw_score_spearman"),
                "component_sane_spearman": regressor_metrics.get("component_sane_spearman"),
                "inter_component_spearman": regressor_metrics.get("inter_component_spearman"),
                "regressor_prediction_direction": regressor_metrics.get("regressor_prediction_direction"),
                "fixed_score_regressor_name": regressor_metrics.get("fixed_score_regressor_name"),
                "fixed_score_regressor_target": regressor_metrics.get("fixed_score_regressor_target"),
                "regressor_model_type": regressor_metrics.get("regressor_model_type"),
                "REGRESSOR_NOT_PROVEN_USEFUL": regressor_metrics.get("REGRESSOR_NOT_PROVEN_USEFUL"),
                "regressor_used_for_ranking": self.current_regressor_used_for_ranking,
                "fallback_to_classifier_only": not self.current_regressor_used_for_ranking,
                "regressor_disabled_reason": self.current_regressor_disabled_reason,
                "effective_regressor_weight": effective_regressor_weight,
                "uncertainty_vs_error_spearman": regressor_metrics.get("uncertainty_vs_error_spearman"),
                "effective_uncertainty_weight": effective_uncertainty_weight,
                "uncertainty_used_for_acquisition": uncertainty_used_for_acquisition,
                "uncertainty_disabled_reason": uncertainty_disabled_reason,
                "acquisition_mode": (
                    "diverse_ranker_v1"
                    if self.config.strategy == "reference_free_active_learning_v3_diverse_ranker"
                    else "lean_production_v1"
                    if self.config.strategy == "reference_free_active_learning_v3_lean"
                    else policy
                ),
                "classifier_gate_retained": gate_retained_count if self.config.strategy in v3_strategies else None,
                "classifier_gate_fraction": (gate_retained_count / max(1, len(scored_rows))) if self.config.strategy in v3_strategies else None,
                "classifier_gate_warning": self.current_classifier_gate_warning if self.config.strategy in v3_strategies else None,
                "exploration_budget_fraction": (0.40 if self.config.strategy == "reference_free_active_learning_v3_lean" else self.config.exploration_fraction) if self.config.strategy in v3_strategies else None,
                "exploitation_budget_fraction": (0.60 if self.config.strategy == "reference_free_active_learning_v3_lean" else (1.0 - self.config.exploration_fraction)) if self.config.strategy in v3_strategies else None,
                "cluster_coverage_fraction": (len({str(row.get('cluster_id','')) for row in survivors}) / max(1, len({str(row.get('cluster_id','')) for row in scored_rows}))) if self.config.strategy in v3_strategies else None,
                "max_cluster_occupancy": max(([sum(1 for row in survivors if str(row.get('cluster_id','')) == cluster_id) for cluster_id in {str(row.get('cluster_id','')) for row in survivors}] or [0])) if self.config.strategy in v3_strategies else None,
                "outlier_risk_penalty_applied": True,
                "interaction_weight_applied": 0.35,
                "acquisition_component_summary": {
                    "classifier_weight": self.config.classifier_weight,
                    "effective_regressor_weight": effective_regressor_weight,
                    "effective_uncertainty_weight": effective_uncertainty_weight,
                    "diversity_weight": self.config.diversity_weight,
                    "cluster_quality_weight": self.config.cluster_quality_weight,
                    "outlier_risk_weight": self.config.outlier_risk_weight,
                    "interaction_weight": 0.35,
                },
                "MODEL_GENERALIZATION_WEAK_ACROSS_CLUSTERS": regressor_metrics.get("MODEL_GENERALIZATION_WEAK_ACROSS_CLUSTERS")
                or classifier_metrics.get("MODEL_GENERALIZATION_WEAK_ACROSS_CLUSTERS"),
            }
        )
        triage_metrics["model_signal_too_weak"] = bool(
            classifier_metrics.get("classifier_recall") is not None
            and (
                _float(classifier_metrics.get("classifier_auc_pr"), 0.0) < 0.1
                or _float(classifier_metrics.get("classifier_precision"), 0.0) < 0.1
            )
        )
        if regressor_metrics.get("REGRESSOR_NOT_PROVEN_USEFUL"):
            triage_metrics.setdefault("warnings", []).append("REGRESSOR_NOT_PROVEN_USEFUL")
        if triage_metrics.get("MODEL_GENERALIZATION_WEAK_ACROSS_CLUSTERS"):
            triage_metrics.setdefault("warnings", []).append("MODEL_GENERALIZATION_WEAK_ACROSS_CLUSTERS")
        _write_json(self.out_dir / "metrics" / "triage_metrics.json", triage_metrics)
        _write_json(
            self.out_dir / "metrics" / "triage_controller_metrics.json",
            {
                "triage_controller": self.config.triage_controller,
                "requested_retain_fraction": self.config.triage_retain_fraction,
                "final_retain_fraction": triage_metrics["final_retain_fraction"],
                "target_recall": self.config.triage_target_recall,
                "achieved_recall_estimate": recall_estimate,
                "iterations": iterations,
                "safe_to_reduce_95_percent": triage_metrics["safe_to_reduce_95_percent"],
                "safe_to_reduce_99_percent": triage_metrics["safe_to_reduce_99_percent"],
                "reason": "model cannot safely reduce this dataset enough to be useful"
                if recall_estimate < self.config.triage_target_recall and triage_metrics["final_retain_fraction"] >= self.config.max_retain_fraction_before_not_useful
                else "",
            },
        )
        return survivors, triage_metrics

    def _fidelity_reliability_payload(self, ligand_ids: list[str]) -> dict[str, Any]:
        per_ligand: dict[str, dict[int, float]] = {}
        for row in self.trace_rows:
            ligand_id = str(row.get("ligand_id", ""))
            if ligand_ids and ligand_id not in set(ligand_ids):
                continue
            level = int(_float(row.get("selected_fidelity_runs"), 0.0) or 0)
            score = _float(row.get("SCORE"), None)
            if score is None:
                continue
            per_ligand.setdefault(ligand_id, {})[level] = score
        final_level = self.final_level
        final_pairs = {ligand_id: levels for ligand_id, levels in per_ligand.items() if final_level in levels}
        correlations: dict[str, float | None] = {}
        recovery: dict[str, float] = {}
        final_scores = {ligand_id: levels[final_level] for ligand_id, levels in final_pairs.items()}
        final_ranked = sorted(final_scores.items(), key=lambda item: item[1])
        final_top_10 = {ligand_id for ligand_id, _ in final_ranked[: max(1, int(math.ceil(len(final_ranked) * 0.1)))]}
        for level in self.config.fidelity_levels[:-1]:
            xs: list[float] = []
            ys: list[float] = []
            level_scores: dict[str, float] = {}
            for ligand_id, levels in final_pairs.items():
                if level not in levels:
                    continue
                xs.append(levels[level])
                ys.append(levels[final_level])
                level_scores[ligand_id] = levels[level]
            correlations[f"spearman_{level}_vs_{final_level}"] = _spearman(xs, ys)
            ranked = sorted(level_scores.items(), key=lambda item: item[1])
            level_top_10 = {ligand_id for ligand_id, _ in ranked[: max(1, int(math.ceil(len(ranked) * 0.1)))]}
            recovery[f"top10pct_recovery_{level}_vs_{final_level}"] = len(level_top_10 & final_top_10) / max(1, len(final_top_10))
        payload = {
            "final_level": final_level,
            "n_multilevel_ligands": len(final_pairs),
            "correlations": correlations,
            "rank_recovery": recovery,
            "low_fidelity_reliable": all((value or -1.0) >= 0.35 for key, value in correlations.items() if key.startswith("spearman_5") or key.startswith("spearman_10")),
        }
        _write_json(self.out_dir / "metrics" / "fidelity_reliability.json", payload)
        return payload

    def _latest_trace_rows(self, ligand_ids: list[str], min_level: int = 0, max_level_exclusive: int | None = None) -> list[dict[str, Any]]:
        wanted = set(str(ligand_id) for ligand_id in ligand_ids)
        latest: dict[str, dict[str, Any]] = {}
        for row in self.trace_rows:
            ligand_id = str(row.get("ligand_id", ""))
            if ligand_id not in wanted:
                continue
            level = int(_float(row.get("selected_fidelity_runs"), 0.0) or 0)
            if level < min_level:
                continue
            if max_level_exclusive is not None and level >= max_level_exclusive:
                continue
            latest[ligand_id] = dict(row)
        return [latest[ligand_id] for ligand_id in ligand_ids if ligand_id in latest]

    def _variant_parent_candidates(self) -> list[dict[str, Any]]:
        level_rows = [dict(state) for state in self.state_by_id.values() if int(_float(state.get("selected_fidelity_runs"), 0.0) or 0) > 0]
        if not level_rows:
            return []
        highest_level = max(int(_float(row.get("selected_fidelity_runs"), 0.0) or 0) for row in level_rows)
        candidates = [row for row in level_rows if int(_float(row.get("selected_fidelity_runs"), 0.0) or 0) == highest_level]
        return _sort_by_score(candidates, "final_score", "current_best_score", "SCORE")

    def _enumerate_final_survivor_variants(self, parent_rows: list[dict[str, Any]]) -> dict[str, Any]:
        variant_rows: list[dict[str, Any]] = []
        best_parent_rows: list[dict[str, Any]] = []
        total_variants = 0
        total_variant_runs = 0
        if not parent_rows:
            write_rows_csv([], self.out_dir / "tables" / "variant_scores_long.csv")
            write_rows_csv([], self.out_dir / "tables" / "best_variant_per_parent.csv")
            return {"variant_generation_backend": "none", "n_parent_ligands": 0, "n_variants_generated": 0, "expansion_factor": 0.0, "added_rDock_runs_due_to_variants": 0, "variant_advantage_warning": False}
        if not RDKit_AVAILABLE and not self.config.allow_no_rdkit_parent_only:
            raise RDockPipelineError("RDKit_REQUIRED_FOR_VARIANT_ENUMERATION")
        backend = "rdkit_variant_enumeration"
        if not RDKit_AVAILABLE and self.config.allow_no_rdkit_parent_only:
            backend = "parent_only_no_rdkit_allowed"
        for row in parent_rows:
            parent_id = str(row.get("ligand_id", ""))
            smiles = str(self.model_by_id.get(parent_id, {}).get("smiles", ""))
            warning = ""
            variant_smiles_list = [smiles] if smiles else [""]
            if RDKit_AVAILABLE and smiles:
                mol = _rdkit_mol(smiles)
                if mol is None:
                    warning = "rdkit_failed_to_parse_smiles"
                else:
                    variant_smiles_list = [Chem.MolToSmiles(mol, isomericSmiles=True)]
                    if self.config.enumerate_stereoisomers != "none" and EnumerateStereoisomers is not None and StereoEnumerationOptions is not None:
                        try:
                            opts = StereoEnumerationOptions(tryEmbedding=False, unique=True, maxIsomers=max(1, self.config.max_stereoisomers_per_parent))
                            stereo_mols = list(EnumerateStereoisomers(mol, options=opts))
                            for stereo_mol in stereo_mols[: max(0, self.config.max_stereoisomers_per_parent - 1)]:
                                variant_smiles_list.append(Chem.MolToSmiles(stereo_mol, isomericSmiles=True))
                        except Exception:
                            warning = "stereoisomer_enumeration_failed"
                    if self.config.enumerate_tautomers != "none":
                        if rdMolStandardize is None:
                            warning = ",".join(filter(None, [warning, "tautomer_module_unavailable"]))
                        else:
                            try:
                                tautomer_enum = rdMolStandardize.TautomerEnumerator()
                                taut = tautomer_enum.Canonicalize(mol)
                                taut_smiles = Chem.MolToSmiles(taut, isomericSmiles=True)
                                variant_smiles_list.append(taut_smiles)
                            except Exception:
                                warning = ",".join(filter(None, [warning, "tautomer_enumeration_failed"]))
            variant_smiles_list = list(dict.fromkeys([text for text in variant_smiles_list if text]))[: max(1, self.config.max_total_variants_per_parent)]
            n_variants = len(variant_smiles_list)
            score = _float(row.get("final_score", row.get("current_best_score", row.get("SCORE"))), None)
            base_runs = int(_float(row.get("selected_fidelity_runs"), 0.0) or 0)
            for idx, variant_smiles in enumerate(variant_smiles_list):
                variant_rows.append(
                    {
                        "parent_ligand_id": parent_id,
                        "variant_id": f"{parent_id}__v{idx+1:02d}",
                        "canonical_smiles": smiles,
                        "variant_smiles": variant_smiles,
                        "variant_type": "parent_identity" if idx == 0 and variant_smiles == smiles else "stereoisomer_or_standardized_variant",
                        "stereo_index": idx,
                        "tautomer_index": 0,
                        "protomer_index": 0,
                        "conformer_id": 0,
                        "total_variants_for_parent": n_variants,
                        "variant_generation_warnings": warning,
                        "variant_score": score if idx == 0 and score is not None else "",
                        "variant_cost_runs": 0,
                        "selected_fidelity_runs": base_runs,
                    }
                )
                total_variants += 1
            best_parent_rows.append(
                {
                    "parent_ligand_id": parent_id,
                    "best_variant_id": f"{parent_id}__v01",
                    "best_variant_score": score if score is not None else "",
                    "n_variants_generated": n_variants,
                    "n_variants_docked": 0,
                    "variant_score_spread": 0.0,
                    "variant_cost_runs": 0,
                    "parent_total_cost_runs": int(_float(row.get("n_rdock_runs_total_spent"), 0.0) or 0),
                }
            )
        write_rows_csv(variant_rows, self.out_dir / "tables" / "variant_scores_long.csv")
        write_rows_csv(best_parent_rows, self.out_dir / "tables" / "best_variant_per_parent.csv")
        parent_level_rows = []
        for row in parent_rows:
            parent_id = str(row.get("ligand_id", ""))
            best = next((item for item in best_parent_rows if str(item["parent_ligand_id"]) == parent_id), None)
            parent_level = dict(row)
            parent_level["parent_ligand_id"] = parent_id
            parent_level["best_variant_id"] = best.get("best_variant_id", "") if best else ""
            parent_level["best_variant_score"] = best.get("best_variant_score", "") if best else ""
            parent_level["n_variants_generated"] = best.get("n_variants_generated", 0) if best else 0
            parent_level["variant_cost_runs"] = best.get("variant_cost_runs", 0) if best else 0
            parent_level["parent_total_cost_runs"] = best.get("parent_total_cost_runs", 0) if best else 0
            parent_level_rows.append(parent_level)
        sorted_parent_level = _sort_by_score(parent_level_rows, "best_variant_score", "final_score", "current_best_score", "SCORE")
        write_rows_csv(sorted_parent_level, self.out_dir / "tables" / "final_hits_parent_level_raw.csv")
        write_rows_csv(sorted_parent_level, self.out_dir / "tables" / "final_hits_parent_level_downranked.csv")
        write_rows_csv(sorted_parent_level, self.out_dir / "tables" / "final_hits_parent_level_filtered.csv")
        variant_metrics = {
            "variant_generation_backend": backend,
            "n_parent_ligands": len(parent_rows),
            "n_variants_generated": total_variants,
            "n_variants_docked": 0,
            "variants_per_parent_distribution": [int(row["n_variants_generated"]) for row in best_parent_rows],
            "expansion_factor": total_variants / max(1, len(parent_rows)),
            "added_rDock_runs_due_to_variants": total_variant_runs,
            "variant_advantage_warning": False,
        }
        _write_json(self.out_dir / "metrics" / "variant_expansion_metrics.json", variant_metrics)
        return variant_metrics

    def _run_reference_free_triage_strategy(self, full_rows: list[dict[str, Any]], full_metrics: dict[str, Any]) -> dict[str, Any]:
        screenable_rows = self._prefilter_candidate_rows()
        self.candidate_rows = screenable_rows
        self.candidate_ids = [str(row["ligand_id"]) for row in self.candidate_rows]
        self.candidate_id_set = set(self.candidate_ids)
        self.state_by_id = {ligand_id: state for ligand_id, state in self.state_by_id.items() if ligand_id in self.candidate_id_set}
        survivors: list[dict[str, Any]] = []
        triage_metrics: dict[str, Any] = {}
        calibration_rows: list[dict[str, Any]] = []
        calibration_ids: list[str] = []
        calibration_observed: list[dict[str, Any]] = []
        validation_ids: list[str] = []
        fidelity_payload = {"final_level": self.final_level, "n_multilevel_ligands": 0, "correlations": {}, "rank_recovery": {}, "low_fidelity_reliable": False}
        if self.config.strategy == "cluster_only_triage":
            selected_rows, selection_metrics = self._cluster_only_selection(screenable_rows)
            write_rows_csv(selected_rows, self.out_dir / "tables" / "cluster_only_survivors.csv")
            rejected_rows = [row for row in screenable_rows if str(row["ligand_id"]) not in {str(item["ligand_id"]) for item in selected_rows}]
            write_rows_csv(rejected_rows, self.out_dir / "tables" / "cluster_only_rejected.csv")
            write_rows_csv(selected_rows + rejected_rows, self.out_dir / "tables" / "cluster_only_triage_scores.csv")
            if full_rows:
                selection_metrics.update(_evaluate_selection_against_reference(full_rows, {str(row["ligand_id"]) for row in selected_rows}, top_fraction=self.config.classifier_top_percentile))
            _write_json(self.out_dir / "metrics" / "cluster_only_triage_metrics.json", selection_metrics)
            survivors = selected_rows
            triage_metrics = {
                "initial_ligands": len(screenable_rows),
                "triage_survivor_count": len(selected_rows),
                "triage_reduction_fraction": 1.0 - (len(selected_rows) / max(1, len(screenable_rows))),
                "triage_recall_estimate": selection_metrics.get("top5pct_recall", 1.0 if not full_rows else None),
                "triage_false_negative_estimate": (1.0 - float(selection_metrics.get("top5pct_recall", 1.0))) if full_rows and selection_metrics.get("top5pct_recall") is not None else None,
                "triage_target_recall": self.config.triage_target_recall,
                "safe_to_reduce_95_percent": False,
                "safe_to_reduce_99_percent": False,
                "confidence_level": "medium" if not full_rows else "high",
                "requested_retain_fraction": self.config.triage_retain_fraction,
                "final_retain_fraction": len(selected_rows) / max(1, len(screenable_rows)),
                "iterations": 1,
                "model_useful_for_target_recall": False,
                "safe_to_reduce_any_meaningfully": selection_metrics.get("top5pct_recall", 0.0) is not None and float(selection_metrics.get("top5pct_recall", 0.0) or 0.0) >= self.config.triage_target_recall,
            }
            _write_json(self.out_dir / "metrics" / "triage_metrics.json", triage_metrics)
            _write_json(self.out_dir / "metrics" / "triage_controller_metrics.json", {"triage_controller": "none", "iterations": 1})
        elif self.config.strategy == "cheap_descriptor_filter_only":
            selected_rows, selection_metrics = self._descriptor_filter_selection(screenable_rows)
            rejected_rows = [row for row in screenable_rows if str(row["ligand_id"]) not in {str(item["ligand_id"]) for item in selected_rows}]
            write_rows_csv(selected_rows, self.out_dir / "tables" / "descriptor_filter_survivors.csv")
            write_rows_csv(rejected_rows, self.out_dir / "tables" / "descriptor_filter_rejected.csv")
            if full_rows:
                selection_metrics.update(_evaluate_selection_against_reference(full_rows, {str(row["ligand_id"]) for row in selected_rows}, top_fraction=self.config.classifier_top_percentile))
            _write_json(self.out_dir / "metrics" / "descriptor_filter_metrics.json", selection_metrics)
            survivors = selected_rows
            triage_metrics = {
                "initial_ligands": len(screenable_rows),
                "triage_survivor_count": len(selected_rows),
                "triage_reduction_fraction": 1.0 - (len(selected_rows) / max(1, len(screenable_rows))),
                "triage_recall_estimate": selection_metrics.get("top5pct_recall", 1.0 if not full_rows else None),
                "triage_false_negative_estimate": (1.0 - float(selection_metrics.get("top5pct_recall", 1.0))) if full_rows and selection_metrics.get("top5pct_recall") is not None else None,
                "triage_target_recall": self.config.triage_target_recall,
                "safe_to_reduce_95_percent": False,
                "safe_to_reduce_99_percent": False,
                "confidence_level": "medium" if not full_rows else "high",
                "requested_retain_fraction": self.config.triage_retain_fraction,
                "final_retain_fraction": len(selected_rows) / max(1, len(screenable_rows)),
                "iterations": 1,
                "model_useful_for_target_recall": False,
                "safe_to_reduce_any_meaningfully": selection_metrics.get("top5pct_recall", 0.0) is not None and float(selection_metrics.get("top5pct_recall", 0.0) or 0.0) >= self.config.triage_target_recall,
            }
            _write_json(self.out_dir / "metrics" / "triage_metrics.json", triage_metrics)
            _write_json(self.out_dir / "metrics" / "triage_controller_metrics.json", {"triage_controller": "none", "iterations": 1})
        else:
            calibration_rows = self._select_calibration_rows(screenable_rows)
        calibration_level = self.config.fidelity_levels[0]
        if calibration_rows:
            future_levels = self.config.fidelity_levels[1:]
            reserve_for_min_final = self.config.min_final_ligands * sum(future_levels)
            reserve_for_validation = max(0, self.config.fidelity_validation_size) * sum(future_levels)
            reserved_budget = min(
                max(0, self.config.cost_budget_runs - calibration_level),
                reserve_for_min_final + reserve_for_validation,
            )
            max_calibration_affordable = max(
                1,
                max(1, (self.config.cost_budget_runs - reserved_budget) // max(1, calibration_level)),
            )
            calibration_rows = calibration_rows[: min(len(calibration_rows), max_calibration_affordable)]
            calibration_ids = [str(row["ligand_id"]) for row in calibration_rows]
            if not calibration_ids:
                raise RDockPipelineError("reference_free_triage_bandit_v1 selected no calibration ligands")
            self._emit_progress("triage_calibration:start", {"calibration_size": len(calibration_ids)})
            calibration_observed = self._run_level(calibration_level, 0, calibration_ids)
            extra_validation_cost = sum(self.config.fidelity_levels[1:])
            remaining_after_calibration = max(
                0,
                self.config.cost_budget_runs - len(calibration_ids) * calibration_level,
            )
            if extra_validation_cost > 0:
                max_validation_affordable = remaining_after_calibration // extra_validation_cost
            else:
                max_validation_affordable = 0
            validation_count = min(
                len(calibration_ids),
                max(0, self.config.fidelity_validation_size),
                max_validation_affordable,
            )
            validation_ids = [str(row["ligand_id"]) for row in _sort_by_score(calibration_observed, "ranking_score", "SCORE")[:validation_count]]
            validation_observed = list(calibration_observed)
            if validation_ids:
                for idx, level in enumerate(self.config.fidelity_levels[1:], start=1):
                    validation_observed.extend(self._run_level(level, idx, validation_ids))
            labeled_lookup: dict[str, dict[str, Any]] = {}
            for row in calibration_observed:
                labeled_lookup[str(row["ligand_id"])] = dict(row)
            for row in validation_observed:
                ligand_id = str(row["ligand_id"])
                labeled_lookup.setdefault(ligand_id, {}).update(dict(row))
            labeled_rows = [dict(self.model_by_id[ligand_id], **row) for ligand_id, row in labeled_lookup.items()]
            write_rows_csv(labeled_rows, self.out_dir / "tables" / "calibration_scores.csv")
            fidelity_payload = self._fidelity_reliability_payload(validation_ids)
            if not fidelity_payload.get("low_fidelity_reliable", False):
                self.config.promotion_policy = "conservative"
                self.config.rescue_fraction = max(self.config.rescue_fraction, 0.1)
                self.config.uncertainty_rescue = max(self.config.uncertainty_rescue, 10)
            survivors, triage_metrics = self._triage_survivors(screenable_rows, labeled_rows)
            if full_rows:
                cluster_rows, _ = self._cluster_only_selection(screenable_rows)
                model_eval = _evaluate_selection_against_reference(full_rows, {str(row["ligand_id"]) for row in survivors}, top_fraction=self.config.classifier_top_percentile)
                cluster_eval = _evaluate_selection_against_reference(full_rows, {str(row["ligand_id"]) for row in cluster_rows}, top_fraction=self.config.classifier_top_percentile)
                model_beats_cluster_only = False
                model_recall = _float(model_eval.get("top5pct_recall"), 0.0) or 0.0
                cluster_recall = _float(cluster_eval.get("top5pct_recall"), 0.0) or 0.0
                model_reduction = _float(model_eval.get("reduction_fraction"), 0.0) or 0.0
                cluster_reduction = _float(cluster_eval.get("reduction_fraction"), 0.0) or 0.0
                if model_recall > cluster_recall:
                    model_beats_cluster_only = True
                elif abs(model_recall - cluster_recall) < 1e-9 and model_reduction > cluster_reduction:
                    model_beats_cluster_only = True
                triage_metrics["model_beats_cluster_only"] = model_beats_cluster_only
        if not survivors:
            raise RDockPipelineError(f"{self.config.strategy} produced no survivors for refinement")
        survivor_ids = [str(row["ligand_id"]) for row in survivors]
        level_counts = self._policy_level_counts(len(survivor_ids), self.config.fidelity_levels, self.config.cost_budget_runs)
        remaining_budget = max(0, self.config.cost_budget_runs - sum(int(_float(state.get("n_rdock_runs_total_spent"), 0.0)) for state in self.state_by_id.values()))
        per_level_summary: list[dict[str, Any]] = []
        if calibration_ids:
            per_level_summary.append(
                {
                    "fidelity_level": calibration_level,
                    "screened_ligands": len(calibration_ids),
                    "successful_ligands": sum(1 for row in calibration_observed if int(_float(row.get("selected_fidelity_runs"), calibration_level) or calibration_level) == calibration_level and str(row.get("rdock_success", "")).lower() in {"true", "1"}),
                    "failed_ligands": sum(1 for row in calibration_observed if int(_float(row.get("selected_fidelity_runs"), calibration_level) or calibration_level) == calibration_level and str(row.get("rdock_success", "")).lower() not in {"true", "1"}),
                    "outlier_count": sum(1 for row in calibration_observed if int(_float(row.get("selected_fidelity_runs"), calibration_level) or calibration_level) == calibration_level and str(row.get("component_warning", "")).strip()),
                }
            )
        self._emit_progress(
            "triage_refinement:start",
            {
                "survivors": len(survivor_ids),
                "remaining_budget_runs": remaining_budget,
                "level_counts": level_counts,
            },
        )
        first_level_target = level_counts[0] if level_counts else len(calibration_ids)
        already_first_level = {
            ligand_id
            for ligand_id in survivor_ids
            if int(_float(self.state_by_id.get(ligand_id, {}).get("selected_fidelity_runs"), 0.0) or 0) >= calibration_level
        }
        need_first_level = max(0, min(len(survivor_ids), first_level_target) - len(already_first_level))
        if need_first_level > 0 and remaining_budget >= calibration_level:
            triage_order = [str(row["ligand_id"]) for row in survivors if str(row["ligand_id"]) not in already_first_level]
            max_affordable_first = min(need_first_level, remaining_budget // max(1, calibration_level))
            new_first_level_ids = triage_order[:max_affordable_first]
            if new_first_level_ids:
                new_first_level_rows = self._run_level(calibration_level, len(self.config.fidelity_levels) + 1, new_first_level_ids)
                if not per_level_summary:
                    per_level_summary.append(
                        {
                            "fidelity_level": calibration_level,
                            "screened_ligands": 0,
                            "successful_ligands": 0,
                            "failed_ligands": 0,
                            "outlier_count": 0,
                        }
                    )
                per_level_summary[0]["screened_ligands"] = int(per_level_summary[0]["screened_ligands"]) + len(new_first_level_ids)
                per_level_summary[0]["successful_ligands"] = int(per_level_summary[0]["successful_ligands"]) + sum(
                    1 for row in new_first_level_rows if str(row.get("rdock_success", "")).lower() in {"true", "1"}
                )
                per_level_summary[0]["failed_ligands"] = int(per_level_summary[0]["failed_ligands"]) + sum(
                    1 for row in new_first_level_rows if str(row.get("rdock_success", "")).lower() not in {"true", "1"}
                )
                per_level_summary[0]["outlier_count"] = int(per_level_summary[0]["outlier_count"]) + sum(
                    1 for row in new_first_level_rows if str(row.get("component_warning", "")).strip()
                )
                remaining_budget = max(
                    0,
                    self.config.cost_budget_runs - sum(int(_float(state.get("n_rdock_runs_total_spent"), 0.0)) for state in self.state_by_id.values()),
                )
        for idx, level in enumerate(self.config.fidelity_levels[1:], start=1):
            if remaining_budget < level:
                break
            target_total = level_counts[idx] if idx < len(level_counts) else 0
            already_at_level = {
                ligand_id
                for ligand_id in survivor_ids
                if int(_float(self.state_by_id.get(ligand_id, {}).get("selected_fidelity_runs"), 0.0) or 0) >= level
            }
            need_level = max(0, target_total - len(already_at_level))
            if need_level <= 0:
                continue
            previous_level = self.config.fidelity_levels[idx - 1]
            promotion_candidates = self._latest_trace_rows(survivor_ids, min_level=previous_level, max_level_exclusive=level)
            if not promotion_candidates:
                continue
            candidate_ids = [str(row["ligand_id"]) for row in promotion_candidates]
            target_affordable = min(need_level, remaining_budget // max(1, level))
            if target_affordable <= 0:
                break
            promoted_ids = self._promote(promotion_candidates, previous_level, level, max(target_affordable, self.config.min_promotion_per_level))
            promoted_ids = [ligand_id for ligand_id in promoted_ids if ligand_id in candidate_ids][:target_affordable]
            if not promoted_ids:
                continue
            level_rows = self._run_level(level, 100 + idx, promoted_ids)
            successful_count = sum(1 for row in level_rows if str(row.get("rdock_success", "")).lower() in {"true", "1"})
            per_level_summary.append(
                {
                    "fidelity_level": level,
                    "screened_ligands": len(promoted_ids),
                    "successful_ligands": successful_count,
                    "failed_ligands": len(promoted_ids) - successful_count,
                    "outlier_count": sum(1 for row in level_rows if str(row.get("component_warning", "")).strip()),
                }
            )
            remaining_budget = max(
                0,
                self.config.cost_budget_runs - sum(int(_float(state.get("n_rdock_runs_total_spent"), 0.0)) for state in self.state_by_id.values()),
            )
        final_promoted = [
            ligand_id
            for ligand_id in survivor_ids
            if int(_float(self.state_by_id.get(ligand_id, {}).get("selected_fidelity_runs"), 0.0) or 0) >= self.final_level
            and bool(self.state_by_id.get(ligand_id, {}).get("rdock_success"))
        ]
        if len(final_promoted) < self.config.min_final_ligands and remaining_budget >= self.final_level:
            candidate_rows = self._latest_trace_rows(survivor_ids, min_level=self.config.fidelity_levels[0], max_level_exclusive=self.final_level)
            candidate_rows = [
                row for row in candidate_rows
                if str(row.get("rdock_success", "")).lower() in {"true", "1"}
                and int(_float(row.get("selected_fidelity_runs"), 0.0) or 0) < self.final_level
            ]
            fallback_target_affordable = min(
                max(0, self.config.min_final_ligands - len(final_promoted)),
                remaining_budget // max(1, self.final_level),
            )
            if fallback_target_affordable > 0 and candidate_rows:
                promotion_request = max(
                    fallback_target_affordable,
                    min(self.config.min_promotion_per_level, len(candidate_rows)),
                )
                promoted_ids = self._promote(
                    candidate_rows,
                    max(int(_float(row.get("selected_fidelity_runs"), 0.0) or 0) for row in candidate_rows),
                    self.final_level,
                    promotion_request,
                )
                if promoted_ids:
                    promoted_ids = promoted_ids[:fallback_target_affordable]
                    level_rows = self._run_level(self.final_level, 999, promoted_ids)
                    successful_count = sum(1 for row in level_rows if str(row.get("rdock_success", "")).lower() in {"true", "1"})
                    per_level_summary.append(
                        {
                            "fidelity_level": self.final_level,
                            "screened_ligands": len(promoted_ids),
                            "successful_ligands": successful_count,
                            "failed_ligands": len(promoted_ids) - successful_count,
                            "outlier_count": sum(1 for row in level_rows if str(row.get("component_warning", "")).strip()),
                            "promotion_source": "forced_min_final_ligands",
                        }
                    )
        return {
            "per_level_summary": per_level_summary,
            "triage_metrics": triage_metrics,
            "fidelity_reliability": fidelity_payload,
        }

    def run_multifidelity(self) -> dict[str, Any]:
        try:
            benchmark_started_at = time.time()
            self._prepare_output_layout()
            observed_rows: list[dict[str, Any]] = []
            per_level_summary: list[dict[str, Any]] = []
            full_rows, full_metrics = ([], {
                "reference_mode": self.config.reference_mode,
                "reference_completion_fraction": 0.0,
                "reference_ligand_count": 0,
                "full_docking_seconds": 0.0,
                "n_runs": self.final_level,
                "benchmark_status": "BENCHMARK PARTIAL / NOT COMPARABLE" if self.config.reference_mode == "none" else "BENCHMARK COMPLETE",
            })
            if not self.config.production_reference_free_mode:
                full_rows, full_metrics = self._run_full_docking()

            if self.reference_free_mode:
                triage_payload = self._run_reference_free_triage_strategy(full_rows, full_metrics)
                per_level_summary = list(triage_payload["per_level_summary"])
            else:
                level_counts = self._policy_level_counts(
                    library_size=len(self.candidate_ids),
                    levels=self.config.fidelity_levels,
                    budget_runs=self.config.cost_budget_runs,
                )
                selected_ids = self._initial_selection(level_counts[0] if level_counts else 0)
                self._emit_progress("multifidelity:start", {"level_counts": level_counts, "final_level": self.final_level})
                for idx, level in enumerate(self.config.fidelity_levels):
                    if not selected_ids:
                        break
                    level_rows = self._run_level(level, idx, selected_ids)
                    observed_rows.extend(level_rows)
                    outlier_count = sum(1 for row in level_rows if str(row.get("intra_outlier", "")).lower() in {"true", "1"})
                    successful_count = sum(1 for row in level_rows if str(row.get("rdock_success", "")).lower() in {"true", "1"})
                    per_level_summary.append(
                        {
                            "fidelity_level": level,
                            "screened_ligands": len(selected_ids),
                            "successful_ligands": successful_count,
                            "failed_ligands": len(selected_ids) - successful_count,
                            "outlier_count": outlier_count,
                        }
                    )
                    if idx + 1 < len(self.config.fidelity_levels):
                        selected_ids = self._promote(level_rows, level, self.config.fidelity_levels[idx + 1], level_counts[idx + 1])
                        if idx % max(1, self.config.checkpoint_every) == 0:
                            self._write_checkpoint(
                                f"level_{level:03d}",
                                {
                                    "level": level,
                                    "selected_ids": selected_ids,
                                    "summary": per_level_summary[-1],
                                },
                            )
                    else:
                        selected_ids = []

            write_rows_csv(self.trace_rows, self.out_dir / "tables" / "multifidelity_trace.csv")
            write_rows_csv(self.trace_rows, self.out_dir / "tables" / "adaptive_queue_trace.csv")
            write_rows_csv(self.pre_docking_prediction_rows, self.out_dir / "tables" / "regressor_predictions_pre_docking.csv")
            write_rows_csv(self.promotion_rows, self.out_dir / "tables" / "promotion_decisions.csv")
            write_rows_csv(self.failed_chunk_rows, self.out_dir / "tables" / "failed_chunks.csv")
            write_rows_csv(self.failed_ligand_rows, self.out_dir / "tables" / "failed_ligands.csv")

            final_rows = [dict(state) for state in self.state_by_id.values() if not self.config.final_fidelity_only_hits or bool(state["is_final_fidelity"])]
            final_rows = [row for row in final_rows if row.get("final_score", "") != "" or not self.config.final_fidelity_only_hits]
            final_rows.sort(key=lambda row: (_float(row.get("final_score", row.get("current_best_score")), float("inf")), str(row.get("ligand_id", ""))))
            write_rows_csv(final_rows, self.out_dir / "tables" / "final_hits.csv")
            final_raw_rows = _sort_by_score([dict(row) for row in final_rows], "final_score", "SCORE", "current_best_score")
            for idx, row in enumerate(final_raw_rows, start=1):
                row["raw_rank"] = idx
            final_downranked_rows = _sort_by_score([dict(row) for row in final_raw_rows], "ranking_score", "final_score", "SCORE")
            for idx, row in enumerate(final_downranked_rows, start=1):
                row["downranked_rank"] = idx
            final_filtered_rows = [
                dict(row)
                for row in final_downranked_rows
                if str(row.get("rdock_success", "")).lower() in {"true", "1"}
                and _float(row.get("ranking_score"), float("inf")) < float("inf")
                and str(row.get("failed_reason", "")).strip() == ""
            ]
            for idx, row in enumerate(final_filtered_rows, start=1):
                row["filtered_rank"] = idx
            write_rows_csv(final_raw_rows, self.out_dir / "tables" / "final_hits_raw.csv")
            write_rows_csv(final_downranked_rows, self.out_dir / "tables" / "final_hits_downranked.csv")
            write_rows_csv(final_filtered_rows, self.out_dir / "tables" / "final_hits_filtered.csv")
            outlier_flag_rows: list[dict[str, Any]] = []
            raw_rank_by_id = {str(row.get("ligand_id", "")): row.get("raw_rank", "") for row in final_raw_rows}
            downranked_rank_by_id = {str(row.get("ligand_id", "")): row.get("downranked_rank", "") for row in final_downranked_rows}
            filtered_rank_by_id = {str(row.get("ligand_id", "")): row.get("filtered_rank", "") for row in final_filtered_rows}
            for row in final_raw_rows:
                ligand_id = str(row.get("ligand_id", ""))
                outlier_flag_rows.append(
                    {
                        "ligand_id": ligand_id,
                        "SCORE": row.get("SCORE", row.get("final_score", "")),
                        "SCORE.INTER": row.get("SCORE.INTER", ""),
                        "SCORE.INTRA": row.get("SCORE.INTRA", ""),
                        "SCORE.RESTR": row.get("SCORE.RESTR", ""),
                        "intra_fraction": row.get("intra_fraction", ""),
                        "intra_dominance_flag": _bool_text("intra_dominance" in str(row.get("component_warning", ""))),
                        "component_warning": row.get("component_warning", ""),
                        "raw_rank": raw_rank_by_id.get(ligand_id, ""),
                        "downranked_rank": downranked_rank_by_id.get(ligand_id, ""),
                        "filtered_rank": filtered_rank_by_id.get(ligand_id, ""),
                    }
                )
            write_rows_csv(
                self._diagnostics_rows(outlier_flag_rows, survivors=final_rows, final_hits=final_filtered_rows),
                self.out_dir / "tables" / "outlier_component_flags.csv",
            )
            variant_metrics = {}
            if self.config.final_survivor_enumerate_variants and self.config.variant_stage in {"final_survivors", "posthoc_top_hits"}:
                variant_parent_rows = final_rows if final_rows else self._variant_parent_candidates()
                variant_metrics = self._enumerate_final_survivor_variants(variant_parent_rows)

            total_runs_spent = sum(int(_float(row.get("n_rdock_runs_total_spent"), 0.0)) for row in self.state_by_id.values())
            baseline_budget_runs = total_runs_spent if self.config.balanced_baselines else self.config.cost_budget_runs
            single_rows: list[dict[str, Any]] = []
            random_rows: list[dict[str, Any]] = []
            diverse_random_rows: list[dict[str, Any]] = []
            single_seconds = 0.0
            random_seconds = 0.0
            diverse_random_seconds = 0.0
            if not self.config.production_reference_free_mode:
                single_count = max(1, baseline_budget_runs // self.final_level)
                single_rows, single_seconds = self._run_single_fidelity_adaptive(single_count)
                random_rows, random_seconds = self._run_random_baseline(baseline_budget_runs, diverse=False)
                diverse_random_rows, diverse_random_seconds = self._run_random_baseline(baseline_budget_runs, diverse=True)

            full_rank_map = {str(row["ligand_id"]): int(row["full_rank"]) for row in full_rows}
            random_ranked = _append_rank_metrics(random_rows, full_rank_map, len(full_rows))
            single_ranked = _append_rank_metrics(single_rows, full_rank_map, len(full_rows))
            final_ranked = _append_rank_metrics(final_rows, full_rank_map, len(full_rows))
            diverse_random_ranked = _append_rank_metrics(diverse_random_rows, full_rank_map, len(full_rows))
            write_rows_csv(random_ranked, self.out_dir / "tables" / "random_baseline_scores.csv")
            write_rows_csv(single_ranked, self.out_dir / "tables" / "single_fidelity_adaptive_scores.csv")
            write_rows_csv(final_ranked, self.out_dir / "tables" / "multifidelity_final_hits_ranked.csv")
            write_rows_csv(diverse_random_ranked, self.out_dir / "tables" / "diverse_random_baseline_scores.csv")

            full_best = full_rows[0] if full_rows else None
            final_only_rows = [row for row in final_ranked if str(row.get("is_final_fidelity", "")).lower() in {"true", "1"}]
            mf_best = final_only_rows[0] if final_only_rows else None
            random_best = min(random_ranked, key=lambda row: _float(row.get("final_score", row.get("SCORE")), float("inf"))) if random_ranked else None
            single_best = min(single_ranked, key=lambda row: _float(row.get("final_score", row.get("SCORE")), float("inf"))) if single_ranked else None
            diverse_random_best = min(diverse_random_ranked, key=lambda row: _float(row.get("final_score", row.get("SCORE")), float("inf"))) if diverse_random_ranked else None
            random_total_runs = sum(int(_float(row.get("n_rdock_runs_total_spent"), self.final_level)) for row in random_ranked)
            single_total_runs = sum(int(_float(row.get("n_rdock_runs_total_spent"), self.final_level)) for row in single_ranked)
            metrics = {
                "strategy": self.config.strategy,
                "dataset_dir": str(self.dataset_dir),
                "target_id": str(self.manifest.get("pdb_id", self.out_dir.name)).lower(),
                "fidelity_levels": self.config.fidelity_levels,
                "cost_budget_runs": self.config.cost_budget_runs,
                "reference_mode": self.config.reference_mode,
                "evaluation_pool_mode": self.config.evaluation_pool_mode,
                "benchmark_status": self.benchmark_status,
                "best_final_SCORE_found_by_multifidelity": _float(mf_best.get("final_score")) if mf_best else None,
                "best_final_SCORE_found_by_random_at_same_cost": _float(random_best.get("final_score", random_best.get("SCORE"))) if random_best else None,
                "best_final_SCORE_found_by_diverse_random_at_same_cost": _float(diverse_random_best.get("final_score", diverse_random_best.get("SCORE"))) if diverse_random_best else None,
                "best_SCORE_in_full_docking": _float(full_best.get("SCORE")) if full_best else None,
                "best_final_SCORE_found_by_single_fidelity": _float(single_best.get("final_score", single_best.get("SCORE"))) if single_best else None,
                "multifidelity_percentile_vs_full": _float(mf_best.get("full_percentile")) if mf_best and self.config.reference_mode == "full" and self.reference_completion_fraction >= 0.99 else None,
                "random_percentile_vs_full": _float(random_best.get("full_percentile")) if random_best and self.config.reference_mode == "full" and self.reference_completion_fraction >= 0.99 else None,
                "single_fidelity_percentile_vs_full": _float(single_best.get("full_percentile")) if single_best and self.config.reference_mode == "full" and self.reference_completion_fraction >= 0.99 else None,
                "top1_overlap_vs_full": _top_overlap(full_rows, final_ranked, 1),
                "top5_overlap_vs_full": _top_overlap(full_rows, final_ranked, 5),
                "top10_overlap_vs_full": _top_overlap(full_rows, final_ranked, 10),
                "total_rdock_runs_spent": total_runs_spent,
                "multifidelity_total_runs_spent": total_runs_spent,
                "random_total_runs_spent": random_total_runs,
                "single_fidelity_total_runs_spent": single_total_runs,
                "cost_ratio_random_vs_multifidelity": (random_total_runs / total_runs_spent) if total_runs_spent else None,
                "cost_ratio_single_vs_multifidelity": (single_total_runs / total_runs_spent) if total_runs_spent else None,
                "reference_completion_fraction": self.reference_completion_fraction,
                "walltime_total_seconds": time.time() - benchmark_started_at,
                "docking_time_seconds": full_metrics["full_docking_seconds"] + self.docking_time_total + single_seconds + random_seconds + diverse_random_seconds,
                "training_time_seconds": self.training_time_total,
                "parsing_time_seconds": self.parsing_time_total,
                "sdf_split_merge_time_seconds": self.sdf_split_merge_time_total,
                "scheduler_time_seconds": self.scheduler_time_total,
                "io_time_seconds": self.io_time_total,
                "overhead_time_seconds": self.overhead_time_total,
                "number_of_ligands_screened_at_each_fidelity": per_level_summary,
                "number_promoted_between_levels": {
                    f"{current}->{next_level}": sum(1 for row in self.promotion_rows if row.get("promoted") and row.get("from_level") == current and row.get("to_level") == next_level)
                    for current, next_level in zip(self.config.fidelity_levels[:-1], self.config.fidelity_levels[1:])
                },
                "promoted_5_to_10": sum(1 for row in self.promotion_rows if row.get("promoted") and row.get("from_level") == 5 and row.get("to_level") == 10),
                "promoted_10_to_15": sum(1 for row in self.promotion_rows if row.get("promoted") and row.get("from_level") == 10 and row.get("to_level") == 15),
                "promoted_15_to_30": sum(1 for row in self.promotion_rows if row.get("promoted") and row.get("from_level") == 15 and row.get("to_level") == 30),
                "promoted_30_to_50": sum(1 for row in self.promotion_rows if row.get("promoted") and row.get("from_level") == 30 and row.get("to_level") == 50),
                "final_fidelity_ligands": len(final_only_rows),
                "success_failure_rate_per_fidelity": per_level_summary,
                "outlier_count_per_fidelity": {str(row["fidelity_level"]): row["outlier_count"] for row in per_level_summary},
                "adaptive_gain_over_random": (
                    _float(random_best.get("final_score", random_best.get("SCORE"))) - _float(mf_best.get("final_score", mf_best.get("SCORE")))
                    if mf_best and random_best
                    else None
                ),
                "final_hits_count": len(final_only_rows),
                "raw_final_hits_count": len(final_raw_rows),
                "downranked_final_hits_count": len(final_downranked_rows),
                "filtered_final_hits_count": len(final_filtered_rows),
                "full_docking_success_count": len(full_rows),
                "random_final_count": len(random_ranked),
                "single_fidelity_final_count": len(single_ranked),
                "production_reference_free_mode": self.config.production_reference_free_mode,
                "use_reference_features": self.config.use_reference_features,
                "variant_expansion_enabled": self.config.final_survivor_enumerate_variants,
                "variant_expansion_metrics": variant_metrics,
                "production_run_success": True,
                "missing_prepared_ligands": len(getattr(self, "missing_prepared_model_rows", [])),
                "failed_chunks": len(self.failed_chunk_rows),
                "failed_ligands": len(self.failed_ligand_rows),
                "records_without_score_dropped": self.rdock_records_without_score_dropped,
            }
            triage_metrics_path = self.out_dir / "metrics" / "triage_metrics.json"
            if triage_metrics_path.exists():
                metrics.update(_load_json(triage_metrics_path))
            fidelity_metrics_path = self.out_dir / "metrics" / "fidelity_reliability.json"
            if fidelity_metrics_path.exists():
                fidelity_payload = _load_json(fidelity_metrics_path)
                metrics["fidelity_reliability"] = fidelity_payload
            metrics["best_raw_hit_score"] = _float(final_raw_rows[0].get("final_score", final_raw_rows[0].get("SCORE")), None) if final_raw_rows else None
            metrics["best_filtered_hit_score"] = _float(final_filtered_rows[0].get("final_score", final_filtered_rows[0].get("SCORE")), None) if final_filtered_rows else None
            metrics["regressor_used_for_ranking"] = bool(self.current_regressor_used_for_ranking)
            metrics["regressor_fallback_reason"] = "" if metrics["regressor_used_for_ranking"] else (
                "regressor_validation_weak" if self.config.regressor_contribution_mode != "none" else "regressor_disabled"
            )
            metrics["effective_regressor_weight"] = self.current_effective_regressor_weight
            production_failure_reason = ""
            if self.config.production_reference_free_mode:
                if not self.promotion_rows:
                    metrics["production_run_success"] = False
                    metrics["benchmark_status"] = "PRODUCTION_FAILED_NO_PROMOTIONS"
                    production_failure_reason = "PRODUCTION_FAILED_NO_FINAL_HITS: no promotion decisions were recorded"
                    metrics["promotion_failure_reason"] = "no_promotion_decisions"
                elif len(final_only_rows) == 0 and self.config.cost_budget_runs > self.final_level:
                    metrics["production_run_success"] = False
                    metrics["benchmark_status"] = "PRODUCTION_FAILED_NO_FINAL_HITS"
                    production_failure_reason = "PRODUCTION_FAILED_NO_FINAL_HITS"
                    metrics["promotion_failure_reason"] = "no_final_hits"
            _write_json(self.out_dir / "metrics" / "adaptive_benchmark_metrics.json", metrics)
            _write_json(self.out_dir / "metrics" / "adaptive_benchmark_metrics_raw.json", metrics)
            _write_json(self.out_dir / "metrics" / "validation_metrics.json", metrics)
            _write_json(self.out_dir / "metrics" / "production_model_metrics.json", metrics)
            _write_json(
                self.out_dir / "metrics" / "rdock_failure_summary.json",
                {
                    "failure_policy": os.environ.get("RDOCK_CHUNK_FAILURE_POLICY", "mark_failed"),
                    "failed_chunks": len(self.failed_chunk_rows),
                    "failed_ligands": len(self.failed_ligand_rows),
                    "records_without_score_dropped": self.rdock_records_without_score_dropped,
                },
            )
            if self.config.production_reference_free_mode:
                triage_scores = self.out_dir / "tables" / "triage_scores.csv"
                triage_survivors = self.out_dir / "tables" / "triage_survivors.csv"
                triage_rejected = self.out_dir / "tables" / "triage_rejected.csv"
                threshold_curve = self.out_dir / "tables" / "threshold_calibration_curve.csv"
                if triage_scores.exists():
                    shutil.copy2(triage_scores, self.out_dir / "tables" / "production_triage_scores.csv")
                if triage_survivors.exists():
                    shutil.copy2(triage_survivors, self.out_dir / "tables" / "production_survivors.csv")
                if triage_rejected.exists():
                    shutil.copy2(triage_rejected, self.out_dir / "tables" / "production_rejected.csv")
                if threshold_curve.exists():
                    shutil.copy2(threshold_curve, self.out_dir / "tables" / "classifier_threshold_curve.csv")

            plots = []
            full_scores_csv = self.out_dir / "tables" / "full_docking_scores.csv"
            if full_scores_csv.exists():
                plots.extend(plot_score_outputs(full_scores_csv, self.out_dir / "plots", title_prefix="full docking"))
            plots.extend(
                plot_multifidelity_outputs(
                    self.out_dir / "tables" / "multifidelity_trace.csv",
                    self.out_dir / "tables" / "final_hits.csv",
                    self.out_dir / "tables" / "random_baseline_scores.csv",
                    self.out_dir / "tables" / "single_fidelity_adaptive_scores.csv",
                    full_scores_csv,
                    self.out_dir / "metrics" / "adaptive_benchmark_metrics.json",
                    self.out_dir / "plots",
                )
            )

            report_lines = [
                f"# {'screen-production-adaptive' if self.config.production_reference_free_mode else 'benchmark-adaptive'}: {self.manifest.get('pdb_id', self.out_dir.name)}",
                "",
                "## Executive Summary",
                f"- benchmark_status: `{metrics.get('benchmark_status')}`",
                f"- production_run_success: `{metrics.get('production_run_success')}`",
                f"- comparable: `{metrics.get('comparable', 'n/a')}`",
                f"- best_filtered_multifidelity: `{metrics.get('best_filtered_hit_score', metrics.get('best_final_SCORE_found_by_multifidelity'))}`",
                f"- best_random: `{metrics.get('best_random_filtered_hit_score', metrics.get('best_final_SCORE_found_by_random_at_same_cost'))}`",
                "",
                "## Input",
                f"- dataset_dir: `{self.dataset_dir}`",
                f"- strategy: `{self.config.strategy}`",
                f"- fidelity_levels: `{','.join(str(v) for v in self.config.fidelity_levels)}`",
                f"- cost_budget_runs: `{self.config.cost_budget_runs}`",
                f"- jobs: `{self.config.jobs}`",
                f"- cpu_fraction: `{self.config.cpu_fraction}`",
                "",
                "## Triage Safety",
            ]
            for key in [
                "initial_ligands",
                "triage_survivor_count",
                "triage_reduction_fraction",
                "triage_recall_estimate",
                "triage_false_negative_estimate",
                "safe_to_reduce_95_percent",
                "safe_to_reduce_99_percent",
                "confidence_level",
            ]:
                if key in metrics:
                    report_lines.append(f"- {key}: `{metrics.get(key)}`")
            report_lines.extend([
                "",
                "## Computational Value",
            ])
            for key in [
                "multifidelity_total_runs_spent",
                "random_total_runs_spent",
                "single_fidelity_total_runs_spent",
                "cost_ratio_random_vs_multifidelity",
                "cost_ratio_single_vs_multifidelity",
                "walltime_total_seconds",
                "docking_time_seconds",
                "training_time_seconds",
            ]:
                report_lines.append(f"- {key}: `{metrics.get(key)}`")
            report_lines.extend([
                "",
                "## Final Hit Quality",
            ])
            for key in [
                "best_final_SCORE_found_by_multifidelity",
                "best_final_SCORE_found_by_random_at_same_cost",
                "best_final_SCORE_found_by_single_fidelity",
                "best_SCORE_in_full_docking",
                "multifidelity_percentile_vs_full",
                "random_percentile_vs_full",
                "single_fidelity_percentile_vs_full",
                "adaptive_gain_over_random",
            ]:
                report_lines.append(f"- {key}: `{metrics.get(key)}`")
            report_lines.extend([
                "",
                "## Production Status",
                f"- promotion_decisions_count: `{len(self.promotion_rows)}`",
                f"- raw_final_hits_count: `{len(final_raw_rows)}`",
                f"- filtered_final_hits_count: `{len(final_filtered_rows)}`",
                f"- missing_prepared_ligands: `{metrics.get('missing_prepared_ligands')}`",
                f"- regressor_used_for_ranking: `{metrics.get('regressor_used_for_ranking')}`",
                f"- regressor_fallback_reason: `{metrics.get('regressor_fallback_reason')}`",
            ])
            report_lines.extend([
                "",
                "## Model operational status",
                f"- classifier_status: `{'ok' if not metrics.get('model_signal_too_weak') else 'weak_signal'}`",
                f"- regressor_status: `{'enabled' if metrics.get('regressor_used_for_ranking') else 'disabled'}`",
                f"- uncertainty_status: `{'enabled' if metrics.get('uncertainty_used_for_acquisition') else 'disabled'}`",
                f"- promotion_status: `{'ok' if len(self.promotion_rows) > 0 else 'failed'}`",
                f"- final_hit_status: `{'ok' if len(final_filtered_rows) > 0 else 'failed'}`",
                f"- comparability_status: `{metrics.get('benchmark_status')}`",
            ])
            report_lines.extend(["", "## Plots"])
            report_lines.extend([f"- `{path}`" for path in plots] or ["- No plots generated"])
            report_lines.extend(["", "## Top Final Hits"])
            for row in final_only_rows[:20]:
                report_lines.append(
                    f"- `{row.get('ligand_id')}` final_score `{row.get('final_score')}` "
                    f"cluster `{row.get('cluster_id')}` runs_spent `{row.get('n_rdock_runs_total_spent')}` "
                    f"warning `{row.get('component_warning', '')}`"
                )
            (self.out_dir / "report.md").write_text("\n".join(report_lines) + "\n", encoding="utf-8")

            manifest = {
                "engine": "benchmark-adaptive",
                "strategy": self.config.strategy,
                "dataset_dir": str(self.dataset_dir),
                "artifacts": {
                    "target_dir": str(self.out_dir / "target"),
                    "ligands_sdf": str(self.out_dir / "ligands" / "all_ligands.sdf"),
                    "full_docking_scores": str(self.out_dir / "tables" / "full_docking_scores.csv"),
                    "random_baseline_scores": str(self.out_dir / "tables" / "random_baseline_scores.csv"),
                    "single_fidelity_scores": str(self.out_dir / "tables" / "single_fidelity_adaptive_scores.csv"),
                    "multifidelity_trace": str(self.out_dir / "tables" / "multifidelity_trace.csv"),
                    "promotion_decisions": str(self.out_dir / "tables" / "promotion_decisions.csv"),
                    "final_hits": str(self.out_dir / "tables" / "final_hits.csv"),
                    "metrics_json": str(self.out_dir / "metrics" / "adaptive_benchmark_metrics.json"),
                    "report": str(self.out_dir / "report.md"),
                },
                "executables": {
                    "rbdock": probe_version(require_executable("rbdock")),
                    "rbcavity": probe_version(require_executable("rbcavity")),
                    "obabel": probe_version(require_executable("obabel")),
                },
                "metrics": metrics,
            }
            _write_json(self.out_dir / "manifest.json", manifest)
            _write_yaml_like(
                self.out_dir / "config.yaml",
                {
                    "dataset_dir": str(self.dataset_dir),
                    "strategy": self.config.strategy,
                    "fidelity_levels": self.config.fidelity_levels,
                    "cost_budget_runs": self.config.cost_budget_runs,
                    "promotion_fraction": self.config.promotion_fraction,
                    "min_per_cluster": self.config.min_per_cluster,
                    "max_per_cluster": self.config.max_per_cluster,
                    "outlier_intra_z_threshold": self.config.outlier_intra_z_threshold,
                    "score_component_filter": self.config.score_component_filter,
                    "final_fidelity_only_hits": self.config.final_fidelity_only_hits,
                    "jobs": self.config.jobs,
                    "cpu_fraction": self.config.cpu_fraction,
                    "resume": self.config.resume,
                },
            )
            audit_payload = audit_benchmark_run(self.out_dir)
            validation_payload = None
            try:
                from .validate_benchmark_model import validate_benchmark_model

                validation_payload = validate_benchmark_model(self.out_dir)
            except Exception:
                validation_payload = None
            self._write_checkpoint("completed", {"metrics": metrics})
            if production_failure_reason:
                self._write_checkpoint("failure", {"error": production_failure_reason, "metrics": metrics})
                raise RDockPipelineError(production_failure_reason)
            self._emit_progress("benchmark:done", {"run_dir": str(self.out_dir), "metrics_path": str(self.out_dir / "metrics" / "adaptive_benchmark_metrics.json")})
            return {"run_dir": str(self.out_dir), "metrics": metrics, "audit": audit_payload, "validation": validation_payload}
        except Exception as exc:
            failure = {
                "error": str(exc),
                "traceback": traceback.format_exc(),
                "dataset_dir": str(self.dataset_dir),
                "out_dir": str(self.out_dir),
            }
            self._write_checkpoint("failure", failure)
            self._emit_progress("benchmark:failed", {"error": str(exc), "failure_checkpoint": str(self.out_dir / "checkpoints" / "failure.json")})
            raise


def build_arg_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(description="Run adaptive rDock benchmark from a prepared dataset directory.")
    parser.add_argument("--dataset-dir", required=True)
    parser.add_argument("--strategy", default="cost_balanced_diverse_multifidelity_surrogate", choices=["multifidelity_adaptive_rdock", "single_fidelity_adaptive_rdock", "cost_balanced_diverse_multifidelity_surrogate", "reference_free_triage_bandit_v1", "reference_free_active_learning_v2", "reference_free_active_learning_v3_diverse_ranker", "reference_free_active_learning_v3_lean", "random_cost_balanced", "diverse_random_cost_balanced", "cluster_only_triage", "single_fidelity_cost_balanced", "cheap_descriptor_filter_only"])
    parser.add_argument("--fidelity-levels", default="5,10,15,30,50")
    parser.add_argument("--cost-budget-runs", type=int, required=True)
    parser.add_argument("--adaptive-budget-ligands", type=int)
    parser.add_argument("--promotion-fraction", type=float, default=0.5)
    parser.add_argument("--min-per-cluster", type=int, default=1)
    parser.add_argument("--max-per-cluster", type=int, default=50)
    parser.add_argument("--outlier-intra-z-threshold", type=float, default=3.0)
    parser.add_argument("--score-component-filter", default="warn")
    parser.add_argument("--final-fidelity-only-hits", default="true")
    parser.add_argument("--reference-mode", default="full", choices=["full", "sampled", "none"])
    parser.add_argument("--evaluation-pool-mode", default="same_pool", choices=["same_pool", "candidate_pool"])
    parser.add_argument("--reference-sample-size", type=int, default=5000)
    parser.add_argument("--reference-sample-seed", type=int, default=42)
    parser.add_argument("--balanced-baselines", default="true")
    parser.add_argument("--posthoc-score-selected-hits", default="false")
    parser.add_argument("--posthoc-final-runs", type=int, default=50)
    parser.add_argument("--force-resume-stale", action="store_true")
    parser.add_argument("--outlier-policy", default="downrank", choices=["flag", "downrank", "exclude"])
    parser.add_argument("--intra-z-threshold", type=float, default=4.0)
    parser.add_argument("--score-z-threshold", type=float, default=5.0)
    parser.add_argument("--max-intra-fraction", type=float, default=0.75)
    parser.add_argument("--max-intra-fraction-soft", type=float, default=0.75)
    parser.add_argument("--max-intra-fraction-hard", type=float, default=0.9)
    parser.add_argument("--exploration-fraction", type=float, default=0.35)
    parser.add_argument("--diversity-weight", type=float, default=0.75)
    parser.add_argument("--uncertainty-weight", type=float, default=0.35)
    parser.add_argument("--outlier-risk-weight", type=float, default=2.0)
    parser.add_argument("--cluster-min-coverage", type=int, default=1)
    parser.add_argument("--use-reference-features", default="false")
    parser.add_argument("--production-reference-free", default="false")
    parser.add_argument("--calibration-size", type=int, default=0)
    parser.add_argument("--calibration-fraction", type=float, default=0.2)
    parser.add_argument("--min-clusters-covered", type=int, default=8)
    parser.add_argument("--calibration-random-fraction", type=float, default=0.15)
    parser.add_argument("--calibration-diversity-weight", type=float, default=1.0)
    parser.add_argument("--fidelity-validation-size", type=int, default=50)
    parser.add_argument("--fidelity-validation-policy", default="cluster_stratified", choices=["diverse", "random", "cluster_stratified"])
    parser.add_argument("--promotion-policy", default="conservative", choices=["conservative", "adaptive", "aggressive", "exploit_heavy", "balanced", "explore_heavy", "quota_ladder"])
    parser.add_argument("--min-final-ligands", type=int, default=20)
    parser.add_argument("--min-promotion-per-level", type=int, default=8)
    parser.add_argument("--promotion-fraction-by-level", default="")
    parser.add_argument("--triage-retain-fraction", type=float, default=0.05)
    parser.add_argument("--triage-target-recall", type=float, default=0.98)
    parser.add_argument("--triage-min-survivors", type=int, default=50)
    parser.add_argument("--triage-max-survivors", type=int, default=0)
    parser.add_argument("--cluster-min-survivors", type=int, default=1)
    parser.add_argument("--cluster-max-survivors", type=int, default=0)
    parser.add_argument("--rescue-fraction", type=float, default=0.05)
    parser.add_argument("--rare-cluster-rescue", type=int, default=20)
    parser.add_argument("--uncertainty-rescue", type=int, default=20)
    parser.add_argument("--allow-low-confidence-triage", action="store_true")
    parser.add_argument("--top-good-fraction", type=float, default=0.1)
    parser.add_argument("--minimum-training-ligands", type=int, default=50)
    parser.add_argument("--triage-controller", default="auto_recall", choices=["auto_recall", "fixed"])
    parser.add_argument("--max-retain-fraction-before-not-useful", type=float, default=0.5)
    parser.add_argument("--classifier-top-percentile", type=float, default=0.1)
    parser.add_argument("--triage-model", default="classifier")
    parser.add_argument("--classifier-threshold-mode", default="recall_target")
    parser.add_argument("--classifier-min-positives", type=int, default=10)
    parser.add_argument("--classifier-holdout-fraction", type=float, default=0.25)
    parser.add_argument("--classifier-fallback", default="cluster_only")
    parser.add_argument("--model-fallback-if-worse", default="none")
    parser.add_argument("--survivor-combination-policy", default="model_only")
    parser.add_argument("--adaptive-policy", default="hybrid_rank", choices=["classifier_only", "classifier_uncertainty", "classifier_uncertainty_diversity", "classifier_plus_regressor_plus_cluster_quality", "hybrid_rank", "ucb_like", "cluster_bandit"])
    parser.add_argument("--regressor-contribution-mode", default="linear", choices=["none", "linear", "gate", "rescue"])
    parser.add_argument("--classifier-weight", type=float, default=1.0)
    parser.add_argument("--regressor-weight", type=float, default=0.35)
    parser.add_argument("--cluster-quality-weight", type=float, default=0.5)
    parser.add_argument("--fixed-score-regressor-name", default="fixed_score_regressor_v1")
    parser.add_argument("--fixed-score-regressor-target", default="component_sane_affinity_like")
    parser.add_argument("--regressor-model-type", default="extra_trees", choices=["extra_trees", "random_forest", "hist_gradient_boosting", "ridge"])
    parser.add_argument("--model-validation-split", default="cluster", choices=["random", "cluster"])
    parser.add_argument("--cluster-quota", type=int, default=0)
    parser.add_argument("--promotion-temperature", type=float, default=1.0)
    parser.add_argument("--diagnostics-level", default="standard", choices=["minimal", "standard", "full"])
    parser.add_argument("--classifier-gate-fraction", type=float, default=0.15)
    parser.add_argument("--classifier-max-gate-fraction", type=float, default=0.2)
    parser.add_argument("--final-survivor-enumerate-variants", default="false")
    parser.add_argument("--variant-stage", default="none")
    parser.add_argument("--enumerate-stereoisomers", default="none")
    parser.add_argument("--max-stereoisomers-per-parent", type=int, default=2)
    parser.add_argument("--enumerate-tautomers", default="none")
    parser.add_argument("--max-tautomers-per-parent", type=int, default=1)
    parser.add_argument("--enumerate-protonation", default="none")
    parser.add_argument("--ph", type=float, default=7.4)
    parser.add_argument("--max-protomer-states-per-parent", type=int, default=1)
    parser.add_argument("--max-conformers-per-variant", type=int, default=1)
    parser.add_argument("--max-total-variants-per-parent", type=int, default=1)
    parser.add_argument("--posthoc-top-parents", type=int, default=100)
    parser.add_argument("--posthoc-max-total-variants-per-parent", type=int, default=20)
    parser.add_argument("--variant-fairness-policy", default="cap")
    parser.add_argument("--allow-no-rdkit-parent-only", action="store_true")
    parser.add_argument("--chunk-size", type=int, default=50)
    parser.add_argument("--rdock-timeout-seconds", type=int, default=3600)
    parser.add_argument("--resume", action="store_true")
    parser.add_argument("--checkpoint-every", type=int, default=1)
    parser.add_argument("--jobs", default="auto")
    parser.add_argument("--cpu-fraction", type=float, default=0.85)
    parser.add_argument("--out", required=True)
    parser.add_argument("--dry-run", action="store_true")
    parser.add_argument("--plan-only", action="store_true")
    return parser


def run_from_args(args: argparse.Namespace) -> dict[str, Any]:
    levels = _parse_levels(args.fidelity_levels)
    dataset_summary = validate_dataset_dir(args.dataset_dir, check_rdock_tools=False)
    plan = {
        "dataset_dir": args.dataset_dir,
        "strategy": args.strategy,
        "fidelity_levels": levels,
        "cost_budget_runs": int(args.cost_budget_runs),
        "adaptive_budget_ligands": args.adaptive_budget_ligands,
        "promotion_fraction": float(args.promotion_fraction),
        "min_per_cluster": int(args.min_per_cluster),
        "max_per_cluster": int(args.max_per_cluster),
        "outlier_intra_z_threshold": float(args.outlier_intra_z_threshold),
        "score_component_filter": args.score_component_filter,
        "final_fidelity_only_hits": str(args.final_fidelity_only_hits).lower() in {"1", "true", "yes", "y"},
        "reference_mode": args.reference_mode,
        "evaluation_pool_mode": args.evaluation_pool_mode,
        "reference_sample_size": int(args.reference_sample_size),
        "reference_sample_seed": int(args.reference_sample_seed),
        "balanced_baselines": str(args.balanced_baselines).lower() in {"1", "true", "yes", "y"},
        "posthoc_score_selected_hits": str(args.posthoc_score_selected_hits).lower() in {"1", "true", "yes", "y"},
        "posthoc_final_runs": int(args.posthoc_final_runs),
        "force_resume_stale": bool(args.force_resume_stale),
        "outlier_policy": args.outlier_policy,
        "intra_z_threshold": float(args.intra_z_threshold),
        "score_z_threshold": float(args.score_z_threshold),
        "max_intra_fraction": float(args.max_intra_fraction),
        "max_intra_fraction_soft": float(args.max_intra_fraction_soft),
        "max_intra_fraction_hard": float(args.max_intra_fraction_hard),
        "exploration_fraction": float(args.exploration_fraction),
        "diversity_weight": float(args.diversity_weight),
        "uncertainty_weight": float(args.uncertainty_weight),
        "outlier_risk_weight": float(args.outlier_risk_weight),
        "cluster_min_coverage": int(args.cluster_min_coverage),
        "use_reference_features": _bool_arg(args.use_reference_features, False),
        "production_reference_free_mode": _bool_arg(args.production_reference_free, False),
        "calibration_size": int(args.calibration_size),
        "calibration_fraction": float(args.calibration_fraction),
        "min_clusters_covered": int(args.min_clusters_covered),
        "calibration_random_fraction": float(args.calibration_random_fraction),
        "calibration_diversity_weight": float(args.calibration_diversity_weight),
        "fidelity_validation_size": int(args.fidelity_validation_size),
        "fidelity_validation_policy": str(args.fidelity_validation_policy),
        "promotion_policy": str(args.promotion_policy),
        "min_final_ligands": int(args.min_final_ligands),
        "min_promotion_per_level": int(args.min_promotion_per_level),
        "promotion_fraction_by_level": str(args.promotion_fraction_by_level),
        "triage_retain_fraction": float(args.triage_retain_fraction),
        "triage_target_recall": float(args.triage_target_recall),
        "triage_min_survivors": int(args.triage_min_survivors),
        "triage_max_survivors": int(args.triage_max_survivors),
        "cluster_min_survivors": int(args.cluster_min_survivors),
        "cluster_max_survivors": int(args.cluster_max_survivors),
        "rescue_fraction": float(args.rescue_fraction),
        "rare_cluster_rescue": int(args.rare_cluster_rescue),
        "uncertainty_rescue": int(args.uncertainty_rescue),
        "allow_low_confidence_triage": bool(args.allow_low_confidence_triage),
        "top_good_fraction": float(args.top_good_fraction),
        "minimum_training_ligands": int(args.minimum_training_ligands),
        "triage_controller": str(getattr(args, "triage_controller", "auto_recall")),
        "max_retain_fraction_before_not_useful": float(getattr(args, "max_retain_fraction_before_not_useful", 0.5)),
        "classifier_top_percentile": float(getattr(args, "classifier_top_percentile", 0.1)),
        "triage_model": str(getattr(args, "triage_model", "classifier")),
        "classifier_threshold_mode": str(getattr(args, "classifier_threshold_mode", "recall_target")),
        "classifier_min_positives": int(getattr(args, "classifier_min_positives", 10)),
        "classifier_holdout_fraction": float(getattr(args, "classifier_holdout_fraction", 0.25)),
        "classifier_fallback": str(getattr(args, "classifier_fallback", "cluster_only")),
        "model_fallback_if_worse": str(getattr(args, "model_fallback_if_worse", "none")),
        "survivor_combination_policy": str(getattr(args, "survivor_combination_policy", "model_only")),
        "adaptive_policy": str(getattr(args, "adaptive_policy", "hybrid_rank")),
        "regressor_contribution_mode": str(getattr(args, "regressor_contribution_mode", "linear")),
        "classifier_weight": float(getattr(args, "classifier_weight", 1.0)),
        "regressor_weight": float(getattr(args, "regressor_weight", 0.35)),
        "cluster_quality_weight": float(getattr(args, "cluster_quality_weight", 0.5)),
        "fixed_score_regressor_name": str(getattr(args, "fixed_score_regressor_name", "fixed_score_regressor_v1")),
        "fixed_score_regressor_target": str(getattr(args, "fixed_score_regressor_target", "component_sane_affinity_like")),
        "regressor_model_type": str(getattr(args, "regressor_model_type", "extra_trees")),
        "model_validation_split": str(getattr(args, "model_validation_split", "cluster")),
        "cluster_quota": int(getattr(args, "cluster_quota", 0)),
        "promotion_temperature": float(getattr(args, "promotion_temperature", 1.0)),
        "final_survivor_enumerate_variants": _bool_arg(getattr(args, "final_survivor_enumerate_variants", "false"), False),
        "variant_stage": str(getattr(args, "variant_stage", "none")),
        "enumerate_stereoisomers": str(getattr(args, "enumerate_stereoisomers", "none")),
        "max_stereoisomers_per_parent": int(getattr(args, "max_stereoisomers_per_parent", 2)),
        "enumerate_tautomers": str(getattr(args, "enumerate_tautomers", "none")),
        "max_tautomers_per_parent": int(getattr(args, "max_tautomers_per_parent", 1)),
        "enumerate_protonation": str(getattr(args, "enumerate_protonation", "none")),
        "ph": float(getattr(args, "ph", 7.4)),
        "max_protomer_states_per_parent": int(getattr(args, "max_protomer_states_per_parent", 1)),
        "max_conformers_per_variant": int(getattr(args, "max_conformers_per_variant", 1)),
        "max_total_variants_per_parent": int(getattr(args, "max_total_variants_per_parent", 1)),
        "posthoc_top_parents": int(getattr(args, "posthoc_top_parents", 100)),
        "posthoc_max_total_variants_per_parent": int(getattr(args, "posthoc_max_total_variants_per_parent", 20)),
        "variant_fairness_policy": str(getattr(args, "variant_fairness_policy", "cap")),
        "allow_no_rdkit_parent_only": bool(getattr(args, "allow_no_rdkit_parent_only", False)),
        "diagnostics_level": str(getattr(args, "diagnostics_level", "standard")),
        "classifier_gate_fraction": float(getattr(args, "classifier_gate_fraction", 0.15)),
        "classifier_max_gate_fraction": float(getattr(args, "classifier_max_gate_fraction", 0.2)),
        "rdock_timeout_seconds": int(getattr(args, "rdock_timeout_seconds", 3600)),
        "jobs": args.jobs,
        "cpu_fraction": float(args.cpu_fraction),
        "dataset_summary": dataset_summary,
    }
    out_dir = Path(args.out)
    out_dir.mkdir(parents=True, exist_ok=True)
    if args.dry_run or args.plan_only:
        _write_json(out_dir / "benchmark_adaptive_plan.json", plan)
        return plan
    config = MultiFidelityConfig(
        strategy=args.strategy,
        fidelity_levels=levels,
        cost_budget_runs=int(args.cost_budget_runs),
        adaptive_budget_ligands=args.adaptive_budget_ligands,
        promotion_fraction=float(args.promotion_fraction),
        min_per_cluster=int(args.min_per_cluster),
        max_per_cluster=int(args.max_per_cluster),
        outlier_intra_z_threshold=float(args.outlier_intra_z_threshold),
        score_component_filter=str(args.score_component_filter),
        final_fidelity_only_hits=str(args.final_fidelity_only_hits).lower() in {"1", "true", "yes", "y"},
        checkpoint_every=int(args.checkpoint_every),
        jobs=args.jobs,
        cpu_fraction=float(args.cpu_fraction),
        resume=bool(args.resume),
        reference_mode=str(args.reference_mode),
        evaluation_pool_mode=str(args.evaluation_pool_mode),
        balanced_baselines=str(args.balanced_baselines).lower() in {"1", "true", "yes", "y"},
        reference_sample_size=int(args.reference_sample_size),
        reference_sample_seed=int(args.reference_sample_seed),
        posthoc_score_selected_hits=str(args.posthoc_score_selected_hits).lower() in {"1", "true", "yes", "y"},
        posthoc_final_runs=int(args.posthoc_final_runs),
        force_resume_stale=bool(args.force_resume_stale),
        outlier_policy=str(args.outlier_policy),
        intra_z_threshold=float(args.intra_z_threshold),
        score_z_threshold=float(args.score_z_threshold),
        max_intra_fraction=float(args.max_intra_fraction),
        max_intra_fraction_soft=float(args.max_intra_fraction_soft),
        max_intra_fraction_hard=float(args.max_intra_fraction_hard),
        exploration_fraction=float(args.exploration_fraction),
        diversity_weight=float(args.diversity_weight),
        uncertainty_weight=float(args.uncertainty_weight),
        outlier_risk_weight=float(args.outlier_risk_weight),
        cluster_min_coverage=int(args.cluster_min_coverage),
        use_reference_features=_bool_arg(args.use_reference_features, False),
        production_reference_free_mode=_bool_arg(args.production_reference_free, False),
        calibration_size=int(args.calibration_size),
        calibration_fraction=float(args.calibration_fraction),
        min_clusters_covered=int(args.min_clusters_covered),
        calibration_random_fraction=float(args.calibration_random_fraction),
        calibration_diversity_weight=float(args.calibration_diversity_weight),
        fidelity_validation_size=int(args.fidelity_validation_size),
        fidelity_validation_policy=str(args.fidelity_validation_policy),
        promotion_policy=str(args.promotion_policy),
        min_final_ligands=int(args.min_final_ligands),
        min_promotion_per_level=int(args.min_promotion_per_level),
        promotion_fraction_by_level=str(args.promotion_fraction_by_level),
        triage_retain_fraction=float(args.triage_retain_fraction),
        triage_target_recall=float(args.triage_target_recall),
        triage_min_survivors=int(args.triage_min_survivors),
        triage_max_survivors=int(args.triage_max_survivors),
        cluster_min_survivors=int(args.cluster_min_survivors),
        cluster_max_survivors=int(args.cluster_max_survivors),
        rescue_fraction=float(args.rescue_fraction),
        rare_cluster_rescue=int(args.rare_cluster_rescue),
        uncertainty_rescue=int(args.uncertainty_rescue),
        allow_low_confidence_triage=bool(args.allow_low_confidence_triage),
        top_good_fraction=float(args.top_good_fraction),
        minimum_training_ligands=int(args.minimum_training_ligands),
        triage_controller=str(getattr(args, "triage_controller", "auto_recall")),
        max_retain_fraction_before_not_useful=float(getattr(args, "max_retain_fraction_before_not_useful", 0.5)),
        classifier_top_percentile=float(getattr(args, "classifier_top_percentile", 0.1)),
        triage_model=str(getattr(args, "triage_model", "classifier")),
        classifier_threshold_mode=str(getattr(args, "classifier_threshold_mode", "recall_target")),
        classifier_min_positives=int(getattr(args, "classifier_min_positives", 10)),
        classifier_holdout_fraction=float(getattr(args, "classifier_holdout_fraction", 0.25)),
        classifier_fallback=str(getattr(args, "classifier_fallback", "cluster_only")),
        model_fallback_if_worse=str(getattr(args, "model_fallback_if_worse", "none")),
        survivor_combination_policy=str(getattr(args, "survivor_combination_policy", "model_only")),
        adaptive_policy=str(getattr(args, "adaptive_policy", "hybrid_rank")),
        regressor_contribution_mode=str(getattr(args, "regressor_contribution_mode", "linear")),
        classifier_weight=float(getattr(args, "classifier_weight", 1.0)),
        regressor_weight=float(getattr(args, "regressor_weight", 0.35)),
        cluster_quality_weight=float(getattr(args, "cluster_quality_weight", 0.5)),
        fixed_score_regressor_name=str(getattr(args, "fixed_score_regressor_name", "fixed_score_regressor_v1")),
        fixed_score_regressor_target=str(getattr(args, "fixed_score_regressor_target", "component_sane_affinity_like")),
        regressor_model_type=str(getattr(args, "regressor_model_type", "extra_trees")),
        model_validation_split=str(getattr(args, "model_validation_split", "cluster")),
        cluster_quota=int(getattr(args, "cluster_quota", 0)),
        promotion_temperature=float(getattr(args, "promotion_temperature", 1.0)),
        final_survivor_enumerate_variants=_bool_arg(getattr(args, "final_survivor_enumerate_variants", "false"), False),
        variant_stage=str(getattr(args, "variant_stage", "none")),
        enumerate_stereoisomers=str(getattr(args, "enumerate_stereoisomers", "none")),
        max_stereoisomers_per_parent=int(getattr(args, "max_stereoisomers_per_parent", 2)),
        enumerate_tautomers=str(getattr(args, "enumerate_tautomers", "none")),
        max_tautomers_per_parent=int(getattr(args, "max_tautomers_per_parent", 1)),
        enumerate_protonation=str(getattr(args, "enumerate_protonation", "none")),
        ph=float(getattr(args, "ph", 7.4)),
        max_protomer_states_per_parent=int(getattr(args, "max_protomer_states_per_parent", 1)),
        max_conformers_per_variant=int(getattr(args, "max_conformers_per_variant", 1)),
        max_total_variants_per_parent=int(getattr(args, "max_total_variants_per_parent", 1)),
        posthoc_top_parents=int(getattr(args, "posthoc_top_parents", 100)),
        posthoc_max_total_variants_per_parent=int(getattr(args, "posthoc_max_total_variants_per_parent", 20)),
        variant_fairness_policy=str(getattr(args, "variant_fairness_policy", "cap")),
        allow_no_rdkit_parent_only=bool(getattr(args, "allow_no_rdkit_parent_only", False)),
        diagnostics_level=str(getattr(args, "diagnostics_level", "standard")),
        classifier_gate_fraction=float(getattr(args, "classifier_gate_fraction", 0.15)),
        classifier_max_gate_fraction=float(getattr(args, "classifier_max_gate_fraction", 0.2)),
    )
    engine = RDockEngine(
        RDockRunConfig(
            n_runs=levels[-1],
            jobs=args.jobs,
            cpu_fraction=float(args.cpu_fraction),
            timeout_seconds=int(getattr(args, "rdock_timeout_seconds", 3600)),
            chunk_size=int(getattr(args, "chunk_size", 0) or 0) or None,
        )
    )
    runner = MultiFidelityAdaptiveRunner(args.dataset_dir, args.out, engine, config)
    return runner.run_multifidelity()


def run_reference_free_from_args(args: argparse.Namespace) -> dict[str, Any]:
    if not getattr(args, "dataset_dir", None):
        raise RDockPipelineError("screen-reference-free currently requires --dataset-dir")
    defaults = {
        "strategy": "reference_free_triage_bandit_v1",
        "reference_mode": "none",
        "evaluation_pool_mode": "same_pool",
        "balanced_baselines": "false",
        "production_reference_free": "true",
        "adaptive_budget_ligands": None,
        "promotion_fraction": 0.5,
        "min_per_cluster": 1,
        "max_per_cluster": 50,
        "outlier_intra_z_threshold": 3.0,
        "score_component_filter": "warn",
        "final_fidelity_only_hits": "true",
        "reference_sample_size": 0,
        "reference_sample_seed": 42,
        "posthoc_score_selected_hits": "false",
        "posthoc_final_runs": 50,
        "force_resume_stale": False,
        "outlier_policy": "downrank",
        "intra_z_threshold": 4.0,
        "score_z_threshold": 5.0,
        "max_intra_fraction": 0.75,
        "max_intra_fraction_soft": 0.75,
        "max_intra_fraction_hard": 0.9,
        "exploration_fraction": 0.35,
        "cluster_min_coverage": 1,
        "calibration_fraction": 0.2,
        "min_clusters_covered": 8,
        "calibration_random_fraction": 0.15,
        "calibration_diversity_weight": 1.0,
        "fidelity_validation_size": 200,
        "fidelity_validation_policy": "cluster_stratified",
        "promotion_fraction_by_level": "",
        "triage_min_survivors": 50,
        "triage_max_survivors": 0,
        "cluster_min_survivors": 1,
        "cluster_max_survivors": 0,
        "rescue_fraction": 0.05,
        "rare_cluster_rescue": 20,
        "uncertainty_rescue": 20,
        "allow_low_confidence_triage": False,
        "top_good_fraction": 0.1,
        "minimum_training_ligands": 50,
        "use_reference_features": "false",
        "triage_controller": "auto_recall",
        "max_retain_fraction_before_not_useful": 0.5,
        "classifier_top_percentile": 0.1,
        "triage_model": "classifier",
        "classifier_threshold_mode": "recall_target",
        "classifier_min_positives": 10,
        "classifier_holdout_fraction": 0.25,
        "classifier_fallback": "cluster_only",
        "model_fallback_if_worse": "none",
        "survivor_combination_policy": "model_only",
        "adaptive_policy": "hybrid_rank",
        "regressor_contribution_mode": "linear",
        "classifier_weight": 1.0,
        "regressor_weight": 0.35,
        "cluster_quality_weight": 0.5,
        "fixed_score_regressor_name": "fixed_score_regressor_v1",
        "fixed_score_regressor_target": "component_sane_affinity_like",
        "regressor_model_type": "extra_trees",
        "cluster_quota": 0,
        "promotion_temperature": 1.0,
        "final_survivor_enumerate_variants": "false",
        "variant_stage": "none",
        "enumerate_stereoisomers": "none",
        "max_stereoisomers_per_parent": 2,
        "enumerate_tautomers": "none",
        "max_tautomers_per_parent": 1,
        "enumerate_protonation": "none",
        "ph": 7.4,
        "max_protomer_states_per_parent": 1,
        "max_conformers_per_variant": 1,
        "max_total_variants_per_parent": 1,
        "posthoc_top_parents": 100,
        "posthoc_max_total_variants_per_parent": 20,
        "variant_fairness_policy": "cap",
        "allow_no_rdkit_parent_only": False,
        "checkpoint_every": 1,
    }
    for key, value in defaults.items():
        if not hasattr(args, key):
            setattr(args, key, value)
    return run_from_args(args)


def run_production_from_args(args: argparse.Namespace) -> dict[str, Any]:
    if not getattr(args, "dataset_dir", None):
        raise RDockPipelineError("screen-production-adaptive currently requires --dataset-dir")
    defaults = {
        "strategy": "reference_free_active_learning_v2",
        "reference_mode": "none",
        "evaluation_pool_mode": "same_pool",
        "balanced_baselines": "false",
        "production_reference_free": "true",
        "adaptive_budget_ligands": None,
        "promotion_fraction": 0.5,
        "min_per_cluster": 1,
        "max_per_cluster": 50,
        "outlier_intra_z_threshold": 3.0,
        "score_component_filter": "warn",
        "final_fidelity_only_hits": "true",
        "reference_sample_size": 0,
        "reference_sample_seed": 42,
        "posthoc_score_selected_hits": "false",
        "posthoc_final_runs": 50,
        "force_resume_stale": False,
        "outlier_policy": "downrank",
        "intra_z_threshold": 4.0,
        "score_z_threshold": 5.0,
        "max_intra_fraction": 0.75,
        "max_intra_fraction_soft": 0.75,
        "max_intra_fraction_hard": 0.9,
        "exploration_fraction": 0.35,
        "cluster_min_coverage": 1,
        "calibration_fraction": 0.2,
        "min_clusters_covered": 8,
        "calibration_random_fraction": 0.15,
        "calibration_diversity_weight": 1.0,
        "fidelity_validation_size": 200,
        "fidelity_validation_policy": "cluster_stratified",
        "promotion_fraction_by_level": "",
        "triage_min_survivors": 50,
        "triage_max_survivors": 0,
        "cluster_min_survivors": 1,
        "cluster_max_survivors": 0,
        "rescue_fraction": 0.05,
        "rare_cluster_rescue": 20,
        "uncertainty_rescue": 20,
        "allow_low_confidence_triage": False,
        "top_good_fraction": 0.1,
        "minimum_training_ligands": 50,
        "use_reference_features": "false",
        "triage_controller": "auto_recall",
        "max_retain_fraction_before_not_useful": 0.5,
        "classifier_top_percentile": 0.05,
        "triage_model": "classifier",
        "classifier_threshold_mode": "recall_target",
        "classifier_min_positives": 10,
        "classifier_holdout_fraction": 0.25,
        "classifier_fallback": "cluster_only",
        "model_fallback_if_worse": "none",
        "survivor_combination_policy": "model_only",
        "adaptive_policy": "cluster_bandit",
        "regressor_contribution_mode": "gate",
        "classifier_weight": 1.0,
        "regressor_weight": 0.2,
        "cluster_quality_weight": 0.5,
        "fixed_score_regressor_name": "fixed_score_regressor_v1",
        "fixed_score_regressor_target": "component_sane_affinity_like",
        "regressor_model_type": "extra_trees",
        "cluster_quota": 0,
        "promotion_temperature": 1.0,
        "calibration_size": 12000,
        "triage_target_recall": 0.95,
        "diversity_weight": 0.75,
        "uncertainty_weight": 0.35,
        "outlier_risk_weight": 2.0,
        "final_survivor_enumerate_variants": "false",
        "variant_stage": "none",
        "enumerate_stereoisomers": "none",
        "max_stereoisomers_per_parent": 2,
        "enumerate_tautomers": "none",
        "max_tautomers_per_parent": 1,
        "enumerate_protonation": "none",
        "ph": 7.4,
        "max_protomer_states_per_parent": 1,
        "max_conformers_per_variant": 1,
        "max_total_variants_per_parent": 1,
        "posthoc_top_parents": 100,
        "posthoc_max_total_variants_per_parent": 20,
        "variant_fairness_policy": "cap",
        "allow_no_rdkit_parent_only": False,
        "checkpoint_every": 1,
    }
    for key, value in defaults.items():
        if not hasattr(args, key):
            setattr(args, key, value)
    return run_from_args(args)


def clean_run_cache(run_dir: str | Path) -> dict[str, Any]:
    root = Path(run_dir)
    removed: list[str] = []
    for name in ("checkpoints", "full_docking", "single_fidelity_adaptive", "random_baseline", "diverse_random_baseline", "rdock", "tables", "metrics", "plots", "poses", "ligands", "target"):
        candidate = root / name
        if candidate.exists():
            shutil.rmtree(candidate)
            removed.append(str(candidate))
    return {"run_dir": str(root), "removed": removed}