Add files using upload-large-folder tool

.pytest_cache/v/cache/lastfailed

@@ -0,0 +1 @@
+{}

.pytest_cache/v/cache/nodeids

@@ -0,0 +1,30 @@
+[
+  "tests/test_backend_diagnostic_logic.py::TestBackendDiagnosticLogic::test_compute_rank_percentile",
+  "tests/test_backend_diagnostic_logic.py::TestBackendDiagnosticLogic::test_manual_agents_check_exists",
+  "tests/test_backend_diagnostic_logic.py::TestBackendDiagnosticLogic::test_recommend_toolchain_runtime_penalty",
+  "tests/test_backend_diagnostic_logic.py::TestBackendDiagnosticLogic::test_required_schema_constants_nonempty",
+  "tests/test_backend_diagnostic_logic.py::TestBackendDiagnosticLogic::test_select_suspicious",
+  "tests/test_backend_diagnostic_logic.py::TestBackendDiagnosticLogic::test_validate_required_columns",
+  "tests/test_pocket_modes.py::TestPocketModes::test_reference_complex_mode_uses_crystal_ligand",
+  "tests/test_pocket_modes.py::TestPocketModes::test_reference_mode_falls_back_to_receptor_centroid",
+  "tests/test_pocket_modes.py::TestPocketModes::test_relaxed_mode_increases_radius",
+  "tests/test_pocket_modes.py::TestPocketModes::test_user_fixed_override_precedence",
+  "tests/test_rdock_backend.py::TestRDockBackend::test_real_rdock_execution_and_provenance",
+  "tests/test_rdock_fixed_pocket.py::TestRDockFixedPocket::test_pocket_spec_stable_across_runs",
+  "tests/test_rdock_fixed_pocket.py::TestRDockFixedPocket::test_user_fixed_pocket_writes_sphere_mapper",
+  "tests/test_rdock_output_parsing_real.py::TestRDockOutputParsingReal::test_parser_reads_real_rdock_score_field",
+  "tests/test_rdock_real_execution.py::TestRDockRealExecution::test_rbcavity_and_rbdock_generate_real_outputs",
+  "tests/test_redocking_validation_guards.py::TestRedockingValidationGuards::test_attempt_bounds_guard",
+  "tests/test_redocking_validation_guards.py::TestRedockingValidationGuards::test_backend_guard",
+  "tests/test_reference_rank_resolution.py::TestReferenceRankResolution::test_falls_back_to_run_rank_when_oracle_missing",
+  "tests/test_reference_rank_resolution.py::TestReferenceRankResolution::test_missing_reference",
+  "tests/test_reference_rank_resolution.py::TestReferenceRankResolution::test_uses_oracle_when_available",
+  "tests/test_smina_backend_timeout.py::test_smina_timeout_returns_failed_row",
+  "tests/test_smina_score_parsing.py::TestSminaScoreParsing::test_parses_affinity_score_only_line",
+  "tests/test_smina_score_parsing.py::TestSminaScoreParsing::test_parses_minimized_affinity",
+  "tests/test_smina_score_parsing.py::TestSminaScoreParsing::test_parses_mode_table",
+  "tests/test_smina_score_parsing.py::TestSminaScoreParsing::test_parses_vina_result",
+  "tests/test_smina_score_parsing.py::TestSminaScoreParsing::test_returns_nan_when_no_score",
+  "tests/test_strict_backend_cleanup.py::TestStrictBackendCleanup::test_haddock_wrapper_removed",
+  "tests/test_strict_backend_cleanup.py::TestStrictBackendCleanup::test_thread_policy_formula_85pct"
+]

libs/adaptive/__init__.py

@@ -0,0 +1,19 @@
+"""Adaptive scheduling, clustering, and surrogate learning components."""
+
+from .clustering import cluster_ligands_butina
+from .epsilon_regret import EpsilonRegretConfig, EpsilonRegretController
+from .hyperclustering import hypercluster_representatives
+from .scheduler import AdaptiveScheduler
+from .surrogate_model import SurrogateModel
+from .thresholding import DynamicEarlyStopController, DynamicThresholdConfig
+
+__all__ = [
+    "AdaptiveScheduler",
+    "DynamicEarlyStopController",
+    "DynamicThresholdConfig",
+    "EpsilonRegretConfig",
+    "EpsilonRegretController",
+    "SurrogateModel",
+    "cluster_ligands_butina",
+    "hypercluster_representatives",
+]

libs/adaptive/clustering.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import Dict, Iterable, List, Sequence
+
+import numpy as np
+from rdkit import DataStructs
+from rdkit.Chem import rdchem
+from rdkit.ML.Cluster import Butina
+
+
+def _np_to_explicit_bitvect(fp: np.ndarray) -> DataStructs.ExplicitBitVect:
+    bitvect = DataStructs.ExplicitBitVect(fp.shape[0])
+    on_bits = np.where(fp > 0)[0]
+    for idx in on_bits:
+        bitvect.SetBit(int(idx))
+    return bitvect
+
+
+def cluster_ligands_butina(
+    ligand_ids: Sequence[str],
+    fingerprints: Sequence[np.ndarray],
+    cutoff: float = 0.35,
+) -> Dict[str, int]:
+    """Cluster ligands with Butina on Tanimoto distance over Morgan fingerprints."""
+    if not ligand_ids:
+        return {}
+    if len(ligand_ids) != len(fingerprints):
+        raise ValueError("ligand_ids and fingerprints must have same length")
+
+    fp_bv = [_np_to_explicit_bitvect(np.asarray(fp, dtype=int)) for fp in fingerprints]
+
+    dists: List[float] = []
+    for i in range(1, len(fp_bv)):
+        sims = DataStructs.BulkTanimotoSimilarity(fp_bv[i], fp_bv[:i])
+        dists.extend([1.0 - x for x in sims])
+
+    clusters = Butina.ClusterData(dists, len(fp_bv), cutoff, isDistData=True)
+
+    mapping: Dict[str, int] = {}
+    for c_idx, cluster in enumerate(clusters):
+        for member in cluster:
+            mapping[ligand_ids[member]] = c_idx
+
+    # Ensure all ligands map to a cluster, even edge cases.
+    for idx, ligand_id in enumerate(ligand_ids):
+        mapping.setdefault(ligand_id, max(mapping.values(), default=-1) + idx + 1)
+    return mapping

libs/adaptive/diversity.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import Iterable
+
+import numpy as np
+
+
+def _tanimoto(fp_a: np.ndarray, fp_b: np.ndarray) -> float:
+    inter = float(np.sum((fp_a > 0) & (fp_b > 0)))
+    union = float(np.sum((fp_a > 0) | (fp_b > 0)))
+    if union == 0:
+        return 0.0
+    return inter / union
+
+
+def selection_diversity(fingerprints: Iterable[np.ndarray]) -> float:
+    fps = list(fingerprints)
+    if len(fps) < 2:
+        return 0.0
+    distances = []
+    for i in range(len(fps)):
+        for j in range(i + 1, len(fps)):
+            distances.append(1.0 - _tanimoto(fps[i], fps[j]))
+    return float(np.mean(distances)) if distances else 0.0

