RelocaTE3

RelocaTE3 identifies transposable element (TE) insertion polymorphisms from short-read resequencing data, at single-base resolution, by comparison to a reference genome. It is a modern, pure-Python reimplementation of RelocaTE2 built on samtools (plus pysam), with no Perl. By default it uses the same aligner pair as RelocaTE2, blat for TE search and bwa aln for genome placement, but the aligner for each stage is selectable: minimap2, bwa, bwa-mem2, bwa aln, bowtie2, or blat (see "Choosing an aligner").

Status: release candidate 0.3.0rc1 (see CHANGELOG.md). The full pipeline (read trimming → genome re-alignment → non-reference insertion calling → reference/shared insertions → genotyping) runs end to end. On the rice Chr3 2 Mb test data, at the shipped defaults, it recovers 196/200 simulated insertions at precision 1.000, the same as RelocaTE2 (notes/2026-08-12-relocate2-chr3-baseline.md); tests/acceptance_test.py gates this. On the larger simulated rice benchmark it matches RelocaTE2's accuracy. Many samples run through the Nextflow pipeline ("Nextflow pipeline" below). Validated for paired-end short reads; see the changelog's known limitations. See plans/PLAN.md for the roadmap (long reads, multiple reference genomes, a pangenome reference, Rust acceleration).

Installation

With pixi (recommended — pins the aligners/samtools/bedtools):

pixi install
pixi run relocaTE3 --help

The default TE aligner is blat, which cannot be installed alongside the plotting stack (its bioconda build hard-pins zlib 1.2.11, and it is linux-64 only). It therefore lives in a separate pixi environment that also carries RelocaTE3 itself:

pixi run -e blat relocaTE3 --help     # linux-64; blat + RelocaTE3 together

Any blat on PATH works just as well — the backend simply shells out to it. BLAT is free for academic, nonprofit and personal use only; commercial users need a license from its authors. Other TE aligners run without it, but detect far fewer insertions (see "Choosing an aligner").

Or with pip, into an environment that already provides the external tools (blat, bwa, samtools, bedtools, and optionally seqtk, which speeds up the BLAT stage; bcftools is needed only for excision mode, characterize -x; the pixi environments and the container include it):

pip install .        # or: pip install -e . for development

Usage

Quick start: one command

run-all executes the whole pipeline for a single sample:

relocaTE3 run-all \
  -1 reads_1.fq.gz -2 reads_2.fq.gz \
  -T RiceTE.fa \
  -g reference.fa \
  -n HEG4 -o HEG4_out \
  --threads 8 \
  --repeatmasker reference.fa.RepeatMasker.out \
  --genotype

That indexes the genome (if needed), finds and trims TE-containing reads, places the flanks, calls non-reference insertions, and — because --repeatmasker and --genotype were given — also emits reference/shared calls and genotypes every site.

run-all dispatches the same handlers as the staged subcommands below, so its results match the staged workflow. Pick whichever fits: run-all for a laptop or a single HPC node, the staged commands when a workflow engine needs to scatter work across samples or chromosomes.

Every default matches RelocaTE2, so the command above reproduces a stock RelocaTE2 run without tuning — see "RelocaTE2 defaults" below for the mapping.

Many samples

run-batch runs the same pipeline across a cohort, one run-all per sample into <outdir>/<sample>:

# a directory of paired FASTQs (RelocaTE2's --fq_dir)
relocaTE3 run-batch --fq-dir reads/ -T RiceTE.fa -g reference.fa \
  -o results --threads 8 --jobs 4 --repeatmasker reference.fa.RepeatMasker.out

# or an explicit sample sheet
relocaTE3 run-batch --samples samples.csv -T RiceTE.fa -g reference.fa -o results

--fq-dir pairs <sample>_R1/_R2 and <sample>_1/_2. The sheet is CSV or TSV with sample_id,r1_fq[,r2_fq], plus optional per-row te_library, reference_genome and repeatmasker columns that override the global flags:

sample_id,r1_fq,r2_fq
HEG4,reads/HEG4_R1.fq.gz,reads/HEG4_R2.fq.gz
A123,reads/A123_R1.fq.gz,reads/A123_R2.fq.gz

