nextflow.config

// ═══════════════════════════════════════════════════════════════════════════════
// GPU SCHEDULING NOTE
// ═══════════════════════════════════════════════════════════════════════════════
// GPU selection is now handled by the external Python GPU Orchestrator.
// The orchestrator passes --gpu_id X to Nextflow, which is used in containerOptions.
// See: platform/api/services/gpu_orchestrator.py
// ═══════════════════════════════════════════════════════════════════════════════

def ensureDir(path) {
    def f = new File(path)
    if (!f.exists()) {
        f.mkdirs()
    }
    return f.toString()
}
def cacheRoot = ensureDir(
        System.getenv('XDG_CACHE_HOME')
        ?: (System.getenv('BMS_DATA') ? "${System.getenv('BMS_DATA')}/cache" : "${System.getenv('HOME') ?: '/tmp'}/.cache")
)
def dglCacheDir = ensureDir("${cacheRoot}/dgl")
def dataRootFallback = System.getenv('BMS_DATA') ?: "${System.getenv('HOME') ?: '/tmp'}/.biomodstack"
def bmsContainerRootFallback = System.getenv('BMS_CONTAINER_DIR') ?: "${dataRootFallback}/apptainer"
def cmConfornetsContainer = System.getenv('BMS_CM_CONFORNETS_CONTAINER_PATH')
def toolsRoot = System.getenv('BMS_TOOLS') ?: "${dataRootFallback}/tools"

def findCodeRoot(start) {
    def candidate = new File(start.toString()).absoluteFile
    for (def depth = 0; depth < 3 && candidate != null; depth++) {
        if (new File(candidate, 'scripts').isDirectory()) {
            return candidate.toString()
        }
        candidate = candidate.parentFile
    }
    return new File(start.toString()).absolutePath
}
def codeRootFallback = System.getenv('BMS_HOME')
    ?: findCodeRoot(projectDir)
def mdFeatureFlag = System.getenv('BMS_FEATURE_MOLECULAR_DYNAMICS') ?: '0'
def resolveRfdModels(weightsRoot) {
    def explicit = System.getenv('BMS_RFD_MODELS')
    if (explicit) {
        return explicit
    }
    def classic = "${weightsRoot}/rfd"
    def rfantibody = "${weightsRoot}/rfantibody/rfantibody_repo/weights"
    return new File(rfantibody).exists() ? rfantibody : classic
}
// Selected installed weights are read-only on every placement. Protect the
// original host pathname too when a native guest alias is used: broader data
// mounts must not expose a second writable name for the selected payload.
// The userspace backend consumes the same explicit modes via its private view.
def weightBind(source, target = null) {
    def guest = target ?: source
    def concrete = new File(source.toString()).toPath()
    try {
        concrete = concrete.toRealPath()
    } catch (java.io.IOException ignored) {
        // Absent assets keep their existing acquisition/native error behavior.
    }
    def bindings = ["${concrete}:${guest}:ro"]
    if (guest.toString() != source.toString()) {
        bindings.add("${concrete}:${source}:ro")
    }
    if (concrete.toString() != source.toString() && concrete.toString() != guest.toString()) {
        bindings.add("${concrete}:${concrete}:ro")
    }
    // A selected pinned layout contains relative aliases to existing acquisition
    // objects. Different-depth guest mounts need those exact referents too.
    // This only projects already-selected paths; registry/reader identity checks
    // remain with their owners. Do not mount/walk the whole acquisition store.
    def layout = concrete
    while (layout != null && !(layout.parent?.parent?.fileName?.toString() == 'layouts'
            && layout.fileName.toString() ==~ /[0-9a-f]{64}/)) {
        layout = layout.parent
    }
    if (layout != null && java.nio.file.Files.isDirectory(concrete)) {
        def objects = layout.parent.parent.parent.resolve('objects/sha256')
        try {
            def members = java.nio.file.Files.walk(concrete)
            try {
                members.filter { java.nio.file.Files.isSymbolicLink(it) }.iterator().toList()
                    .sort { a, b -> a.toString() <=> b.toString() }.each { member ->
                        def referent = member.toRealPath()
                        if (referent.parent?.parent == objects
                                && referent.parent.fileName.toString() ==~ /[0-9a-f]{64}/
                                && referent.fileName.toString() == 'runtime.sif') {
                            def projected = new File(guest.toString()).toPath()
                                .resolve(concrete.relativize(referent)).normalize()
                            bindings.add("${referent}:${projected}:ro")
                            bindings.add("${referent}:${referent}:ro")
                        }
                    }
            } finally {
                members.close()
            }
        } catch (java.io.IOException ignored) {
            // Missing/partial layouts are still handled by normal preparation.
        }
    }
    return bindings.unique().join(',')
}
def gpuPrefix(gpuId) { "--nv --env CUDA_DEVICE_ORDER=PCI_BUS_ID --env CUDA_VISIBLE_DEVICES=${gpuId}" }
def firstConfiguredGpuIds(explicitGpuIds, fallbackGpuId) {
    def explicit = explicitGpuIds == null ? '' : explicitGpuIds.toString().trim()
    return explicit ? explicit : (fallbackGpuId == null ? '' : fallbackGpuId.toString().trim())
}