libs/adaptive/epsilon_regret.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Iterable, List, Sequence
+
+import numpy as np
+
+
+@dataclass
+class EpsilonRegretConfig:
+    epsilon_quality: float = 0.10
+    acceptable_regret: float = 0.10
+    min_budget: int = 250
+    max_budget: int = 10000
+    min_model_weight: float = 0.25
+    patience_rounds: int = 6
+    min_improvement: float = 0.02
+    uncertainty_multiplier: float = 0.50
+    min_cluster_coverage: float = 0.20
+    min_hypercluster_coverage: float = 0.20
+
+
+class EpsilonRegretController:
+    """
+    Budget-aware stop controller with epsilon-regret semantics.
+
+    Online intent:
+    stop when estimated remaining gain is small relative to current best score,
+    after minimum exploration and coverage constraints are satisfied.
+    """
+
+    def __init__(self, config: EpsilonRegretConfig | None = None) -> None:
+        self.config = config or EpsilonRegretConfig()
+        self.best_score = np.inf
+        self.stagnant_rounds = 0
+        self.history: List[Dict[str, float | int | bool | str]] = []
+
+    @staticmethod
+    def _mean_or_nan(values: Sequence[float]) -> float:
+        arr = np.asarray(values, dtype=float)
+        if arr.size == 0:
+            return float("nan")
+        return float(np.nanmean(arr))
+
+    @staticmethod
+    def _estimate_remaining_gain(
+        best_score: float,
+        expected_remaining_scores: Iterable[float],
+        uncertainty_scores: Iterable[float],
+        uncertainty_multiplier: float,
+    ) -> float:
+        pred = np.asarray(list(expected_remaining_scores), dtype=float)
+        unc = np.asarray(list(uncertainty_scores), dtype=float)
+        if pred.size == 0:
+            return float("inf")
+        if unc.size != pred.size:
+            unc = np.full(pred.shape[0], np.nanmean(unc) if unc.size else 1.0, dtype=float)
+        optimistic = pred - float(max(0.0, uncertainty_multiplier)) * np.abs(unc)
+        optimistic_best = float(np.nanmin(optimistic)) if np.isfinite(optimistic).any() else float(np.nanmin(pred))
+        if not np.isfinite(optimistic_best) or not np.isfinite(best_score):
+            return float("inf")
+        # lower score is better
+        return float(max(0.0, best_score - optimistic_best))
+
+    def update(
+        self,
+        *,
+        round_idx: int,
+        n_evaluated: int,
+        best_score_now: float,
+        recent_scores: Sequence[float],
+        model_weight: float,
+        cluster_coverage: float,
+        hypercluster_coverage: float,
+        expected_remaining_scores: Iterable[float],
+        uncertainty_scores: Iterable[float],
+        time_importance: float,
+        budget_cap: int,
+    ) -> Dict[str, float | int | bool | str]:
+        cfg = self.config
+        ti = float(max(0.0, min(1.0, float(time_importance))))
+
+        if np.isfinite(self.best_score):
+            improvement = float(self.best_score - best_score_now)
+        else:
+            improvement = float("inf")
+
+        if improvement > float(cfg.min_improvement):
+            self.stagnant_rounds = 0
+        else:
+            self.stagnant_rounds += 1
+        self.best_score = min(float(self.best_score), float(best_score_now))
+
+        epsilon_rel = float(max(cfg.epsilon_quality, cfg.acceptable_regret))
+        # Higher time importance permits slightly larger acceptable residual gain.
+        epsilon_rel *= float(1.0 + 0.5 * ti)
+        epsilon_abs = float(epsilon_rel * max(1.0, abs(float(self.best_score))))
+
+        remaining_gain = self._estimate_remaining_gain(
+            best_score=float(self.best_score),
+            expected_remaining_scores=expected_remaining_scores,
+            uncertainty_scores=uncertainty_scores,
+            uncertainty_multiplier=float(cfg.uncertainty_multiplier),
+        )
+        regret_ratio_proxy = float(remaining_gain / max(1.0, abs(float(self.best_score))))
+
+        budget_floor = int(max(1, cfg.min_budget))
+        budget_ceiling = int(min(cfg.max_budget, budget_cap))
+        budget_ready = int(n_evaluated) >= budget_floor
+        model_ready = float(model_weight) >= float(cfg.min_model_weight)
+        coverage_ready = bool(
+            float(cluster_coverage) >= float(cfg.min_cluster_coverage)
+            and float(hypercluster_coverage) >= float(cfg.min_hypercluster_coverage)
+        )
+        stagnation_ready = int(self.stagnant_rounds) >= int(cfg.patience_rounds)
+
+        hit_budget_ceiling = int(n_evaluated) >= int(budget_ceiling)
+        epsilon_ready = bool(np.isfinite(remaining_gain) and remaining_gain <= epsilon_abs)
+        stop = bool(hit_budget_ceiling or (budget_ready and model_ready and coverage_ready and stagnation_ready and epsilon_ready))
+
+        if hit_budget_ceiling:
+            reason = "max_budget_reached"
+        elif not budget_ready:
+            reason = "below_min_budget"
+        elif not model_ready:
+            reason = "model_not_ready"
+        elif not coverage_ready:
+            reason = "coverage_not_ready"
+        elif not stagnation_ready:
+            reason = "insufficient_stagnation_evidence"
+        elif not epsilon_ready:
+            reason = "remaining_gain_above_epsilon"
+        else:
+            reason = "epsilon_regret_stop"
+
+        rec = {
+            "round_idx": int(round_idx),
+            "n_evaluated": int(n_evaluated),
+            "best_score": float(self.best_score),
+            "recent_mean_score": self._mean_or_nan(recent_scores),
+            "model_weight": float(model_weight),
+            "cluster_coverage": float(cluster_coverage),
+            "hypercluster_coverage": float(hypercluster_coverage),
+            "stagnant_rounds": int(self.stagnant_rounds),
+            "epsilon_abs": float(epsilon_abs),
+            "estimated_remaining_gain": float(remaining_gain),
+            "regret_ratio_proxy": float(regret_ratio_proxy),
+            "budget_floor": int(budget_floor),
+            "budget_ceiling": int(budget_ceiling),
+            "budget_ready": bool(budget_ready),
+            "model_ready": bool(model_ready),
+            "coverage_ready": bool(coverage_ready),
+            "stagnation_ready": bool(stagnation_ready),
+            "epsilon_ready": bool(epsilon_ready),
+            "stop": bool(stop),
+            "reason": reason,
+        }
+        self.history.append(rec)
+        return rec
+

libs/adaptive/features.py

