Remove redundant regressor_set, replace fake tests with real ds000114 integration

- Drop regressor_set param from longitudinal_process; iterate
  regressor_files.keys() instead.  The resolve layer already filters to
  the requested strategies, so the dict keys ARE the set.  Eliminates
  the caller sync burden.

- Delete tests/full_pipeline/longitudinal/ -- the conftest hacked the
  cross-sectional anat brain as a "longitudinal template", which
  exercises the code path but not the actual transform chain.

- Rewrite tests/integration/longitudinal/test_regression_reuse.py as a
  proper end-to-end CLI test: rbc functional -> rbc longitudinal
  functional on ds000114 sub-01 ses-test via subprocess.  Asserts
  expected BIDS tree, non-degenerate variance, and binary mask.

- Add ds000114_func_derivatives and longitudinal_func_output fixtures
  to the integration conftest so the full cross-sectional -> longitudinal
  chain runs on real multi-session data with docker.

Author: nx10

src/rbc/orchestration/longitudinal/functional.py

@@ -60,10 +60,7 @@ def process_func(
         ses=pipe_ctx.ses,  # type: ignore[arg-type]
         regressors=regressors,
     )
-    func_outputs = functional_longitudinal(
-        **resolved,  # type: ignore[arg-type]
-        regressor_set=regressors,
-    )
+    func_outputs = functional_longitudinal(**resolved)  # type: ignore[arg-type]
     fex = func_q.derive(space="longitudinal")
     export_longitudinal_func(fex, func_outputs, regressors=regressors)
 

src/rbc/workflows/longitudinal/functional.py

@@ -19,9 +19,7 @@
 )
 
 if TYPE_CHECKING:
-    from collections.abc import Sequence
     from pathlib import Path
-    from typing import Literal
 
 _logger = logging.getLogger("rbc")
 
@@ -57,7 +55,6 @@ def longitudinal_process(
     bold: Path,
     bold_mask: Path,
     regressor_files: dict[str, Path],
-    regressor_set: Sequence[Literal["36-parameter", "aCompCor"]] = ("36-parameter",),
 ) -> FunctionalLongOutputs:
     """Transform preprocessed functional outputs to longitudinal template space.
 
@@ -66,6 +63,10 @@ def longitudinal_process(
     No regressor recomputation is performed: the same regressor matrix is
     applied in the new target space.
 
+    Regression is applied for every strategy present in *regressor_files*.
+    The caller controls which strategies to run by passing only the desired
+    keys (the resolve layer filters to the requested ``--regressor`` set).
+
     Args:
         template: Longitudinal template image.
         anat_to_template_xfm: T1w-to-longitudinal-template composite warp.
@@ -74,9 +75,8 @@ def longitudinal_process(
         bold: Preprocessed bold image.
         bold_mask: Bold brain mask.
         regressor_files: Raw (unfiltered) regressor ``.1D`` files from
-            the cross-sectional run, keyed by strategy name.
-        regressor_set: Which regressor strategies to apply.  Must be a
-            subset of the keys in *regressor_files*.
+            the cross-sectional run, keyed by strategy name.  Regression
+            is applied for every key in this dict.
 
     Returns:
         :class:`FunctionalLongOutputs` with all inputs transformed to
@@ -98,8 +98,7 @@ def longitudinal_process(
 
     regressed: dict[str, Path] = {}
     cleaned: dict[str, Path] = {}
-    for reg in regressor_set:
-        reg_file = regressor_files[reg]
+    for reg, reg_file in regressor_files.items():
         _logger.info("Longitudinal %s nuisance regression (no bandpass)", reg)
         regressed[reg] = apply_regression(
             bold_file=long_bold,

tests/full_pipeline/longitudinal/__init__.py

@@ -25,6 +25,7 @@
 )
 
 _SUB = "01"
+_TASK = "fingerfootlips"
 
 
 def _rbc_exe() -> str:
@@ -143,3 +144,70 @@ def longitudinal_template_output(
         ],
     )
     return ds000114_anat_derivatives
+
+
+@pytest.fixture(scope="session")
+def ds000114_func_derivatives(
+    ds000114_dataset: Path,
+    longitudinal_template_output: Path,
+    _runner: str,
+) -> Path:
+    """Run ``rbc functional`` on ds000114 sub-01 ses-test.
+
+    Produces cross-sectional functional derivatives (including raw
+    regressor ``.1D`` files) that the longitudinal functional stage
+    consumes.  Writes into the same derivatives tree as the template
+    stage so all outputs are visible to downstream fixtures.
+
+    Only ses-test is processed (one session is sufficient to exercise
+    the longitudinal functional chain).
+    """
+    _run_rbc(
+        [
+            "functional",
+            str(ds000114_dataset),
+            str(longitudinal_template_output),
+            "-o",
+            str(longitudinal_template_output),
+            "--runner",
+            _runner,
+            "--participant-label",
+            _SUB,
+            "--session-label",
+            "test",
+            "--task",
+            _TASK,
+        ],
+    )
+    return longitudinal_template_output
+
+
+@pytest.fixture(scope="session")
+def longitudinal_func_output(
+    ds000114_func_derivatives: Path,
+    _runner: str,
+) -> Path:
+    """Run ``rbc longitudinal functional`` on ds000114 sub-01 ses-test.
+
+    Produces longitudinal functional derivatives (warped BOLD,
+    per-regressor regressed/cleaned BOLD) by consuming the
+    cross-sectional functional outputs and the longitudinal template.
+    """
+    _run_rbc(
+        [
+            "longitudinal",
+            "functional",
+            str(ds000114_func_derivatives),
+            "-o",
+            str(ds000114_func_derivatives),
+            "--runner",
+            _runner,
+            "--participant-label",
+            _SUB,
+            "--session-label",
+            "test",
+            "--task",
+            _TASK,
+        ],
+    )
+    return ds000114_func_derivatives