params {
    //////////////////////////
    // ESSENTIAL PARAMETERS //
    //////////////////////////

    // Pipeline mode. Choose from 'monomer_denovo', 'monomer_foldcond', 'monomer_motifscaff', 'monomer_partialdiff',
    // 'binder_denovo', 'binder_foldcond', 'binder_motifscaff', or 'binder_partialdiff'
    rfd_mode = null

    // Number of designs to generate using RFdiffusion
    rfd_num_designs = 8

    // Number of sequences to generate per RFdiffusion design
    seqs_per_design = 8

    // Number of parallel jobs for sequence-based prediction
    num_parallel_jobs = 1

    // GPU ID passed by external orchestrator. For standalone runs, fallback to NXF_DEFAULT_GPU or 0.
    gpu_id = System.getenv('NXF_DEFAULT_GPU') ? System.getenv('NXF_DEFAULT_GPU').toInteger() : 0
    // Runtime placement, not a scientific preset. CPU remains the existing default.
    protonpottsmpnn_device = System.getenv('BMS_PROTONPOTTSMPNN_DEVICE') ?: 'cpu'
    protonpottsmpnn_container_path = System.getenv('BMS_PROTONPOTTSMPNN_CONTAINER_PATH') ?: null

    // API base URL for spawn/wait/collect workflows
    api_url = System.getenv('API_BASE_URL') ?: "http://localhost:8000"

    // Path configuration (optional overrides for portability)
    code_root = codeRootFallback
    data_root = System.getenv('BMS_DATA')
    cm_api_runtime_dir = System.getenv('BMS_CM_API_RUNTIME_DIR') ?: "${dataRootFallback}/runtime/cm-api-python"
    api_python = System.getenv('BMS_API_PYTHON') ?: "${params.cm_api_runtime_dir}/current/venv/bin/python"
    weights_root = System.getenv('BMS_WEIGHTS') ?: "${dataRootFallback}/weights"
    msa_local_db = System.getenv('BMS_COLABFOLD_DB') ?: "${dataRootFallback}/colabfold_db"
    msa_cache_dir = System.getenv('BMS_MSA_CACHE') ?: "${dataRootFallback}/msa_cache"
    cache_root = cacheRoot

    // Output directory for results. Existing results in this directory will be overwritten. 
    // To generate a unique directory name with date/time use a Groovy function e.g "bms_results/${new Date().format('yyyyMMdd_HHmmss')}"
    out_dir = params.data_root ? "${params.data_root}/bms_results" : "bms_results"

    // Complex/Ligand definition JSON path (for complex prediction)
    complex_json_path = null

    //////////////////////////////
    // MODE SPECIFIC PARAMETERS //
    //////////////////////////////

    // Contigs specification. See examples in documentation. e.g. '[A17-145/0 50-100]'
    // Required for 'binder_denovo', 'binder_motifscaff', 'binder_partialdiff', 'monomer_denovo', 'monomer_motifscaff', 'monomer_partialdiff' modes
    rfd_contigs = null

    // Path to input pdb e.g. target protein for binder design 'target.pdb'
    // Required for 'binder_denovo', 'binder_foldcond', 'binder_motifscaff', 'binder_partialdiff', 'monomer_motifscaff', 'monomer_partialdiff' modes
    rfd_input_pdb = null

    // Hotspot residues on target chain(s) for binder design. e.g. '[A56,A115,A123]'
    // Optional for 'binder_denovo' and 'binder_foldcond' modes
    rfd_hotspots = null

    // Path to directory containing fold conditioning secondary structure (*_ss.pt) and block adjacency files (*_adj.pt) files e.g. 'binderscaffolds/scaffolds_assorted'
    // Required for 'binder_foldcond' and 'monomer_foldcond' modes.
    rfd_scaffold_dir = null

    // Paths to fold conditioning secondary structure and block adjacency files for the target protein. e.g. 'target_ss.pt', 'target_adj.pt'
    // Required for 'binder_foldcond' mode.
    rfd_target_ss = null
    rfd_target_adj = null

    // Whether to ignore loop regions when applying secondary structure constraints from scaffolds (default=true)
    // Optional for 'binder_foldcond' and 'monomer_foldcond' modes.
    // Recommended to set to false for binder design as the scaffold sets have enough diversity
    rfd_mask_loops = true

    // Residues that will have their sequence masked when diffusing (default=null). e.g. '[A17-19/A143-145]'
    // Optional for 'monomer_motifscaff' and 'monomer_foldcond' modes
    rfd_inpaint_seq = null

    // Total length of diffused chain when performing motif scaffolding (default = null). e.g. '100-100', '100-120'
    // Optional for 'binder_motifscaff' and 'monomer_motifscaff' modes
    rfd_length = null

    // Number of timesteps for partial diffusion. e.g. 20
    // Required by 'binder_partialdiff' and 'monomer_partialdiff' modes
    rfd_partial_diffusion_timesteps = null

    //////////////////////////////////
    // WORKFLOW ADVANCED PARAMETERS //
    //////////////////////////////////
    // Diffusion method: 'rfd3' (RFdiffusion3/Foundry, recommended) or 'boltzgen' (all-atom generator).
    // Legacy 'rfd' is no longer supported in tracked repo state.
    diffusion_method = 'rfd3'

    // Allow Nextflow to retry failed processes on OOM (137) or SIGSEGV (139).
    // Default: false (fail immediately for easier debugging)
    // Set to true for production runs where transient failures should be retried
    allow_retries = false

    // Sequence design method: 'fampnn' (Full-Atom MPNN, recommended) or 'mpnn' (ProteinMPNN, legacy)
    seq_method = 'fampnn'

    // Structure prediction method. Choose from 'af2' (AlphaFold2), 'boltz' (Boltz-2), or 'rf3' (RosettaFold3/Foundry).
    pred_method = 'af2'

    // Whether to compress output final designs in a tar.gz archive. If false, results will be output as uncompressed PDB files.
    zip_pdbs = true

    // Whether to run RFdiffusion only and skip downstream stages (i.e. sequence design, prediction, and analysis)
    run_rfd_only = false

    // Whether to skip stages (RFdiffusion, sequence design, and/or prediction).
    // Skip RFdiffusion and run Sequence Design, Structure Prediction, and Analysis only. Must provide 'skip_input_dir' directory below containing PDB and JSON files with metadata. Binder design PDBs must have binder as chain A and target as chain B.
    skip_rfd = false

    // Skip RFdiffusion and Sequence Design, and run Structure Prediction and Analysis only. Must provide 'skip_input_dir' directory below containing PDB files. Binder design PDBs must have binder as chain A and target as chain B.
    skip_rfd_seq = false

    // Skip RFdiffusion, Sequence Design, and Structure Prediction, and run Analysis only. Must provide 'skip_input_dir' directory below containing PDB files. Binder design PDBs must have binder as chain A and target as chain B.
    skip_rfd_seq_pred = false

    // Skip only Structure Prediction stage (useful for standalone docking)
    skip_pred = false

    // Path to input files when skipping stages, e.g. a collected output directory from a previous run.
    skip_input_dir = null

    /////////////////////////////
    // ANTIBODY DESIGN PARAMETERS //
    /////////////////////////////
    // Heavy chain sequence for structure prediction.
    heavy_sequence = null

    // Light chain sequence for structure prediction.
    light_sequence = null

    // Target PDB alias (used in main.nf but maps to rfd_input_pdb usually, or explicit target_pdb)
    target_pdb = null

    // Antigen chain IDs for De Novo design (e.g. 'A')
    antigen_chains = null
    // Optional framework family hint for antibody-shaped generators
    framework_type = null

    // General sequence name
    sequence_name = null
    // Optional job batch label for orchestrated and experimental workflows
    batch_name = null
    // Optional batch manifest for copy/paste structure screens
    sequence_batch_json_path = null
    // Optional staged directory of per-variant complex JSON payloads
    complex_batch_dir = null
    // Optional explicit Boltz asset overrides used by some experimental workflows
    boltz_model_path = null
    boltz_ccd_path = null

    // Boltz-CP experimental workflow parameters
    bcp_input_path = null
    bcp_repo_path = null
    bcp_container_path = null
    bcp_gpu_ids = null
    bcp_size_cp = 4
    bcp_cp_topology = '2d'
    bcp_input_format = 'config_files'
    bcp_output_format = 'mmcif'
    bcp_write_full_pae = false
    bcp_recycling_steps = 3
    bcp_sampling_steps = 200
    bcp_diffusion_samples = 1
    bcp_seed = null

    // ConforNets experimental monomer conformer workflow parameters
    cn_task = 'diversity'
    cn_sequence = null
    cn_chain_id = 'A'
    cn_benchmark_name = 'bms_confornets'
    cn_test_case_name = 'monomer_case'
    cn_reference_pdb_1 = ''
    cn_reference_name_1 = 'ref_a'
    cn_reference_pdb_2 = ''
    cn_reference_name_2 = 'ref_b'
    cn_checkpoint_path = "${params.weights_root}/openfold3/of3-p2-155k.pt"
    cn_config_yaml = ''
    cn_confornets_repo_path = System.getenv('BMS_CONFORNETS_REPO') ?: '/opt/confornets'
    cn_skip_msa = false
    cn_num_runs = 2
    cn_k_confornets = 2
    cn_num_samples = 5
    cn_max_steps = 21
    cn_save_steps = '5,10,15,20'
    cn_num_recycles = 0
    cn_num_diffusion_steps = 200
    cn_lr = 0.001
    cn_grad_clip = 10.0
    cn_compute_confidence = true
    cn_save_full_confidence = false
    cn_compute_evaluation = true
    cn_confornet_path = ''
    cn_mse_dir = ''
    cn_source_test_cases = ''
    cn_container_path = null
    cm_confornets_container_path = cmConfornetsContainer

    // Shared target geometry controls for conditioned/frozen validation runs
    target_geometry_mode = null
    boltz_target_geometry_mode = null
    protenix_target_geometry_mode = null
    target_template_threshold_angstrom = 2.0
    strict_target_rmsd = null

    // Antibody Design Mode: Controls which residues are designable during sequence design
    // Options:
    //   'cdr_only' (default) - Only CDR loops are designable, all framework regions fixed
    //   'cdr_selective' - Only selected CDR loops designable (use antibody_design_loops)
    //   'framework_allowed' - CDRs + framework designable, VHH tetrad protected
    //   'full_design' - Everything designable (expert mode, may break antibody structure)
    antibody_design_mode = 'cdr_only'

    // CDR loops to design (comma-separated). Only used when antibody_design_mode = 'cdr_selective'
    // Options: H1, H2, H3, L1, L2, L3 (VHH only has H loops)
    antibody_design_loops = 'H1,H2,H3,L1,L2,L3'

    // Protect VHH tetrad (FR2 positions 37,44,45,47) from modification
    // Critical for VHH solubility - should almost always be true
    protect_vhh_tetrad = true

    // Antibody chain IDs in HLT-formatted PDBs (default: H for heavy, L for light)
    antibody_chains = 'H,L'
    // Keep non-antibody chains sequence-locked during FAMPNN/PPIFlow redesign.
    lock_target_chains = true
    // In CDR-focused modes, keep framework residues fixed unless explicitly relaxed.
    lock_antibody_framework = true
    // Optional PPIFlow tuning surfaces
    ppiflow_rotamer_shell_cutoff = null
    ppiflow_backbone_region_mode = null
    ppiflow_backbone_loop_scope = null

    // Skip RFantibody backbone generation and use pre-existing PDBs
    skip_rfantibody = false
    rfantibody_input_pdbs = null

    // Job naming and batching
    name = null

    // FAMPNN orchestration settings
    fampnn_collected_pdbs = null
    pdbs_per_job = 5

    // FAMPNN filtering (post sequence design)
    enable_fampnn_filter = true
    fampnn_max_residue_psce = 3.0  // Max per-residue PSCE for filtering
    analysis_chain_id = 'all_chains'  // Chain(s) for PSCE analysis

    // RFantibody settings
    rfantibody_num_designs = 10
    rfantibody_design_loops = ''
    rfantibody_diffusion_steps = 50    // 20-50 typical, allow up to 200 for extended denoising sweeps
    rfantibody_noise_scale_ca = 1.0    // 0.5-2.0 (higher = more exploratory backbone sampling)
    rfantibody_noise_scale_frame = 1.0 // 0.5-2.0 (higher = more exploratory orientation sampling)
    rfantibody_guide_scale = 10        // 1-50 (higher = stronger hotspot guidance)
    // Optional explicit checkpoint path override for RFantibody.
    // If null, module auto-resolves RFdiffusion_Ab.pt from rfd_models bind + legacy paths.
    rfantibody_ckpt_override = null
    // Debug-only switch: mount host RFantibody repo over /opt/RFantibody.
    // Default false keeps container code immutable and binds only host weights.
    rfantibody_debug_repo_overlay = false

    // Epitope residues for target binding (e.g., "A45,A46,A52")
    epitope_residues = null

    /////////////////////////////////////
    // ANTIBODY STAGE TOGGLES & SETTINGS //
    /////////////////////////////////////

    // ThermoMPNN Stability Filter (OFF by default)
    // Filters unstable sequences before Boltz-2 validation
    run_thermompnn = false
    thermompnn_max_ddg = 2.0  // Max ddG threshold (kcal/mol) for filtering

    // FrustraMPNN frustration analysis (OFF by default)
    // Optional post-pipeline analysis on final candidates
    run_frustrampnn = false
    // Enabled canonical execution is initially fail-closed; degraded/optional is not exposed.
    frustrampnn_requiredness = 'required'

    // ANARCII CDR annotation (OFF by default)
    // Post-pipeline polishing for CDR metadata
    run_anarcii_post = false
    anarcii_execution_mode = 'auto'
    anarcii_gpu_id = null
    anarcii_batch_size = 500
    anarcii_cpu_threads = 24
    anarcii_include_children = true
    anarcii_chain_timeout = 120

    // AF2 Backprop CDR Refinement (OFF by default)
    // Uses ColabDesign AfDesign to optimize CDR sequences for binding confidence
    run_af2_backprop = false
    af2_backprop_soft_iters = 100    // Soft optimization iterations
    af2_backprop_temp_iters = 100    // Temperature annealing iterations
    af2_backprop_hard_iters = 10     // Hard discrete iterations
    af2_backprop_num_recycles = 3    // AF2 recycling iterations
    af2_backprop_learning_rate = 0.1 // Gradient descent step size
    af2_backprop_use_multimer = true // Use AlphaFold-Multimer
    af2_backprop_num_models = 1      // Number of AF2 models to ensemble (1-5)
    af2_backprop_loss_plddt = 0.1    // Weight for pLDDT loss
    af2_backprop_loss_pae = 0.1      // Weight for PAE loss
    af2_backprop_loss_contact = 0.5  // Weight for interface contact loss
    af2_backprop_binder_chain = 'H'  // Chain to redesign (auto-set for VHH)

    // PPIFlow Maturation (OFF by default)
    run_maturation = false
    maturation_designs_per_job = 4
    maturation_anchor_threshold = -5.0
    maturation_anchor_distance_cutoff = 12.0
    maturation_min_improvement = -1.0
    maturation_filter_percentile = 0
    maturation_design_mode = 'inherit'
    maturation_redesign_temp = null
    maturation_redesign_steps = null
    maturation_redesign_enabled = true
    maturation_redesign_top_n = 0

    // PPIFlow configuration
    ppiflow_start_t = 0.5
    ppiflow_samples_per_target = 3
    ppiflow_retry_limit = 10
    ppiflow_config = "/app/ppiflow/configs/test_antibody.yaml"
    ppiflow_checkpoint = "nanobody"
    ppiflow_checkpoint_path = null
    ppiflow_weights_dir = "${params.weights_root}/ppiflow"
    ppiflow_heavy_chain = null
    ppiflow_light_chain = null
    ppiflow_antigen_chain = null

    // Path to AlphaFold2 parameters (for AF2 backprop)
    alphafold_params = "${params.weights_root}/alphafold/params"


    /////////////////////////////
    // RFD ADVANCED PARAMETERS //
    /////////////////////////////

    // Override the diffusion model checkpoint used by RFdiffusion.
    // Choose from: 'active_site', 'base', 'base_epoch8', 'complex_base', 'complex_beta', 'complex_fold_base', 'inpaint_seq', 'inpaint_seq_fold'
    // RFdiffusion will automatically select a checkpoint. Not recommended to override except for 'binder_denovo' mode i.e. 'complex_beta'
    rfd_ckpt_override = null

    // Scale of noise for RFD translations (ca) and rotations (frame)
    // 1 (default) is recommended for monomer modes to increase diversity
    // 0 is recommended for binder modes to increase success rates
    rfd_noise_scale = null

    // Additional configuration parameters to pass to RFdiffusion that are not externalised in Nextflow. e.g. 'contigmap.inpaint_str=[B165-178]'
    rfd_extra_config = null

    //////////////////////////////
    // MPNN ADVANCED PARAMETERS //
    //////////////////////////////
    // Parameters for ProteinMPNN-FastRelax. Binder design modes only.

    // Residue types to avoid during sequence design (one letter case-insensitive) (default: 'CX').
    mpnn_omitAAs = 'CX'

    // Temperature for sequence sampling. Higher values increase sequence diversity. Default=0.1
    // For binder design, it is recommended to decrease this significantly e.g. 0.0001 
    mpnn_temperature = 0.1

    // Checkpoint type to use for ProteinMPNN. Choose from 'vanilla' or 'soluble' (default = soluble).
    mpnn_checkpoint_type = 'soluble'

    // Checkpoint model to use for ProteinMPNN. Indicates noise level used during training for backbone atoms.
    // Choose from 'v_48_002','v_48_010,'v_48_020','v_48_030'. (default = 'v_48_020', noised with 0.20Å Gaussian noise)
    mpnn_checkpoint_model = 'v_48_020'

    // Standard deviation of Gaussian noise to add to backbone atoms.
    // 0 = no change to backbone, 0.1-0.3 = allows mild pertubation of backbone
    mpnn_backbone_noise = 0

    // Maximum number of fast relax cycles to run on each sequence. Set to zero to disable.
    mpnn_relax_max_cycles = 0

    // Number of sequences to generate between relaxation steps. The sequence with the best score will be kept.
    mpnn_relax_seqs_per_cycle = 1

    // Whether to run a relaxation cycle before saving output.
    mpnn_relax_output = false

    // Convergence criteria 1 of 2. 
    // Design is considered converged if the C-alpha RMSD (Å) between cycles is <= this threshold (default: 0.2)
    mpnn_relax_convergence_rmsd = 0.2

    // Convergence criteria 2 of 2. 
    // Design is considered converged if the improvement in score between cycles is <= this threshold (default: 0.1)
    mpnn_relax_convergence_score = 0.1

    // Design is considered converged if it meets both convergence criteria for n consecutive cycles (default: 1)
    mpnn_relax_convergence_max_cycles = 1

    // Additional configuration parameters to pass to ProteinMPNN-FastRelax that are not externalised in Nextflow. e.g. '-protein_features='full''
    mpnn_extra_config = null

    ////////////////////////////////
    // FAMPNN ADVANCED PARAMETERS //
    ////////////////////////////////
    // Parameters for Full-Atom MPNN

    // Fix target side-chain positions when performing binder sequence design (default: false)
    fampnn_fix_target_sidechains = false

    // FAMPNN constraint mode: 'generic' (no fixed residues) or 'antibody' (CDR-aware constraints)
    fampnn_constraint_mode = 'generic'

    // Default checkpoint preset for Full-Atom MPNN sequence design.
    fampnn_checkpoint = "fampnn_0_0.pt"
    fampnn_checkpoint_path = null

    // Only keep sidechains below this PSCE threshold during design; null to keep all (default: 0.3)
    fampnn_psce_threshold = 0.3

    // Temperature for sequence sampling. Higher values increase sequence diversity (default: 0.1)
    // For binder design, it is recommended to decrease this significantly e.g. 0.0001 
    fampnn_temperature = 0.1

    // Exclude cysteine residues from sequence design (default: true)
    fampnn_exclude_cys = true

    // Sequence-only mode: skip sidechain diffusion for faster inference (default: false)
    fampnn_seq_only = false

    // Number of denoising timesteps: higher = better quality but slower (default: 100)
    fampnn_num_steps = 100

    // FA-MPNN seq_probs-derived single-substitution mutation triage reporting.
    // Keeps model-favored alternatives where log(P_alt)-log(P_sampled) meets the threshold.
    fampnn_mutation_top_n = 25
    fampnn_mutation_min_log_odds_delta = 0.0

    // Batch size for inference: reduce if encountering OOM errors (default: 4)
    fampnn_batch_size = 4

    // Repack sidechains after final denoising step (default: true)
    fampnn_repack_last = true

    // Additional configuration parameters to pass to Full-Atom MPNN for debugging
    // e.g. 'seed=42 scn_diffusion.num_steps=50 scn_diffusion.step_scale=1.0'
    fampnn_extra_config = null

    //////////////////////////////
    // PRED ADVANCED PARAMETERS //
    //////////////////////////////
    // Parameters for structure prediction using AlphaFold2 Initial-Guess and Boltz-2.

    // Path to uncropped target PDB file to use in structure prediction e.g. './benchmarkdata/5o45_pd-l1_uncropped.pdb'.
    uncropped_target_pdb = null

    // Use an initial-guess of the target chain(s) when performing binder structure prediction. When false, AF2 will not use an initial guess. Default = true
    af2_initial_guess = true

    // Additional configuration parameters to pass to AlphaFold2 Initial-Guess that are not externalised in Nextflow. e.g. '-recycle 3'
    af2_extra_config = '-debug'

    // Boltz settings
    boltz_sampling_steps = 200
    boltz_recycling_steps = 3
    boltz_num_samples = 1
    boltz_use_msa = false
    boltz_anchor_target = false
    boltz_anchor_strict = false
    boltz_anchor_target_max_rmsd = 1.5
    // Default to false (fast, single sequence)
    rf3_use_msa = true
    // Default to true (RF3 needs MSA for quality)
    boltz_method = ''
    // Default to none (no conditioning)
    boltz_extra_config = ''

    // Antibody Workflow Mode
    // true = Exploration (parallel child jobs across GPUs - fast screening)
    // false = Refinement (sequential on one GPU - thorough analysis)
    // Default: null (must be set via command line --exploration_mode)
    exploration_mode = null

    // Local MSA Database Settings (uses local MMseqs2 - no API calls!)
    // Set via params.msa_local_db / params.msa_cache_dir (env: BMS_COLABFOLD_DB/BMS_MSA_CACHE)
    // Persistent MSA cache - never recompute for same sequence
    msa_path = null
    // Optional precomputed A3M path for workflows that can consume it directly
    msa_threads = 32
    // Total CPU-thread budget requested for local MMseqs2 search; high-quality EnvDB sharding subdivides this budget rather than raising it
    msa_target_shard_mode = 'auto'
    // EnvDB target DB sharding policy for balanced/maximum local MSA: auto|required|off
    msa_target_shards = 4
    // Default number of EnvDB target shards; workers use roughly msa_threads / msa_target_shards threads each
    msa_target_shard_min_size_gb = 1.0
    // Minimum target DB size in GiB before auto sharding is enabled
    msa_use_gpu = true
    // Use GPU-accelerated mmseqs2 when available (hybrid: auto-fallback to CPU)
    msa_preset = 'fast'
    // Default MSA profile for folding workflows: quick UniRef-only search
    msa_gpu_mode = 'opportunistic'
    // MSA GPU policy: opportunistic = use GPU only when relatively idle, else CPU
    msa_gpu_threshold = 60
    // Util/memory threshold (%) for opportunistic MSA GPU selection
    msa_preferred_gpus = null
    // Optional comma-separated GPU allowlist for MSA (e.g., '1,2')
    msa_excluded_gpus = null
    // Optional comma-separated GPU denylist for MSA (e.g., '0' to reserve 5090 for folding)
    msa_gpu_server_mode = 'persistent'
    // MMseqs2 gpuserver mode: persistent|auto|required|off (streaming search when GPU MSA is enabled)
    msa_gpu_server_wait_timeout = 120
    // Seconds to wait for gpuserver handshake (0=no wait, -1=infinite)
    msa_gpu_server_db_load_mode = 2
    // db-load-mode for gpuserver streaming (2 = mmap, aligned with shared local-MSA runtime defaults)
    msa_gpu_server_startup_wait = 5.0
    // Seconds to wait after gpuserver start before first search
    msa_reference_sequence = null
    // For mutagenesis: use this as cache key so all variants share one MSA
    msa_force_refresh = false
    // Force MSA regeneration (bypass cache) for each run
    msa_cache_only = false
    // Use only existing cached MSA for the sequence; fail if cache is missing
    msa_max_seqs = null
    // Optional max hit cap for MMseqs2 candidate set (lower values are faster; ColabFold often uses ~300)
    msa_taxon_list = null
    msa_evalue = null
    msa_min_seq_id = null
    msa_min_coverage = null
    msa_use_expand = null
    msa_use_env = null
    msa_num_iterations = null
    msa_chain_timeout_seconds = null
    msa_allow_empty_fallback = false
    msa_provider = 'colabfold_api'
    // MSA backend provider: local|colabfold_api (remote server is the structure-prediction default)
    colabfold_api_host = 'https://api.colabfold.com'
    // Remote ColabFold API host (used when msa_provider=colabfold_api)
    colabfold_api_min_interval = 6.0
    // Minimum seconds between remote API submissions (global pacing)
    colabfold_api_poll_interval = 6.0
    // Polling interval in seconds for remote API ticket status

    // The number of diffusion samples to use for prediction with Boltz-2. (default: 1)
    boltz_diffusion_samples = null
    // Let boltz_num_samples from CLI take precedence
    boltz_max_parallel_samples = 1

    // Use physics-based potentials during inference to improve physical plausibility of predictions (also known as Boltz-2x). Increases prediction time.
    boltz_use_potentials = false

    // Step scale for diffusion sampling (default: 1.638). Lower values = more diverse, higher = more conserved.
    boltz_step_scale = null

    // Additional configuration parameters to pass to Boltz-2 that are not externalised in Nextflow. e.g. '--msa_pairing_strategy complete'
    boltz_extra_config = null

    // ═══════════════════════════════════════════════════════════════════════════
    // BOLTZ-2 BINDING AFFINITY PREDICTION (Quality Feature)
    // ═══════════════════════════════════════════════════════════════════════════
    // Enable Boltz-2's binding affinity prediction head (outputs log10 IC50 & probability)
    // WARNING: Adds ~2-5 min per design - keep off for initial screening
    boltz_predict_affinity = false
    
    // Sampling steps for affinity prediction (default: 200)
    boltz_sampling_steps_affinity = 200
    
    // Diffusion samples for affinity head (default: 5, more = better estimate)
    boltz_diffusion_samples_affinity = 5
    
    // Apply Molecular Weight correction to affinity value (for small molecules)
    boltz_affinity_mw_correction = false

    //////////////////////////////
    // RFD3 ADVANCED PARAMETERS //
    //////////////////////////////
    // Parameters for RFdiffusion3 (Foundry)

    // Number of structure batches per design (default: 1, produces 8 models per batch)
    rfd3_batches_per_design = 1

    // Additional RFD3 config overrides (Hydra format)
    rfd3_extra_config = null

    /////////////////////////////////
    // PROTEIN LOCAL REDESIGN PARAMS //
    /////////////////////////////////
    plr_input_pdb = null
    plr_model_number = null
    plr_design_chains = null
    plr_context_chains = ''
    plr_region_mode = 'manual_ranges'
    plr_redesign_ranges = null
    plr_interface_cutoff = 6.0
    plr_region_padding = 2
    plr_num_designs = 8
    plr_seq_method = 'fampnn'
    plr_fix_fixed_sidechains = true
    plr_structure_validators = 'protenix_v2'
    plr_backbone_input_pdbs = null
    plr_sequence_input_pdbs = null
    plr_validation_input_pdbs = null
    plr_region_manifest = null
    plr_final_candidate_dir = null

    /////////////////////////////
    // RF3 ADVANCED PARAMETERS //
    /////////////////////////////
    // Parameters for RosettaFold3 (Foundry)

    // Additional RF3 config overrides
    rf3_extra_config = null

    // RF3 Filtering Parameters
    // Minimum pLDDT score for RF3 predictions
    rf3_min_plddt = null

    // Minimum pTM score for RF3 predictions  
    rf3_min_ptm = null

    // Maximum PAE for RF3 predictions
    rf3_max_pae = null

    // Maximum overall RMSD for RF3 predictions
    rf3_max_rmsd_overall = null

    // Maximum binder RMSD for RF3 predictions (binder modes)
    rf3_max_rmsd_binder = null

    // Optional bind root and analysis image used by MD process labels even when MD profiles are inactive.
    md_input_root = null
    md_analysis_container = System.getenv('BMS_MD_ANALYSIS_CONTAINER')
    md_analysis_sif_sha256 = System.getenv('BMS_MD_ANALYSIS_SIF_SHA256')
    md_analysis_implementation_sha256 = System.getenv('BMS_MD_ANALYSIS_IMPLEMENTATION_SHA256')
    md_preparation_container = System.getenv('BMS_MD_PREPARATION_SIF') ?: "${bmsContainerRootFallback}/md-preparation-v1.sif"
    md_preparation_runtime_lock = System.getenv('BMS_MD_PREPARATION_RUNTIME_LOCK') ?: "${params.data_root ?: dataRootFallback}/md-preparation/env-v1-explicit.txt"
    md_gromacs_container = System.getenv('BMS_MD_GROMACS_SIF') ?: "${bmsContainerRootFallback}/gromacs-md-2025.3.sif"
    md_openmm_container = System.getenv('BMS_MD_OPENMM_SIF') ?: "${bmsContainerRootFallback}/openmm-md-8.5.2.sif"

    /////////////////////////
    // BOLTZGEN PARAMETERS //
    /////////////////////////
    // Parameters for BoltzGen (All-atom binder generation)

    // Number of designs to generate
    boltzgen_num_designs = 10

    // Scaffold length range (e.g. '80-120' or '100')
    boltzgen_scaffold_length = '80-120'

    // Ligand SMILES string (if not using NTP template)
    boltzgen_ligand_smiles = null

    // NTP template type (e.g. 'dATP', 'GTP') - overrides ligand_smiles if provided
    boltzgen_ntp_type = null

    // Binding pocket specification (e.g., 'A:45-52,A:78-85' for residue ranges)
    boltzgen_binding_site_residues = null

    // Include catalytic site features (Mg2+ coordination) for enzyme design
    boltzgen_catalytic_site = false

    // Existing protein backbone for NTP docking mode
    boltzgen_input_pdb = null

    // Ligand structure with 3D coordinates for scaffold_around_ligand mode
    boltzgen_ligand_pdb = null

    // Additional configuration overrides
    boltzgen_extra_config = null

    // New parameters for DNA complex and batching
    boltzgen_protein_sequence = null
    boltzgen_dna_template_seq = null
    boltzgen_dna_primer_seq = null
    boltzgen_dna_structure = null
    boltzgen_batch_size = 1

    /////////////////////////
    // DIFFDOCK PARAMETERS //
    /////////////////////////
    // Parameters for DiffDock (Protein-Ligand Docking)

    // Whether to run the docking stage (Stage 4)
    run_docking = false

    // Number of docking poses to generate per complex
    diffdock_num_poses = 10

    // Minimum confidence threshold for filtering poses (0.0 - 1.0)
    diffdock_confidence_threshold = 0.0

    // Ligand SMILES for docking (if not provided, will look for 'ligand_description' column in inputs or use NTP type)
    diffdock_ligand_smiles = null

    // NTP template type to use as ligand
    diffdock_ntp_type = null

    // Additional configuration overrides
    diffdock_extra_config = null

    // Number of inference steps (higher = more accurate but slower)
    diffdock_inference_steps = 20

    /////////////////////////
    // UNI-DOCK PARAMETERS //
    /////////////////////////
    // Parameters for Uni-Dock (GPU-accelerated AutoDock Vina)

    // Number of docking poses to generate per ligand
    unidock_num_poses = 9

    // Scoring function: 'vina', 'vinardo', or 'ad4'
    unidock_scoring = 'vina'

    // Search exhaustiveness (32=standard, 128+=blind docking)
    unidock_exhaustiveness = 32

    // Docking box edge length in Angstroms
    unidock_box_size = 25

    // Box center coordinates as "x,y,z" (empty = auto-detect)
    unidock_box_center = ''

    // Flexible receptor sidechains as "A:42,A:89" (empty = rigid)
    unidock_flexible_residues = ''

    // Affinity threshold for filtering poses (kcal/mol)
    unidock_affinity_threshold = -7.0

    // Ligand SMILES for docking
    unidock_ligand_smiles = null

    // NTP template type for docking
    unidock_ntp_type = null

    // Search mode preset: 'fast', 'balance', 'detail'
    unidock_search_mode = ''

    // Minimum RMSD between output poses (Angstroms)
    unidock_min_rmsd = 1.0

    // Maximum energy difference to show from best pose (kcal/mol)
    unidock_energy_range = 3.0

    // Random seed for reproducibility (0 = random)
    unidock_seed = 0

    // Optional Uni-Dock GPU override for hosts with adapter-specific runtime issues.
    // Leave unset to use the orchestrator-assigned gpu_id / NXF_DEFAULT_GPU path.
    unidock_gpu_id = System.getenv('BMS_UNIDOCK_GPU_ID') ?: null

    //////////////////////////
    // FILTERING PARAMETERS //
    //////////////////////////

    // RFdiffusion Filtering Parameters. Applies to binder chain only in binder design modes, otherwise all chains.
    // Max/min number of alpha-helices in design
    rfd_min_helices = null
    rfd_max_helices = null

    // Max/min number of beta-strands in design
    rfd_min_strands = null
    rfd_max_strands = null

    // Max/min number of secondary structure elements (α-helices + β-strands)
    rfd_min_ss = null
    rfd_max_ss = null

    // Max/min radius of gyration (Å) of design
    rfd_min_rog = null
    rfd_max_rog = null

    // ProteinMPNN Filtering Parameters
    // Maximum ProteinMPNN score (negative log likelihood).
    // A lower score means ProteinMPNN is more confident in the sequence.
    mpnn_max_score = null

    // Full-Atom MPNN Filtering Parameters
    // Max average predicted side-chain error (PSCE) for designed side-chains.
    // Applies to binder chain only in binder design modes, otherwise averages all chains.
    // A lower score means FAMPNN is more confident in the sequence.
    fampnn_max_psce = null

    // AlphaFold2 Initial-Guess Filtering Parameters.
    // Max predicted aligned error for interactions between binder and target
    af2_max_pae_interaction = null

    // Max predicted aligned error for all chains
    af2_max_pae_overall = null

    // Max predicted aligned error for binder
    af2_max_pae_binder = null

    // Max predicted aligned error for target
    af2_max_pae_target = null

    // Min average pLDDT score for target and binder chains
    af2_min_plddt_overall = null

    // Min pLDDT score required for binder
    af2_min_plddt_binder = null

    // Min pLDDT score required for target
    af2_min_plddt_target = null

    // Max C-alpha RMSD between AF2 prediction and input design when all chains are aligned
    af2_max_rmsd_overall = null

    // Max binder C-alpha RMSD between AF2 prediction and input design when binder chains are aligned
    af2_max_rmsd_binder_bndaln = null

    // Max binder C-alpha RMSD between AF2 prediction and input design when target chains are aligned
    af2_max_rmsd_binder_tgtaln = null

    // Max target C-alpha RMSD between AF2 prediction and input design when target chains are aligned
    af2_max_rmsd_target = null

    // Boltz-2 Filtering Parameters.

    // Max C-alpha RMSD between all chains of Boltz-2 prediction and input design.
    boltz_max_overall_rmsd = null

    // Max C-alpha RMSD between binder chains of Boltz-2 prediction and input design. Binder modes only. 
    boltz_max_binder_rmsd = null

    // Max C-alpha RMSD between target chains of Boltz-2 prediction and input design. Binder modes only. 
    boltz_max_target_rmsd = null

    // Minimum confidence score
    boltz_min_conf_score = null

    // Minimum predicted TM-score
    boltz_min_ptm = null

    // Minimum predicted TM-score of interface
    boltz_min_ptm_interface = null

    // Minimum pLDDT score of the complex
    boltz_min_plddt = null

    // Minimum pLDDT score of the complex interface
    boltz_min_plddt_interface = null

    // Maximum predicted distance error for the complex
    boltz_max_pde = null

    // Maximum predicted distance error for the complex interface
    boltz_max_pde_interface = null

    // ═══════════════════════════════════════════════════════════════════════════
    // OPENMM PHYSICS REFINEMENT PARAMETERS
    // ═══════════════════════════════════════════════════════════════════════════
    // Post-generation relaxation and MM-GBSA binding affinity scoring
    
    // Master toggle for physics refinement
    openmm_enabled = false
    
    // Compute tier: 'fast' (minimize), 'standard' (min+equil), 'full' (+MM-GBSA)
    openmm_compute_tier = 'fast'
    
    // Force field priority (comma-separated fallback chain)
    openmm_force_field = 'amber14sb'
    openmm_force_field_priority = 'amber14sb,mace-off,ani2x'
    
    // Antibody/Nanobody-specific settings
    openmm_cdr_only = true              // Only minimize CDR regions (default for antibodies)
    openmm_restraint_mode = 'framework' // 'none', 'framework', or 'backbone'
    openmm_restraint_strength = 5.0     // kcal/mol/Ų
    openmm_antibody_chain = 'H'         // Heavy chain ID
    
    // Minimization settings
    openmm_max_iterations = 500         // Maximum L-BFGS iterations
    openmm_energy_tolerance = 10.0      // Convergence tolerance (kJ/mol)
    
    // MM-GBSA scoring settings
    openmm_mmgbsa_mode = 'off'          // 'off', 'interface', 'stability', 'both'
    openmm_binder_chains = 'H'          // Binder chain IDs (comma-separated)
    openmm_target_chains = 'A'          // Target chain IDs (comma-separated)
    
    // Top-N gating: Only run expensive MM-GBSA on top designs by iPTM
    openmm_top_n_gating = true
    openmm_top_n_percentage = 10        // Top 10% of designs by iPTM
    
    // Neural Network Force Fields (experimental)
    openmm_nnff_enabled = false
    openmm_nnff_potential = 'mace-off'  // 'mace-off' or 'ani2x'

    // ═══════════════════════════════════════════════════════════════════════════
    // RFDPOLY MULTI-POLYMER DESIGN PARAMETERS (OLIGO DESIGNER)
    // ═══════════════════════════════════════════════════════════════════════════
    // De novo design of DNA, RNA, proteins, and mixed assemblies
    // GitHub: https://github.com/RosettaCommons/RFDpoly
    
    // Master toggle for RFDpoly workflow
    rfdpoly_enabled = false
    
    // Path to cloned RFDpoly repository
    rfdpoly_dir = System.getenv('BMS_RFDPOLY_DIR') ?: "${params.weights_root}/rfdpoly/rfdpoly_repo"
    
    // Model checkpoint selection (addendum fix #1)
    // Options: 'generalized' (all polymers) or 'rna_optimized'
    rfdpoly_checkpoint = 'generalized'
    
    // Checkpoint file mapping - addendum fix #1
    // generalized → train_session2024-07-08_1720455712_BFF_3.00.pt
    // rna_optimized → train_session2024-06-27_1719522052_BFF_7.00.pt
    rfdpoly_weights = "${params.weights_root}/rfdpoly/train_session2024-07-08_1720455712_BFF_3.00.pt"
    rfdpoly_weights_rna = "${params.weights_root}/rfdpoly/train_session2024-06-27_1719522052_BFF_7.00.pt"
    
    // Generation settings
    rfdpoly_num_designs = 4           // Designs per run (1-64)
    rfdpoly_diffusion_steps = 50      // Quality: 25 (fast) to 100 (high quality)
    
    // Chain configuration - space-separated lengths
    rfdpoly_contigs = '100'           // e.g., "33 33 75" for DNA(33), RNA(33), protein(75)
    rfdpoly_polymer_chains = 'dna'    // Comma-separated: 'dna,rna,protein'
    
    // Optional motif scaffolding
    rfdpoly_input_pdb = null          // Template PDB for scaffolding
    
    // Oligo Designer validation settings
    oligo_validate_boltz = false      // Optional Boltz-2 structure validation (GPU-heavy)
    oligo_min_plddt = 70.0            // Minimum pLDDT threshold
    oligo_min_ptm = 0.5               // Minimum pTM threshold
    oligo_max_pae = 15.0              // Maximum PAE threshold
    oligo_refine_openmm = false       // Optional physics refinement

    ///////////////////////////
    // CLUSTER CONFIGURATION //
    ///////////////////////////

    // Path to the pipeline containers directory or cloud URL to fetch from
    container_dir = 'https://object-store.rc.nectar.org.au/v1/AUTH_b6f9bdf15faf4320a7587fd42f62e530/ContainerHub'

    // Path to the RFdiffusion model checkpoints
    rfd_models = resolveRfdModels(params.weights_root)

    // Path to the AlphaFold2 models
    af2_models = System.getenv('BMS_AF2_MODELS') ?: "${params.weights_root}/alphafold/params"

    // Path to the Boltz-2 models
    boltz_models = System.getenv('BMS_BOLTZ_MODELS') ?: "${params.weights_root}/boltz"

    // Path to the Protenix model weights
    protenix_weights = System.getenv('BMS_PROTENIX_WEIGHTS') ?: "${params.weights_root}/protenix"
    // Host-local image path used for the preflight snapshot and in-container remeasurement.
    // A remote container_dir remains valid for other workflows, but CM Protenix
    // requires this explicit local identity before it can run.
    protenix_container_path = System.getenv('BMS_PROTENIX_CONTAINER_PATH')

    // ESMFold2 standalone defaults. Runtime remains local-files-only
    // until the container and Biohub ESMFold2/ESMC-6B cache are installed explicitly.
    esmf_model_variant = 'fast'
    esmf_model_id_or_path = System.getenv('BMS_ESMFOLD2_MODEL') ?: 'biohub/ESMFold2-Fast'
    esmf_local_files_only = true
    esmf_chain_id = 'A'
    esmf_pdb_sequence_path = ''
    esmf_pdb_chain_ids = ''
    esmf_pdb_include_dna_rna = true
    esmf_msa_path = ''
    esmf_msa_format = 'auto'
    esmf_msa_max_sequences = null
    esmf_msa_remove_insertions = true
    esmf_dna_sequence = ''
    esmf_dna_chain_id = 'C'
    esmf_rna_sequence = ''
    esmf_rna_chain_id = 'D'
    esmf_ligand_smiles = ''
    esmf_ligand_ccd = ''
    esmf_ligand_chain_id = 'L'
    esmf_complex_components_json = ''
    esmf_complex_components_file = ''
    esmf_complex_components = []
    complex_components = []
    esmf_num_loops = 3
    esmf_num_sampling_steps = 50
    esmf_num_diffusion_samples = 1
    esmf_device = 'auto'
    esmf_container_path = System.getenv('BMS_ESMFOLD2_CONTAINER') ?: null

    ///////////////////////////
    // PROTENIX PARAMETERS   //
    ///////////////////////////
    // Parameters for Protenix structure prediction (ByteDance AF3-level)

    // Model weight variant (v2 or v1.0.0 series)
    protenix_model_weights = 'protenix-v2'

    // Random seeds (comma-separated)
    protenix_seeds = '42'

    // Number of diffusion samples per seed
    protenix_n_sample = 5

    // Number of diffusion steps (higher = better quality, slower)
    protenix_n_step = 200

    // Number of recycling iterations
    protenix_n_cycle = 10

    // Use MSA (auto-switches to ESM model when false)
    protenix_use_msa = true

    // Protenix MSA backend: auto = ColabFold API for small jobs, local MSA for larger jobs
    protenix_msa_backend = 'auto'

    // Use structural templates (requires HMMER in container)
    protenix_use_template = false
    protenix_anchor_target = false
    protenix_anchor_strict = false
    protenix_anchor_target_max_rmsd = 1.5

    // Enable data caching for repeated inference
    protenix_enable_cache = true

    // Enable kernel fusion for faster inference
    protenix_enable_fusion = true

    /////////////////////////
    // NANOPORE PARAMETERS //
    /////////////////////////
    // Standalone ONT basecalling + methylation analysis
    nanopore_enabled = false
    pod5_dir = null
    bam_path = null
    bam_force_realign = false
    // Minimum alignment MAPQ applied when preparing/analyzing BAM inputs.
    bam_min_mapq = 0
    fastq_path = null
    reference_fasta = null
    // Server-staged immutable pooled ONT reference-set snapshot.
    reference_set_manifest = null
    pooled_assignment_min_mapq = null
    pooled_assignment_min_alignment_score_margin = null
    // Server-owned approved comparison-panel settings. Public clients cannot
    // set these paths; they are injected only from a receipt materialization.
    comparison_panel_snapshot = null
    comparison_panel_min_mapq = 20
    comparison_panel_min_score_margin = 10
    // Optional BioModStack job id used when stamping generated QC manifests.
    job_id = null
    dorado_model = 'sup'
    dorado_quality_mode = 'sup'
    dorado_basecall_mode = 'simplex'
    ont_molecule_type = 'dna'
    dorado_lock_manifest = "${params.code_root}/config/ngs/dorado_v2.1.2.lock.json"
    dorado_model_root = "${params.weights_root}/dorado/2.1.2"
    // Local runtime defaults must not capture the pre-profile ContainerHub URL.
    runtime_image_store = System.getenv('BMS_RUNTIME_IMAGE_STORE') ?: "${bmsContainerRootFallback}/.image-store"
    dorado_runtime_sif = System.getenv('BMS_NGS_RUNTIME_SIF') ?: "${bmsContainerRootFallback}/dorado.sif"
    pod5_python = System.getenv('BMS_POD5_PYTHON') ?: 'python3'
    duplex_pairs = null
    barcode_kit = null
    sample_sheet = null
    // Use cuda:0 (single visible GPU) by default; scheduler pinning sets CUDA_VISIBLE_DEVICES.
    dorado_device = 'cuda:0'
    modified_bases = 'none'
    min_qscore = 10
    trim_adapters = true
    emit_summary = true
    dorado_batch_size = null
    run_modkit = true
    modkit_filter_threshold = null
    // FASTQ plasmid-QC stage (align + consensus + coverage/read-length summaries).
    run_fastq_qc = true
    // Legacy toggle retained for older clients (only used when run_fastq_qc is unset).
    run_multimer_qc = false
    expected_plasmid_size = null // Auto: length of the selected reference; positive values override
    // Legacy dimer-analysis controls retained for backward compatibility.
    // Dimer output mode: 'core' keeps canonical outputs only; 'debug' keeps all detailed artifacts.
    dimer_output_mode = 'core'
    // Back-compat toggle: when true, preserve legacy dimer artifact files even in core mode.
    dimer_emit_legacy_outputs = false
    enable_rotating_reference_frames = true
    rotation_scan_step_bp = 1
    single_ref_split_min_mapq = 20
    single_ref_split_min_segment_bp = 250
    single_ref_split_max_query_gap_bp = 500
    multimer_ratio_threshold = 1.8
    min_fastq_read_length = 0
    // FASTQ alignment controls (minimap2).
    // Bundled-runtime-compatible default for minimap2 2.24; override per run as needed.
    fastq_minimap2_preset = 'map-ont'
    // Keep minimap2 default behavior (secondary alignments enabled) unless explicitly disabled.
    fastq_minimap2_allow_secondary = true
    // FASTQ QC IGV analytics: window size for gradient/GC/split/softclip tracks.
    igv_track_window_bp = 100
    // FASTQ QC IGV report: number of top hotspot intervals to include in report table.
    igv_report_max_sites = 40
    // FASTQ QC IGV report: flanking bases around each report interval.
    igv_report_flanking_bp = 200
    run_assembly = false
    // Nested wf-clone launches its own Nextflow run. Give that nested run a
    // persistent shared cache explicitly; otherwise Nextflow stores remote
    // Singularity images under each task's wf_clone_work/singularity directory.
    wf_clone_singularity_cache = System.getenv('BMS_WF_CLONE_SINGULARITY_CACHE') ?: "${bmsContainerRootFallback}/singularity_cache"
    // Native compilation binds the installed engine home. Direct Nextflow use
    // inherits its launcher home unless a clone-specific override is supplied.
    wf_clone_nxf_home = System.getenv('BMS_WF_CLONE_NXF_HOME') ?: null
    wf_clone_runtime_lock = System.getenv('BMS_WF_CLONE_RUNTIME_LOCK') ?: "${params.code_root}/config/ngs/wf_clone_validation_v1.8.4.lock.json"
    wf_clone_basecaller_model = 'dna_r10.4.1_e8.2_400bps_hac@v6.0.0'
    wf_clone_sample = null
    wf_clone_approx_size = 7000
    wf_clone_assm_coverage = 60
    wf_clone_trim_length = 0
    wf_clone_min_quality = 9
    wf_clone_assembly_tool = 'flye'
    wf_clone_large_construct = false

    // GPU model requested (e.g. 'A30')
    gpu_model = 'A30'

    // GPU queue name or partition (if applicable, e.g. 'gpuq')
    gpu_queue = null

    // Number of GPUs to request. Keep portable; deployments can override with BMS_GPU_COUNT.
    gpus = (System.getenv('BMS_GPU_COUNT') ?: '1') as Integer

    // Number of CPUs to request per GPU
    cpus_per_gpu = 8

    // Number of CPUs to request for CPU-only jobs
    cpus = 24

    // Memory requested for GPU jobs
    memory_gpu = '24GB'

    // Memory requested for CPU-only jobs
    memory_cpu = '24GB'

    ////////////////////////////////
    // INTERNAL SYSTEM PARAMETERS //
    ////////////////////////////////
    // WARNING: These parameters are used internally by the pipeline system.
    // Users should NOT modify these parameters as they will interfere with functionality
    bindsweeper_param_combo = null
}
profiles {
    // RFantibody child job profile - standalone backbone generation
    antibody_backbone {
        params {
            rfd_mode = 'rfantibody_backbone'  // Routes to standalone RFantibody entry point
        }
    }
    maturation_child {
        params {
            rfd_mode = 'maturation_child'
            skip_rfd = true
            skip_rfd_seq = true
            skip_rfd_seq_pred = true
        }
    }
    test {
        // base configuration for testing
        params {
            rfd_num_designs = 4
            seqs_per_design = 2
        }
    }
    docker {
        // Docker deployment with standard container paths
        params {
            data_root = '/data'
            weights_root = '/weights'
            msa_local_db = '/data/colabfold_db'
            msa_cache_dir = '/data/msa_cache'
        }
    }
    hpc {
        // HPC/SLURM deployment with scratch-based storage
        params {
            data_root = System.getenv('SCRATCH') ?: System.getenv('TMPDIR') ?: '/scratch'
            weights_root = "${params.data_root}/weights"
            msa_local_db = "${params.data_root}/colabfold_db"
            msa_cache_dir = "${params.data_root}/msa_cache"
        }
    }
    af2_predict {
        params {
            pred_method = 'af2'
            skip_rfd_seq = true
        }
    }
    rf3 {
        params {
            pred_method = 'rf3'
            skip_rfd_seq = true
        }
    }
    boltz {
        params {
            pred_method = 'boltz'
            skip_rfd_seq = true
        }
    }
    both {
        // Run both Boltz-2 and RF3 predictors for sequence-based structure prediction
        params {
            pred_method = 'both'
        }
    }
    boltzgen {
        // BoltzGen ligand-aware binder design
        params {
            diffusion_method = 'boltzgen'
            run_docking = false
            seq_method = 'fampnn'
            pred_method = 'boltz'
        }
    }
    oligo_design {
        // Oligo Designer - RFDpoly multi-polymer design (DNA/RNA/protein)
        params {
            rfd_mode = 'oligo_design'
            rfdpoly_enabled = true
        }
    }
    protein_local_redesign {
        params {
            rfd_mode = 'protein_local_redesign'
            diffusion_method = 'rfd3'
            seq_method = 'fampnn'
            pred_method = 'boltz'
            plr_region_mode = 'manual_ranges'
            plr_num_designs = 8
            plr_seq_method = 'fampnn'
            plr_fix_fixed_sidechains = true
            plr_structure_validators = 'protenix_v2'
            interactive_gating = true
            interactive_gate_stage = 'post_structure_validation'
            interactive_gate_continue = false
        }
    }
    protein_cad_experimental {
        params {
            rfd_mode = 'protein_cad_experimental'
            pcad_backend = 'disco'
            pcad_task = 'unconditional'
            pcad_num_designs = 8
            pcad_target_lengths = '100,200'
            laproteina_preset = 'ucond_tri'
            laproteina_samples_per_length = 8
            laproteina_num_steps = 400
            disco_experiment = 'designable'
            disco_effort = 'fast'
        }
    }
    rfd3_generation {
        params {
            modification_mode = 'de_novo_design'
            diffusion_method = 'rfd3'
            rfd_mode = 'monomer_denovo'
            run_rfd_only = true
            skip_rfd = false
            skip_rfd_seq = false
            skip_rfd_seq_pred = false
            run_frustrampnn = false
        }
    }
    shape_blueprint {
        params {
            modification_mode = 'shape_blueprint'
            shape_generator = 'rfd3'
            shape_sequence_engines = 'proteinmpnn,fampnn'
            shape_predictor = 'esmfold2'
            shape_rfd3_num_timesteps = 200
            shape_esmf_model_variant = 'fast'
            shape_esmf_num_loops = 3
            shape_esmf_num_sampling_steps = 50
        }
    }
    protein_hunter_experimental {
        params {
            rfd_mode = 'protein_hunter_experimental'
            ph_backend = 'boltz'
            ph_task = 'protein_binder'
            ph_num_designs = 4
            ph_num_cycles = 7
            ph_min_protein_length = 90
            ph_max_protein_length = 150
            ph_percent_x = 50
            ph_seed_binder_sequence = ''
            ph_target_protein_sequences = ''
            ph_target_pdb = ''
            ph_target_pdb_chain = ''
            ph_target_template_path = ''
            ph_target_template_chain_id = ''
            ph_ligand_smiles = ''
            ph_ligand_ccd = ''
            ph_nucleic_sequence = ''
            ph_nucleic_type = 'rna'
            ph_contact_residues = ''
            ph_cyclic = false
            ph_alanine_bias = true
            ph_temperature = 0.1
            ph_high_iptm_threshold = 0.7
            ph_high_plddt_threshold = 0.8
            ph_msa_mode = 'mmseqs'
            ph_boltz_model_version = 'boltz2'
            ph_boltz_model_path = ''
            ph_boltz_ccd_path = ''
            ph_chai_hysteresis_mode = 'templates'
            ph_chai_num_recycles = 3
            ph_chai_num_diff_steps = 200
            ph_chai_repredict = true
        }
    }
    boltz_cp_experimental {
        params {
            rfd_mode = 'boltz_cp_experimental'
            bcp_repo_path = '/opt/fold-cp'
            bcp_gpu_ids = System.getenv('BMS_BOLTZ_CP_GPU_IDS') ?: ''
            bcp_size_cp = 4
            bcp_input_format = 'config_files'
            bcp_output_format = 'mmcif'
            bcp_write_full_pae = false
            bcp_recycling_steps = 3
            bcp_sampling_steps = 200
            bcp_diffusion_samples = 1
        }
    }
    confornets_experimental {
        params {
            rfd_mode = 'confornets_experimental'
            cn_task = 'diversity'
            cn_chain_id = 'A'
            cn_benchmark_name = 'bms_confornets'
            cn_test_case_name = 'monomer_case'
            cn_confornets_repo_path = System.getenv('BMS_CONFORNETS_REPO') ?: '/opt/confornets'
            cn_num_runs = 2
            cn_k_confornets = 2
            cn_num_samples = 5
            cn_max_steps = 21
            cn_save_steps = '5,10,15,20'
            cn_num_recycles = 0
            cn_num_diffusion_steps = 200
            cn_skip_msa = false
            cn_compute_confidence = true
            cn_save_full_confidence = false
            cn_compute_evaluation = true
        }
    }
    // Phase 3 safety amendment: the canonical API emits this profile explicitly.
    conformational_mapping {
        executor.name = 'local'
        process {
            executor = 'local'
            errorStrategy = 'terminate'
            maxRetries = 0
        }
        params {
            cm_request_path = null
        }
    }
    molecular_dynamics {
        params {
            rfd_mode = 'molecular_dynamics'
            md_job_config = null
            md_input_root = null
        }
    }
    molecular_dynamics_experimental {
        params {
            rfd_mode = 'molecular_dynamics_experimental'
            md_job_config = null
            md_input_root = null
            replica_index = 0
            md_engine = null
        }
    }
    molecular_dynamics_coordinator {
        params {
            rfd_mode = 'molecular_dynamics_coordinator'
            md_job_config = null
            md_input_root = null
            md_child_poll_seconds = 5
            md_analysis_enabled = (System.getenv('BMS_MD_ANALYSIS_ENABLED') ?: '0') == '1'
        }
    }
    molecular_dynamics_analysis {
        executor.name = 'local'
        process {
            executor = 'local'
            errorStrategy = 'retry'
            maxRetries = 2
            withLabel: MolecularDynamicsAnalysis {
                cpus = 4
                memory = '12 GB'
                time = '4h'
            }
        }
        params {
            rfd_mode = 'molecular_dynamics_analysis'
            md_analysis_work_item = null
            md_analysis_stride = 1
            md_analysis_max_points = 2000
            md_analysis_container = System.getenv('BMS_MD_ANALYSIS_CONTAINER') ?: "${bmsContainerRootFallback}/md-analysis-1.0.0.sif"
            md_analysis_sif_sha256 = System.getenv('BMS_MD_ANALYSIS_SIF_SHA256')
            md_analysis_implementation_sha256 = System.getenv('BMS_MD_ANALYSIS_IMPLEMENTATION_SHA256')
        }
    }
    bindcraft2 {
        process {
            withName: RunBindCraft2 {
                cpus = 4
                memory = '16 GB'
                time = '72h'
            }
        }
    }
    protonpottsmpnn_design {
        process {
            withName: RunProtonPottsMPNNDesign {
                cpus = params.cpus ?: 4
                memory = '16 GB'
                time = '12h'
            }
        }
    }
    ligandmpnn_interface_context {
        process {
            withName: RunLigandMPNNInterfaceContext {
                cpus = 4
                memory = '16 GB'
                time = '12h'
            }
        }
    }
    // ESMFold2 engine profile used by structure prediction, mutagenesis, and de-novo validation.
    esmfold2 {
        executor.name = 'local'
        process {
            executor = 'local'
            errorStrategy = 'terminate'
            maxRetries = 0

            withName: ESMFold2Predict {
                cpus = 8
                memory = '16 GB'
                time = '6h'
                accelerator = 1
            }

            withName: BatchESMFold2Validation {
                cpus = 8
                memory = '16 GB'
                time = '12h'
                accelerator = 1
            }


        }

        params {
            esmf_model_variant = 'fast'
            esmf_model_id_or_path = ''
            esmf_local_files_only = true
            esmf_num_loops = 1
            esmf_num_sampling_steps = 5
            esmf_num_diffusion_samples = 1
            esmf_device = 'cuda'
            esmf_gpu_id = 0
        }
    }


    ont_basecall_dna {
        params {
            nanopore_enabled = true
            rfd_mode = 'ont_basecall_dna'
            ont_workflow_id = 'ont_basecall_dna'
            ont_molecule_type = 'dna'
            skip_rfd = true
            skip_rfd_seq = true
            skip_rfd_seq_pred = true
            skip_pred = true
            run_docking = false
        }
    }
    ont_basecall_rna {
        params {
            nanopore_enabled = true
            rfd_mode = 'ont_basecall_rna'
            ont_workflow_id = 'ont_basecall_rna'
            ont_molecule_type = 'rna'
            dorado_model = 'rna004_sup'
            skip_rfd = true
            skip_rfd_seq = true
            skip_rfd_seq_pred = true
            skip_pred = true
            run_docking = false
        }
    }
    ont_plasmid_qc {
        params {
            nanopore_enabled = true
            rfd_mode = 'ont_plasmid_qc'
            ont_workflow_id = 'ont_plasmid_qc'
            fastq_minimap2_preset = 'map-ont'
            skip_rfd = true
            skip_rfd_seq = true
            skip_rfd_seq_pred = true
            skip_pred = true
            run_docking = false
        }
    }
    ont_construct_screening {
        params {
            nanopore_enabled = true
            rfd_mode = 'ont_construct_screening'
            ont_workflow_id = 'ont_construct_screening'
            fastq_minimap2_preset = 'map-ont'
            skip_rfd = true
            skip_rfd_seq = true
            skip_rfd_seq_pred = true
            skip_pred = true
            run_docking = false
        }
    }
    ont_methylation_analysis {
        params {
            nanopore_enabled = true
            rfd_mode = 'ont_methylation_analysis'
            ont_workflow_id = 'ont_methylation_analysis'
            skip_rfd = true
            skip_rfd_seq = true
            skip_rfd_seq_pred = true
            skip_pred = true
            run_docking = false
        }
    }
    ont_fastq_qc {
        params {
            nanopore_enabled = true
            rfd_mode = 'ont_fastq_qc'
            ont_workflow_id = 'ont_fastq_qc'
            fastq_minimap2_preset = 'map-ont'
            skip_rfd = true
            skip_rfd_seq = true
            skip_rfd_seq_pred = true
            skip_pred = true
            run_docking = false
        }
    }
    ont_pooled_reference_assignment {
        executor.name = 'local'
        process {
            executor = 'local'
            errorStrategy = 'terminate'
            maxRetries = 0
        }
        params {
            nanopore_enabled = true
            rfd_mode = 'ont_pooled_reference_assignment'
            ont_workflow_id = 'ont_pooled_reference_assignment'
            pooled_assignment_min_mapq = 20
            pooled_assignment_min_alignment_score_margin = 10
            skip_rfd = true
            skip_rfd_seq = true
            skip_rfd_seq_pred = true
            skip_pred = true
            run_docking = false
        }
    }
    wf_clone_validation {
        params {
            nanopore_enabled = true
            rfd_mode = 'wf_clone_validation'
            ont_workflow_id = 'wf_clone_validation'
            fastq_minimap2_preset = 'map-ont'
            skip_rfd = true
            skip_rfd_seq = true
            skip_rfd_seq_pred = true
            skip_pred = true
            run_docking = false
        }
    }
    protenix {
        // Protenix structure prediction (ByteDance AF3-level predictor)
        params {
            pred_method = 'protenix'
            skip_rfd_seq = true
        }
    }
    protein_sequence_design {
        // Selected native wrapper owns sequence design only, not prediction.
        params {
            skip_rfd = true
            skip_pred = true
        }
    }
    fampnn_predict {
        // Skip diffusion, just do sequence design + prediction (for existing backbones)
        params {
            skip_rfd = true
            seq_method = 'fampnn'
            pred_method = 'boltz'
        }
    }
    docking {
        // Standalone DiffDock docking (no design pipeline)
        params {
            skip_rfd = true
            skip_rfd_seq = true
            skip_pred = true
            run_docking = true
        }
    }
    unidock {
        // Standalone Uni-Dock GPU docking (physics-based)
        params {
            skip_rfd = true
            skip_rfd_seq = true
            skip_pred = true
        }
    }
    dual_docking {
        // Run both DiffDock and Uni-Dock for orthogonal validation
        params {
            skip_rfd = true
            skip_rfd_seq = true
            skip_pred = true
            run_docking = true
        }
    }
    monomer_denovo {
        params {
            rfd_mode = 'monomer_denovo'
            rfd_contigs = '[80-80]'
            seq_method = 'fampnn'
            pred_method = 'boltz'
        }
    }
    monomer_foldcond {
        params {
            rfd_mode = 'monomer_foldcond'
            rfd_scaffold_dir = './binderscaffolds/scaffolds_assorted'
            seq_method = 'fampnn'
        }
    }
    monomer_motifscaff {
        params {
            rfd_mode = 'monomer_motifscaff'
            rfd_input_pdb = './benchmarkdata/5o45_pd-l1.pdb'
            rfd_contigs = '[A17-43/9-15/A53-117/3-6/A121-131]'
            rfd_inpaint_seq = '[A17-19/A129-131]'
        }
    }
    monomer_partialdiff {
        params {
            rfd_mode = 'monomer_partialdiff'
            rfd_input_pdb = './benchmarkdata/5o45_pd-l1.pdb'
            rfd_contigs = '[A17-111/20]'
            rfd_partial_diffusion_timesteps = 20
            mpnn_relax_max_cycles = 1
            pred_method = 'boltz'
        }
    }
    binder_denovo {
        params {
            rfd_mode = 'binder_denovo'
            rfd_input_pdb = './benchmarkdata/5o45_pd-l1.pdb'
            rfd_contigs = '[A17-131/0 60-100]'
        }
    }
    binder_foldcond {
        params {
            rfd_mode = 'binder_foldcond'
            rfd_input_pdb = './benchmarkdata/5o45_pd-l1.pdb'
            rfd_scaffold_dir = './binderscaffolds/scaffolds_assorted'
            rfd_target_ss = './benchmarkdata/5o45_pd-l1_ss.pt'
            rfd_target_adj = './benchmarkdata/5o45_pd-l1_adj.pt'
            rfd_mask_loops = false
        }
    }
    binder_motifscaff {
        params {
            rfd_mode = 'binder_motifscaff'
            rfd_input_pdb = "./lib/examplebinder.pdb"
            rfd_contigs = "[5-10/A1-88/10-20/0 B89-203]"
            rfd_ckpt_override = 'complex_base'
            rfd_length = '110-110'
        }
    }
    binder_partialdiff {
        params {
            rfd_mode = 'binder_partialdiff'
            rfd_input_pdb = "./lib/examplebinder.pdb"
            rfd_contigs = "[88-88/0 B89-203]"
            rfd_partial_diffusion_timesteps = 20
        }
    }
    apptainer {
        conda.enabled = false
        apptainer.enabled = true
        apptainer.autoMount = true
        // Nextflow 25.10 can throw a null pullTimeout NPE before a task starts
        // when pulling remote Apptainer images from a bare profile. Keep a real
        // timeout/cache on the generic profile so standalone experimental smoke
        // runs do not depend on workstation-specific profile layering.
        apptainer.pullTimeout = System.getenv('NXF_APPTAINER_PULL_TIMEOUT') ?: '60 min'
        apptainer.cacheDir = System.getenv('NXF_APPTAINER_CACHEDIR') ?: ensureDir("${cacheRoot}/apptainer")
        singularity.enabled = false
        docker.enabled = false
        params.container_dir = "https://object-store.rc.nectar.org.au/v1/AUTH_b6f9bdf15faf4320a7587fd42f62e530/ContainerHub"
    }
    singularity {
        conda.enabled = false
        apptainer.enabled = false
        apptainer.autoMount = false
        singularity.enabled = true
        singularity.autoMount = true
        docker.enabled = false
        params.container_dir = "https://object-store.rc.nectar.org.au/v1/AUTH_b6f9bdf15faf4320a7587fd42f62e530/ContainerHub"
    }
    // Profile for WEHI HPC environment
    milton {
        conda.enabled = false
        apptainer.enabled = true
        apptainer.autoMount = true
        singularity.enabled = false
        docker.enabled = false
        params.rfd_models = resolveRfdModels(params.weights_root)
        params.af2_models = System.getenv('BMS_AF2_MODELS') ?: "${params.weights_root}/alphafold/params"
        params.boltz_models = System.getenv('BMS_BOLTZ_MODELS') ?: "${params.weights_root}/boltz"
        params.container_dir = System.getenv('BMS_CONTAINER_DIR') ?: (params.data_root ? "${params.data_root}/apptainer" : "${params.code_root}/apptainer")
        params.gpu_queue = 'gpuq'
    }

    // Local workstation profile. GPU count is env/config driven, not tied to host ordinals.
    workstation_ryzen7960x {
        conda.enabled = false
        apptainer.enabled = true
        apptainer.autoMount = true
        apptainer.pullTimeout = '60 min'
        apptainer.cacheDir = System.getenv('NXF_APPTAINER_CACHEDIR') ?: ensureDir("${cacheRoot}/apptainer")
        singularity.enabled = false
        docker.enabled = false

        // Local executor (not SLURM)
        executor.name = 'local'
        executor.queueSize = 100

        params {
            // Local model paths (download once, use forever)
            rfd_models = resolveRfdModels(params.weights_root)
            af2_models = System.getenv('BMS_AF2_MODELS') ?: "${params.weights_root}/alphafold/params"
            boltz_models = System.getenv('BMS_BOLTZ_MODELS') ?: "${params.weights_root}/boltz"

            // Local container directory (all .sif files in one location)
            // Prefer explicit env override, then data-root apptainer store, then repo-local fallback.
            container_dir = System.getenv('BMS_CONTAINER_DIR') ?: (params.data_root ? "${params.data_root}/apptainer" : "${params.code_root}/apptainer")

            // GPU configuration - override per deployment via BMS_WORKSTATION_GPU_COUNT/BMS_GPU_COUNT.
            gpus = (System.getenv('BMS_WORKSTATION_GPU_COUNT') ?: System.getenv('BMS_GPU_COUNT') ?: params.gpus ?: '1') as Integer

            // CPU allocation per GPU task; tune per deployment alongside GPU count.
            cpus_per_gpu = 4

            // Memory per GPU task; tune per deployment/workload.
            memory_gpu = '12GB'

            // CPU-only tasks (filtering, analysis)
            cpus = 4
            memory_cpu = '8GB'

            // No SLURM-specific settings
            gpu_model = null
            gpu_queue = null
        }

        process {
            // Default resources for CPU tasks
            cpus = params.cpus
            memory = params.memory_cpu

            // GPU tasks: allow up to 25 parallel - VRAM-aware allocation handles packing
            withLabel: gpu {
                maxForks = 25
                cpus = params.cpus_per_gpu
                memory = params.memory_gpu
                // Retry strategy is configurable via params.allow_retries (default: OFF for debugging)
                // When OFF: jobs fail immediately on error so you can diagnose the issue
                // When ON: retries on OOM (137) and SIGSEGV (139), but NOT on general errors (1)
                errorStrategy = { 
                    if (params.allow_retries) {
                        task.exitStatus in [137, 139] ? 'retry' : 'finish'
                    } else {
                        'terminate'
                    }
                }
                maxRetries = params.allow_retries ? 3 : 0
                containerOptions = {
                    def baseOpts = task.ext.containerOptions ?: ""

                    // ═══════════════════════════════════════════════════════════════
                    // STRICT ORCHESTRATOR MODE: One source of truth for GPU assignment
                    // ═══════════════════════════════════════════════════════════════
                    // The Python GPU Orchestrator is the ONLY decision-maker for GPU
                    // assignment. It reads the target_vram_fill slider from UI config
                    // and performs VRAM-aware bin-packing.
                    //
                    // DO NOT add nvidia-smi fallback here - it bypasses orchestrator
                    // and causes job pile-ups on a single GPU.
                    // ═══════════════════════════════════════════════════════════════
                    
                    // Use orchestrator-assigned GPU, or env var for standalone runs
                    def gpuId = params.gpu_id?.toString() ?: System.getenv("NXF_DEFAULT_GPU") ?: '0'
                    
                    return "${gpuPrefix(gpuId)} ${baseOpts}"
                }
            }

            // Legacy GPU-labelled tasks still exist in several modules (RFantibody,
            // ThermoMPNN, AntiFold, FrustraMPNN). Keep them on the same dynamic
            // CPU/memory contract as the main gpu label.
            withLabel: process_gpu {
                maxForks = 25
                cpus = params.cpus_per_gpu
                memory = params.memory_gpu
            }

            // Light GPU tasks: follow orchestrator or standalone GPU selection
            withLabel: gpu_light {
                maxForks = 4
                cpus = params.cpus_per_gpu
                memory = '16GB'
                containerOptions = {
                    def baseOpts = task.ext.containerOptions ?: ""

                    // ═══════════════════════════════════════════════════════════════
                    // GPU ASSIGNMENT PRIORITY:
                    // 1. task.ext.gpu_id - Per-task assignment from process input (FAMPNN multi-GPU)
                    // 2. params.gpu_id - Global orchestrator assignment
                    // 3. NXF_DEFAULT_GPU env var - For standalone runs
                    // 4. Default to GPU 0 if no env override
                    // ═══════════════════════════════════════════════════════════════
                    
                    def gpuId = task.ext.gpu_id?.toString() ?: params.gpu_id?.toString() ?: System.getenv("NXF_DEFAULT_GPU") ?: '0'
                    
                    return "${gpuPrefix(gpuId)} ${baseOpts}"
                }
            }
        }
    }

    debug {
        cleanup = false
    }
}