@@ -0,0 +1,408 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Iterable, List, Tuple
+
+import numpy as np
+import pandas as pd
+from rdkit import Chem
+from rdkit.Chem import AllChem, Descriptors, Lipinski, MolSurf, rdMolDescriptors
+from rdkit.Chem.Scaffolds import MurckoScaffold
+from rdkit.DataStructs import TanimotoSimilarity
+
+try:
+    from rdkit.Chem import rdFreeSASA
+except Exception:  # pragma: no cover
+    rdFreeSASA = None  # type: ignore[assignment]
+
+
+@dataclass
+class FeatureValue:
+    value: float | None
+    available: bool
+    source: str
+    feature_type: str
+
+
+@dataclass
+class FeatureBundle:
+    object_id: str
+    features: Dict[str, FeatureValue]
+
+    def to_records(self, channel: str, round_idx: int | None = None) -> List[dict]:
+        rows: List[dict] = []
+        for name, fv in sorted(self.features.items()):
+            rows.append(
+                {
+                    "object_id": self.object_id,
+                    "round": round_idx,
+                    "channel": channel,
+                    "feature_name": name,
+                    "value": fv.value,
+                    "available": bool(fv.available),
+                    "source": fv.source,
+                    "feature_type": fv.feature_type,
+                }
+            )
+        return rows
+
+
+def _fv(value: float | None, available: bool, source: str, feature_type: str) -> FeatureValue:
+    return FeatureValue(value=value, available=available, source=source, feature_type=feature_type)
+
+
+def _safe_float(value: float | int | None) -> float | None:
+    if value is None:
+        return None
+    try:
+        v = float(value)
+    except Exception:
+        return None
+    if not np.isfinite(v):
+        return None
+    return v
+
+
+def _compute_ligand_sasa(mol: Chem.Mol) -> Tuple[float | None, bool]:
+    if rdFreeSASA is None:
+        return None, False
+    try:
+        if mol.GetNumConformers() == 0:
+            m = Chem.AddHs(Chem.Mol(mol))
+            status = AllChem.EmbedMolecule(m, AllChem.ETKDGv3())
+            if int(status) != 0:
+                return None, False
+        else:
+            m = Chem.Mol(mol)
+
+        if m.GetNumConformers() == 0:
+            return None, False
+
+        radii = rdFreeSASA.classifyAtoms(m)
+        sasa = rdFreeSASA.CalcSASA(m, radii)
+        return _safe_float(sasa), True
+    except Exception:
+        return None, False
+
+
+def build_ligand_feature_bundle(
+    ligand_id: str,
+    smiles: str,
+    fingerprint: np.ndarray,
+    reference_mol: Chem.Mol | None = None,
+    compute_partial_charges: bool = True,
+    compute_sasa: bool = True,
+) -> FeatureBundle:
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        raise ValueError(f"Invalid SMILES for ligand {ligand_id}: {smiles}")
+
+    m_h = Chem.AddHs(Chem.Mol(mol))
+    if compute_partial_charges:
+        try:
+            AllChem.ComputeGasteigerCharges(m_h)
+            partial_charges = []
+            for atom in m_h.GetAtoms():
+                prop = atom.GetProp("_GasteigerCharge") if atom.HasProp("_GasteigerCharge") else "nan"
+                try:
+                    q = float(prop)
+                except Exception:
+                    continue
+                if np.isfinite(q):
+                    partial_charges.append(q)
+            if partial_charges:
+                mean_abs_q = float(np.mean(np.abs(partial_charges)))
+                total_q = float(np.sum(partial_charges))
+                has_q = True
+            else:
+                mean_abs_q = None
+                total_q = None
+                has_q = False
+        except Exception:
+            mean_abs_q = None
+            total_q = None
+            has_q = False
+    else:
+        mean_abs_q = None
+        total_q = None
+        has_q = False
+
+    aromatic_rings = rdMolDescriptors.CalcNumAromaticRings(mol)
+    formal_charge = Chem.GetFormalCharge(mol)
+    heavy_atoms = mol.GetNumHeavyAtoms()
+    frac_csp3 = rdMolDescriptors.CalcFractionCSP3(mol)
+    bertz_ct = Descriptors.BertzCT(mol)
+    balaban_j = Descriptors.BalabanJ(mol)
+    topological_complexity = rdMolDescriptors.CalcChi0v(mol)
+
+    if compute_sasa:
+        ligand_sasa, has_sasa = _compute_ligand_sasa(m_h)
+    else:
+        ligand_sasa, has_sasa = None, False
+
+    reference_similarity = None
+    scaffold_match = None
+    chemical_distance = None
+    if reference_mol is not None:
+        fp_gen = AllChem.GetMorganGenerator(radius=2, fpSize=int(fingerprint.shape[0]))
+        ref_fp = fp_gen.GetFingerprint(reference_mol)
+        lig_fp = fp_gen.GetFingerprint(mol)
+        sim = TanimotoSimilarity(ref_fp, lig_fp)
+        reference_similarity = float(sim)
+        chemical_distance = float(1.0 - sim)
+
+        ref_scaffold = MurckoScaffold.MurckoScaffoldSmiles(mol=reference_mol)
+        lig_scaffold = MurckoScaffold.MurckoScaffoldSmiles(mol=mol)
+        scaffold_match = float(ref_scaffold == lig_scaffold)
+
+    features: Dict[str, FeatureValue] = {
+        "ligand_mw": _fv(_safe_float(Descriptors.MolWt(mol)), True, "rdkit", "exact"),
+        "ligand_logp": _fv(_safe_float(Descriptors.MolLogP(mol)), True, "rdkit", "exact"),
+        "ligand_tpsa": _fv(_safe_float(MolSurf.TPSA(mol)), True, "rdkit", "exact"),
+        "ligand_hbd": _fv(_safe_float(Lipinski.NumHDonors(mol)), True, "rdkit", "exact"),
+        "ligand_hba": _fv(_safe_float(Lipinski.NumHAcceptors(mol)), True, "rdkit", "exact"),
+        "ligand_rotatable_bonds": _fv(_safe_float(Lipinski.NumRotatableBonds(mol)), True, "rdkit", "exact"),
+        "ligand_aromatic_ring_count": _fv(_safe_float(aromatic_rings), True, "rdkit", "exact"),
+        "ligand_formal_charge": _fv(_safe_float(formal_charge), True, "rdkit", "exact"),
+        "ligand_partial_charge_abs_mean": _fv(mean_abs_q, has_q, "rdkit", "approximate"),
+        "ligand_partial_charge_total": _fv(total_q, has_q, "rdkit", "approximate"),
+        "ligand_topological_bertz": _fv(_safe_float(bertz_ct), True, "rdkit", "exact"),
+        "ligand_topological_balaban_j": _fv(_safe_float(balaban_j), True, "rdkit", "exact"),
+        "ligand_topological_chi0v": _fv(_safe_float(topological_complexity), True, "rdkit", "exact"),
+        "ligand_fraction_csp3": _fv(_safe_float(frac_csp3), True, "rdkit", "exact"),
+        "ligand_heavy_atom_count": _fv(_safe_float(heavy_atoms), True, "rdkit", "exact"),
+        "ligand_sasa": _fv(ligand_sasa, has_sasa, "geometric", "approximate"),
+        "similarity_to_reference": _fv(reference_similarity, reference_similarity is not None, "rdkit", "exact"),
+        "scaffold_match": _fv(scaffold_match, scaffold_match is not None, "rdkit", "exact"),
+        "chemical_distance_to_reference": _fv(chemical_distance, chemical_distance is not None, "rdkit", "exact"),
+    }
+
+    for i, bit in enumerate(fingerprint.astype(float).tolist()):
+        features[f"morgan_fp_{i:04d}"] = _fv(float(bit), True, "rdkit", "exact")
+
+    return FeatureBundle(object_id=ligand_id, features=features)
+
+
+def build_protein_feature_bundle(target_id: str, sequence_features: Dict[str, float], structure_features: Dict[str, float]) -> FeatureBundle:
+    seq_len = float(sequence_features.get("seq_length", 1.0) or 1.0)
+    hydrophobic = sum(sequence_features.get(f"aa_frac_{aa}", 0.0) for aa in ["A", "V", "I", "L", "M", "F", "W", "Y"])
+    charged = sum(sequence_features.get(f"aa_frac_{aa}", 0.0) for aa in ["K", "R", "H", "D", "E"])
+    polar = sum(sequence_features.get(f"aa_frac_{aa}", 0.0) for aa in ["S", "T", "N", "Q", "C"])
+
+    residue_count = float(structure_features.get("residue_count", 0.0))
+    mean_extent = float(structure_features.get("mean_spatial_extent", 0.0))
+    pocket_residues = float(structure_features.get("pocket_residue_count", 0.0))
+
+    approx_volume = float(max(0.0, mean_extent**3))
+    pocket_coverage = float(pocket_residues / max(residue_count, 1.0))
+
+    features = {
+        "pocket_hydrophobic_fraction": _fv(hydrophobic, True, "protein", "exact"),
+        "pocket_charged_fraction": _fv(charged, True, "protein", "exact"),
+        "pocket_polar_fraction": _fv(polar, True, "protein", "exact"),
+        "pocket_residue_count": _fv(residue_count, True, "protein", "exact"),
+        "pocket_volume_approx": _fv(approx_volume, True, "geometric", "approximate"),
+        "pocket_coverage_fraction": _fv(pocket_coverage, True, "geometric", "approximate"),
+        "pocket_sequence_length": _fv(seq_len, True, "protein", "exact"),
+    }
+    return FeatureBundle(object_id=target_id, features=features)
+
+
+def build_complex_feature_bundle(
+    ligand_id: str,
+    docking_score: float,
+    interface_features: Dict[str, float],
+    ligand_bundle: FeatureBundle,
+    protein_bundle: FeatureBundle,
+) -> FeatureBundle:
+    lig = ligand_bundle.features
+    prot = protein_bundle.features
+
+    logp = lig.get("ligand_logp", _fv(None, False, "rdkit", "exact")).value or 0.0
+    tpsa = lig.get("ligand_tpsa", _fv(None, False, "rdkit", "exact")).value or 0.0
+    charge_mag = lig.get("ligand_partial_charge_abs_mean", _fv(None, False, "rdkit", "approximate")).value
+    heavy_atoms = lig.get("ligand_heavy_atom_count", _fv(None, False, "rdkit", "exact")).value or 1.0
+    pocket_volume = prot.get("pocket_volume_approx", _fv(None, False, "geometric", "approximate")).value or 1.0
+    pocket_hydrophobic = prot.get("pocket_hydrophobic_fraction", _fv(None, False, "protein", "exact")).value or 0.0
+
+    interface_contact_proxy = float(interface_features.get("interface_contact_proxy", max(0.0, -docking_score / 8.0)))
+    hbond_proxy = float(interface_features.get("hbond_proxy", max(0.0, tpsa / 100.0)))
+    shape_proxy = float(interface_features.get("shape_proxy", max(0.0, 1.0 / (1.0 + abs(docking_score)))))
+
+    contact_count = max(1.0, heavy_atoms * (0.3 + interface_contact_proxy))
+    polar_contacts = contact_count * min(1.0, tpsa / 120.0)
+    hydrophobic_contacts = contact_count * min(1.0, max(0.0, logp) / 6.0) * (0.5 + pocket_hydrophobic)
+    clash_count = max(0.0, docking_score - 9.0)
+    min_distance = max(1.5, 6.0 - interface_contact_proxy)
+    pocket_coverage = min(1.0, contact_count / max(10.0, pocket_volume / 20.0))
+    interaction_density = contact_count / max(1.0, pocket_volume)
+
+    ligand_sasa = lig.get("ligand_sasa", _fv(None, False, "geometric", "approximate")).value
+    protein_sasa = pocket_volume * 0.75
+    if ligand_sasa is not None:
+        complex_sasa = max(1.0, protein_sasa + ligand_sasa - 0.5 * contact_count)
+        buried_sasa = max(0.0, protein_sasa + ligand_sasa - complex_sasa)
+        burial_ratio = buried_sasa / max(ligand_sasa, 1e-6)
+        sasa_available = True
+    else:
+        complex_sasa = None
+        buried_sasa = None
+        burial_ratio = None
+        sasa_available = False
+
+    if charge_mag is not None:
+        electrostatic_proxy = -charge_mag * max(0.5, 5.0 - min_distance)
+        electro_available = True
+    else:
+        electrostatic_proxy = None
+        electro_available = False
+
+    contact_energy = -0.15 * contact_count
+    steric_penalty = 0.6 * clash_count
+    hydrophobic_proxy = -0.1 * hydrophobic_contacts
+    interaction_decomp = contact_energy + hydrophobic_proxy + (electrostatic_proxy or 0.0) + steric_penalty
+
+    features = {
+        "complex_contact_count": _fv(float(contact_count), True, "interaction", "proxy"),
+        "complex_hbond_proxy": _fv(float(hbond_proxy), True, "interaction", "proxy"),
+        "complex_polar_contact_count": _fv(float(polar_contacts), True, "interaction", "proxy"),
+        "complex_hydrophobic_contact_proxy": _fv(float(hydrophobic_contacts), True, "interaction", "proxy"),
+        "complex_clash_count": _fv(float(clash_count), True, "interaction", "proxy"),
+        "complex_min_distance": _fv(float(min_distance), True, "geometric", "approximate"),
+        "complex_pocket_coverage": _fv(float(pocket_coverage), True, "interaction", "proxy"),
+        "complex_interaction_density": _fv(float(interaction_density), True, "interaction", "proxy"),
+        "complex_ligand_sasa": _fv(_safe_float(ligand_sasa), ligand_sasa is not None, "geometric", "approximate"),
+        "complex_protein_sasa": _fv(_safe_float(protein_sasa), True, "geometric", "approximate"),
+        "complex_sasa": _fv(_safe_float(complex_sasa), sasa_available, "geometric", "approximate"),
+        "complex_buried_sasa": _fv(_safe_float(buried_sasa), sasa_available, "geometric", "approximate"),
+        "complex_shape_complementarity": _fv(float(shape_proxy), True, "geometric", "proxy"),
+        "complex_ligand_burial_ratio": _fv(_safe_float(burial_ratio), sasa_available, "geometric", "approximate"),
+        "energy_contact_proxy": _fv(float(contact_energy), True, "energy_proxy", "proxy"),
+        "energy_electrostatic_proxy": _fv(_safe_float(electrostatic_proxy), electro_available, "energy_proxy", "proxy"),
+        "energy_steric_clash_penalty": _fv(float(steric_penalty), True, "energy_proxy", "proxy"),
+        "energy_hydrophobic_proxy": _fv(float(hydrophobic_proxy), True, "energy_proxy", "proxy"),
+        "energy_interaction_decomposition": _fv(float(interaction_decomp), True, "energy_proxy", "proxy"),
+    }
+
+    return FeatureBundle(object_id=ligand_id, features=features)
+
+
+def build_rdock_feature_bundle(
+    ligand_id: str,
+    parsed_row: Dict[str, float | int | str | bool | None],
+) -> FeatureBundle:
+    """Build a feature bundle from rDock-native and rDock-derived per-ligand outputs."""
+
+    def _as_feature(
+        key: str,
+        source: str,
+        ftype: str,
+    ) -> FeatureValue:
+        value = _safe_float(parsed_row.get(key))  # type: ignore[arg-type]
+        return _fv(value, value is not None, source, ftype if value is not None else "unavailable")
+
+    features: Dict[str, FeatureValue] = {
+        "rdock_total_score": _as_feature("rdock_total_score", "rdock_native", "exact"),
+        "rdock_pose_rank": _as_feature("rdock_pose_rank", "rdock_native", "exact"),
+        "n_generated_poses": _as_feature("n_generated_poses", "rdock_native", "exact"),
+        "best_pose_score": _as_feature("best_pose_score", "rdock_native", "exact"),
+        "mean_top3_pose_score": _as_feature("mean_top3_pose_score", "rdock_native", "exact"),
+        "mean_top5_pose_score": _as_feature("mean_top5_pose_score", "rdock_native", "exact"),
+        "std_top5_pose_score": _as_feature("std_top5_pose_score", "rdock_native", "exact"),
+        "pose_score_gap_1_2": _as_feature("pose_score_gap_1_2", "rdock_native", "exact"),
+        "rdock_restraint_term": _as_feature("rdock_restraint_term", "rdock_native", "exact"),
+        "rdock_internal_ligand_term": _as_feature("rdock_internal_ligand_term", "rdock_native", "exact"),
+        "rdock_polar_term": _as_feature("rdock_polar_term", "rdock_native", "exact"),
+        "rdock_vdw_term": _as_feature("rdock_vdw_term", "rdock_native", "exact"),
+        "top_pose_rmsd_consistency": _as_feature("top_pose_rmsd_consistency", "rdock_derived", "proxy"),
+        "contact_overlap_consistency": _as_feature("contact_overlap_consistency", "rdock_derived", "proxy"),
+        "hotspot_contact_frequency": _as_feature("hotspot_contact_frequency", "rdock_derived", "proxy"),
+        "subpocket_match_score": _as_feature("subpocket_match_score", "rdock_derived", "proxy"),
+        "replicate_mean_score": _as_feature("replicate_mean_score", "rdock_derived", "proxy"),
+        "replicate_score_variance": _as_feature("replicate_score_variance", "rdock_derived", "proxy"),
+        "replicate_consensus_score": _as_feature("replicate_consensus_score", "rdock_derived", "proxy"),
+    }
+    return FeatureBundle(object_id=ligand_id, features=features)
+
+
+def merge_bundles(object_id: str, bundles: Iterable[FeatureBundle]) -> FeatureBundle:
+    merged: Dict[str, FeatureValue] = {}
+    for bundle in bundles:
+        merged.update(bundle.features)
+    return FeatureBundle(object_id=object_id, features=merged)
+
+
+def bundles_to_wide_frames(
+    bundles: List[FeatureBundle],
+    ordered_feature_names: List[str] | None = None,
+) -> Tuple[pd.DataFrame, pd.DataFrame, List[str]]:
+    if not bundles:
+        return pd.DataFrame(), pd.DataFrame(), []
+
+    if ordered_feature_names is None:
+        feature_set = set()
+        for bundle in bundles:
+            feature_set.update(bundle.features.keys())
+        ordered_feature_names = sorted(feature_set)
+
+    value_rows = []
+    mask_rows = []
+    for bundle in bundles:
+        vrow = {"ligand_id": bundle.object_id}
+        mrow = {"ligand_id": bundle.object_id}
+        for name in ordered_feature_names:
+            fv = bundle.features.get(name)
+            if fv is None or not fv.available or fv.value is None:
+                vrow[name] = np.nan
+                mrow[f"mask_{name}"] = 0
+            else:
+                vrow[name] = float(fv.value)
+                mrow[f"mask_{name}"] = 1
+        value_rows.append(vrow)
+        mask_rows.append(mrow)
+
+    return pd.DataFrame(value_rows), pd.DataFrame(mask_rows), ordered_feature_names
+
+
+def compute_feature_diagnostics(values_df: pd.DataFrame, masks_df: pd.DataFrame, target: pd.Series | None = None) -> pd.DataFrame:
+    if values_df.empty:
+        return pd.DataFrame(columns=["feature", "missing_frac", "mean", "std", "min", "max", "is_constant", "corr_to_target"])
+
+    numeric_cols = [c for c in values_df.columns if c != "ligand_id"]
+    rows = []
+    for col in numeric_cols:
+        vals = pd.to_numeric(values_df[col], errors="coerce")
+        mask_col = f"mask_{col}"
+        if mask_col in masks_df.columns:
+            missing_frac = 1.0 - float(pd.to_numeric(masks_df[mask_col], errors="coerce").mean())
+        else:
+            missing_frac = float(vals.isna().mean())
+
+        finite_vals = vals[np.isfinite(vals)]
+        is_constant = finite_vals.nunique(dropna=True) <= 1 if not finite_vals.empty else True
+
+        if target is not None and len(target) == len(vals):
+            target_num = pd.to_numeric(target, errors="coerce")
+            paired = pd.concat([vals, target_num], axis=1).dropna()
+            if paired.shape[0] >= 3 and paired.iloc[:, 0].nunique(dropna=True) > 1 and paired.iloc[:, 1].nunique(dropna=True) > 1:
+                corr = paired.iloc[:, 0].corr(paired.iloc[:, 1])
+                corr_val = float(corr) if corr is not None and np.isfinite(corr) else np.nan
+            else:
+                corr_val = np.nan
+        else:
+            corr_val = np.nan
+
+        rows.append(
+            {
+                "feature": col,
+                "missing_frac": float(missing_frac),
+                "mean": float(finite_vals.mean()) if not finite_vals.empty else np.nan,
+                "std": float(finite_vals.std()) if not finite_vals.empty else np.nan,
+                "min": float(finite_vals.min()) if not finite_vals.empty else np.nan,
+                "max": float(finite_vals.max()) if not finite_vals.empty else np.nan,
+                "is_constant": bool(is_constant),
+                "corr_to_target": corr_val,
+            }
+        )
+
+    return pd.DataFrame(rows).sort_values(["missing_frac", "feature"], ascending=[False, True]).reset_index(drop=True)