--jobs sets how many samples run at once (each still uses --threads). Batches are resumable: a sample that already has a results table is skipped unless --force; with --genotype (or --genotype-bam) it also needs a characterized table that is not older than its results table, so a sample whose genotyping did not finish is re-run. By default the batch stops at the first failing sample; pass --keep-going to run the rest and get a summary at the end (the exit code is non-zero either way if anything failed).

Only when the batch genotypes (--genotype or --genotype-bam) does it then write <outdir>/cohort/, by running relocaTE3 cohort (see "Cohort outputs") on the characterized table of every sample that did not fail, including samples skipped as already complete. Without --genotype the cohort step is skipped and logged ("cohort skipped: run without --genotype"), even if characterized tables from an earlier run exist; an existing <outdir>/cohort/ is then left as it was, with a warning that it is out of date. If the cohort step fails, the batch logs the error, still lists any failed samples, and exits non-zero. Sample names may not be cohort or contain =.

Nextflow pipeline

The repository is also a Nextflow pipeline. It runs many samples in parallel and writes one cohort table and one MultiQC report. Each task runs one relocaTE3 subcommand with run-all's settings, so every sample's files are identical to run-all --genotype with the same settings (tests/nextflow/parity_chr3.sh checks this on the Chr3 test data).

You need Nextflow ≥ 26.04 and Apptainer, Singularity or Docker. Test run, from GitHub:

nextflow run stajichlab/RelocaTE3 -r v0.3.0rc1 -profile test,apptainer --container_tag 0.3.0rc1

For the development version, use -r main --container_tag dev (the dev image is built from main).

Your own samples:

nextflow run stajichlab/RelocaTE3 -r v0.3.0rc1 -profile apptainer \
  --container_tag 0.3.0rc1 \
  --input samples.csv --genome reference.fa \
  --te_library mping.fa --te_name mping \
  --repeatmasker reference.fa.RepeatMasker.out --outdir results

The sample sheet is CSV, one row per lane (rows with the same sample are merged); fastq_2 and genotype_bam are optional:

sample,fastq_1,fastq_2,genotype_bam
HEG4,/data/HEG4_R1.fq.gz,/data/HEG4_R2.fq.gz,
A123,/data/A123_R1.fq.gz,/data/A123_R2.fq.gz,/data/A123.cram

Settings use run-all's names in snake case (--te_aligner, --size, ...) with the same defaults, except that --genotype is on. Outputs: results/<sample>/ (the run-all layout), results/cohort/ (see "Cohort outputs"), results/multiqc/relocate3_report.html and results/pipeline_info/. On UCR HPCC, add -profile hpcc and launch Nextflow from an sbatch head job.

The pipeline user guide covers the sample sheet rules, every parameter, the profiles, an HPCC launch script, outputs, the BLAT scatter, reproducibility and troubleshooting.

Staged subcommands

Note that run performs TE-read identification and flank generation only (map + trim, steps 2-3) — it is not the complete pipeline. A full single-sample analysis chains the stages:

# 1. one-time: index the reference genome (faidx, minimap2, and the
#    --genome-aligner's index, default bwa for bwaaln)
relocaTE3 index-genome -g reference.fa

# 2-3. identify TE-containing reads and emit flanking reads (map + trim)
relocaTE3 run \
  --left reads_1.fq.gz --right reads_2.fq.gz \
  --te-library RiceTE.fa \
  --name HEG4 --outdir HEG4_out \
  --threads 8

# 4. re-align the trimmed flanking reads to the genome
relocaTE3 align-genome \
  -g reference.fa \
  -f HEG4_out/flanking/HEG4.left.flankingReads.fq HEG4_out/flanking/HEG4.right.flankingReads.fq \
  -1 reads_1.fq.gz -2 reads_2.fq.gz \
  -n HEG4 -o HEG4_out --threads 8

# 5. cluster junction/supporting reads into non-reference insertions
relocaTE3 find-insertions \
  -b HEG4_out/HEG4.repeat.bwaaln.sorted.bam \
  --read-repeat HEG4_out/te_containing/HEG4.read_repeat_name.txt \
  --target ALL --name HEG4 --outdir HEG4_out --te-name mping \
  --fullreads-bam HEG4_out/genome_aln/HEG4.fullreads.genome.bam \
  --reference-ins reference.fa.RepeatMasker.out