process {
    // default is to use resource request for cpu-only jobs
    cpus = "${params.cpus}"
    memory = "${params.memory_cpu}"
    // Canonical FrustraMPNN is host-adapted and launches its authenticated SIF
    // directly. One orchestrator-selected physical GPU is isolated per task;
    // the contained model sees task-local CUDA index 0.
    withLabel: frustrampnn_gpu {
        maxForks = 1
        cpus = "${params.cpus_per_gpu}"
        memory = "${params.memory_gpu}"
        accelerator = 1
        ext.accelerator_vendor = 'nvidia'
        ext.accelerator_api = 'cuda'
        ext.accelerator_count = 1
        errorStrategy = 'terminate'
        maxRetries = 0
        containerOptions = {
            def gpuId = params.frustrampnn_physical_gpu_id?.toString()
            if (!(gpuId ==~ /(?:0|[1-9][0-9]*)/)) {
                throw new IllegalArgumentException(
                    'frustrampnn_gpu requires explicit scheduler-assigned frustrampnn_physical_gpu_id'
                )
            }
            return gpuPrefix(gpuId)
        }
    }
    withLabel: gpu {
        clusterOptions = '--gres=gpu:' + "${params.gpu_model}" + ':1'
        cpus = "${params.cpus_per_gpu}"
        memory = "${params.memory_gpu}"
        queue = params.gpu_queue ? "${params.gpu_queue}" : null
    }
    withLabel: AF2 {
        container = { (System.getenv('BMS_SELECTED_IMAGE_AF2_SIF') ?: "${params.container_dir}/af2.sif") }
        containerOptions = """${gpuPrefix(params.gpu_id)} \
            --env "XLA_PYTHON_CLIENT_PREALLOCATE=false" \
            --bind "${params.code_root}/scripts:/scripts" \
            --bind "${params.code_root}" \
            --bind ${weightBind(params.af2_models, "/dl_binder_design/af2_initial_guess/model_weights/params")}"""
    }
    withLabel: Boltz {
        container = { (System.getenv('BMS_SELECTED_IMAGE_BOLTZ2_SIF') ?: "${params.container_dir}/boltz2.sif") }
        containerOptions = """${gpuPrefix(params.gpu_id)} \
            --bind ${params.data_root ?: dataRootFallback}:${params.data_root ?: dataRootFallback} \
            --bind ${params.code_root}/scripts:/scripts \
            --bind ${params.code_root} \
            --bind ${weightBind(params.boltz_models, "/boltzcache")}"""
    }
    withLabel: BoltzCP {
        container = params.bcp_container_path ?: (System.getenv('BMS_SELECTED_IMAGE_FOLD_CP_SIF') ?: "${params.container_dir}/fold-cp.sif")
        containerOptions = """--nv --env CUDA_DEVICE_ORDER=PCI_BUS_ID --env CUDA_VISIBLE_DEVICES=${firstConfiguredGpuIds(params.get('bcp_gpu_ids', null), params.get('gpu_id', 0))} \
            --env HF_HOME=/cache/huggingface --env XDG_CACHE_HOME=/cache/general --env TRITON_CACHE_DIR=/cache/triton --env MPLCONFIGDIR=/cache/matplotlib \
            --bind ${params.cache_root}:/cache \
            --bind ${params.data_root ?: dataRootFallback}:${params.data_root ?: dataRootFallback} \
            --bind ${params.code_root}/scripts:/scripts \
            --bind ${params.code_root} \
            --bind ${weightBind(params.boltz_models, "/boltzcache")}"""
    }
    withLabel: ConforNets {
        container = { params.cn_container_path ?: (System.getenv('BMS_SELECTED_IMAGE_CONFORNETS_SIF') ?: "${params.container_dir}/confornets.sif") }
        containerOptions = """${gpuPrefix(params.gpu_id)} \
            --env HF_HOME=/cache/huggingface --env XDG_CACHE_HOME=/cache/general --env TRITON_CACHE_DIR=/cache/triton --env MPLCONFIGDIR=/cache/matplotlib --env NUMBA_CACHE_DIR=/cache/numba \
            --bind ${params.cache_root}:/cache \
            ${params.cn_confornets_repo_path ? "--bind " + params.cn_confornets_repo_path + ":" + params.cn_confornets_repo_path : ""} \
            --bind ${params.data_root ?: dataRootFallback}:${params.data_root ?: dataRootFallback} \
            --bind ${params.code_root}/scripts:/scripts \
            --bind ${params.code_root} \
            --bind ${weightBind(params.weights_root, "/weights")}"""
    }
    withLabel: ConforNetsCanonical {
        container = { params.cm_confornets_container_path ?: (System.getenv('BMS_SELECTED_IMAGE_CONFORNETS_CANONICAL_SIF') ?: "${params.container_dir}/confornets-canonical.sif") }
        containerOptions = """${gpuPrefix(params.gpu_id)} \
            --env HF_HOME=/cache/huggingface --env XDG_CACHE_HOME=/cache/general --env TRITON_CACHE_DIR=/cache/triton --env MPLCONFIGDIR=/cache/matplotlib --env NUMBA_CACHE_DIR=/cache/numba \
            --bind ${params.cache_root}:/cache \
            --bind ${params.data_root ?: dataRootFallback}:${params.data_root ?: dataRootFallback} \
            --bind ${params.code_root}/scripts:/scripts \
            --bind ${params.code_root} \
            --bind ${weightBind(params.weights_root, "/weights")}"""
    }
    withLabel: MolecularDynamicsPreparation {
        container = params.md_preparation_container
        containerOptions = """--env BMS_FEATURE_MOLECULAR_DYNAMICS=${mdFeatureFlag} \
            --env BMS_MD_PREPARATION_SIF=/opt/bms-md-preparation-runtime.sif \
            --env BMS_MD_PREPARATION_RUNTIME_LOCK=/opt/bms-md-preparation-runtime.lock \
            --bind ${params.md_preparation_container}:/opt/bms-md-preparation-runtime.sif:ro \
            --bind ${params.md_preparation_runtime_lock}:/opt/bms-md-preparation-runtime.lock:ro \
            --bind ${params.data_root ?: dataRootFallback}:${params.data_root ?: dataRootFallback} \
            ${params.md_input_root ? "--bind " + params.md_input_root + ":" + params.md_input_root : ""} \
            --bind ${params.code_root}:${params.code_root}"""
        cpus = 1
        memory = '4 GB'
        time = '1h'
        errorStrategy = 'terminate'
    }
    withLabel: MolecularDynamicsCpu {
        container = { (System.getenv('BMS_SELECTED_IMAGE_GROMACS_MD_2025_3_SIF') ?: "${params.container_dir}/gromacs-md-2025.3.sif") }
        containerOptions = """--env BMS_FEATURE_MOLECULAR_DYNAMICS=${mdFeatureFlag} \
            --bind ${params.data_root ?: dataRootFallback}:${params.data_root ?: dataRootFallback} \
            ${params.md_input_root ? "--bind " + params.md_input_root + ":" + params.md_input_root : ""} \
            --bind ${params.code_root}:${params.code_root}"""
        cpus = 1
        memory = '2 GB'
        time = '1h'
        errorStrategy = 'terminate'
    }
    withLabel: MolecularDynamicsAnalysis {
        container = params.md_analysis_container ?: "${bmsContainerRootFallback}/md-analysis-1.0.0.sif"
        containerOptions = """--env BMS_FEATURE_MOLECULAR_DYNAMICS=${mdFeatureFlag} \
            --env BMS_MD_ANALYSIS_SIF_SHA256=${params.md_analysis_sif_sha256 ?: ''} \
            --env BMS_MD_ANALYSIS_IMPLEMENTATION_SHA256=${params.md_analysis_implementation_sha256 ?: ''} \
            --bind ${params.md_analysis_container ?: bmsContainerRootFallback + '/md-analysis-1.0.0.sif'}:/opt/bms-md-analysis-runtime.sif:ro \
            --bind ${params.data_root ?: dataRootFallback}:${params.data_root ?: dataRootFallback} \
            --bind ${params.code_root}:${params.code_root}"""
        cpus = 4
        memory = '12 GB'
        time = '4h'
        errorStrategy = 'retry'
        maxRetries = 2
    }
    withLabel: MolecularDynamicsCoordinator {
        cpus = 1
        memory = '2 GB'
        time = '7d'
        errorStrategy = 'terminate'
    }
    withLabel: MolecularDynamicsGromacs {
        container = params.md_gromacs_container
        containerOptions = """${gpuPrefix(params.gpu_id)} --env BMS_FEATURE_MOLECULAR_DYNAMICS=${mdFeatureFlag} \
            --bind ${params.md_gromacs_container}:/opt/bms-md-engine-runtime.sif:ro \
            --bind ${params.data_root ?: dataRootFallback}:${params.data_root ?: dataRootFallback} \
            ${params.md_input_root ? "--bind " + params.md_input_root + ":" + params.md_input_root : ""} \
            --bind ${params.code_root}:${params.code_root}"""
        cpus = 8
        memory = '16 GB'
        time = '24h'
        ext.accelerator_vendor = 'nvidia'
        ext.accelerator_api = 'cuda'
        ext.accelerator_count = 1
        errorStrategy = 'terminate'
    }
    withLabel: MolecularDynamicsOpenMM {
        container = params.md_openmm_container
        containerOptions = """${gpuPrefix(params.gpu_id)} --env BMS_FEATURE_MOLECULAR_DYNAMICS=${mdFeatureFlag} \
            --bind ${params.md_openmm_container}:/opt/bms-md-engine-runtime.sif:ro \
            --bind ${params.data_root ?: dataRootFallback}:${params.data_root ?: dataRootFallback} \
            ${params.md_input_root ? "--bind " + params.md_input_root + ":" + params.md_input_root : ""} \
            --bind ${params.code_root}:${params.code_root}"""
        cpus = 4
        memory = '8 GB'
        time = '24h'
        ext.accelerator_vendor = 'nvidia'
        ext.accelerator_api = 'cuda'
        ext.accelerator_count = 1
        errorStrategy = 'terminate'
    }
    withLabel: ESMFold2 {
        container = params.esmf_container_path ?: (System.getenv('BMS_SELECTED_IMAGE_ESMFOLD2_SIF') ?: "${params.container_dir}/esmfold2.sif")
        containerOptions = """${gpuPrefix(params.gpu_id)} \
            --env HF_HOME=/weights/esmfold2/hf_home --env HF_HUB_CACHE=/weights/esmfold2/hf_home/hub --env TRANSFORMERS_CACHE=/weights/esmfold2/hf_home/hub --env XDG_CACHE_HOME=/cache/general --env TRITON_CACHE_DIR=/cache/triton \
            --bind ${params.cache_root}:/cache \
            --bind ${params.data_root ?: dataRootFallback}:${params.data_root ?: dataRootFallback} \
            --bind ${params.code_root}/scripts:/scripts \
            --bind ${params.code_root} \
            --bind ${weightBind(params.weights_root, "/weights")}"""
    }
    withLabel: FAMPNN {
        container = { (System.getenv('BMS_SELECTED_IMAGE_FAMPNN_SIF') ?: "${params.container_dir}/fampnn.sif") }
        containerOptions = """${gpuPrefix(params.gpu_id)} \
            --bind ${params.code_root}/scripts:/scripts \
            --bind ${params.code_root}"""
    }
    withLabel: MPNN {
        container = { (System.getenv('BMS_SELECTED_IMAGE_DL_BINDER_DESIGN_SIF') ?: "${params.container_dir}/dl_binder_design.sif") }
        containerOptions = """${gpuPrefix(params.gpu_id)} \
            --bind ${params.code_root}/scripts:/scripts \
            --bind ${params.code_root}"""
    }
    withLabel: RFDiffusion {
        container = { (System.getenv('BMS_SELECTED_IMAGE_RFDIFFUSION_SIF') ?: "${params.container_dir}/rfdiffusion.sif") }
        containerOptions = """${gpuPrefix(params.gpu_id)} \
            --writable-tmpfs \
            --bind ${params.code_root}/schedules:/app/RFdiffusion/schedules \
            --bind ${dglCacheDir}:\$HOME/.dgl \
            --bind ${params.code_root}/scripts:/scripts \
            --bind ${params.code_root} \
            --bind ${weightBind(params.rfd_models, "/app/RFdiffusion/models")}"""
    }
    withLabel: pyrosetta_tools {
        container = { (System.getenv('BMS_SELECTED_IMAGE_PYROSETTA_TOOLS_SIF') ?: "${params.container_dir}/pyrosetta_tools.sif") }
        containerOptions = """--env PATH=/opt/conda/envs/pyrosetta/bin:\$PATH \
            --bind ${params.cm_api_runtime_dir}:${params.cm_api_runtime_dir}:ro \
            --bind ${params.code_root} \
            --bind ${params.code_root}/scripts:/scripts"""
    }
    withLabel: Foundry {
        container = { (System.getenv('BMS_SELECTED_IMAGE_FOUNDRY_SIF') ?: "${params.container_dir}/foundry.sif") }
        containerOptions = {
            def checkpointBind = task.process.tokenize(':').last() in ['RunRF3', 'RunRFD3'] ? "--bind ${weightBind("${params.weights_root}/foundry/checkpoints", "/foundry/checkpoints")}" : ''
            return """${gpuPrefix(params.gpu_id)} \
            --writable-tmpfs \
            --env FOUNDRY_CHECKPOINT_DIRS=/foundry/checkpoints \
            --env XDG_CACHE_HOME=/tmp --env TRITON_CACHE_DIR=/tmp/triton \
            --env HF_HOME=/cache/huggingface \
            --bind ${params.cache_root}:/cache \
            --bind ${params.code_root}/scripts:/scripts \
            --bind ${params.code_root} \
            ${checkpointBind}"""
        }
    }
    withLabel: ShapeRFD3 {
        container = { (System.getenv('BMS_SELECTED_IMAGE_SHAPE_RFD3_SIF') ?: "${params.container_dir}/shape_rfd3.sif") }
        containerOptions = {
            def checkpointBind = "--bind ${weightBind("${params.weights_root}/foundry/checkpoints", "/foundry/checkpoints")}"
            return """${gpuPrefix(params.gpu_id)} \
            --writable-tmpfs \
            --env FOUNDRY_CHECKPOINT_DIRS=/foundry/checkpoints \
            --env XDG_CACHE_HOME=/tmp --env TRITON_CACHE_DIR=/tmp/triton \
            --env HF_HOME=/cache/huggingface \
            --bind ${params.cache_root}:/cache \
            --bind ${params.code_root}/scripts/shape_blueprint/shape_guidance.py:/usr/local/lib/python3.12/dist-packages/shape_guidance.py:ro \
            --bind ${params.code_root}/scripts/shape_blueprint/rfd3_shape_sampler.py:/usr/local/lib/python3.12/dist-packages/bms_shape_sampler.py:ro \
            --bind ${params.code_root} \
            ${checkpointBind}"""
        }
    }
    withLabel: ShapeEvaluate {
        container = { (System.getenv('BMS_SELECTED_IMAGE_SHAPE_RFD3_SIF') ?: "${params.container_dir}/shape_rfd3.sif") }
        containerOptions = """--cleanenv \
            --bind ${params.code_root}"""
        cpus = 2
        memory = '8 GB'
        errorStrategy = 'terminate'
    }
    withLabel: BoltzGen {
        container = { (System.getenv('BMS_SELECTED_IMAGE_BOLTZGEN_SIF') ?: "${params.container_dir}/boltzgen.sif") }
        containerOptions = """${gpuPrefix(params.gpu_id)} \
            --env HF_HOME=/cache/huggingface --env XDG_CACHE_HOME=/cache/general --env MPLCONFIGDIR=/cache/matplotlib \
            --env TRITON_CACHE_DIR=/cache/triton \
            --bind ${params.cache_root}:/cache \
            --bind ${params.code_root}/scripts:/scripts \
            --bind ${params.code_root} \
            --bind ${weightBind("${params.weights_root}/boltzgen", "/weights/boltzgen")}"""
    }
    withLabel: LaProteina {
        container = { (System.getenv('BMS_SELECTED_IMAGE_LAPROTEINA_SIF') ?: "${params.container_dir}/laproteina.sif") }
        containerOptions = """${gpuPrefix(params.gpu_id)} \
            --writable-tmpfs \
            --env HF_HOME=/cache/huggingface --env XDG_CACHE_HOME=/cache/general --env MPLCONFIGDIR=/cache/matplotlib \
            --bind ${params.cache_root}:/cache \
            --bind ${params.code_root}/scripts:/scripts \
            --bind ${params.code_root} \
            --bind ${weightBind(params.weights_root)}"""
    }
    withLabel: DISCO {
        container = { (System.getenv('BMS_SELECTED_IMAGE_DISCO_SIF') ?: "${params.container_dir}/disco.sif") }
        containerOptions = """${gpuPrefix(params.gpu_id)} \
            --writable-tmpfs \
            --env HF_HOME=/cache/huggingface --env XDG_CACHE_HOME=/cache/general --env TRITON_CACHE_DIR=/cache/triton \
            --bind ${params.cache_root}:/cache \
            --bind ${params.code_root}/scripts:/scripts \
            --bind ${params.code_root} \
            --bind ${weightBind(params.weights_root)}"""
    }
    withLabel: Caliby {
        container = { (System.getenv('BMS_SELECTED_IMAGE_CALIBY_SIF') ?: "${params.container_dir}/caliby.sif") }
        containerOptions = """${gpuPrefix(params.gpu_id)} \
            --writable-tmpfs \
            --env HF_HOME=/cache/huggingface --env XDG_CACHE_HOME=/cache/general --env TRITON_CACHE_DIR=/cache/triton \
            --env MODEL_PARAMS_DIR=/weights/caliby/model_params \
            --bind ${params.cache_root}:/cache \
            --bind ${params.code_root}/scripts:/scripts \
            --bind ${params.code_root} \
            --bind ${weightBind(params.weights_root, "/weights")}"""
    }
    withLabel: ProteinHunter {
        container = { (System.getenv('BMS_SELECTED_IMAGE_PROTEIN_HUNTER_SIF') ?: "${params.container_dir}/protein_hunter.sif") }
        containerOptions = """${gpuPrefix(params.gpu_id)} \
            --writable-tmpfs \
            --env HF_HOME=/cache/huggingface --env XDG_CACHE_HOME=/cache/general --env TRITON_CACHE_DIR=/cache/triton \
            --env MPLCONFIGDIR=/cache/matplotlib --env NUMBA_CACHE_DIR=/cache/numba \
            --env BMS_MOUNTED_WEIGHTS=/weights --env BMS_HOST_WEIGHTS=${params.weights_root} \
            --bind ${params.cache_root}:/cache \
            --bind ${params.code_root}/scripts:/scripts \
            --bind ${params.code_root} \
            --bind ${weightBind(params.weights_root, "/weights")}"""
    }

    withLabel: DiffDock {
        container = { (System.getenv('BMS_SELECTED_IMAGE_DIFFDOCK_SIF') ?: "${params.container_dir}/diffdock.sif") }
        containerOptions = """${gpuPrefix(params.gpu_id)} \
            --env HF_HOME=/cache/huggingface --env TORCH_HOME=/cache/torch --env XDG_CACHE_HOME=/cache/general \
            --bind ${params.cache_root}:/cache \
            --pwd /cache \
            --bind ${params.code_root}/scripts:/scripts \
            --bind ${params.code_root} \
            --bind ${weightBind("${params.weights_root}/diffdock/workdir", "/cache/workdir")} \
            --bind ${weightBind("${params.weights_root}/diffdock/torch/hub/checkpoints", "/cache/torch/hub/checkpoints")}"""
    }
    withLabel: UniDock {
        container = { (System.getenv('BMS_SELECTED_IMAGE_UNIDOCK_SIF') ?: "${params.container_dir}/unidock.sif") }
        containerOptions = {
            def gpuId = params.unidock_gpu_id?.toString() ?: params.gpu_id?.toString() ?: System.getenv("NXF_DEFAULT_GPU") ?: '0'
            return """${gpuPrefix(gpuId)} \
                --bind ${params.code_root}/scripts:/scripts \
                --bind ${params.code_root}"""
        }
    }
    withLabel: Antiberty {
        container = { (System.getenv('BMS_SELECTED_IMAGE_ANTIBODY_TOOLS_SIF') ?: "${params.container_dir}/antibody_tools.sif") }
        containerOptions = """${gpuPrefix(params.gpu_id)} \
            --bind ${params.code_root}/scripts:/scripts \
            --bind ${params.code_root}"""
    }
    withLabel: ThermoMPNN {
        container = { (System.getenv('BMS_SELECTED_IMAGE_STABILITY_TOOLS_SIF') ?: "${params.container_dir}/stability_tools.sif") }
        containerOptions = """${gpuPrefix(params.gpu_id)} \
            --env BMS_WEIGHTS=${params.weights_root} \
            --bind ${params.code_root}/scripts:/scripts \
            --bind ${params.code_root} \
            --bind ${weightBind(params.weights_root)}"""
    }

    withLabel: AF2_BACKPROP {
        container = { (System.getenv('BMS_SELECTED_IMAGE_AF2_SIF') ?: "${params.container_dir}/af2.sif") }
        containerOptions = """${gpuPrefix(params.gpu_id)} \
            --env "XLA_PYTHON_CLIENT_PREALLOCATE=false" \
            --bind ${params.code_root}/scripts:/scripts \
            --bind ${params.code_root} \
            --writable-tmpfs \
            --bind ${weightBind(params.alphafold_params, "/af2_params")}"""
    }

    withLabel: OpenMM {
        container = { (System.getenv('BMS_SELECTED_IMAGE_OPENMM_SIF') ?: "${params.container_dir}/openmm.sif") }
        containerOptions = """${gpuPrefix(params.gpu_id)} \
            --env OPENMM_DEFAULT_PLATFORM=CUDA \
            --bind ${params.code_root}/scripts:/scripts \
            --bind ${params.code_root}"""
    }

    withLabel: RFDpoly {
        container = { (System.getenv('BMS_SELECTED_IMAGE_RFDPOLY_V2_SIF') ?: "${params.container_dir}/rfdpoly_v2.sif") }
        // Rebuilt container (v2.0): PyTorch 2.10+cu128, DGL 2.1.0, sm_120 Blackwell
        containerOptions = """${gpuPrefix(params.gpu_id)} \
            --home /tmp \
            --env PYTHONNOUSERSITE=1 \
            --env DGL_HOME=/tmp \
            --env TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD=1 \
            --env MPLCONFIGDIR=/tmp \
            --bind ${params.rfdpoly_dir}:/RFDpoly \
            --bind ${params.code_root}/scripts:/scripts \
            --bind ${params.code_root} \
            --bind ${weightBind("${params.weights_root}/rfdpoly", "/models")}"""
    }

    withLabel: PPIFlow {
        container = { (System.getenv('BMS_SELECTED_IMAGE_PPIFLOW_SIF') ?: "${params.container_dir}/ppiflow.sif") }
        containerOptions = """${gpuPrefix(params.gpu_id)} \
            --bind ${params.code_root}/scripts:/scripts \
            --bind ${params.code_root} \
            ${params.ppiflow_weights_dir ? "--bind " + weightBind(params.ppiflow_weights_dir, "/opt/ppiflow/ckpt") : ""}"""
    }

    withLabel: nampnn {
        container = { (System.getenv('BMS_SELECTED_IMAGE_NAMPNN_SIF') ?: "${params.container_dir}/nampnn.sif") }
        // NA-MPNN for nucleic acid sequence design (Stage 2 of Oligo Designer)
        // Uses CUDA 12.8 for modern NVIDIA GPU compatibility
        containerOptions = """--nv --env CUDA_DEVICE_ORDER=PCI_BUS_ID ${gpuPrefix(params.gpu_id)} \
            --home /tmp \
            --env PYTHONNOUSERSITE=1 \
            --bind ${params.code_root}/scripts:/scripts \
            --bind ${params.code_root} \
            --bind ${weightBind("${params.weights_root}/nampnn/NA-MPNN", "/app/NA-MPNN")}"""
    }

    withLabel: Protenix {
        container = { params.protenix_container_path ?: (System.getenv('BMS_SELECTED_IMAGE_PROTENIX_SIF') ?: "${params.container_dir}/protenix.sif") }
        // The workstation gpu label composes task.ext.containerOptions with the
        // scheduler-owned GPU prefix. Keep Protenix binds in ext so later
        // profile composition cannot discard the immutable runtime contract.
        ext.containerOptions = """--env PYTHONNOUSERSITE=1 --env PIP_NO_USER=1 \
            ${System.getenv('BMS_REMOTE_EXECUTION') == '1' && (params.containsKey('protenix_prepared_msa_dir') && params.protenix_prepared_msa_dir || params.protenix_msa_backend in ['colabfold_api', 'neurosnap_api', 'neurosnap'] || params.protenix_use_msa == false) ? '' : "--bind ${params.msa_local_db}:${params.msa_local_db}"} \
            --bind ${params.msa_cache_dir}:${params.msa_cache_dir} \
            --bind ${params.cm_api_runtime_dir}:${params.cm_api_runtime_dir}:ro \
            --bind ${params.code_root}/scripts:/scripts \
            --bind ${params.code_root} \
            --bind ${weightBind(params.protenix_weights, "/protenix_weights")}"""
    }

    withName: CanonicalProtenixEnsemble {
        // Higher precedence than Protenix/gpu labels: select the verified object,
        // never the mutable source alias, while preserving scheduler GPU options.
        container = { runtime_image }
        containerOptions = {
            def gpuId = params.gpu_id?.toString() ?: System.getenv('NXF_DEFAULT_GPU') ?: '0'
            def objectDir = new File(runtime_image.toString()).parent
            return "${gpuPrefix(gpuId)} ${task.ext.containerOptions ?: ''} --bind ${objectDir}:${objectDir}:ro"
        }
    }

    withLabel: dorado_gpu {
        container = { params.dorado_runtime_sif }
        containerOptions = { """${gpuPrefix(params.gpu_id)} \
            --bind ${params.dorado_runtime_sif}:/runtime/dorado.sif:ro \
            --bind ${params.code_root}:${params.code_root}:ro \
            ${params.pod5_dir ? "--bind ${new File(params.pod5_dir.toString()).canonicalPath}:${new File(params.pod5_dir.toString()).canonicalPath}:ro" : ''} \
            --bind ${weightBind(params.dorado_model_root ?: "${params.weights_root}/dorado/2.1.2", "/weights/dorado/2.1.2")}""" }
    }

    withLabel: dorado_cpu {
        container = { params.dorado_runtime_sif }
        containerOptions = { """--bind ${params.dorado_runtime_sif}:/runtime/dorado.sif:ro \
            --bind ${params.code_root}:${params.code_root}:ro""" }
    }

    withLabel: wf_clone {
        // Host-level nested Nextflow execution for EPI2ME wf-clone-validation.
        // Keep single-fork to avoid concurrent nested session contention.
        maxForks = 1
        cpus = "${params.cpus}"
        memory = "${params.memory_cpu}"
    }

    withLabel: local_cpu {
        // Host-level lightweight processes (bash/awk only, no container needed).
        container = null
        cpus = 2
        memory = "${params.memory_cpu}"
    }

    withLabel: fastq_qc_cpu {
        // FastqPlasmidQC uses the selected Dorado runtime for the pinned
        // samtools/igv-reports scientific method.  The process module must not
        // select a different host/container implementation at task runtime.
        container = { params.dorado_runtime_sif }
        containerOptions = """--bind ${params.code_root}:${params.code_root}:ro"""
        cpus = "${params.cpus}"
        memory = "${params.memory_cpu}"
    }

    withLabel: pooled_assignment_cpu {
        // Pooled assignment runs only in the digest-locked Dorado/NGS SIF.
        container = { params.dorado_runtime_sif }
        cpus = 8
        memory = "${params.memory_cpu}"
    }

    // A maturation child job is the scheduler's GPU allocation unit. Keep the
    // heavy GPU steps inside that child serial so one child cannot fan out
    // multiple concurrent PPIFlow/FAMPNN GPU tasks onto the same assigned GPU.
    withName: RunPartialFlow {
        maxForks = 1
    }

    withName: RunMaturationFAMPNN {
        maxForks = 1
    }

    // ANARCII can spike CPU usage hard on certain matured samples. Keep it
    // bounded so multiple maturation children do not saturate the host and
    // look stalled while numbering backlog drains.
    withName: ANARCII {
        maxForks = 4
    }
}