libs/adaptive/hyperclustering.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import Dict, Sequence
+
+import numpy as np
+from sklearn.cluster import AgglomerativeClustering
+
+
+def hypercluster_representatives(
+    cluster_vectors: Dict[int, np.ndarray],
+    n_hyperclusters: int | None = None,
+) -> Dict[int, int]:
+    """Agglomerative clustering over cluster representative vectors."""
+    if not cluster_vectors:
+        return {}
+
+    cluster_ids = sorted(cluster_vectors)
+    x = np.vstack([cluster_vectors[cid] for cid in cluster_ids])
+
+    if len(cluster_ids) == 1:
+        return {cluster_ids[0]: 0}
+
+    n_clusters = n_hyperclusters or max(2, int(np.sqrt(len(cluster_ids))))
+    n_clusters = min(n_clusters, len(cluster_ids))
+
+    model = AgglomerativeClustering(n_clusters=n_clusters)
+    labels = model.fit_predict(x)
+    return {cluster_id: int(label) for cluster_id, label in zip(cluster_ids, labels)}

libs/adaptive/metrics.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from typing import Dict, Iterable, Sequence
+
+import numpy as np
+
+from .diversity import selection_diversity
+
+
+def clustering_metrics(cluster_map: Dict[str, int], hypercluster_map: Dict[int, int]) -> Dict[str, float]:
+    return {
+        "ligand_count": float(len(cluster_map)),
+        "cluster_count": float(len(set(cluster_map.values())) if cluster_map else 0),
+        "hypercluster_count": float(len(set(hypercluster_map.values())) if hypercluster_map else 0),
+    }
+
+
+def score_metrics(scores: Sequence[float]) -> Dict[str, float]:
+    if not scores:
+        return {
+            "evaluated_ligand_count": 0.0,
+            "mean_score": 0.0,
+            "best_score": 0.0,
+        }
+    arr = np.asarray(scores, dtype=float)
+    return {
+        "evaluated_ligand_count": float(arr.size),
+        "mean_score": float(np.mean(arr)),
+        "best_score": float(np.min(arr)),
+    }
+
+
+def enrichment_metrics(scores: Sequence[float], labels: Sequence[int] | None, topk: int = 10) -> Dict[str, float]:
+    if labels is None or not scores or len(labels) != len(scores):
+        return {"topk_hit_rate": 0.0, "enrichment_like": 0.0}
+
+    idx_sorted = np.argsort(np.asarray(scores, dtype=float))
+    labels_arr = np.asarray(labels, dtype=int)
+    k = min(topk, len(idx_sorted))
+    top_hits = int(np.sum(labels_arr[idx_sorted[:k]]))
+    baseline = float(np.mean(labels_arr)) if labels_arr.size else 0.0
+    hit_rate = top_hits / max(k, 1)
+    enrichment = (hit_rate / baseline) if baseline > 0 else 0.0
+    return {"topk_hit_rate": float(hit_rate), "enrichment_like": float(enrichment)}
+
+
+def diversity_metric(selected_fingerprints: Iterable[np.ndarray]) -> Dict[str, float]:
+    return {"selection_diversity": selection_diversity(selected_fingerprints)}

libs/adaptive/policies.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class PrioritizationPolicy:
+    utility_weight: float = 0.55
+    uncertainty_weight: float = 0.2
+    diversity_weight: float = 0.15
+    cluster_bonus_weight: float = 0.1
+    conservative_deprioritize_quantile: float = 0.15

libs/adaptive/prioritization.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import Dict
+
+from .policies import PrioritizationPolicy
+
+
+def compute_priority(
+    predicted_utility: float,
+    uncertainty: float,
+    diversity_gain: float,
+    cluster_bonus: float,
+    policy: PrioritizationPolicy,
+) -> float:
+    """Weighted priority function used by adaptive queueing."""
+    return (
+        policy.utility_weight * predicted_utility
+        + policy.uncertainty_weight * uncertainty
+        + policy.diversity_weight * diversity_gain
+        + policy.cluster_bonus_weight * cluster_bonus
+    )
+
+
+def cluster_bonus(cluster_load: Dict[int, int], cluster_id: int) -> float:
+    load = cluster_load.get(cluster_id, 0)
+    return 1.0 / (1.0 + float(load))