# 7. genotype the insertions from a reads-to-genome BAM/CRAM
#    (or build one: relocaTE3 align-reads -1 reads_1.fq.gz -2 reads_2.fq.gz
#     -g reference.fa -n HEG4 -o HEG4_out -> HEG4_out/genome_aln/HEG4.reads.genome.bam)
relocaTE3 characterize \
  -s HEG4_out/results/ALL.mping.all_nonref_insert.txt \
  -b reads_to_genome.bam -g reference.fa \
  -o HEG4_out/results

Subcommands

Command	Step	Purpose
run-all	0-7	Whole pipeline for one sample in one command (dispatches the staged handlers below)
run-batch	0-7	Whole pipeline for many samples from a sample sheet or FASTQ directory
index-genome	1	Index the reference genome (samtools faidx, minimap2, and the --genome-aligner's index)
map	2	Align reads to the TE library (produces per-side BAMs)
trim	3	Trim the TE portion from TE-library BAMs, emit flanking reads
run	2-3	Map + trim in one step (TE-read identification + flank generation) — not the full pipeline
te-split	2	BLAT TE search spread over jobs, step 1: cut the reads into chunk FASTAs plus manifest.tsv
te-search-chunk	2	Step 2: BLAT chunk FASTAs against the TE library (one BAM per chunk; any number of jobs)
te-merge-trim	2-3	Step 3: merge every chunk BAM and trim; writes exactly run's files
annotate-ref	0	Annotate where reference TE copies are (minimap2 → existingTE.bed), to filter novel calls
find-reference	0/6	Call reference TEs that are also present in this sample → all_ref_insert.{gff,txt}
align-genome	4	Re-align flanking reads to the genome
find-insertions	5	Cluster junction/supporting reads → non-reference insertions
align-reads	7	Align the original reads to the genome for genotyping (genome_aln/<name>.reads.genome.bam)
characterize	7	Genotype insertions (homozygous/heterozygous/somatic; -x for excision)

Run relocaTE3 <command> --help for the full flag list.

Inputs

• Reads (-l/--left/--r1, -r/--right/--r2): one (single-end) or two (paired-end) FASTQ files (.fq/.fq.gz). Any read-name convention works -- /1-/2 suffixes, modern Illumina (@A00519:... 1:N:0:INDEX, where the name is identical in both files), or SRA/ENA dumps with no mate marker. Which file a read came from determines its mate, so the name does not have to say.
• TE library (-T/--te-library): FASTA of TE/repeat consensus sequences.
• Genome (-g/--genome-fasta): reference genome FASTA.
• Existing-TE annotation (find-insertions --reference-ins, optional): a RepeatMasker .out or BED of reference TE copies, used to skip/flag reference insertions.
• Characterize alignments (characterize -b): sorted, indexed BAM or CRAM of the original reads aligned to the genome. CRAM input also requires -g (the genome FASTA).

Outputs

Under --outdir (example for --name HEG4, and find-insertions --te-name mping --target ALL):

HEG4.left.bam / HEG4.right.bam            reads aligned to the TE library (map)
HEG4.repeat.bwaaln.sorted.bam            flanking reads aligned to the genome (align-genome;
                                          named for the aligner, minimap2 abbreviates to "minimap")
genome_aln/
  HEG4.fullreads.genome.bam              original junction reads aligned with the same genome
                                          aligner for RelocaTE2 false-junction filtering
flanking/
  HEG4.left.flankingReads.fq             trimmed flanking reads (5'/3')
  HEG4.right.flankingReads.fq
te_containing/
  HEG4.read_repeat_name.txt              read → TE-family assignment table
  HEG4.left.ContainingReads.fq / HEG4.right.ContainingReads.fq
te_portions/
  HEG4.five_prime.fa / HEG4.three_prime.fa   TE-matching read portions
results/
  ALL.mping.all_nonref_insert.txt                        non-reference insertions, every call (characterize input)
  ALL.mping.all_nonref_insert.gff                        RelocaTE2's headline filtered set
  ALL.mping.all_nonref_insert.raw.txt / .gff             every call
  ALL.mping.all_nonref_insert.all.txt / .gff             minus one-sided calls at reference TE boundaries
  ALL.mping.all_nonref_insert.high_conf.txt / .gff       two-sided junction calls only
  ALL.mping.all_nonref_supporting.txt / .gff             sites supported by mate pairs alone (no junction read)
  ALL.mping.all_nonref_insert.characTErized.gff / .txt   genotyped insertions (characterize)
  HEG4.all_ref_insert.gff / .txt                         reference/shared insertions (find-reference)
existingTE.bed                                           reference TE copies (find-reference/annotate-ref)

Reproducibility. The same inputs and the same version produce the same result tables. Reads matching several TE families equally well, and tied cluster-level family votes, are resolved by a fixed rank rather than by whichever alignment the aligner emitted first, so results do not shift between runs. Note that intermediate BAMs are written by multi-threaded aligners and may still differ byte-for-byte between runs; the tables under results/ are the reproducible artifacts.

The characterized GFF carries the RelocaTE2 attribute set: TSD, Name (the single primary TE family), Note, and Left/Right_junction_reads and Left/Right_support_reads. RelocaTE3 appends junction-read family evidence as TE_family_support, TE_family_confidence, and TE_family_status. It reports the weaker, indirect mate evidence separately as TE_supporting_family_support, TE_supporting_family_confidence, and TE_supporting_family_status, with TE_family_concordance describing whether the two evidence classes agree. The single primary family remains junction-driven rather than joining disagreeing assignments into a compound family name.

Cohort outputs

relocaTE3 cohort -i <table> [<table> ...] -o <dir> combines per-sample *.all_nonref_insert.characTErized.txt tables. Give each as a path (the sample name is read from its strain column) or as NAME=PATH (needed for a sample with no calls, i.e. a header-only table). Input order does not matter.

cohort.characTErized.txt    one header, then every per-sample row unchanged, by sample then original order
cohort.genotype_matrix.tsv  sites x samples: chromosome start end strand TE <sample...>
cohort.summary_mqc.tsv      MultiQC custom-content table: calls per sample and per genotype class

The genotype matrix is a plain TSV with no comment lines:

• One row per exact site (chromosome, start, end, strand, TE), taken from chromosome.pos (Chr1:1132975..1132977), strand and TE.
• A cell is the sample's status there, or . when the sample has no call.
• Nearby sites, or the same position on the other strand, are not merged; that is left to a future VCF output.
• Rows sort by chromosome in natural order (Chr1 < Chr2 < Chr10; names without digits sort as text), then start, end, strand and TE.
• The TSD is not part of the site key: two samples with different TSDs at the same chromosome/start/end/strand/TE share a row. Each sample's TSD stays in cohort.characTErized.txt.
• One sample with two rows at the same site key is an error.

An argument that is an existing file is always a plain path, so file names may contain =; otherwise it is split at the first = into NAME=PATH. The three files are written together: a failed run leaves the previous outputs unchanged.

In the summary, the genotype class is the status before the first / (homozygous, heterozygous, somatic_insertion, other), and excision counts statuses that mention excision. So homozygous/excision_no_footprint counts once as homozygous and once as excision.

Migrating from RelocaTE2

RelocaTE2	RelocaTE3
--fq_dir (directory)	run-batch --fq-dir, or --left/--right for one sample
--te_fasta	-T/--te-library
--genome_fasta	-g/--genome-fasta
--reference_ins	find-insertions --reference-ins
--mismatch / --mismatch_junction	--mismatch (one knob covers both; default 2, same as RelocaTE2)
--aligner blat/bwa/bowtie2	run --te-aligner and align-genome --genome-aligner — the defaults (blat, bwa aln) already match RelocaTE2
characterizer.pl (Perl)	characterize
--mate_1_id / --mate_2_id / --unpaired_id	not needed — the mate is taken from which file the read came from
whole pipeline in one command	run-all
all_ref_insert.gff/.txt	find-reference (or run-all --repeatmasker)

run-all is the closest equivalent to a single RelocaTE2 invocation. The staged subcommands remain available for workflow engines.

Output tiers

RelocaTE2 does not publish one call set, it publishes several (clean_false_positive.py), and its headline number comes from the filtered file. RelocaTE3 emits the same tiers so the two can be compared like for like:

file	contents
.txt	every call — the table, left unfiltered
.raw.txt / .raw.gff	every call
.all.txt / .all.gff	minus one-sided calls sitting within --distance (3 bp) of a reference TE boundary
.gff	headline — minus singleton, insufficient_data and supporting_reads calls
.high_conf.txt / .high_conf.gff	additionally minus calls with exactly one junction read on one side and none on the other

Each tier is a subset of the one above it. Note that the filtering applies to the GFF, not the table: RelocaTE2 cleans only its GFF and genotypes the unfiltered table, so characterize sees every call in both tools.

On the rice Chr3 2 Mb fixture the tiers score:

tier	calls	recall	precision	F1
.raw / .all / .txt	199	193/200 (0.965)	0.970	0.967
headline .gff	199	193/200 (0.965)	0.970	0.967
.high_conf	193	191/200 (0.955)	0.990	0.972

RelocaTE2 on the same inputs scores 196 calls, 196/200, precision 1.000 (F1 0.990) — see notes/2026-08-12-relocate2-chr3-baseline.md.

.high_conf is the set to use when precision matters more than sensitivity. Note it is not "two-sided calls only" — RelocaTE2 removes only the single-read one-sided case, and so does this. --require-both-junctions (on by default) is stricter still. During calling, it drops every one-sided call except RelocaTE2's supporting_junction class.

The .raw → .all step is RelocaTE2's reference-TE boundary filter: a call is dropped only if it is one-sided and one of its endpoints lies within --distance bp of a reference TE's start or end, on the reasoning that reads from an intact reference copy's edge mimic a novel junction. A two-sided call at a boundary is kept. It needs --reference-ins (or run-all --repeatmasker); without one, .all equals .raw.

On the Chr3 2 Mb fixture this filter removes nothing — of 37 one-sided calls, none fall within even 50 bp of a reference TE boundary — so it is not what separates RelocaTE3's precision from RelocaTE2's there. .high_conf is.

Mate-pair-only insertions

When a cluster has supporting mates but no junction read mapped, RelocaTE2 still calls a site and writes it to all_nonref_supporting.{txt,gff} — kept out of all_nonref_insert because, with T:0 R:0 L:0, it is much weaker evidence. RelocaTE3 does the same. Three cases, following RelocaTE2:

• both strands — the site lies in the gap between the innermost mates
• forward only — spans one library insert onwards from the rightmost mate
• reverse only — the mirror image

-s/--size (default 500) is the library insert size used for the one-sided spans; RelocaTE2 widens it by 20% for library spread.

Treat these as leads, not calls. On the Chr3 2 Mb fixture the path produces 6 sites and none of them correspond to a true insertion — each rests on a single read per strand. They are reported because RelocaTE2 reports them, and they are filed separately for the same reason RelocaTE2 files them separately.

RelocaTE2 defaults

RelocaTE3 ships RelocaTE2's defaults, so an untuned run reproduces RelocaTE2's behaviour. Values below are cited from RelocaTE2's source.

Parameter	RelocaTE2	RelocaTE3	Source
TE-search aligner	blat	--te-aligner blat	relocaTE2.py:204
Genome placement	bwa aln	--genome-aligner bwaaln	relocaTE_align.py
Mismatches (reads vs TE)	--mismatch 2	--mismatch 2	relocaTE2.py:207
Mismatches (junction reads)	--mismatch_junction 2	same --mismatch	relocaTE2.py:208
Match-length cutoff	--len_cut_match 10	--min-match 10	relocaTE2.py:205
Trimmed-length cutoff	--len_cut_trim 10	--min-trimmed 10	relocaTE2.py:206
TSD	UNK (hardcoded)	--tsd UNK (the only value accepted)	relocaTE2.py:346
Junction reads required	both sides, or the supporting_junction exception	--require-both-junctions (on)	characterizer.pl:91
Insert size	--size 500	-s/--size 500	relocaTE2.py:198
MAPQ admission	none (MAPQ < 29 marks a read low quality)	--min-mapq 0	relocaTE_insertionFinder.py:1523
Threads	--cpu 1	--threads 1	relocaTE2.py:199

Two RelocaTE2 options have no RelocaTE3 flag because they are no longer needed:

• --mate_1_id/--mate_2_id/--unpaired_id: the mate comes from which file a read is in.
• --split: RelocaTE3 always runs BLAT and trims its hits one chunk at a time.

-s/--size (default 500) is the library insert size, as in RelocaTE2.

• RelocaTE2 uses it only to place insertions supported by mate pairs alone (relocaTE_insertionFinder.py:446,455); so does RelocaTE3. See Mate-pair-only insertions.
• It does not affect junction-read calls.
• Set it to your library's insert size. The real-rice validation uses 250, matching RelocaTE2's settings for those samples.

--min-mapq (default 0) admits reads at every MAPQ, as RelocaTE2 does. RelocaTE2 has no MAPQ admission gate. It marks reads below MAPQ 29 as low quality (relocaTE_insertionFinder.py:1523) and drops only calls that rest entirely on such reads (:226-241); RelocaTE3 ports both. Raising --min-mapq adds a filter RelocaTE2 does not have.

One-sided calls and --require-both-junctions

Default: on. This is RelocaTE2's own rule, not a RelocaTE3 policy. Its final call set needs junction reads on both sides, with one narrow exception (characterizer.pl:91):

if ( ($left_count >= 1 and $right_count >= 1) or $TSD eq 'supporting_junction' ) {

RelocaTE2's intermediate table admits one-sided rows (relocaTE_insertionFinder.py:365, l_count >= 1 or r_count >= 1).

• Every one-sided row gets a sentinel in the TSD column instead of a real TSD: supporting_junction, singleton or insufficient_data (:373-392).
• The characterize gate above and clean_false_positive.py filter them out again.
• supporting_junction covers one junction side plus unpaired supporting reads on the other side.

RelocaTE3 applies the same gate in two places:

• characterize implements characterizer.pl:91 exactly. Whatever the flag says, characterized output keeps only two-sided calls and supporting_junction calls.
• --require-both-junctions drops the other one-sided candidates earlier, during calling. It keeps supporting_junction.

--no-require-both-junctions keeps every one-sided candidate in all_nonref_insert.txt and the .raw tier. Use it for single-element screens where recall matters more than precision and calls will be validated. On a multi-family TE library with the default bwa aln genome aligner, those extra rows are mostly false.

Measurements and history: docs/require-both-junctions.md.

Choosing an aligner

The aligner is selectable per stage:

• TE-library search (map / run): --te-aligner {minimap2,bwa,bwamem2,bwaaln,bowtie2,blat} (default blat, matching RelocaTE2). --aligner is a deprecated alias.
• Genome re-alignment (align-genome): --genome-aligner {minimap2,bwa,bwamem2,bwaaln,bowtie2} (default bwaaln, matching RelocaTE2). blat is TE-search only and is rejected here.

Measured on the riceTElib benchmark (14-family library, 3 replicates per coverage, 1,500 simulated insertions per coverage). Detected insertions and precision, from relocate-benchmark profile checkpoint-213a0df (2026-10-18):

TE search / genome	detected 5x	15x	30x	precision 30x
blat / bwaaln (default)	550	886	1077	0.988
blat / bwa (MEM)	370	553	624	0.923
bowtie2 / bwa (MEM)	327	485	546	0.958
bwa / bwa (MEM)	272	434	497	0.973
minimap2 / minimap2	261	406	467	0.981
RelocaTE2	548	878	1068	0.993

Only the default pair matches RelocaTE2; every other combination tested finds roughly half as many insertions. The genome aligner matters as much as the TE aligner (blat with bwa MEM loses ~40%). Non-BLAT TE aligners have not been benchmarked with bwaaln genome placement, so there is no measured replacement for BLAT yet.

relocaTE3 run --left r1.fq --right r2.fq -T RiceTE.fa -n HEG4 -o HEG4_out --te-aligner bwa
relocaTE3 align-genome -g reference.fa -f HEG4_out/flanking/*.flankingReads.fq -n HEG4 -o HEG4_out --genome-aligner bwa

minimap2, bwa, bwa-mem2, and bowtie2 are pinned in the default pixi environment; blat is in the separate blat environment (see Installation). Non-minimap2 genome BAMs are named {name}.repeat.{aligner}.sorted.bam — with the default bwaaln that is {name}.repeat.bwaaln.sorted.bam.

Development

pixi run test          # run the test suite
pixi run -e blat pytest tests/acceptance_test.py   # acceptance gates (needs the blat env)

UCR HPCC User Development

The following commands run RelocaTE3 on real rice data and compares results to legacy RelocaTE2 results. See validation directory for more information.

pixi run validate-rice --container-tag sha-<short>          # 10 samples through the Nextflow pipeline
pixi run validate-rice --mode run-all --local --force B_10  # smoke test (one sample, run-all, forced re-run)
pixi run validate-rice --mode run-all                       # 10-sample run-all SLURM array