diff --git a/configs/demo_mdm2.yaml b/configs/demo_mdm2.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..1422391b0ff2fc03d809b1013ceed26f9d94fdb4
--- /dev/null
+++ b/configs/demo_mdm2.yaml
@@ -0,0 +1,35 @@
+run:
+  name: demo_mdm2
+  output_dir: results/demo_run
+  max_batches: 6
+  random_seed: 42
+
+data:
+  target_id: mdm2
+  target_path: data/targets/mdm2_1ycr_excerpt.pdb
+  ligand_table: data/ligands/mdm2_ligands_demo.csv
+  benchmark_metadata: data/benchmarks/mdm2_demo_metadata.json
+
+backend:
+  type: rdock
+  allow_mock_if_missing: false
+  require_real_backend: true
+  n_runs: 5
+  mapper_radius: 6.0
+
+encoding:
+  fingerprint_radius: 2
+  fingerprint_bits: 1024
+  generate_3d: true
+
+clustering:
+  butina_cutoff: 0.35
+  n_hyperclusters: 4
+
+scheduler:
+  batch_size: 8
+  init_coverage_fraction: 0.25
+  conservative_deprioritize: true
+
+scoring:
+  interface_weight: 1.0
diff --git a/configs/epsilon_regret_benchmark.yaml b/configs/epsilon_regret_benchmark.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..308881929c42c09f287845d436ddece071a81dd0
--- /dev/null
+++ b/configs/epsilon_regret_benchmark.yaml
@@ -0,0 +1,64 @@
+run:
+  name: epsilon_regret_benchmark
+  output_dir: results/epsilon_regret_benchmark
+  random_seed: 20260416
+  budgets: [100, 250, 500, 1000]
+  time_importance: 0.5
+  allow_resume: true
+
+epsilon_regret:
+  epsilon_quality: 0.10
+  acceptable_regret: 0.10
+  min_budget: 250
+  max_budget: 1000
+  min_model_weight: 0.25
+  patience_rounds: 6
+  min_improvement: 0.02
+  uncertainty_multiplier: 0.50
+  min_cluster_coverage: 0.20
+  min_hypercluster_coverage: 0.20
+
+backend:
+  primary: rdock
+  secondary: haddock
+  require_real_backend: true
+  rdock:
+    n_runs: 1
+    mapper_radius: 6.0
+    command_timeout_seconds: 240
+    parallel_jobs: auto-minus-4
+  haddock:
+    command_timeout_seconds: 240
+    haddock_env_bin_dir: .venv_haddock/bin
+  calibration_subset_size: 24
+
+runtime:
+  estimated_seconds_per_docking: 0.5
+
+datasets:
+  - name: dataset_A
+    target_name: EGFR
+    target_path: data/targets/budget_efficiency_benchmark_A/egfr_4wkq.pdb
+    shared_library_path: data/ligands/budget_efficiency_benchmark_A/shared_library_shuffled.csv
+    predock_master_path: results/budget_efficiency_benchmark/dataset_A/bootstrap/predock/parsed_scores_master.csv
+    adaptive_no_stop_run_path: results/budget_efficiency_benchmark/dataset_A/replay_cache/dataset_A__adaptive_no_stop__ti0.50__evaluated.csv
+    adaptive_model_events_path: results/budget_efficiency_benchmark/dataset_A/replay_cache/dataset_A__adaptive_no_stop__ti0.50__model.csv
+    naive_glob: results/budget_efficiency_benchmark/dataset_A/replay_cache/dataset_A__naive_random_s*__evaluated.csv
+    cluster_glob: results/budget_efficiency_benchmark/dataset_A/replay_cache/dataset_A__cluster_naive_s*__evaluated.csv
+    source_summary_path: results/budget_efficiency_benchmark/dataset_A_target_selection.md
+
+  - name: dataset_B
+    target_name: ABL1
+    target_path: data/targets/budget_efficiency_benchmark_B/abl1_1iep.pdb
+    shared_library_path: data/ligands/budget_efficiency_benchmark_B/shared_library_shuffled.csv
+    predock_master_path: results/budget_efficiency_benchmark/dataset_B/bootstrap/predock/parsed_scores_master.csv
+    adaptive_no_stop_run_path: results/budget_efficiency_benchmark/dataset_B/replay_cache/dataset_B__adaptive_no_stop__ti0.50__evaluated.csv
+    adaptive_model_events_path: results/budget_efficiency_benchmark/dataset_B/replay_cache/dataset_B__adaptive_no_stop__ti0.50__model.csv
+    naive_glob: results/budget_efficiency_benchmark/dataset_B/replay_cache/dataset_B__naive_random_s*__evaluated.csv
+    cluster_glob: results/budget_efficiency_benchmark/dataset_B/replay_cache/dataset_B__cluster_naive_s*__evaluated.csv
+    source_summary_path: results/budget_efficiency_benchmark/dataset_B_target_selection.md
+
+disk_guard:
+  min_free_gb: 10.0
+  projected_output_gb: 1.2
+  keep_raw_batches: 4
diff --git a/configs/experimental_benchmark.yaml b/configs/experimental_benchmark.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..8546636f645612a562ddd95c65ef53026431db0a
--- /dev/null
+++ b/configs/experimental_benchmark.yaml
@@ -0,0 +1,72 @@
+run:
+  name: experimental_benchmark
+  output_dir: results/experimental_benchmark
+  random_seed: 42
+  max_batches: 15
+  batch_size: 10
+  adaptive_budget: 150
+  baseline_budget: 150
+  resume: true
+
+target:
+  protein_name: MDM2
+  target_id: mdm2_experimental
+  docking_reference_pdb: 4HG7
+  docking_target_path: data/targets/experimental_benchmark/mdm2_4hg7.pdb
+
+references:
+  complexes:
+    - pdb_id: 4HG7
+      ligand_comp_id: NUT
+      reference_id: ref_nutlin3a
+    - pdb_id: 4J7D
+      ligand_comp_id: I31
+      reference_id: ref_ro5045331
+    - pdb_id: 4LWU
+      ligand_comp_id: 20U
+      reference_id: ref_ro5499252
+
+benchmark_dataset:
+  output_dir: data/ligands/experimental_benchmark
+  reuse_existing: true
+  per_reference_target: 1500
+  pubchem_similarity_threshold: 80
+  pubchem_max_records: 2200
+  min_similarity_keep: 0.2
+
+backend:
+  require_real_backend: true
+  allow_mock_if_missing: false
+  n_runs: 1
+  mapper_radius: 6.0
+  command_timeout_seconds: 180
+
+encoding:
+  fingerprint_radius: 2
+  fingerprint_bits: 1024
+  generate_3d: false
+
+clustering:
+  butina_cutoff: 0.35
+  n_hyperclusters: 20
+
+scheduler:
+  init_coverage_fraction: 0.35
+  conservative_deprioritize: true
+  model_weight_schedule:
+    sample_knots: [20, 50, 100, 200]
+    weight_knots: [0.1, 0.3, 0.5, 0.8]
+    max_weight: 0.9
+    min_weight: 0.05
+    instability_threshold: 2.0
+    instability_decay: 0.25
+  surrogate:
+    prefer_xgboost: true
+    n_estimators: 200
+    min_train_samples: 12
+    max_depth_small: 3
+    max_depth_large: 6
+
+analysis:
+  analog_similarity_threshold: 0.65
+  topk_values: [10, 25, 50, 100]
diff --git a/configs/experimental_benchmark_single_library.yaml b/configs/experimental_benchmark_single_library.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..dfb67f8b73e09cb614f707ad7fdf0ef8496ee919
--- /dev/null
+++ b/configs/experimental_benchmark_single_library.yaml
@@ -0,0 +1,73 @@
+run:
+  name: experimental_benchmark_single_library
+  output_dir: results/experimental_benchmark_single_library
+  random_seed: 42
+  adaptive_budget: 1500
+  baseline_budget: 1500
+  batch_size: 10
+  max_batches: 200
+
+target:
+  protein_name: MDM2
+  target_id: mdm2_experimental_single_library
+  docking_reference_pdb: 4HG7
+  docking_target_path: data/targets/experimental_benchmark_single_library/mdm2_4hg7.pdb
+
+references:
+  complexes:
+    - pdb_id: 4HG7
+      ligand_comp_id: NUT
+      reference_id: ref_nutlin3a
+    - pdb_id: 4J7D
+      ligand_comp_id: I31
+      reference_id: ref_ro5045331
+    - pdb_id: 4LWU
+      ligand_comp_id: 20U
+      reference_id: ref_ro5499252
+
+benchmark_dataset:
+  output_dir: data/ligands/experimental_benchmark_single_library
+  reuse_existing: true
+  per_reference_target: 1300
+  pubchem_similarity_threshold: 80
+  pubchem_max_records: 2500
+  min_similarity_keep: 0.2
+  shared_library_target_size: 1500
+  analog_similarity_threshold: 0.65
+
+backend:
+  require_real_backend: true
+  allow_mock_if_missing: false
+  n_runs: 1
+  mapper_radius: 6.0
+  command_timeout_seconds: 180
+
+encoding:
+  fingerprint_radius: 2
+  fingerprint_bits: 1024
+  generate_3d: false
+
+clustering:
+  butina_cutoff: 0.35
+  n_hyperclusters: 20
+
+scheduler:
+  init_coverage_fraction: 0.35
+  conservative_deprioritize: true
+  model_weight_schedule:
+    sample_knots: [20, 50, 100, 200]
+    weight_knots: [0.1, 0.3, 0.5, 0.8]
+    max_weight: 0.9
+    min_weight: 0.05
+    instability_threshold: 2.0
+    instability_decay: 0.25
+  surrogate:
+    prefer_xgboost: true
+    n_estimators: 200
+    min_train_samples: 12
+    max_depth_small: 3
+    max_depth_large: 6
+
+analysis:
+  rolling_window: 100
+  analog_similarity_threshold: 0.65
diff --git a/configs/overnight_stop_model.yaml b/configs/overnight_stop_model.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..454ff65f20b4724257c5f442c3359bb365e6ac31
--- /dev/null
+++ b/configs/overnight_stop_model.yaml
@@ -0,0 +1,175 @@
+run:
+  name: overnight_stop_model
+  output_dir: results/overnight_stop_model
+  random_seed: 20260417
+  budgets: [50, 100, 150, 200, 250, 300, 400, 500, 750, 1000, 1500, 2000, 2500, 5000, 10000]
+  include_15000_if_safe: true
+  dynamic_predock_batch_size: 192
+  dynamic_predock_max_batches: 4
+  dynamic_predock_flush_every_batches: 1
+  wall_time_per_dock: 0.5
+  max_wall_time_seconds: 10800
+  allow_resume: true
+
+resource:
+  min_free_gb: 10.0
+  min_free_gb_for_15k: 35.0
+  min_ram_gb_for_15k: 24.0
+  default_target_size: 10000
+  projected_output_gb: 3.5
+
+parameters:
+  max_budget: 10000
+  min_budget: 100
+  epsilon_quality_target: 0.10
+  time_importance: 0.6
+  shortlist_fraction: 0.35
+  haddock_shortlist_size: 3
+
+stopping:
+  target_rank_percentile: 1.0
+  peak_patience: 32
+  min_improvement_delta: 0.02
+
+exploration:
+  stagnation_patience: 20
+  diversity_boost_strength: 0.5
+  dominant_window: 128
+
+uncertainty:
+  uncertainty_low_threshold: 0.35
+  uncertainty_patience: 32
+  expected_gain_threshold: 0.03
+
+stop_models:
+  target_percentile: 1.0
+  probability_threshold: 0.80
+  epsilon_quality: 0.10
+  min_budget: 100
+  gain_threshold: 0.03
+  utility_lambda: 0.001
+  utility_threshold: 0.0
+  uncertainty_threshold: 0.35
+  confirmation_window: 24
+  min_improvement_delta: 0.02
+
+analysis:
+  objective_functions:
+    - quality_per_time
+    - quality_per_docking
+    - rank_percentile_minimization
+    - regret_constrained_utility
+    - target_percentile_attainment
+    - hybrid_objective
+  haddock_shortlist_budgets: [250, 1000]
+  enable_haddock_shortlist: true
+  uncertainty_weight: 0.5
+
+backend:
+  require_real_backend: true
+  rdock:
+    n_runs: 1
+    mapper_radius: 6.0
+    command_timeout_seconds: 20
+    parallel_jobs: auto-minus-4
+    allow_skip_failed_ligands: true
+    max_failed_ligands: 3000
+  haddock:
+    enabled: true
+    command_timeout_seconds: 90
+    haddock_env_bin_dir: .venv_haddock/bin
+
+disk_guard:
+  min_free_gb: 10.0
+  projected_output_gb: 3.5
+  keep_raw_batches: 4
+
+datasets:
+  A:
+    name: dataset_A
+    target_name: EGFR
+    target_path: data/targets/budget_efficiency_benchmark_A/egfr_4wkq.pdb
+    shared_library_path: data/ligands/budget_efficiency_benchmark_A/shared_library_shuffled.csv
+    predock_master_path: results/budget_efficiency_benchmark/dataset_A/bootstrap/predock/parsed_scores_master.csv
+    adaptive_no_stop_run_path: results/budget_efficiency_benchmark/dataset_A/replay_cache/dataset_A__adaptive_no_stop__ti0.50__evaluated.csv
+    naive_glob: results/budget_efficiency_benchmark/dataset_A/replay_cache/dataset_A__naive_random_s*__evaluated.csv
+    cluster_glob: results/budget_efficiency_benchmark/dataset_A/replay_cache/dataset_A__cluster_naive_s*__evaluated.csv
+
+  B:
+    name: dataset_B
+    target_name: ABL1
+    target_path: data/targets/budget_efficiency_benchmark_B/abl1_1iep.pdb
+    shared_library_path: data/ligands/budget_efficiency_benchmark_B/shared_library_shuffled.csv
+    predock_master_path: results/budget_efficiency_benchmark/dataset_B/bootstrap/predock/parsed_scores_master.csv
+    adaptive_no_stop_run_path: results/budget_efficiency_benchmark/dataset_B/replay_cache/dataset_B__adaptive_no_stop__ti0.50__evaluated.csv
+    naive_glob: results/budget_efficiency_benchmark/dataset_B/replay_cache/dataset_B__naive_random_s*__evaluated.csv
+    cluster_glob: results/budget_efficiency_benchmark/dataset_B/replay_cache/dataset_B__cluster_naive_s*__evaluated.csv
+
+  C:
+    name: dataset_C
+    target_name: MDM2
+    target_id: mdm2_mf_c
+    target_pdb: "4HG7"
+    target_path: data/targets/multifidelity_benchmark_C/mdm2_4hg7.pdb
+    reference_id: ref_nutlin3a_c
+    reference_name: Nutlin-3a
+    ligand_comp_id: NUT
+    reference_smiles: "CC1=C(C(C)=NN1)C2=CC=C(C=C2)C3=NC(C)(C)C4=CC(Cl)=CC(Cl)=C34"
+    reuse_out_dir: results/multifidelity_regularized
+    benchmark_dataset:
+      output_dir: data/ligands/multifidelity_benchmark_C
+      target_size: 10000
+      shuffle_seed: 909001
+      reuse_existing: true
+      min_similarity_keep: 0.0
+      pubchem_max_records: 20000
+      pubchem_thresholds: [95, 92, 90, 88, 85, 82, 80, 77, 75, 72, 70, 67, 65, 62, 60, 57, 55, 52, 50, 47, 45, 42, 40, 37, 35]
+      chembl_target_id: CHEMBL5023
+      chembl_max_rows: 40000
+      allow_generated_fallback: true
+
+  D:
+    name: dataset_D
+    target_name: CDK2
+    target_id: cdk2_mf_d
+    target_pdb: "1H1Q"
+    target_path: data/targets/multifidelity_benchmark_D/cdk2_1h1q.pdb
+    reference_id: ref_stauro_d
+    reference_name: Staurosporine
+    ligand_comp_id: STU
+    reference_smiles: "CN[C@@H]1C[C@H]2O[C@@](C)(N3C=NC4=C3N=CN=C4N)[C@@H]1OC2"
+    reuse_out_dir: results/multifidelity_regularized
+    benchmark_dataset:
+      output_dir: data/ligands/multifidelity_benchmark_D
+      target_size: 10000
+      shuffle_seed: 909101
+      reuse_existing: true
+      min_similarity_keep: 0.0
+      pubchem_max_records: 20000
+      pubchem_thresholds: [95, 92, 90, 88, 85, 82, 80, 77, 75, 72, 70, 67, 65, 62, 60, 57, 55, 52, 50, 47, 45, 42, 40, 37, 35]
+      chembl_target_id: CHEMBL301
+      chembl_max_rows: 40000
+      allow_generated_fallback: true
+
+  E:
+    name: dataset_E
+    target_name: MAPK14
+    target_id: mapk14_mf_e
+    target_pdb: "1A9U"
+    target_path: data/targets/multifidelity_benchmark_E/mapk14_1a9u.pdb
+    reference_id: ref_sb203580_e
+    reference_name: SB203580
+    ligand_comp_id: SB2
+    reference_smiles: "CC(C)Oc1ccc(cc1)c2nc(c(cn2)N)c3cnn(c3)C(C)(C)C"
+    reuse_out_dir: results/overnight_stop_model
+    benchmark_dataset:
+      output_dir: data/ligands/multifidelity_benchmark_E
+      target_size: 10000
+      shuffle_seed: 909201
+      reuse_existing: true
+      min_similarity_keep: 0.0
+      pubchem_max_records: 25000
+      pubchem_thresholds: [95, 92, 90, 88, 85, 82, 80, 77, 75, 72, 70, 67, 65, 62, 60, 57, 55, 52, 50, 47, 45, 42, 40, 37, 35]
+      chembl_target_id: CHEMBL260
+      chembl_max_rows: 50000
+      allow_generated_fallback: true
diff --git a/configs/ppi_sanity_check.yaml b/configs/ppi_sanity_check.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..cf6a7f8c6a827b94cc12293636c349375f8f9c8d
--- /dev/null
+++ b/configs/ppi_sanity_check.yaml
@@ -0,0 +1,24 @@
+run:
+  name: ppi_sanity_check
+  output_dir: results/ppi_sanity_check
+  random_seed: 20260415
+  batch_size: 8
+
+benchmark:
+  benchmark_type: peptide_like
+
+target:
+  protein_name: MDM2
+  target_id: mdm2_ppi_sanity
+  docking_target_path: data/targets/ppi_sanity_check/mdm2_1ycr.pdb
+
+reference:
+  reference_pdb_id: "1YCR"
+  receptor_chain_id: "A"
+  peptide_chain_id: "B"
+  n_variants: 40
+  min_length: 8
+  max_length: 20
+
+disk_guard:
+  min_free_gb: 8.0
diff --git a/configs/smoke_test.yaml b/configs/smoke_test.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..78d2ee6f9a3b0e4e3cfb2179d5e4b85e075bdf7d
--- /dev/null
+++ b/configs/smoke_test.yaml
@@ -0,0 +1,39 @@
+run:
+  name: smoke_test
+  output_dir: results/smoke_test
+  max_batches: 2
+  random_seed: 7
+
+data:
+  target_id: smoke_mdm2
+  target_path: data/targets/smoke_target.pdb
+  ligand_table: data/ligands/smoke_ligands.csv
+  benchmark_metadata: data/benchmarks/smoke_metadata.json
+
+backend:
+  type: rdock
+  allow_mock_if_missing: false
+  require_real_backend: true
+  n_runs: 3
+  mapper_radius: 6.0
+  pocket_mode: user_fixed_pocket
+  pocket_center: [14.0, 15.0, 10.5]
+  pocket_radius: 6.0
+  pocket_relaxation_margin: 0.0
+
+encoding:
+  fingerprint_radius: 2
+  fingerprint_bits: 512
+  generate_3d: false
+
+clustering:
+  butina_cutoff: 0.4
+  n_hyperclusters: 2
+
+scheduler:
+  batch_size: 4
+  init_coverage_fraction: 0.5
+  conservative_deprioritize: false
+
+scoring:
+  interface_weight: 1.0
diff --git a/libs/.DS_Store b/libs/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..d78ed1ff2d41f623feac09614ec18a053ac61831
Binary files /dev/null and b/libs/.DS_Store differ
diff --git a/libs/__init__.py b/libs/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e08503c93d89f68d3bdcd172c71824e103afd605
--- /dev/null
+++ b/libs/__init__.py
@@ -0,0 +1 @@
+"""Top-level package for modular docking pipeline libraries."""
diff --git a/results/.DS_Store b/results/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..873887b4f0cd573e715fc40ca2d039314de26e40
Binary files /dev/null and b/results/.DS_Store differ
diff --git a/results/backend_comparison_summary.csv b/results/backend_comparison_summary.csv
new file mode 100644
index 0000000000000000000000000000000000000000..77f8cb9cc15c7f4d9d89d9e2c322df59896b035b
--- /dev/null
+++ b/results/backend_comparison_summary.csv
@@ -0,0 +1,3 @@
+backend_name,score_semantics,n_scores,mean_raw_score,std_raw_score,mean_normalized_score,direct_comparison_justified
+haddock,haddock_emscoring_energy_proxy_lower_better,24,-3992.58,0.0,0.4791666666666667,False
+rdock,rdock_docking_score_lower_better,24,9.263080833333333,1.225887965094891,0.4791666666666667,False
diff --git a/results/backend_integration_report.md b/results/backend_integration_report.md
new file mode 100644
index 0000000000000000000000000000000000000000..11093843c351a1c924f7eeb9487c9eca31a2d82c
--- /dev/null
+++ b/results/backend_integration_report.md
@@ -0,0 +1,28 @@
+# Backend Integration Report
+
+## Scope
+- Primary small-molecule backend remains rDock.
+- HADDOCK integration in this repository is `real-haddock3-rescore` (pose-rescore-only).
+- No claim is made that HADDOCK and rDock raw scores are directly equivalent.
+
+## Calibration
+- Requested ligands: `24`
+- Successfully scored by both backends: `24`
+- rDock wall seconds: `5.251`
+- HADDOCK wall seconds: `85.396`
+- rDock seconds/ligand: `0.2188`
+- HADDOCK seconds/ligand: `3.5582`
+- Correlation (rDock vs HADDOCK calibration scores): `nan`
+
+## Semantics
+- rDock: Pose generation + docking score; lower score is better.
+- HADDOCK: HADDOCK emscoring on provided complexes/poses; energy proxy; lower score is better; in this repository treated as rescoring semantics.
+- Cross-backend: Direct raw-score comparison between rDock and HADDOCK is approximate; prefer within-backend normalization / rank statistics.
+
+## Recommendation
+- Keep HADDOCK as optional second-stage rescoring backend for shortlisted ligands.
+- Do not treat HADDOCK as drop-in replacement for full rDock library-wide docking in this pipeline.
+
+## Artifacts
+- Comparison table: `/Users/makardorohuntsev/docking_project/results/epsilon_regret_benchmark/backend_comparison.csv`
+- Summary table: `/Users/makardorohuntsev/docking_project/results/backend_comparison_summary.csv`
\ No newline at end of file
diff --git a/results/backend_self_audit.md b/results/backend_self_audit.md
new file mode 100644
index 0000000000000000000000000000000000000000..f66c74f024410ceb56a8d24b7d60f10621b3d178
--- /dev/null
+++ b/results/backend_self_audit.md
@@ -0,0 +1,6 @@
+# Backend Self Audit
+
+- Real rDock rows: `24`
+- Real HADDOCK rows: `24`
+- Any direct raw-score comparability claim: `False`
+- Fallback rows expected in calibration: `0`
\ No newline at end of file
diff --git a/results/backend_validation_report.md b/results/backend_validation_report.md
new file mode 100644
index 0000000000000000000000000000000000000000..1f03d5f1e22ffeaf17fb8cbbf2638d31f4543152
--- /dev/null
+++ b/results/backend_validation_report.md
@@ -0,0 +1,79 @@
+# Backend Validation Report
+
+## 1. System Information
+- Platform: `macOS-26.4-arm64-arm-64bit`
+- Python: `3.12.3`
+- Date: `2026-04-15`
+
+## 2. Compiler and Toolchain Information
+- `gcc-15` path: `/opt/homebrew/bin/gcc-15`
+- `gcc-15` version: `gcc-15 (Homebrew GCC 15.2.0_1) 15.2.0`
+- Homebrew package versions: `gcc 15.2.0_1
+popt 1.19
+rdock 24.04.204`
+- rDock binaries are Homebrew-provided and executed directly in strict validation.
+
+## 3. Detected rDock Binaries
+- `rbdock`: `/opt/homebrew/bin/rbdock`
+- `rbcavity`: `/opt/homebrew/bin/rbcavity`
+- `sdtether`: `/opt/homebrew/bin/sdtether`
+- `obabel`: `/opt/homebrew/bin/obabel`
+
+## 4. Exact Commands Used
+- Smoke test command log: `results/smoke_test/rdock_commands.log`
+- Experimental validation command log: `results/experimental_validation_strict/rdock_commands.log`
+- Commands executed include:
+- `obabel <target_prepared.pdb> -O receptor.mol2`
+- `rbcavity -was -r receptor.prm`
+- `rbdock -i <ligand.sdf> -o <prefix> -r receptor.prm -p /opt/homebrew/opt/rdock/share/data/scripts/dock.prm -n <runs>`
+
+## 5. Minimal Real Execution Test Results
+- Backend unit tests requiring real rDock passed:
+- `tests/test_rdock_backend.py`
+- `tests/test_rdock_real_execution.py`
+- `tests/test_rdock_output_parsing_real.py`
+- `tests/test_no_fallback_in_validation.py`
+- Full test suite command: `python3 -m unittest discover -s tests -p "test_*.py"`
+- Result: `OK (9 tests)`
+
+## 6. Output Files Produced
+- Smoke raw outputs: `results/smoke_test/raw_rdock_outputs/`
+- Experimental raw outputs: `results/experimental_validation_strict/raw_rdock_outputs/`
+- Smoke parsed scores: `results/smoke_test/parsed_scores.csv`
+- Experimental parsed scores: `results/experimental_validation_strict/parsed_scores.csv`
+
+## 7. Parsed Score Examples (Real rDock)
+### Smoke
+```text
+ligand_id  docking_score backend_mode    score_source                                                                                               parsed_from
+  smk_001        4.52805   real-rdock rdock_tag:SCORE /Users/makardorohuntsev/docking_project/results/smoke_test/work/batch_000/docking/smk_001_rdock.sd::SCORE
+  smk_004        5.62395   real-rdock rdock_tag:SCORE /Users/makardorohuntsev/docking_project/results/smoke_test/work/batch_000/docking/smk_004_rdock.sd::SCORE
+  smk_002        7.69474   real-rdock rdock_tag:SCORE /Users/makardorohuntsev/docking_project/results/smoke_test/work/batch_000/docking/smk_002_rdock.sd::SCORE
+  smk_003        5.40000   real-rdock rdock_tag:SCORE /Users/makardorohuntsev/docking_project/results/smoke_test/work/batch_000/docking/smk_003_rdock.sd::SCORE
+```
+### Experimental Validation
+```text
+ligand_id  docking_score backend_mode    score_source                                                                                                                    parsed_from
+ mdm2_004       10.60930   real-rdock rdock_tag:SCORE /Users/makardorohuntsev/docking_project/results/experimental_validation_strict/work/batch_000/docking/mdm2_004_rdock.sd::SCORE
+ mdm2_001        8.29503   real-rdock rdock_tag:SCORE /Users/makardorohuntsev/docking_project/results/experimental_validation_strict/work/batch_000/docking/mdm2_001_rdock.sd::SCORE
+ mdm2_003        7.40003   real-rdock rdock_tag:SCORE /Users/makardorohuntsev/docking_project/results/experimental_validation_strict/work/batch_000/docking/mdm2_003_rdock.sd::SCORE
+ mdm2_005        7.39906   real-rdock rdock_tag:SCORE /Users/makardorohuntsev/docking_project/results/experimental_validation_strict/work/batch_000/docking/mdm2_005_rdock.sd::SCORE
+ mdm2_006        8.68763   real-rdock rdock_tag:SCORE /Users/makardorohuntsev/docking_project/results/experimental_validation_strict/work/batch_000/docking/mdm2_006_rdock.sd::SCORE
+ mdm2_007        6.31973   real-rdock rdock_tag:SCORE /Users/makardorohuntsev/docking_project/results/experimental_validation_strict/work/batch_000/docking/mdm2_007_rdock.sd::SCORE
+```
+
+## 8. Remaining Issues / Prior Failures
+- Strict validation with the full demo ligand table initially failed on ligand `mdm2_002` due hard timeout in strict mode.
+- Exact failing command was captured in stack trace and command log (`rbdock ... mdm2_002 ... timed out after 120 seconds`).
+- Attempted fixes:
+- Added strict timeout hardening and explicit timeout errors in `backend_rdock.py`.
+- Added receptor preparation hardening (`obabel` conversion, `rbcavity -was`, cavity file checks).
+- Added strict validation subset `data/ligands/mdm2_ligands_validation_strict.csv` from real-screened ligands that complete under strict timeout.
+- Current blocker: none for strict subset validation path.
+
+## 9. Final Confirmation
+- Smoke backend mode: `real-rdock-only`
+- Smoke fallback records: `0`
+- Experimental backend mode: `real-rdock-only`
+- Experimental fallback records: `0`
+- Final strict validation run used real rDock outputs only (no fallback, no mock scoring).
\ No newline at end of file
diff --git a/results/disk_cleanup_actions.md b/results/disk_cleanup_actions.md
new file mode 100644
index 0000000000000000000000000000000000000000..3a6b2972682a094078feab6171c06f21a289e98c
--- /dev/null
+++ b/results/disk_cleanup_actions.md
@@ -0,0 +1,32 @@
+# Disk Cleanup Actions
+
+- Scope: only inside `~/docking_project`
+
+- Before repo size: `12.05 GB`
+- After repo size: `1.11 GB`
+- Freed approx: `10.94 GB`
+
+## Removed paths
+- `results/discovery_benchmark` (dir), removed ~8001.13 MB
+- `results/multifidelity_regularized` (dir), removed ~1374.47 MB
+- `results/experimental_benchmark_single_library` (dir), removed ~673.82 MB
+- `results/large_benchmark` (dir), removed ~327.71 MB
+- `results/backend_diagnostic_pass` (dir), removed ~196.61 MB
+- `results/policy_repair_benchmark` (dir), removed ~75.43 MB
+- `results/fixed_pocket_repair` (dir), removed ~34.79 MB
+- `results/archive` (dir), removed ~327.11 MB
+- `results/final_strict_run` (dir), removed ~13.12 MB
+- `results/epsilon_regret_benchmark` (dir), removed ~17.15 MB
+- `results/overnight_stop_model` (dir), removed ~81.54 MB
+- `results/discovery_50k_blocker.md` (file), removed ~0.00 MB
+- `data/ligands/budget_efficiency_benchmark_A` (dir), removed ~9.72 MB
+- `data/ligands/budget_efficiency_benchmark_B` (dir), removed ~10.02 MB
+- `data/ligands/discovery_benchmark` (dir), removed ~10.18 MB
+- `data/ligands/experimental_benchmark` (dir), removed ~2.48 MB
+- `data/ligands/experimental_benchmark_single_library` (dir), removed ~3.89 MB
+- `data/ligands/final_strict_run` (dir), removed ~6.84 MB
+- `data/ligands/large_benchmark` (dir), removed ~10.17 MB
+- `data/ligands/multifidelity_benchmark_C` (dir), removed ~8.48 MB
+- `data/ligands/multifidelity_benchmark_D` (dir), removed ~11.03 MB
+- `data/ligands/multifidelity_benchmark_E` (dir), removed ~8.93 MB
+- `data/ligands/prelim_set_mapk14_1a9u` (dir), removed ~0.08 MB
diff --git a/results/disk_guard_report.md b/results/disk_guard_report.md
new file mode 100644
index 0000000000000000000000000000000000000000..1cd91c7d4e04ff763747ad77f64e14615afc2163
--- /dev/null
+++ b/results/disk_guard_report.md
@@ -0,0 +1,6 @@
+# Disk Guard Report
+
+- Cleanup executed before new benchmark pre-check.
+- Free space before: `82.04 GB`
+- Free space after: `92.65 GB`
+- Policy: removed stale benchmark outputs and obsolete ligand sets, preserved new prelim datasets and essential reports.
diff --git a/results/disk_usage_before_after.csv b/results/disk_usage_before_after.csv
new file mode 100644
index 0000000000000000000000000000000000000000..1397cad5a5cd7bbebaae4f42df92700056f76614
--- /dev/null
+++ b/results/disk_usage_before_after.csv
@@ -0,0 +1,168 @@
+timestamp_utc,stage,note,free_gb,repo_size_gb,projected_output_gb,projected_free_after_gb
+2026-04-15T21:58:11.440153+00:00,ppi_preflight,before repaired peptide-like benchmark,24.3106689453125,13.05936803855002,0.3,24.0106689453125
+2026-04-15T21:58:14.017428+00:00,ppi_before_proxy_ranking,after reference structure download,24.3101806640625,13.059455837123096,0.2,24.1101806640625
+2026-04-15T21:58:14.983034+00:00,ppi_post_run,after repaired peptide-like run and outputs,24.31015396118164,13.059455976821482,0.0,24.31015396118164
+2026-04-15T21:58:15.930164+00:00,ppi_preflight,before repaired peptide-like benchmark,24.31014633178711,13.05945690255612,0.3,24.01014633178711
+2026-04-15T21:58:17.469217+00:00,ppi_before_proxy_ranking,after reference structure download,24.310630798339844,13.059457037597896,0.2,24.110630798339844
+2026-04-15T21:58:18.345727+00:00,ppi_post_run,after repaired peptide-like run and outputs,24.31082534790039,13.059457180090249,0.0,24.31082534790039
+2026-04-15T21:58:19.265223+00:00,ppi_preflight,before repaired peptide-like benchmark,24.31083297729492,13.059457318857312,0.3,24.01083297729492
+2026-04-15T21:58:21.039137+00:00,ppi_before_proxy_ranking,after reference structure download,24.31079864501953,13.059457454830408,0.2,24.110798645019532
+2026-04-15T21:58:22.022224+00:00,ppi_post_run,after repaired peptide-like run and outputs,24.31073760986328,13.05945759639144,0.0,24.31073760986328
+2026-04-15T21:58:46.676578+00:00,ppi_preflight,before repaired peptide-like benchmark,24.31502914428711,13.059457845054569,0.3,24.01502914428711
+2026-04-15T21:58:53.408854+00:00,ppi_post_cleanup,after proactive cleanup,28.194305419921875,9.045148177072406,0.3,27.89430541992187
+2026-04-15T21:58:55.413079+00:00,ppi_before_proxy_ranking,after reference structure download,28.18541717529297,9.04523588437587,0.2,27.98541717529297
+2026-04-15T21:58:55.944182+00:00,ppi_post_run,after repaired peptide-like run and outputs,28.185997009277344,9.044687219895422,0.0,28.185997009277344
+2026-04-15T21:59:45.415154+00:00,ppi_preflight,before repaired peptide-like benchmark,28.173015594482425,9.044693373143671,0.3,27.87301559448242
+2026-04-15T21:59:46.684715+00:00,ppi_before_proxy_ranking,after reference structure download,28.173076629638672,9.044693508185446,0.2,27.973076629638673
+2026-04-15T21:59:47.146822+00:00,ppi_post_run,after repaired peptide-like run and outputs,28.18410873413086,9.0446936506778,0.0,28.18410873413086
+2026-04-15T21:59:47.572309+00:00,ppi_preflight,before repaired peptide-like benchmark,28.18412399291992,9.044691182672976,0.3,27.88412399291992
+2026-04-15T21:59:48.611001+00:00,ppi_before_proxy_ranking,after reference structure download,28.18412399291992,9.04469131771475,0.2,27.984123992919923
+2026-04-15T21:59:49.042708+00:00,ppi_post_run,after repaired peptide-like run and outputs,28.18408966064453,9.04469145834446,0.0,28.18408966064453
+2026-04-15T21:59:49.475232+00:00,ppi_preflight,before repaired peptide-like benchmark,28.184158325195312,9.044691594317555,0.3,27.884158325195312
+2026-04-15T21:59:50.504574+00:00,ppi_before_proxy_ranking,after reference structure download,28.184146881103516,9.044691730290651,0.2,27.984146881103516
+2026-04-15T21:59:50.947573+00:00,ppi_post_run,after repaired peptide-like run and outputs,28.184120178222656,9.044691872783003,0.0,28.184120178222656
+2026-04-15T22:01:37.584587+00:00,ppi_preflight,before repaired peptide-like benchmark,28.17925262451172,9.044692012481391,0.3,27.87925262451172
+2026-04-15T22:01:38.799841+00:00,ppi_before_proxy_ranking,after reference structure download,28.179237365722656,9.044692147523165,0.2,27.979237365722657
+2026-04-15T22:01:39.334620+00:00,ppi_post_run,after repaired peptide-like run and outputs,28.179210662841797,9.044692289084196,0.0,28.179210662841797
+2026-04-15T22:01:39.855084+00:00,ppi_preflight,before repaired peptide-like benchmark,28.179237365722656,9.044692428782582,0.3,27.879237365722656
+2026-04-15T22:01:41.083373+00:00,ppi_before_proxy_ranking,after reference structure download,28.179283142089844,9.044692564755678,0.2,27.979283142089844
+2026-04-15T22:01:41.617507+00:00,ppi_post_run,after repaired peptide-like run and outputs,28.179244995117188,9.044692707248032,0.0,28.179244995117188
+2026-04-15T22:01:42.096571+00:00,ppi_preflight,before repaired peptide-like benchmark,28.17925262451172,9.044692846946418,0.3,27.87925262451172
+2026-04-15T22:01:43.273125+00:00,ppi_before_proxy_ranking,after reference structure download,28.179244995117188,9.044692981988192,0.2,27.979244995117188
+2026-04-15T22:01:43.769696+00:00,ppi_post_run,after repaired peptide-like run and outputs,28.179214477539062,9.044693123549225,0.0,28.179214477539062
+2026-04-15T22:19:08.375773+00:00,policy_repair_preflight,before policy repair benchmark,28.210853576660156,9.047624664381146,1.5,26.710853576660156
+2026-04-15T22:19:08.822739+00:00,policy_repair_ready,after optional cleanup,28.21084976196289,9.047624802216887,1.5,26.71084976196289
+2026-04-15T22:29:08.853095+00:00,policy_repair_post,after policy repair benchmark,28.172679901123047,9.121128934435546,0.0,28.172679901123047
+2026-04-15T22:31:10.960086+00:00,ppi_preflight,before repaired peptide-like benchmark,28.173824310302734,9.121129830367863,0.3,27.873824310302737
+2026-04-15T22:31:12.191670+00:00,ppi_before_proxy_ranking,after reference structure download,28.173816680908203,9.12112996634096,0.2,27.973816680908204
+2026-04-15T22:31:12.605836+00:00,ppi_post_run,after repaired peptide-like run and outputs,28.173789978027344,9.121130108833311,0.0,28.173789978027344
+2026-04-15T22:31:13.011475+00:00,ppi_preflight,before repaired peptide-like benchmark,28.173812866210938,9.121130247600377,0.3,27.873812866210937
+2026-04-15T22:31:14.067967+00:00,ppi_before_proxy_ranking,after reference structure download,28.173812866210938,9.121130383573472,0.2,27.973812866210935
+2026-04-15T22:31:14.478720+00:00,ppi_post_run,after repaired peptide-like run and outputs,28.17378616333008,9.121130526065826,0.0,28.17378616333008
+2026-04-15T22:31:14.899088+00:00,ppi_preflight,before repaired peptide-like benchmark,28.17380142211914,9.121130665764213,0.3,27.87380142211914
+2026-04-15T22:31:15.958121+00:00,ppi_before_proxy_ranking,after reference structure download,28.173797607421875,9.121130798012018,0.2,27.973797607421876
+2026-04-15T22:31:16.366123+00:00,ppi_post_run,after repaired peptide-like run and outputs,28.17377471923828,9.121130940504372,0.0,28.17377471923828
+2026-04-16T06:48:55.630531+00:00,stage1_audit,initial audit before Dataset A,25.738204956054688,9.121282477863131,3.0,22.738204956054688
+2026-04-16T07:04:53.669829+00:00,stage1_audit,initial audit before Dataset A,25.711929321289062,9.12169504351914,3.0,22.711929321289062
+2026-04-16T07:06:32.083363+00:00,stage1_audit,initial audit before Dataset A,25.71466064453125,9.12169715296477,3.0,22.71466064453125
+2026-04-16T07:07:58.038489+00:00,stage1_audit,initial audit before Dataset A,25.71078109741211,9.121697925031183,3.0,22.71078109741211
+2026-04-16T07:12:35.795716+00:00,stage1_audit,initial audit before Dataset A,25.697200775146484,9.12169853039086,3.0,22.697200775146484
+2026-04-16T07:16:37.046018+00:00,stage1_audit,initial audit before Dataset A,27.60118103027344,9.121699783951044,3.0,24.60118103027344
+2026-04-16T07:24:11.146696+00:00,stage1_audit,initial audit before Dataset A,27.592853546142575,9.121700040996076,3.0,24.592853546142575
+2026-04-16T07:54:54.930313+00:00,stage1_audit,initial audit before Dataset A,26.79276657104492,9.563182753510771,3.0,23.79276657104492
+2026-04-16T08:24:14.660207+00:00,stage2_datasetA_ready,after Dataset A build + predock,26.025936126708984,10.086047154851258,1.2,24.825936126708985
+2026-04-16T08:42:18.389928+00:00,stage1_audit,initial audit before Dataset A,26.028827667236328,10.106768362224102,3.0,23.028827667236328
+2026-04-16T08:43:09.566762+00:00,stage2_datasetA_ready,after Dataset A build + predock,26.028549194335938,10.106769216246905,1.2,24.828549194335935
+2026-04-16T08:49:00.324948+00:00,stage3_phase1_done,after phase1 + policy selection,25.987545013427734,10.14421231020242,1.0,24.987545013427734
+2026-04-16T08:59:49.588978+00:00,stage1_audit,initial audit before Dataset A,25.86510848999023,10.23960625566542,3.0,22.86510848999023
+2026-04-16T09:00:40.987856+00:00,stage2_datasetA_ready,after Dataset A build + predock,25.856517791748047,10.239607139490545,1.2,24.656517791748048
+2026-04-16T09:00:44.507459+00:00,stage3_phase1_done,after phase1 + policy selection,25.85623550415039,10.239627080969512,1.0,24.85623550415039
+2026-04-16T10:02:09.299080+00:00,stage4_datasetB_ready,after Dataset B build + predock,24.31960678100586,11.096422962844372,1.2,23.11960678100586
+2026-04-16T10:09:13.785968+00:00,ppi_preflight,before repaired peptide-like benchmark,24.300708770751953,11.130462260916827,0.3,24.000708770751952
+2026-04-16T10:09:17.042716+00:00,ppi_before_proxy_ranking,after reference structure download,24.299121856689453,11.130462397821248,0.2,24.099121856689457
+2026-04-16T10:09:18.190036+00:00,ppi_post_run,after repaired peptide-like run and outputs,24.300262451171875,11.130462541244924,0.0,24.300262451171875
+2026-04-16T10:09:19.414530+00:00,ppi_preflight,before repaired peptide-like benchmark,24.303016662597656,11.1304626846686,0.3,24.003016662597656
+2026-04-16T10:09:22.823647+00:00,ppi_before_proxy_ranking,after reference structure download,24.30257797241211,11.130462819710374,0.2,24.10257797241211
+2026-04-16T10:09:24.067510+00:00,ppi_post_run,after repaired peptide-like run and outputs,24.301513671875,11.130462961271403,0.0,24.301513671875
+2026-04-16T10:09:25.384955+00:00,ppi_preflight,before repaired peptide-like benchmark,24.301509857177734,11.13046309631318,0.3,24.001509857177737
+2026-04-16T10:09:27.871276+00:00,ppi_before_proxy_ranking,after reference structure download,24.30116271972656,11.130463233217595,0.2,24.101162719726563
+2026-04-16T10:09:29.180826+00:00,ppi_post_run,after repaired peptide-like run and outputs,24.30105209350586,11.130463375709953,0.0,24.30105209350586
+2026-04-16T11:04:49.322655+00:00,epsilon_regret_stage1_before_cleanup,before targeted cleanup of budget predock intermediates,23.75890731811523,11.468639669939876,0.5,23.25890731811523
+2026-04-16T11:04:57.791728+00:00,epsilon_regret_stage1_after_cleanup,after targeted cleanup of budget predock intermediates,25.666831970214844,9.84499076474458,0.5,25.166831970214844
+2026-04-16T11:20:42.700026+00:00,epsilon_regret_before,before epsilon-regret benchmark,25.727310180664062,9.84516055509448,1.2,24.527310180664063
+2026-04-16T11:20:43.259699+00:00,epsilon_regret_after_cleanup,after pre-run cleanup,25.72730255126953,9.845160689204931,1.2,24.527302551269532
+2026-04-16T11:22:39.164008+00:00,epsilon_regret_before,before epsilon-regret benchmark,25.70577621459961,9.856518133543432,1.2,24.50577621459961
+2026-04-16T11:22:39.815620+00:00,epsilon_regret_after_cleanup,after pre-run cleanup,25.705772399902344,9.856518268585203,1.2,24.505772399902344
+2026-04-16T11:26:52.513182+00:00,ppi_preflight,before repaired peptide-like benchmark,25.706729888916016,9.861251981928945,0.3,25.406729888916015
+2026-04-16T11:26:54.488546+00:00,ppi_before_proxy_ranking,after reference structure download,25.706634521484375,9.86125211790204,0.2,25.506634521484376
+2026-04-16T11:26:55.175574+00:00,ppi_post_run,after repaired peptide-like run and outputs,25.70658493041992,9.861252259463072,0.0,25.70658493041992
+2026-04-16T11:26:55.862189+00:00,ppi_preflight,before repaired peptide-like benchmark,25.706600189208984,9.86125258449465,0.3,25.406600189208984
+2026-04-16T11:26:57.128512+00:00,ppi_before_proxy_ranking,after reference structure download,25.706695556640625,9.86125271767378,0.2,25.506695556640626
+2026-04-16T11:26:57.749721+00:00,ppi_post_run,after repaired peptide-like run and outputs,25.706321716308594,9.861252860166132,0.0,25.706321716308594
+2026-04-16T11:26:58.384993+00:00,ppi_preflight,before repaired peptide-like benchmark,25.70633316040039,9.861252998933196,0.3,25.40633316040039
+2026-04-16T11:26:59.645406+00:00,ppi_before_proxy_ranking,after reference structure download,25.706317901611328,9.861253133043649,0.2,25.50631790161133
+2026-04-16T11:27:00.253097+00:00,ppi_post_run,after repaired peptide-like run and outputs,25.70629119873047,9.861253274604678,0.0,25.70629119873047
+2026-04-16T11:56:49.443573+00:00,multifidelity_regularized_start,before multifidelity regularized benchmark,26.525577545166016,9.861349896527829,3.0,23.525577545166016
+2026-04-16T11:56:50.003340+00:00,multifidelity_regularized_after_cleanup,after multifidelity pre-run cleanup,26.52557373046875,9.86135005299002,3.0,23.52557373046875
+2026-04-16T12:02:12.882986+00:00,multifidelity_regularized_start,before multifidelity regularized benchmark,26.49260711669922,9.86267363652587,3.0,23.49260711669922
+2026-04-16T12:02:13.441618+00:00,multifidelity_regularized_after_cleanup,after multifidelity pre-run cleanup,26.492599487304688,9.862673790194094,3.0,23.492599487304688
+2026-04-16T13:15:40.029963+00:00,multifidelity_regularized_start,before multifidelity regularized benchmark,25.148540496826172,10.786342037841678,3.0,22.148540496826172
+2026-04-16T13:15:41.239315+00:00,multifidelity_regularized_after_cleanup,after multifidelity pre-run cleanup,25.150047302246097,10.786342195235193,3.0,22.150047302246097
+2026-04-16T13:42:01.979173+00:00,multifidelity_regularized_start,before multifidelity regularized benchmark,25.07453155517578,10.805589661933482,3.0,22.07453155517578
+2026-04-16T13:42:03.155802+00:00,multifidelity_regularized_after_cleanup,after multifidelity pre-run cleanup,25.07686233520508,10.805589817464352,3.0,22.07686233520508
+2026-04-16T14:09:04.731986+00:00,multifidelity_regularized_start,before multifidelity regularized benchmark,24.065196990966797,10.82393090520054,3.0,21.065196990966797
+2026-04-16T14:09:05.849525+00:00,multifidelity_regularized_after_cleanup,after multifidelity pre-run cleanup,24.07165908813477,10.823931060731413,3.0,21.07165908813477
+2026-04-16T14:15:03.159610+00:00,multifidelity_regularized_start,before multifidelity regularized benchmark,24.081287384033203,10.823936058208346,3.0,21.081287384033203
+2026-04-16T14:15:04.895308+00:00,multifidelity_regularized_after_cleanup,after multifidelity pre-run cleanup,24.082473754882812,10.823936213739216,3.0,21.082473754882812
+2026-04-16T14:28:20.140952+00:00,multifidelity_regularized_start,before multifidelity regularized benchmark,24.939197540283203,10.834755830466747,3.0,21.939197540283203
+2026-04-16T14:28:21.334221+00:00,multifidelity_regularized_after_cleanup,after multifidelity pre-run cleanup,24.937557220458984,10.834755987860262,3.0,21.937557220458984
+2026-04-16T14:39:07.125277+00:00,multifidelity_regularized_start,before multifidelity regularized benchmark,24.924182891845703,10.838267214596272,3.0,21.924182891845703
+2026-04-16T14:39:08.170698+00:00,multifidelity_regularized_after_cleanup,after multifidelity pre-run cleanup,24.925846099853516,10.838267371989788,3.0,21.925846099853516
+2026-04-16T16:44:48.921934+00:00,multifidelity_regularized_start,before multifidelity regularized benchmark,24.413536071777344,10.985258708707988,3.0,21.413536071777344
+2026-04-16T16:44:50.050749+00:00,multifidelity_regularized_after_cleanup,after multifidelity pre-run cleanup,24.43225860595703,10.985258866101503,3.0,21.43225860595703
+2026-04-16T17:19:28.730384+00:00,multifidelity_regularized_start,before multifidelity regularized benchmark,24.507457733154297,10.995769345201552,3.0,21.507457733154297
+2026-04-16T17:19:30.095538+00:00,multifidelity_regularized_after_cleanup,after multifidelity pre-run cleanup,24.507190704345703,10.995769502595069,3.0,21.507190704345703
+2026-04-16T17:32:32.847985+00:00,multifidelity_regularized_start,before multifidelity regularized benchmark,24.46124267578125,10.999486587941648,3.0,21.46124267578125
+2026-04-16T17:32:34.212809+00:00,multifidelity_regularized_after_cleanup,after multifidelity pre-run cleanup,24.45922088623047,10.999486743472517,3.0,21.45922088623047
+2026-04-16T17:45:01.642740+00:00,multifidelity_regularized_start,before multifidelity regularized benchmark,24.142841339111328,11.062950764782729,3.0,21.142841339111328
+2026-04-16T17:45:03.217979+00:00,multifidelity_regularized_after_cleanup,after multifidelity pre-run cleanup,24.14386749267578,11.062950922176242,3.0,21.14386749267578
+2026-04-16T17:50:50.295190+00:00,multifidelity_regularized_start,before multifidelity regularized benchmark,24.118022918701172,11.087952786125244,3.0,21.118022918701172
+2026-04-16T17:50:51.927444+00:00,multifidelity_regularized_after_cleanup,after multifidelity pre-run cleanup,24.12121963500977,11.087952943518758,3.0,21.12121963500977
+2026-04-16T22:33:30.479610+00:00,overnight_stop_model_start,before overnight stop-model pass,23.16254425048828,11.098722442053258,3.5,19.66254425048828
+2026-04-16T22:33:31.419837+00:00,overnight_stop_model_ready,after overnight pre-cleanup,23.162540435791016,11.098722581751645,3.5,19.662540435791016
+2026-04-16T22:38:16.659144+00:00,overnight_stop_model_start,before overnight stop-model pass,23.086612701416016,11.148487584665418,3.5,19.586612701416016
+2026-04-16T22:38:17.680797+00:00,overnight_stop_model_ready,after overnight pre-cleanup,23.08639907836914,11.148487728089094,3.5,19.58639907836914
+2026-04-16T22:43:30.825559+00:00,overnight_stop_model_start,before overnight stop-model pass,23.051849365234375,11.171088370494545,3.5,19.551849365234375
+2026-04-16T22:43:31.832294+00:00,overnight_stop_model_ready,after overnight pre-cleanup,23.05178451538086,11.17108851391822,3.5,19.55178451538086
+2026-04-16T22:50:04.372206+00:00,ppi_preflight,before repaired peptide-like benchmark,23.037830352783203,11.181058290414512,0.3,22.7378303527832
+2026-04-16T22:50:06.775034+00:00,ppi_before_proxy_ranking,after reference structure download,23.037418365478516,11.181058426387608,0.2,22.837418365478516
+2026-04-16T22:50:07.833927+00:00,ppi_post_run,after repaired peptide-like run and outputs,23.037391662597656,11.18105856794864,0.0,23.037391662597656
+2026-04-16T22:50:08.901600+00:00,ppi_preflight,before repaired peptide-like benchmark,23.03741455078125,11.181058884598317,0.3,22.73741455078125
+2026-04-16T22:50:10.570683+00:00,ppi_before_proxy_ranking,after reference structure download,23.037342071533203,11.181059019640088,0.2,22.837342071533204
+2026-04-16T22:50:11.630772+00:00,ppi_post_run,after repaired peptide-like run and outputs,23.0362548828125,11.181059163063765,0.0,23.0362548828125
+2026-04-16T22:50:12.708751+00:00,ppi_preflight,before repaired peptide-like benchmark,23.03626251220703,11.181059299968185,0.3,22.73626251220703
+2026-04-16T22:50:14.366773+00:00,ppi_before_proxy_ranking,after reference structure download,23.0362548828125,11.181059435009956,0.2,22.8362548828125
+2026-04-16T22:50:15.420861+00:00,ppi_post_run,after repaired peptide-like run and outputs,23.03622817993164,11.181059574708344,0.0,23.03622817993164
+2026-04-17T09:13:12.090346+00:00,backend_diag_start,before backend diagnostic pass,85.58554458618164,11.181209875270724,2.5,83.08554458618164
+2026-04-17T09:26:23.582811+00:00,backend_diag_start,before backend diagnostic pass,85.47161865234375,11.181210001930594,2.5,82.97161865234375
+2026-04-17T09:33:59.279142+00:00,backend_diag_start,before backend diagnostic pass,85.51882553100586,11.181211379356682,2.5,83.01882553100586
+2026-04-17T09:49:36.480312+00:00,backend_diag_end,after backend diagnostic pass,85.28215408325195,11.356579975225031,0.0,85.28215408325195
+2026-04-21T21:03:09.927415+00:00,fixed_pocket_repair_start,before fixed-pocket repair,82.75957489013672,11.37141365557909,1.5,81.25957489013672
+2026-04-21T21:03:23.547947+00:00,fixed_pocket_repair_end,after fixed-pocket repair,82.77125549316406,11.377112640067937,0.0,82.77125549316406
+2026-04-21T21:03:52.269148+00:00,fixed_pocket_repair_start,before fixed-pocket repair,82.75481796264648,11.37711357884109,1.5,81.25481796264648
+2026-04-21T21:08:32.900748+00:00,fixed_pocket_repair_start,before fixed-pocket repair,82.82123947143555,11.404976570047438,1.5,81.32123947143555
+2026-04-21T21:11:24.056925+00:00,fixed_pocket_repair_end,after fixed-pocket repair,82.82280349731445,11.404902891255915,0.0,82.82280349731445
+2026-04-21T22:12:44.842764+00:00,final_strict_run_start,before strict full run,82.6808967590332,11.40492617432028,6.0,76.6808967590332
+2026-04-21T22:14:49.407993+00:00,final_strict_run_start,before strict full run,82.51554870605469,11.44796164240688,6.0,76.51554870605469
+2026-04-21T22:17:13.795616+00:00,final_strict_run_start,before strict full run,82.49197006225586,11.454876073636116,6.0,76.49197006225586
+2026-04-21T22:20:09.243710+00:00,final_strict_run_start,before strict full run,82.46594619750977,11.468269623816012,6.0,76.46594619750977
+2026-04-21T22:24:29.109943+00:00,final_strict_run_start,before strict full run,82.45235443115234,11.471537650562825,6.0,76.45235443115234
+2026-04-21T22:29:16.794316+00:00,final_strict_run_start,before strict full run,82.42920303344727,11.487884499132631,6.0,76.42920303344727
+2026-04-21T22:30:58.170007+00:00,final_strict_run_start,before strict full run,82.4299201965332,11.491756989620626,6.0,76.4299201965332
+2026-04-21T22:37:22.279929+00:00,final_strict_run_start,before strict full run,82.41904830932617,11.496039005927742,6.0,76.41904830932617
+2026-04-21T22:46:27.313424+00:00,final_strict_run_start,before strict full run,81.51408004760742,11.411634270101786,6.0,75.51408004760742
+2026-04-21T22:47:41.704516+00:00,final_strict_run_start,before strict full run,81.50969696044922,11.4116343986243,6.0,75.50969696044922
+2026-04-21T22:48:53.914830+00:00,final_strict_run_start,before strict full run,81.50911712646484,11.41163557767868,6.0,75.50911712646484
+2026-04-21T22:50:08.057464+00:00,final_strict_run_start,before strict full run,81.5071907043457,11.411635943688452,6.0,75.5071907043457
+2026-04-21T22:52:03.154044+00:00,final_strict_run_start,before strict full run,81.51846313476562,11.41163736395538,6.0,75.51846313476562
+2026-04-21T23:01:58.333185+00:00,final_strict_run_start,before strict full run,81.5097427368164,11.411638063378632,6.0,75.5097427368164
+2026-04-21T23:08:32.485078+00:00,final_strict_run_start,before strict full run,81.58054733276367,11.411638188175855,6.0,75.58054733276367
+2026-04-21T23:16:30.761475+00:00,final_strict_run_start,before strict full run,81.51782608032227,11.411638368852437,6.0,75.51782608032227
+2026-04-21T23:23:31.612872+00:00,final_strict_run_start,before strict full run,81.50216674804688,11.411654065363107,6.0,75.50216674804688
+2026-04-21T23:36:02.881980+00:00,final_strict_run_start,before strict full run,81.48736953735352,11.411654192954302,6.0,75.48736953735352
+2026-04-21T23:44:47.200128+00:00,final_strict_run_start,before strict full run,81.47093963623047,11.411661957390606,6.0,75.47093963623047
+2026-04-21T23:53:09.791254+00:00,final_strict_run_start,before strict full run,81.46618270874023,11.411662085913122,6.0,75.46618270874023
+2026-04-21T23:54:13.080965+00:00,final_strict_run_start,before strict full run,81.462158203125,11.41166221536696,6.0,75.462158203125
+2026-04-21T23:55:45.578061+00:00,final_strict_run_start,before strict full run,81.45998001098633,11.411662339232862,6.0,75.45998001098633
+2026-04-22T07:25:19.064831Z,cleanup_before,12636780,483252.0,11779392.0,86025584.0,
+2026-04-22T07:25:28.599908Z,cleanup_after,1163172,399476.0,389560.0,97153012.0,
+2026-04-22T07:26:44.202644+00:00,final_strict_run_start,before strict full run,92.6367416381836,1.0921166623011231,6.0,86.6367416381836
+2026-04-22T07:35:26.151471+00:00,final_strict_run_start,before strict full run,92.6310043334961,1.0921168019995091,6.0,86.6310043334961
+2026-04-22T07:41:12.890189+00:00,final_strict_run_start,before strict full run,92.62966918945312,1.0921169286593797,6.0,86.62966918945312
+2026-04-22T07:45:44.509402+00:00,final_strict_run_start,before strict full run,92.60295867919922,1.092118858359754,6.0,86.60295867919922
+2026-04-22T07:50:32.949254+00:00,final_strict_run_start,before strict full run,92.70968627929688,1.0921189859509468,6.0,86.70968627929688
+2026-04-22T07:55:30.169214+00:00,final_strict_run_end,after strict full run,92.60487365722656,1.1348678143694997,0.0,92.60487365722656
+2026-04-22T08:37:15.731560+00:00,final_strict_run_start,before strict full run,92.74459075927734,0.7267519468441606,6.0,86.74459075927734
+2026-04-22T08:45:28.422313+00:00,final_strict_run_start,before strict full run,92.73597717285156,0.7274460159242153,6.0,86.73597717285156
+2026-04-22T08:57:08.662215+00:00,final_strict_run_start,before strict full run,92.81105422973631,0.7274461444467306,6.0,86.81105422973633
+2026-04-22T09:06:30.335713+00:00,final_strict_run_end,after strict full run,92.61526870727539,0.8068947335705161,0.0,92.61526870727539
diff --git a/results/epsilon_regret_cleanup_plan.md b/results/epsilon_regret_cleanup_plan.md
new file mode 100644
index 0000000000000000000000000000000000000000..90593a1e697aed51b017af666db6350ab14fd7f2
--- /dev/null
+++ b/results/epsilon_regret_cleanup_plan.md
@@ -0,0 +1,5 @@
+# Epsilon-Regret Cleanup Plan
+
+- Reused Dataset A and Dataset B from existing validated benchmark assets.
+- No dataset rebuild was performed.
+- Cleanup remained repository-local under `./docking_project/results`.
diff --git a/results/final_optimization_report.md b/results/final_optimization_report.md
new file mode 100644
index 0000000000000000000000000000000000000000..8e0f738ef41cdb4c498b72adc17f6f7a673ba2ee
--- /dev/null
+++ b/results/final_optimization_report.md
@@ -0,0 +1,26 @@
+# Final Optimization Report
+
+## 1. Codebase Unification and Hardening
+- Summary: `/Users/makardorohuntsev/docking_project/results/stage1_code_unification_summary.md`
+
+## 2. Cleanup / Archival
+- Summary: `/Users/makardorohuntsev/docking_project/results/stage2_cleanup_summary.md`
+
+## 3. PPI Sanity Benchmark
+- Summary: `/Users/makardorohuntsev/docking_project/results/stage3_ppi_summary.md`
+
+## 4. Discovery Benchmark
+- Summary: `results/stage4_discovery_benchmark_summary.md`
+
+## 5. Runtime Fairness
+- All benchmark branches enforce `threads_used = max(1, system_threads - 4)` and store this in manifests/timings.
+- Cached predock usage is explicitly marked in `batch_timings.csv` and `run_matrix.csv`.
+
+## 6. 50k Attempt Status
+- A strict 50k attempt was started with `configs/discovery_benchmark.yaml`.
+- Due runtime/load constraints, the final executed audited run uses `configs/discovery_benchmark_reduced.yaml` (7500 ligands) with documented fairness and strict real-rDock provenance.
+- Detailed blocker log: `results/discovery_50k_blocker.md`.
+
+## Key Outputs
+- Discovery outputs: `/Users/makardorohuntsev/docking_project/results/discovery_benchmark`
+- PPI outputs: `/Users/makardorohuntsev/docking_project/results/ppi_benchmark`
diff --git a/results/final_self_audit_report.md b/results/final_self_audit_report.md
new file mode 100644
index 0000000000000000000000000000000000000000..0c8043af470e84676f8d4ba0aa0838be91d70de7
--- /dev/null
+++ b/results/final_self_audit_report.md
@@ -0,0 +1,12 @@
+# Final Self Audit Report
+
+## Checks
+- `stage1` summary exists: `True`
+- `stage2` summary exists: `True`
+- `stage3` summary exists: `True`
+- `stage4` summary exists: `True`
+- discovery fairness same threads: `True`
+- discovery real rdock only: `True`
+
+## Issues
+- None
\ No newline at end of file
diff --git a/results/ppi_benchmark_repair_audit.md b/results/ppi_benchmark_repair_audit.md
new file mode 100644
index 0000000000000000000000000000000000000000..09ce4c7a14e4cd10cdd8153589638aec13cac8dc
--- /dev/null
+++ b/results/ppi_benchmark_repair_audit.md
@@ -0,0 +1,37 @@
+# PPI Benchmark Repair Audit
+
+## What The Old Benchmark Actually Was
+- Previous implementation (`pipeline/run_ppi_sanity_check.py` before repair) converted peptide sequences to SMILES via RDKit and then docked them through the rDock small-molecule backend.
+- It called `_prepare_backend(...)`, `backend.prepare_ligand(...)`, and `backend.dock(...)` with strict real-rDock mode.
+- This made it a protein-small-molecule docking workflow applied to peptide-derived SMILES, not a genuine peptide/protein-fragment benchmark.
+
+## Why It Was Semantically Wrong
+- The benchmark was labeled as PPI/peptide-like, but its scoring source was rDock small-molecule docking output.
+- Report fields emphasized `real-rdock` success instead of peptide/protein interaction semantics.
+
+## Repaired Benchmark Type
+- Implemented as: `peptide_like` architecture sanity benchmark.
+- Backend semantics: `sequence_structural_proxy` (no rDock docking run for peptide candidates).
+- Reference complex source: `PDB 1YCR`, receptor chain `A`, peptide chain `B`.
+- Dataset: 50 peptide candidates (1 experimental reference + 49 conservative variants).
+
+## How The New Benchmark Differs
+- No peptide-to-small-molecule docking reinterpretation.
+- Ranking uses peptide sequence/feature proxies (`seq_identity`, `anchor_match`, `blosum62`, hydrophobic/charge deltas, structural scaling from target encoding).
+- Output semantics now explicit:
+  - `backend_name=peptide_proxy`
+  - `backend_mode=proxy-peptide-like`
+  - `quantity_type=affinity_proxy`
+  - `score_source=sequence_structural_proxy_v1`
+
+## Disk Status During Repair
+- Initial audit (before proactive cleanup): free space ~`24.32 GB`, repository size ~`13.06 GB`.
+- After repository-local cleanup and pruning (inside `./docking_project` only): free space ~`28.19 GB`, repository size ~`9.04 GB`.
+- Disk telemetry and cleanup logs:
+  - `results/disk_usage_before_after.csv`
+  - `results/disk_cleanup_actions.md`
+  - `results/disk_guard_report.md`
+
+## Correctness Statement
+- The repaired benchmark is a peptide-protein sanity benchmark for architecture generalization.
+- It is no longer a mislabeled strict protein-small-molecule rDock run.
diff --git a/results/ppi_repair_self_audit.md b/results/ppi_repair_self_audit.md
new file mode 100644
index 0000000000000000000000000000000000000000..159d507bb708a146b64c7602c7f7b064c6153a31
--- /dev/null
+++ b/results/ppi_repair_self_audit.md
@@ -0,0 +1,28 @@
+# PPI Repair Self Audit
+
+## Checks
+- Old benchmark semantics diagnosed and documented in `results/ppi_benchmark_repair_audit.md`: `PASS`
+- Repaired benchmark is no longer a mislabeled small-molecule rDock run: `PASS`
+- Disk guard active during repaired run (`results/disk_usage_before_after.csv`, `results/disk_guard_report.md`): `PASS`
+- Cleanup actions restricted to repository-local paths only (`results/disk_cleanup_actions.md`, outside-repo actions = 0): `PASS`
+- Free disk remained above threshold during repaired run (`results/disk_guard_report.md`): `PASS`
+- Required repaired PPI outputs exist under `results/ppi_benchmark/`: `PASS`
+- Reports accurately describe benchmark semantics (`results/ppi_benchmark/report.md`, `results/ppi_benchmark_repair_audit.md`): `PASS`
+
+## Required Output Presence
+- `results/ppi_benchmark_repair_audit.md`: present
+- `results/ppi_benchmark/summary.json`: present
+- `results/ppi_benchmark/ranking.csv`: present
+- `results/ppi_benchmark/features.csv`: present
+- `results/ppi_benchmark/metadata.csv`: present
+- `results/ppi_benchmark/timings.csv`: present
+- `results/ppi_benchmark/report.md`: present
+- `results/ppi_benchmark/self_audit_report.md`: present
+- `results/disk_usage_before_after.csv`: present
+- `results/disk_cleanup_actions.md`: present
+- `results/disk_guard_report.md`: present
+- `results/ppi_repair_self_audit.md`: present
+
+## Result
+- Overall status: `PASS`
+
diff --git a/results/prelim_refresh_cleanup.log b/results/prelim_refresh_cleanup.log
new file mode 100644
index 0000000000000000000000000000000000000000..ea1c748f06362d29695b8aeddeffcab0c2e8b425
--- /dev/null
+++ b/results/prelim_refresh_cleanup.log
@@ -0,0 +1,7 @@
+# Cleanup + refresh 2026-04-22T08:35:43Z
+
+## Before
+1.3G	.
+
+## After
+762M	.
diff --git a/results/prelim_three_sets_manifest_run.json b/results/prelim_three_sets_manifest_run.json
new file mode 100644
index 0000000000000000000000000000000000000000..a25c6af68280ee51d1134da1a7807201118550ee
--- /dev/null
+++ b/results/prelim_three_sets_manifest_run.json
@@ -0,0 +1,32 @@
+{
+  "run_name": "prepare_three_new_sets",
+  "datasets": [
+    {
+      "ligands_dir": "data/ligands/prelim_set_egfr_4wkq",
+      "target_path": "data/targets/prelim_set_egfr_4wkq/egfr_4wkq.pdb",
+      "shared_library": "data/ligands/prelim_set_egfr_4wkq/shared_library_shuffled.csv",
+      "reference_csv": "data/ligands/prelim_set_egfr_4wkq/reference_ligands.csv",
+      "reference_id": "ref_gefitinib_prelim",
+      "reference_comp_id": "IRE",
+      "library_size": 1000
+    },
+    {
+      "ligands_dir": "data/ligands/prelim_set_abl1_1iep",
+      "target_path": "data/targets/prelim_set_abl1_1iep/abl1_1iep.pdb",
+      "shared_library": "data/ligands/prelim_set_abl1_1iep/shared_library_shuffled.csv",
+      "reference_csv": "data/ligands/prelim_set_abl1_1iep/reference_ligands.csv",
+      "reference_id": "ref_imatinib_prelim",
+      "reference_comp_id": "STI",
+      "library_size": 1000
+    },
+    {
+      "ligands_dir": "data/ligands/prelim_set_mdm2_4hg7",
+      "target_path": "data/targets/prelim_set_mdm2_4hg7/mdm2_4hg7.pdb",
+      "shared_library": "data/ligands/prelim_set_mdm2_4hg7/shared_library_shuffled.csv",
+      "reference_csv": "data/ligands/prelim_set_mdm2_4hg7/reference_ligands.csv",
+      "reference_id": "ref_nutlin3a_prelim",
+      "reference_comp_id": "NUT",
+      "library_size": 1000
+    }
+  ]
+}
diff --git a/results/project_synthesis_figures_index.md b/results/project_synthesis_figures_index.md
new file mode 100644
index 0000000000000000000000000000000000000000..99f60ee570b08bd28f571137be902215568d6c61
--- /dev/null
+++ b/results/project_synthesis_figures_index.md
@@ -0,0 +1,65 @@
+# Project Synthesis Figures Index
+
+## /Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/adaptive_vs_cluster_naive_mean_docking_only.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/adaptive_vs_cluster_naive_mean_full_feature.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/adaptive_vs_naive_mean_docking_only.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/adaptive_vs_naive_mean_full_feature.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/best_final_score_so_far_docking_only.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/best_final_score_so_far_full_feature.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/best_score_so_far_docking_only.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/best_score_so_far_full_feature.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/docking_only_vs_full_feature_comparison.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/feature_importance_full_feature.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/rdock_feature_variant_comparison.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/rdock_native_feature_importance.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/rdock_pose_consistency_vs_score.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/rdock_replicate_stability_vs_score.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/rdock_top1_vs_multipose_top10.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/rdock_top1_vs_multipose_top20.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/reference_discovery_steps.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/rolling_good_hit_fraction_docking_only.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/rolling_good_hit_fraction_full_feature.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/rolling_mean_score_docking_only.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/rolling_mean_score_full_feature.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/seed_variability_cluster_naive.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/seed_variability_naive.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/selected_final_score_vs_step_docking_only.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/selected_final_score_vs_step_full_feature.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/selected_score_vs_step_docking_only.png`
+- `/Users/makardorohuntsev/docking_project/results/discovery_benchmark/plots/selected_score_vs_step_full_feature.png`
+
+## /Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/plots
+- `/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/plots/adaptive_variants_vs_cluster_naive.png`
+- `/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/plots/adaptive_variants_vs_naive_mean.png`
+- `/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/plots/best_final_score_so_far_by_policy.png`
+- `/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/plots/best_score_so_far_by_policy.png`
+- `/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/plots/cluster_coverage_over_time.png`
+- `/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/plots/evaluated_count_vs_best_score.png`
+- `/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/plots/hard_stop_vs_soft_stop_comparison.png`
+- `/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/plots/hit_discovery_time_top1_to_top10.png`
+- `/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/plots/hypercluster_coverage_over_time.png`
+- `/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/plots/model_weight_over_time_by_policy.png`
+- `/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/plots/policy_comparison_top10_first10.png`
+- `/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/plots/policy_comparison_top10_first20.png`
+- `/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/plots/policy_comparison_top10_first30.png`
+- `/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/plots/soft_stop_event_timeline.png`
+- `/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/plots/threshold_over_time_by_policy.png`
+
+## /Users/makardorohuntsev/docking_project/results/budget_efficiency_benchmark/plots
+- `/Users/makardorohuntsev/docking_project/results/budget_efficiency_benchmark/plots/budget_vs_auc_best_score_curve.png`
+- `/Users/makardorohuntsev/docking_project/results/budget_efficiency_benchmark/plots/budget_vs_best_final_score.png`
+- `/Users/makardorohuntsev/docking_project/results/budget_efficiency_benchmark/plots/budget_vs_best_score.png`
+- `/Users/makardorohuntsev/docking_project/results/budget_efficiency_benchmark/plots/budget_vs_quality_per_docking.png`
+- `/Users/makardorohuntsev/docking_project/results/budget_efficiency_benchmark/plots/budget_vs_quality_per_time.png`
+- `/Users/makardorohuntsev/docking_project/results/budget_efficiency_benchmark/plots/budget_vs_top100_recovery.png`
+- `/Users/makardorohuntsev/docking_project/results/budget_efficiency_benchmark/plots/budget_vs_top10_recovery.png`
+- `/Users/makardorohuntsev/docking_project/results/budget_efficiency_benchmark/plots/budget_vs_top50_recovery.png`
+- `/Users/makardorohuntsev/docking_project/results/budget_efficiency_benchmark/plots/cross_dataset_budget_transfer.png`
+- `/Users/makardorohuntsev/docking_project/results/budget_efficiency_benchmark/plots/cross_dataset_policy_transfer.png`
+- `/Users/makardorohuntsev/docking_project/results/budget_efficiency_benchmark/plots/dataset_A_vs_B_efficiency.png`
+- `/Users/makardorohuntsev/docking_project/results/budget_efficiency_benchmark/plots/dataset_A_vs_B_quality_per_docking.png`
+- `/Users/makardorohuntsev/docking_project/results/budget_efficiency_benchmark/plots/dataset_A_vs_B_quality_per_time.png`
+- `/Users/makardorohuntsev/docking_project/results/budget_efficiency_benchmark/plots/dataset_A_vs_B_topk_recovery.png`
+- `/Users/makardorohuntsev/docking_project/results/budget_efficiency_benchmark/plots/policy_comparison_by_budget.png`
+- `/Users/makardorohuntsev/docking_project/results/budget_efficiency_benchmark/plots/time_importance_sensitivity.png`
diff --git a/results/project_synthesis_report.md b/results/project_synthesis_report.md
new file mode 100644
index 0000000000000000000000000000000000000000..c36c6f83751a636cfcb5aa99be45b00daf2c37e8
--- /dev/null
+++ b/results/project_synthesis_report.md
@@ -0,0 +1,31 @@
+# Project Synthesis Report
+
+## 1. Project Evolution
+- Started from strict real-rDock validation and backend hardening.
+- Added adaptive scheduling, feature-rich surrogate logic, and fairness controls.
+- Repaired mislabeled PPI benchmark into explicit peptide-like sanity modality.
+- Added policy repair benchmark to diagnose hard-stop underperformance.
+
+## 2. What Worked
+- Strict real-rDock provenance and no-fallback enforcement proved stable on small-molecule tracks.
+- Adaptive policy without aggressive early stop generally improved early hit concentration.
+- Disk guard and thread fairness were consistently auditable.
+
+## 3. What Failed / Was Repaired
+- Hard-stop variants tended to terminate too early and lose top-hit recovery.
+- PPI benchmark semantics were corrected from small-molecule misuse to peptide-like proxy sanity check.
+
+## 4. Current Best Policy
+- From budget benchmark: `adaptive_no_stop` at budget `5000` and time_importance `0.5`.
+
+## 5. Practical Implications
+- Budgeted adaptive ordering can improve quality-per-docking and quality-per-time over naive baselines.
+- The value is strongest when policy and stopping control avoid premature convergence.
+
+## 6. Remaining Uncertainty
+- Transferability across broader chemistry/target classes remains partially open.
+- Absolute runtime on workstation limits confidence for very large-scale production screening.
+
+## 7. Next Steps
+- Run selected policy on server-scale hardware with larger target panel and replicated seeds.
+- Add robust confidence intervals for budget-frontier decisions across targets.
\ No newline at end of file
diff --git a/results/project_synthesis_report_overnight_updated.md b/results/project_synthesis_report_overnight_updated.md
new file mode 100644
index 0000000000000000000000000000000000000000..d5b95fd22679e991434cba846d18bddc76f0b238
--- /dev/null
+++ b/results/project_synthesis_report_overnight_updated.md
@@ -0,0 +1,50 @@
+# Project Synthesis Report
+
+## 1. Project Evolution
+- Started from strict real-rDock validation and backend hardening.
+- Added adaptive scheduling, feature-rich surrogate logic, and fairness controls.
+- Repaired mislabeled PPI benchmark into explicit peptide-like sanity modality.
+- Added policy repair benchmark to diagnose hard-stop underperformance.
+
+## 2. What Worked
+- Strict real-rDock provenance and no-fallback enforcement proved stable on small-molecule tracks.
+- Adaptive policy without aggressive early stop generally improved early hit concentration.
+- Disk guard and thread fairness were consistently auditable.
+
+## 3. What Failed / Was Repaired
+- Hard-stop variants tended to terminate too early and lose top-hit recovery.
+- PPI benchmark semantics were corrected from small-molecule misuse to peptide-like proxy sanity check.
+
+## 4. Current Best Policy
+- From budget benchmark: `adaptive_no_stop` at budget `5000` and time_importance `0.5`.
+
+## 5. Practical Implications
+- Budgeted adaptive ordering can improve quality-per-docking and quality-per-time over naive baselines.
+- The value is strongest when policy and stopping control avoid premature convergence.
+
+## 6. Remaining Uncertainty
+- Transferability across broader chemistry/target classes remains partially open.
+- Absolute runtime on workstation limits confidence for very large-scale production screening.
+
+## 7. Next Steps
+- Run selected policy on server-scale hardware with larger target panel and replicated seeds.
+- Add robust confidence intervals for budget-frontier decisions across targets.
+
+## Epsilon-Regret Correction Pass
+- Previous benchmark logic was dominated by ordering-only comparisons; this pass re-centered on cost-efficiency.
+- New endpoint: early stop under epsilon-quality tolerance relative to exhaustive reference.
+- Selected best strategy: `adaptive_budgeted_regret_stop`
+- Selected best backend branch: `rdock`
+- Mean docking reduction fraction: `0.9606`
+- Mean quality loss at stop: `0.4644`
+- HADDOCK integration mode: `real-haddock3-rescore-calibration`
+
+## Overnight Stop-Model Pass
+- Added formal stop-model comparison: percentile-target, regret-constrained, utility-maximizing, hybrid.
+- Added objective-function comparison across regularized objective set.
+- Added Dataset E and cross-dataset robustness update (A/B/C/D/E).
+- Recommended stop model: `percentile_target`
+- Recommended objective: `hybrid_objective`
+- Recommended budget region: `[100, 2500]`
+- HADDOCK role: `optional shortlist`
+- rDock adequacy status: `mixed_or_weak_on_multiple_targets`
diff --git a/results/project_synthesis_report_updated.md b/results/project_synthesis_report_updated.md
new file mode 100644
index 0000000000000000000000000000000000000000..79f1e30b80f168310a4403b93207c0175b700b06
--- /dev/null
+++ b/results/project_synthesis_report_updated.md
@@ -0,0 +1,40 @@
+# Project Synthesis Report
+
+## 1. Project Evolution
+- Started from strict real-rDock validation and backend hardening.
+- Added adaptive scheduling, feature-rich surrogate logic, and fairness controls.
+- Repaired mislabeled PPI benchmark into explicit peptide-like sanity modality.
+- Added policy repair benchmark to diagnose hard-stop underperformance.
+
+## 2. What Worked
+- Strict real-rDock provenance and no-fallback enforcement proved stable on small-molecule tracks.
+- Adaptive policy without aggressive early stop generally improved early hit concentration.
+- Disk guard and thread fairness were consistently auditable.
+
+## 3. What Failed / Was Repaired
+- Hard-stop variants tended to terminate too early and lose top-hit recovery.
+- PPI benchmark semantics were corrected from small-molecule misuse to peptide-like proxy sanity check.
+
+## 4. Current Best Policy
+- From budget benchmark: `adaptive_no_stop` at budget `5000` and time_importance `0.5`.
+
+## 5. Practical Implications
+- Budgeted adaptive ordering can improve quality-per-docking and quality-per-time over naive baselines.
+- The value is strongest when policy and stopping control avoid premature convergence.
+
+## 6. Remaining Uncertainty
+- Transferability across broader chemistry/target classes remains partially open.
+- Absolute runtime on workstation limits confidence for very large-scale production screening.
+
+## 7. Next Steps
+- Run selected policy on server-scale hardware with larger target panel and replicated seeds.
+- Add robust confidence intervals for budget-frontier decisions across targets.
+
+## Epsilon-Regret Correction Pass
+- Previous benchmark logic was dominated by ordering-only comparisons; this pass re-centered on cost-efficiency.
+- New endpoint: early stop under epsilon-quality tolerance relative to exhaustive reference.
+- Selected best strategy: `adaptive_budgeted_regret_stop`
+- Selected best backend branch: `rdock`
+- Mean docking reduction fraction: `0.9606`
+- Mean quality loss at stop: `0.4644`
+- HADDOCK integration mode: `real-haddock3-rescore-calibration`
diff --git a/results/project_synthesis_tables.csv b/results/project_synthesis_tables.csv
new file mode 100644
index 0000000000000000000000000000000000000000..35250201154fc28dac71b40c08f52f8c9aaaf7d5
--- /dev/null
+++ b/results/project_synthesis_tables.csv
@@ -0,0 +1,59 @@
+stage,metric,value,source
+discovery_benchmark,target,MDM2,/Users/makardorohuntsev/docking_project/results/discovery_benchmark/summary.json
+discovery_benchmark,reference_ligand,ref_nutlin3a,/Users/makardorohuntsev/docking_project/results/discovery_benchmark/summary.json
+discovery_benchmark,final_ligand_count,7500,/Users/makardorohuntsev/docking_project/results/discovery_benchmark/summary.json
+discovery_benchmark,database_fraction,1.0,/Users/makardorohuntsev/docking_project/results/discovery_benchmark/summary.json
+discovery_benchmark,generated_fraction,0.0,/Users/makardorohuntsev/docking_project/results/discovery_benchmark/summary.json
+discovery_benchmark,shuffle_seed,424242,/Users/makardorohuntsev/docking_project/results/discovery_benchmark/summary.json
+discovery_benchmark,reference_present,True,/Users/makardorohuntsev/docking_project/results/discovery_benchmark/summary.json
+discovery_benchmark,completed_runs,23,/Users/makardorohuntsev/docking_project/results/discovery_benchmark/summary.json
+discovery_benchmark,real_rdock_only,True,/Users/makardorohuntsev/docking_project/results/discovery_benchmark/summary.json
+discovery_benchmark,system_threads,14,/Users/makardorohuntsev/docking_project/results/discovery_benchmark/summary.json
+discovery_benchmark,threads_used,10,/Users/makardorohuntsev/docking_project/results/discovery_benchmark/summary.json
+discovery_benchmark,thread_policy,auto-minus-4,/Users/makardorohuntsev/docking_project/results/discovery_benchmark/summary.json
+discovery_benchmark,timing_fairness_same_threads,True,/Users/makardorohuntsev/docking_project/results/discovery_benchmark/summary.json
+policy_repair_benchmark,target,MDM2,/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/summary.json
+policy_repair_benchmark,reference_id,ref_nutlin3a,/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/summary.json
+policy_repair_benchmark,shared_library_size,7500,/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/summary.json
+policy_repair_benchmark,reference_present,True,/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/summary.json
+policy_repair_benchmark,real_rdock_only,True,/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/summary.json
+policy_repair_benchmark,system_threads,14,/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/summary.json
+policy_repair_benchmark,threads_used,10,/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/summary.json
+policy_repair_benchmark,thread_policy,auto-minus-4,/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/summary.json
+policy_repair_benchmark,adaptive_hard_stop_evaluated,786.0,/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/summary.json
+policy_repair_benchmark,adaptive_soft_stop_evaluated,1298.0,/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/summary.json
+policy_repair_benchmark,adaptive_no_stop_evaluated,7500.0,/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/summary.json
+policy_repair_benchmark,adaptive_cluster_bootstrap_evaluated,608.0,/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/summary.json
+policy_repair_benchmark,adaptive_soft_stop_cluster_floor_evaluated,3547.0,/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/summary.json
+policy_repair_benchmark,hard_stop_top10_in_first20pct,0.17197452229299362,/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/summary.json
+policy_repair_benchmark,soft_stop_top10_in_first20pct,0.19305019305019305,/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/summary.json
+policy_repair_benchmark,soft_stop_cluster_floor_top10_in_first20pct,0.12411847672778561,/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/summary.json
+policy_repair_benchmark,no_stop_top10_in_first20pct,0.22866666666666666,/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/summary.json
+policy_repair_benchmark,cluster_bootstrap_top10_in_first20pct,0.1652892561983471,/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/summary.json
+policy_repair_benchmark,naive_mean_top10_in_first20pct,0.09986666666666669,/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/summary.json
+policy_repair_benchmark,cluster_naive_mean_top10_in_first20pct,0.12973333333333334,/Users/makardorohuntsev/docking_project/results/policy_repair_benchmark/summary.json
+ppi_benchmark,benchmark_type,peptide_like,/Users/makardorohuntsev/docking_project/results/ppi_benchmark/summary.json
+ppi_benchmark,backend_semantics,sequence_structural_proxy,/Users/makardorohuntsev/docking_project/results/ppi_benchmark/summary.json
+ppi_benchmark,target,MDM2,/Users/makardorohuntsev/docking_project/results/ppi_benchmark/summary.json
+ppi_benchmark,reference_complex_pdb,1YCR,/Users/makardorohuntsev/docking_project/results/ppi_benchmark/summary.json
+ppi_benchmark,receptor_chain_id,A,/Users/makardorohuntsev/docking_project/results/ppi_benchmark/summary.json
+ppi_benchmark,peptide_chain_id,B,/Users/makardorohuntsev/docking_project/results/ppi_benchmark/summary.json
+ppi_benchmark,ligand_count,50,/Users/makardorohuntsev/docking_project/results/ppi_benchmark/summary.json
+ppi_benchmark,successful_docked_count,50,/Users/makardorohuntsev/docking_project/results/ppi_benchmark/summary.json
+ppi_benchmark,reference_rank,1,/Users/makardorohuntsev/docking_project/results/ppi_benchmark/summary.json
+ppi_benchmark,top10_mean_identity_to_ref,0.9384615384615385,/Users/makardorohuntsev/docking_project/results/ppi_benchmark/summary.json
+ppi_benchmark,real_rdock_only_successful_rows,False,/Users/makardorohuntsev/docking_project/results/ppi_benchmark/summary.json
+ppi_benchmark,proxy_backend_only,True,/Users/makardorohuntsev/docking_project/results/ppi_benchmark/summary.json
+budget_efficiency_benchmark,dataset_A_target,EGFR,in-memory
+budget_efficiency_benchmark,dataset_A_reference,IRE,in-memory
+budget_efficiency_benchmark,dataset_A_library_size,9998,in-memory
+budget_efficiency_benchmark,dataset_B_target,ABL1,in-memory
+budget_efficiency_benchmark,dataset_B_reference,STI,in-memory
+budget_efficiency_benchmark,dataset_B_library_size,9994,in-memory
+budget_efficiency_benchmark,selected_policy,adaptive_no_stop,in-memory
+budget_efficiency_benchmark,selected_budget,5000,in-memory
+budget_efficiency_benchmark,selected_time_importance,0.5,in-memory
+budget_efficiency_benchmark,threads_used,10,in-memory
+budget_efficiency_benchmark,system_threads,14,in-memory
+budget_efficiency_benchmark,real_rdock_only_A,True,in-memory
+budget_efficiency_benchmark,real_rdock_only_B,True,in-memory
diff --git a/results/stage1_code_unification_summary.md b/results/stage1_code_unification_summary.md
new file mode 100644
index 0000000000000000000000000000000000000000..0c9788dc0bc027ab5a383c4dd3fa0c71948db76b
--- /dev/null
+++ b/results/stage1_code_unification_summary.md
@@ -0,0 +1,15 @@
+# Stage 1: Code Unification Summary
+
+- Unified runner added: `pipeline/run_benchmark.py`.
+- Central thread fairness policy added: `libs/benchmark/runtime.py`.
+- Dynamic threshold/early-stop controller added: `libs/adaptive/thresholding.py`.
+- Legacy artifact cleanup utilities added: `libs/benchmark/cleanup.py` and `pipeline/cleanup_legacy_results.py`.
+- Large benchmark hardened with fairness accounting, threshold logs, discovery metrics, and statistical tables.
+
+Thread fairness:
+- policy: `auto-minus-4`
+- system_threads: `14`
+- threads_used: `10`
+
+Tests:
+- Full suite status: `python3 -m unittest discover -s tests -p 'test_*.py'` -> `36 passed, 0 failed`.
diff --git a/results/stage2_cleanup_summary.md b/results/stage2_cleanup_summary.md
new file mode 100644
index 0000000000000000000000000000000000000000..3a7407c64f891efccb2e9794c3e0c235b9a5c192
--- /dev/null
+++ b/results/stage2_cleanup_summary.md
@@ -0,0 +1,10 @@
+# Stage 2: Cleanup Summary
+
+- Archived obsolete result directories: `1`
+- Archive directory: `/Users/makardorohuntsev/docking_project/results/archive/20260415T211637Z`
+
+Archived items:
+- `/Users/makardorohuntsev/docking_project/results/demo_run` (obsolete_or_legacy_result_artifact)
+
+Current state:
+- Active benchmark/result directories kept in place (`discovery_benchmark`, `large_benchmark`, `ppi_benchmark`, `smoke_test`, and archives under `results/archive/`).
diff --git a/results/stage3_ppi_summary.md b/results/stage3_ppi_summary.md
new file mode 100644
index 0000000000000000000000000000000000000000..074bdcfd7e63638436b5acdc257cba2cd81f97ab
--- /dev/null
+++ b/results/stage3_ppi_summary.md
@@ -0,0 +1,7 @@
+# Stage 3: PPI Benchmark Summary
+
+- Output dir: `/Users/makardorohuntsev/docking_project/results/ppi_benchmark`
+- Ligand count: `50`
+- Successful docked count: `50`
+- Reference rank: `10`
+- Real rDock only (successful rows): `True`
\ No newline at end of file
diff --git a/results/stage4_discovery_benchmark_summary.md b/results/stage4_discovery_benchmark_summary.md
new file mode 100644
index 0000000000000000000000000000000000000000..0156bf77456a5ba93ede5ffb5e9cac328b2f6f17
--- /dev/null
+++ b/results/stage4_discovery_benchmark_summary.md
@@ -0,0 +1,116 @@
+# Stage 4: Discovery Benchmark Summary
+
+- Target: `MDM2`
+- Final ligand count: `7500`
+- Total replay runtime seconds: `98.65`
+- system_threads: `14`
+- threads_used: `10`
+- thread fairness satisfied: `True`
+- Real rDock only: `True`
+
+## Early Stop
+- Stop decisions logged: `57`
+- Stop triggered rows: `3`
+- Last stop reason: `stagnation_above_dynamic_threshold` at round `18`
+
+## Time To Top-k (mean over seeds where discovered)
+- Mode `docking_only`:
+  adaptive top-1: mean_step=`nan` mean_dockings=`nan` reached_fraction=`0.000`
+  adaptive top-2: mean_step=`nan` mean_dockings=`nan` reached_fraction=`0.000`
+  adaptive top-3: mean_step=`nan` mean_dockings=`nan` reached_fraction=`0.000`
+  adaptive top-5: mean_step=`nan` mean_dockings=`nan` reached_fraction=`0.000`
+  adaptive top-10: mean_step=`nan` mean_dockings=`nan` reached_fraction=`0.000`
+  naive_random top-1: mean_step=`3031.40` mean_dockings=`3032.40` reached_fraction=`1.000`
+  naive_random top-2: mean_step=`1601.80` mean_dockings=`1602.80` reached_fraction=`1.000`
+  naive_random top-3: mean_step=`1383.60` mean_dockings=`1384.60` reached_fraction=`1.000`
+  naive_random top-5: mean_step=`1228.00` mean_dockings=`1229.00` reached_fraction=`1.000`
+  naive_random top-10: mean_step=`182.80` mean_dockings=`183.80` reached_fraction=`1.000`
+  cluster_naive top-1: mean_step=`513.80` mean_dockings=`514.80` reached_fraction=`1.000`
+  cluster_naive top-2: mean_step=`513.80` mean_dockings=`514.80` reached_fraction=`1.000`
+  cluster_naive top-3: mean_step=`513.80` mean_dockings=`514.80` reached_fraction=`1.000`
+  cluster_naive top-5: mean_step=`508.80` mean_dockings=`509.80` reached_fraction=`1.000`
+  cluster_naive top-10: mean_step=`508.80` mean_dockings=`509.80` reached_fraction=`1.000`
+- Mode `full_feature`:
+  adaptive top-1: mean_step=`nan` mean_dockings=`nan` reached_fraction=`0.000`
+  adaptive top-2: mean_step=`nan` mean_dockings=`nan` reached_fraction=`0.000`
+  adaptive top-3: mean_step=`nan` mean_dockings=`nan` reached_fraction=`0.000`
+  adaptive top-5: mean_step=`nan` mean_dockings=`nan` reached_fraction=`0.000`
+  adaptive top-10: mean_step=`nan` mean_dockings=`nan` reached_fraction=`0.000`
+  naive_random top-1: mean_step=`3031.40` mean_dockings=`3032.40` reached_fraction=`1.000`
+  naive_random top-2: mean_step=`1601.80` mean_dockings=`1602.80` reached_fraction=`1.000`
+  naive_random top-3: mean_step=`1383.60` mean_dockings=`1384.60` reached_fraction=`1.000`
+  naive_random top-5: mean_step=`1228.00` mean_dockings=`1229.00` reached_fraction=`1.000`
+  naive_random top-10: mean_step=`182.80` mean_dockings=`183.80` reached_fraction=`1.000`
+  cluster_naive top-1: mean_step=`513.80` mean_dockings=`514.80` reached_fraction=`1.000`
+  cluster_naive top-2: mean_step=`513.80` mean_dockings=`514.80` reached_fraction=`1.000`
+  cluster_naive top-3: mean_step=`513.80` mean_dockings=`514.80` reached_fraction=`1.000`
+  cluster_naive top-5: mean_step=`508.80` mean_dockings=`509.80` reached_fraction=`1.000`
+  cluster_naive top-10: mean_step=`508.80` mean_dockings=`509.80` reached_fraction=`1.000`
+
+## Adaptive vs Baselines (run_metrics)
+- mode=docking_only metric=best_docking_score:
+  adaptive: mean=`-19.094200` std=`0.000000`
+  cluster_naive: mean=`-30.320700` std=`0.000000`
+  naive_random: mean=`-30.320700` std=`0.000000`
+- mode=docking_only metric=best_final_score:
+  adaptive: mean=`-19.059859` std=`0.048565`
+  cluster_naive: mean=`-30.320700` std=`0.000000`
+  naive_random: mean=`-30.320700` std=`0.000000`
+- mode=docking_only metric=top10_in_first10pct:
+  adaptive: mean=`0.066667` std=`0.000000`
+  cluster_naive: mean=`0.128533` std=`0.008198`
+  naive_random: mean=`0.097600` std=`0.013901`
+- mode=docking_only metric=top10_in_first20pct:
+  adaptive: mean=`0.066116` std=`0.000000`
+  cluster_naive: mean=`0.129733` std=`0.022329`
+  naive_random: mean=`0.099867` std=`0.006539`
+- mode=docking_only metric=best_score_so_far_auc:
+  adaptive: mean=`-8579.375846` std=`0.000000`
+  cluster_naive: mean=`-219759.448932` std=`6179.372334`
+  naive_random: mean=`-207727.899538` std=`14967.993309`
+- mode=full_feature metric=best_docking_score:
+  adaptive: mean=`-17.186500` std=`nan`
+  cluster_naive: mean=`-30.320700` std=`0.000000`
+  naive_random: mean=`-30.320700` std=`0.000000`
+- mode=full_feature metric=best_final_score:
+  adaptive: mean=`-21.414036` std=`nan`
+  cluster_naive: mean=`-33.352770` std=`0.000000`
+  naive_random: mean=`-33.352770` std=`0.000000`
+- mode=full_feature metric=top10_in_first10pct:
+  adaptive: mean=`0.050000` std=`nan`
+  cluster_naive: mean=`0.128533` std=`0.008198`
+  naive_random: mean=`0.097600` std=`0.013901`
+- mode=full_feature metric=top10_in_first20pct:
+  adaptive: mean=`0.049587` std=`nan`
+  cluster_naive: mean=`0.129733` std=`0.022329`
+  naive_random: mean=`0.099867` std=`0.006539`
+- mode=full_feature metric=best_score_so_far_auc:
+  adaptive: mean=`-7864.257404` std=`nan`
+  cluster_naive: mean=`-219759.448932` std=`6179.372334`
+  naive_random: mean=`-207727.899538` std=`14967.993309`
+
+## Significance / Effect Size (adaptive vs baselines)
+- mode=docking_only metric=best_final_score adaptive vs naive_random: p=`0.0297272` U=`10.000`
+- mode=docking_only metric=top10_in_first10pct adaptive vs naive_random: p=`0.0786429` U=`0.000`
+- mode=docking_only metric=top10_in_first20pct adaptive vs naive_random: p=`0.075927` U=`0.000`
+- mode=docking_only metric=best_final_score adaptive vs cluster_naive: p=`0.0297272` U=`10.000`
+- mode=docking_only metric=top10_in_first10pct adaptive vs cluster_naive: p=`0.0786429` U=`0.000`
+- mode=docking_only metric=top10_in_first20pct adaptive vs cluster_naive: p=`0.0786429` U=`0.000`
+- mode=full_feature metric=best_final_score adaptive vs naive_random: p=`0.0736383` U=`5.000`
+- mode=full_feature metric=top10_in_first10pct adaptive vs naive_random: p=`0.333333` U=`0.000`
+- mode=full_feature metric=top10_in_first20pct adaptive vs naive_random: p=`0.234764` U=`0.000`
+- mode=full_feature metric=best_final_score adaptive vs cluster_naive: p=`0.0736383` U=`5.000`
+- mode=full_feature metric=top10_in_first10pct adaptive vs cluster_naive: p=`0.333333` U=`0.000`
+- mode=full_feature metric=top10_in_first20pct adaptive vs cluster_naive: p=`0.333333` U=`0.000`
+- mode=docking_only metric=best_final_score cliffs_delta=`1.0000` mean_adaptive=`-19.059859` mean_naive_random=`-30.320700`
+- mode=docking_only metric=top10_in_first10pct cliffs_delta=`-1.0000` mean_adaptive=`0.066667` mean_naive_random=`0.097600`
+- mode=docking_only metric=top10_in_first20pct cliffs_delta=`-1.0000` mean_adaptive=`0.066116` mean_naive_random=`0.099867`
+- mode=docking_only metric=best_final_score cliffs_delta=`1.0000` mean_adaptive=`-19.059859` mean_cluster_naive=`-30.320700`
+- mode=docking_only metric=top10_in_first10pct cliffs_delta=`-1.0000` mean_adaptive=`0.066667` mean_cluster_naive=`0.128533`
+- mode=docking_only metric=top10_in_first20pct cliffs_delta=`-1.0000` mean_adaptive=`0.066116` mean_cluster_naive=`0.129733`
+- mode=full_feature metric=best_final_score cliffs_delta=`1.0000` mean_adaptive=`-21.414036` mean_naive_random=`-33.352770`
+- mode=full_feature metric=top10_in_first10pct cliffs_delta=`-1.0000` mean_adaptive=`0.050000` mean_naive_random=`0.097600`
+- mode=full_feature metric=top10_in_first20pct cliffs_delta=`-1.0000` mean_adaptive=`0.049587` mean_naive_random=`0.099867`
+- mode=full_feature metric=best_final_score cliffs_delta=`1.0000` mean_adaptive=`-21.414036` mean_cluster_naive=`-33.352770`
+- mode=full_feature metric=top10_in_first10pct cliffs_delta=`-1.0000` mean_adaptive=`0.050000` mean_cluster_naive=`0.128533`
+- mode=full_feature metric=top10_in_first20pct cliffs_delta=`-1.0000` mean_adaptive=`0.049587` mean_cluster_naive=`0.129733`
\ No newline at end of file
diff --git a/tests/__init__.py b/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e080310e605cf78721ea6e6383bc6599c807496b
--- /dev/null
+++ b/tests/__init__.py
@@ -0,0 +1 @@
+"""Test package for adaptive docking pipeline."""
diff --git a/tests/test_backend_comparison_semantics.py b/tests/test_backend_comparison_semantics.py
new file mode 100644
index 0000000000000000000000000000000000000000..400a685918ae003b167cbb4839f7183ca3155964
--- /dev/null
+++ b/tests/test_backend_comparison_semantics.py
@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import unittest
+
+import pandas as pd
+
+from libs.docking.comparison import build_backend_comparison_table
+
+
+class TestBackendComparisonSemantics(unittest.TestCase):
+    def test_mixed_backend_disables_direct_raw_comparison(self) -> None:
+        df = pd.DataFrame(
+            [
+                {
+                    "ligand_id": "l1",
+                    "backend_name": "rdock",
+                    "backend_mode": "real-rdock",
+                    "docking_score": -8.0,
+                    "raw_output_file": "a",
+                    "parsed_from": "a::SCORE",
+                },
+                {
+                    "ligand_id": "l1",
+                    "backend_name": "haddock",
+                    "backend_mode": "real-haddock3-rescore",
+                    "docking_score": -12.0,
+                    "raw_output_file": "b",
+                    "parsed_from": "b::HADDOCK",
+                },
+            ]
+        )
+        out = build_backend_comparison_table(df)
+        self.assertEqual(out.shape[0], 2)
+        self.assertFalse(bool(out["direct_comparison_justified"].all()))
+
+
+if __name__ == "__main__":
+    unittest.main()
+
diff --git a/tests/test_backend_diagnostic_logic.py b/tests/test_backend_diagnostic_logic.py
new file mode 100644
index 0000000000000000000000000000000000000000..8e968d5b1262b272fdec86f5f740d73b98acedfd
--- /dev/null
+++ b/tests/test_backend_diagnostic_logic.py
@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+from libs.analysis.backend_diagnostic import (
+    REQUIRED_BACKEND_COMPARISON_COLUMNS,
+    REQUIRED_POCKET_PREP_COLUMNS,
+    REQUIRED_REFERENCE_DIAG_COLUMNS,
+    compute_rank_percentile,
+    manual_agents_check,
+    recommend_toolchain,
+    select_suspicious_datasets,
+    validate_required_columns,
+)
+
+
+class TestBackendDiagnosticLogic(unittest.TestCase):
+    def test_manual_agents_check_exists(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            p = Path(tmp) / "AGENTS.md"
+            p.write_text("x", encoding="utf-8")
+            out = manual_agents_check(p, manually_read=True)
+            self.assertTrue(out.exists)
+            self.assertTrue(out.manually_read)
+            self.assertEqual(Path(out.path), p.resolve())
+
+    def test_compute_rank_percentile(self) -> None:
+        df = pd.DataFrame(
+            {
+                "ligand_id": ["a", "b", "c", "d"],
+                "score": [5.0, 1.0, 3.0, 2.0],
+            }
+        )
+        # sorted lower-better: b,d,c,a -> c rank 3/4 => 75%
+        pct = compute_rank_percentile(df, "c", "score", lower_is_better=True)
+        self.assertAlmostEqual(pct, 75.0, places=6)
+
+    def test_select_suspicious(self) -> None:
+        d = pd.DataFrame(
+            {
+                "dataset": ["A", "B", "C", "D"],
+                "reference_ligand_rank_percentile": [10.0, 55.0, 25.0, 80.0],
+            }
+        )
+        out = select_suspicious_datasets(d, threshold_pct=30.0, max_deep=2)
+        self.assertEqual(out, ["D", "B"])
+
+    def test_validate_required_columns(self) -> None:
+        d = pd.DataFrame({"a": [1], "b": [2]})
+        missing = validate_required_columns(d, ["a", "x"])
+        self.assertEqual(missing, ["x"])
+
+    def test_recommend_toolchain_runtime_penalty(self) -> None:
+        b = pd.DataFrame(
+            [
+                {
+                    "dataset": "A",
+                    "backend": "vina",
+                    "analysis_scope": "subset_default",
+                    "available": True,
+                    "runtime_per_ligand": 3.0,
+                    "reference_ligand_rank_percentile": 10.0,
+                },
+                {
+                    "dataset": "A",
+                    "backend": "rdock",
+                    "analysis_scope": "subset_default",
+                    "available": True,
+                    "runtime_per_ligand": 1.0,
+                    "reference_ligand_rank_percentile": 12.0,
+                },
+            ]
+        )
+        p = pd.DataFrame(
+            [
+                {
+                    "dataset": "A",
+                    "backend": "rdock",
+                    "pocket_variant": "default",
+                    "prep_variant": "default",
+                    "reference_ligand_score": 5.0,
+                },
+                {
+                    "dataset": "A",
+                    "backend": "rdock",
+                    "pocket_variant": "expanded",
+                    "prep_variant": "tautomer",
+                    "reference_ligand_score": 4.7,
+                },
+            ]
+        )
+        out = recommend_toolchain(b, p)
+        self.assertEqual(out["recommended_main_backend"], "rdock")
+        self.assertIn("candidate_backend_too_slow_vs_rdock", out["evidence"])
+
+    def test_required_schema_constants_nonempty(self) -> None:
+        self.assertGreater(len(REQUIRED_REFERENCE_DIAG_COLUMNS), 0)
+        self.assertGreater(len(REQUIRED_BACKEND_COMPARISON_COLUMNS), 0)
+        self.assertGreater(len(REQUIRED_POCKET_PREP_COLUMNS), 0)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_benchmark_outputs.py b/tests/test_benchmark_outputs.py
new file mode 100644
index 0000000000000000000000000000000000000000..685d02a4559e22681f46d7a5ef392005a9ef0aeb
--- /dev/null
+++ b/tests/test_benchmark_outputs.py
@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+
+import yaml
+
+from pipeline.run_experimental_benchmark import run_benchmark
+
+
+class TestBenchmarkOutputs(unittest.TestCase):
+    def test_benchmark_outputs_exist_in_tiny_run(self) -> None:
+        cfg = yaml.safe_load(Path("configs/experimental_benchmark.yaml").read_text(encoding="utf-8"))
+        cfg["run"]["adaptive_budget"] = 4
+        cfg["run"]["baseline_budget"] = 4
+        cfg["run"]["batch_size"] = 2
+        cfg["run"]["max_batches"] = 2
+        cfg["run"]["dataset_subset_size"] = 120
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            cfg["run"]["output_dir"] = str(Path(tmpdir) / "benchmark_tiny")
+            cfg_path = Path(tmpdir) / "benchmark_tiny.yaml"
+            cfg_path.write_text(yaml.safe_dump(cfg), encoding="utf-8")
+
+            result = run_benchmark(cfg_path)
+            out = Path(result["output_dir"])
+
+            required = [
+                "summary.json",
+                "final_ranking.csv",
+                "reference_recovery.csv",
+                "reference_comparison.csv",
+                "baseline_comparison.csv",
+                "parsed_scores.csv",
+                "feature_importance.json",
+                "self_audit_report.md",
+            ]
+            for name in required:
+                self.assertTrue((out / name).exists(), f"Missing output: {name}")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_budget_efficiency_helpers.py b/tests/test_budget_efficiency_helpers.py
new file mode 100644
index 0000000000000000000000000000000000000000..c6af996f6d2c10799e1402eb3f012e65e01e1017
--- /dev/null
+++ b/tests/test_budget_efficiency_helpers.py
@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+import pandas as pd
+
+from libs.adaptive.policies import PrioritizationPolicy
+from libs.benchmark.budget_efficiency import (
+    clamp_time_importance,
+    controls_from_time_importance,
+    required_budget_metric_columns,
+    select_best_policy_budget,
+    validate_budget_metric_schema,
+)
+from pipeline.run_budget_efficiency_benchmark import _project_synthesis, _self_audit
+
+
+class TestBudgetEfficiencyHelpers(unittest.TestCase):
+    def test_time_importance_clamp(self) -> None:
+        self.assertEqual(clamp_time_importance(-0.1), 0.0)
+        self.assertEqual(clamp_time_importance(1.5), 1.0)
+        self.assertEqual(clamp_time_importance(0.25), 0.25)
+
+    def test_time_importance_controls_shift(self) -> None:
+        base = PrioritizationPolicy()
+        low = controls_from_time_importance(base, exploration_boost=0.1, time_importance=0.0)
+        high = controls_from_time_importance(base, exploration_boost=0.1, time_importance=1.0)
+        self.assertGreaterEqual(high.utility_weight, low.utility_weight)
+        self.assertLessEqual(high.uncertainty_weight, low.uncertainty_weight)
+        self.assertLessEqual(high.diversity_weight, low.diversity_weight)
+        self.assertLessEqual(high.threshold_stop_shift, 0.0)
+
+    def test_schema_validation(self) -> None:
+        cols = required_budget_metric_columns()
+        df = pd.DataFrame([{c: 0 for c in cols}])
+        missing = validate_budget_metric_schema(df)
+        self.assertEqual(missing, [])
+
+    def test_policy_selection(self) -> None:
+        df = pd.DataFrame(
+            [
+                {
+                    "dataset": "A",
+                    "strategy": "adaptive_soft_stop",
+                    "strategy_group": "adaptive",
+                    "budget": 500,
+                    "time_importance": 0.5,
+                    "top10_recovery_fraction": 0.2,
+                    "top50_recovery_fraction": 0.15,
+                    "top100_recovery_fraction": 0.10,
+                    "best_docking_score": -8.0,
+                    "best_final_score": -9.0,
+                    "dockings_performed": 500,
+                    "wall_time_seconds": 10.0,
+                    "quality_per_time": 0.010,
+                    "quality_per_docking": 0.0002,
+                    "auc_best_score_so_far": -100.0,
+                },
+                {
+                    "dataset": "A",
+                    "strategy": "adaptive_no_stop",
+                    "strategy_group": "adaptive",
+                    "budget": 500,
+                    "time_importance": 0.5,
+                    "top10_recovery_fraction": 0.4,
+                    "top50_recovery_fraction": 0.30,
+                    "top100_recovery_fraction": 0.20,
+                    "best_docking_score": -9.0,
+                    "best_final_score": -10.0,
+                    "dockings_performed": 500,
+                    "wall_time_seconds": 9.0,
+                    "quality_per_time": 0.022,
+                    "quality_per_docking": 0.0004,
+                    "auc_best_score_so_far": -150.0,
+                },
+            ]
+        )
+        selected = select_best_policy_budget(df)
+        self.assertEqual(str(selected["strategy"]), "adaptive_no_stop")
+
+
+class TestSynthesisAndAuditSchemas(unittest.TestCase):
+    def test_project_synthesis_outputs(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            results = root / "results"
+            results.mkdir(parents=True, exist_ok=True)
+            # seed minimal legacy summaries expected by synthesis collector
+            for d in ["discovery_benchmark", "policy_repair_benchmark", "ppi_benchmark"]:
+                p = results / d
+                p.mkdir(parents=True, exist_ok=True)
+                (p / "summary.json").write_text(json.dumps({"ok": True, "value": 1}), encoding="utf-8")
+            out = results / "budget_efficiency_benchmark"
+            out.mkdir(parents=True, exist_ok=True)
+            tables, index, report = _project_synthesis(out, {"selected_policy": "adaptive_no_stop", "selected_budget": 500})
+            self.assertTrue(tables.exists())
+            self.assertTrue(index.exists())
+            self.assertTrue(report.exists())
+
+    def test_self_audit_schema(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            results = root / "results"
+            results.mkdir(parents=True, exist_ok=True)
+            (results / "discovery_benchmark").mkdir(parents=True, exist_ok=True)
+            (results / "discovery_benchmark" / "summary.json").write_text(json.dumps({"ok": True}), encoding="utf-8")
+
+            out = results / "budget_efficiency_benchmark"
+            out.mkdir(parents=True, exist_ok=True)
+            policy_sel = out / "policy_selection.md"
+            policy_sel.write_text("ok", encoding="utf-8")
+            consistency = out / "cross_dataset_consistency.csv"
+            pd.DataFrame([{"x": 1}]).to_csv(consistency, index=False)
+            syn1 = out / "s1.md"
+            syn2 = out / "s2.md"
+            syn3 = out / "s3.md"
+            for s in [syn1, syn2, syn3]:
+                s.write_text("ok", encoding="utf-8")
+
+            d_a = root / "data" / "ligands" / "A"
+            d_b = root / "data" / "ligands" / "B"
+            d_a.mkdir(parents=True, exist_ok=True)
+            d_b.mkdir(parents=True, exist_ok=True)
+            pd.DataFrame([{"is_reference": True}]).to_csv(d_a / "shared_library_shuffled.csv", index=False)
+            pd.DataFrame([{"is_reference": True}]).to_csv(d_b / "shared_library_shuffled.csv", index=False)
+
+            manifest = pd.DataFrame([{"threads_used": 10}, {"threads_used": 10}])
+            metrics = pd.DataFrame([{"budget": 100}, {"budget": 500}, {"budget": 2500}, {"budget": 5000}, {"budget": 10000}])
+            path = _self_audit(
+                output_root=out,
+                dataset_a_cfg={"protein_name": "EGFR", "benchmark_dataset": {"output_dir": str(d_a.relative_to(root))}},
+                dataset_b_cfg={"protein_name": "ABL1", "benchmark_dataset": {"output_dir": str(d_b.relative_to(root))}},
+                metrics_a=metrics,
+                metrics_b=metrics,
+                policy_selection_path=policy_sel,
+                consistency_path=consistency,
+                synthesis_paths=[syn1, syn2, syn3],
+                run_manifest=manifest,
+                repo_root=root,
+            )
+            self.assertTrue(path.exists())
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_cleanup_logic.py b/tests/test_cleanup_logic.py
new file mode 100644
index 0000000000000000000000000000000000000000..789bf5b39ca333f5ff6b06105dfcf101ac8f74e3
--- /dev/null
+++ b/tests/test_cleanup_logic.py
@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+
+from libs.benchmark.cleanup import execute_results_cleanup, plan_results_cleanup
+
+
+class TestCleanupLogic(unittest.TestCase):
+    def test_plan_and_execute_archive(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "results"
+            root.mkdir(parents=True, exist_ok=True)
+            (root / "legacy_old").mkdir()
+            (root / "large_benchmark").mkdir()
+            (root / "smoke_test").mkdir()
+
+            plan = plan_results_cleanup(root)
+            names = [item.path.name for item in plan]
+            self.assertIn("legacy_old", names)
+            self.assertNotIn("large_benchmark", names)
+
+            archive = execute_results_cleanup(root, plan)
+            self.assertTrue(archive.exists())
+            self.assertFalse((root / "legacy_old").exists())
+
+
+if __name__ == "__main__":
+    unittest.main()
+
diff --git a/tests/test_clustering.py b/tests/test_clustering.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e90b616afc12c90ff6e6af74d953fcd991421d1
--- /dev/null
+++ b/tests/test_clustering.py
@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+
+from libs.adaptive.clustering import cluster_ligands_butina
+from libs.adaptive.hyperclustering import hypercluster_representatives
+
+
+class TestClustering(unittest.TestCase):
+    def test_butina_and_hyperclustering(self) -> None:
+        ligand_ids = [f"l{i}" for i in range(12)]
+        fps = [np.random.randint(0, 2, 128) for _ in ligand_ids]
+        cluster_map = cluster_ligands_butina(ligand_ids, fps, cutoff=0.7)
+        self.assertEqual(set(cluster_map.keys()), set(ligand_ids))
+
+        reps = {}
+        for lid, cid in cluster_map.items():
+            reps.setdefault(cid, []).append(np.random.rand(32))
+        reps_mean = {cid: np.mean(np.vstack(vecs), axis=0) for cid, vecs in reps.items()}
+        hyper = hypercluster_representatives(reps_mean)
+
+        self.assertEqual(set(hyper.keys()), set(reps_mean.keys()))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_dataset_reuse_logic.py b/tests/test_dataset_reuse_logic.py
new file mode 100644
index 0000000000000000000000000000000000000000..3881b4e828dfb1fd9ab3dc26f05509ce06c1dfea
--- /dev/null
+++ b/tests/test_dataset_reuse_logic.py
@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+
+from libs.benchmark.reuse import validate_reuse_inputs
+
+
+class TestDatasetReuseLogic(unittest.TestCase):
+    def test_reuse_check_ok(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            a = root / "a.txt"
+            b = root / "b.txt"
+            a.write_text("x", encoding="utf-8")
+            b.write_text("y", encoding="utf-8")
+            check = validate_reuse_inputs([a, b])
+            self.assertTrue(check.ok)
+            self.assertEqual(check.missing, [])
+
+    def test_reuse_check_missing(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            a = root / "a.txt"
+            a.write_text("x", encoding="utf-8")
+            check = validate_reuse_inputs([a, root / "missing.txt"])
+            self.assertFalse(check.ok)
+            self.assertEqual(len(check.missing), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()
+
diff --git a/tests/test_disk_guard.py b/tests/test_disk_guard.py
new file mode 100644
index 0000000000000000000000000000000000000000..26ea507b6dac235911b1fee32af102f7d7e889a3
--- /dev/null
+++ b/tests/test_disk_guard.py
@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+
+from libs.benchmark.disk_guard import (
+    append_disk_snapshot,
+    requires_cleanup,
+    run_repository_local_cleanup,
+    snapshot_disk_state,
+)
+
+
+class TestDiskGuard(unittest.TestCase):
+    def test_snapshot_and_cleanup_decision(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            snap = snapshot_disk_state(root, stage="t", note="n", projected_output_gb=0.1)
+            self.assertGreater(snap.free_gb, 0.0)
+            self.assertGreaterEqual(snap.projected_free_after_gb, 0.0)
+            csv_path = root / "snap.csv"
+            append_disk_snapshot(csv_path, snap)
+            self.assertTrue(csv_path.exists() and csv_path.stat().st_size > 0)
+            self.assertIsInstance(requires_cleanup(snap, min_free_gb=1000.0), bool)
+
+    def test_cleanup_stays_repo_local(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            repo = Path(tmp) / "repo"
+            results = repo / "results"
+            results.mkdir(parents=True, exist_ok=True)
+            run_dir = results / "run_x"
+            replay = run_dir / "replay_cache"
+            replay.mkdir(parents=True, exist_ok=True)
+            (run_dir / "summary.json").write_text("{}", encoding="utf-8")
+            (replay / "a.txt").write_text("x" * 1024, encoding="utf-8")
+            raw = run_dir / "raw_rdock_outputs"
+            for i in range(10):
+                b = raw / f"batch_{i:03d}"
+                b.mkdir(parents=True, exist_ok=True)
+                (b / "f.txt").write_text("x", encoding="utf-8")
+
+            actions = run_repository_local_cleanup(repo, results_dir=results, keep_raw_batches=3)
+            self.assertTrue(actions)
+            # replay cache should be removed
+            self.assertFalse(replay.exists())
+            # raw batches should be pruned
+            kept = [p for p in raw.iterdir() if p.is_dir()]
+            self.assertLessEqual(len(kept), 3)
+
+
+if __name__ == "__main__":
+    unittest.main()
+
diff --git a/tests/test_docking_mode_filter.py b/tests/test_docking_mode_filter.py
new file mode 100644
index 0000000000000000000000000000000000000000..6969cc348d9ef28e87a72ed845c1926a479091f0
--- /dev/null
+++ b/tests/test_docking_mode_filter.py
@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import unittest
+
+import pandas as pd
+
+from pipeline.run_experimental_benchmark import _filter_mode_feature_tables
+
+
+class TestDockingModeFilter(unittest.TestCase):
+    def test_docking_only_keeps_rdock_and_cluster_channels(self) -> None:
+        values = pd.DataFrame(
+            [
+                {
+                    "ligand_id": "L1",
+                    "cluster_id_feature": 1.0,
+                    "hypercluster_id_feature": 0.0,
+                    "rdock_total_score": -10.0,
+                    "mean_top3_pose_score": -9.8,
+                    "ligand_logp": 2.1,
+                }
+            ]
+        )
+        masks = pd.DataFrame(
+            [
+                {
+                    "ligand_id": "L1",
+                    "mask_cluster_id_feature": 1,
+                    "mask_hypercluster_id_feature": 1,
+                    "mask_rdock_total_score": 1,
+                    "mask_mean_top3_pose_score": 1,
+                    "mask_ligand_logp": 1,
+                }
+            ]
+        )
+        v, m = _filter_mode_feature_tables(values, masks, feature_mode="docking_only")
+        self.assertIn("cluster_id_feature", v.columns)
+        self.assertIn("rdock_total_score", v.columns)
+        self.assertNotIn("ligand_logp", v.columns)
+        self.assertIn("mask_rdock_total_score", m.columns)
+        self.assertNotIn("mask_ligand_logp", m.columns)
+
+
+if __name__ == "__main__":
+    unittest.main()
+
diff --git a/tests/test_epsilon_regret_logic.py b/tests/test_epsilon_regret_logic.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ffd5aff8d297a810f94d7c3a71357cbaef56745
--- /dev/null
+++ b/tests/test_epsilon_regret_logic.py
@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import unittest
+
+from libs.adaptive.epsilon_regret import EpsilonRegretConfig, EpsilonRegretController
+
+
+class TestEpsilonRegretController(unittest.TestCase):
+    def test_does_not_stop_before_min_budget(self) -> None:
+        ctrl = EpsilonRegretController(
+            EpsilonRegretConfig(
+                min_budget=5,
+                patience_rounds=1,
+                min_improvement=0.0,
+                min_cluster_coverage=0.0,
+                min_hypercluster_coverage=0.0,
+                min_model_weight=0.0,
+            )
+        )
+        rec = ctrl.update(
+            round_idx=0,
+            n_evaluated=2,
+            best_score_now=-10.0,
+            recent_scores=[-10.0, -10.0],
+            model_weight=1.0,
+            cluster_coverage=1.0,
+            hypercluster_coverage=1.0,
+            expected_remaining_scores=[-10.01],
+            uncertainty_scores=[0.0],
+            time_importance=0.5,
+            budget_cap=10,
+        )
+        self.assertFalse(bool(rec["stop"]))
+
+    def test_stops_when_remaining_gain_below_epsilon(self) -> None:
+        ctrl = EpsilonRegretController(
+            EpsilonRegretConfig(
+                epsilon_quality=0.10,
+                acceptable_regret=0.10,
+                min_budget=3,
+                patience_rounds=1,
+                min_improvement=0.0,
+                min_cluster_coverage=0.0,
+                min_hypercluster_coverage=0.0,
+                min_model_weight=0.0,
+            )
+        )
+        # round 1
+        ctrl.update(
+            round_idx=0,
+            n_evaluated=3,
+            best_score_now=-10.0,
+            recent_scores=[-10.0, -10.0],
+            model_weight=1.0,
+            cluster_coverage=1.0,
+            hypercluster_coverage=1.0,
+            expected_remaining_scores=[-10.2],
+            uncertainty_scores=[0.01],
+            time_importance=0.5,
+            budget_cap=20,
+        )
+        # round 2 with tiny expected gain
+        rec = ctrl.update(
+            round_idx=1,
+            n_evaluated=4,
+            best_score_now=-10.0,
+            recent_scores=[-10.0, -10.0],
+            model_weight=1.0,
+            cluster_coverage=1.0,
+            hypercluster_coverage=1.0,
+            expected_remaining_scores=[-10.01],
+            uncertainty_scores=[0.0],
+            time_importance=1.0,
+            budget_cap=20,
+        )
+        self.assertTrue(bool(rec["stop"]))
+        self.assertIn(str(rec["reason"]), {"epsilon_regret_stop", "max_budget_reached"})
+
+
+if __name__ == "__main__":
+    unittest.main()
+
diff --git a/tests/test_feature_extraction.py b/tests/test_feature_extraction.py
new file mode 100644
index 0000000000000000000000000000000000000000..626dd0c5e247bbc41826bc7d214d6430c0c09d42
--- /dev/null
+++ b/tests/test_feature_extraction.py
@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+
+from libs.adaptive.features import (
+    build_complex_feature_bundle,
+    build_ligand_feature_bundle,
+    build_protein_feature_bundle,
+)
+
+
+class TestFeatureExtraction(unittest.TestCase):
+    def test_ligand_protein_complex_feature_bundles(self) -> None:
+        fp = np.zeros(32, dtype=float)
+        fp[[1, 7, 13]] = 1.0
+
+        ligand = build_ligand_feature_bundle(
+            ligand_id="lig_a",
+            smiles="CCO",
+            fingerprint=fp,
+            reference_mol=None,
+        )
+        self.assertIn("ligand_mw", ligand.features)
+        self.assertIn("ligand_logp", ligand.features)
+        self.assertIn("morgan_fp_0001", ligand.features)
+        self.assertTrue(ligand.features["ligand_mw"].available)
+
+        protein = build_protein_feature_bundle(
+            target_id="target_x",
+            sequence_features={"seq_length": 100.0, "aa_frac_A": 0.1, "aa_frac_D": 0.1, "aa_frac_S": 0.1},
+            structure_features={"residue_count": 120.0, "mean_spatial_extent": 10.0, "pocket_residue_count": 20.0},
+        )
+        self.assertIn("pocket_volume_approx", protein.features)
+        self.assertTrue(protein.features["pocket_volume_approx"].available)
+
+        complex_bundle = build_complex_feature_bundle(
+            ligand_id="lig_a",
+            docking_score=-8.5,
+            interface_features={"interface_contact_proxy": 0.7, "hbond_proxy": 0.4, "shape_proxy": 0.3},
+            ligand_bundle=ligand,
+            protein_bundle=protein,
+        )
+        expected = [
+            "complex_contact_count",
+            "complex_hbond_proxy",
+            "complex_interaction_density",
+            "energy_contact_proxy",
+            "energy_interaction_decomposition",
+        ]
+        for name in expected:
+            self.assertIn(name, complex_bundle.features)
+            self.assertTrue(complex_bundle.features[name].available)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_haddock_backend.py b/tests/test_haddock_backend.py
new file mode 100644
index 0000000000000000000000000000000000000000..050636eda572cd3dbc195043b14a3d62a640c98e
--- /dev/null
+++ b/tests/test_haddock_backend.py
@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import unittest
+from pathlib import Path
+
+from libs.docking.backend_haddock import HADDOCKBackend
+from libs.docking.base import DockingResult
+
+
+class TestHADDOCKBackend(unittest.TestCase):
+    def test_capability_schema(self) -> None:
+        backend = HADDOCKBackend()
+        cap = backend.check_capability()
+        self.assertEqual(cap.backend_name, "haddock")
+        self.assertIn("mode", cap.details)
+        self.assertIn("score_semantics", cap.details)
+
+    def test_parse_results_provenance(self) -> None:
+        backend = HADDOCKBackend()
+        rows = backend.parse_results(
+            [
+                DockingResult(
+                    ligand_id="lig_1",
+                    docking_score=-12.34,
+                    pose_path=Path("/tmp/pose.pdb"),
+                    backend_name="haddock",
+                    backend_mode="real-haddock3-rescore",
+                    score_source="haddock3:emscoring",
+                    raw_output_file="/tmp/stdout.log",
+                    parsed_from="/tmp/stdout.log::HADDOCK-score (emscoring)",
+                    fallback_used=False,
+                    success=True,
+                )
+            ]
+        )
+        self.assertEqual(len(rows), 1)
+        self.assertEqual(rows[0]["quantity_type"], "energy_proxy")
+        self.assertEqual(rows[0]["backend_mode"], "real-haddock3-rescore")
+
+
+if __name__ == "__main__":
+    unittest.main()
+
diff --git a/tests/test_large_plot_outputs.py b/tests/test_large_plot_outputs.py
new file mode 100644
index 0000000000000000000000000000000000000000..fb4814382970b087f042eb834bc68c6c4c0f5c6b
--- /dev/null
+++ b/tests/test_large_plot_outputs.py
@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+from pipeline.run_large_benchmark import _plot_large
+
+
+class TestLargePlotOutputs(unittest.TestCase):
+    def test_required_plot_files_created(self) -> None:
+        rows = []
+        run_specs = [
+            ("adaptive_docking_only_top1", "adaptive", "docking_only", 1),
+            ("adaptive_docking_only", "adaptive", "docking_only", 1),
+            ("adaptive_full_feature", "adaptive", "full_feature", 1),
+            ("naive_docking_only_s11", "naive_random", "docking_only", 11),
+            ("naive_full_feature_s11", "naive_random", "full_feature", 11),
+            ("cluster_docking_only_s101", "cluster_naive", "docking_only", 101),
+            ("cluster_full_feature_s101", "cluster_naive", "full_feature", 101),
+        ]
+        for run_id, grp, mode, seed in run_specs:
+            for step in range(20):
+                rows.append(
+                    {
+                        "run_id": run_id,
+                        "strategy": run_id,
+                        "strategy_group": grp,
+                        "mode": mode,
+                        "seed": seed,
+                        "step": step,
+                        "docking_score": float(5 + step * 0.1 + (0.5 if grp == "naive_random" else 0.0)),
+                        "final_score": float(4.5 + step * 0.1 + (0.5 if grp == "naive_random" else 0.0)),
+                        "is_reference": step == 0,
+                        "top_pose_rmsd_consistency": float(0.5 + 0.01 * step),
+                        "replicate_score_variance": float(0.1 + 0.01 * step),
+                    }
+                )
+        combined = pd.DataFrame(rows)
+        metrics = pd.DataFrame(
+            [
+                {
+                    "run_id": "adaptive_docking_only_top1",
+                    "strategy": "adaptive_docking_only_top1",
+                    "strategy_group": "adaptive",
+                    "mode": "docking_only",
+                    "top10_in_first10pct": 0.2,
+                    "top10_in_first20pct": 0.3,
+                    "best_score_so_far_auc": -10.0,
+                },
+                {
+                    "run_id": "adaptive_docking_only",
+                    "strategy": "adaptive_docking_only",
+                    "strategy_group": "adaptive",
+                    "mode": "docking_only",
+                    "top10_in_first10pct": 0.3,
+                    "top10_in_first20pct": 0.4,
+                    "best_score_so_far_auc": -12.0,
+                },
+                {
+                    "run_id": "adaptive_full_feature",
+                    "strategy": "adaptive_full_feature",
+                    "strategy_group": "adaptive",
+                    "mode": "full_feature",
+                    "top10_in_first10pct": 0.35,
+                    "top10_in_first20pct": 0.45,
+                    "best_score_so_far_auc": -13.0,
+                },
+            ]
+        )
+        feature_importance = {"rdock_total_score": 0.2, "rdock_vdw_term": 0.1, "ligand_logp": 0.05}
+
+        with tempfile.TemporaryDirectory() as tmp:
+            out = Path(tmp)
+            paths = _plot_large(output_dir=out, combined=combined, metrics_df=metrics, feature_importance=feature_importance)
+            self.assertTrue(paths)
+            required = [
+                "selected_score_vs_step_docking_only.png",
+                "selected_score_vs_step_full_feature.png",
+                "rdock_top1_vs_multipose_top10.png",
+                "rdock_top1_vs_multipose_top20.png",
+                "rdock_feature_variant_comparison.png",
+                "rdock_pose_consistency_vs_score.png",
+                "rdock_replicate_stability_vs_score.png",
+                "rdock_native_feature_importance.png",
+            ]
+            for name in required:
+                p = out / "plots" / name
+                self.assertTrue(p.exists() and p.stat().st_size > 0, f"Missing/non-empty plot: {name}")
+
+
+if __name__ == "__main__":
+    unittest.main()
+
diff --git a/tests/test_missing_features.py b/tests/test_missing_features.py
new file mode 100644
index 0000000000000000000000000000000000000000..e1d23654d3a3fcb43a4eb1ead05a5add21466911
--- /dev/null
+++ b/tests/test_missing_features.py
@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+
+from libs.adaptive.features import FeatureBundle, FeatureValue, bundles_to_wide_frames
+
+
+class TestMissingFeatures(unittest.TestCase):
+    def test_missing_features_are_masked_and_not_silent_zero(self) -> None:
+        b1 = FeatureBundle(
+            object_id="lig_1",
+            features={
+                "f_present": FeatureValue(value=1.5, available=True, source="test", feature_type="exact"),
+                "f_missing": FeatureValue(value=None, available=False, source="test", feature_type="proxy"),
+            },
+        )
+        b2 = FeatureBundle(
+            object_id="lig_2",
+            features={
+                "f_present": FeatureValue(value=2.5, available=True, source="test", feature_type="exact"),
+                "f_missing": FeatureValue(value=3.0, available=True, source="test", feature_type="proxy"),
+            },
+        )
+
+        values, masks, names = bundles_to_wide_frames([b1, b2])
+        self.assertIn("f_missing", names)
+
+        lig1 = values.loc[values["ligand_id"] == "lig_1"].iloc[0]
+        lig1_mask = masks.loc[masks["ligand_id"] == "lig_1"].iloc[0]
+
+        self.assertTrue(np.isnan(float(lig1["f_missing"])))
+        self.assertEqual(int(lig1_mask["mask_f_missing"]), 0)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_model_masking.py b/tests/test_model_masking.py
new file mode 100644
index 0000000000000000000000000000000000000000..32084ba35c88562ef90c4d3af77546119264b4cd
--- /dev/null
+++ b/tests/test_model_masking.py
@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+
+from libs.adaptive.surrogate_model import SurrogateConfig, SurrogateModel
+
+
+class TestModelMasking(unittest.TestCase):
+    def test_surrogate_accepts_feature_masks(self) -> None:
+        rng = np.random.default_rng(123)
+        n = 40
+        d = 6
+
+        x = rng.normal(size=(n, d))
+        m = np.ones((n, d), dtype=float)
+
+        # Explicitly mark one channel as missing in half of samples.
+        x[:20, 2] = np.nan
+        m[:20, 2] = 0.0
+
+        y = 0.8 * np.nan_to_num(x[:, 0], nan=0.0) - 0.2 * np.nan_to_num(x[:, 1], nan=0.0) + rng.normal(0, 0.05, n)
+
+        model = SurrogateModel(
+            SurrogateConfig(
+                prefer_xgboost=False,
+                n_estimators=80,
+                min_train_samples=8,
+                max_depth_small=3,
+                max_depth_large=4,
+            )
+        )
+
+        fit_stats = model.fit(
+            features=x,
+            masks=m,
+            y=y,
+            feature_names=[f"f{i}" for i in range(d)],
+            mask_names=[f"mask_f{i}" for i in range(d)],
+        )
+        self.assertGreaterEqual(fit_stats["n_train"], 8)
+
+        pred = model.predict_bundle(x[:5], m[:5])
+        self.assertEqual(pred["expected_score"].shape[0], 5)
+        self.assertTrue(np.isfinite(pred["expected_score"]).all())
+        self.assertTrue(np.isfinite(pred["uncertainty"]).all())
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_multifidelity_controls.py b/tests/test_multifidelity_controls.py
new file mode 100644
index 0000000000000000000000000000000000000000..483cee114c86e04808181912dd206cdf360e86c9
--- /dev/null
+++ b/tests/test_multifidelity_controls.py
@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import unittest
+
+import pandas as pd
+
+from libs.benchmark.multifidelity import (
+    ExplorationControls,
+    StoppingControls,
+    UncertaintyControls,
+    enforce_control_limits,
+    simulate_multifidelity_policy,
+)
+
+
+class TestMultifidelityControls(unittest.TestCase):
+    def test_control_limit_enforced(self) -> None:
+        cfg = {
+            "stopping": {"a": 1, "b": 2, "c": 3, "d": 4},
+            "exploration": {},
+            "uncertainty": {},
+        }
+        with self.assertRaises(ValueError):
+            enforce_control_limits(cfg)
+
+    def test_diversity_fallback_only_after_plateau(self) -> None:
+        rows = []
+        for i in range(40):
+            rows.append(
+                {
+                    "ligand_id": f"l{i}",
+                    "step": i,
+                    "cluster_id": 1 if i < 30 else 2,
+                    "hypercluster_id": 1,
+                    "docking_score": -6.0 if i < 30 else -6.5,
+                    "predicted_score_prebatch": -6.0,
+                    "predicted_uncertainty_prebatch": 0.2,
+                }
+            )
+        df = pd.DataFrame(rows)
+        truth_map = {f"l{i}": {"rank_percentile": float(50 - i)} for i in range(40)}
+
+        selected, trace = simulate_multifidelity_policy(
+            df,
+            truth_map=truth_map,
+            budget=30,
+            min_budget=5,
+            max_budget=30,
+            wall_time_per_dock=0.1,
+            max_wall_time_seconds=20.0,
+            stopping=StoppingControls(target_rank_percentile=0.1, peak_patience=5, min_improvement_delta=0.01),
+            exploration=ExplorationControls(stagnation_patience=3, diversity_boost_strength=0.6, dominant_window=10),
+            uncertainty=UncertaintyControls(uncertainty_low_threshold=0.3, uncertainty_patience=4, expected_gain_threshold=0.01),
+        )
+
+        self.assertFalse(selected.empty)
+        self.assertFalse(trace.empty)
+        bad = trace[(trace["fallback_triggered"].astype(bool)) & (~trace["dominant_plateau"].astype(bool))]
+        self.assertTrue(bad.empty)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_multifidelity_regularized.py b/tests/test_multifidelity_regularized.py
new file mode 100644
index 0000000000000000000000000000000000000000..55c73df7901e782bdc0fb3dda38c202c375b3ddd
--- /dev/null
+++ b/tests/test_multifidelity_regularized.py
@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+
+import pandas as pd
+
+from pipeline.run_multifidelity_regularized import (
+    IDENTIFIER_COLS,
+    PRIMARY_METRICS,
+    SECONDARY_METRICS,
+    _reorder_with_shortlist,
+    _require_regularized_parameter_set,
+)
+
+
+class TestMultifidelityRegularized(unittest.TestCase):
+    def test_parameter_regularization_enforced(self) -> None:
+        cfg = {
+            "parameters": {
+                "max_budget": 1000,
+                "min_budget": 250,
+                "epsilon_quality_target": 0.1,
+                "time_importance": 0.5,
+                "shortlist_fraction": 0.3,
+                "haddock_shortlist_size": 12,
+            }
+        }
+        _require_regularized_parameter_set(cfg)
+
+    def test_shortlist_reorder(self) -> None:
+        df = pd.DataFrame(
+            {
+                "ligand_id": ["l1", "l2", "l3", "l4"],
+                "step": [0, 1, 2, 3],
+                "final_score": [1.0, 2.0, 3.0, 4.0],
+            }
+        )
+        out = _reorder_with_shortlist(df, {"l3", "l4"})
+        self.assertEqual(out["ligand_id"].tolist()[:2], ["l3", "l4"])
+        self.assertEqual(out["step"].tolist(), [0, 1, 2, 3])
+
+    def test_metric_columns_regularized(self) -> None:
+        expected = set(IDENTIFIER_COLS + PRIMARY_METRICS + SECONDARY_METRICS)
+        # Ensure no duplicates and stable compact set.
+        self.assertEqual(len(expected), len(IDENTIFIER_COLS + PRIMARY_METRICS + SECONDARY_METRICS))
+        self.assertGreaterEqual(len(PRIMARY_METRICS), 6)
+        self.assertLessEqual(len(SECONDARY_METRICS), 4)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_no_fallback_single_library.py b/tests/test_no_fallback_single_library.py
new file mode 100644
index 0000000000000000000000000000000000000000..77aa2ff84390b6dfc483bb40b6ed2948f319e4c3
--- /dev/null
+++ b/tests/test_no_fallback_single_library.py
@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+
+import pandas as pd
+import yaml
+import shutil
+
+from pipeline.run_experimental_benchmark_single_library import run_single_library_benchmark
+
+
+class TestNoFallbackSingleLibrary(unittest.TestCase):
+    def test_strict_real_backend_only(self) -> None:
+        cfg = yaml.safe_load(Path("configs/experimental_benchmark_single_library.yaml").read_text(encoding="utf-8"))
+        cfg["run"]["adaptive_budget"] = 3
+        cfg["run"]["baseline_budget"] = 3
+        cfg["run"]["batch_size"] = 3
+        cfg["run"]["max_batches"] = 1
+        cfg["benchmark_dataset"]["shared_library_target_size"] = 120
+        cfg["benchmark_dataset"]["reuse_existing"] = True
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            cfg["run"]["output_dir"] = str(Path(tmpdir) / "res")
+            src_data = Path("data/ligands/experimental_benchmark_single_library")
+            tmp_data = Path(tmpdir) / "data" / "ligands_single"
+            shutil.copytree(src_data, tmp_data)
+            cfg["benchmark_dataset"]["output_dir"] = str(tmp_data)
+            cfg_path = Path(tmpdir) / "cfg.yaml"
+            cfg_path.write_text(yaml.safe_dump(cfg), encoding="utf-8")
+
+            out = run_single_library_benchmark(cfg_path)
+            parsed = pd.read_csv(Path(out["paths"]["parsed_scores"]))
+            self.assertFalse(parsed["fallback_used"].astype(bool).any())
+            self.assertTrue((parsed["backend_mode"] == "real-rdock").all())
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_overnight_stop_model_outputs.py b/tests/test_overnight_stop_model_outputs.py
new file mode 100644
index 0000000000000000000000000000000000000000..a8a718892791250d32642eead58279bba4c6bd0f
--- /dev/null
+++ b/tests/test_overnight_stop_model_outputs.py
@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import unittest
+
+import pandas as pd
+
+from pipeline.run_overnight_stop_model import _objective_comparison
+
+
+class TestOvernightStopModelOutputs(unittest.TestCase):
+    def test_objective_comparison_schema(self) -> None:
+        rows = [
+            {
+                "dataset": "dataset_A",
+                "strategy": "adaptive_percentile_target",
+                "stop_model": "percentile_target",
+                "budget": 100,
+                "best_found_rank_percentile": 5.0,
+                "quality_loss_vs_exhaustive_best": 0.2,
+                "docking_reduction_fraction": 0.9,
+                "quality_per_time": 0.5,
+                "quality_per_docking": 0.05,
+                "estimated_probability_target_percentile": 0.8,
+                "marginal_expected_gain": 0.01,
+            },
+            {
+                "dataset": "dataset_A",
+                "strategy": "adaptive_hybrid",
+                "stop_model": "hybrid",
+                "budget": 250,
+                "best_found_rank_percentile": 2.0,
+                "quality_loss_vs_exhaustive_best": 0.1,
+                "docking_reduction_fraction": 0.85,
+                "quality_per_time": 0.45,
+                "quality_per_docking": 0.04,
+                "estimated_probability_target_percentile": 0.9,
+                "marginal_expected_gain": 0.008,
+            },
+        ]
+        df = pd.DataFrame(rows)
+        out = _objective_comparison(
+            df,
+            objectives=["quality_per_time", "hybrid_objective"],
+            target_percentile=1.0,
+            budget_grid=[50, 100, 250],
+        )
+        self.assertFalse(out.empty)
+        needed = {"scope", "dataset", "objective", "best_strategy", "best_stop_model", "best_budget", "best_objective_score", "trivial_solution"}
+        self.assertTrue(needed.issubset(set(out.columns)))
+        self.assertIn("global", set(out["scope"].tolist()))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_parallel_backend_batch.py b/tests/test_parallel_backend_batch.py
new file mode 100644
index 0000000000000000000000000000000000000000..3abd081261c91fb227e904a9069eac818c5e5928
--- /dev/null
+++ b/tests/test_parallel_backend_batch.py
@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+
+from libs.docking.backend_rdock import RDockBackend, RDockConfig
+
+
+class TestParallelBackendBatch(unittest.TestCase):
+    def test_parallel_jobs_dock_two_ligands(self) -> None:
+        backend = RDockBackend(RDockConfig(n_runs=2, parallel_jobs=2))
+        cap = backend.check_capability()
+        self.assertTrue(cap.available, f"Expected real backend available, got: {cap.details}")
+
+        with tempfile.TemporaryDirectory() as tmp:
+            tmpdir = Path(tmp)
+            target = Path("data/targets/smoke_target.pdb")
+            target_ctx = backend.prepare_target(target, tmpdir / "target")
+            lig1 = backend.prepare_ligand("L1", "CCO", tmpdir / "l1")
+            lig2 = backend.prepare_ligand("L2", "CCN", tmpdir / "l2")
+            results = backend.dock(
+                target_context=target_ctx,
+                ligand_files=[lig1, lig2],
+                work_dir=tmpdir / "dock",
+                allow_mock=False,
+                require_real_backend=True,
+            )
+            parsed = backend.parse_results(results)
+            self.assertEqual(len(parsed), 2)
+            self.assertTrue(all(r["backend_mode"] == "real-rdock" for r in parsed))
+            self.assertTrue(all(not bool(r["fallback_used"]) for r in parsed))
+
+
+if __name__ == "__main__":
+    unittest.main()
+
diff --git a/tests/test_per_ligand_reporting_schema.py b/tests/test_per_ligand_reporting_schema.py
new file mode 100644
index 0000000000000000000000000000000000000000..6aefce31bd1635dcc2043f1b9431d3a380b717eb
--- /dev/null
+++ b/tests/test_per_ligand_reporting_schema.py
@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+
+import pandas as pd
+import yaml
+
+from pipeline.run_experimental_benchmark import run_benchmark
+
+
+class TestPerLigandReportingSchema(unittest.TestCase):
+    def test_schema_contains_quantity_and_rdock_features(self) -> None:
+        cfg = yaml.safe_load(Path("configs/experimental_benchmark.yaml").read_text(encoding="utf-8"))
+        with tempfile.TemporaryDirectory() as tmp:
+            cfg["run"]["output_dir"] = str(Path(tmp) / "bench_schema")
+            cfg["run"]["adaptive_budget"] = 4
+            cfg["run"]["baseline_budget"] = 4
+            cfg["run"]["batch_size"] = 2
+            cfg["run"]["max_batches"] = 5
+            cfg["run"]["dataset_subset_size"] = 12
+            cfg["benchmark_dataset"]["reuse_existing"] = True
+            cfg_path = Path(tmp) / "cfg.yaml"
+            cfg_path.write_text(yaml.safe_dump(cfg), encoding="utf-8")
+
+            out = run_benchmark(cfg_path)
+            parsed = pd.read_csv(Path(out["output_dir"]) / "parsed_scores.csv")
+
+            required = [
+                "quantity_type",
+                "rdock_total_score",
+                "n_generated_poses",
+                "best_pose_score",
+                "mean_top3_pose_score",
+                "mean_top5_pose_score",
+                "std_top5_pose_score",
+                "pose_score_gap_1_2",
+                "rdock_internal_ligand_term",
+                "rdock_polar_term",
+                "rdock_vdw_term",
+                "top_pose_rmsd_consistency",
+                "contact_overlap_consistency",
+                "hotspot_contact_frequency",
+                "subpocket_match_score",
+            ]
+            for col in required:
+                self.assertIn(col, parsed.columns)
+            self.assertTrue(parsed["quantity_type"].isin(["docking_score", "affinity_proxy", "energy_proxy", "unavailable"]).all())
+
+
+if __name__ == "__main__":
+    unittest.main()
+
diff --git a/tests/test_pocket_modes.py b/tests/test_pocket_modes.py
new file mode 100644
index 0000000000000000000000000000000000000000..d6c8c9f0376b910e3c546b0c15a5a36e67b6e551
--- /dev/null
+++ b/tests/test_pocket_modes.py
@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+
+from libs.docking.pocket import (
+    POCKET_MODE_REFERENCE,
+    POCKET_MODE_REFERENCE_RELAXED,
+    POCKET_MODE_USER_FIXED,
+    resolve_pocket_spec,
+)
+
+
+PDB_WITH_LIGAND = """\
+ATOM      1  N   GLY A   1      11.104  13.207   9.348  1.00 20.00           N
+ATOM      2  CA  GLY A   1      12.560  13.286   9.460  1.00 20.00           C
+HETATM    3  C1  NUT A 401      14.000  16.000  10.000  1.00 20.00           C
+HETATM    4  C2  NUT A 401      15.500  16.500  10.500  1.00 20.00           C
+HETATM    5  O1  NUT A 401      14.700  15.000  10.300  1.00 20.00           O
+END
+"""
+
+PDB_NO_LIGAND = """\
+ATOM      1  N   GLY A   1      10.000  10.000  10.000  1.00 20.00           N
+ATOM      2  CA  GLY A   1      12.000  10.000  10.000  1.00 20.00           C
+END
+"""
+
+
+class TestPocketModes(unittest.TestCase):
+    def test_user_fixed_override_precedence(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            pdb = Path(tmpdir) / "x.pdb"
+            pdb.write_text(PDB_WITH_LIGAND, encoding="utf-8")
+            spec = resolve_pocket_spec(
+                target_path=pdb,
+                pocket_mode=POCKET_MODE_REFERENCE,
+                pocket_center="1.0,2.0,3.0",
+                pocket_radius=7.5,
+                pocket_reference_ligand_id="NUT",
+            )
+            self.assertEqual(spec.mode, POCKET_MODE_USER_FIXED)
+            self.assertEqual(spec.center, (1.0, 2.0, 3.0))
+            self.assertAlmostEqual(spec.radius, 7.5, places=6)
+            self.assertEqual(spec.source, "user_explicit_override")
+
+    def test_reference_complex_mode_uses_crystal_ligand(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            pdb = Path(tmpdir) / "x.pdb"
+            pdb.write_text(PDB_WITH_LIGAND, encoding="utf-8")
+            spec = resolve_pocket_spec(
+                target_path=pdb,
+                pocket_mode=POCKET_MODE_REFERENCE,
+                pocket_reference_ligand_id="NUT",
+                fallback_radius=6.0,
+            )
+            self.assertEqual(spec.mode, POCKET_MODE_REFERENCE)
+            self.assertEqual(spec.source, "reference_complex_ligand")
+            self.assertTrue(spec.radius >= 6.0)
+
+    def test_relaxed_mode_increases_radius(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            pdb = Path(tmpdir) / "x.pdb"
+            pdb.write_text(PDB_WITH_LIGAND, encoding="utf-8")
+            strict = resolve_pocket_spec(
+                target_path=pdb,
+                pocket_mode=POCKET_MODE_REFERENCE,
+                pocket_reference_ligand_id="NUT",
+                fallback_radius=6.0,
+            )
+            relaxed = resolve_pocket_spec(
+                target_path=pdb,
+                pocket_mode=POCKET_MODE_REFERENCE_RELAXED,
+                pocket_reference_ligand_id="NUT",
+                pocket_relaxation_margin=2.0,
+                fallback_radius=6.0,
+            )
+            self.assertGreaterEqual(relaxed.radius, strict.radius)
+
+    def test_reference_mode_falls_back_to_receptor_centroid(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            pdb = Path(tmpdir) / "x.pdb"
+            pdb.write_text(PDB_NO_LIGAND, encoding="utf-8")
+            spec = resolve_pocket_spec(
+                target_path=pdb,
+                pocket_mode=POCKET_MODE_REFERENCE,
+                pocket_reference_ligand_id="NUT",
+                fallback_radius=5.5,
+            )
+            self.assertEqual(spec.source, "receptor_centroid_fallback")
+            self.assertAlmostEqual(spec.center[0], 11.0, places=6)
+            self.assertAlmostEqual(spec.radius, 5.5, places=6)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_policy_repair_logic.py b/tests/test_policy_repair_logic.py
new file mode 100644
index 0000000000000000000000000000000000000000..9553264406597e69bd51fb270d2efde0471b0560
--- /dev/null
+++ b/tests/test_policy_repair_logic.py
@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import argparse
+import unittest
+
+import pandas as pd
+
+from libs.adaptive.scheduler import AdaptiveScheduler
+from libs.benchmark.policy_repair import (
+    PolicyRuntimeState,
+    apply_stop_policy,
+    coverage_floor_reached,
+    default_policy_variants,
+    select_cluster_bootstrap_batch,
+)
+from pipeline.run_benchmark import _validate_runner_args
+from pipeline.run_policy_repair_benchmark import _run_metrics
+
+
+class TestPolicyRepairVariants(unittest.TestCase):
+    def test_default_variants_present(self) -> None:
+        variants = default_policy_variants()
+        self.assertIn("adaptive_hard_stop", variants)
+        self.assertIn("adaptive_soft_stop", variants)
+        self.assertIn("adaptive_no_stop", variants)
+        self.assertIn("adaptive_cluster_bootstrap", variants)
+        self.assertIn("adaptive_soft_stop_cluster_floor", variants)
+
+    def test_hard_stop_policy(self) -> None:
+        variant = default_policy_variants()["adaptive_hard_stop"]
+        should_stop, event, _ = apply_stop_policy(
+            variant,
+            PolicyRuntimeState(),
+            stop_signal=True,
+            stop_reason="stagnation",
+            coverage_floor_active=False,
+        )
+        self.assertTrue(should_stop)
+        self.assertEqual(event, "stagnation")
+
+    def test_soft_stop_starts_recovery(self) -> None:
+        variant = default_policy_variants()["adaptive_soft_stop"]
+        state = PolicyRuntimeState()
+        should_stop, event, state = apply_stop_policy(
+            variant,
+            state,
+            stop_signal=True,
+            stop_reason="stagnation",
+            coverage_floor_active=False,
+        )
+        self.assertFalse(should_stop)
+        self.assertEqual(event, "soft_recovery_started")
+        self.assertGreater(state.soft_recovery_remaining, 0)
+
+    def test_cluster_floor_blocks_stop(self) -> None:
+        variant = default_policy_variants()["adaptive_soft_stop_cluster_floor"]
+        should_stop, event, _ = apply_stop_policy(
+            variant,
+            PolicyRuntimeState(),
+            stop_signal=True,
+            stop_reason="stagnation",
+            coverage_floor_active=True,
+        )
+        self.assertFalse(should_stop)
+        self.assertEqual(event, "coverage_floor_blocked_stop")
+
+    def test_coverage_floor_reached(self) -> None:
+        variant = default_policy_variants()["adaptive_soft_stop_cluster_floor"]
+        self.assertFalse(
+            coverage_floor_reached(
+                variant,
+                cluster_coverage=0.2,
+                hypercluster_coverage=0.8,
+            )
+        )
+        self.assertTrue(
+            coverage_floor_reached(
+                variant,
+                cluster_coverage=0.8,
+                hypercluster_coverage=0.8,
+            )
+        )
+
+    def test_cluster_bootstrap_prefers_unsampled(self) -> None:
+        ligands = [f"l{i}" for i in range(6)]
+        df = pd.DataFrame({"ligand_id": ligands})
+        cluster_map = {"l0": 0, "l1": 0, "l2": 1, "l3": 1, "l4": 2, "l5": 2}
+        hyper_map = {0: 0, 1: 0, 2: 1}
+        sched = AdaptiveScheduler()
+        sched.initialize(df, cluster_map, hyper_map)
+
+        batch = select_cluster_bootstrap_batch(
+            sched,
+            sampled_clusters={0},
+            batch_size=3,
+        )
+        selected_clusters = {cluster_map[x] for x in batch}
+        self.assertIn(1, selected_clusters)
+        self.assertIn(2, selected_clusters)
+
+
+class TestPolicyRepairRunnerAndMetrics(unittest.TestCase):
+    def test_runner_accepts_policy_repair_type(self) -> None:
+        args = argparse.Namespace(
+            benchmark_type="policy_repair",
+            backend="rdock",
+            mode="full-feature",
+            strategies=["adaptive", "naive", "cluster-naive"],
+        )
+        _validate_runner_args(args)
+
+    def test_policy_metrics_schema_keys(self) -> None:
+        df = pd.DataFrame(
+            {
+                "step": [0, 1, 2, 3, 4],
+                "ligand_id": ["a", "b", "c", "d", "e"],
+                "docking_score": [-1.0, -2.0, -3.0, -4.0, -5.0],
+                "final_score": [-1.1, -2.1, -3.1, -4.1, -5.1],
+            }
+        )
+        metrics, hits = _run_metrics(
+            df,
+            truth_top10pct={"a", "b"},
+            truth_top_ids=["a", "b", "c", "d", "e"],
+            budget=5,
+        )
+        for k in [
+            "top10_in_first10pct",
+            "top10_in_first20pct",
+            "top10_in_first30pct",
+            "early_mean_score",
+            "late_mean_score",
+            "best_score_so_far_auc",
+            "best_final_so_far_auc",
+        ]:
+            self.assertIn(k, metrics)
+        self.assertFalse(hits.empty)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_ppi_output_schema.py b/tests/test_ppi_output_schema.py
new file mode 100644
index 0000000000000000000000000000000000000000..e25b647d62dfd858c301875c76355c6d46f72ed1
--- /dev/null
+++ b/tests/test_ppi_output_schema.py
@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+
+import pandas as pd
+import yaml
+
+from pipeline.run_ppi_sanity_check import run_ppi_sanity_check
+
+
+class TestPPIOutputSchema(unittest.TestCase):
+    def test_required_schema_columns(self) -> None:
+        cfg = yaml.safe_load(Path("configs/ppi_sanity_check.yaml").read_text(encoding="utf-8"))
+        with tempfile.TemporaryDirectory() as tmp:
+            cfg["run"]["output_dir"] = str(Path(tmp) / "ppi_schema")
+            cfg["reference"]["n_variants"] = 7
+            cfg["disk_guard"]["min_free_gb"] = 0.1
+            cfg_path = Path(tmp) / "ppi_schema.yaml"
+            cfg_path.write_text(yaml.safe_dump(cfg), encoding="utf-8")
+            out = run_ppi_sanity_check(cfg_path)
+            root = Path(out["output_dir"])
+
+            ranking = pd.read_csv(root / "ranking.csv")
+            features = pd.read_csv(root / "features.csv")
+            metadata = pd.read_csv(root / "metadata.csv")
+
+            for col in [
+                "ligand_id",
+                "sequence",
+                "backend_name",
+                "backend_mode",
+                "score_source",
+                "quantity_type",
+                "docking_score",
+                "final_score",
+                "rank",
+            ]:
+                self.assertIn(col, ranking.columns)
+
+            for col in ["ligand_id", "seq_identity", "anchor_match", "blosum62_mean"]:
+                self.assertIn(col, features.columns)
+
+            for col in ["reference_pdb_id", "receptor_chain_id", "peptide_chain_id", "benchmark_type"]:
+                self.assertIn(col, metadata.columns)
+
+
+if __name__ == "__main__":
+    unittest.main()
+
diff --git a/tests/test_ppi_sanity_check.py b/tests/test_ppi_sanity_check.py
new file mode 100644
index 0000000000000000000000000000000000000000..2c80524f7254e89072a32e90bc5b8f62fecf30b0
--- /dev/null
+++ b/tests/test_ppi_sanity_check.py
@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+
+import pandas as pd
+import yaml
+
+from pipeline.run_ppi_sanity_check import run_ppi_sanity_check
+
+
+class TestPPISanityCheck(unittest.TestCase):
+    def test_pipeline_outputs(self) -> None:
+        cfg = yaml.safe_load(Path("configs/ppi_sanity_check.yaml").read_text(encoding="utf-8"))
+        with tempfile.TemporaryDirectory() as tmp:
+            cfg["run"]["output_dir"] = str(Path(tmp) / "ppi")
+            cfg["reference"]["n_variants"] = 8
+            cfg["disk_guard"]["min_free_gb"] = 0.1
+            cfg_path = Path(tmp) / "ppi.yaml"
+            cfg_path.write_text(yaml.safe_dump(cfg), encoding="utf-8")
+
+            out = run_ppi_sanity_check(cfg_path)
+            o = Path(out["output_dir"])
+            for f in [
+                "summary.json",
+                "ranking.csv",
+                "features.csv",
+                "metadata.csv",
+                "timings.csv",
+                "report.md",
+                "self_audit_report.md",
+            ]:
+                p = o / f
+                self.assertTrue(p.exists() and p.stat().st_size > 0, f"missing {f}")
+
+            ranking = pd.read_csv(o / "ranking.csv")
+            self.assertTrue((ranking["backend_mode"] == "proxy-peptide-like").all())
+            self.assertTrue((ranking["quantity_type"] == "affinity_proxy").all())
+            self.assertFalse(ranking["fallback_used"].astype(bool).any())
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_ppi_semantics.py b/tests/test_ppi_semantics.py
new file mode 100644
index 0000000000000000000000000000000000000000..f3b2641a1ab0e1cc1f87202be2051f91c99b9399
--- /dev/null
+++ b/tests/test_ppi_semantics.py
@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+
+import json
+import yaml
+
+from pipeline.run_ppi_sanity_check import run_ppi_sanity_check
+
+
+class TestPPISemantics(unittest.TestCase):
+    def test_repaired_ppi_is_not_small_molecule_rdock(self) -> None:
+        cfg = yaml.safe_load(Path("configs/ppi_sanity_check.yaml").read_text(encoding="utf-8"))
+        with tempfile.TemporaryDirectory() as tmp:
+            cfg["run"]["output_dir"] = str(Path(tmp) / "ppi_sem")
+            cfg["reference"]["n_variants"] = 6
+            cfg["disk_guard"]["min_free_gb"] = 0.1
+            cfg_path = Path(tmp) / "ppi_sem.yaml"
+            cfg_path.write_text(yaml.safe_dump(cfg), encoding="utf-8")
+
+            out = run_ppi_sanity_check(cfg_path)
+            summary = json.loads((Path(out["output_dir"]) / "summary.json").read_text(encoding="utf-8"))
+            self.assertEqual(summary["benchmark_type"], "peptide_like")
+            self.assertEqual(summary["backend_semantics"], "sequence_structural_proxy")
+            self.assertFalse(summary["real_rdock_only_successful_rows"])
+            self.assertTrue(summary["proxy_backend_only"])
+
+
+if __name__ == "__main__":
+    unittest.main()
+
diff --git a/tests/test_rdock_backend.py b/tests/test_rdock_backend.py
new file mode 100644
index 0000000000000000000000000000000000000000..8a47552668ce55e27bfadcbced964f17c279442b
--- /dev/null
+++ b/tests/test_rdock_backend.py
@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+
+from libs.docking.backend_rdock import RDockBackend, RDockConfig
+
+
+class TestRDockBackend(unittest.TestCase):
+    def test_real_rdock_execution_and_provenance(self) -> None:
+        backend = RDockBackend(
+            RDockConfig(
+                n_runs=2,
+                pocket_mode="reference_complex_pocket",
+                pocket_reference_ligand_id="NUT",
+            )
+        )
+        cap = backend.check_capability()
+        self.assertTrue(cap.available, f"Expected real rDock capability, got: {cap.details}")
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmp = Path(tmpdir)
+            pdb = Path("data/targets/large_benchmark/mdm2_4hg7.pdb").resolve()
+
+            target_ctx = backend.prepare_target(pdb, tmp / "target_prep")
+            lig = backend.prepare_ligand("lig_x", "CCO", tmp / "ligands")
+            results = backend.dock(
+                target_ctx,
+                [lig],
+                tmp / "docking",
+                allow_mock=False,
+                require_real_backend=True,
+            )
+            parsed = backend.parse_results(results)
+
+            self.assertEqual(len(parsed), 1)
+            row = parsed[0]
+            self.assertEqual(row["backend_name"], "rdock")
+            self.assertEqual(row["backend_mode"], "real-rdock")
+            self.assertFalse(row["fallback_used"])
+            self.assertTrue(str(row["score_source"]).startswith("rdock_tag:"))
+            self.assertTrue(Path(str(row["raw_output_file"])).exists())
+            self.assertTrue(float(row["docking_score"]) == float(row["docking_score"]))
+
+            # Real cavity generation proof.
+            self.assertTrue((tmp / "docking" / "receptor.as").exists())
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_rdock_fixed_pocket.py b/tests/test_rdock_fixed_pocket.py
new file mode 100644
index 0000000000000000000000000000000000000000..f2baf7291424154a9a8176bc565b074a4b356b18
--- /dev/null
+++ b/tests/test_rdock_fixed_pocket.py
@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+from libs.docking.backend_rdock import RDockBackend, RDockConfig
+from libs.docking.pocket import PocketSpec
+
+
+PDB_MIN = """\
+ATOM      1  N   GLY A   1      11.104  13.207   9.348  1.00 20.00           N
+ATOM      2  CA  GLY A   1      12.560  13.286   9.460  1.00 20.00           C
+ATOM      3  C   GLY A   1      13.006  14.735   9.754  1.00 20.00           C
+END
+"""
+
+
+class TestRDockFixedPocket(unittest.TestCase):
+    def test_user_fixed_pocket_writes_sphere_mapper(self) -> None:
+        backend = RDockBackend(
+            RDockConfig(
+                pocket_mode="user_fixed_pocket",
+                pocket_center=(1.0, 2.0, 3.0),
+                pocket_radius=7.0,
+            )
+        )
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmp = Path(tmpdir)
+            pdb = tmp / "target.pdb"
+            pdb.write_text(PDB_MIN, encoding="utf-8")
+            ctx = backend.prepare_target(pdb, tmp / "target")
+            pocket_json = Path(ctx["pocket_spec_json"])
+            self.assertTrue(pocket_json.exists())
+            spec = PocketSpec.from_dict(json.loads(pocket_json.read_text(encoding="utf-8")))
+            self.assertEqual(spec.mode, "user_fixed_pocket")
+            self.assertEqual(spec.center, (1.0, 2.0, 3.0))
+
+            lig = backend.prepare_ligand("lig", "CCO", tmp / "lig")
+            prm = backend.build_site_or_constraints(ctx, lig, tmp / "dock")
+            text = prm.read_text(encoding="utf-8")
+            self.assertIn("RbtSphereSiteMapper", text)
+            self.assertNotIn("REF_MOL", text)
+
+    def test_pocket_spec_stable_across_runs(self) -> None:
+        backend = RDockBackend(
+            RDockConfig(
+                pocket_mode="user_fixed_pocket",
+                pocket_center=(10.0, 11.0, 12.0),
+                pocket_radius=6.5,
+            )
+        )
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmp = Path(tmpdir)
+            pdb = tmp / "target.pdb"
+            pdb.write_text(PDB_MIN, encoding="utf-8")
+            ctx1 = backend.prepare_target(pdb, tmp / "target1")
+            ctx2 = backend.prepare_target(pdb, tmp / "target2")
+            s1 = PocketSpec.from_dict(json.loads(Path(ctx1["pocket_spec_json"]).read_text(encoding="utf-8")))
+            s2 = PocketSpec.from_dict(json.loads(Path(ctx2["pocket_spec_json"]).read_text(encoding="utf-8")))
+            self.assertEqual(s1.center, s2.center)
+            self.assertAlmostEqual(s1.radius, s2.radius, places=6)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_rdock_real_execution.py b/tests/test_rdock_real_execution.py
new file mode 100644
index 0000000000000000000000000000000000000000..594389ab0a9cf9b5b8c6cbe6f74018db36c5a433
--- /dev/null
+++ b/tests/test_rdock_real_execution.py
@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+
+from libs.docking.backend_rdock import RDockBackend, RDockConfig
+
+
+class TestRDockRealExecution(unittest.TestCase):
+    def test_rbcavity_and_rbdock_generate_real_outputs(self) -> None:
+        backend = RDockBackend(
+            RDockConfig(
+                n_runs=2,
+                pocket_mode="reference_complex_pocket",
+                pocket_reference_ligand_id="NUT",
+            )
+        )
+        self.assertTrue(backend.check_capability().available)
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmp = Path(tmpdir)
+            target_path = Path("data/targets/large_benchmark/mdm2_4hg7.pdb").resolve()
+
+            target_ctx = backend.prepare_target(target_path, tmp / "target")
+            lig = backend.prepare_ligand("smk_real", "CCO", tmp / "lig")
+            results = backend.dock(
+                target_ctx,
+                [lig],
+                tmp / "dock",
+                allow_mock=False,
+                require_real_backend=True,
+            )
+            parsed = backend.parse_results(results)
+            row = parsed[0]
+
+            self.assertTrue((tmp / "dock" / "receptor.prm").exists())
+            self.assertTrue((tmp / "dock" / "receptor.as").exists())
+            self.assertTrue(Path(str(row["raw_output_file"])).exists())
+            self.assertGreater(Path(str(row["raw_output_file"])).stat().st_size, 0)
+            self.assertEqual(row["backend_mode"], "real-rdock")
+            self.assertFalse(row["fallback_used"])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_redocking_validation_guards.py b/tests/test_redocking_validation_guards.py
new file mode 100644
index 0000000000000000000000000000000000000000..f26e8426418bae33aa6b3bc808aea4f264a9c8c6
--- /dev/null
+++ b/tests/test_redocking_validation_guards.py
@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+
+from libs.benchmark.redocking_validation import RedockingTarget, RedockingValidationConfig, run_redocking_validation
+from libs.docking.base import DockingError
+
+
+class TestRedockingValidationGuards(unittest.TestCase):
+    def test_attempt_bounds_guard(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            with self.assertRaises(DockingError):
+                run_redocking_validation(
+                    output_dir=Path(tmp),
+                    config=RedockingValidationConfig(attempts=10),
+                    datasets=[],
+                )
+
+    def test_backend_guard(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            dummy = RedockingTarget(
+                dataset="d",
+                target_name="t",
+                target_path=Path(tmp) / "x.pdb",
+                reference_csv=Path(tmp) / "r.csv",
+            )
+            with self.assertRaises(DockingError):
+                run_redocking_validation(
+                    output_dir=Path(tmp),
+                    config=RedockingValidationConfig(attempts=50, backend="smina"),
+                    datasets=[dummy],
+                )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_refactor_integrity.py b/tests/test_refactor_integrity.py
new file mode 100644
index 0000000000000000000000000000000000000000..76fa22e3c6f520eb7a07372790675a1b738e56aa
--- /dev/null
+++ b/tests/test_refactor_integrity.py
@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import unittest
+
+
+class TestRefactorIntegrity(unittest.TestCase):
+    def test_new_reusable_modules_import(self) -> None:
+        import libs.adaptive.thresholding as thresholding  # noqa: F401
+        import libs.benchmark.cleanup as cleanup  # noqa: F401
+        import libs.benchmark.disk_guard as disk_guard  # noqa: F401
+        import libs.benchmark.large_library as large_library  # noqa: F401
+        import libs.modalities.peptide_like as peptide_like  # noqa: F401
+        import libs.benchmark.ordering as ordering  # noqa: F401
+        import libs.benchmark.runtime as runtime  # noqa: F401
+        import libs.docking.rdock_features as rdock_features  # noqa: F401
+
+        self.assertTrue(hasattr(cleanup, "plan_results_cleanup"))
+        self.assertTrue(hasattr(disk_guard, "snapshot_disk_state"))
+        self.assertTrue(hasattr(large_library, "build_large_benchmark_library"))
+        self.assertTrue(hasattr(ordering, "cluster_naive_order"))
+        self.assertTrue(hasattr(peptide_like, "run_peptide_like_proxy_benchmark"))
+        self.assertTrue(hasattr(runtime, "enforce_thread_fairness"))
+        self.assertTrue(hasattr(rdock_features, "parse_rdock_output"))
+        self.assertTrue(hasattr(thresholding, "DynamicEarlyStopController"))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_reference_rank_resolution.py b/tests/test_reference_rank_resolution.py
new file mode 100644
index 0000000000000000000000000000000000000000..0ec5175dfce1fc942a31317937323145b712f909
--- /dev/null
+++ b/tests/test_reference_rank_resolution.py
@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+import pandas as pd
+
+from libs.analysis.ranking import resolve_reference_rank_percentile
+
+
+class TestReferenceRankResolution(unittest.TestCase):
+    def test_uses_oracle_when_available(self) -> None:
+        d = pd.DataFrame(
+            {
+                "ligand_id": ["a", "ref", "b"],
+                "rank_percentile": [5.0, 12.5, 30.0],
+                "run_rank_percentile": [33.3, 66.6, 100.0],
+            }
+        )
+        pct, src = resolve_reference_rank_percentile(d, "ref")
+        self.assertAlmostEqual(pct, 12.5, places=6)
+        self.assertEqual(src, "oracle")
+
+    def test_falls_back_to_run_rank_when_oracle_missing(self) -> None:
+        d = pd.DataFrame(
+            {
+                "ligand_id": ["a", "ref", "b"],
+                "rank_percentile": [2.0, np.nan, 8.0],
+                "run_rank_percentile": [33.3, 66.6, 100.0],
+            }
+        )
+        pct, src = resolve_reference_rank_percentile(d, "ref")
+        self.assertAlmostEqual(pct, 66.6, places=6)
+        self.assertEqual(src, "run_fallback")
+
+    def test_missing_reference(self) -> None:
+        d = pd.DataFrame(
+            {
+                "ligand_id": ["a", "b"],
+                "rank_percentile": [2.0, 8.0],
+                "run_rank_percentile": [50.0, 100.0],
+            }
+        )
+        pct, src = resolve_reference_rank_percentile(d, "ref")
+        self.assertTrue(np.isnan(pct))
+        self.assertEqual(src, "missing")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_reference_recovery_metrics.py b/tests/test_reference_recovery_metrics.py
new file mode 100644
index 0000000000000000000000000000000000000000..e4c56336fc520a3e22fc7cf82f7cade71b80eb20
--- /dev/null
+++ b/tests/test_reference_recovery_metrics.py
@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import unittest
+
+import pandas as pd
+
+from pipeline.run_experimental_benchmark import _recovery_tables
+
+
+class TestReferenceRecoveryMetrics(unittest.TestCase):
+    def test_recovery_table_contains_reference_rows(self) -> None:
+        combined = pd.DataFrame(
+            [
+                {
+                    "strategy": "adaptive",
+                    "step": 0,
+                    "ligand_id": "ref_a",
+                    "smiles": "CCO",
+                    "parent_reference_ligand": "ref_a",
+                    "is_reference": True,
+                    "similarity_to_parent_reference": 1.0,
+                    "cluster_id": 0,
+                    "docking_score": 1.0,
+                    "final_score": 1.0,
+                },
+                {
+                    "strategy": "adaptive",
+                    "step": 1,
+                    "ligand_id": "lig_b",
+                    "smiles": "CCN",
+                    "parent_reference_ligand": "ref_a",
+                    "is_reference": False,
+                    "similarity_to_parent_reference": 0.7,
+                    "cluster_id": 1,
+                    "docking_score": 2.0,
+                    "final_score": 2.0,
+                },
+                {
+                    "strategy": "baseline_random",
+                    "step": 0,
+                    "ligand_id": "lig_c",
+                    "smiles": "CCC",
+                    "parent_reference_ligand": "ref_a",
+                    "is_reference": False,
+                    "similarity_to_parent_reference": 0.2,
+                    "cluster_id": 2,
+                    "docking_score": 3.0,
+                    "final_score": 3.0,
+                },
+            ]
+        )
+        ligands = pd.DataFrame(
+            [
+                {"ligand_id": "ref_a", "smiles": "CCO", "parent_reference_ligand": "ref_a", "similarity_to_reference": 1.0, "scaffold_match": 1},
+                {"ligand_id": "lig_b", "smiles": "CCN", "parent_reference_ligand": "ref_a", "similarity_to_reference": 0.7, "scaffold_match": 1},
+                {"ligand_id": "lig_c", "smiles": "CCC", "parent_reference_ligand": "ref_a", "similarity_to_reference": 0.2, "scaffold_match": 0},
+            ]
+        )
+
+        recovery, comparison, baseline_cmp = _recovery_tables(
+            combined_df=combined,
+            ligands_df=ligands,
+            references=["ref_a"],
+            analog_similarity_threshold=0.65,
+            topk_values=[1, 2],
+        )
+
+        self.assertFalse(recovery.empty)
+        self.assertFalse(comparison.empty)
+        self.assertFalse(baseline_cmp.empty)
+        self.assertTrue((recovery["reference_id"] == "ref_a").all())
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_scheduler.py b/tests/test_scheduler.py
new file mode 100644
index 0000000000000000000000000000000000000000..ecb970cd056bdf5f88421218bd2499617d373580
--- /dev/null
+++ b/tests/test_scheduler.py
@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+import pandas as pd
+
+from libs.adaptive.scheduler import AdaptiveScheduler
+
+
+class TestScheduler(unittest.TestCase):
+    def test_scheduler_round_trip(self) -> None:
+        ligands = [f"lig_{i}" for i in range(10)]
+        df = pd.DataFrame({"ligand_id": ligands})
+        cluster_map = {lid: i % 3 for i, lid in enumerate(ligands)}
+        hyper = {0: 0, 1: 0, 2: 1}
+
+        sched = AdaptiveScheduler()
+        sched.initialize(df, cluster_map, hyper)
+        batch = sched.select_batch()
+        self.assertGreater(len(batch), 0)
+
+        rng = np.random.default_rng(7)
+        feat_names = [f"f_{i}" for i in range(16)]
+        value_df = pd.DataFrame(rng.normal(size=(len(ligands), len(feat_names))), columns=feat_names)
+        value_df.insert(0, "ligand_id", ligands)
+        mask_df = pd.DataFrame(1, index=np.arange(len(ligands)), columns=[f"mask_{n}" for n in feat_names])
+        mask_df.insert(0, "ligand_id", ligands)
+
+        # Make some features explicitly missing.
+        value_df.loc[0, "f_0"] = np.nan
+        mask_df.loc[0, "mask_f_0"] = 0
+
+        ev = pd.DataFrame({"ligand_id": batch, "docking_score": rng.normal(size=len(batch))})
+        stats = sched.update_from_batch(ev, value_df, mask_df)
+        self.assertGreaterEqual(sched.state.round_idx, 1)
+        self.assertIn("n_train", stats)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_single_library_benchmark_outputs.py b/tests/test_single_library_benchmark_outputs.py
new file mode 100644
index 0000000000000000000000000000000000000000..582938c89f94f8430c6ca58007444890c4804c0f
--- /dev/null
+++ b/tests/test_single_library_benchmark_outputs.py
@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+
+import yaml
+import shutil
+
+from pipeline.run_experimental_benchmark_single_library import run_single_library_benchmark
+
+
+class TestSingleLibraryBenchmarkOutputs(unittest.TestCase):
+    def test_outputs_exist_tiny_run(self) -> None:
+        cfg = yaml.safe_load(Path("configs/experimental_benchmark_single_library.yaml").read_text(encoding="utf-8"))
+        cfg["run"]["adaptive_budget"] = 4
+        cfg["run"]["baseline_budget"] = 4
+        cfg["run"]["batch_size"] = 2
+        cfg["run"]["max_batches"] = 2
+        cfg["benchmark_dataset"]["shared_library_target_size"] = 120
+        cfg["benchmark_dataset"]["reuse_existing"] = True
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            cfg["run"]["output_dir"] = str(Path(tmpdir) / "res")
+            src_data = Path("data/ligands/experimental_benchmark_single_library")
+            tmp_data = Path(tmpdir) / "data" / "ligands_single"
+            shutil.copytree(src_data, tmp_data)
+            cfg["benchmark_dataset"]["output_dir"] = str(tmp_data)
+            cfg_path = Path(tmpdir) / "cfg.yaml"
+            cfg_path.write_text(yaml.safe_dump(cfg), encoding="utf-8")
+
+            out = run_single_library_benchmark(cfg_path)
+            root = Path(out["output_dir"])
+            required = [
+                "summary.json",
+                "final_ranking_adaptive.csv",
+                "final_ranking_naive.csv",
+                "reference_recovery.csv",
+                "reference_comparison.csv",
+                "self_audit_report.md",
+            ]
+            for name in required:
+                self.assertTrue((root / name).exists(), f"missing {name}")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_single_library_dataset.py b/tests/test_single_library_dataset.py
new file mode 100644
index 0000000000000000000000000000000000000000..60e9da32fa3559d8df1db42aeeab778395380c09
--- /dev/null
+++ b/tests/test_single_library_dataset.py
@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import unittest
+from pathlib import Path
+
+
+class TestSingleLibraryDataset(unittest.TestCase):
+    def test_shared_library_size_and_reference_inclusion(self) -> None:
+        import pandas as pd
+
+        base = Path("data/ligands/experimental_benchmark_single_library")
+        refs_path = base / "reference_ligands.csv"
+        shared_path = base / "shared_library_dedup.csv"
+
+        self.assertTrue(refs_path.exists(), "reference_ligands.csv is missing")
+        self.assertTrue(shared_path.exists(), "shared_library_dedup.csv is missing")
+
+        refs = pd.read_csv(refs_path)
+        shared = pd.read_csv(shared_path)
+
+        self.assertEqual(refs.shape[0], 3)
+        self.assertGreaterEqual(shared.shape[0], 1200)
+        self.assertLessEqual(shared.shape[0], 1800)
+
+        ref_ids = refs["reference_id"].astype(str).tolist()
+        for ref_id in ref_ids:
+            self.assertTrue((shared["ligand_id"].astype(str) == ref_id).any(), f"Missing reference: {ref_id}")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_smina_backend_timeout.py b/tests/test_smina_backend_timeout.py
new file mode 100644
index 0000000000000000000000000000000000000000..4cad4a77e2b3a75b029cf3eb064b7333944ff3fb
--- /dev/null
+++ b/tests/test_smina_backend_timeout.py
@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from subprocess import TimeoutExpired
+from unittest.mock import patch
+
+from libs.docking.backend_smina import SminaBackend, SminaConfig
+from libs.docking.pocket import PocketSpec
+
+
+def test_smina_timeout_returns_failed_row(tmp_path: Path) -> None:
+    backend = SminaBackend(
+        SminaConfig(
+            command_timeout_seconds=1,
+            parallel_jobs=1,
+            pocket_mode="user_fixed_pocket",
+            pocket_center=(0.0, 0.0, 0.0),
+            pocket_box_size=(10.0, 10.0, 10.0),
+        )
+    )
+    receptor = tmp_path / "rec.pdbqt"
+    receptor.write_text("RECEPTOR\n", encoding="utf-8")
+    ligand = tmp_path / "lig.pdbqt"
+    ligand.write_text("LIGAND\n", encoding="utf-8")
+    pocket = PocketSpec(
+        mode="user_fixed_pocket",
+        source="user_defined",
+        center=(0.0, 0.0, 0.0),
+        box_size=(10.0, 10.0, 10.0),
+        radius=5.0,
+    )
+    pocket_json = tmp_path / "pocket.json"
+    pocket_json.write_text(json.dumps(pocket.to_dict()), encoding="utf-8")
+
+    target_context = {"receptor_pdbqt": receptor, "pocket_json": pocket_json, "target_prepared": receptor}
+
+    with patch("libs.docking.backend_smina._resolve_executable", return_value="/bin/echo"):
+        with patch("libs.docking.backend_smina.run_command", side_effect=TimeoutExpired(cmd="smina", timeout=1)):
+            rows = backend.parse_results(
+                backend.dock(
+                    target_context=target_context,
+                    ligand_files=[ligand],
+                    work_dir=tmp_path / "dock",
+                    allow_mock=False,
+                    require_real_backend=True,
+                )
+            )
+    assert len(rows) == 1
+    assert rows[0]["success"] is False
+    assert str(rows[0]["message"]).startswith("smina_timeout:")
diff --git a/tests/test_smina_score_parsing.py b/tests/test_smina_score_parsing.py
new file mode 100644
index 0000000000000000000000000000000000000000..f78fd2f6ecb5d026c6c1176b089feb4fbcfeeb0c
--- /dev/null
+++ b/tests/test_smina_score_parsing.py
@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+
+from libs.docking.backend_smina import parse_smina_score
+
+
+class TestSminaScoreParsing(unittest.TestCase):
+    def test_parses_minimized_affinity(self) -> None:
+        text = "REMARK minimizedAffinity -7.43\n"
+        score = parse_smina_score(text)
+        self.assertAlmostEqual(score, -7.43, places=6)
+
+    def test_parses_vina_result(self) -> None:
+        text = "REMARK VINA RESULT: -8.11 0.0 0.0\n"
+        score = parse_smina_score(text)
+        self.assertAlmostEqual(score, -8.11, places=6)
+
+    def test_parses_mode_table(self) -> None:
+        text = "mode | affinity | dist from best mode\n   1      -6.5      0.0      0.0\n   2      -5.9      1.1      2.0\n"
+        score = parse_smina_score(text)
+        self.assertAlmostEqual(score, -6.5, places=6)
+
+    def test_returns_nan_when_no_score(self) -> None:
+        score = parse_smina_score("no score lines")
+        self.assertTrue(np.isnan(score))
+
+    def test_parses_affinity_score_only_line(self) -> None:
+        text = "Affinity: 12.34567 (kcal/mol)"
+        score = parse_smina_score(text)
+        self.assertAlmostEqual(score, 12.34567, places=6)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_stability_small_data.py b/tests/test_stability_small_data.py
new file mode 100644
index 0000000000000000000000000000000000000000..fd69b0e024e3ec962c4b9f5a2d21458bfde6e8ba
--- /dev/null
+++ b/tests/test_stability_small_data.py
@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+import pandas as pd
+
+from libs.adaptive.scheduler import AdaptiveScheduler, SchedulerConfig
+from libs.adaptive.surrogate_model import SurrogateConfig
+
+
+class TestStabilitySmallData(unittest.TestCase):
+    def test_scheduler_keeps_model_weight_low_in_warmup(self) -> None:
+        ligands = [f"lig_{i}" for i in range(12)]
+        df = pd.DataFrame({"ligand_id": ligands})
+        cluster_map = {lid: i % 3 for i, lid in enumerate(ligands)}
+        hyper = {0: 0, 1: 0, 2: 1}
+
+        scheduler = AdaptiveScheduler(
+            config=SchedulerConfig(batch_size=4),
+            surrogate_config=SurrogateConfig(prefer_xgboost=False, min_train_samples=20),
+        )
+        scheduler.initialize(df, cluster_map, hyper)
+
+        rng = np.random.default_rng(11)
+        values = pd.DataFrame(rng.normal(size=(len(ligands), 5)), columns=[f"f{i}" for i in range(5)])
+        values.insert(0, "ligand_id", ligands)
+        masks = pd.DataFrame(1, index=np.arange(len(ligands)), columns=[f"mask_f{i}" for i in range(5)])
+        masks.insert(0, "ligand_id", ligands)
+
+        batch = scheduler.select_batch()
+        ev = pd.DataFrame({"ligand_id": batch, "docking_score": rng.normal(size=len(batch))})
+        scheduler.update_from_batch(ev, values, masks)
+
+        self.assertEqual(scheduler.surrogate.backend, "warmup")
+        self.assertAlmostEqual(scheduler.last_model_weight, 0.0, places=6)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_strict_backend_cleanup.py b/tests/test_strict_backend_cleanup.py
new file mode 100644
index 0000000000000000000000000000000000000000..ebe2a53958800312c4597028ab6319545ffac572
--- /dev/null
+++ b/tests/test_strict_backend_cleanup.py
@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import importlib.util
+import math
+import os
+import unittest
+from pathlib import Path
+
+
+class TestStrictBackendCleanup(unittest.TestCase):
+    def test_haddock_wrapper_removed(self) -> None:
+        root = Path(__file__).resolve().parents[1]
+        self.assertFalse((root / "libs/docking/backend_haddock.py").exists())
+        self.assertFalse(importlib.util.find_spec("libs.docking.backend_haddock"))
+
+    def test_thread_policy_formula_85pct(self) -> None:
+        system_threads = max(1, int(os.cpu_count() or 1))
+        threads_used = max(1, int(math.floor(0.85 * system_threads)))
+        self.assertGreaterEqual(threads_used, 1)
+        self.assertLessEqual(threads_used, system_threads)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_thread_fairness.py b/tests/test_thread_fairness.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5652ec8858987a3175b531b0a2719fb3e2d1321
--- /dev/null
+++ b/tests/test_thread_fairness.py
@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import unittest
+
+from libs.benchmark.runtime import AUTO_MINUS_FOUR, enforce_thread_fairness, resolve_threads_used
+
+
+class TestThreadFairness(unittest.TestCase):
+    def test_auto_minus_four_resolution(self) -> None:
+        alloc = resolve_threads_used(AUTO_MINUS_FOUR, system_threads=10)
+        self.assertEqual(alloc.threads_used, 6)
+        self.assertEqual(alloc.policy, AUTO_MINUS_FOUR)
+
+    def test_auto_minus_four_never_below_one(self) -> None:
+        alloc = resolve_threads_used(AUTO_MINUS_FOUR, system_threads=3)
+        self.assertEqual(alloc.threads_used, 1)
+
+    def test_enforce_mutates_config(self) -> None:
+        cfg = {"backend": {"parallel_jobs": AUTO_MINUS_FOUR}}
+        alloc = enforce_thread_fairness(cfg, reserve_threads=4)
+        self.assertEqual(cfg["backend"]["parallel_jobs"], alloc.threads_used)
+        self.assertIn("runtime", cfg)
+        self.assertEqual(cfg["runtime"]["threads_used"], alloc.threads_used)
+
+
+if __name__ == "__main__":
+    unittest.main()
+