libs/adaptive/queue_manager.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Iterable, List
+
+from .state import QueueItem
+
+VALID_STATUSES = {"active", "deprioritized", "frozen", "completed"}
+
+
+@dataclass
+class QueueManager:
+    items: Dict[str, QueueItem]
+
+    @classmethod
+    def from_items(cls, items: Iterable[QueueItem]) -> "QueueManager":
+        return cls(items={item.ligand_id: item for item in items})
+
+    def set_status(self, ligand_id: str, status: str) -> None:
+        if status not in VALID_STATUSES:
+            raise ValueError(f"Invalid status: {status}")
+        self.items[ligand_id].status = status
+
+    def active_items(self) -> List[QueueItem]:
+        return [item for item in self.items.values() if item.status == "active"]
+
+    def completed_items(self) -> List[QueueItem]:
+        return [item for item in self.items.values() if item.status == "completed"]
+
+    def ordered_active(self) -> List[QueueItem]:
+        return sorted(self.active_items(), key=lambda item: item.priority, reverse=True)

libs/adaptive/scheduler.py

@@ -0,0 +1,253 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List
+
+import numpy as np
+import pandas as pd
+
+from .metrics import score_metrics
+from .policies import PrioritizationPolicy
+from .prioritization import cluster_bonus, compute_priority
+from .queue_manager import QueueManager
+from .state import QueueItem, SchedulerState
+from .surrogate_model import SurrogateConfig, SurrogateModel
+from .weight_schedule import WeightScheduleConfig, compute_model_weight
+
+
+@dataclass
+class SchedulerConfig:
+    batch_size: int = 8
+    init_coverage_fraction: float = 0.25
+    conservative_deprioritize: bool = True
+    state_path: str = "results/state.json"
+    weight_schedule: WeightScheduleConfig = field(default_factory=WeightScheduleConfig)
+
+
+class AdaptiveScheduler:
+    """Adaptive batch scheduler with queue state and online masked surrogate updates."""
+
+    def __init__(
+        self,
+        config: SchedulerConfig | None = None,
+        policy: PrioritizationPolicy | None = None,
+        surrogate_config: SurrogateConfig | None = None,
+    ) -> None:
+        self.config = config or SchedulerConfig()
+        self.policy = policy or PrioritizationPolicy()
+        self.surrogate = SurrogateModel(surrogate_config)
+        self.state = SchedulerState()
+        self.queue_manager = QueueManager.from_items([])
+        self.last_model_weight: float = 0.0
+
+    def initialize(
+        self,
+        ligands_df: pd.DataFrame,
+        cluster_map: Dict[str, int],
+        hypercluster_for_cluster: Dict[int, int],
+    ) -> None:
+        items: List[QueueItem] = []
+        cluster_load: Dict[int, int] = {}
+
+        for row in ligands_df.itertuples(index=False):
+            ligand_id = str(row.ligand_id)
+            cluster_id = int(cluster_map.get(ligand_id, -1))
+            hypercluster_id = int(hypercluster_for_cluster.get(cluster_id, -1))
+            bonus = cluster_bonus(cluster_load, cluster_id)
+            priority = compute_priority(
+                predicted_utility=0.0,
+                uncertainty=1.0,
+                diversity_gain=bonus,
+                cluster_bonus=bonus,
+                policy=self.policy,
+            )
+            items.append(
+                QueueItem(
+                    ligand_id=ligand_id,
+                    status="active",
+                    priority=float(priority),
+                    cluster_id=cluster_id,
+                    hypercluster_id=hypercluster_id,
+                )
+            )
+            cluster_load[cluster_id] = cluster_load.get(cluster_id, 0) + 1
+
+        self.state = SchedulerState(queue=items, batch_history=[], round_idx=0)
+        self.queue_manager = QueueManager.from_items(items)
+
+    def select_batch(self) -> List[str]:
+        active = self.queue_manager.ordered_active()
+        if not active:
+            # If conservative deprioritization exhausted active queue, reactivate
+            # deprioritized candidates to continue spending the docking budget.
+            deprioritized = sorted(
+                [item for item in self.queue_manager.items.values() if item.status == "deprioritized"],
+                key=lambda item: item.priority,
+                reverse=True,
+            )
+            if not deprioritized:
+                return []
+            for item in deprioritized:
+                item.status = "active"
+            active = deprioritized
+
+        coverage_count = max(1, int(self.config.batch_size * self.config.init_coverage_fraction))
+        by_hypercluster: Dict[int, List[QueueItem]] = {}
+        for item in active:
+            by_hypercluster.setdefault(item.hypercluster_id, []).append(item)
+
+        selected: List[str] = []
+        # Broad initial coverage.
+        for _h_id, items in sorted(by_hypercluster.items(), key=lambda x: len(x[1]), reverse=True):
+            if len(selected) >= coverage_count:
+                break
+            selected.append(items[0].ligand_id)
+
+        # Fill remaining slots by priority.
+        for item in active:
+            if len(selected) >= self.config.batch_size:
+                break
+            if item.ligand_id not in selected:
+                selected.append(item.ligand_id)
+
+        for ligand_id in selected:
+            self.queue_manager.items[ligand_id].times_selected += 1
+        return selected
+
+    @staticmethod
+    def _mean_or_default(values: list[float], default: float = 0.0) -> float:
+        if not values:
+            return float(default)
+        return float(np.mean(np.asarray(values, dtype=float)))
+
+    def update_from_batch(
+        self,
+        evaluated_df: pd.DataFrame,
+        feature_values_df: pd.DataFrame,
+        feature_masks_df: pd.DataFrame,
+    ) -> Dict[str, float]:
+        # Mark completed ligands and store latest score.
+        score_map = dict(zip(evaluated_df["ligand_id"].astype(str), evaluated_df["docking_score"].astype(float)))
+        for ligand_id, score in score_map.items():
+            if ligand_id in self.queue_manager.items:
+                item = self.queue_manager.items[ligand_id]
+                item.status = "completed"
+                item.last_score = float(score)
+
+        if feature_values_df.empty or feature_masks_df.empty:
+            raise ValueError("Feature tables cannot be empty in adaptive update")
+
+        if "ligand_id" not in feature_values_df.columns or "ligand_id" not in feature_masks_df.columns:
+            raise ValueError("Feature tables must include ligand_id column")
+
+        ligand_order = feature_values_df["ligand_id"].astype(str).tolist()
+        features = feature_values_df.drop(columns=["ligand_id"]).to_numpy(dtype=float)
+        masks = feature_masks_df.drop(columns=["ligand_id"]).to_numpy(dtype=float)
+        feature_names = feature_values_df.drop(columns=["ligand_id"]).columns.tolist()
+        mask_names = feature_masks_df.drop(columns=["ligand_id"]).columns.tolist()
+
+        target = np.full(len(ligand_order), np.nan, dtype=float)
+        for i, ligand_id in enumerate(ligand_order):
+            if ligand_id in self.queue_manager.items:
+                score = self.queue_manager.items[ligand_id].last_score
+                if score is not None:
+                    target[i] = float(score)
+
+        fit_stats = self.surrogate.fit(
+            features=features,
+            masks=masks,
+            y=target,
+            feature_names=feature_names,
+            mask_names=mask_names,
+        )
+
+        n_train = int(fit_stats.get("n_train", 0.0))
+        instability_ratio = float(fit_stats.get("instability_ratio", 1.0))
+        model_weight = compute_model_weight(
+            n_samples=n_train,
+            instability_ratio=instability_ratio,
+            config=self.config.weight_schedule,
+        )
+        if self.surrogate.model is None:
+            model_weight = 0.0
+        self.last_model_weight = float(model_weight)
+
+        # Predict for active items.
+        active_items = self.queue_manager.active_items()
+        active_ids = [item.ligand_id for item in active_items]
+
+        completed_items = [item for item in self.queue_manager.items.values() if item.last_score is not None]
+        global_completed = [float(item.last_score) for item in completed_items if item.last_score is not None]
+        global_mean_score = self._mean_or_default(global_completed, default=0.0)
+
+        cluster_scores: Dict[int, list[float]] = {}
+        hyper_scores: Dict[int, list[float]] = {}
+        for item in completed_items:
+            assert item.last_score is not None
+            cluster_scores.setdefault(item.cluster_id, []).append(float(item.last_score))
+            hyper_scores.setdefault(item.hypercluster_id, []).append(float(item.last_score))
+
+        if active_ids:
+            id_to_idx = {lid: idx for idx, lid in enumerate(ligand_order)}
+            x_active = np.vstack([features[id_to_idx[lid]] for lid in active_ids])
+            m_active = np.vstack([masks[id_to_idx[lid]] for lid in active_ids])
+            bundle = self.surrogate.predict_bundle(x_active, m_active)
+
+            cluster_load: Dict[int, int] = {}
+            for item in active_items:
+                cluster_load[item.cluster_id] = cluster_load.get(item.cluster_id, 0) + 1
+
+            for i, ligand_id in enumerate(active_ids):
+                item = self.queue_manager.items[ligand_id]
+
+                cluster_mean = self._mean_or_default(cluster_scores.get(item.cluster_id, []), default=np.nan)
+                hyper_mean = self._mean_or_default(hyper_scores.get(item.hypercluster_id, []), default=np.nan)
+                observed_docking = (
+                    cluster_mean
+                    if np.isfinite(cluster_mean)
+                    else hyper_mean
+                    if np.isfinite(hyper_mean)
+                    else global_mean_score
+                )
+
+                docking_component = -float(observed_docking)
+                model_component = -float(bundle["expected_score"][i])
+                blended_utility = (1.0 - model_weight) * docking_component + model_weight * model_component
+
+                bonus = cluster_bonus(cluster_load, item.cluster_id)
+                item.priority = compute_priority(
+                    predicted_utility=float(blended_utility),
+                    uncertainty=float(bundle["uncertainty"][i]),
+                    diversity_gain=bonus,
+                    cluster_bonus=bonus,
+                    policy=self.policy,
+                )
+
+            if self.config.conservative_deprioritize:
+                priorities = np.asarray([self.queue_manager.items[lid].priority for lid in active_ids], dtype=float)
+                threshold = float(np.quantile(priorities, self.policy.conservative_deprioritize_quantile))
+                for lid in active_ids:
+                    if self.queue_manager.items[lid].priority < threshold:
+                        self.queue_manager.items[lid].status = "deprioritized"
+
+        self.state.round_idx += 1
+        sm = score_metrics(evaluated_df["docking_score"].astype(float).tolist())
+        batch_record: Dict[str, float | str] = {
+            "round_idx": self.state.round_idx,
+            "batch_size": int(evaluated_df.shape[0]),
+            "model_weight": float(model_weight),
+            "n_train": float(n_train),
+            "train_mae": float(fit_stats.get("train_mae", np.nan)),
+            "val_mae": float(fit_stats.get("val_mae", np.nan)),
+            "instability_ratio": float(instability_ratio),
+            "surrogate_backend": self.surrogate.backend,
+            **sm,
+        }
+        self.state.batch_history.append(batch_record)
+        return fit_stats
+
+    def save_state(self, output_path: str | Path | None = None) -> Path:
+        target = Path(output_path or self.config.state_path)
+        self.state.queue = list(self.queue_manager.items.values())
+        return self.state.save(target)

libs/adaptive/state.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List
+
+import json
+
+
+@dataclass
+class QueueItem:
+    ligand_id: str
+    status: str = "active"
+    priority: float = 0.0
+    hypercluster_id: int = -1
+    cluster_id: int = -1
+    times_selected: int = 0
+    last_score: float | None = None
+
+
+@dataclass
+class SchedulerState:
+    queue: List[QueueItem] = field(default_factory=list)
+    batch_history: List[Dict[str, Any]] = field(default_factory=list)
+    round_idx: int = 0
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "queue": [asdict(item) for item in self.queue],
+            "batch_history": self.batch_history,
+            "round_idx": self.round_idx,
+        }
+
+    @classmethod
+    def from_dict(cls, payload: Dict[str, Any]) -> "SchedulerState":
+        queue = [QueueItem(**item) for item in payload.get("queue", [])]
+        return cls(queue=queue, batch_history=payload.get("batch_history", []), round_idx=int(payload.get("round_idx", 0)))
+
+    def save(self, path: str | Path) -> Path:
+        target = Path(path)
+        target.parent.mkdir(parents=True, exist_ok=True)
+        with target.open("w", encoding="utf-8") as handle:
+            json.dump(self.to_dict(), handle, indent=2)
+        return target
+
+    @classmethod
+    def load(cls, path: str | Path) -> "SchedulerState":
+        source = Path(path)
+        with source.open("r", encoding="utf-8") as handle:
+            return cls.from_dict(json.load(handle))

libs/adaptive/surrogate_model.py

@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+import numpy as np
+from sklearn.ensemble import RandomForestRegressor
+
+try:
+    from xgboost import XGBRegressor
+except Exception:  # pragma: no cover
+    XGBRegressor = None  # type: ignore[assignment]
+
+
+@dataclass
+class SurrogateConfig:
+    prefer_xgboost: bool = True
+    random_state: int = 42
+    n_estimators: int = 200
+    min_train_samples: int = 8
+    max_depth_small: int = 3
+    max_depth_large: int = 6
+
+
+class SurrogateModel:
+    """Surrogate model with explicit missing-feature masking support."""
+
+    def __init__(self, config: Optional[SurrogateConfig] = None):
+        self.config = config or SurrogateConfig()
+        self.model = None
+        self.backend = "uninitialized"
+        self.feature_names: List[str] = []
+        self.mask_names: List[str] = []
+
+        self._median: np.ndarray | None = None
+        self._iqr: np.ndarray | None = None
+        self._train_x: np.ndarray | None = None
+        self._train_y: np.ndarray | None = None
+        self.last_fit_stats: Dict[str, float] = {}
+
+    def _build_model(self, n_samples: int):
+        max_depth = self.config.max_depth_small if n_samples < 50 else self.config.max_depth_large
+        if self.config.prefer_xgboost and XGBRegressor is not None:
+            self.backend = "xgboost"
+            return XGBRegressor(
+                n_estimators=self.config.n_estimators,
+                max_depth=max_depth,
+                learning_rate=0.05,
+                subsample=0.9,
+                colsample_bytree=0.9,
+                reg_alpha=0.1,
+                reg_lambda=1.0,
+                random_state=self.config.random_state,
+            )
+
+        self.backend = "random_forest"
+        return RandomForestRegressor(
+            n_estimators=max(100, self.config.n_estimators),
+            max_depth=max_depth,
+            random_state=self.config.random_state,
+            n_jobs=-1,
+        )
+
+    def _fit_normalizer(self, x: np.ndarray, m: np.ndarray) -> None:
+        med = []
+        iqr = []
+        for j in range(x.shape[1]):
+            vals = x[m[:, j] > 0.5, j]
+            if vals.size == 0:
+                med.append(0.0)
+                iqr.append(1.0)
+                continue
+            q1 = float(np.quantile(vals, 0.25))
+            q3 = float(np.quantile(vals, 0.75))
+            inter = max(1e-6, q3 - q1)
+            med.append(float(np.median(vals)))
+            iqr.append(inter)
+        self._median = np.asarray(med, dtype=float)
+        self._iqr = np.asarray(iqr, dtype=float)
+
+    def _transform(self, x: np.ndarray, m: np.ndarray, fit: bool = False) -> np.ndarray:
+        x = np.asarray(x, dtype=float)
+        m = np.asarray(m, dtype=float)
+        if fit or self._median is None or self._iqr is None:
+            self._fit_normalizer(x, m)
+        assert self._median is not None and self._iqr is not None
+
+        x_filled = np.where(np.isfinite(x), x, np.nan)
+        for j in range(x.shape[1]):
+            col = x_filled[:, j]
+            missing = ~np.isfinite(col)
+            col[missing] = self._median[j]
+            x_filled[:, j] = (col - self._median[j]) / self._iqr[j]
+
+        # Explicit missingness information: concatenate mask vector.
+        return np.concatenate([x_filled, m], axis=1)
+
+    def fit(
+        self,
+        features: np.ndarray,
+        masks: np.ndarray,
+        y: np.ndarray,
+        feature_names: List[str],
+        mask_names: List[str],
+    ) -> Dict[str, float]:
+        y = np.asarray(y, dtype=float)
+        valid = np.isfinite(y)
+        n_samples = int(np.sum(valid))
+
+        self.feature_names = list(feature_names)
+        self.mask_names = list(mask_names)
+
+        if n_samples < self.config.min_train_samples:
+            self.model = None
+            self.backend = "warmup"
+            self.last_fit_stats = {
+                "n_train": float(n_samples),
+                "train_mae": np.nan,
+                "val_mae": np.nan,
+                "instability_ratio": 1.0,
+            }
+            return self.last_fit_stats
+
+        x = np.asarray(features, dtype=float)[valid]
+        m = np.asarray(masks, dtype=float)[valid]
+        yv = y[valid]
+
+        x_trans = self._transform(x, m, fit=True)
+        self._train_x = x_trans
+        self._train_y = yv
+
+        self.model = self._build_model(n_samples=n_samples)
+        self.model.fit(x_trans, yv)
+
+        train_pred = self.model.predict(x_trans)
+        train_mae = float(np.mean(np.abs(train_pred - yv)))
+
+        # Simple rolling validation proxy.
+        if n_samples >= 12:
+            split = int(max(8, n_samples * 0.8))
+            x_tr, x_val = x_trans[:split], x_trans[split:]
+            y_tr, y_val = yv[:split], yv[split:]
+
+            val_model = self._build_model(n_samples=split)
+            val_model.fit(x_tr, y_tr)
+            val_pred = val_model.predict(x_val)
+            val_mae = float(np.mean(np.abs(val_pred - y_val))) if y_val.size else train_mae
+        else:
+            val_mae = train_mae
+
+        instability = float((val_mae + 1e-6) / (train_mae + 1e-6))
+        self.last_fit_stats = {
+            "n_train": float(n_samples),
+            "train_mae": train_mae,
+            "val_mae": val_mae,
+            "instability_ratio": instability,
+        }
+        return self.last_fit_stats
+
+    def _rf_uncertainty(self, x: np.ndarray) -> np.ndarray:
+        assert self.model is not None
+        if not hasattr(self.model, "estimators_"):
+            return np.full(x.shape[0], float(np.std(self._train_y)) if self._train_y is not None else 1.0)
+        preds = np.vstack([tree.predict(x) for tree in self.model.estimators_])
+        return np.std(preds, axis=0)
+
+    def predict_bundle(self, features: np.ndarray, masks: np.ndarray, topk_threshold: float | None = None) -> Dict[str, np.ndarray]:
+        n = features.shape[0]
+        if self.model is None:
+            return {
+                "expected_score": np.zeros(n, dtype=float),
+                "topk_probability": np.full(n, 0.5, dtype=float),
+                "uncertainty": np.full(n, 1.0, dtype=float),
+            }
+
+        x = self._transform(np.asarray(features, dtype=float), np.asarray(masks, dtype=float), fit=False)
+        expected = self.model.predict(x)
+
+        if self.backend == "random_forest":
+            uncertainty = self._rf_uncertainty(x)
+        else:
+            residual_scale = (
+                float(np.std(self._train_y - self.model.predict(self._train_x)))
+                if self._train_x is not None and self._train_y is not None
+                else 1.0
+            )
+            uncertainty = np.full(expected.shape[0], max(1e-3, residual_scale))
+
+        if topk_threshold is None:
+            topk_threshold = float(np.quantile(self._train_y, 0.8)) if self._train_y is not None else 0.0
+
+        z = (expected - topk_threshold) / (uncertainty + 1e-6)
+        topk_prob = 1.0 / (1.0 + np.exp(-z))
+        return {
+            "expected_score": expected.astype(float),
+            "topk_probability": topk_prob.astype(float),
+            "uncertainty": uncertainty.astype(float),
+        }
+
+    def feature_importance(self) -> Dict[str, float]:
+        if self.model is None or not hasattr(self.model, "feature_importances_"):
+            return {}
+
+        names = self.feature_names + self.mask_names
+        importances = np.asarray(self.model.feature_importances_, dtype=float)
+        if importances.size != len(names):
+            return {}
+        return {name: float(value) for name, value in zip(names, importances)}

libs/adaptive/thresholding.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, List, Sequence
+
+import numpy as np
+
+
+@dataclass
+class DynamicThresholdConfig:
+    min_evaluated: int = 500
+    patience_rounds: int = 8
+    min_model_weight: float = 0.35
+    quantile: float = 0.15
+    uncertainty_weight: float = 0.20
+    min_improvement: float = 0.02
+    exploration_margin: float = 0.45
+    exploitation_margin: float = 0.10
+    reference_evaluations: int = 5000
+
+
+class DynamicEarlyStopController:
+    """
+    Conservative early-stop controller for adaptive replay.
+
+    Lower scores are considered better.
+    """
+
+    def __init__(self, config: DynamicThresholdConfig | None = None) -> None:
+        self.config = config or DynamicThresholdConfig()
+        self.best_score = np.inf
+        self.stagnant_rounds = 0
+        self.history: List[Dict[str, float | int | bool | str]] = []
+
+    def update(
+        self,
+        *,
+        round_idx: int,
+        n_evaluated: int,
+        all_scores: Sequence[float],
+        recent_scores: Sequence[float],
+        model_weight: float,
+        mean_uncertainty: float,
+    ) -> Dict[str, float | int | bool | str]:
+        cfg = self.config
+        scores = np.asarray(all_scores, dtype=float)
+        recent = np.asarray(recent_scores, dtype=float)
+
+        if scores.size == 0:
+            rec = {
+                "round_idx": int(round_idx),
+                "n_evaluated": int(n_evaluated),
+                "dynamic_threshold": np.nan,
+                "score_quantile": np.nan,
+                "best_score": np.nan,
+                "recent_mean_score": np.nan,
+                "mean_uncertainty": float(mean_uncertainty),
+                "model_weight": float(model_weight),
+                "stagnant_rounds": int(self.stagnant_rounds),
+                "eligible_for_stop": False,
+                "stop": False,
+                "reason": "no_scores",
+            }
+            self.history.append(rec)
+            return rec
+
+        score_quantile = float(np.nanquantile(scores, cfg.quantile))
+        best = float(np.nanmin(scores))
+        recent_mean = float(np.nanmean(recent)) if recent.size else float(np.nan)
+        uncertainty = float(max(0.0, mean_uncertainty))
+
+        if np.isfinite(self.best_score):
+            improvement = float(self.best_score - best)
+        else:
+            improvement = np.inf
+
+        if improvement > cfg.min_improvement:
+            self.stagnant_rounds = 0
+        else:
+            self.stagnant_rounds += 1
+        self.best_score = min(self.best_score, best)
+
+        coverage = float(min(1.0, n_evaluated / max(1.0, float(cfg.reference_evaluations))))
+        margin = (1.0 - coverage) * cfg.exploration_margin + coverage * cfg.exploitation_margin
+        dynamic_threshold = float(score_quantile + margin + cfg.uncertainty_weight * uncertainty)
+
+        eligible = (
+            int(n_evaluated) >= int(cfg.min_evaluated)
+            and float(model_weight) >= float(cfg.min_model_weight)
+        )
+        plateau = self.stagnant_rounds >= int(cfg.patience_rounds)
+        poor_recent = bool(np.isfinite(recent_mean) and recent_mean >= dynamic_threshold)
+        should_stop = bool(eligible and plateau and poor_recent)
+
+        if not eligible:
+            reason = "not_eligible"
+        elif not plateau:
+            reason = "improving_or_not_stagnant"
+        elif not poor_recent:
+            reason = "recent_batch_still_competitive"
+        else:
+            reason = "stagnation_above_dynamic_threshold"
+
+        rec = {
+            "round_idx": int(round_idx),
+            "n_evaluated": int(n_evaluated),
+            "dynamic_threshold": dynamic_threshold,
+            "score_quantile": score_quantile,
+            "best_score": self.best_score,
+            "recent_mean_score": recent_mean,
+            "mean_uncertainty": uncertainty,
+            "model_weight": float(model_weight),
+            "stagnant_rounds": int(self.stagnant_rounds),
+            "eligible_for_stop": bool(eligible),
+            "stop": should_stop,
+            "reason": reason,
+        }
+        self.history.append(rec)
+        return rec
+

libs/adaptive/weight_schedule.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Sequence
+
+
+@dataclass
+class WeightScheduleConfig:
+    sample_knots: tuple[int, int, int, int] = (20, 50, 100, 200)
+    weight_knots: tuple[float, float, float, float] = (0.1, 0.3, 0.5, 0.8)
+    max_weight: float = 0.9
+    min_weight: float = 0.05
+    instability_threshold: float = 2.0
+    instability_decay: float = 0.25
+
+
+def _interp(x: float, xs: Sequence[float], ys: Sequence[float]) -> float:
+    if x <= xs[0]:
+        return float(ys[0])
+    if x >= xs[-1]:
+        return float(ys[-1])
+
+    for i in range(1, len(xs)):
+        if x <= xs[i]:
+            x0, x1 = xs[i - 1], xs[i]
+            y0, y1 = ys[i - 1], ys[i]
+            t = (x - x0) / max(1e-9, (x1 - x0))
+            return float(y0 + t * (y1 - y0))
+    return float(ys[-1])
+
+
+def compute_model_weight(
+    n_samples: int,
+    instability_ratio: float = 1.0,
+    config: WeightScheduleConfig | None = None,
+) -> float:
+    cfg = config or WeightScheduleConfig()
+
+    base = _interp(float(n_samples), cfg.sample_knots, cfg.weight_knots)
+    if n_samples > cfg.sample_knots[-1]:
+        extra = min(cfg.max_weight - base, 0.05 * (n_samples - cfg.sample_knots[-1]) / 100.0)
+        base += max(0.0, extra)
+
+    if instability_ratio > cfg.instability_threshold:
+        base *= max(0.1, 1.0 - cfg.instability_decay)
+
+    base = max(cfg.min_weight, min(cfg.max_weight, base))
+    return float(base)

libs/analysis/backend_diagnostic.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Iterable
+
+import numpy as np
+import pandas as pd
+
+
+REQUIRED_REFERENCE_DIAG_COLUMNS = [
+    "dataset",
+    "target_name",
+    "reference_ligand_id",
+    "reference_ligand_score",
+    "reference_ligand_rank_percentile",
+    "adaptive_best_score",
+    "exhaustive_best_score",
+]
+
+REQUIRED_BACKEND_COMPARISON_COLUMNS = [
+    "dataset",
+    "backend",
+    "analysis_scope",
+    "available",
+    "n_ligands",
+    "runtime_seconds",
+    "runtime_per_ligand",
+    "reference_ligand_score",
+    "reference_ligand_rank_percentile",
+    "best_score",
+    "score_gap_reference_vs_best",
+    "reference_pose_centroid_distance_A",
+    "reference_pose_in_expected_pocket",
+]
+
+REQUIRED_POCKET_PREP_COLUMNS = [
+    "dataset",
+    "backend",
+    "pocket_variant",
+    "prep_variant",
+    "reference_ligand_score",
+    "reference_pose_centroid_distance_A",
+    "reference_pose_in_expected_pocket",
+]
+
+
+@dataclass(frozen=True)
+class ManualAgentsCheck:
+    exists: bool
+    path: str
+    manually_read: bool
+
+
+def manual_agents_check(path: str | Path, manually_read: bool = True) -> ManualAgentsCheck:
+    p = Path(path).expanduser().resolve()
+    return ManualAgentsCheck(exists=p.exists(), path=str(p), manually_read=bool(manually_read and p.exists()))
+
+
+def _safe_float(x: Any, default: float = np.nan) -> float:
+    try:
+        v = float(x)
+        return float(v) if np.isfinite(v) else float(default)
+    except Exception:
+        return float(default)
+
+
+def compute_rank_percentile(df: pd.DataFrame, ligand_id: str, score_col: str, lower_is_better: bool = True) -> float:
+    if df.empty or score_col not in df.columns:
+        return np.nan
+    d = df[["ligand_id", score_col]].copy()
+    d["ligand_id"] = d["ligand_id"].astype(str)
+    d[score_col] = pd.to_numeric(d[score_col], errors="coerce")
+    d = d.dropna(subset=[score_col]).copy()
+    if d.empty:
+        return np.nan
+    d = d.sort_values(score_col, ascending=bool(lower_is_better)).reset_index(drop=True)
+    hit = d.index[d["ligand_id"] == str(ligand_id)]
+    if len(hit) == 0:
+        return np.nan
+    rank = int(hit[0]) + 1
+    return float(100.0 * rank / max(1, d.shape[0]))
+
+
+def select_suspicious_datasets(reference_diag_df: pd.DataFrame, threshold_pct: float = 25.0, max_deep: int = 2) -> list[str]:
+    if reference_diag_df.empty:
+        return []
+    d = reference_diag_df.copy()
+    d["reference_ligand_rank_percentile"] = pd.to_numeric(d["reference_ligand_rank_percentile"], errors="coerce")
+    d = d.dropna(subset=["reference_ligand_rank_percentile"]).copy()
+    d = d[d["reference_ligand_rank_percentile"] >= float(threshold_pct)].copy()
+    if d.empty:
+        return []
+    d = d.sort_values("reference_ligand_rank_percentile", ascending=False)
+    return d["dataset"].astype(str).head(int(max(1, max_deep))).tolist()
+
+
+def validate_required_columns(df: pd.DataFrame, required_columns: Iterable[str]) -> list[str]:
+    cols = set(df.columns)
+    missing = [c for c in required_columns if c not in cols]
+    return missing
+
+
+def recommend_toolchain(
+    backend_comparison_df: pd.DataFrame,
+    pocket_prep_df: pd.DataFrame,
+) -> dict[str, Any]:
+    """
+    Choose practical recommendation from diagnostic evidence.
+
+    Policy:
+    - Prefer backend with best median reference rank percentile under "subset_default" scope.
+    - Penalize poor runtime-per-ligand if >2x best runtime.
+    - Use pocket/prep gain to detect whether core issue is mostly preparation/pocket.
+    """
+    out: dict[str, Any] = {
+        "recommended_main_backend": "rdock",
+        "recommended_rescoring": "gnina_or_haddock_shortlist_optional",
+        "keep_haddock": "optional_shortlist_only",
+        "main_failure_source": "mixed",
+        "evidence": [],
+    }
+
+    bdf = backend_comparison_df.copy()
+    if not bdf.empty:
+        bdf = bdf[bdf["analysis_scope"].astype(str) == "subset_default"].copy()
+    if not bdf.empty:
+        bdf["runtime_per_ligand"] = pd.to_numeric(bdf["runtime_per_ligand"], errors="coerce")
+        bdf["reference_ligand_rank_percentile"] = pd.to_numeric(bdf["reference_ligand_rank_percentile"], errors="coerce")
+        agg = (
+            bdf.groupby("backend", as_index=False)
+            .agg(
+                median_ref_rank_pct=("reference_ligand_rank_percentile", "median"),
+                median_runtime=("runtime_per_ligand", "median"),
+                available_ratio=("available", "mean"),
+            )
+            .sort_values(["median_ref_rank_pct", "median_runtime"], ascending=[True, True])
+        )
+        if not agg.empty:
+            best = agg.iloc[0]
+            best_runtime = max(1e-9, _safe_float(best["median_runtime"], 1.0))
+            candidate = str(best["backend"])
+            if _safe_float(best["available_ratio"], 0.0) < 0.5:
+                out["evidence"].append("best_rank_backend_not_reliably_available")
+            else:
+                out["recommended_main_backend"] = candidate
+
+            rd = agg[agg["backend"].astype(str).str.lower() == "rdock"]
+            if not rd.empty:
+                rd_runtime = max(1e-9, _safe_float(rd.iloc[0]["median_runtime"], best_runtime))
+                if best_runtime > 2.0 * rd_runtime and candidate != "rdock":
+                    out["evidence"].append("candidate_backend_too_slow_vs_rdock")
+                    out["recommended_main_backend"] = "rdock"
+
+            out["evidence"].append(f"rank_runtime_table={agg.to_dict(orient='records')}")
+
+    pdf = pocket_prep_df.copy()
+    if not pdf.empty:
+        pdf["reference_ligand_score"] = pd.to_numeric(pdf["reference_ligand_score"], errors="coerce")
+        deltas: list[float] = []
+        for (_, _), sub in pdf.groupby(["dataset", "backend"]):
+            default = sub[(sub["pocket_variant"] == "default") & (sub["prep_variant"] == "default")]
+            if default.empty:
+                continue
+            default_score = _safe_float(default.iloc[0]["reference_ligand_score"], np.nan)
+            best_score = _safe_float(sub["reference_ligand_score"].min(), np.nan)
+            if np.isfinite(default_score) and np.isfinite(best_score):
+                deltas.append(default_score - best_score)
+        mean_gain = float(np.mean(np.asarray(deltas, dtype=float))) if deltas else 0.0
+        if mean_gain > 1.0:
+            out["main_failure_source"] = "pocket_or_preparation"
+        elif mean_gain > 0.2:
+            out["main_failure_source"] = "mixed"
+        else:
+            out["main_failure_source"] = "backend_scoring_limitations"
+        out["evidence"].append(f"mean_reference_gain_from_pocket_prep={mean_gain:.3f}")
+
+    out["keep_haddock"] = "optional_shortlist_only"
+    return out

libs/analysis/ranking.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+
+def resolve_reference_rank_percentile(
+    merged_df: pd.DataFrame,
+    reference_ligand_id: str,
+    *,
+    oracle_rank_col: str = "rank_percentile",
+    run_rank_col: str = "run_rank_percentile",
+) -> tuple[float, str]:
+    """
+    Resolve reference rank percentile with robust fallback.
+
+    Returns:
+    - rank percentile (float)
+    - source ("oracle", "run_fallback", "missing")
+    """
+    if merged_df.empty:
+        return float("nan"), "missing"
+
+    d = merged_df.copy()
+    if "ligand_id" not in d.columns:
+        return float("nan"), "missing"
+    d["ligand_id"] = d["ligand_id"].astype(str)
+    ref = d[d["ligand_id"] == str(reference_ligand_id)]
+    if ref.empty:
+        return float("nan"), "missing"
+
+    if oracle_rank_col in ref.columns:
+        oracle_val = pd.to_numeric(ref[oracle_rank_col], errors="coerce").iloc[0]
+        if np.isfinite(float(oracle_val)):
+            return float(oracle_val), "oracle"
+
+    if run_rank_col in d.columns:
+        run_val = pd.to_numeric(ref[run_rank_col], errors="coerce").iloc[0]
+        if np.isfinite(float(run_val)):
+            return float(run_val), "run_fallback"
+
+    return float("nan"), "missing"
+

libs/benchmark/__init__.py

@@ -0,0 +1,108 @@
+"""Benchmark utilities for large-scale and modality sanity-check runs."""
+
+from .cleanup import CleanupItem, execute_results_cleanup, plan_results_cleanup
+from .budget_efficiency import (
+    TimeImportanceControls,
+    clamp_time_importance,
+    controls_from_time_importance,
+    required_budget_metric_columns,
+    select_best_policy_budget,
+    summarize_diversity,
+    validate_budget_metric_schema,
+)
+from .disk_guard import (
+    DiskCleanupAction,
+    DiskSnapshot,
+    append_disk_snapshot,
+    requires_cleanup,
+    run_repository_local_cleanup,
+    snapshot_disk_state,
+    write_cleanup_actions,
+    write_disk_guard_report,
+)
+from .large_library import build_large_benchmark_library
+from .ordering import cluster_naive_order
+from .policy_repair import (
+    AdaptivePolicyVariant,
+    PolicyRuntimeState,
+    apply_stop_policy,
+    coverage_floor_reached,
+    coverage_fraction,
+    default_policy_variants,
+    effective_controls,
+    regret_stop_variant,
+    select_cluster_bootstrap_batch,
+)
+from .multifidelity import (
+    ExplorationControls,
+    StoppingControls,
+    UncertaintyControls,
+    controls_from_config,
+    enforce_control_limits,
+    simulate_multifidelity_policy,
+)
+from .overnight_stop import (
+    OBJECTIVES,
+    STOP_MODELS,
+    StopModelParams,
+    estimate_marginal_expected_gain,
+    estimate_probability_target_percentile,
+    is_trivial_objective_solution,
+    objective_value,
+    simulate_stop_model,
+)
+from .runtime import AUTO_MINUS_FOUR, ThreadAllocation, detect_system_threads, enforce_thread_fairness, resolve_threads_used
+from .reuse import ReuseCheck, validate_reuse_inputs
+
+__all__ = [
+    "AUTO_MINUS_FOUR",
+    "AdaptivePolicyVariant",
+    "CleanupItem",
+    "DiskCleanupAction",
+    "DiskSnapshot",
+    "PolicyRuntimeState",
+    "TimeImportanceControls",
+    "ThreadAllocation",
+    "ReuseCheck",
+    "apply_stop_policy",
+    "append_disk_snapshot",
+    "build_large_benchmark_library",
+    "clamp_time_importance",
+    "cluster_naive_order",
+    "coverage_floor_reached",
+    "coverage_fraction",
+    "controls_from_time_importance",
+    "default_policy_variants",
+    "detect_system_threads",
+    "effective_controls",
+    "estimate_marginal_expected_gain",
+    "estimate_probability_target_percentile",
+    "enforce_thread_fairness",
+    "execute_results_cleanup",
+    "is_trivial_objective_solution",
+    "objective_value",
+    "OBJECTIVES",
+    "STOP_MODELS",
+    "plan_results_cleanup",
+    "required_budget_metric_columns",
+    "regret_stop_variant",
+    "requires_cleanup",
+    "resolve_threads_used",
+    "run_repository_local_cleanup",
+    "simulate_multifidelity_policy",
+    "simulate_stop_model",
+    "StopModelParams",
+    "StoppingControls",
+    "ExplorationControls",
+    "UncertaintyControls",
+    "controls_from_config",
+    "enforce_control_limits",
+    "validate_reuse_inputs",
+    "select_best_policy_budget",
+    "select_cluster_bootstrap_batch",
+    "snapshot_disk_state",
+    "summarize_diversity",
+    "validate_budget_metric_schema",
+    "write_cleanup_actions",
+    "write_disk_guard_report",
+]